Fixed serious concurrency issue.

DevTrends · DevTrends · commit 38752fa9b933 · 2012-01-24T12:27:01.000Z
Allowed use in Medium Trust.
diff --git a/DevTrends.MvcDonutCaching/CacheSettingsManager.cs b/DevTrends.MvcDonutCaching/CacheSettingsManager.cs
@@ -1,4 +1,6 @@
 ﻿using System.Configuration;
+using System.Diagnostics;
+using System.Security;
 using System.Web;
 using System.Web.Configuration;
 
@@ -11,7 +13,16 @@ public class CacheSettingsManager : ICacheSettingsManager
 
         public CacheSettingsManager()
         {
-            _outputCacheSection = (OutputCacheSection)ConfigurationManager.GetSection("system.web/caching/outputCache");
+            try
+            {
+                _outputCacheSection = (OutputCacheSection)ConfigurationManager.GetSection("system.web/caching/outputCache");
+            }
+            catch (SecurityException)
+            {
+                Debug.WriteLine("MvcDonutCaching does not have permission to read web.config section. Using default provider.");
+                _outputCacheSection = new OutputCacheSection { DefaultProviderName = AspnetInternalProviderName, EnableOutputCache = true };
+            }
+            
         }
 
         public string RetrieveOutputCacheProviderType()
diff --git a/DevTrends.MvcDonutCaching/DonutOutputCacheAttribute.cs b/DevTrends.MvcDonutCaching/DonutOutputCacheAttribute.cs
@@ -1,25 +1,22 @@
 ﻿using System;
 using System.Globalization;
 using System.IO;
+using System.Web;
 using System.Web.Mvc;
 using System.Web.UI;
-using System.Web;
 
 namespace DevTrends.MvcDonutCaching
 {
     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
     public class DonutOutputCacheAttribute : ActionFilterAttribute, IExceptionFilter
     {
-        private const string CallbackKey = "d0nutCallback";
-
         private readonly IKeyGenerator _keyGenerator;
         private readonly IDonutHoleFiller _donutHoleFiller;
         private readonly IExtendedOutputCacheManager _outputCacheManager;
         private readonly ICacheSettingsManager _cacheSettingsManager;
         private readonly ICacheHeadersHelper _cacheHeadersHelper;
 
         private CacheSettings _cacheSettings;
-        private string _cacheKey;
 
         public int Duration { get; set; }
         public string VaryByParam { get; set; }
@@ -45,11 +42,11 @@ public override void OnActionExecuting(ActionExecutingContext filterContext)
         {
             _cacheSettings = BuildCacheSettings();
 
+            var cacheKey = _keyGenerator.GenerateKey(filterContext, _cacheSettings);
+
             if (_cacheSettings.IsServerCachingEnabled)
             {
-                _cacheKey = _keyGenerator.GenerateKey(filterContext, _cacheSettings);
-
-                var cachedItem = _outputCacheManager.GetItem(_cacheKey);
+                var cachedItem = _outputCacheManager.GetItem(cacheKey);
 
                 if (cachedItem != null)
                 {
@@ -63,17 +60,15 @@ public override void OnActionExecuting(ActionExecutingContext filterContext)
 
             if (filterContext.Result == null)
             {
-                var callbackKey = BuildCallbackKey(filterContext);
-
                 var cachingWriter = new StringWriter(CultureInfo.InvariantCulture);
 
                 var originalWriter = filterContext.HttpContext.Response.Output;
 
                 filterContext.HttpContext.Response.Output = cachingWriter;
 
-                filterContext.HttpContext.Items[callbackKey] = new Action<bool>(hasErrors =>
+                filterContext.HttpContext.Items[cacheKey] = new Action<bool>(hasErrors =>
                 {
-                    filterContext.HttpContext.Items.Remove(callbackKey);
+                    filterContext.HttpContext.Items.Remove(cacheKey);
 
                     filterContext.HttpContext.Response.Output = originalWriter;
 
@@ -89,7 +84,7 @@ public override void OnActionExecuting(ActionExecutingContext filterContext)
 
                         if (_cacheSettings.IsServerCachingEnabled && filterContext.HttpContext.Response.StatusCode == 200)
                         {
-                            _outputCacheManager.AddItem(_cacheKey, cacheItem, DateTime.Now.AddSeconds(_cacheSettings.Duration));
+                            _outputCacheManager.AddItem(cacheKey, cacheItem, DateTime.Now.AddSeconds(_cacheSettings.Duration));
                         }
                     }
                 });
@@ -113,24 +108,16 @@ public void OnException(ExceptionContext filterContext)
 
         private void ExecuteCallback(ControllerContext context, bool hasErrors)
         {
-            var callbackKey = BuildCallbackKey(context);
+            var cacheKey = _keyGenerator.GenerateKey(context, _cacheSettings);
 
-            var callback = context.HttpContext.Items[callbackKey] as Action<bool>;
+            var callback = context.HttpContext.Items[cacheKey] as Action<bool>;
 
             if (callback != null)
             {
                 callback.Invoke(hasErrors);
             }
         }
 
-        private string BuildCallbackKey(ControllerContext context)
-        {
-            var actionName = context.RouteData.Values["action"].ToString();
-            var controllerName = context.RouteData.Values["controller"].ToString();
-
-            return string.Format("{0}.{1}.{2}", CallbackKey, controllerName, actionName);
-        }
-        
         private CacheSettings BuildCacheSettings()
         {
             CacheSettings cacheSettings;
diff --git a/DevTrends.MvcDonutCaching/Properties/AssemblyInfo.cs b/DevTrends.MvcDonutCaching/Properties/AssemblyInfo.cs
@@ -11,5 +11,5 @@
 [assembly: AssemblyCulture("")]
 [assembly: ComVisible(false)]
 [assembly: Guid("ebcc3291-f04a-4511-b7eb-ddf57a74ada9")]
-[assembly: AssemblyVersion("1.1.0")]
-[assembly: AssemblyFileVersion("1.1.0")]
+[assembly: AssemblyVersion("1.1.1")]
+[assembly: AssemblyFileVersion("1.1.1")]
diff --git a/nuget/Build.bat b/nuget/Build.bat
@@ -0,0 +1,3 @@
+nuget pack
+
+pause
diff --git a/nuget/MvcDonutCaching.nuspec b/nuget/MvcDonutCaching.nuspec
@@ -0,0 +1,14 @@
+<?xml version="1.0"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
+  <metadata>
+    <id>MvcDonutCaching</id>
+    <version>1.1.1</version>
+    <authors>Paul Hiles</authors>
+    <owners>DevTrends</owners>
+    <licenseUrl>http://mvcdonutcaching.codeplex.com/license</licenseUrl>
+    <projectUrl>http://mvcdonutcaching.codeplex.com/</projectUrl>
+    <requireLicenseAcceptance>false</requireLicenseAcceptance>
+    <description>MvcDonutCaching provides extensible donut output caching for ASP.NET MVC 3 and above.</description>
+    <tags>mvc3 donut caching mvc outputcaching substitution</tags>
+  </metadata>
+</package>
diff --git a/nuget/content/DevTrends.MvcDonutCaching.README.txt b/nuget/content/DevTrends.MvcDonutCaching.README.txt
@@ -0,0 +1,6 @@
+Getting started with DevTrends.MvcDonutCaching
+----------------------------------------------
+
+Find out how to use DevTrends.MvcDonutCaching by visiting http://mvcdonutcaching.codeplex.com/
+
+Please report all bugs and feature requests on CodePlex.
diff --git a/nuget/content/Views/web.config.transform b/nuget/content/Views/web.config.transform
@@ -0,0 +1,9 @@
+<configuration>
+    <system.web.webPages.razor>
+        <pages>
+			<namespaces>
+				<add namespace="DevTrends.MvcDonutCaching" />
+			</namespaces>            
+        </pages>
+    </system.web.webPages.razor>
+</configuration>
diff --git a/nuget/lib/DevTrends.MvcDonutCaching.dll b/nuget/lib/DevTrends.MvcDonutCaching.dll

Original file line number	Diff line number	Diff line change
`@@ -1,25 +1,22 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Globalization;`
`3`	`3`	`using System.IO;`
	`4`	`+using System.Web;`
`4`	`5`	`using System.Web.Mvc;`
`5`	`6`	`using System.Web.UI;`
`6`		`-using System.Web;`
`7`	`7`
`8`	`8`	`namespace DevTrends.MvcDonutCaching`
`9`	`9`	`{`
`10`	`10`	`[AttributeUsage(AttributeTargets.Class \| AttributeTargets.Method, Inherited = true, AllowMultiple = false)]`
`11`	`11`	`public class DonutOutputCacheAttribute : ActionFilterAttribute, IExceptionFilter`
`12`	`12`	`{`
`13`		`- private const string CallbackKey = "d0nutCallback";`
`14`		`-`
`15`	`13`	`private readonly IKeyGenerator _keyGenerator;`
`16`	`14`	`private readonly IDonutHoleFiller _donutHoleFiller;`
`17`	`15`	`private readonly IExtendedOutputCacheManager _outputCacheManager;`
`18`	`16`	`private readonly ICacheSettingsManager _cacheSettingsManager;`
`19`	`17`	`private readonly ICacheHeadersHelper _cacheHeadersHelper;`
`20`	`18`
`21`	`19`	`private CacheSettings _cacheSettings;`
`22`		`- private string _cacheKey;`
`23`	`20`
`24`	`21`	`public int Duration { get; set; }`
`25`	`22`	`public string VaryByParam { get; set; }`
`@@ -45,11 +42,11 @@ public override void OnActionExecuting(ActionExecutingContext filterContext)`
`45`	`42`	`{`
`46`	`43`	`_cacheSettings = BuildCacheSettings();`
`47`	`44`
	`45`	`+ var cacheKey = _keyGenerator.GenerateKey(filterContext, _cacheSettings);`
	`46`	`+`
`48`	`47`	`if (_cacheSettings.IsServerCachingEnabled)`
`49`	`48`	`{`
`50`		`- _cacheKey = _keyGenerator.GenerateKey(filterContext, _cacheSettings);`
`51`		`-`
`52`		`- var cachedItem = _outputCacheManager.GetItem(_cacheKey);`
	`49`	`+ var cachedItem = _outputCacheManager.GetItem(cacheKey);`
`53`	`50`
`54`	`51`	`if (cachedItem != null)`
`55`	`52`	`{`
`@@ -63,17 +60,15 @@ public override void OnActionExecuting(ActionExecutingContext filterContext)`
`63`	`60`
`64`	`61`	`if (filterContext.Result == null)`
`65`	`62`	`{`
`66`		`- var callbackKey = BuildCallbackKey(filterContext);`
`67`		`-`
`68`	`63`	`var cachingWriter = new StringWriter(CultureInfo.InvariantCulture);`
`69`	`64`
`70`	`65`	`var originalWriter = filterContext.HttpContext.Response.Output;`
`71`	`66`
`72`	`67`	`filterContext.HttpContext.Response.Output = cachingWriter;`
`73`	`68`
`74`		`- filterContext.HttpContext.Items[callbackKey] = new Action<bool>(hasErrors =>`
	`69`	`+ filterContext.HttpContext.Items[cacheKey] = new Action<bool>(hasErrors =>`
`75`	`70`	`{`
`76`		`- filterContext.HttpContext.Items.Remove(callbackKey);`
	`71`	`+ filterContext.HttpContext.Items.Remove(cacheKey);`
`77`	`72`
`78`	`73`	`filterContext.HttpContext.Response.Output = originalWriter;`
`79`	`74`
`@@ -89,7 +84,7 @@ public override void OnActionExecuting(ActionExecutingContext filterContext)`
`89`	`84`
`90`	`85`	`if (_cacheSettings.IsServerCachingEnabled && filterContext.HttpContext.Response.StatusCode == 200)`
`91`	`86`	`{`
`92`		`- _outputCacheManager.AddItem(_cacheKey, cacheItem, DateTime.Now.AddSeconds(_cacheSettings.Duration));`
	`87`	`+ _outputCacheManager.AddItem(cacheKey, cacheItem, DateTime.Now.AddSeconds(_cacheSettings.Duration));`
`93`	`88`	`}`
`94`	`89`	`}`
`95`	`90`	`});`
`@@ -113,24 +108,16 @@ public void OnException(ExceptionContext filterContext)`
`113`	`108`
`114`	`109`	`private void ExecuteCallback(ControllerContext context, bool hasErrors)`
`115`	`110`	`{`
`116`		`- var callbackKey = BuildCallbackKey(context);`
	`111`	`+ var cacheKey = _keyGenerator.GenerateKey(context, _cacheSettings);`
`117`	`112`
`118`		`- var callback = context.HttpContext.Items[callbackKey] as Action<bool>;`
	`113`	`+ var callback = context.HttpContext.Items[cacheKey] as Action<bool>;`
`119`	`114`
`120`	`115`	`if (callback != null)`
`121`	`116`	`{`
`122`	`117`	`callback.Invoke(hasErrors);`
`123`	`118`	`}`
`124`	`119`	`}`
`125`	`120`
`126`		`- private string BuildCallbackKey(ControllerContext context)`
`127`		`- {`
`128`		`- var actionName = context.RouteData.Values["action"].ToString();`
`129`		`- var controllerName = context.RouteData.Values["controller"].ToString();`
`130`		`-`
`131`		`- return string.Format("{0}.{1}.{2}", CallbackKey, controllerName, actionName);`
`132`		`- }`
`133`		`-`
`134`	`121`	`private CacheSettings BuildCacheSettings()`
`135`	`122`	`{`
`136`	`123`	`CacheSettings cacheSettings;`