public void CanStore()
        {
            var store = new InMemoryCacheStore();

            store.AddOrUpdateAsync(new CacheKey(DummyUrl, new string[0]),
                                   ResponseHelper.GetOkMessage()).Wait();

            var r = store.GetValueAsync(new CacheKey(DummyUrl, new string[0])).Result;

            Assert.NotNull(r);
        }
Example #2
0
        public VirtualDbCacheableReader(DataSourceCacheEntry entry, SelectStatement select)
            : base(select)
        {
            _entry = entry;

            _spoolerTask = new Task(() =>
            {
                var cacheReader = new VirtualDbReader(select);
                try
                {
                    _entry.State = ECacheState.Busy;

                    var store = new InMemoryCacheStore
                    {
                        Fields = cacheReader.FieldNames()
                    };


                    while (cacheReader.Read())
                    {
                        var row = new object[store.Fields.Count];
                        for (var j = 0; j < row.Length; j++)
                        {
                            row[j] = cacheReader[j];
                        }
                        store.Data.Add(row);
                    }

                    _entry.Store = store;

                    //write to file
                    using (FileStream fs = new FileStream(entry.Key + ".cache", FileMode.Create)){
                        // var formatter = new BinaryFormatter();
                        // formatter.Serialize(fs, store);
                    }

                    _entry.State = ECacheState.Ready;
                }
                catch (Exception exception)
                {
                    _entry.State = ECacheState.Invalid;
                    log.Error(exception);
                    throw;
                }
                finally
                {
                    cacheReader.Close();
                }
            });

            _spoolerTask.Start();
        }
Example #3
0
        public async Task RespectsExpiry()
        {
            _store = new InMemoryCacheStore(TimeSpan.Zero);
            var _cachingHandler = new CachingHandler(_store)
            {
                InnerHandler = _dummyHandler
            };

            _httpClient = new HttpClient(_cachingHandler);

            _dummyHandler.Response = ResponseHelper.GetOkMessage(1, true);
            var response = await _httpClient.GetAsync(DummyUrl);

            Thread.Sleep(100);
            _dummyHandler.Response = ResponseHelper.GetNotModifiedMessage(1);

            // first caching
            response = await _httpClient.GetAsync(DummyUrl);

            Console.WriteLine(response.Headers.GetCacheCowHeader().ToString());
            Assert.NotNull(response.Headers.GetCacheCowHeader().RetrievedFromCache);
            Assert.True(response.Headers.GetCacheCowHeader().RetrievedFromCache.Value);

            // stale go getter
            Thread.Sleep(1500);
            _dummyHandler.Response = ResponseHelper.GetOkMessage(1, true);
            response = await _httpClient.GetAsync(DummyUrl);

            Console.WriteLine(response.Headers.GetCacheCowHeader().ToString());
            Assert.NotNull(response.Headers.GetCacheCowHeader().DidNotExist);
            Assert.True(response.Headers.GetCacheCowHeader().DidNotExist.Value);

            // immediate, get it from cache - short circuit
            response = await _httpClient.GetAsync(DummyUrl);

            Console.WriteLine(response.Headers.GetCacheCowHeader().ToString());
            Assert.Null(response.Headers.GetCacheCowHeader().WasStale);
        }