/// <summary> /// Attempts to apply some caching rules to a response /// </summary> protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { var response = await base.SendAsync(request, cancellationToken); var cacheHeaders = new CacheControlHeaderValue { NoCache = true }; if ((int)response.StatusCode > 400 || // 400 and above are errors response.StatusCode == HttpStatusCode.NoContent || // no content, no cache response.StatusCode == HttpStatusCode.Created) // any 201 Created response is not cacheable as the response is based off of the request body { // no caching allowed cacheHeaders.NoStore = true; } else if (response.StatusCode == HttpStatusCode.OK) { // 200 Okay responses should generally be cached cacheHeaders.NoStore = false; cacheHeaders.Private = false; // always revalidate cacheHeaders.MaxAge = new TimeSpan(0, 0, 0); } response.Headers.CacheControl = cacheHeaders; return response; }
public bool Should_be_determined_from_MaxAge_and_cacheControl(int maxAge, bool? noCache, bool? noStore, int? cacheControlMaxAge, bool ignoreRevalidation) { CacheControlHeaderValue cacheControl = null; if (noCache.HasValue || noStore.HasValue || cacheControlMaxAge.HasValue) { cacheControl = new CacheControlHeaderValue { NoCache = noCache ?? false, NoStore = noStore ?? false, }; if (cacheControlMaxAge.HasValue) { cacheControl.MaxAge = TimeSpan.FromSeconds(cacheControlMaxAge.Value); } } var att = new OutputCacheAttributeWithPublicMethods { MaxAge = (uint)maxAge, IgnoreRevalidationRequest = ignoreRevalidation }; // Action return att.ShouldIgnoreCachePublic(cacheControl, new HttpRequestMessage()); }
public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext) { var cachecontrol = new CacheControlHeaderValue(); cachecontrol.MaxAge = TimeSpan.FromSeconds(_clientTimeSpan); cachecontrol.MustRevalidate = true; actionExecutedContext.ActionContext.Response.Headers.CacheControl = cachecontrol; }
public void Should_return_null_if_cache_not_mature_as_min_fresh_request() { // Arrange var cacheControl = new CacheControlHeaderValue { MinFresh = TimeSpan.FromSeconds(100) }; var cacheItem = new WebApiCacheItem { CreatedTime = DateTime.UtcNow.AddSeconds(-20), MaxAge = 1000, StaleWhileRevalidate = 5, IgnoreRevalidationRequest = false }; var request = new HttpRequestMessage(); var svc = new CacheResponseBuilder { }; // Action var response = svc.GetResponse(cacheControl, cacheItem, request); // Assert Assert.IsNull(response); }
public void Subscribe(Uri subscriptionUri, Uri callbackUri, TimeSpan subscriptionTimeSpan) { var httpClient = new HttpClient(); var req = new HttpRequestMessage { RequestUri = subscriptionUri, Version = HttpVersion.Version11 }; req.Headers.UserAgent.Add(new ProductInfoHeaderValue("SimpleSonos", "1.0")); req.Method = new HttpMethod("SUBSCRIBE"); req.Headers.Add("CALLBACK", "<" + callbackUri.AbsoluteUri + ">"); req.Headers.Add("NT", "upnp:event"); req.Headers.Add("TIMEOUT", "Second-" + (int) subscriptionTimeSpan.TotalSeconds); req.Headers.ConnectionClose = true; var cch = new CacheControlHeaderValue {NoCache = true}; req.Headers.CacheControl = cch; try { var resp = httpClient.SendAsync(req).Result; Console.WriteLine("Gor response from " + subscriptionUri.Host + ". StatusCode: " + resp.StatusCode); if (resp.Headers.Contains("SID")) Console.WriteLine("SID: " + resp.Headers.GetValues("SID").First()); if (resp.Headers.Contains("TIMEOUT")) Console.WriteLine("TIMEOUT: " + resp.Headers.GetValues("TIMEOUT").First()); if (resp.Headers.Contains("Server")) Console.WriteLine("Server: " + resp.Headers.GetValues("Server").First()); } catch (Exception e) { Console.WriteLine("ERROR TRYING TO SUBSCRIBE " + e); } }
private CacheControlHeaderValue setClientCache() { var cachecontrol = new CacheControlHeaderValue(); cachecontrol.MaxAge = TimeSpan.FromSeconds(_clientTimeSpan); cachecontrol.MustRevalidate = true; return cachecontrol; }
public NotModifiedResponse(HttpRequestMessage request, CacheControlHeaderValue cacheControlHeaderValue, EntityTagHeaderValue etag) : base(HttpStatusCode.NotModified) { if(etag!=null) this.Headers.ETag = etag; this.Headers.CacheControl = cacheControlHeaderValue; this.RequestMessage = request; }
private void CheckValidParsedValue(string input, int startIndex, CacheControlHeaderValue expectedResult, int expectedIndex) { HttpHeaderParser parser = CacheControlHeaderParser.Parser; object result = null; Assert.True(parser.TryParseValue(input, null, ref startIndex, out result)); Assert.Equal(expectedIndex, startIndex); Assert.Equal(result, expectedResult); }
/// <summary> /// default .ctor is no cache policy /// </summary> public HttpCacheControlPolicyAttribute() { _cacheControl = new CacheControlHeaderValue() { Private = true, NoCache = true, NoStore = true }; }
private CacheControlHeaderValue SetClientCache() { var cachecontrol = new CacheControlHeaderValue { MaxAge = TimeSpan.FromSeconds(Duration), MustRevalidate = true }; return cachecontrol; }
public void Properties_SetAndGetAllProperties_SetValueReturnedInGetter() { CacheControlHeaderValue cacheControl = new CacheControlHeaderValue(); // Bool properties cacheControl.NoCache = true; Assert.True(cacheControl.NoCache); cacheControl.NoStore = true; Assert.True(cacheControl.NoStore); cacheControl.MaxStale = true; Assert.True(cacheControl.MaxStale); cacheControl.NoTransform = true; Assert.True(cacheControl.NoTransform); cacheControl.OnlyIfCached = true; Assert.True(cacheControl.OnlyIfCached); cacheControl.Public = true; Assert.True(cacheControl.Public); cacheControl.Private = true; Assert.True(cacheControl.Private); cacheControl.MustRevalidate = true; Assert.True(cacheControl.MustRevalidate); cacheControl.ProxyRevalidate = true; Assert.True(cacheControl.ProxyRevalidate); // TimeSpan properties TimeSpan timeSpan = new TimeSpan(1, 2, 3); cacheControl.MaxAge = timeSpan; Assert.Equal(timeSpan, cacheControl.MaxAge); cacheControl.SharedMaxAge = timeSpan; Assert.Equal(timeSpan, cacheControl.SharedMaxAge); cacheControl.MaxStaleLimit = timeSpan; Assert.Equal(timeSpan, cacheControl.MaxStaleLimit); cacheControl.MinFresh = timeSpan; Assert.Equal(timeSpan, cacheControl.MinFresh); // String collection properties Assert.NotNull(cacheControl.NoCacheHeaders); Assert.Throws<ArgumentException>(() => { cacheControl.NoCacheHeaders.Add(null); }); Assert.Throws<FormatException>(() => { cacheControl.NoCacheHeaders.Add("invalid token"); }); cacheControl.NoCacheHeaders.Add("token"); Assert.Equal(1, cacheControl.NoCacheHeaders.Count); Assert.Equal("token", cacheControl.NoCacheHeaders.First()); Assert.NotNull(cacheControl.PrivateHeaders); Assert.Throws<ArgumentException>(() => { cacheControl.PrivateHeaders.Add(null); }); Assert.Throws<FormatException>(() => { cacheControl.PrivateHeaders.Add("invalid token"); }); cacheControl.PrivateHeaders.Add("token"); Assert.Equal(1, cacheControl.PrivateHeaders.Count); Assert.Equal("token", cacheControl.PrivateHeaders.First()); // NameValueHeaderValue collection property Assert.NotNull(cacheControl.Extensions); Assert.Throws<ArgumentNullException>(() => { cacheControl.Extensions.Add(null); }); cacheControl.Extensions.Add(new NameValueHeaderValue("name", "value")); Assert.Equal(1, cacheControl.Extensions.Count); Assert.Equal(new NameValueHeaderValue("name", "value"), cacheControl.Extensions.First()); }
/// <summary> /// Sets the cache headers /// </summary> /// <param name="response">The actual response</param> protected virtual void ApplyCacheHeaders( HttpResponseMessage response) { var cacheControl = new CacheControlHeaderValue { MaxAge = TimeSpan.FromSeconds(ClientTimeSpan) }; response.Headers.CacheControl = cacheControl; }
public HttpCacheControlPolicyAttribute(bool isPrivate, int maxAgeInSeconds) : this() { _cacheControl = new CacheControlHeaderValue() { Private = isPrivate, Public = !isPrivate, MustRevalidate = true, MaxAge = TimeSpan.FromSeconds(maxAgeInSeconds) }; }
/// <summary> /// Uses a factory type to provide the value. /// This type can read from config, etc. /// Must have a public parameterless method that return CacheControlHeaderValue /// </summary> /// <param name="cacheControlHeaderValueFactory">The type of the factory. /// Any public method that returns CacheControlHeaderValue will be used. /// Type's constructor must be parameterless</param> public HttpCacheControlPolicyAttribute(Type cacheControlHeaderValueFactory) { var factory = Activator.CreateInstance(cacheControlHeaderValueFactory); var method = factory.GetType().GetMethods(BindingFlags.Public | BindingFlags.Instance) .FirstOrDefault(m => m.ReturnType == typeof(CacheControlHeaderValue)); if(method == null) throw new ArgumentException("This type does not have a factory method: " + cacheControlHeaderValueFactory.FullName); _cacheControl = (CacheControlHeaderValue) method.Invoke(factory, new object[0]); }
public void Should_return_GatewayTimeout_when_no_cache_and_request_sent_OnlyIfCached_control() { // Arrange var cacheControl = new CacheControlHeaderValue {OnlyIfCached = true}; var svc = new CacheResponseBuilder(); // Action var result = svc.GetResponse(cacheControl, null, new HttpRequestMessage()); // Assert Assert.AreEqual(HttpStatusCode.GatewayTimeout, result.StatusCode); Assert.AreEqual("no cache available", result.Headers.GetValues("X-Flatwhite-Message").Single()); }
public void HttpProvider_CustomCacheHeaderAndTimeout() { var timeout = TimeSpan.FromSeconds(200); var cacheHeader = new CacheControlHeaderValue(); using (var defaultHttpProvider = new HttpProvider(null) { CacheControlHeader = cacheHeader, OverallTimeout = timeout }) { Assert.IsFalse(defaultHttpProvider.httpClient.DefaultRequestHeaders.CacheControl.NoCache, "NoCache true."); Assert.IsFalse(defaultHttpProvider.httpClient.DefaultRequestHeaders.CacheControl.NoStore, "NoStore true."); Assert.AreEqual(timeout, defaultHttpProvider.httpClient.Timeout, "Unexpected default timeout set."); Assert.IsNotNull(defaultHttpProvider.Serializer, "Serializer not initialized."); Assert.IsInstanceOfType(defaultHttpProvider.Serializer, typeof(Serializer), "Unexpected serializer initialized."); } }
public async Task Should_return_new_etag_if_cache_item_found_but_doesnt_match_checksum(string cacheChecksum, HttpStatusCode resultCode) { // Arrange var cacheControl = new CacheControlHeaderValue { MaxStale = true, MaxStaleLimit = TimeSpan.FromSeconds(15), MinFresh = TimeSpan.FromSeconds(20) }; var oldCacheItem = new WebApiCacheItem { CreatedTime = DateTime.UtcNow.AddSeconds(-11), MaxAge = 10, StaleWhileRevalidate = 5, IgnoreRevalidationRequest = true, ResponseCharSet = "UTF8", ResponseMediaType = "text/json", Content = new byte[0], Key = "fw-0-HASHEDKEY", Checksum = cacheChecksum }; var request = new HttpRequestMessage { Method = new HttpMethod("GET"), RequestUri = new Uri("http://localhost") }; request.Headers.Add("If-None-Match", "\"fw-0-HASHEDKEY-OLDCHECKSUM\""); var builder = new CacheResponseBuilder(); var handler = new EtagHeaderHandler(builder); await Global.CacheStoreProvider.GetAsyncCacheStore().SetAsync("fw-0-HASHEDKEY", oldCacheItem, DateTimeOffset.Now.AddDays(1)).ConfigureAwait(false); // Action Global.Cache.PhoenixFireCage["fw-0-HASHEDKEY"] = new WebApiPhoenix(NSubstitute.Substitute.For<_IInvocation>(), new CacheInfo(), oldCacheItem, request); var response = await handler.HandleAsync(cacheControl, request, CancellationToken.None).ConfigureAwait(false); Assert.AreEqual(resultCode, response.StatusCode); if (resultCode == HttpStatusCode.OK) { Assert.AreEqual($"\"fw-0-HASHEDKEY-{cacheChecksum}\"", response.Headers.ETag.Tag); } else { Assert.IsNull(response.Headers.ETag); } }
public void TryParse_SetOfValidValueStrings_ParsedCorrectly() { // Just verify parser is implemented correctly. Don't try to test syntax parsed by CacheControlHeaderValue. CacheControlHeaderValue expected = new CacheControlHeaderValue(); expected.NoStore = true; expected.MinFresh = new TimeSpan(0, 2, 3); CheckValidParsedValue("X , , no-store, min-fresh=123", 1, expected, 29); expected = new CacheControlHeaderValue(); expected.MaxStale = true; expected.NoCache = true; expected.NoCacheHeaders.Add("t"); CheckValidParsedValue("max-stale, no-cache=\"t\", ,,", 0, expected, 27); }
public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext) { if (actionExecutedContext.Response.StatusCode >= HttpStatusCode.InternalServerError) { return; } var cachecontrol = new CacheControlHeaderValue { MaxAge = TimeSpan.FromSeconds(ClientTimeSpan), MustRevalidate = true, Public = true }; actionExecutedContext.Response.Headers.CacheControl = cachecontrol; }
public async Task Should_return_null_if_no_etag_in_request() { // Arrange var cacheControl = new CacheControlHeaderValue(); var request = new HttpRequestMessage { Method = new HttpMethod("GET"), RequestUri = new Uri("http://localhost") }; var builder = Substitute.For<ICacheResponseBuilder>(); var handler = new EtagHeaderHandler(builder); // Action var response = await handler.HandleAsync(cacheControl, request, CancellationToken.None); Assert.IsNull(response); }
public void TestRefreshPolicyFor404() { var configuration = new HttpConfiguration(new HttpRouteCollection("/")); configuration.Services.Replace(typeof (IHttpControllerSelector), new NotFoundControllerSelector()); configuration.Routes.MapHttpRoute("main", "api/{controller}/{id}"); var request = new HttpRequestMessage(HttpMethod.Get, new Uri("http://aliostad/api/CachePolicyAction/1")); var routeData = configuration.Routes.GetRouteData(request); request.Properties.Add(HttpPropertyKeys.HttpRouteDataKey, (object)routeData); var headerValue = new CacheControlHeaderValue(); var attributeBasedCachePolicy = new AttributeBasedCacheControlPolicy(headerValue); // act var cchv = attributeBasedCachePolicy.GetCacheControl(request, configuration); // assert Assert.AreEqual(headerValue, cchv); }
public async Task Should_return_null_if_cache_item_not_found() { // Arrange var cacheControl = new CacheControlHeaderValue(); var request = new HttpRequestMessage { Method = new HttpMethod("GET"), RequestUri = new Uri("http://localhost") }; request.Headers.Add("If-None-Match", "\"fw-1000-HASHEDKEY-CHECKSUM\""); var builder = Substitute.For<ICacheResponseBuilder>(); var handler = new EtagHeaderHandler(builder); // Action var response = await handler.HandleAsync(cacheControl, request, CancellationToken.None); Assert.IsNull(response); }
public HttpCacheControlPolicyAttribute(bool isPrivate, int maxAgeInSeconds, bool mustRevalidate = true, bool noCache = false, bool noTransform = false) : this() { // copy values to the header _cacheControl = new CacheControlHeaderValue() { Private = isPrivate, Public = !isPrivate, MustRevalidate = mustRevalidate, MaxAge = TimeSpan.FromSeconds(maxAgeInSeconds), NoCache = noCache, NoTransform = noTransform }; }
protected CacheControlHeaderValue CloneCacheControlHeaderValue(CacheControlHeaderValue headerValue) { return new CacheControlHeaderValue() { MaxAge = headerValue.MaxAge, MaxStale = headerValue.MaxStale, MaxStaleLimit = headerValue.MaxStaleLimit, MinFresh = headerValue.MinFresh, MustRevalidate = headerValue.MustRevalidate, NoCache = headerValue.NoCache, NoStore = headerValue.NoStore, NoTransform = headerValue.NoTransform, OnlyIfCached = headerValue.OnlyIfCached, Private = headerValue.Private, ProxyRevalidate = headerValue.ProxyRevalidate, Public = headerValue.Public, SharedMaxAge = headerValue.SharedMaxAge }; }
private CacheControlHeaderValue(CacheControlHeaderValue source) { Debug.Assert(source != null); _noCache = source._noCache; _noStore = source._noStore; _maxAge = source._maxAge; _sharedMaxAge = source._sharedMaxAge; _maxStale = source._maxStale; _maxStaleLimit = source._maxStaleLimit; _minFresh = source._minFresh; _noTransform = source._noTransform; _onlyIfCached = source._onlyIfCached; _publicField = source._publicField; _privateField = source._privateField; _mustRevalidate = source._mustRevalidate; _proxyRevalidate = source._proxyRevalidate; if (source._noCacheHeaders != null) { foreach (var noCacheHeader in source._noCacheHeaders) { NoCacheHeaders.Add(noCacheHeader); } } if (source._privateHeaders != null) { foreach (var privateHeader in source._privateHeaders) { PrivateHeaders.Add(privateHeader); } } if (source._extensions != null) { foreach (var extension in source._extensions) { Extensions.Add((NameValueHeaderValue)((ICloneable)extension).Clone()); } } }
private CacheControlHeaderValue(CacheControlHeaderValue source) { Contract.Requires(source != null); noCache = source.noCache; noStore = source.noStore; maxAge = source.maxAge; sharedMaxAge = source.sharedMaxAge; maxStale = source.maxStale; maxStaleLimit = source.maxStaleLimit; minFresh = source.minFresh; noTransform = source.noTransform; onlyIfCached = source.onlyIfCached; publicField = source.publicField; privateField = source.privateField; mustRevalidate = source.mustRevalidate; proxyRevalidate = source.proxyRevalidate; if (source.noCacheHeaders != null) { foreach (var noCacheHeader in source.noCacheHeaders) { NoCacheHeaders.Add(noCacheHeader); } } if (source.privateHeaders != null) { foreach (var privateHeader in source.privateHeaders) { PrivateHeaders.Add(privateHeader); } } if (source.extensions != null) { foreach (var extension in source.extensions) { Extensions.Add((NameValueHeaderValue)((ICloneable)extension).Clone()); } } }
private CacheControlHeaderValue(CacheControlHeaderValue source) { Contract.Requires(source != null); noCache = source.noCache; noStore = source.noStore; maxAge = source.maxAge; sharedMaxAge = source.sharedMaxAge; maxStale = source.maxStale; maxStaleLimit = source.maxStaleLimit; minFresh = source.minFresh; noTransform = source.noTransform; onlyIfCached = source.onlyIfCached; publicField = source.publicField; privateField = source.privateField; mustRevalidate = source.mustRevalidate; proxyRevalidate = source.proxyRevalidate; if (source.noCacheHeaders != null) { foreach (var noCacheHeader in source.noCacheHeaders) { NoCacheHeaders.Add(noCacheHeader); } } if (source.privateHeaders != null) { foreach (var privateHeader in source.privateHeaders) { PrivateHeaders.Add(privateHeader); } } if (source.extensions != null) { foreach (var extension in source.extensions) { Extensions.Add((NameValueHeaderValue)((ICloneable)extension).Clone()); } } }
public void Ctor_Default () { var value = new CacheControlHeaderValue (); Assert.AreEqual (0, value.Extensions.Count, "#1"); Assert.IsNull (value.MaxAge, "#2"); Assert.IsFalse (value.MaxStale, "#3"); Assert.IsNull (value.MaxStaleLimit, "#4"); Assert.IsNull (value.MinFresh, "#5"); Assert.IsFalse (value.MustRevalidate, "#6"); Assert.IsFalse (value.NoCache, "#7"); Assert.IsFalse (value.NoStore, "#8"); Assert.IsFalse (value.NoTransform, "#9"); Assert.IsFalse (value.OnlyIfCached, "#10"); Assert.IsFalse (value.Private, "#11"); Assert.AreEqual (0, value.PrivateHeaders.Count, "#12"); Assert.IsFalse (value.ProxyRevalidate, "#13"); Assert.IsFalse (value.Public, "#14"); Assert.IsNull (value.SharedMaxAge, "#15"); }
public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext) { // if some exception happened before in pipeline, response will be null if (actionExecutedContext.Response == null) { return; } HttpStatusCode statusCode = actionExecutedContext.Response.StatusCode; if (statusCode == HttpStatusCode.OK || statusCode == HttpStatusCode.NotModified) { var response = actionExecutedContext.Response; var cacheControl = new CacheControlHeaderValue(); cacheControl.MaxAge = TimeSpan.FromSeconds(MaxAge); response.Headers.CacheControl = cacheControl; } base.OnActionExecuted(actionExecutedContext); }
public static void ApplyCacheRequestDirective(this HttpRequestMessage requestMessage, CacheRequestDirective cacheDirective, ConditionalRequestDirective conditionalDirective) { var cacheControlHeader = new CacheControlHeaderValue(); cacheControlHeader.MaxAge = cacheDirective.MaxAge; cacheControlHeader.MaxStale = cacheDirective.MaxStale.HasValue; if (cacheDirective.MaxStale != TimeSpan.MaxValue) cacheControlHeader.MaxStaleLimit = cacheDirective.MaxStale; cacheControlHeader.MinFresh = cacheDirective.MinFresh; cacheControlHeader.NoCache = cacheDirective.NoCache; if (cacheDirective.NoCache) requestMessage.Headers.Pragma.Add(new NameValueHeaderValue("no-cache")); cacheControlHeader.NoStore = cacheDirective.NoStore; // TODO deal with no-transform cacheControlHeader.OnlyIfCached = cacheDirective.OnlyIfCached; requestMessage.Headers.CacheControl = cacheControlHeader; requestMessage.Headers.IfModifiedSince = conditionalDirective.IfModifiedSince; requestMessage.Headers.IfUnmodifiedSince = conditionalDirective.IfUnmodifiedSince; CopyETags(conditionalDirective.IfMatch, requestMessage.Headers.IfMatch); CopyETags(conditionalDirective.IfNoneMatch, requestMessage.Headers.IfNoneMatch); }
/// <summary> /// cacheControl ヘッダ値によりキャッシュ要素を作成、登録します。 /// </summary> /// <param name="requestUri"></param> /// <param name="cacheControl"></param> /// <param name="eTag"></param> /// <param name="content"></param> public static void CreateEntry(string requestUri, CacheControlHeaderValue cacheControl, string eTag, string content) { Contract.Requires(requestUri!=null); Contract.Requires(cacheControl!=null); Contract.Requires(eTag!=null); Contract.Requires(content!=null); if(CacheProvider==null) return; if( cacheControl.NoCache ) return; CacheProvider.CreateEntry( new CacheEntry(requestUri) { Content = content, ETag = eTag, ExpireAt = DateTime.UtcNow.Add(cacheControl.MaxAge ?? TimeSpan.FromSeconds(60)) }); }
/// <summary> /// Try to get the cache from etag and build the response if cache is available /// </summary> /// <param name="cacheControl"></param> /// <param name="request"></param> /// <param name="cancellationToken"></param> /// <returns></returns> public async Task<HttpResponseMessage> HandleAsync(CacheControlHeaderValue cacheControl, HttpRequestMessage request, CancellationToken cancellationToken) { if (request.Headers.IfNoneMatch != null) { // Etag format: fw-StoreId-HashedKey-Checksum var requestEtags = request.Headers.IfNoneMatch.Where(t => t.Tag != null && t.Tag.StartsWith("\"fw-")).ToList(); if (requestEtags.Count > 0) { foreach (var etag in requestEtags) { var etagString = etag.Tag.Trim('"'); var index = etagString.IndexOf("-", 4, StringComparison.Ordinal); var storeIdString = index > 0 ? etagString.Substring(3, index - 3) : "0"; index = etagString.LastIndexOf("-", StringComparison.Ordinal); int storeId; IAsyncCacheStore cacheStore = null; if (int.TryParse(storeIdString, out storeId)) { cacheStore = Global.CacheStoreProvider.GetAsyncCacheStore(storeId) ?? Global.CacheStoreProvider.GetAsyncCacheStore(); } if (cacheStore != null && index > 0) { var hashedKey = etagString.Substring(0, index); var checkSum = etagString.Substring(index + 1); var cacheItem = (await cacheStore.GetAsync(hashedKey)) as WebApiCacheItem; if (cacheItem != null && cacheItem.Checksum == checkSum) { request.Properties[WebApiExtensions.__webApi_etag_matched] = true; } return _builder.GetResponse(cacheControl, cacheItem, request); } } } } return null; }
public override bool Equals(object obj) { CacheControlHeaderValue other = obj as CacheControlHeaderValue; if (other == null) { return(false); } if ((noCache != other.noCache) || (noStore != other.noStore) || (maxAge != other.maxAge) || (sharedMaxAge != other.sharedMaxAge) || (maxStale != other.maxStale) || (maxStaleLimit != other.maxStaleLimit) || (minFresh != other.minFresh) || (noTransform != other.noTransform) || (onlyIfCached != other.onlyIfCached) || (publicField != other.publicField) || (privateField != other.privateField) || (mustRevalidate != other.mustRevalidate) || (proxyRevalidate != other.proxyRevalidate)) { return(false); } if (!HeaderUtilities.AreEqualCollections(noCacheHeaders, other.noCacheHeaders, HeaderUtilities.CaseInsensitiveStringComparer)) { return(false); } if (!HeaderUtilities.AreEqualCollections(privateHeaders, other.privateHeaders, HeaderUtilities.CaseInsensitiveStringComparer)) { return(false); } if (!HeaderUtilities.AreEqualCollections(extensions, other.extensions)) { return(false); } return(true); }
public override bool Equals(object obj) { CacheControlHeaderValue other = obj as CacheControlHeaderValue; if (other == null) { return(false); } if ((_noCache != other._noCache) || (_noStore != other._noStore) || (_maxAge != other._maxAge) || (_sharedMaxAge != other._sharedMaxAge) || (_maxStale != other._maxStale) || (_maxStaleLimit != other._maxStaleLimit) || (_minFresh != other._minFresh) || (_noTransform != other._noTransform) || (_onlyIfCached != other._onlyIfCached) || (_publicField != other._publicField) || (_privateField != other._privateField) || (_mustRevalidate != other._mustRevalidate) || (_proxyRevalidate != other._proxyRevalidate)) { return(false); } if (!HeaderUtilities.AreEqualCollections(_noCacheHeaders, other._noCacheHeaders, StringComparer.OrdinalIgnoreCase)) { return(false); } if (!HeaderUtilities.AreEqualCollections(_privateHeaders, other._privateHeaders, StringComparer.OrdinalIgnoreCase)) { return(false); } if (!HeaderUtilities.AreEqualCollections(_extensions, other._extensions)) { return(false); } return(true); }
public static bool TryParse(string input, out CacheControlHeaderValue parsedValue) { throw new NotImplementedException(); }
public static bool TryParse(string input, out CacheControlHeaderValue parsedValue) { parsedValue = null; if (input == null) { return(true); } var value = new CacheControlHeaderValue(); var lexer = new Lexer(input); Token t; do { t = lexer.Scan(); if (t != Token.Type.Token) { return(false); } string s = lexer.GetStringValue(t); bool token_read = false; TimeSpan?ts; switch (s) { case "no-store": value.NoStore = true; break; case "no-transform": value.NoTransform = true; break; case "only-if-cached": value.OnlyIfCached = true; break; case "public": value.Public = true; break; case "must-revalidate": value.MustRevalidate = true; break; case "proxy-revalidate": value.ProxyRevalidate = true; break; case "max-stale": value.MaxStale = true; t = lexer.Scan(); if (t != Token.Type.SeparatorEqual) { token_read = true; break; } t = lexer.Scan(); if (t != Token.Type.Token) { return(false); } ts = lexer.TryGetTimeSpanValue(t); if (ts == null) { return(false); } value.MaxStaleLimit = ts; break; case "max-age": case "s-maxage": case "min-fresh": t = lexer.Scan(); if (t != Token.Type.SeparatorEqual) { return(false); } t = lexer.Scan(); if (t != Token.Type.Token) { return(false); } ts = lexer.TryGetTimeSpanValue(t); if (ts == null) { return(false); } switch (s.Length) { case 7: value.MaxAge = ts; break; case 8: value.SharedMaxAge = ts; break; default: value.MinFresh = ts; break; } break; case "private": case "no-cache": if (s.Length == 7) { value.Private = true; } else { value.NoCache = true; } t = lexer.Scan(); if (t != Token.Type.SeparatorEqual) { token_read = true; break; } t = lexer.Scan(); if (t != Token.Type.QuotedString) { return(false); } foreach (var entry in lexer.GetQuotedStringValue(t).Split(',')) { var qs = entry.Trim('\t', ' '); if (s.Length == 7) { value.PrivateHeaders.Add(qs); } else { value.NoCache = true; value.NoCacheHeaders.Add(qs); } } break; default: string name = lexer.GetStringValue(t); string svalue = null; t = lexer.Scan(); if (t == Token.Type.SeparatorEqual) { t = lexer.Scan(); switch (t.Kind) { case Token.Type.Token: case Token.Type.QuotedString: svalue = lexer.GetStringValue(t); break; default: return(false); } } else { token_read = true; } value.Extensions.Add(NameValueHeaderValue.Create(name, svalue)); break; } if (!token_read) { t = lexer.Scan(); } } while (t == Token.Type.SeparatorComma); if (t != Token.Type.End) { return(false); } parsedValue = value; return(true); }
public static bool TryParse(string input, out CacheControlHeaderValue parsedValue) { }
private static bool TrySetCacheControlValues(CacheControlHeaderValue cc, List <NameValueHeaderValue> nameValueList) { foreach (NameValueHeaderValue nameValue in nameValueList) { bool success = true; string name = nameValue.Name.ToLowerInvariant(); switch (name) { case noCacheString: success = TrySetOptionalTokenList(nameValue, ref cc._noCache, ref cc._noCacheHeaders); break; case noStoreString: success = TrySetTokenOnlyValue(nameValue, ref cc._noStore); break; case maxAgeString: success = TrySetTimeSpan(nameValue, ref cc._maxAge); break; case maxStaleString: success = ((nameValue.Value == null) || TrySetTimeSpan(nameValue, ref cc._maxStaleLimit)); if (success) { cc._maxStale = true; } break; case minFreshString: success = TrySetTimeSpan(nameValue, ref cc._minFresh); break; case noTransformString: success = TrySetTokenOnlyValue(nameValue, ref cc._noTransform); break; case onlyIfCachedString: success = TrySetTokenOnlyValue(nameValue, ref cc._onlyIfCached); break; case publicString: success = TrySetTokenOnlyValue(nameValue, ref cc._publicField); break; case privateString: success = TrySetOptionalTokenList(nameValue, ref cc._privateField, ref cc._privateHeaders); break; case mustRevalidateString: success = TrySetTokenOnlyValue(nameValue, ref cc._mustRevalidate); break; case proxyRevalidateString: success = TrySetTokenOnlyValue(nameValue, ref cc._proxyRevalidate); break; case sharedMaxAgeString: success = TrySetTimeSpan(nameValue, ref cc._sharedMaxAge); break; default: cc.Extensions.Add(nameValue); // success is always true break; } if (!success) { return(false); } } return(true); }
internal static int GetCacheControlLength(string input, int startIndex, CacheControlHeaderValue storeValue, out CacheControlHeaderValue parsedValue) { }