Support cache implementations having a max key length

Author: fredericDelaporte

CoreDistributedCache/NHibernate.Caches.CoreDistributedCache.Memory/MemoryFactory.cs

@@ -111,6 +111,9 @@ public IDistributedCache BuildCache()
 			return _cache;
 		}
 
+		/// <inheritdoc />
+		public int? MaxKeySize => null;
+
 		private class Options : MemoryDistributedCacheOptions, IOptions<MemoryDistributedCacheOptions>
 		{
 			MemoryDistributedCacheOptions IOptions<MemoryDistributedCacheOptions>.Value => this;

CoreDistributedCache/NHibernate.Caches.CoreDistributedCache.Redis/RedisFactory.cs

@@ -62,6 +62,9 @@ public RedisFactory(IDictionary<string, string> properties)
 				Log.Info("No {0} property provided", _instanceName);
 		}
 
+		/// <inheritdoc />
+		public int? MaxKeySize => null;
+
 		/// <inheritdoc />
 		public IDistributedCache BuildCache()
 		{

CoreDistributedCache/NHibernate.Caches.CoreDistributedCache.SqlServer/SqlServerFactory.cs

@@ -98,6 +98,9 @@ public SqlServerFactory(IDictionary<string, string> properties)
 			}
 		}
 
+		/// <inheritdoc />
+		public int? MaxKeySize => 449;
+
 		/// <inheritdoc />
 		public IDistributedCache BuildCache()
 		{

CoreDistributedCache/NHibernate.Caches.CoreDistributedCache.Tests/Async/CoreDistributedCacheFixture.cs

@@ -0,0 +1,59 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by AsyncGenerator.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+
+#region License
+
+//
+//  CoreDistributedCache - A cache provider for NHibernate using Microsoft.Extensions.Caching.Distributed.IDistributedCache.
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+
+#endregion
+
+using System;
+using System.Collections.Generic;
+using Microsoft.Extensions.Caching.Distributed;
+using NHibernate.Cache;
+using NHibernate.Caches.Common.Tests;
+using NUnit.Framework;
+using NSubstitute;
+
+namespace NHibernate.Caches.CoreDistributedCache.Tests
+{
+	using System.Threading.Tasks;
+	using System.Threading;
+	public partial class CoreDistributedCacheFixture : CacheFixture
+	{
+
+		[Test]
+		public async Task MaxKeySizeAsync()
+		{
+			var distribCache = Substitute.For<IDistributedCache>();
+			const int maxLength = 20;
+			var cache = new CoreDistributedCache(distribCache, maxLength, "foo", new Dictionary<string, string>());
+			await (cache.PutAsync(new string('k', maxLength * 2), "test", CancellationToken.None));
+			await (distribCache.Received().SetAsync(Arg.Is<string>(k => k.Length <= maxLength), Arg.Any<byte[]>(),
+				Arg.Any<DistributedCacheEntryOptions>()));
+		}
+	}
+}

CoreDistributedCache/NHibernate.Caches.CoreDistributedCache.Tests/CoreDistributedCacheFixture.cs

@@ -21,19 +21,33 @@
 #endregion
 
 using System;
+using System.Collections.Generic;
+using Microsoft.Extensions.Caching.Distributed;
 using NHibernate.Cache;
 using NHibernate.Caches.Common.Tests;
 using NUnit.Framework;
+using NSubstitute;
 
 namespace NHibernate.Caches.CoreDistributedCache.Tests
 {
 	[TestFixture]
-	public class CoreDistributedCacheFixture : CacheFixture
+	public partial class CoreDistributedCacheFixture : CacheFixture
 	{
 		protected override bool SupportsSlidingExpiration => true;
 		protected override bool SupportsClear => false;
 
 		protected override Func<ICacheProvider> ProviderBuilder =>
 			() => new CoreDistributedCacheProvider();
+
+		[Test]
+		public void MaxKeySize()
+		{
+			var distribCache = Substitute.For<IDistributedCache>();
+			const int maxLength = 20;
+			var cache = new CoreDistributedCache(distribCache, maxLength, "foo", new Dictionary<string, string>());
+			cache.Put(new string('k', maxLength * 2), "test");
+			distribCache.Received().Set(Arg.Is<string>(k => k.Length <= maxLength), Arg.Any<byte[]>(),
+				Arg.Any<DistributedCacheEntryOptions>());
+		}
 	}
 }

CoreDistributedCache/NHibernate.Caches.CoreDistributedCache.Tests/NHibernate.Caches.CoreDistributedCache.Tests.csproj

@@ -23,6 +23,7 @@
   <ItemGroup>
     <PackageReference Include="log4net" Version="2.0.8" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.6.1" />
+    <PackageReference Include="NSubstitute" Version="3.1.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.9.0" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFramework)'=='netcoreapp2.0'">

CoreDistributedCache/NHibernate.Caches.CoreDistributedCache.Tests/TestsContext.cs

@@ -1,6 +1,7 @@
-#if !NETFX
-using log4net.Repository.Hierarchy;
+using log4net.Repository.Hierarchy;
+#if !NETFX
 using NHibernate.Caches.Common.Tests;
+#endif
 using NUnit.Framework;
 
 namespace NHibernate.Caches.CoreDistributedCache.Tests
@@ -11,20 +12,19 @@ public class TestsContext
 		[OneTimeSetUp]
 		public void RunBeforeAnyTests()
 		{
+#if !NETFX
 			TestsContextHelper.RunBeforeAnyTests(typeof(TestsContext).Assembly, "coredistributedcache");
-			//When .NET Core App 2.0 tests run from VS/VSTest the entry assembly is "testhost.dll"
-			//so we need to explicitly load the configuration
-			if (TestsContextHelper.ExecutingWithVsTest)
-			{
-				ConfigureLog4Net();
-			}
+#endif
+			ConfigureLog4Net();
 		}
 
+#if !NETFX
 		[OneTimeTearDown]
 		public void RunAfterAnyTests()
 		{
 			TestsContextHelper.RunAfterAnyTests();
 		}
+#endif
 
 		private static void ConfigureLog4Net()
 		{
@@ -40,4 +40,3 @@ private static void ConfigureLog4Net()
 		}
 	}
 }
-#endif

CoreDistributedCache/NHibernate.Caches.CoreDistributedCache/Async/CoreDistributedCache.cs

@@ -13,6 +13,8 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Runtime.Serialization.Formatters.Binary;
+using System.Security.Cryptography;
+using System.Text;
 using Microsoft.Extensions.Caching.Distributed;
 using NHibernate.Util;
 

CoreDistributedCache/NHibernate.Caches.CoreDistributedCache/CoreDistributedCache.cs

@@ -25,6 +25,8 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Runtime.Serialization.Formatters.Binary;
+using System.Security.Cryptography;
+using System.Text;
 using Microsoft.Extensions.Caching.Distributed;
 using NHibernate.Util;
 
@@ -44,18 +46,21 @@ public partial class CoreDistributedCache : ICache
 		private static readonly INHibernateLogger Log = NHibernateLogger.For(typeof(CoreDistributedCache));
 
 		private readonly IDistributedCache _cache;
+		private readonly int? _maxKeySize;
 
 		private static readonly TimeSpan DefaultExpiration = TimeSpan.FromSeconds(300);
 		private const bool _defaultUseSlidingExpiration = false;
 		private static readonly string DefaultRegionPrefix = string.Empty;
 		private const string _cacheKeyPrefix = "NHibernate-Cache:";
 
 		private string _fullRegion;
+		private bool _hasWarnedOnHashLength;
 
 		/// <summary>
 		/// Default constructor.
 		/// </summary>
 		/// <param name="cache">The <see cref="IDistributedCache"/> instance to use.</param>
+		/// <param name="maxKeySize">If key size is limited, the maximal key size.</param>
 		/// <param name="region">The region of the cache.</param>
 		/// <param name="properties">Cache configuration properties.</param>
 		/// <remarks>
@@ -68,9 +73,13 @@ public partial class CoreDistributedCache : ICache
 		/// All parameters are optional. The defaults are an expiration of 300 seconds, no sliding expiration and no prefix.
 		/// </remarks>
 		/// <exception cref="ArgumentException">The "expiration" property could not be parsed.</exception>
-		public CoreDistributedCache(IDistributedCache cache, string region, IDictionary<string, string> properties)
+		public CoreDistributedCache(
+			IDistributedCache cache, int? maxKeySize, string region, IDictionary<string, string> properties)
 		{
+			if (maxKeySize.HasValue && maxKeySize <= 0)
+				throw new ArgumentException($"{nameof(maxKeySize)} must be null or superior to 1.", nameof(maxKeySize));
 			_cache = cache;
+			_maxKeySize = maxKeySize;
 			RegionName = region;
 			Configure(properties);
 		}
@@ -161,7 +170,35 @@ private static bool GetUseSlidingExpiration(IDictionary<string, string> props)
 
 		private string GetCacheKey(object key)
 		{
-			return string.Concat(_cacheKeyPrefix, _fullRegion, ":", key.ToString(), "@", key.GetHashCode());
+			var keyAsString = string.Concat(_cacheKeyPrefix, _fullRegion, ":", key.ToString(), "@", key.GetHashCode());
+			if (!_maxKeySize.HasValue || _maxKeySize >= keyAsString.Length)
+				return keyAsString;
+
+			Log.Info(
+				"Computing a hashed key for too long key '{0}'. This may cause collisions resulting into additional cache misses.",
+				key);
+			// Hash it for respecting max key size. Collisions will be avoided by storing the actual key along
+			// the object and comparing it on retrieval.
+			using (var hasher = new SHA256Managed())
+			{
+				var bytes = Encoding.UTF8.GetBytes(keyAsString);
+				var computedHash = Convert.ToBase64String(hasher.ComputeHash(bytes));
+				if (computedHash.Length <= _maxKeySize)
+					return computedHash;
+
+				if (!_hasWarnedOnHashLength)
+				{
+					// No lock for this field, some redundant logs will be less harm than locking.
+					_hasWarnedOnHashLength = true;
+					Log.Warn(
+						"Hash computed for too long keys are themselves too long. They will be truncated, further " +
+						"increasing the risk of collision resulting into additional cache misses. Consider using a " +
+						"cache supporting longer keys. Hash length: {0}; max key size: {1}",
+						computedHash.Length, _maxKeySize);
+				}
+
+				return computedHash.Substring(0, _maxKeySize.Value);
+			}
 		}
 
 		/// <inheritdoc />

CoreDistributedCache/NHibernate.Caches.CoreDistributedCache/CoreDistributedCacheProvider.cs

@@ -138,7 +138,7 @@ public ICache BuildCache(string regionName, IDictionary<string, string> properti
 
 				Log.Debug("building cache with region: {0}, properties: {1}, factory: {2}" , regionName, sb.ToString(), CacheFactory.GetType().FullName);
 			}
-			return new CoreDistributedCache(CacheFactory.BuildCache(), regionName, properties);
+			return new CoreDistributedCache(CacheFactory.BuildCache(), CacheFactory.MaxKeySize, regionName, properties);
 		}
 
 		/// <inheritdoc />