|
using System;
using System.Collections;
using System.Collections.Generic;
using System.Configuration.Provider;
using System.Runtime.Serialization;
using System.Security.Permissions;
using System.Threading;
using System.Web;
using System.Web.Compilation;
using System.Web.Configuration;
using System.Web.Hosting;
using System.Web.Management;
using System.Web.UI;
using System.Web.Util;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
namespace System.Web.Caching {
/*
We currently have the following buffer types:
HttpResponseBufferElement - managed memory
HttpResponseUnmanagedBufferElement - native memory
HttpResourceResponseElement - pointer to resource
HttpFileResponseElement - contains a file name, file can have 64-bit length
HttpSubstBlockResponseElement - subst callback
Custom output cache providers do not support all features. If we cannot use a custom output cache,
provider, we will use the internal cache. We will use a custom output cache provider only if:
a) no instance validation callbacks (static callbacks are okay)
b) no dependencies other than files
c) no sliding expiration
d) no instance substitution callbacks (HttpSubstBlockResponseElement) (static callbacks okay)
INSERT/GET:
----------
The custom cache provider receives an OutputCacheEntry, which contains the status, headers, response elements,
cache policy settings, and kernel cache key. The cache provider can coallesce response elements. For example,
a disk based cache may return a single response element which is the name of a file containing the entire response.
ISSUES:
If the custom cache provider is distributed, the cache keys must be unique for two applications with the same name
but different domains. For example, a request to http://company1.com/myapp/page.aspx and a request to
http://company2.com/myapp/page.aspx need to use output cache entry keys that include the domain name. Today, the
key is just /myapp/page.aspx. It would need to include the Host header, but if that is "localhost", "::1", etc,
we'd need to use %USERDOMAIN%\%COMPUTERNAME% instead. But it is possible for a single site to have multiple host name
bindings, so this would result in multiple cache entries for potentially the same cached result. We could allow this to be
adjusted by adding a setting to the cache policy.
*/
internal class DependencyCacheEntry {
private string _providerName;
private string _outputCacheEntryKey;
private string _kernelCacheEntryKey;
internal string ProviderName { get { return _providerName; } }
internal string OutputCacheEntryKey { get { return _outputCacheEntryKey; } }
internal string KernelCacheEntryKey { get { return _kernelCacheEntryKey; } }
internal DependencyCacheEntry(string oceKey, string kernelCacheEntryKey, string providerName) {
_outputCacheEntryKey = oceKey;
_kernelCacheEntryKey = kernelCacheEntryKey;
_providerName = providerName;
}
}
public static class OutputCache {
private const string OUTPUTCACHE_KEYPREFIX_DEPENDENCIES = CacheInternal.PrefixOutputCache + "D";
internal const string ASPNET_INTERNAL_PROVIDER_NAME = "AspNetInternalProvider";
private static bool s_inited;
private static object s_initLock = new object();
private static CacheItemRemovedCallback s_entryRemovedCallback;
private static CacheItemRemovedCallback s_dependencyRemovedCallback;
private static CacheItemRemovedCallback s_dependencyRemovedCallbackForFragment;
private static OutputCacheProvider s_defaultProvider;
private static OutputCacheProviderCollection s_providers;
// when there are no providers being used, we'll use this count to optimize performance when the value is zero.
private static int s_cEntries;
//
// private helper methods
//
private static void AddCacheKeyToDependencies(ref CacheDependency dependencies, string cacheKey) {
CacheDependency keyDep = new CacheDependency(0, null, new string[1] {cacheKey});
if (dependencies == null) {
dependencies = keyDep;
}
else {
// if it's not an aggregate, we have to create one because you can't add
// it to anything but an aggregate
AggregateCacheDependency agg = dependencies as AggregateCacheDependency;
if (agg != null) {
agg.Add(keyDep);
}
else {
agg = new AggregateCacheDependency();
agg.Add(keyDep, dependencies);
dependencies = agg;
}
}
}
private static void EnsureInitialized() {
if (s_inited)
return;
lock (s_initLock) {
if (!s_inited) {
OutputCacheSection settings = RuntimeConfig.GetAppConfig().OutputCache;
s_providers = settings.CreateProviderCollection();
s_defaultProvider = settings.GetDefaultProvider(s_providers);
s_entryRemovedCallback = new CacheItemRemovedCallback(OutputCache.EntryRemovedCallback);
s_dependencyRemovedCallback = new CacheItemRemovedCallback(OutputCache.DependencyRemovedCallback);
s_dependencyRemovedCallbackForFragment = new CacheItemRemovedCallback(OutputCache.DependencyRemovedCallbackForFragment);
s_inited = true;
}
}
}
private static void DecrementCount() {
if (Providers == null)
Interlocked.Decrement(ref s_cEntries);
}
private static void IncrementCount() {
if (Providers == null)
Interlocked.Increment(ref s_cEntries);
}
private static OutputCacheProvider GetFragmentProvider(String providerName) {
// if providerName is null, use default provider. If default provider is null, we'll use internal cache.
// if providerName is not null, get it from the provider collection.
OutputCacheProvider provider = null;
if (providerName == null) {
provider = s_defaultProvider;
}
else {
provider = s_providers[providerName];
if (provider == null) {
Debug.Assert(false, "Unexpected, " + providerName + " should be a member of the collection.");
throw new ProviderException(SR.GetString(SR.Provider_Not_Found, providerName));
}
}
#if DBG
string msg = (provider != null) ? provider.GetType().Name : "null";
Debug.Trace("OutputCache", "GetFragmentProvider(" + providerName + ") --> " + msg);
#endif
return provider;
}
private static OutputCacheProvider GetProvider(HttpContext context) {
Debug.Assert(context != null, "context != null");
if (context == null) {
return null;
}
// Call GetOutputCacheProviderName
// so it can determine which provider to use.
HttpApplication app = context.ApplicationInstance;
string name = app.GetOutputCacheProviderName(context);
if (name == null) {
throw new ProviderException(SR.GetString(SR.GetOutputCacheProviderName_Invalid, name));
}
// AspNetInternalProvider means use the internal cache
if (name == OutputCache.ASPNET_INTERNAL_PROVIDER_NAME) {
return null;
}
OutputCacheProvider provider = (s_providers == null) ? null : s_providers[name];
if (provider == null) {
throw new ProviderException(SR.GetString(SR.GetOutputCacheProviderName_Invalid, name));
}
return provider;
}
private static OutputCacheEntry Convert(CachedRawResponse cachedRawResponse, string depKey, string[] fileDependencies) {
List<HeaderElement> headerElements = null;
ArrayList headers = cachedRawResponse._rawResponse.Headers;
int count = (headers != null) ? headers.Count : 0;
for (int i = 0; i < count; i++) {
if (headerElements == null) {
headerElements = new List<HeaderElement>(count);
}
HttpResponseHeader h = (HttpResponseHeader)(headers[i]);
headerElements.Add(new HeaderElement(h.Name, h.Value));
}
List<ResponseElement> responseElements = null;
ArrayList buffers = cachedRawResponse._rawResponse.Buffers;
count = (buffers != null) ? buffers.Count : 0;
for (int i = 0; i < count; i++) {
if (responseElements == null) {
responseElements = new List<ResponseElement>(count);
}
IHttpResponseElement elem = buffers[i] as IHttpResponseElement;
if (elem is HttpFileResponseElement) {
HttpFileResponseElement fileElement = elem as HttpFileResponseElement;
responseElements.Add(new FileResponseElement(fileElement.FileName, fileElement.Offset, elem.GetSize()));
}
else if (elem is HttpSubstBlockResponseElement) {
HttpSubstBlockResponseElement substElement = elem as HttpSubstBlockResponseElement;
responseElements.Add(new SubstitutionResponseElement(substElement.Callback));
}
else {
byte[] b = elem.GetBytes();
long length = (b != null) ? b.Length : 0;
responseElements.Add(new MemoryResponseElement(b, length));
}
}
OutputCacheEntry oce = new OutputCacheEntry(
cachedRawResponse._cachedVaryId,
cachedRawResponse._settings,
cachedRawResponse._kernelCacheUrl,
depKey,
fileDependencies,
cachedRawResponse._rawResponse.StatusCode,
cachedRawResponse._rawResponse.StatusDescription,
headerElements,
responseElements
);
return oce;
}
private static CachedRawResponse Convert(OutputCacheEntry oce) {
ArrayList headers = null;
if (oce.HeaderElements != null && oce.HeaderElements.Count > 0) {
headers = new ArrayList(oce.HeaderElements.Count);
for (int i = 0; i < oce.HeaderElements.Count; i++) {
HttpResponseHeader h = new HttpResponseHeader(oce.HeaderElements[i].Name, oce.HeaderElements[i].Value);
headers.Add(h);
}
}
ArrayList buffers = null;
if (oce.ResponseElements != null && oce.ResponseElements.Count > 0) {
buffers = new ArrayList(oce.ResponseElements.Count);
for (int i = 0; i < oce.ResponseElements.Count; i++) {
ResponseElement re = oce.ResponseElements[i];
IHttpResponseElement elem = null;
if (re is FileResponseElement) {
HttpContext context = HttpContext.Current;
HttpWorkerRequest wr = (context != null) ? context.WorkerRequest : null;
bool supportsLongTransmitFile = (wr != null && wr.SupportsLongTransmitFile);
bool isImpersonating = ((context != null && context.IsClientImpersonationConfigured) || HttpRuntime.IsOnUNCShareInternal);
FileResponseElement fre = (FileResponseElement)re;
// DevDiv #21203: Need to verify permission to access the requested file since handled by native code.
HttpRuntime.CheckFilePermission(fre.Path);
elem = new HttpFileResponseElement(fre.Path, fre.Offset, fre.Length, isImpersonating, supportsLongTransmitFile);
}
else if (re is MemoryResponseElement) {
MemoryResponseElement mre = (MemoryResponseElement)re;
int size = System.Convert.ToInt32(mre.Length);
elem = new HttpResponseBufferElement(mre.Buffer, size);
}
else if (re is SubstitutionResponseElement) {
SubstitutionResponseElement sre = (SubstitutionResponseElement)re;
elem = new HttpSubstBlockResponseElement(sre.Callback);
}
else {
throw new NotSupportedException();
}
buffers.Add(elem);
}
}
else {
buffers = new ArrayList();
}
HttpRawResponse rawResponse = new HttpRawResponse(oce.StatusCode, oce.StatusDescription, headers, buffers, false /*hasSubstBlocks*/);
CachedRawResponse cachedRawResponse = new CachedRawResponse(rawResponse, oce.Settings, oce.KernelCacheUrl, oce.CachedVaryId);
return cachedRawResponse;
}
//
// helpers for accessing InternalCache
//
// add CachedVary
private static CachedVary UtcAdd(String key, CachedVary cachedVary) {
return (CachedVary) HttpRuntime.Cache.InternalCache.Add(key, cachedVary, null);
}
// add ControlCachedVary
private static ControlCachedVary UtcAdd(String key, ControlCachedVary cachedVary) {
return (ControlCachedVary) HttpRuntime.Cache.InternalCache.Add(key, cachedVary, null);
}
private static bool IsSubstBlockSerializable(HttpRawResponse rawResponse) {
if (!rawResponse.HasSubstBlocks)
return true;
for (int i = 0; i < rawResponse.Buffers.Count; i++) {
HttpSubstBlockResponseElement substBlock = rawResponse.Buffers[i] as HttpSubstBlockResponseElement;
if (substBlock == null)
continue;
if (!substBlock.Callback.Method.IsStatic)
return false;
}
return true;
}
//
// callbacks
//
private static void HandleErrorWithoutContext(Exception e) {
HttpApplicationFactory.RaiseError(e);
try {
WebBaseEvent.RaiseRuntimeError(e, typeof(OutputCache));
}
catch {
}
}
// only used by providers
private static void DependencyRemovedCallback(string key, object value, CacheItemRemovedReason reason) {
Debug.Trace("OutputCache", "DependencyRemovedCallback: reason=" + reason + ", key=" + key);
DependencyCacheEntry dce = value as DependencyCacheEntry;
if (dce.KernelCacheEntryKey != null) {
// invalidate kernel cache entry
if (HttpRuntime.UseIntegratedPipeline) {
UnsafeIISMethods.MgdFlushKernelCache(dce.KernelCacheEntryKey);
}
else {
UnsafeNativeMethods.InvalidateKernelCache(dce.KernelCacheEntryKey);
}
}
if (reason == CacheItemRemovedReason.DependencyChanged) {
if (dce.OutputCacheEntryKey != null) {
try {
OutputCache.RemoveFromProvider(dce.OutputCacheEntryKey, dce.ProviderName);
}
catch (Exception e) {
HandleErrorWithoutContext(e);
}
}
}
}
// only used by providers
private static void DependencyRemovedCallbackForFragment(string key, object value, CacheItemRemovedReason reason) {
Debug.Trace("OutputCache", "DependencyRemovedCallbackForFragment: reason=" + reason + ", key=" + key);
if (reason == CacheItemRemovedReason.DependencyChanged) {
DependencyCacheEntry dce = value as DependencyCacheEntry;
if (dce.OutputCacheEntryKey != null) {
try {
OutputCache.RemoveFragment(dce.OutputCacheEntryKey, dce.ProviderName);
}
catch (Exception e) {
HandleErrorWithoutContext(e);
}
}
}
}
// only used by internal cache
private static void EntryRemovedCallback(string key, object value, CacheItemRemovedReason reason) {
Debug.Trace("OutputCache", "EntryRemovedCallback: reason=" + reason + ", key=" + key);
DecrementCount();
PerfCounters.DecrementCounter(AppPerfCounter.OUTPUT_CACHE_ENTRIES);
PerfCounters.IncrementCounter(AppPerfCounter.OUTPUT_CACHE_TURNOVER_RATE);
CachedRawResponse cachedRawResponse = value as CachedRawResponse;
if (cachedRawResponse != null) {
String kernelCacheUrl = cachedRawResponse._kernelCacheUrl;
// if it is kernel cached, the url will be non-null.
// if the entry was re-inserted, don't remove kernel entry since it will be updated
if (kernelCacheUrl != null && HttpRuntime.Cache.InternalCache.Get(key) == null) {
// invalidate kernel cache entry
if (HttpRuntime.UseIntegratedPipeline) {
UnsafeIISMethods.MgdFlushKernelCache(kernelCacheUrl);
}
else {
UnsafeNativeMethods.InvalidateKernelCache(kernelCacheUrl);
}
}
}
}
//
// public properties
//
public static string DefaultProviderName {
get {
EnsureInitialized();
return (s_defaultProvider != null) ? s_defaultProvider.Name : OutputCache.ASPNET_INTERNAL_PROVIDER_NAME;
}
}
public static OutputCacheProviderCollection Providers {
get {
EnsureInitialized();
return s_providers;
}
}
//
// internal properties and methods
//
//
// If we're not using a provider, we can optimize this so the OutputCacheModule
// only need run when there are entries--return true iff count is non-zero.
// If we're using a provider, it's not easy to keep track of the number of entries,
// so always return true (so OutputCacheModule always runs).
//
internal static bool InUse {
get {
return (Providers == null) ? (s_cEntries != 0) : true;
}
}
internal static void ThrowIfProviderNotFound(String providerName) {
// null means use default provider or internal cache
if (providerName == null) {
return;
}
OutputCacheProviderCollection providers = Providers;
if (providers == null || providers[providerName] == null) {
throw new ProviderException(SR.GetString(SR.Provider_Not_Found, providerName));
}
}
internal static bool HasDependencyChanged(bool isFragment, string depKey, string[] fileDeps, string kernelKey, string oceKey, string providerName) {
if (depKey == null)
{
#if DBG
Debug.Trace("OutputCache", "HasDependencyChanged(" + depKey + ", ..., " + oceKey + ", ...) --> false");
#endif
return false;
}
// is the file dependency already in the in-memory cache?
if (HttpRuntime.Cache.InternalCache.Get(depKey) != null) {
#if DBG
Debug.Trace("OutputCache", "HasDependencyChanged(" + depKey + ", ..., " + oceKey + ", ...) --> false");
#endif
return false;
}
// deserialize the file dependencies
CacheDependency dep = new CacheDependency(0, fileDeps);
int idStartIndex = OUTPUTCACHE_KEYPREFIX_DEPENDENCIES.Length;
int idLength = depKey.Length - idStartIndex;
CacheItemRemovedCallback callback = (isFragment) ? s_dependencyRemovedCallbackForFragment : s_dependencyRemovedCallback;
// have the file dependencies changed?
if (String.Compare(dep.GetUniqueID(), 0, depKey, idStartIndex, idLength, StringComparison.Ordinal) == 0) {
// file dependencies have not changed--cache them with callback to remove OutputCacheEntry if they change
HttpRuntime.Cache.InternalCache.Insert(depKey, new DependencyCacheEntry(oceKey, kernelKey, providerName), new CacheInsertOptions() {
Dependencies = dep,
OnRemovedCallback = callback
});
#if DBG
Debug.Trace("OutputCache", "HasDependencyChanged(" + depKey + ", ..., " + oceKey + ", ...) --> false, DEPENDENCY RE-INSERTED");
#endif
return false;
}
else {
// file dependencies have changed
dep.Dispose();
#if DBG
Debug.Trace("OutputCache", "HasDependencyChanged(" + depKey + ", ..., " + oceKey + ", ...) --> true, " + dep.GetUniqueID());
#endif
return true;
}
}
[SecurityPermission(SecurityAction.Assert, Flags = SecurityPermissionFlag.SerializationFormatter)]
public static void Serialize(Stream stream, Object data) {
BinaryFormatter formatter = new BinaryFormatter();
if (data is OutputCacheEntry || data is PartialCachingCacheEntry || data is CachedVary || data is ControlCachedVary ||
data is FileResponseElement || data is MemoryResponseElement || data is SubstitutionResponseElement) {
formatter.Serialize(stream, data);
}
else {
throw new ArgumentException(SR.GetString(SR.OutputCacheExtensibility_CantSerializeDeserializeType));
}
}
[SecurityPermission(SecurityAction.Assert, Flags = SecurityPermissionFlag.SerializationFormatter)]
public static object Deserialize(Stream stream) {
BinaryFormatter formatter = new BinaryFormatter();
Object data = formatter.Deserialize(stream);
if (!(data is OutputCacheEntry || data is PartialCachingCacheEntry || data is CachedVary || data is ControlCachedVary ||
data is FileResponseElement || data is MemoryResponseElement || data is SubstitutionResponseElement)) {
throw new ArgumentException(SR.GetString(SR.OutputCacheExtensibility_CantSerializeDeserializeType));
}
return data;
}
// lookup cached vary
// lookup entry
// lookup entry for content-encoding
internal static Object Get(String key) {
// if it's not in the provider or the default provider is undefined,
// check the internal cache (we don't know where it is).
Object result = null;
OutputCacheProvider provider = GetProvider(HttpContext.Current);
if (provider != null) {
result = provider.Get(key);
OutputCacheEntry oce = result as OutputCacheEntry;
if (oce != null) {
if (HasDependencyChanged(false /*isFragment*/, oce.DependenciesKey, oce.Dependencies, oce.KernelCacheUrl, key, provider.Name)) {
OutputCache.RemoveFromProvider(key, provider.Name);
#if DBG
Debug.Trace("OutputCache", "Get(" + key + ") --> null, " + provider.Name);
#endif
return null;
}
result = Convert(oce);
}
}
if (result == null) {
result = HttpRuntime.Cache.InternalCache.Get(key);
#if DBG
string typeName = (result != null) ? result.GetType().Name : "null";
Debug.Trace("OutputCache", "Get(" + key + ") --> " + typeName + ", CacheInternal");
}
else {
Debug.Trace("OutputCache", "Get(" + key + ") --> " + result.GetType().Name + ", " + provider.Name);
#endif
}
return result;
}
// lookup fragment
internal static Object GetFragment(String key, String providerName) {
// if providerName is null, use default provider.
// if providerName is not null, get it from the provider collection.
// if it's not in the provider or the default provider is undefined,
// check the internal cache (we don't know where it is).
Object result = null;
OutputCacheProvider provider = GetFragmentProvider(providerName);
if (provider != null) {
result = provider.Get(key);
PartialCachingCacheEntry fragment = result as PartialCachingCacheEntry;
if (fragment != null) {
if (HasDependencyChanged(true /*isFragment*/, fragment._dependenciesKey, fragment._dependencies, null /*kernelKey*/, key, provider.Name)) {
OutputCache.RemoveFragment(key, provider.Name);
#if DBG
Debug.Trace("OutputCache", "GetFragment(" + key + "," + providerName + ") --> null, " + providerName);
#endif
return null;
}
}
}
if (result == null) {
result = HttpRuntime.Cache.InternalCache.Get(key);
#if DBG
string typeName = (result != null) ? result.GetType().Name : "null";
Debug.Trace("OutputCache", "GetFragment(" + key + "," + providerName + ") --> " + typeName + ", CacheInternal");
}
else {
Debug.Trace("OutputCache", "GetFragment(" + key + "," + providerName + ") --> " + result.GetType().Name + ", " + providerName);
#endif
}
return result;
}
// remove cache vary
// remove entry
internal static void Remove(String key, HttpContext context) {
// we don't know if it's in the internal cache or
// one of the providers. If a context is given,
// then we can narrow down to at most one provider.
// If the context is null, then we don't know which
// provider and we have to check all.
HttpRuntime.Cache.InternalCache.Remove(key);
if (context == null) {
// remove from all providers since we don't know which one it's in.
OutputCacheProviderCollection providers = Providers;
if (providers != null) {
foreach (OutputCacheProvider provider in providers) {
provider.Remove(key);
}
}
}
else {
OutputCacheProvider provider = GetProvider(context);
if (provider != null) {
provider.Remove(key);
}
}
#if DBG
Debug.Trace("OutputCache", "Remove(" + key + ", context)");
#endif
}
// remove cache vary
// remove entry
internal static void RemoveFromProvider(String key, String providerName) {
// we know where it is. If providerName is given,
// then it is in that provider. If it's not given,
// it's in the internal cache.
if (providerName == null) {
throw new ArgumentNullException("providerName");
}
OutputCacheProviderCollection providers = Providers;
OutputCacheProvider provider = (providers == null) ? null : providers[providerName];
if (provider == null) {
throw new ProviderException(SR.GetString(SR.Provider_Not_Found, providerName));
}
provider.Remove(key);
#if DBG
Debug.Trace("OutputCache", "Remove(" + key + ", " + providerName + ")");
#endif
}
// remove fragment
internal static void RemoveFragment(String key, String providerName) {
// if providerName is null, use default provider.
// if providerName is not null, get it from the provider collection.
// remove it from the provider and the internal cache (we don't know where it is).
OutputCacheProvider provider = GetFragmentProvider(providerName);
if (provider != null) {
provider.Remove(key);
}
HttpRuntime.Cache.InternalCache.Remove(key);
#if DBG
Debug.Trace("OutputCache", "RemoveFragment(" + key + "," + providerName + ")");
#endif
}
// insert fragment
internal static void InsertFragment(String cachedVaryKey, ControlCachedVary cachedVary,
String fragmentKey, PartialCachingCacheEntry fragment,
CacheDependency dependencies,
DateTime absExp, TimeSpan slidingExp,
String providerName) {
// if providerName is not null, find the provider in the collection.
// if providerName is null, use default provider.
// if the default provider is undefined or the fragment can't be inserted in the
// provider, insert it in the internal cache.
OutputCacheProvider provider = GetFragmentProvider(providerName);
//
// ControlCachedVary and PartialCachingCacheEntry can be serialized
//
bool useProvider = (provider != null);
if (useProvider) {
bool canUseProvider = (slidingExp == Cache.NoSlidingExpiration
&& (dependencies == null || dependencies.IsFileDependency()));
if (useProvider && !canUseProvider) {
throw new ProviderException(SR.GetString(SR.Provider_does_not_support_policy_for_fragments, providerName));
}
}
#if DBG
bool cachedVaryPutInCache = (cachedVary != null);
#endif
if (cachedVary != null) {
// Add the ControlCachedVary item so that a request will know
// which varies are needed to issue another request.
// Use the Add method so that we guarantee we only use
// a single ControlCachedVary and don't overwrite existing ones.
ControlCachedVary cachedVaryInCache;
if (!useProvider) {
cachedVaryInCache = OutputCache.UtcAdd(cachedVaryKey, cachedVary);
}
else {
cachedVaryInCache = (ControlCachedVary) provider.Add(cachedVaryKey, cachedVary, Cache.NoAbsoluteExpiration);
}
if (cachedVaryInCache != null) {
if (!cachedVary.Equals(cachedVaryInCache)) {
// overwrite existing cached vary
if (!useProvider) {
HttpRuntime.Cache.InternalCache.Insert(cachedVaryKey, cachedVary, null);
}
else {
provider.Set(cachedVaryKey, cachedVary, Cache.NoAbsoluteExpiration);
}
}
else {
cachedVary = cachedVaryInCache;
#if DBG
cachedVaryPutInCache = false;
#endif
}
}
if (!useProvider) {
AddCacheKeyToDependencies(ref dependencies, cachedVaryKey);
}
// not all caches support cache key dependencies, but we can use a "change number" to associate
// the ControlCachedVary and the PartialCachingCacheEntry
fragment._cachedVaryId = cachedVary.CachedVaryId;
}
// Now insert into the cache (use cache provider if possible, otherwise use internal cache)
if (!useProvider) {
HttpRuntime.Cache.InternalCache.Insert(fragmentKey, fragment, new CacheInsertOptions() {
Dependencies = dependencies,
AbsoluteExpiration = absExp,
SlidingExpiration = slidingExp
});
}
else {
string depKey = null;
if (dependencies != null) {
depKey = OUTPUTCACHE_KEYPREFIX_DEPENDENCIES + dependencies.GetUniqueID();
fragment._dependenciesKey = depKey;
fragment._dependencies = dependencies.GetFileDependencies();
}
provider.Set(fragmentKey, fragment, absExp);
if (dependencies != null) {
// use Add and dispose dependencies if there's already one in the cache
Object d = HttpRuntime.Cache.InternalCache.Add(depKey, new DependencyCacheEntry(fragmentKey, null, provider.Name),
new CacheInsertOptions() {
Dependencies = dependencies,
AbsoluteExpiration = absExp,
OnRemovedCallback = s_dependencyRemovedCallbackForFragment
});
if (d != null) {
dependencies.Dispose();
}
}
}
#if DBG
string cachedVaryType = (cachedVaryPutInCache) ? "ControlCachedVary" : "";
string providerUsed = (useProvider) ? provider.Name : "CacheInternal";
Debug.Trace("OutputCache", "InsertFragment("
+ cachedVaryKey + ", "
+ cachedVaryType + ", "
+ fragmentKey + ", PartialCachingCacheEntry, ...) -->"
+ providerUsed);
#endif
}
// insert cached vary or output cache entry
internal static void InsertResponse(String cachedVaryKey, CachedVary cachedVary,
String rawResponseKey, CachedRawResponse rawResponse,
CacheDependency dependencies,
DateTime absExp, TimeSpan slidingExp) {
// if the provider is undefined or the fragment can't be inserted in the
// provider, insert it in the internal cache.
OutputCacheProvider provider = GetProvider(HttpContext.Current);
//
// CachedVary can be serialized.
// CachedRawResponse is not always serializable.
//
bool useProvider = (provider != null);
if (useProvider) {
bool canUseProvider = (IsSubstBlockSerializable(rawResponse._rawResponse)
&& rawResponse._settings.IsValidationCallbackSerializable()
&& slidingExp == Cache.NoSlidingExpiration
&& (dependencies == null || dependencies.IsFileDependency()));
if (useProvider && !canUseProvider) {
throw new ProviderException(SR.GetString(SR.Provider_does_not_support_policy_for_responses, provider.Name));
}
}
#if DBG
bool cachedVaryPutInCache = (cachedVary != null);
#endif
if (cachedVary != null) {
/*
* Add the CachedVary item so that a request will know
* which headers are needed to issue another request.
*
* Use the Add method so that we guarantee we only use
* a single CachedVary and don't overwrite existing ones.
*/
CachedVary cachedVaryInCache;
if (!useProvider) {
cachedVaryInCache = OutputCache.UtcAdd(cachedVaryKey, cachedVary);
}
else {
cachedVaryInCache = (CachedVary) provider.Add(cachedVaryKey, cachedVary, Cache.NoAbsoluteExpiration);
}
if (cachedVaryInCache != null) {
if (!cachedVary.Equals(cachedVaryInCache)) {
if (!useProvider) {
HttpRuntime.Cache.InternalCache.Insert(cachedVaryKey, cachedVary, null);
}
else {
provider.Set(cachedVaryKey, cachedVary, Cache.NoAbsoluteExpiration);
}
}
else {
cachedVary = cachedVaryInCache;
#if DBG
cachedVaryPutInCache = false;
#endif
}
}
if (!useProvider) {
AddCacheKeyToDependencies(ref dependencies, cachedVaryKey);
}
// not all caches support cache key dependencies, but we can use a "change number" to associate
// the ControlCachedVary and the PartialCachingCacheEntry
rawResponse._cachedVaryId = cachedVary.CachedVaryId;
}
// Now insert into the cache (use cache provider if possible, otherwise use internal cache)
if (!useProvider) {
HttpRuntime.Cache.InternalCache.Insert(rawResponseKey, rawResponse, new CacheInsertOptions() {
Dependencies = dependencies,
AbsoluteExpiration = absExp,
SlidingExpiration = slidingExp,
OnRemovedCallback = s_entryRemovedCallback
});
IncrementCount();
PerfCounters.IncrementCounter(AppPerfCounter.OUTPUT_CACHE_ENTRIES);
PerfCounters.IncrementCounter(AppPerfCounter.OUTPUT_CACHE_TURNOVER_RATE);
}
else {
string depKey = null;
string[] fileDeps = null;
if (dependencies != null) {
depKey = OUTPUTCACHE_KEYPREFIX_DEPENDENCIES + dependencies.GetUniqueID();
fileDeps = dependencies.GetFileDependencies();
}
OutputCacheEntry oce = Convert(rawResponse, depKey, fileDeps);
provider.Set(rawResponseKey, oce, absExp);
if (dependencies != null) {
// use Add and dispose dependencies if there's already one in the cache
Object d = HttpRuntime.Cache.InternalCache.Add(depKey, new DependencyCacheEntry(rawResponseKey, oce.KernelCacheUrl, provider.Name),
new CacheInsertOptions() {
Dependencies = dependencies,
AbsoluteExpiration = absExp,
OnRemovedCallback = s_dependencyRemovedCallbackForFragment
});
if (d != null) {
dependencies.Dispose();
}
}
}
#if DBG
string cachedVaryType = (cachedVaryPutInCache) ? "CachedVary" : "";
string providerUsed = (useProvider) ? provider.Name : "CacheInternal";
Debug.Trace("OutputCache", "InsertResposne("
+ cachedVaryKey + ", "
+ cachedVaryType + ", "
+ rawResponseKey + ", CachedRawResponse, ...) -->"
+ providerUsed);
#endif
}
}
}
|