1 public void OnActionExecuting(ActionExecutingContext filterContext) {
  2
  3
  4
  5             Logger.Debug("Incoming request for URL '{0}'.", filterContext.RequestContext.HttpContext.Request.RawUrl);
  6
  7
  8
  9             // This filter is not reentrant (multiple executions within the same request are
 10
 11             // not supported) so child actions are ignored completely.
 12
 13             if (filterContext.IsChildAction) {
 14
 15                 Logger.Debug("Action '{0}' ignored because it's a child action.", filterContext.ActionDescriptor.ActionName);
 16
 17                 return;
 18
 19             }
 20
 21
 22
 23             _now = _clock.UtcNow;
 24
 25             _workContext = _workContextAccessor.GetContext();
 26
 27
 28
 29             if (!RequestIsCacheable(filterContext))
 30
 31                 return;
 32
 33
 34
 35             // Computing the cache key after we know that the request is cacheable means that we are only performing this calculation on requests that require it
 36
 37             _cacheKey = ComputeCacheKey(filterContext, GetCacheKeyParameters(filterContext));
 38
 39             _invariantCacheKey = ComputeCacheKey(filterContext, null);
 40
 41
 42
 43             Logger.Debug("Cache key '{0}' was created.", _cacheKey);
 44
 45
 46
 47             // The cache key lock for a given cache key is used to synchronize requests to
 48
 49             // ensure only a single request is regenerating the item.
 50
 51             var cacheKeyLock = _cacheKeyLocks.GetOrAdd(_cacheKey, x => new object());
 52
 53
 54
 55             try {
 56
 57
 58
 59                 // Is there a cached item, and are we allowed to serve it?
 60
 61                 var allowServeFromCache = filterContext.RequestContext.HttpContext.Request.Headers["Cache-Control"] != "no-cache" || CacheSettings.IgnoreNoCache;
 62
 63                 var cacheItem = _cacheStorageProvider.GetCacheItem(_cacheKey);
 64
 65                 if (allowServeFromCache && cacheItem != null) {
 66
 67
 68
 69                     Logger.Debug("Item '{0}' was found in cache.", _cacheKey);
 70
 71
 72
 73                     // Is the cached item in its grace period?
 74
 75                     if (cacheItem.IsInGracePeriod(_now)) {
 76
 77
 78
 79                         // Render the content unless another request is already doing so.
 80
 81                         if (Monitor.TryEnter(cacheKeyLock)) {
 82
 83                             Logger.Debug("Item '{0}' is in grace period and not currently being rendered; rendering item...", _cacheKey);
 84
 85                             BeginRenderItem(filterContext);
 86
 87                             return;
 88
 89                         }
 90
 91                     }
 92
 93
 94
 95                     // Cached item is not yet in its grace period, or is already being
 96
 97                     // rendered by another request; serve it from cache.
 98
 99                     Logger.Debug("Serving item '{0}' from cache.", _cacheKey);
100
101                     ServeCachedItem(filterContext, cacheItem);
102
103                     return;
104
105                 }
106
107
108
109                 // No cached item found, or client doesn't want it; acquire the cache key
110
111                 // lock to render the item.
112
113                 Logger.Debug("Item '{0}' was not found in cache or client refuses it. Acquiring cache key lock...", _cacheKey);
114
115                 if (Monitor.TryEnter(cacheKeyLock, TimeSpan.FromSeconds(20))) {
116
117                     Logger.Debug("Cache key lock for item '{0}' was acquired.", _cacheKey);
118
119
120
121                     // Item might now have been rendered and cached by another request; if so serve it from cache.
122
123                     if (allowServeFromCache) {
124
125                         cacheItem = _cacheStorageProvider.GetCacheItem(_cacheKey);
126
127                         if (cacheItem != null) {
128
129                             Logger.Debug("Item '{0}' was now found; releasing cache key lock and serving from cache.", _cacheKey);
130
131                             Monitor.Exit(cacheKeyLock);
132
133                             ServeCachedItem(filterContext, cacheItem);
134
135                             return;
136
137                         }
138
139                     }
140
141                 }
142
143
144
145                 // Either we acquired the cache key lock and the item was still not in cache, or
146
147                 // the lock acquisition timed out. In either case render the item.
148
149                 Logger.Debug("Rendering item '{0}'...", _cacheKey);
150
151                 BeginRenderItem(filterContext);
152
153
154
155             }
156
157             catch {
158
159                 // Remember to release the cache key lock in the event of an exception!
160
161                 Logger.Debug("Exception occurred for item '{0}'; releasing any acquired lock.", _cacheKey);
162
163                 if (Monitor.IsEntered(cacheKeyLock))
164
165                     Monitor.Exit(cacheKeyLock);
166
167                 throw;
168
169             }
170
171         }

  1 public void OnResultExecuted(ResultExecutedContext filterContext) {
  2
  3           var captureHandlerIsAttached = false;
  4
  5
  6
  7             try {
  8
  9
 10
 11                 // This filter is not reentrant (multiple executions within the same request are
 12
 13                 // not supported) so child actions are ignored completely.
 14
 15                 if (filterContext.IsChildAction || !_isCachingRequest)
 16
 17                     return;
 18
 19
 20
 21                 Logger.Debug("Item '{0}' was rendered.", _cacheKey);
 22
 23
 24
 25                 // Obtain individual route configuration, if any.
 26
 27                 CacheRouteConfig configuration = null;
 28
 29                 var configurations = _cacheService.GetRouteConfigs();
 30
 31                 if (configurations.Any()) {
 32
 33                     var route = filterContext.Controller.ControllerContext.RouteData.Route;
 34
 35                     var key = _cacheService.GetRouteDescriptorKey(filterContext.HttpContext, route);
 36
 37                     configuration = configurations.FirstOrDefault(c => c.RouteKey == key);
 38
 39                 }
 40
 41
 42
 43                 if (!ResponseIsCacheable(filterContext, configuration)) {
 44
 45                     filterContext.HttpContext.Response.Cache.SetCacheability(HttpCacheability.NoCache);
 46
 47                     filterContext.HttpContext.Response.Cache.SetNoStore();
 48
 49                     filterContext.HttpContext.Response.Cache.SetMaxAge(new TimeSpan(0));
 50
 51                     return;
 52
 53                 }
 54
 55
 56
 57                 // Determine duration and grace time.
 58
 59                 var cacheDuration = configuration != null && configuration.Duration.HasValue ? configuration.Duration.Value : CacheSettings.DefaultCacheDuration;
 60
 61                 var cacheGraceTime = configuration != null && configuration.GraceTime.HasValue ? configuration.GraceTime.Value : CacheSettings.DefaultCacheGraceTime;
 62
 63
 64
 65                 // Include each content item ID as tags for the cache entry.
 66
 67                 var contentItemIds = _displayedContentItemHandler.GetDisplayed().Select(x => x.ToString(CultureInfo.InvariantCulture)).ToArray();
 68
 69
 70
 71                 // Capture the response output using a custom filter stream.
 72
 73                 var response = filterContext.HttpContext.Response;
 74
 75                 var captureStream = new CaptureStream(response.Filter);
 76
 77                 response.Filter = captureStream;
 78
 79                 captureStream.Captured += (output) => {
 80
 81                     try {
 82
 83                         // Since this is a callback any call to injected dependencies can result in an Autofac exception: "Instances
 84
 85                         // cannot be resolved and nested lifetimes cannot be created from this LifetimeScope as it has already been disposed."
 86
 87                         // To prevent access to the original lifetime scope a new work context scope should be created here and dependencies
 88
 89                         // should be resolved from it.
 90
 91
 92
 93                         using (var scope = _workContextAccessor.CreateWorkContextScope()) {
 94
 95                             var cacheItem = new CacheItem() {
 96
 97                                 CachedOnUtc = _now,
 98
 99                                 Duration = cacheDuration,
100
101                                 GraceTime = cacheGraceTime,
102
103                                 Output = output,
104
105                                 ContentType = response.ContentType,
106
107                                 QueryString = filterContext.HttpContext.Request.Url.Query,
108
109                                 CacheKey = _cacheKey,
110
111                                 InvariantCacheKey = _invariantCacheKey,
112
113                                 Url = filterContext.HttpContext.Request.Url.AbsolutePath,
114
115                                 Tenant = scope.Resolve<ShellSettings>().Name,
116
117                                 StatusCode = response.StatusCode,
118
119                                 Tags = new[] { _invariantCacheKey }.Union(contentItemIds).ToArray()
120
121                             };
122
123
124
125                             // Write the rendered item to the cache.
126
127                             var cacheStorageProvider = scope.Resolve<IOutputCacheStorageProvider>();
128
129                             cacheStorageProvider.Remove(_cacheKey);
130
131                             cacheStorageProvider.Set(_cacheKey, cacheItem);
132
133
134
135                             Logger.Debug("Item '{0}' was written to cache.", _cacheKey);
136
137
138
139                             // Also add the item tags to the tag cache.
140
141                             var tagCache = scope.Resolve<ITagCache>();
142
143                             foreach (var tag in cacheItem.Tags) {
144
145                                 tagCache.Tag(tag, _cacheKey);
146
147                             }
148
149                         }
150
151                     }
152
153                     finally {
154
155                         // Always release the cache key lock when the request ends.
156
157                         ReleaseCacheKeyLock();
158
159                     }
160
161                 };
162
163
164
165                 captureHandlerIsAttached = true;
166
167             }
168
169             finally {
170
171                 // If the response filter stream capture handler was attached then we'll trust
172
173                 // it to release the cache key lock at some point in the future when the stream
174
175                 // is flushed; otherwise we'll make sure we'll release it here.
176
177                 if (!captureHandlerIsAttached)
178
179                     ReleaseCacheKeyLock();
180
181             }
182
183         }