public static void Register(HttpConfiguration config) { // Web API configuration and services config.Filters.Add(new CorsOptions()); config.BindParameter(typeof(Paginate), new PaginateModelBinder()); config.BindParameter(typeof(FileUpload), new FileUploadModelBinder()); var cachecow = new CachingHandler(config); config.MessageHandlers.Add(cachecow); FormatterConfig.RegisterFormatters(config); // Web API routes config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); }
public static void Register(HttpConfiguration config) { // Web API 配置和服务 // Web API 路由 config.MapHttpAttributeRoutes(); //跨域处理 config.EnableCors(new EnableCorsAttribute("*", "*", "*")); //自定义过滤器 config.Filters.Add(new MyExceptionFilterAttribute()); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{action}/{id}", defaults: new { id = RouteParameter.Optional }); //配置接口缓存 var cachingHandler = new CachingHandler(new HttpConfiguration(), "Accept", "Accept-Encoding"); cachingHandler.CacheControlHeaderProvider = new AttributeBasedCacheControlPolicy( new CacheControlHeaderValue() { NoCache = true, Private = true, NoStore = true }).GetCacheControl; cachingHandler.CacheRefreshPolicyProvider = new AttributeBasedCacheRefreshPolicy(TimeSpan.FromSeconds(15)).GetCacheRefreshPolicy; config.MessageHandlers.Add(cachingHandler); }
public static void Register(HttpConfiguration config) { config.Routes.MapHttpRoute( name: "PricingApi", routeTemplate: "api/{controller}/{id}", defaults: new { controller = "Test", id = RouteParameter.Optional }); config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always; config.Formatters.XmlFormatter.UseXmlSerializer = true; var cachingHandler = new CachingHandler(config, new InMemoryEntityTagStore(), "Accept", "Accept-Encoding"); cachingHandler.CacheControlHeaderProvider = new AttributeBasedCacheControlPolicy(new CacheControlHeaderValue() { NoCache = true, Private = true, NoStore = true }).GetCacheControl; // turn caching off unless an attribute is used cachingHandler.CacheRefreshPolicyProvider = new AttributeBasedCacheRefreshPolicy(TimeSpan.FromMinutes(15)).GetCacheRefreshPolicy; config.MessageHandlers.Add(cachingHandler); }
public HttpClient CreateHttpClient() { var handler = new CachingHandler(new FlatFileCacheStore(cacheRoot)) { InnerHandler = new HttpClientHandler() }; var baseValidator = handler.ResponseValidator; handler.ResponseValidator = m => { var result = baseValidator(m); if (result == ResponseValidationResult.NotExist || result == ResponseValidationResult.OK) { return(result); } var sinceName = "X-Forced-Cache-Since"; var sinceString = m.Headers.Contains(sinceName) ? m.Headers.GetValues(sinceName).SingleOrDefault() : null; if (sinceString == null) { m.Headers.Add(sinceName, DateTimeOffset.Now.ToString()); return(ResponseValidationResult.OK); } var since = DateTimeOffset.Parse(sinceString); return((DateTimeOffset.Now - since).TotalHours <= 1 ? ResponseValidationResult.OK : ResponseValidationResult.Stale); }; return(new HttpClient(handler)); }
public void GivenIHaveAnAPIRunningCacheCowServerAndUsingStorage(string storage) { IEntityTagStore store; var configuration = new HttpConfiguration(); switch (storage) { case "InMemory": store = new InMemoryEntityTagStore(); break; default: throw new ArgumentException("Store unknown: " + storage); } configuration.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); var inMemoryServer = new InMemoryServer(configuration); var cachingHandler = new CachingHandler(configuration, store, "Accept") { InnerHandler = inMemoryServer }; var client = new HttpClient(cachingHandler); ScenarioContext.Current[Keys.Client] = client; ScenarioContext.Current[Keys.CacheHandler] = cachingHandler; }
public static void TestManualInvalidation(string method) { // setup var mocks = new MockRepository(); string routePattern1 = "http://myserver/api/stuffs/*"; string routePattern2 = "http://myserver/api/more/*"; var entityTagStore = mocks.StrictMock <IEntityTagStore>(); var linkedUrls = new[] { "url1", "url2" }; var cachingHandler = new CachingHandler(new HttpConfiguration(), entityTagStore) { LinkedRoutePatternProvider = (req) => linkedUrls, }; entityTagStore.Expect(x => x.RemoveResource("/api/stuff/")).Return(1); entityTagStore.Expect(x => x.RemoveResource("/api/more/")).Return(1); mocks.ReplayAll(); // run cachingHandler.InvalidateResource(new HttpRequestMessage(new HttpMethod(method), new Uri(TestUrl))); cachingHandler.InvalidateResource(new HttpRequestMessage(new HttpMethod(method), new Uri(TestUrl2))); // verify mocks.VerifyAll(); }
//... // Create a new caching handler and register it with the container. public void RegisterCache(HttpConfiguration config, IUnityContainer container) { var cachingHandler = new CachingHandler(config); // ... container.RegisterInstance<ICachingHandler>(cachingHandler); }
public static void TestCacheInvalidationForPost(string method) { // setup var locationUrl = new Uri("http://api/SomeLocationUrl"); var mocks = new MockRepository(); var request = new HttpRequestMessage(new HttpMethod(method), TestUrl); string routePattern = "http://myserver/api/stuffs/*"; var entityTagStore = mocks.StrictMock <IEntityTagStore>(); var linkedUrls = new[] { "url1", "url2" }; var cachingHandler = new CachingHandler(new HttpConfiguration(), entityTagStore) { LinkedRoutePatternProvider = (req) => linkedUrls }; var entityTagKey = new CacheKey(TestUrl, new string[0], routePattern); var response = new HttpResponseMessage(); response.Headers.Location = locationUrl; var invalidateCacheForPost = cachingHandler.PostInvalidationRule(entityTagKey, request, response); if (method == "POST") { entityTagStore.Expect(x => x.RemoveAllByRoutePattern(locationUrl.ToString())).Return(1); } mocks.ReplayAll(); // run invalidateCacheForPost(); // verify mocks.VerifyAll(); }
public static void TestCacheInvalidationForPost(string method) { const string relatedUrl = "http://api/SomeLocationUrl/"; // setup var locationUrl = new Uri(relatedUrl); var mocks = new MockRepository(); var request = new HttpRequestMessage(new HttpMethod(method), TestUrl); string routePattern = "http://myserver/api/stuffs/*"; var entityTagStore = mocks.StrictMock <IEntityTagStore>(); var cachingHandler = new CachingHandler("test", "1.0.0", new HttpConfiguration(), entityTagStore); var entityTagKey = new CacheKey(TestUrl, new string[0], routePattern, "test", "1.0.0"); var response = new HttpResponseMessage(); response.Headers.Location = locationUrl; var invalidateCacheForPost = cachingHandler.PostInvalidationRule(entityTagKey, request, response); if (method == "POST") { entityTagStore.Expect(x => x.RemoveAllByRoutePattern("/SomeLocationUrl/")).Return(1); entityTagStore.Expect(x => x.RemoveResource("/SomeLocationUrl/")).Return(1); } mocks.ReplayAll(); // run invalidateCacheForPost(); // verify mocks.VerifyAll(); }
public void Test_Not_Cacheable_StatusCode(HttpStatusCode code) { var cachingHandler = new CachingHandler("test", "1.0.0"); var response = new HttpResponseMessage(code); Assert.AreEqual(cachingHandler.ResponseValidator(response), ResponseValidationResult.NotCacheable); }
public async Task Issue238_It_cache_even_if_compression_is_on() { var compressionHandler = new HttpClientHandler(); if (compressionHandler.SupportsAutomaticDecompression) { compressionHandler.AutomaticDecompression = DecompressionMethods.GZip; } var pipeline = new CachingHandler(new DictionaryBasedCache()) { InnerHandler = compressionHandler, DefaultVaryHeaders = new [] { "Accept", "Accept-Encoding" } }; var client = new HttpClient(pipeline); var request1 = new HttpRequestMessage(HttpMethod.Get, CacheablePublicResource); var request2 = new HttpRequestMessage(HttpMethod.Get, CacheablePublicResource); var response = await client.SendAsync(request1); var responseFromCache = await client.SendAsync(request2); Assert.NotNull(responseFromCache.Headers.GetCacheCowHeader()); Assert.True(responseFromCache.Headers.GetCacheCowHeader().RetrievedFromCache); }
public static void TestCacheInvalidation(string method) { // setup var mocks = new MockRepository(); var request = new HttpRequestMessage(new HttpMethod(method), TestUrl); string routePattern = "http://myserver/api/stuffs/*"; var entityTagStore = mocks.StrictMock <IEntityTagStore>(); var linkedUrls = new [] { "url1", "url2" }; var cachingHandler = new CachingHandler(new HttpConfiguration(), entityTagStore) { LinkedRoutePatternProvider = (req) => linkedUrls }; var entityTagKey = new CacheKey(TestUrl, new string[0], routePattern); var response = new HttpResponseMessage(); var invalidateCache = cachingHandler.InvalidateCache(entityTagKey, request, response); entityTagStore.Expect(x => x.RemoveResource("/api/stuff/")).Return(1); mocks.ReplayAll(); // run invalidateCache(); // verify mocks.VerifyAll(); }
private void ConfigureCaching(HttpConfiguration configuration) { var cachingHandler = new CachingHandler(configuration); configuration.MessageHandlers.Add(cachingHandler); s_container.RegisterInstance <ICachingHandler>(cachingHandler); }
private static void ConfigApi(HttpConfiguration config) { // Web API configuration and services // Web API routes config.MapHttpAttributeRoutes(); var cors = new EnableCorsAttribute("*", "*", "*"); config.EnableCors(cors); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); config.Formatters.JsonFormatter.SupportedMediaTypes.Clear(); config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/vnd.noark5-v4+json")); config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new DefaultContractResolver(); config.Formatters.XmlFormatter.SupportedMediaTypes.Clear(); config.Formatters.XmlFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/vnd.noark5-v4+xml")); config.Formatters.XmlFormatter.UseXmlSerializer = true; config.Formatters.XmlFormatter.MaxDepth = 5; //config.Formatters.XmlFormatter.WriterSettings.ConformanceLevel= System.Xml.ConformanceLevel. config.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore; config.Formatters.JsonFormatter.SerializerSettings = new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore }; var cachecow = new CachingHandler(config); GlobalConfiguration.Configuration.MessageHandlers.Add(cachecow); }
public void Test_Not_Cacheable_No_CacheControl() { var cachingHandler = new CachingHandler(); var response = new HttpResponseMessage(HttpStatusCode.OK); Assert.AreEqual(cachingHandler.ResponseValidator(response), ResponseValidationResult.NotCacheable); }
public static void Register(HttpConfiguration config) { config.EnableSystemDiagnosticsTracing(); config.Services.Replace(typeof(ITraceWriter), new SlabTraceWriter()); config.Services.Add(typeof(IExceptionLogger), new SlabLoggingExceptionLogger()); config.MapHttpAttributeRoutes(); config.DependencyResolver = new UnityDependencyResolver(UnityConfig.GetConfiguredContainer()); RegisterFilterProviders(config); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); var cacheCowCacheHandler = new CachingHandler(config); config.MessageHandlers.Add(cacheCowCacheHandler); // Required if you want to use application/xml //var odataFormatters = ODataMediaTypeFormatters.Create(); //config.Formatters.InsertRange(0, odataFormatters); ODataBatchHandler odataBatchHandler = new ODataBatchHandlerSingleTransaction(GlobalConfiguration.DefaultServer); odataBatchHandler.MessageQuotas.MaxOperationsPerChangeset = 10; odataBatchHandler.MessageQuotas.MaxPartsPerBatch = 10; config.MapODataServiceRoute("odata", "odata", model: GetModel(), batchHandler: odataBatchHandler); }
public void Configuration(IAppBuilder app) { var cachingHandler = new CachingHandler(new HttpConfiguration(), new InMemoryEntityTagStore(), "Accept"); cachingHandler.CacheControlHeaderProvider = (message, configuration) => new CacheControlHeaderValue() { //NoCache = true, //MaxAge = TimeSpan.FromSeconds(100) }; var config = new HttpConfiguration(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); app.UseWebApi(config, (q, s) => true); //app.UseHttpMessageHandler(new MyClass()); //app.UseHttpMessageHandler(new MyClass2()); //app.UseNancy(); app.UseHttpMessageHandler(new OwinHandlerBridge(cachingHandler), (q, s) => false); }
private static void ConfigureCachingETagSupport(HttpConfiguration config) { var connectionString = ConfigurationManager.ConnectionStrings["DefaultConnection"]?.ConnectionString; var sqlTagStore = new SqlServerEntityTagStore(connectionString); var cachingHandler = new CachingHandler(config, sqlTagStore); config.MessageHandlers.Add(cachingHandler); }
public void DoesNotDisposeCacheStoreIfPassedToIt() { var mock = new Moq.Mock <ICacheStore>(MockBehavior.Strict); var handler = new CachingHandler(mock.Object); handler.Dispose(); mock.Verify(); }
public void DoesNotDisposeVaryHeaderStoreIfPassedToIt() { var mockcs = new Moq.Mock <ICacheStore>(); var mockvh = new Moq.Mock <IVaryHeaderStore>(MockBehavior.Strict); var handler = new CachingHandler(mockcs.Object, mockvh.Object); handler.Dispose(); mockvh.Verify(); }
public FauxServerTests() { var _cachingHandler = new CachingHandler(_store) { InnerHandler = _dummyHandler }; _httpClient = new HttpClient(_cachingHandler); }
public void Test_Not_Cacheable_No_Content() { var cachingHandler = new CachingHandler(); var response = new HttpResponseMessage(HttpStatusCode.OK); response.Headers.CacheControl = new CacheControlHeaderValue { Public = true }; Assert.AreEqual(cachingHandler.ResponseValidator(response), ResponseValidationResult.NotCacheable); }
private static void SetupDbCaching(HttpConfiguration config) { var connectionString = ConfigurationManager.ConnectionStrings["cache"].ConnectionString; var cacheStore = new SqlServerEntityTagStore(connectionString); var cacheHandler = new CachingHandler(config, cacheStore) { AddLastModifiedHeader = false }; config.MessageHandlers.Add(cacheHandler); }
public void Setup() { _mockRepository = new MockRepository(); _cacheStore = _mockRepository.StrictMock <ICacheStore>(); _messageHandler = new DummyMessageHandler(); _cachingHandler = new CachingHandler(_cacheStore) { InnerHandler = _messageHandler }; _client = new HttpClient(_cachingHandler); }
public CachingHandlerTests() { _cacheStore = new Mock <ICacheStore>(); _messageHandler = new DummyMessageHandler(); _cachingHandler = new CachingHandler(_cacheStore.Object) { InnerHandler = _messageHandler }; _client = new HttpClient(_cachingHandler); }
public ContactsController() { var cachingHandler = new CachingHandler(new SqlStore()) { InnerHandler = new HttpClientHandler() }; httpClient = new HttpClient(cachingHandler) { BaseAddress = new Uri(WebConfigurationManager.AppSettings["ApiEndpoint"]) }; }
public void Test_Not_Cacheable_No_Expiration() { var cachingHandler = new CachingHandler("test", "1.0.0"); var response = new HttpResponseMessage(HttpStatusCode.OK); response.Headers.CacheControl = new CacheControlHeaderValue() { Public = true }; response.Content = new ByteArrayContent(new byte[256]); Assert.AreEqual(cachingHandler.ResponseValidator(response), ResponseValidationResult.NotCacheable); }
public static void TestGetModifiedUnmodifiedReturnsNullIfNoneDefined() { // setup var request = new HttpRequestMessage(HttpMethod.Get, TestUrl); var entityTagHandler = new CachingHandler("test", "1.0.0", new HttpConfiguration()); var getRule = entityTagHandler.GetIfModifiedUnmodifiedSince(); // run var task = getRule(request); // verify Assert.IsNull(task); }
public static void TestPutIfUnmodifiedReturnsNullIfVerbNotPut() { // setup var request = new HttpRequestMessage(HttpMethod.Get, TestUrl); var entityTagHandler = new CachingHandler(new HttpConfiguration()); var getRule = entityTagHandler.PutIfUnmodifiedSince(); // run var task = getRule(request); // verify Assert.IsNull(task); }
public void Test_NoCache_IsCacheable_And_NotStale_But_MustRevalidate() { var cachingHandler = new CachingHandler(); var response = new HttpResponseMessage(HttpStatusCode.OK); response.Headers.CacheControl = new CacheControlHeaderValue { Public = true, NoCache = true }; response.Content = new ByteArrayContent(new byte[256]); response.Content.Headers.Expires = DateTimeOffset.Now.AddHours(1); // resource is not stale Assert.AreEqual(cachingHandler.ResponseValidator(response), ResponseValidationResult.MustRevalidate); }