Example #1
0
        AsyncSubject <byte[]> WriteBlobToDisk(string key, byte[] byteData, bool synchronous)
        {
            var ret       = new AsyncSubject <byte[]>();
            var scheduler = synchronous ? System.Reactive.Concurrency.Scheduler.Immediate : Scheduler;

            var path = GetPathForKey(key);

            // NB: The fact that our writing AsyncSubject waits until the
            // write actually completes means that an Insert immediately
            // followed by a Get will take longer to process - however,
            // this also means that failed writes will disappear from the
            // cache, which is A Good Thing.

            Func <IObservable <byte[]> > writeResult = () => BeforeWriteToDiskFilter(byteData, scheduler)
                                                       .Select(x => new MemoryStream(x))
                                                       .Zip(Observable.Defer(() =>
                                                                             filesystem.OpenFileForWriteAsync(path, scheduler))
                                                            .Retry(1),
                                                            (from, to) => new { from, to })
                                                       .SelectMany(x => x.from.CopyToAsync(x.to, scheduler))
                                                       .Select(_ => byteData)
                                                       .Do(_ =>
            {
                if (!synchronous && key != BlobCacheIndexKey)
                {
                    actionTaken.OnNext(Unit.Default);
                }
            }, ex => LogHost.Default.WarnException("Failed to write out file: " + path, ex));

            writeResult().Multicast(ret).Connect();
            return(ret);
        }