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);
}
