internal CachedRawResponse(HttpRawResponse rawResponse, HttpCachePolicySettings settings, string kernelCacheUrl, Guid cachedVaryId)
{
this._rawResponse = rawResponse;
this._settings = settings;
this._kernelCacheUrl = kernelCacheUrl;
this._cachedVaryId = cachedVaryId;
}
internal CachedRawResponse(
HttpRawResponse rawResponse,
HttpCachePolicySettings settings,
CachedVary cachedVary)
{
_rawResponse = rawResponse;
_settings = settings;
_cachedVary = cachedVary;
}
internal OutputCacheEntry(Guid cachedVaryId, HttpCachePolicySettings settings, string kernelCacheUrl, string dependenciesKey, string[] dependencies, int statusCode, string statusDescription, List <HeaderElement> headerElements, List <ResponseElement> responseElements)
{
this._cachedVaryId = cachedVaryId;
this._settings = settings;
this._kernelCacheUrl = kernelCacheUrl;
this._dependenciesKey = dependenciesKey;
this._dependencies = dependencies;
this._statusCode = statusCode;
this._statusDescription = statusDescription;
this._headerElements = headerElements;
this._responseElements = responseElements;
}
public void ValidUntilExpires_Should_Be_True()
{
var setting = new HttpCachePolicySettings()
{
SlidingExpiration = false,
GenerateLastModifiedFromFiles = false,
GenerateEtagFromFiles = false,
ValidationCallbackInfo = null
};
Assert.True(setting.ValidUntilExpires);
}
public void CheckHeaders_Should_Return_False_If_RequestHeaders_Not_Have_CacheControl_And_Pragma_Header()
{
var ocHelper = new OutputCacheHelper(CreateHttpContextBase());
var settings = new HttpCachePolicySettings()
{
GenerateEtagFromFiles = true
};
var result = ocHelper.CheckHeaders(settings);
Assert.False(result);
}
public void HasValidationPolicy_Should_Be_True(bool slidingExp, bool genLastModifiedFromFiles,
bool genEtagFromFiles, IEnumerable <KeyValuePair <HttpCacheValidateHandler, object> > callbackInfo)
{
var setting = new HttpCachePolicySettings()
{
SlidingExpiration = slidingExp,
GenerateLastModifiedFromFiles = genLastModifiedFromFiles,
GenerateEtagFromFiles = genEtagFromFiles,
ValidationCallbackInfo = callbackInfo
};
Assert.True(setting.HasValidationPolicy());
}
public void CheckHeaders_Should_Return_False_If_HttpCachePolicySettings_HasValidationPolicy()
{
var httpContextMoq = new Mock <HttpContextBase>();
var ocHelper = new OutputCacheHelper(httpContextMoq.Object);
var settings = new HttpCachePolicySettings()
{
GenerateEtagFromFiles = true
};
var result = ocHelper.CheckHeaders(settings);
Assert.False(result);
}
public async void CheckValidityAsync_Should_Do_Nothing_And_Return_False_If_ValidationCallbackInfo_Is_Empty()
{
var ocHelper = new OutputCacheHelper(CreateHttpContextBase());
var settings = new HttpCachePolicySettings();
var result = await ocHelper.CheckValidityAsync("key", settings);
Assert.False(result);
settings.ValidationCallbackInfo = new List <KeyValuePair <HttpCacheValidateHandler, object> >();
result = await ocHelper.CheckValidityAsync("key1", settings);
Assert.False(result);
}
public async void CheckValidityAsync_Should_Return_True_If_ValidationStatus_Is_Not_IgnoreThisRequest()
{
var cacheUtilMoq = new Mock <IOutputCacheUtility>();
var context = CreateHttpContextBase();
cacheUtilMoq.Setup(util => util.GetContextFromHttpContextBase(context));
var ocHelper = new OutputCacheHelper(context, cacheUtilMoq.Object);
var settings = new HttpCachePolicySettings();
var callbackInfo = new List <KeyValuePair <HttpCacheValidateHandler, object> >();
var kv = new KeyValuePair <HttpCacheValidateHandler, object>(HttpCacheValidateHandlerReturnIgnoreThisRequestStatus, "test");
callbackInfo.Add(kv);
settings.ValidationCallbackInfo = callbackInfo;
var result = await ocHelper.CheckValidityAsync("key", settings);
Assert.True(result);
}
public void CheckHeaders_Should_Return_True_If_Pragma_Is_NoCache()
{
var requestHeaders = new NameValueCollection();
requestHeaders.Add(PragmaHeaderName, "no-cache");
var ocHelper = new OutputCacheHelper(CreateHttpContextBase(requestHeaders));
var settings = new HttpCachePolicySettings()
{
SlidingExpiration = true,
GenerateLastModifiedFromFiles = false,
GenerateEtagFromFiles = false,
ValidationCallbackInfo = null
};
var result = ocHelper.CheckHeaders(settings);
Assert.True(result);
}
public void IsValidationCallbackSerializable_Should_Be_True_When_All_HttpCacheValidateHandler_Are_Static()
{
var callbackInfo = new List <KeyValuePair <HttpCacheValidateHandler, object> >();
callbackInfo.Add(new KeyValuePair <HttpCacheValidateHandler, object>(StaticHttpCacheValidateHandler1, 1));
callbackInfo.Add(new KeyValuePair <HttpCacheValidateHandler, object>(StaticHttpCacheValidateHandler2, 2));
var setting = new HttpCachePolicySettings()
{
ValidationCallbackInfo = callbackInfo
};
Assert.True(setting.IsValidationCallbackSerializable());
callbackInfo = new List <KeyValuePair <HttpCacheValidateHandler, object> >();
setting = new HttpCachePolicySettings()
{
ValidationCallbackInfo = callbackInfo
};
Assert.True(setting.IsValidationCallbackSerializable());
callbackInfo = new List <KeyValuePair <HttpCacheValidateHandler, object> >();
callbackInfo.Add(new KeyValuePair <HttpCacheValidateHandler, object>(HttpCacheValidateHandler1, 1));
setting = new HttpCachePolicySettings()
{
ValidationCallbackInfo = callbackInfo
};
Assert.False(setting.IsValidationCallbackSerializable());
callbackInfo = new List <KeyValuePair <HttpCacheValidateHandler, object> >();
callbackInfo.Add(new KeyValuePair <HttpCacheValidateHandler, object>(HttpCacheValidateHandler1, 1));
callbackInfo.Add(new KeyValuePair <HttpCacheValidateHandler, object>(StaticHttpCacheValidateHandler1, 1));
setting = new HttpCachePolicySettings()
{
ValidationCallbackInfo = callbackInfo
};
Assert.False(setting.IsValidationCallbackSerializable());
}
internal void OnLeave(object source, EventArgs eventArgs)
{
HttpApplication application = (HttpApplication)source;
HttpContext context = application.Context;
HttpRequest request = context.Request;
HttpResponse response = context.Response;
HttpCachePolicy cache = null;
bool flag = false;
if (response.HasCachePolicy)
{
cache = response.Cache;
if (((cache.IsModified() && (response.Cookies.Count <= 0)) && (response.StatusCode == 200)) && (((request.HttpVerb == HttpVerb.GET) || (request.HttpVerb == HttpVerb.POST)) && response.IsBuffered()))
{
bool flag3 = false;
if ((cache.GetCacheability() == HttpCacheability.Public) && context.RequestRequiresAuthorization())
{
cache.SetCacheability(HttpCacheability.Private);
flag3 = true;
}
if (((((cache.GetCacheability() == HttpCacheability.Public) || (cache.GetCacheability() == HttpCacheability.ServerAndPrivate)) || ((cache.GetCacheability() == HttpCacheability.Server) || flag3)) && (!cache.GetNoServerCaching() && (cache.HasExpirationPolicy() || cache.HasValidationPolicy()))) && ((!cache.VaryByHeaders.GetVaryByUnspecifiedParameters() && (cache.VaryByParams.AcceptsParams() || ((request.HttpVerb != HttpVerb.POST) && !request.HasQueryString))) && (!cache.VaryByContentEncodings.IsModified() || cache.VaryByContentEncodings.IsCacheableEncoding(context.Response.GetHttpHeaderContentEncoding()))))
{
flag = true;
}
}
}
if (flag)
{
CachedVary vary;
string str;
string[] varyByParams;
this.RecordCacheMiss();
HttpCachePolicySettings currentSettings = cache.GetCurrentSettings(response);
string[] varyByContentEncodings = currentSettings.VaryByContentEncodings;
string[] varyByHeaders = currentSettings.VaryByHeaders;
if (currentSettings.IgnoreParams)
{
varyByParams = null;
}
else
{
varyByParams = currentSettings.VaryByParams;
}
if (this._key == null)
{
this._key = this.CreateOutputCachedItemKey(context, null);
}
if (((varyByContentEncodings == null) && (varyByHeaders == null)) && ((varyByParams == null) && (currentSettings.VaryByCustom == null)))
{
str = this._key;
vary = null;
}
else
{
int num;
int length;
if (varyByHeaders != null)
{
num = 0;
length = varyByHeaders.Length;
while (num < length)
{
varyByHeaders[num] = "HTTP_" + CultureInfo.InvariantCulture.TextInfo.ToUpper(varyByHeaders[num].Replace('-', '_'));
num++;
}
}
bool varyByAllParams = false;
if (varyByParams != null)
{
varyByAllParams = (varyByParams.Length == 1) && (varyByParams[0] == "*");
if (varyByAllParams)
{
varyByParams = null;
}
else
{
num = 0;
length = varyByParams.Length;
while (num < length)
{
varyByParams[num] = CultureInfo.InvariantCulture.TextInfo.ToLower(varyByParams[num]);
num++;
}
}
}
vary = new CachedVary(varyByContentEncodings, varyByHeaders, varyByParams, varyByAllParams, currentSettings.VaryByCustom);
str = this.CreateOutputCachedItemKey(context, vary);
if (str == null)
{
return;
}
if (!response.IsBuffered())
{
return;
}
}
DateTime noAbsoluteExpiration = Cache.NoAbsoluteExpiration;
TimeSpan noSlidingExpiration = Cache.NoSlidingExpiration;
if (currentSettings.SlidingExpiration)
{
noSlidingExpiration = currentSettings.SlidingDelta;
}
else if (currentSettings.IsMaxAgeSet)
{
DateTime time2 = (currentSettings.UtcTimestampCreated != DateTime.MinValue) ? currentSettings.UtcTimestampCreated : context.UtcTimestamp;
noAbsoluteExpiration = time2 + currentSettings.MaxAge;
}
else if (currentSettings.IsExpiresSet)
{
noAbsoluteExpiration = currentSettings.UtcExpires;
}
if (noAbsoluteExpiration > DateTime.UtcNow)
{
HttpRawResponse snapshot = response.GetSnapshot();
string kernelCacheUrl = response.SetupKernelCaching(null);
Guid cachedVaryId = (vary != null) ? vary.CachedVaryId : Guid.Empty;
CachedRawResponse rawResponse = new CachedRawResponse(snapshot, currentSettings, kernelCacheUrl, cachedVaryId);
CacheDependency dependencies = response.CreateCacheDependencyForResponse();
try
{
OutputCache.InsertResponse(this._key, vary, str, rawResponse, dependencies, noAbsoluteExpiration, noSlidingExpiration);
}
catch
{
if (dependencies != null)
{
dependencies.Dispose();
}
throw;
}
}
this._key = null;
}
}
internal void OnEnter(object source, EventArgs eventArgs)
{
this._key = null;
this._recordedCacheMiss = false;
if (OutputCache.InUse)
{
string[] strArray2 = null;
string[] strArray3 = null;
HttpApplication application = (HttpApplication)source;
HttpContext context = application.Context;
context.GetFilePathData();
HttpRequest request = context.Request;
HttpResponse response = context.Response;
switch (request.HttpVerb)
{
case HttpVerb.GET:
case HttpVerb.HEAD:
case HttpVerb.POST:
{
string str;
this._key = str = this.CreateOutputCachedItemKey(context, null);
object obj2 = OutputCache.Get(str);
if (obj2 != null)
{
int num;
int length;
CachedVary cachedVary = obj2 as CachedVary;
if (cachedVary != null)
{
str = this.CreateOutputCachedItemKey(context, cachedVary);
if (str == null)
{
return;
}
if (cachedVary._contentEncodings == null)
{
obj2 = OutputCache.Get(str);
}
else
{
obj2 = null;
bool flag3 = true;
string knownRequestHeader = context.WorkerRequest.GetKnownRequestHeader(0x16);
if (knownRequestHeader != null)
{
string[] contentEncodings = cachedVary._contentEncodings;
int startIndex = 0;
bool flag4 = false;
while (!flag4)
{
flag4 = true;
int index = GetAcceptableEncoding(contentEncodings, startIndex, knownRequestHeader);
if (index > -1)
{
flag3 = false;
obj2 = OutputCache.Get(str + contentEncodings[index]);
if (obj2 == null)
{
startIndex = index + 1;
if (startIndex < contentEncodings.Length)
{
flag4 = false;
}
}
}
else if (index == -2)
{
flag3 = false;
}
}
}
if ((obj2 == null) && flag3)
{
obj2 = OutputCache.Get(str);
}
}
if ((obj2 == null) || (((CachedRawResponse)obj2)._cachedVaryId != cachedVary.CachedVaryId))
{
if (obj2 != null)
{
OutputCache.Remove(str, context);
}
return;
}
}
CachedRawResponse response2 = (CachedRawResponse)obj2;
HttpCachePolicySettings settings = response2._settings;
if ((cachedVary == null) && !settings.IgnoreParams)
{
if (request.HttpVerb == HttpVerb.POST)
{
this.RecordCacheMiss();
return;
}
if (request.HasQueryString)
{
this.RecordCacheMiss();
return;
}
}
if (settings.IgnoreRangeRequests)
{
string str8 = request.Headers["Range"];
if (StringUtil.StringStartsWithIgnoreCase(str8, "bytes"))
{
return;
}
}
if (!settings.HasValidationPolicy())
{
string str4 = request.Headers["Cache-Control"];
if (str4 != null)
{
strArray2 = str4.Split(s_fieldSeparators);
for (num = 0; num < strArray2.Length; num++)
{
string str6 = strArray2[num];
switch (str6)
{
case "no-cache":
case "no-store":
this.RecordCacheMiss();
return;
}
if (StringUtil.StringStartsWith(str6, "max-age="))
{
int num4;
try
{
num4 = Convert.ToInt32(str6.Substring(8), CultureInfo.InvariantCulture);
}
catch
{
num4 = -1;
}
if (num4 >= 0)
{
int num6 = (int)((context.UtcTimestamp.Ticks - settings.UtcTimestampCreated.Ticks) / 0x989680L);
if (num6 >= num4)
{
this.RecordCacheMiss();
return;
}
}
}
else if (StringUtil.StringStartsWith(str6, "min-fresh="))
{
int num5;
try
{
num5 = Convert.ToInt32(str6.Substring(10), CultureInfo.InvariantCulture);
}
catch
{
num5 = -1;
}
if (((num5 >= 0) && settings.IsExpiresSet) && !settings.SlidingExpiration)
{
int num7 = (int)((settings.UtcExpires.Ticks - context.UtcTimestamp.Ticks) / 0x989680L);
if (num7 < num5)
{
this.RecordCacheMiss();
return;
}
}
}
}
}
string str5 = request.Headers["Pragma"];
if (str5 != null)
{
strArray3 = str5.Split(s_fieldSeparators);
for (num = 0; num < strArray3.Length; num++)
{
if (strArray3[num] == "no-cache")
{
this.RecordCacheMiss();
return;
}
}
}
}
else if (settings.ValidationCallbackInfo != null)
{
HttpValidationStatus valid = HttpValidationStatus.Valid;
HttpValidationStatus ignoreThisRequest = valid;
num = 0;
length = settings.ValidationCallbackInfo.Length;
while (num < length)
{
ValidationCallbackInfo info = settings.ValidationCallbackInfo[num];
try
{
info.handler(context, info.data, ref valid);
}
catch (Exception exception)
{
valid = HttpValidationStatus.Invalid;
HttpApplicationFactory.RaiseError(exception);
}
switch (valid)
{
case HttpValidationStatus.Invalid:
OutputCache.Remove(str, context);
this.RecordCacheMiss();
return;
case HttpValidationStatus.IgnoreThisRequest:
ignoreThisRequest = HttpValidationStatus.IgnoreThisRequest;
break;
case HttpValidationStatus.Valid:
break;
default:
valid = ignoreThisRequest;
break;
}
num++;
}
if (ignoreThisRequest == HttpValidationStatus.IgnoreThisRequest)
{
this.RecordCacheMiss();
return;
}
}
HttpRawResponse rawResponse = response2._rawResponse;
if ((cachedVary == null) || (cachedVary._contentEncodings == null))
{
string acceptEncoding = request.Headers["Accept-Encoding"];
string contentEncoding = null;
ArrayList headers = rawResponse.Headers;
if (headers != null)
{
foreach (HttpResponseHeader header in headers)
{
if (header.Name == "Content-Encoding")
{
contentEncoding = header.Value;
break;
}
}
}
if (!IsAcceptableEncoding(contentEncoding, acceptEncoding))
{
this.RecordCacheMiss();
return;
}
}
int num3 = -1;
if (!rawResponse.HasSubstBlocks)
{
string ifModifiedSince = request.IfModifiedSince;
if (ifModifiedSince != null)
{
num3 = 0;
try
{
DateTime time = HttpDate.UtcParse(ifModifiedSince);
if ((settings.IsLastModifiedSet && (settings.UtcLastModified <= time)) && (time <= context.UtcTimestamp))
{
num3 = 1;
}
}
catch
{
}
}
if (num3 != 0)
{
string ifNoneMatch = request.IfNoneMatch;
if (ifNoneMatch != null)
{
num3 = 0;
string[] strArray = ifNoneMatch.Split(s_fieldSeparators);
num = 0;
length = strArray.Length;
while (num < length)
{
if ((num == 0) && strArray[num].Equals("*"))
{
num3 = 1;
break;
}
if (strArray[num].Equals(settings.ETag))
{
num3 = 1;
break;
}
num++;
}
}
}
}
if (num3 == 1)
{
response.ClearAll();
response.StatusCode = 0x130;
}
else
{
bool sendBody = request.HttpVerb != HttpVerb.HEAD;
response.UseSnapshot(rawResponse, sendBody);
}
response.Cache.ResetFromHttpCachePolicySettings(settings, context.UtcTimestamp);
string originalCacheUrl = response2._kernelCacheUrl;
if (originalCacheUrl != null)
{
response.SetupKernelCaching(originalCacheUrl);
}
PerfCounters.IncrementCounter(AppPerfCounter.OUTPUT_CACHE_RATIO_BASE);
PerfCounters.IncrementCounter(AppPerfCounter.OUTPUT_CACHE_HITS);
this._key = null;
this._recordedCacheMiss = false;
application.CompleteRequest();
return;
}
return;
}
}
}
}
