Upgrade StackExchange.Redis to v2.6.122 (#258)

Turnerj · web-flow · commit 0ee67956f53e · 2023-08-10T22:57:59.000+09:30
diff --git a/CacheTower.sln b/CacheTower.sln
@@ -45,7 +45,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CacheTower.Serializers.Newt
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CacheTower.Serializers.Protobuf", "src\CacheTower.Serializers.Protobuf\CacheTower.Serializers.Protobuf.csproj", "{436A6DF0-3DD8-4342-ACC5-EF0B8D5DF9DD}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CacheTower.Serializers.SystemTextJson", "src\CacheTower.Serializers.SystemTextJson\CacheTower.Serializers.SystemTextJson.csproj", "{4E94E3E8-3CC0-4F23-BFD7-157C8C386AFB}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CacheTower.Serializers.SystemTextJson", "src\CacheTower.Serializers.SystemTextJson\CacheTower.Serializers.SystemTextJson.csproj", "{4E94E3E8-3CC0-4F23-BFD7-157C8C386AFB}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
diff --git a/src/CacheTower.Extensions.Redis/CacheTower.Extensions.Redis.csproj b/src/CacheTower.Extensions.Redis/CacheTower.Extensions.Redis.csproj
@@ -9,7 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="StackExchange.Redis" Version="2.6.116" />
+    <PackageReference Include="StackExchange.Redis" Version="2.6.122" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/CacheTower.Extensions.Redis/RedisLockExtension.cs b/src/CacheTower.Extensions.Redis/RedisLockExtension.cs
@@ -45,7 +45,7 @@ public RedisLockExtension(IConnectionMultiplexer connection, RedisLockOptions op
 
 		LockedOnKeyRefresh = new ConcurrentDictionary<string, TaskCompletionSource<bool>>(StringComparer.Ordinal);
 
-		Subscriber.Subscribe(options.RedisChannel, (channel, value) =>
+		Subscriber.Subscribe(GetRedisChannel(), (channel, value) =>
 		{
 			if (!value.IsNull)
 			{
@@ -54,6 +54,8 @@ public RedisLockExtension(IConnectionMultiplexer connection, RedisLockOptions op
 		});
 	}
 
+	private RedisChannel GetRedisChannel() => new(Options.RedisChannel, RedisChannel.PatternMode.Auto);
+
 	/// <inheritdoc/>
 	public void Register(ICacheStack cacheStack)
 	{
@@ -68,7 +70,7 @@ public void Register(ICacheStack cacheStack)
 	private async ValueTask ReleaseLockAsync(string cacheKey)
 	{
 		var lockKey = string.Format(Options.KeyFormat, cacheKey);
-		await Subscriber.PublishAsync(Options.RedisChannel, cacheKey, CommandFlags.FireAndForget);
+		await Subscriber.PublishAsync(GetRedisChannel(), cacheKey, CommandFlags.FireAndForget);
 		await Database.KeyDeleteAsync(lockKey, CommandFlags.FireAndForget);
 		UnlockWaitingTasks(cacheKey);
 	}
diff --git a/src/CacheTower.Extensions.Redis/RedisRemoteEvictionExtension.cs b/src/CacheTower.Extensions.Redis/RedisRemoteEvictionExtension.cs
@@ -12,8 +12,8 @@ namespace CacheTower.Extensions.Redis
 	public class RedisRemoteEvictionExtension : ICacheChangeExtension
 	{
 		private ISubscriber Subscriber { get; }
-		private string FlushChannel { get; }
-		private string EvictionChannel { get; }
+		private RedisChannel FlushChannel { get; }
+		private RedisChannel EvictionChannel { get; }
 
 		private bool IsRegistered { get; set; }
 
@@ -39,8 +39,8 @@ public RedisRemoteEvictionExtension(IConnectionMultiplexer connection, string ch
 			}
 
 			Subscriber = connection.GetSubscriber();
-			FlushChannel = $"{channelPrefix}.RemoteFlush";
-			EvictionChannel = $"{channelPrefix}.RemoteEviction";
+			FlushChannel = new($"{channelPrefix}.RemoteFlush", RedisChannel.PatternMode.Auto);
+			EvictionChannel = new($"{channelPrefix}.RemoteEviction", RedisChannel.PatternMode.Auto);
 			FlaggedEvictions = new HashSet<string>(StringComparer.Ordinal);
 		}
 
diff --git a/src/CacheTower.Providers.Redis/CacheTower.Providers.Redis.csproj b/src/CacheTower.Providers.Redis/CacheTower.Providers.Redis.csproj
@@ -9,7 +9,7 @@
 	</PropertyGroup>
 
 	<ItemGroup>
-		<PackageReference Include="StackExchange.Redis" Version="2.6.116" />
+		<PackageReference Include="StackExchange.Redis" Version="2.6.122" />
 	</ItemGroup>
 
 	<ItemGroup>
diff --git a/src/CacheTower.Providers.Redis/RedisCacheLayer.cs b/src/CacheTower.Providers.Redis/RedisCacheLayer.cs
@@ -75,10 +75,8 @@ public async ValueTask FlushAsync()
 			var redisValue = await Database.StringGetAsync(cacheKey);
 			if (redisValue != RedisValue.Null)
 			{
-				using (var stream = new MemoryStream(redisValue))
-				{
-					return Options.Serializer.Deserialize<CacheEntry<T>>(stream);
-				}
+				using var stream = new MemoryStream(redisValue);
+				return Options.Serializer.Deserialize<CacheEntry<T>>(stream);
 			}
 
 			return default;
@@ -99,13 +97,11 @@ public async ValueTask SetAsync<T>(string cacheKey, CacheEntry<T> cacheEntry)
 				return;
 			}
 
-			using (var stream = new MemoryStream())
-			{
-				Options.Serializer.Serialize(stream, cacheEntry);
-				stream.Seek(0, SeekOrigin.Begin);
-				var redisValue = RedisValue.CreateFrom(stream);
-				await Database.StringSetAsync(cacheKey, redisValue, expiryOffset);
-			}
+			using var stream = new MemoryStream();
+			Options.Serializer.Serialize(stream, cacheEntry);
+			stream.Seek(0, SeekOrigin.Begin);
+			var redisValue = RedisValue.CreateFrom(stream);
+			await Database.StringSetAsync(cacheKey, redisValue, expiryOffset);
 		}
 	}
 }
diff --git a/tests/CacheTower.Tests/Extensions/Redis/RedisLockExtensionTests.cs b/tests/CacheTower.Tests/Extensions/Redis/RedisLockExtensionTests.cs
@@ -74,7 +74,7 @@ public async Task RefreshValueNotifiesChannelSubscribers()
 
 		var completionSource = new TaskCompletionSource<bool>();
 
-		await connection.GetSubscriber().SubscribeAsync("CacheTower.CacheLock", (channel, value) =>
+		await connection.GetSubscriber().SubscribeAsync(new("CacheTower.CacheLock", RedisChannel.PatternMode.Literal), (channel, value) =>
 		{
 			if (value == "TestKey")
 			{
@@ -126,7 +126,7 @@ public async Task ObservedLockSingle()
 		Assert.IsTrue(extension.LockedOnKeyRefresh.ContainsKey("TestKey"), "Lock was not established");
 
 		//Trigger the end of the lock
-		await connection.GetSubscriber().PublishAsync("CacheTower.CacheLock", "TestKey");
+		await connection.GetSubscriber().PublishAsync(new("CacheTower.CacheLock", RedisChannel.PatternMode.Literal), "TestKey");
 
 		var succeedingTask = await Task.WhenAny(lockTask, Task.Delay(TimeSpan.FromSeconds(10)));
 		if (!succeedingTask.Equals(lockTask))
@@ -160,7 +160,7 @@ public async Task ObservedLockMultiple()
 		Assert.IsTrue(extension.LockedOnKeyRefresh.ContainsKey("TestKey"), "Lock was not established");
 
 		//Trigger the end of the lock
-		await connection.GetSubscriber().PublishAsync("CacheTower.CacheLock", "TestKey");
+		await connection.GetSubscriber().PublishAsync(new("CacheTower.CacheLock", RedisChannel.PatternMode.Literal), "TestKey");
 
 		var whenAllRefreshesTask = Task.WhenAll(lockTask1, lockTask2);
 		var succeedingTask = await Task.WhenAny(whenAllRefreshesTask, Task.Delay(TimeSpan.FromSeconds(10)));
diff --git a/tests/CacheTower.Tests/Extensions/Redis/RedisRemoteEvictionExtensionTests.cs b/tests/CacheTower.Tests/Extensions/Redis/RedisRemoteEvictionExtensionTests.cs
@@ -60,7 +60,7 @@ public async Task RemoteEvictionOccursOnRefresh()
 			extensionTwo.Register(cacheStackMockTwo);
 
 			var completionSource = new TaskCompletionSource<bool>();
-			connection.GetSubscriber().Subscribe("CacheTower.RemoteEviction").OnMessage(channelMessage =>
+			connection.GetSubscriber().Subscribe(new("CacheTower.RemoteEviction", RedisChannel.PatternMode.Literal)).OnMessage(channelMessage =>
 			{
 				if (channelMessage.Message == "TestKey")
 				{
@@ -111,7 +111,7 @@ public async Task RemoteEvictionOccursOnLocalEviction()
 			extensionTwo.Register(cacheStackMockTwo);
 
 			var completionSource = new TaskCompletionSource<bool>();
-			connection.GetSubscriber().Subscribe("CacheTower.RemoteEviction").OnMessage(channelMessage =>
+			connection.GetSubscriber().Subscribe(new("CacheTower.RemoteEviction", RedisChannel.PatternMode.Literal)).OnMessage(channelMessage =>
 			{
 				if (channelMessage.Message == "TestKey")
 				{
@@ -166,7 +166,7 @@ public async Task RemoteFlush()
 			extensionTwo.Register(cacheStackMockTwo);
 
 			var completionSource = new TaskCompletionSource<bool>();
-			connection.GetSubscriber().Subscribe("CacheTower.RemoteFlush").OnMessage(channelMessage =>
+			connection.GetSubscriber().Subscribe(new("CacheTower.RemoteFlush", RedisChannel.PatternMode.Literal)).OnMessage(channelMessage =>
 			{
 				if (channelMessage.Message == StackExchange.Redis.RedisValue.EmptyString)
 				{
@@ -210,9 +210,9 @@ public async Task NoEvictionOnNewEntries()
 			var subscriberMock = Substitute.For<ISubscriber>();
 
 			subscriberMock.Subscribe(Arg.Any<RedisChannel>(), Arg.Any<CommandFlags>())
-				.Returns(x => realConnection.GetSubscriber().Subscribe("DummyMessageQueue"));
+				.Returns(x => realConnection.GetSubscriber().Subscribe(new("DummyMessageQueue", RedisChannel.PatternMode.Literal)));
 			subscriberMock.Subscribe(Arg.Any<RedisChannel>(), Arg.Any<CommandFlags>())
-				.Returns(x => realConnection.GetSubscriber().Subscribe("DummyMessageQueue"));
+				.Returns(x => realConnection.GetSubscriber().Subscribe(new("DummyMessageQueue", RedisChannel.PatternMode.Literal)));
 			connectionMock.GetSubscriber(Arg.Any<object>())
 				.Returns(subscriberMock);
 
@@ -222,7 +222,7 @@ public async Task NoEvictionOnNewEntries()
 
 			await cacheStackOne.GetOrSetAsync<int>("NoEvictionOnNewEntries", _ => Task.FromResult(1), new CacheSettings(TimeSpan.FromMinutes(5)));
 
-			await subscriberMock.DidNotReceive().PublishAsync("CacheTower.RemoteEviction", Arg.Any<RedisValue>(), Arg.Any<CommandFlags>());
+			await subscriberMock.DidNotReceive().PublishAsync(new("CacheTower.RemoteEviction", RedisChannel.PatternMode.Literal), Arg.Any<RedisValue>(), Arg.Any<CommandFlags>());
 		}
 	}
 }

Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ public RedisLockExtension(IConnectionMultiplexer connection, RedisLockOptions op`
`45`	`45`
`46`	`46`	`LockedOnKeyRefresh = new ConcurrentDictionary<string, TaskCompletionSource<bool>>(StringComparer.Ordinal);`
`47`	`47`
`48`		`- Subscriber.Subscribe(options.RedisChannel, (channel, value) =>`
	`48`	`+ Subscriber.Subscribe(GetRedisChannel(), (channel, value) =>`
`49`	`49`	`{`
`50`	`50`	`if (!value.IsNull)`
`51`	`51`	`{`
`@@ -54,6 +54,8 @@ public RedisLockExtension(IConnectionMultiplexer connection, RedisLockOptions op`
`54`	`54`	`});`
`55`	`55`	`}`
`56`	`56`
	`57`	`+ private RedisChannel GetRedisChannel() => new(Options.RedisChannel, RedisChannel.PatternMode.Auto);`
	`58`	`+`
`57`	`59`	`/// <inheritdoc/>`
`58`	`60`	`public void Register(ICacheStack cacheStack)`
`59`	`61`	`{`
`@@ -68,7 +70,7 @@ public void Register(ICacheStack cacheStack)`
`68`	`70`	`private async ValueTask ReleaseLockAsync(string cacheKey)`
`69`	`71`	`{`
`70`	`72`	`var lockKey = string.Format(Options.KeyFormat, cacheKey);`
`71`		`- await Subscriber.PublishAsync(Options.RedisChannel, cacheKey, CommandFlags.FireAndForget);`
	`73`	`+ await Subscriber.PublishAsync(GetRedisChannel(), cacheKey, CommandFlags.FireAndForget);`
`72`	`74`	`await Database.KeyDeleteAsync(lockKey, CommandFlags.FireAndForget);`
`73`	`75`	`UnlockWaitingTasks(cacheKey);`
`74`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,8 +12,8 @@ namespace CacheTower.Extensions.Redis`
`12`	`12`	`public class RedisRemoteEvictionExtension : ICacheChangeExtension`
`13`	`13`	`{`
`14`	`14`	`private ISubscriber Subscriber { get; }`
`15`		`- private string FlushChannel { get; }`
`16`		`- private string EvictionChannel { get; }`
	`15`	`+ private RedisChannel FlushChannel { get; }`
	`16`	`+ private RedisChannel EvictionChannel { get; }`
`17`	`17`
`18`	`18`	`private bool IsRegistered { get; set; }`
`19`	`19`
`@@ -39,8 +39,8 @@ public RedisRemoteEvictionExtension(IConnectionMultiplexer connection, string ch`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`Subscriber = connection.GetSubscriber();`
`42`		`- FlushChannel = $"{channelPrefix}.RemoteFlush";`
`43`		`- EvictionChannel = $"{channelPrefix}.RemoteEviction";`
	`42`	`+ FlushChannel = new($"{channelPrefix}.RemoteFlush", RedisChannel.PatternMode.Auto);`
	`43`	`+ EvictionChannel = new($"{channelPrefix}.RemoteEviction", RedisChannel.PatternMode.Auto);`
`44`	`44`	`FlaggedEvictions = new HashSet<string>(StringComparer.Ordinal);`
`45`	`45`	`}`
`46`	`46`
Original file line number	Diff line number	Diff line change
`@@ -75,10 +75,8 @@ public async ValueTask FlushAsync()`
`75`	`75`	`var redisValue = await Database.StringGetAsync(cacheKey);`
`76`	`76`	`if (redisValue != RedisValue.Null)`
`77`	`77`	`{`
`78`		`- using (var stream = new MemoryStream(redisValue))`
`79`		`- {`
`80`		`- return Options.Serializer.Deserialize<CacheEntry<T>>(stream);`
`81`		`- }`
	`78`	`+ using var stream = new MemoryStream(redisValue);`
	`79`	`+ return Options.Serializer.Deserialize<CacheEntry<T>>(stream);`
`82`	`80`	`}`
`83`	`81`
`84`	`82`	`return default;`
`@@ -99,13 +97,11 @@ public async ValueTask SetAsync<T>(string cacheKey, CacheEntry<T> cacheEntry)`
`99`	`97`	`return;`
`100`	`98`	`}`
`101`	`99`
`102`		`- using (var stream = new MemoryStream())`
`103`		`- {`
`104`		`- Options.Serializer.Serialize(stream, cacheEntry);`
`105`		`- stream.Seek(0, SeekOrigin.Begin);`
`106`		`- var redisValue = RedisValue.CreateFrom(stream);`
`107`		`- await Database.StringSetAsync(cacheKey, redisValue, expiryOffset);`
`108`		`- }`
	`100`	`+ using var stream = new MemoryStream();`
	`101`	`+ Options.Serializer.Serialize(stream, cacheEntry);`
	`102`	`+ stream.Seek(0, SeekOrigin.Begin);`
	`103`	`+ var redisValue = RedisValue.CreateFrom(stream);`
	`104`	`+ await Database.StringSetAsync(cacheKey, redisValue, expiryOffset);`
`109`	`105`	`}`
`110`	`106`	`}`
`111`	`107`	`}`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ public async Task RemoteEvictionOccursOnRefresh()`
`60`	`60`	`extensionTwo.Register(cacheStackMockTwo);`
`61`	`61`
`62`	`62`	`var completionSource = new TaskCompletionSource<bool>();`
`63`		`- connection.GetSubscriber().Subscribe("CacheTower.RemoteEviction").OnMessage(channelMessage =>`
	`63`	`+ connection.GetSubscriber().Subscribe(new("CacheTower.RemoteEviction", RedisChannel.PatternMode.Literal)).OnMessage(channelMessage =>`
`64`	`64`	`{`
`65`	`65`	`if (channelMessage.Message == "TestKey")`
`66`	`66`	`{`
`@@ -111,7 +111,7 @@ public async Task RemoteEvictionOccursOnLocalEviction()`
`111`	`111`	`extensionTwo.Register(cacheStackMockTwo);`
`112`	`112`
`113`	`113`	`var completionSource = new TaskCompletionSource<bool>();`
`114`		`- connection.GetSubscriber().Subscribe("CacheTower.RemoteEviction").OnMessage(channelMessage =>`
	`114`	`+ connection.GetSubscriber().Subscribe(new("CacheTower.RemoteEviction", RedisChannel.PatternMode.Literal)).OnMessage(channelMessage =>`
`115`	`115`	`{`
`116`	`116`	`if (channelMessage.Message == "TestKey")`
`117`	`117`	`{`
`@@ -166,7 +166,7 @@ public async Task RemoteFlush()`
`166`	`166`	`extensionTwo.Register(cacheStackMockTwo);`
`167`	`167`
`168`	`168`	`var completionSource = new TaskCompletionSource<bool>();`
`169`		`- connection.GetSubscriber().Subscribe("CacheTower.RemoteFlush").OnMessage(channelMessage =>`
	`169`	`+ connection.GetSubscriber().Subscribe(new("CacheTower.RemoteFlush", RedisChannel.PatternMode.Literal)).OnMessage(channelMessage =>`
`170`	`170`	`{`
`171`	`171`	`if (channelMessage.Message == StackExchange.Redis.RedisValue.EmptyString)`
`172`	`172`	`{`
`@@ -210,9 +210,9 @@ public async Task NoEvictionOnNewEntries()`
`210`	`210`	`var subscriberMock = Substitute.For<ISubscriber>();`
`211`	`211`
`212`	`212`	`subscriberMock.Subscribe(Arg.Any<RedisChannel>(), Arg.Any<CommandFlags>())`
`213`		`- .Returns(x => realConnection.GetSubscriber().Subscribe("DummyMessageQueue"));`
	`213`	`+ .Returns(x => realConnection.GetSubscriber().Subscribe(new("DummyMessageQueue", RedisChannel.PatternMode.Literal)));`
`214`	`214`	`subscriberMock.Subscribe(Arg.Any<RedisChannel>(), Arg.Any<CommandFlags>())`
`215`		`- .Returns(x => realConnection.GetSubscriber().Subscribe("DummyMessageQueue"));`
	`215`	`+ .Returns(x => realConnection.GetSubscriber().Subscribe(new("DummyMessageQueue", RedisChannel.PatternMode.Literal)));`
`216`	`216`	`connectionMock.GetSubscriber(Arg.Any<object>())`
`217`	`217`	`.Returns(subscriberMock);`
`218`	`218`
`@@ -222,7 +222,7 @@ public async Task NoEvictionOnNewEntries()`
`222`	`222`
`223`	`223`	`await cacheStackOne.GetOrSetAsync<int>("NoEvictionOnNewEntries", _ => Task.FromResult(1), new CacheSettings(TimeSpan.FromMinutes(5)));`
`224`	`224`
`225`		`- await subscriberMock.DidNotReceive().PublishAsync("CacheTower.RemoteEviction", Arg.Any<RedisValue>(), Arg.Any<CommandFlags>());`
	`225`	`+ await subscriberMock.DidNotReceive().PublishAsync(new("CacheTower.RemoteEviction", RedisChannel.PatternMode.Literal), Arg.Any<RedisValue>(), Arg.Any<CommandFlags>());`
`226`	`226`	`}`
`227`	`227`	`}`
`228`	`228`	`}`