diff --git a/StackRedis.L1.Test/Keys/KeyDelete.cs b/StackRedis.L1.Test/Keys/KeyDelete.cs index 99d0cd8..41c9633 100644 --- a/StackRedis.L1.Test/Keys/KeyDelete.cs +++ b/StackRedis.L1.Test/Keys/KeyDelete.cs @@ -12,7 +12,7 @@ public class KeyDelete : UnitTestBase [TestMethod] public void KeyDelete_AfterSet() { - _memDb.StringSet("key1", "value1"); + _memDb.StringSet("key1", "value1", null, When.Always); //value1 should be mem cached Assert.AreEqual("value1", (string)_memDb.StringGet("key1")); @@ -34,7 +34,7 @@ public void KeyDelete_AfterSet() [TestMethod] public async Task KeyDeleteAsync_AfterSet() { - await _memDb.StringSetAsync("key1", "value1"); + await _memDb.StringSetAsync("key1", "value1", null, When.Always); //value1 should be mem cached Assert.AreEqual("value1", (string)(await _memDb.StringGetAsync("key1"))); diff --git a/StackRedis.L1.Test/Keys/KeyExists.cs b/StackRedis.L1.Test/Keys/KeyExists.cs index a035f2d..bd66a11 100644 --- a/StackRedis.L1.Test/Keys/KeyExists.cs +++ b/StackRedis.L1.Test/Keys/KeyExists.cs @@ -28,7 +28,7 @@ public void KeyExists_True_StringAdd() Assert.IsFalse(_memDb.KeyExists("key1")); Assert.AreEqual(1, CallsByMemDb); - _memDb.StringSet("key1", "value1"); + _memDb.StringSet("key1", "value1", null, When.Always); Assert.AreEqual(2, CallsByMemDb); //We should be able to tell that it exists without going to redis @@ -39,7 +39,7 @@ public void KeyExists_True_StringAdd() [TestMethod] public void KeyExists_False_KeyDelete() { - _memDb.StringSet("key1", "value1"); + _memDb.StringSet("key1", "value1", null, When.Always); Assert.AreEqual(1, CallsByMemDb); Assert.IsTrue(_memDb.KeyExists("key1")); diff --git a/StackRedis.L1.Test/Keys/KeyExistsAsync.cs b/StackRedis.L1.Test/Keys/KeyExistsAsync.cs index 3cdb7d2..ce6758d 100644 --- a/StackRedis.L1.Test/Keys/KeyExistsAsync.cs +++ b/StackRedis.L1.Test/Keys/KeyExistsAsync.cs @@ -28,7 +28,7 @@ public async Task KeyExistsAsync_True_StringAdd() Assert.IsFalse(await _memDb.KeyExistsAsync("key1")); Assert.AreEqual(1, CallsByMemDb); - await _memDb.StringSetAsync("key1", "value1"); + await _memDb.StringSetAsync("key1", "value1", null, When.Always); Assert.AreEqual(2, CallsByMemDb); //We should be able to tell that it exists without going to redis @@ -39,7 +39,7 @@ public async Task KeyExistsAsync_True_StringAdd() [TestMethod] public async Task KeyExistsAsync_False_KeyDelete() { - _memDb.StringSet("key1", "value1"); + _memDb.StringSet("key1", "value1", null, When.Always); Assert.AreEqual(1, CallsByMemDb); Assert.IsTrue(await _memDb.KeyExistsAsync("key1")); diff --git a/StackRedis.L1.Test/Keys/KeyExpire.cs b/StackRedis.L1.Test/Keys/KeyExpire.cs index c0cf14a..a52ee66 100644 --- a/StackRedis.L1.Test/Keys/KeyExpire.cs +++ b/StackRedis.L1.Test/Keys/KeyExpire.cs @@ -13,7 +13,7 @@ public class KeyExpire : UnitTestBase [TestMethod] public async Task KeyExpire_DateTime() { - _memDb.StringSet("key1", "value1"); + _memDb.StringSet("key1", "value1", null, When.Always); //value1 should be mem cached Assert.IsTrue(_memDb.StringGet("key1").HasValue); @@ -28,14 +28,14 @@ public async Task KeyExpire_DateTime() Assert.IsFalse(_memDb.StringGet("key1").HasValue); //Add it again and make sure it's back - _memDb.StringSet("key1", "value1"); + _memDb.StringSet("key1", "value1", null, When.Always); Assert.IsTrue(_memDb.StringGet("key1").HasValue); } [TestMethod] public void KeyExpire_DateTime_Negative() { - _memDb.StringSet("key1", "value1"); + _memDb.StringSet("key1", "value1", null, When.Always); //value1 should be mem cached Assert.IsTrue(_memDb.StringGet("key1").HasValue); @@ -49,7 +49,7 @@ public void KeyExpire_DateTime_Negative() [TestMethod] public async Task KeyExpire_Timespan() { - _memDb.StringSet("key1", "value1"); + _memDb.StringSet("key1", "value1", null, When.Always); //value1 should be mem cached Assert.IsTrue(_memDb.StringGet("key1").HasValue); @@ -64,14 +64,14 @@ public async Task KeyExpire_Timespan() Assert.IsFalse(_memDb.StringGet("key1").HasValue); //Add it again and make sure it's back - _memDb.StringSet("key1", "value1"); + _memDb.StringSet("key1", "value1", null, When.Always); Assert.IsTrue(_memDb.StringGet("key1").HasValue); } [TestMethod] public void KeyExpire_Timespan_Negative() { - _memDb.StringSet("key1", "value1"); + _memDb.StringSet("key1", "value1", null, When.Always); //value1 should be mem cached Assert.IsTrue(_memDb.StringGet("key1").HasValue); @@ -86,7 +86,7 @@ public void KeyExpire_Timespan_Negative() public async Task KeyExpire_ClearTimeout_Timespan() { //Set a key with a timeout - _memDb.StringSet("key1", "value1", TimeSpan.FromMilliseconds(50)); + _memDb.StringSet("key1", "value1", TimeSpan.FromMilliseconds(50), When.Always); //Clear the timeout before it finishes _memDb.KeyExpire("key1", (TimeSpan?)null); @@ -102,7 +102,7 @@ public async Task KeyExpire_ClearTimeout_Timespan() public async Task KeyExpire_ClearTimeout_DateTime() { //Set a key with a timeout - _memDb.StringSet("key1", "value1", TimeSpan.FromMilliseconds(50)); + _memDb.StringSet("key1", "value1", TimeSpan.FromMilliseconds(50), When.Always); //Clear the timeout before it finishes _memDb.KeyExpire("key1", (DateTime?)null); diff --git a/StackRedis.L1.Test/Keys/KeyExpireAsync.cs b/StackRedis.L1.Test/Keys/KeyExpireAsync.cs index 2bb3d3a..09bf509 100644 --- a/StackRedis.L1.Test/Keys/KeyExpireAsync.cs +++ b/StackRedis.L1.Test/Keys/KeyExpireAsync.cs @@ -12,7 +12,7 @@ public class KeyExpireAsync : UnitTestBase [TestMethod] public async Task KeyExpireAsync_DateTime() { - await _memDb.StringSetAsync("key1", "value1"); + await _memDb.StringSetAsync("key1", "value1", null, When.Always); //value1 should be mem cached Assert.IsTrue((await _memDb.StringGetAsync("key1")).HasValue); @@ -27,14 +27,14 @@ public async Task KeyExpireAsync_DateTime() Assert.IsFalse((await _memDb.StringGetAsync("key1")).HasValue); //Add it again and make sure it's back - await _memDb.StringSetAsync("key1", "value1"); + await _memDb.StringSetAsync("key1", "value1", null, When.Always); Assert.IsTrue((await _memDb.StringGetAsync("key1")).HasValue); } [TestMethod] public async Task KeyExpireAsync_DateTime_Negative() { - _memDb.StringSet("key1", "value1"); + _memDb.StringSet("key1", "value1", null, When.Always); //value1 should be mem cached Assert.IsTrue(_memDb.StringGet("key1").HasValue); @@ -48,7 +48,7 @@ public async Task KeyExpireAsync_DateTime_Negative() [TestMethod] public async Task KeyExpire_Timespan() { - _memDb.StringSet("key1", "value1"); + _memDb.StringSet("key1", "value1", null, When.Always); //value1 should be mem cached Assert.IsTrue(_memDb.StringGet("key1").HasValue); @@ -63,14 +63,14 @@ public async Task KeyExpire_Timespan() Assert.IsFalse(_memDb.StringGet("key1").HasValue); //Add it again and make sure it's back - _memDb.StringSet("key1", "value1"); + _memDb.StringSet("key1", "value1", null, When.Always); Assert.IsTrue(_memDb.StringGet("key1").HasValue); } [TestMethod] public async Task KeyExpire_Timespan_Negative() { - _memDb.StringSet("key1", "value1"); + _memDb.StringSet("key1", "value1", null, When.Always); //value1 should be mem cached Assert.IsTrue(_memDb.StringGet("key1").HasValue); @@ -85,7 +85,7 @@ public async Task KeyExpire_Timespan_Negative() public async Task KeyExpire_ClearTimeout_Timespan() { //Set a key with a timeout - _memDb.StringSet("key1", "value1", TimeSpan.FromMilliseconds(50)); + _memDb.StringSet("key1", "value1", TimeSpan.FromMilliseconds(50), When.Always); //Clear the timeout before it finishes await _memDb.KeyExpireAsync("key1", (TimeSpan?)null); @@ -101,7 +101,7 @@ public async Task KeyExpire_ClearTimeout_Timespan() public async Task KeyExpire_ClearTimeout_DateTime() { //Set a key with a timeout - _memDb.StringSet("key1", "value1", TimeSpan.FromMilliseconds(50)); + _memDb.StringSet("key1", "value1", TimeSpan.FromMilliseconds(50), When.Always); //Clear the timeout before it finishes await _memDb.KeyExpireAsync("key1", (DateTime?)null); diff --git a/StackRedis.L1.Test/Keys/KeyRename.cs b/StackRedis.L1.Test/Keys/KeyRename.cs index 7b3f808..7c0b2e8 100644 --- a/StackRedis.L1.Test/Keys/KeyRename.cs +++ b/StackRedis.L1.Test/Keys/KeyRename.cs @@ -13,7 +13,7 @@ public class KeyRename : UnitTestBase public void KeyRename_Simple() { //Create a key - _memDb.StringSet("blah_key1", "str"); + _memDb.StringSet("blah_key1", "str", null, When.Always); Assert.AreEqual(1, CallsByMemDb); //Rename it @@ -32,7 +32,7 @@ public void KeyRename_Simple() [TestMethod] public async Task KeyRename_ExpiryStillSet() { - _memDb.StringSet("key1", "value1"); + _memDb.StringSet("key1", "value1", null, When.Always); //Now expire it _memDb.KeyExpire("key1", DateTime.UtcNow.AddMilliseconds(50)); @@ -52,8 +52,8 @@ public async Task KeyRename_ExpiryStillSet() [TestMethod] public void KeyRename_NewKeyAlreadyExists() { - _memDb.StringSet("key1", "value1"); - _memDb.StringSet("key2", "value2"); + _memDb.StringSet("key1", "value1", null, When.Always); + _memDb.StringSet("key2", "value2", null, When.Always); //Rename the key _memDb.KeyRename("key1", "key2"); diff --git a/StackRedis.L1.Test/Keys/KeyRenameAsync.cs b/StackRedis.L1.Test/Keys/KeyRenameAsync.cs index 50d1bd0..8aa05d6 100644 --- a/StackRedis.L1.Test/Keys/KeyRenameAsync.cs +++ b/StackRedis.L1.Test/Keys/KeyRenameAsync.cs @@ -13,7 +13,7 @@ public class KeyRenameAsync : UnitTestBase public async Task KeyRenameAsync_Simple() { //Create a key - await _memDb.StringSetAsync("key1", "str"); + await _memDb.StringSetAsync("key1", "str", null, When.Always); Assert.AreEqual(1, CallsByMemDb); //Rename it @@ -33,7 +33,7 @@ public async Task KeyRenameAsync_Simple() [TestMethod] public async Task KeyRenameAsync_ExpiryStillSet() { - await _memDb.StringSetAsync("key1", "value1"); + await _memDb.StringSetAsync("key1", "value1", null, When.Always); //Now expire it await _memDb.KeyExpireAsync("key1", DateTime.UtcNow.AddMilliseconds(20)); @@ -53,8 +53,8 @@ public async Task KeyRenameAsync_ExpiryStillSet() [TestMethod] public async Task KeyRenameAsync_NewKeyAlreadyExists() { - await _memDb.StringSetAsync("key1", "value1"); - await _memDb.StringSetAsync("key2", "value2"); + await _memDb.StringSetAsync("key1", "value1", null, When.Always); + await _memDb.StringSetAsync("key2", "value2", null, When.Always); //Rename the key await _memDb.KeyRenameAsync("key1", "key2"); diff --git a/StackRedis.L1.Test/Keys/KeyTimeToLive.cs b/StackRedis.L1.Test/Keys/KeyTimeToLive.cs index fb9f6ea..9f05832 100644 --- a/StackRedis.L1.Test/Keys/KeyTimeToLive.cs +++ b/StackRedis.L1.Test/Keys/KeyTimeToLive.cs @@ -13,7 +13,7 @@ public class KeyTimeToLive : UnitTestBase [TestMethod] public void KeyTimeToLive_Simple() { - _memDb.StringSet("key1", "value1"); + _memDb.StringSet("key1", "value1", null, When.Always); //Give it a ttl in redis _redisDirectDb.KeyExpire("key1", TimeSpan.FromMinutes(10)); @@ -32,7 +32,7 @@ public void KeyTimeToLive_Simple() [TestMethod] public async Task KeyTimeToLive_ByOtherClient() { - _memDb.StringSet("key1", "value1"); + _memDb.StringSet("key1", "value1", null, When.Always); //Give it a ttl in redis _redisDirectDb.KeyExpire("key1", TimeSpan.FromMinutes(10)); diff --git a/StackRedis.L1.Test/NoRedis/NoRedisTests.cs b/StackRedis.L1.Test/NoRedis/NoRedisTests.cs index 9bd0b79..c1d9472 100644 --- a/StackRedis.L1.Test/NoRedis/NoRedisTests.cs +++ b/StackRedis.L1.Test/NoRedis/NoRedisTests.cs @@ -1,4 +1,5 @@ using Microsoft.VisualStudio.TestTools.UnitTesting; +using StackExchange.Redis; using System; using System.Collections.Generic; using System.Linq; @@ -14,7 +15,7 @@ public class NoRedisTests public void NoRedis_StringGet() { RedisL1Database db = new RedisL1Database("unique str"); - db.StringSet("nodbkey", "value"); + db.StringSet("nodbkey", "value", null, When.Always); Assert.AreEqual("value", (string)db.StringGet("nodbkey")); } } diff --git a/StackRedis.L1.Test/StackRedis.L1.Test.csproj b/StackRedis.L1.Test/StackRedis.L1.Test.csproj index a29c253..fe4523a 100644 --- a/StackRedis.L1.Test/StackRedis.L1.Test.csproj +++ b/StackRedis.L1.Test/StackRedis.L1.Test.csproj @@ -20,10 +20,10 @@ - - - - + + + + diff --git a/StackRedis.L1.Test/String/StringAppend.cs b/StackRedis.L1.Test/String/StringAppend.cs index d66ce52..7560602 100644 --- a/StackRedis.L1.Test/String/StringAppend.cs +++ b/StackRedis.L1.Test/String/StringAppend.cs @@ -12,7 +12,7 @@ public class StringAppend: UnitTestBase [TestMethod] public void StringAppend_Simple() { - _memDb.StringSet("key", "a"); + _memDb.StringSet("key", "a", null, When.Always); Assert.AreEqual(1, CallsByMemDb); _memDb.StringAppend("key", "b"); @@ -27,7 +27,7 @@ public void StringAppend_Simple() [TestMethod] public async Task StringAppend_InRedis_Notification() { - _memDb.StringSet("key", "a"); + _memDb.StringSet("key", "a", null, When.Always); Assert.AreEqual(1, CallsByMemDb); _otherClientDb.StringAppend("key", "b"); @@ -57,7 +57,7 @@ public void StringAppend_DoesNotExist() [TestMethod] public async Task StringAppendAsync_Simple() { - await _memDb.StringSetAsync("key", "a"); + await _memDb.StringSetAsync("key", "a", null, When.Always); Assert.AreEqual(1, CallsByMemDb); await _memDb.StringAppendAsync("key", "b"); @@ -72,7 +72,7 @@ public async Task StringAppendAsync_Simple() [TestMethod] public async Task StringAppendAsync_InRedis_Notification() { - await _memDb.StringSetAsync("key", "a"); + await _memDb.StringSetAsync("key", "a", null, When.Always); Assert.AreEqual(1, CallsByMemDb); await _otherClientDb.StringAppendAsync("key", "b"); diff --git a/StackRedis.L1.Test/String/StringDecrement.cs b/StackRedis.L1.Test/String/StringDecrement.cs index fecb021..462a137 100644 --- a/StackRedis.L1.Test/String/StringDecrement.cs +++ b/StackRedis.L1.Test/String/StringDecrement.cs @@ -12,7 +12,7 @@ public class StringDecrement: UnitTestBase [TestMethod] public void StringDecrement_Double_Simple() { - _memDb.StringSet("key", "2.5"); + _memDb.StringSet("key", "2.5", null, When.Always); Assert.AreEqual(1, CallsByMemDb); _memDb.StringDecrement("key", 1.5); @@ -28,7 +28,7 @@ public void StringDecrement_Double_Simple() [TestMethod] public async Task StringDecrement_Double_InRedis_Notification() { - _memDb.StringSet("key", "2.5"); + _memDb.StringSet("key", "2.5", null, When.Always); Assert.AreEqual(1, CallsByMemDb); _otherClientDb.StringDecrement("key", 1.5); @@ -46,7 +46,7 @@ public async Task StringDecrement_Double_InRedis_Notification() [TestMethod] public async Task StringDecrementAsync_Double_Simple() { - await _memDb.StringSetAsync("key", "2.5"); + await _memDb.StringSetAsync("key", "2.5", null, When.Always); Assert.AreEqual(1, CallsByMemDb); await _memDb.StringDecrementAsync("key", 1.5); @@ -61,7 +61,7 @@ public async Task StringDecrementAsync_Double_Simple() [TestMethod] public void StringDecrement_Long_Simple() { - _memDb.StringSet("key", "3"); + _memDb.StringSet("key", "3", null, When.Always); Assert.AreEqual(1, CallsByMemDb); _memDb.StringDecrement("key", 2); @@ -77,7 +77,7 @@ public void StringDecrement_Long_Simple() [TestMethod] public async Task StringDecrement_Long_InRedis_Notification() { - _memDb.StringSet("key", "3"); + _memDb.StringSet("key", "3", null, When.Always); Assert.AreEqual(1, CallsByMemDb); _otherClientDb.StringDecrement("key", 2); @@ -95,7 +95,7 @@ public async Task StringDecrement_Long_InRedis_Notification() [TestMethod] public async Task StringDecrementAsync_Long_Simple() { - await _memDb.StringSetAsync("key", "3"); + await _memDb.StringSetAsync("key", "3", null, When.Always); Assert.AreEqual(1, CallsByMemDb); await _memDb.StringDecrementAsync("key", 2); diff --git a/StackRedis.L1.Test/String/StringGet.cs b/StackRedis.L1.Test/String/StringGet.cs index e7ad28d..3b7c715 100644 --- a/StackRedis.L1.Test/String/StringGet.cs +++ b/StackRedis.L1.Test/String/StringGet.cs @@ -31,7 +31,7 @@ public async Task StringGet_StringChangedInRedis() await Task.Delay(1200); //Now change it in redis - _otherClientDb.StringSet("key1", "value2"); + _otherClientDb.StringSet("key1", "value2", null, When.Always); //Wait for it to propagate and re-retrieve await Task.Delay(50); @@ -77,7 +77,7 @@ public void StringGet_Simple_Multi_OneValueCached() public async Task StringGet_WithExpiry() { //Set in redis with an expiry - _otherClientDb.StringSet("key_exp", "value1", TimeSpan.FromMilliseconds(30)); + _otherClientDb.StringSet("key_exp", "value1", TimeSpan.FromMilliseconds(30), When.Always); //Pull into memory Assert.AreEqual("value1", (string)_memDb.StringGet("key_exp")); diff --git a/StackRedis.L1.Test/String/StringGetWithExpiry.cs b/StackRedis.L1.Test/String/StringGetWithExpiry.cs index 373cfc7..2ed2b0b 100644 --- a/StackRedis.L1.Test/String/StringGetWithExpiry.cs +++ b/StackRedis.L1.Test/String/StringGetWithExpiry.cs @@ -1,5 +1,6 @@ using System; using Microsoft.VisualStudio.TestTools.UnitTesting; +using StackExchange.Redis; namespace StackRedis.L1.Test.String { @@ -47,7 +48,7 @@ public void StringGetWithExpiry_StringAndNoExpirySetViaRedis() [TestMethod] public void StringGetWithExpiry_StringAndExpirySetInMem() { - _memDb.StringSet("key1", "val", TimeSpan.FromDays(1)); + _memDb.StringSet("key1", "val", TimeSpan.FromDays(1), When.Always); Assert.AreEqual(1, CallsByMemDb); var result = _memDb.StringGetWithExpiry("key1"); @@ -60,7 +61,7 @@ public void StringGetWithExpiry_StringAndExpirySetInMem() [TestMethod] public void StringGetWithExpiry_StringAndNoExpirySetInMem() { - _memDb.StringSet("key1", "val"); + _memDb.StringSet("key1", "val", null, When.Always); Assert.AreEqual(1, CallsByMemDb); var result = _memDb.StringGetWithExpiry("key1"); diff --git a/StackRedis.L1.Test/String/StringGetWithExpiryAsync.cs b/StackRedis.L1.Test/String/StringGetWithExpiryAsync.cs index b44b019..4c4320c 100644 --- a/StackRedis.L1.Test/String/StringGetWithExpiryAsync.cs +++ b/StackRedis.L1.Test/String/StringGetWithExpiryAsync.cs @@ -1,6 +1,7 @@ using System; using Microsoft.VisualStudio.TestTools.UnitTesting; using System.Threading.Tasks; +using StackExchange.Redis; namespace StackRedis.L1.Test.String { @@ -48,7 +49,7 @@ public async Task StringGetWithExpiryAsync_StringAndNoExpirySetViaRedis() [TestMethod] public async Task StringGetWithExpiryAsync_StringAndExpirySetInMem() { - await _memDb.StringSetAsync("key1", "val", TimeSpan.FromDays(1)); + await _memDb.StringSetAsync("key1", "val", TimeSpan.FromDays(1), When.Always); Assert.AreEqual(1, CallsByMemDb); var result = await _memDb.StringGetWithExpiryAsync("key1"); @@ -61,7 +62,7 @@ public async Task StringGetWithExpiryAsync_StringAndExpirySetInMem() [TestMethod] public async Task StringGetWithExpiryAsync_StringAndNoExpirySetInMem() { - await _memDb.StringSetAsync("key1", "val"); + await _memDb.StringSetAsync("key1", "val", null, When.Always); Assert.AreEqual(1, CallsByMemDb); var result = await _memDb.StringGetWithExpiryAsync("key1"); diff --git a/StackRedis.L1.Test/String/StringIncrement.cs b/StackRedis.L1.Test/String/StringIncrement.cs index ed374d3..7d472f0 100644 --- a/StackRedis.L1.Test/String/StringIncrement.cs +++ b/StackRedis.L1.Test/String/StringIncrement.cs @@ -12,7 +12,7 @@ public class StringIncrement: UnitTestBase [TestMethod] public void StringIncrement_Double_Simple() { - _memDb.StringSet("key", "1"); + _memDb.StringSet("key", "1", null, When.Always); Assert.AreEqual(1, CallsByMemDb); _memDb.StringIncrement("key", 1.5); @@ -28,7 +28,7 @@ public void StringIncrement_Double_Simple() [TestMethod] public async Task StringIncrement_Double_InRedis_Notification() { - _memDb.StringSet("key", "1"); + _memDb.StringSet("key", "1", null, When.Always); Assert.AreEqual(1, CallsByMemDb); _otherClientDb.StringIncrement("key", 1.5); @@ -45,7 +45,7 @@ public async Task StringIncrement_Double_InRedis_Notification() [TestMethod] public async Task StringIncrementAsync_Double_Simple() { - await _memDb.StringSetAsync("key", "1"); + await _memDb.StringSetAsync("key", "1", null, When.Always); Assert.AreEqual(1, CallsByMemDb); await _memDb.StringIncrementAsync("key", 1.5); @@ -60,7 +60,7 @@ public async Task StringIncrementAsync_Double_Simple() [TestMethod] public void StringIncrement_Long_Simple() { - _memDb.StringSet("key", "1"); + _memDb.StringSet("key", "1", null, When.Always); Assert.AreEqual(1, CallsByMemDb); _memDb.StringIncrement("key", 2); @@ -76,7 +76,7 @@ public void StringIncrement_Long_Simple() [TestMethod] public async Task StringIncrement_Long_InRedis_Notification() { - _memDb.StringSet("key", "1"); + _memDb.StringSet("key", "1", null, When.Always); Assert.AreEqual(1, CallsByMemDb); _otherClientDb.StringIncrement("key", 2); @@ -94,7 +94,7 @@ public async Task StringIncrement_Long_InRedis_Notification() [TestMethod] public async Task StringIncrementAsync_Long_Simple() { - await _memDb.StringSetAsync("key", "1"); + await _memDb.StringSetAsync("key", "1", null, When.Always); Assert.AreEqual(1, CallsByMemDb); await _memDb.StringIncrementAsync("key", 2); diff --git a/StackRedis.L1.Test/String/StringLength.cs b/StackRedis.L1.Test/String/StringLength.cs index 78cb9a5..04a0dd3 100644 --- a/StackRedis.L1.Test/String/StringLength.cs +++ b/StackRedis.L1.Test/String/StringLength.cs @@ -12,7 +12,7 @@ public class StringLength : UnitTestBase [TestMethod] public void StringLength_Simple() { - _memDb.StringSet("key", "value"); + _memDb.StringSet("key", "value", null, When.Always); Assert.AreEqual(1, CallsByMemDb); //length should be retrievable from cache @@ -23,7 +23,7 @@ public void StringLength_Simple() [TestMethod] public async Task StringLength_StringChangedInRedis() { - _memDb.StringSet("key", "value"); + _memDb.StringSet("key", "value", null, When.Always); Assert.AreEqual(1, CallsByMemDb); //Get the length from the cache @@ -33,7 +33,7 @@ public async Task StringLength_StringChangedInRedis() await Task.Delay(50); //Change the string in redis - _otherClientDb.StringSet("key", "longer value"); + _otherClientDb.StringSet("key", "longer value", null, When.Always); await Task.Delay(30); //Wait for the keyspace notification to remove the string diff --git a/StackRedis.L1.Test/String/StringLengthAsync.cs b/StackRedis.L1.Test/String/StringLengthAsync.cs index 63f6392..62fba7f 100644 --- a/StackRedis.L1.Test/String/StringLengthAsync.cs +++ b/StackRedis.L1.Test/String/StringLengthAsync.cs @@ -12,7 +12,7 @@ public class StringLengthAsync : UnitTestBase [TestMethod] public async Task StringLengthAsync_Simple() { - await _memDb.StringSetAsync("key", "value"); + await _memDb.StringSetAsync("key", "value", null, When.Always); Assert.AreEqual(1, CallsByMemDb); //length should be retrievable from cache @@ -23,7 +23,7 @@ public async Task StringLengthAsync_Simple() [TestMethod] public async Task StringLengthAsync_StringChangedInRedis() { - await _memDb.StringSetAsync("key", "value"); + await _memDb.StringSetAsync("key", "value", null, When.Always); Assert.AreEqual(1, CallsByMemDb); //Get the length from the cache @@ -33,7 +33,7 @@ public async Task StringLengthAsync_StringChangedInRedis() await Task.Delay(50); //Change the string in redis - await _otherClientDb.StringSetAsync("key", "longer value"); + await _otherClientDb.StringSetAsync("key", "longer value", null, When.Always); await Task.Delay(30); //Wait for the keyspace notification to remove the string diff --git a/StackRedis.L1.Test/String/StringSet.cs b/StackRedis.L1.Test/String/StringSet.cs index 7bfe2ce..4428def 100644 --- a/StackRedis.L1.Test/String/StringSet.cs +++ b/StackRedis.L1.Test/String/StringSet.cs @@ -11,7 +11,7 @@ public class StringSet : UnitTestBase [TestMethod] public void StringSet_ThenGet() { - _memDb.StringSet("key1", "value1"); + _memDb.StringSet("key1", "value1", null, When.Always); Assert.AreEqual(1, CallsByMemDb); diff --git a/StackRedis.L1.Test/String/StringSetAsync.cs b/StackRedis.L1.Test/String/StringSetAsync.cs index 841c685..8c55723 100644 --- a/StackRedis.L1.Test/String/StringSetAsync.cs +++ b/StackRedis.L1.Test/String/StringSetAsync.cs @@ -12,7 +12,7 @@ public class StringSetAsync : UnitTestBase [TestMethod] public async Task StringSetAsync_ThenGet() { - await _memDb.StringSetAsync("key1", "value1"); + await _memDb.StringSetAsync("key1", "value1", null, When.Always); Assert.AreEqual(1, CallsByMemDb); //value1 should be mem cached diff --git a/StackRedis.L1.Test/String/StringSetBit.cs b/StackRedis.L1.Test/String/StringSetBit.cs index c2fb72b..fbdd8c4 100644 --- a/StackRedis.L1.Test/String/StringSetBit.cs +++ b/StackRedis.L1.Test/String/StringSetBit.cs @@ -12,7 +12,7 @@ public class StringSetBit : UnitTestBase [TestMethod] public void StringSetBit_Simple() { - _memDb.StringSet("key", "value"); + _memDb.StringSet("key", "value", null, When.Always); Assert.AreEqual(1, CallsByMemDb); _memDb.StringSetBit("key", 2, false); @@ -28,7 +28,7 @@ public void StringSetBit_Simple() [TestMethod] public async Task StringSetBit_InRedis_Notification() { - _memDb.StringSet("key", "value"); + _memDb.StringSet("key", "value", null, When.Always); Assert.AreEqual(1, CallsByMemDb); _otherClientDb.StringSetBit("key", 2, false); @@ -46,7 +46,7 @@ public async Task StringSetBit_InRedis_Notification() [TestMethod] public async Task StringSetBitAsync_Simple() { - await _memDb.StringSetAsync("key", "value"); + await _memDb.StringSetAsync("key", "value", null, When.Always); Assert.AreEqual(1, CallsByMemDb); await _memDb.StringSetBitAsync("key", 2, false); diff --git a/StackRedis.L1.Test/String/StringSetRange.cs b/StackRedis.L1.Test/String/StringSetRange.cs index b2bc7c7..a18f200 100644 --- a/StackRedis.L1.Test/String/StringSetRange.cs +++ b/StackRedis.L1.Test/String/StringSetRange.cs @@ -12,7 +12,7 @@ public class StringSetRange : UnitTestBase [TestMethod] public void StringSetRange_Simple() { - _memDb.StringSet("key", "value"); + _memDb.StringSet("key", "value", null, When.Always); Assert.AreEqual(1, CallsByMemDb); _memDb.StringSetRange("key", 2, "x"); @@ -28,7 +28,7 @@ public void StringSetRange_Simple() [TestMethod] public async Task StringSetRange_InRedis_Notification() { - _memDb.StringSet("key", "value"); + _memDb.StringSet("key", "value", null, When.Always); Assert.AreEqual(1, CallsByMemDb); _otherClientDb.StringSetRange("key", 2, "x"); @@ -46,7 +46,7 @@ public async Task StringSetRange_InRedis_Notification() [TestMethod] public async Task StringSetRangeAsync_Simple() { - await _memDb.StringSetAsync("key", "value"); + await _memDb.StringSetAsync("key", "value", null, When.Always); Assert.AreEqual(1, CallsByMemDb); await _memDb.StringSetRangeAsync("key", 2, "x"); diff --git a/StackRedis.L1/KeyspaceNotifications/NotificationListener.cs b/StackRedis.L1/KeyspaceNotifications/NotificationListener.cs index 6bf4921..1913722 100644 --- a/StackRedis.L1/KeyspaceNotifications/NotificationListener.cs +++ b/StackRedis.L1/KeyspaceNotifications/NotificationListener.cs @@ -132,6 +132,11 @@ private static void HandleKeyspaceDetailEvent(DatabaseInstanceData dbData, strin //A key was removed dbData.MemoryCache.Remove(new[] { key }); } + else if(eventName == "getdel") + { + //A key was removed + dbData.MemoryCache.Remove(new[] { key }); + } else if (eventName == "expire") { //The TTL has changed - clear it in memory diff --git a/StackRedis.L1/Notifications/NotificationDatabase.cs b/StackRedis.L1/Notifications/NotificationDatabase.cs index f492ad3..81cbfab 100644 --- a/StackRedis.L1/Notifications/NotificationDatabase.cs +++ b/StackRedis.L1/Notifications/NotificationDatabase.cs @@ -1976,7 +1976,6 @@ public Task StringSetBitAsync(RedisKey key, long offset, bool bit, Command return _redisDb.StringSetBitAsync(key, offset, bit, flags); } - public RedisValue StringSetRange(RedisKey key, long offset, RedisValue value, CommandFlags flags = CommandFlags.None) { PublishEvent(key, "setrange"); @@ -2008,5 +2007,198 @@ public void WaitAll(params Task[] tasks) { _redisDb.WaitAll(tasks); } + + public long HashStringLength(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None) + { + return _redisDb.HashStringLength(key, hashField, flags); + } + + public RedisValue[] ListLeftPop(RedisKey key, long count, CommandFlags flags = CommandFlags.None) + { + return _redisDb.ListLeftPop(key, count, flags); + } + + public long ListLeftPush(RedisKey key, RedisValue[] values, When when = When.Always, CommandFlags flags = CommandFlags.None) + { + return _redisDb.ListLeftPush(key, values, when, flags); + } + + public RedisValue[] ListRightPop(RedisKey key, long count, CommandFlags flags = CommandFlags.None) + { + return _redisDb.ListRightPop(key, count, flags); + } + + public long ListRightPush(RedisKey key, RedisValue[] values, When when = When.Always, CommandFlags flags = CommandFlags.None) + { + return _redisDb.ListRightPush(key, values, when, flags); + } + + public long SortedSetRangeAndStore(RedisKey sourceKey, RedisKey destinationKey, RedisValue start, RedisValue stop, SortedSetOrder sortedSetOrder = SortedSetOrder.ByRank, Exclude exclude = Exclude.None, Order order = Order.Ascending, long skip = 0, long? take = null, CommandFlags flags = CommandFlags.None) + { + return _redisDb.SortedSetRangeAndStore(sourceKey, destinationKey, start, stop, sortedSetOrder, exclude, order, skip, take, flags); + } + + public bool StreamCreateConsumerGroup(RedisKey key, RedisValue groupName, RedisValue? position = null, bool createStream = true, CommandFlags flags = CommandFlags.None) + { + return _redisDb.StreamCreateConsumerGroup(key, groupName, position, createStream, flags); + } + + public StreamEntry[] StreamReadGroup(RedisKey key, RedisValue groupName, RedisValue consumerName, RedisValue? position = null, int? count = null, bool noAck = false, CommandFlags flags = CommandFlags.None) + { + return _redisDb.StreamReadGroup(key, groupName, consumerName, position, count, noAck, flags); + } + + public RedisStream[] StreamReadGroup(StreamPosition[] streamPositions, RedisValue groupName, RedisValue consumerName, int? countPerStream = null, bool noAck = false, CommandFlags flags = CommandFlags.None) + { + return _redisDb.StreamReadGroup(streamPositions, groupName, consumerName, countPerStream, noAck, flags); + } + + public RedisValue StringGetSetExpiry(RedisKey key, TimeSpan? expiry, CommandFlags flags = CommandFlags.None) + { + return _redisDb.StringGetSetExpiry(key, expiry, flags); + } + + public RedisValue StringGetSetExpiry(RedisKey key, DateTime expiry, CommandFlags flags = CommandFlags.None) + { + return _redisDb.StringGetSetExpiry(key, expiry, flags); + } + + public RedisValue StringGetDelete(RedisKey key, CommandFlags flags = CommandFlags.None) + { + PublishEvent(key, "getdel"); + return _redisDb.StringGetDelete(key, flags); + } + + public bool StringSet(RedisKey key, RedisValue value, TimeSpan? expiry = null, bool keepTtl = false, When when = When.Always, CommandFlags flags = CommandFlags.None) + { + PublishEvent(key, "set"); + return _redisDb.StringSet(key, value, expiry, keepTtl, when, flags); + } + + public RedisValue StringSetAndGet(RedisKey key, RedisValue value, TimeSpan? expiry, When when, CommandFlags flags) + { + PublishEvent(key, "set"); + return _redisDb.StringSetAndGet(key, value, expiry, when, flags); + } + + public RedisValue StringSetAndGet(RedisKey key, RedisValue value, TimeSpan? expiry = null, bool keepTtl = false, When when = When.Always, CommandFlags flags = CommandFlags.None) + { + PublishEvent(key, "set"); + return _redisDb.StringSetAndGet(key, value, expiry, keepTtl, when, flags); + } + + public bool KeyTouch(RedisKey key, CommandFlags flags = CommandFlags.None) + { + return _redisDb.KeyTouch(key, flags); + } + + public long KeyTouch(RedisKey[] keys, CommandFlags flags = CommandFlags.None) + { + return _redisDb.KeyTouch(keys, flags); + } + + public IAsyncEnumerable HashScanAsync(RedisKey key, RedisValue pattern = default, int pageSize = 250, long cursor = 0, int pageOffset = 0, CommandFlags flags = CommandFlags.None) + { + return _redisDb.HashScanAsync(key, pattern, pageSize, cursor, pageOffset, flags); + } + + public Task HashStringLengthAsync(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None) + { + return _redisDb.HashStringLengthAsync(key, hashField, flags); + } + + public Task ListLeftPopAsync(RedisKey key, long count, CommandFlags flags = CommandFlags.None) + { + return _redisDb.ListLeftPopAsync(key, count, flags); + } + + public Task ListLeftPushAsync(RedisKey key, RedisValue[] values, When when = When.Always, CommandFlags flags = CommandFlags.None) + { + return _redisDb.ListLeftPushAsync(key, values, when, flags); + } + + public Task ListRightPopAsync(RedisKey key, long count, CommandFlags flags = CommandFlags.None) + { + return _redisDb.ListRightPopAsync(key, count, flags); + } + + public Task ListRightPushAsync(RedisKey key, RedisValue[] values, When when = When.Always, CommandFlags flags = CommandFlags.None) + { + return _redisDb.ListRightPushAsync(key, values, when, flags); + } + + public IAsyncEnumerable SetScanAsync(RedisKey key, RedisValue pattern = default, int pageSize = 250, long cursor = 0, int pageOffset = 0, CommandFlags flags = CommandFlags.None) + { + return _redisDb.SetScanAsync(key, pattern, pageSize, cursor, pageOffset, flags); + } + + public Task SortedSetRangeAndStoreAsync(RedisKey sourceKey, RedisKey destinationKey, RedisValue start, RedisValue stop, SortedSetOrder sortedSetOrder = SortedSetOrder.ByRank, Exclude exclude = Exclude.None, Order order = Order.Ascending, long skip = 0, long? take = null, CommandFlags flags = CommandFlags.None) + { + return _redisDb.SortedSetRangeAndStoreAsync(sourceKey, destinationKey, start, stop, sortedSetOrder, exclude, order, skip, take, flags); + } + + public IAsyncEnumerable SortedSetScanAsync(RedisKey key, RedisValue pattern = default, int pageSize = 250, long cursor = 0, int pageOffset = 0, CommandFlags flags = CommandFlags.None) + { + return _redisDb.SortedSetScanAsync(key, pattern, pageSize, cursor, pageOffset, flags); + } + + public Task StreamCreateConsumerGroupAsync(RedisKey key, RedisValue groupName, RedisValue? position = null, bool createStream = true, CommandFlags flags = CommandFlags.None) + { + return _redisDb.StreamCreateConsumerGroupAsync(key, groupName, position, createStream, flags); + } + + public Task StreamReadGroupAsync(RedisKey key, RedisValue groupName, RedisValue consumerName, RedisValue? position = null, int? count = null, bool noAck = false, CommandFlags flags = CommandFlags.None) + { + return _redisDb.StreamReadGroupAsync(key, groupName, consumerName, position, count, noAck, flags); + } + + public Task StreamReadGroupAsync(StreamPosition[] streamPositions, RedisValue groupName, RedisValue consumerName, int? countPerStream = null, bool noAck = false, CommandFlags flags = CommandFlags.None) + { + return _redisDb.StreamReadGroupAsync(streamPositions, groupName, consumerName, countPerStream, noAck, flags); + } + + public Task StringGetSetExpiryAsync(RedisKey key, TimeSpan? expiry, CommandFlags flags = CommandFlags.None) + { + return _redisDb.StringGetSetExpiryAsync(key, expiry, flags); + } + + public Task StringGetSetExpiryAsync(RedisKey key, DateTime expiry, CommandFlags flags = CommandFlags.None) + { + return _redisDb.StringGetSetExpiryAsync(key, expiry, flags); + } + + public Task StringGetDeleteAsync(RedisKey key, CommandFlags flags = CommandFlags.None) + { + PublishEvent(key, "getdel"); + return _redisDb.StringGetDeleteAsync(key, flags); + } + + public Task StringSetAsync(RedisKey key, RedisValue value, TimeSpan? expiry = null, bool keepTtl = false, When when = When.Always, CommandFlags flags = CommandFlags.None) + { + PublishEvent(key, "set"); + return _redisDb.StringSetAsync(key, value, expiry, keepTtl, when, flags); + } + + public Task StringSetAndGetAsync(RedisKey key, RedisValue value, TimeSpan? expiry, When when, CommandFlags flags) + { + PublishEvent(key, "set"); + return _redisDb.StringSetAndGetAsync(key, value, expiry, when, flags); + } + + public Task StringSetAndGetAsync(RedisKey key, RedisValue value, TimeSpan? expiry = null, bool keepTtl = false, When when = When.Always, CommandFlags flags = CommandFlags.None) + { + PublishEvent(key, "set"); + return _redisDb.StringSetAndGetAsync(key, value, expiry, keepTtl, when, flags); + } + + public Task KeyTouchAsync(RedisKey key, CommandFlags flags = CommandFlags.None) + { + return _redisDb.KeyTouchAsync(key, flags); + } + + public Task KeyTouchAsync(RedisKey[] keys, CommandFlags flags = CommandFlags.None) + { + return _redisDb.KeyTouchAsync(keys, flags); + } } } diff --git a/StackRedis.L1/RedisForwardingDatabase.cs b/StackRedis.L1/RedisForwardingDatabase.cs index a789dd1..46a3770 100644 --- a/StackRedis.L1/RedisForwardingDatabase.cs +++ b/StackRedis.L1/RedisForwardingDatabase.cs @@ -2115,5 +2115,227 @@ public virtual void WaitAll(params Task[] tasks) _onCall(); _redisDb.WaitAll(tasks); } + + public long HashStringLength(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.HashStringLength(key, hashField, flags); + } + + public RedisValue[] ListLeftPop(RedisKey key, long count, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.ListLeftPop(key, count, flags); + } + + public long ListLeftPush(RedisKey key, RedisValue[] values, When when = When.Always, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.ListLeftPush(key, values, when, flags); + } + + public RedisValue[] ListRightPop(RedisKey key, long count, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.ListRightPop(key, count, flags); + } + + public long ListRightPush(RedisKey key, RedisValue[] values, When when = When.Always, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.ListRightPush(key, values, when, flags); + } + + public long SortedSetRangeAndStore(RedisKey sourceKey, RedisKey destinationKey, RedisValue start, RedisValue stop, SortedSetOrder sortedSetOrder = SortedSetOrder.ByRank, Exclude exclude = Exclude.None, Order order = Order.Ascending, long skip = 0, long? take = null, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.SortedSetRangeAndStore(sourceKey, destinationKey, start, stop, sortedSetOrder, exclude, order, skip, take, flags); + } + + public bool StreamCreateConsumerGroup(RedisKey key, RedisValue groupName, RedisValue? position = null, bool createStream = true, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.StreamCreateConsumerGroup(key, groupName, position, createStream, flags); + } + + public StreamEntry[] StreamReadGroup(RedisKey key, RedisValue groupName, RedisValue consumerName, RedisValue? position = null, int? count = null, bool noAck = false, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.StreamReadGroup(key, groupName, consumerName, position, count, noAck, flags); + } + + public RedisStream[] StreamReadGroup(StreamPosition[] streamPositions, RedisValue groupName, RedisValue consumerName, int? countPerStream = null, bool noAck = false, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.StreamReadGroup(streamPositions, groupName, consumerName, countPerStream, noAck, flags); + } + + public RedisValue StringGetSetExpiry(RedisKey key, TimeSpan? expiry, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.StringGetSetExpiry(key, expiry, flags); + } + + public RedisValue StringGetSetExpiry(RedisKey key, DateTime expiry, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.StringGetSetExpiry(key, expiry, flags); + } + + public RedisValue StringGetDelete(RedisKey key, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.StringGetDelete(key, flags); + } + + public bool StringSet(RedisKey key, RedisValue value, TimeSpan? expiry = null, bool keepTtl = false, When when = When.Always, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.StringSet(key, value, expiry, keepTtl, when, flags); + } + + public RedisValue StringSetAndGet(RedisKey key, RedisValue value, TimeSpan? expiry, When when, CommandFlags flags) + { + _onCall(); + return _redisDb.StringSetAndGet(key, value, expiry, when, flags); + } + + public RedisValue StringSetAndGet(RedisKey key, RedisValue value, TimeSpan? expiry = null, bool keepTtl = false, When when = When.Always, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.StringSetAndGet(key, value, expiry, keepTtl, when, flags); + } + + public bool KeyTouch(RedisKey key, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.KeyTouch(key, flags); + } + + public long KeyTouch(RedisKey[] keys, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.KeyTouch(keys, flags); + } + + public IAsyncEnumerable HashScanAsync(RedisKey key, RedisValue pattern = default, int pageSize = 250, long cursor = 0, int pageOffset = 0, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.HashScanAsync(key, pattern, pageSize, cursor, pageOffset, flags); + } + + public Task HashStringLengthAsync(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.HashStringLengthAsync(key, hashField, flags); + } + + public Task ListLeftPopAsync(RedisKey key, long count, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.ListLeftPopAsync(key, count, flags); + } + + public Task ListLeftPushAsync(RedisKey key, RedisValue[] values, When when = When.Always, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.ListLeftPushAsync(key, values, when, flags); + } + + public Task ListRightPopAsync(RedisKey key, long count, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.ListRightPopAsync(key, count, flags); + } + + public Task ListRightPushAsync(RedisKey key, RedisValue[] values, When when = When.Always, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.ListRightPushAsync(key, values, when, flags); + } + + public IAsyncEnumerable SetScanAsync(RedisKey key, RedisValue pattern = default, int pageSize = 250, long cursor = 0, int pageOffset = 0, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.SetScanAsync(key, pattern, pageSize, cursor, pageOffset, flags); + } + + public Task SortedSetRangeAndStoreAsync(RedisKey sourceKey, RedisKey destinationKey, RedisValue start, RedisValue stop, SortedSetOrder sortedSetOrder = SortedSetOrder.ByRank, Exclude exclude = Exclude.None, Order order = Order.Ascending, long skip = 0, long? take = null, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.SortedSetRangeAndStoreAsync(sourceKey, destinationKey, start, stop, sortedSetOrder, exclude, order, skip, take, flags); + } + + public IAsyncEnumerable SortedSetScanAsync(RedisKey key, RedisValue pattern = default, int pageSize = 250, long cursor = 0, int pageOffset = 0, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.SortedSetScanAsync(key, pattern, pageSize, cursor, pageOffset, flags); + } + + public Task StreamCreateConsumerGroupAsync(RedisKey key, RedisValue groupName, RedisValue? position = null, bool createStream = true, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.StreamCreateConsumerGroupAsync(key, groupName, position, createStream, flags); + } + + public Task StreamReadGroupAsync(RedisKey key, RedisValue groupName, RedisValue consumerName, RedisValue? position = null, int? count = null, bool noAck = false, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.StreamReadGroupAsync(key, groupName, consumerName, position, count, noAck, flags); + } + + public Task StreamReadGroupAsync(StreamPosition[] streamPositions, RedisValue groupName, RedisValue consumerName, int? countPerStream = null, bool noAck = false, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.StreamReadGroupAsync(streamPositions, groupName, consumerName, countPerStream, noAck, flags); + } + + public Task StringGetSetExpiryAsync(RedisKey key, TimeSpan? expiry, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.StringGetSetExpiryAsync(key, expiry, flags); + } + + public Task StringGetSetExpiryAsync(RedisKey key, DateTime expiry, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.StringGetSetExpiryAsync(key, expiry, flags); + } + + public Task StringGetDeleteAsync(RedisKey key, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.StringGetDeleteAsync(key, flags); + } + + public Task StringSetAsync(RedisKey key, RedisValue value, TimeSpan? expiry = null, bool keepTtl = false, When when = When.Always, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.StringSetAsync(key, value, expiry, keepTtl, when, flags); + } + + public Task StringSetAndGetAsync(RedisKey key, RedisValue value, TimeSpan? expiry, When when, CommandFlags flags) + { + _onCall(); + return _redisDb.StringSetAndGetAsync(key, value, expiry, when, flags); + } + + public Task StringSetAndGetAsync(RedisKey key, RedisValue value, TimeSpan? expiry = null, bool keepTtl = false, When when = When.Always, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.StringSetAndGetAsync(key, value, expiry, keepTtl, when, flags); + } + + public Task KeyTouchAsync(RedisKey key, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.KeyTouchAsync(key, flags); + } + + public Task KeyTouchAsync(RedisKey[] keys, CommandFlags flags = CommandFlags.None) + { + _onCall(); + return _redisDb.KeyTouchAsync(keys, flags); + } } } diff --git a/StackRedis.L1/RedisL1Database.cs b/StackRedis.L1/RedisL1Database.cs index ef48dc2..1f6a925 100644 --- a/StackRedis.L1/RedisL1Database.cs +++ b/StackRedis.L1/RedisL1Database.cs @@ -2698,5 +2698,261 @@ public void Dispose() DatabaseRegister.Instance.RemoveInstanceData(_uniqueId); _dbData.Dispose(); } + + public long HashStringLength(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.HashStringLength(key, hashField, flags); + } + + public RedisValue[] ListLeftPop(RedisKey key, long count, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.ListLeftPop(key, count, flags); + } + + public long ListLeftPush(RedisKey key, RedisValue[] values, When when = When.Always, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.ListLeftPush(key, values, when, flags); + } + + public RedisValue[] ListRightPop(RedisKey key, long count, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.ListRightPop(key, count, flags); + } + + public long ListRightPush(RedisKey key, RedisValue[] values, When when = When.Always, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.ListRightPush(key, values, when, flags); + } + + public long SortedSetRangeAndStore(RedisKey sourceKey, RedisKey destinationKey, RedisValue start, RedisValue stop, SortedSetOrder sortedSetOrder = SortedSetOrder.ByRank, Exclude exclude = Exclude.None, Order order = Order.Ascending, long skip = 0, long? take = null, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.SortedSetRangeAndStore(sourceKey, destinationKey, start, stop, sortedSetOrder, exclude, order, skip, take, flags); + } + + public bool StreamCreateConsumerGroup(RedisKey key, RedisValue groupName, RedisValue? position = null, bool createStream = true, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.StreamCreateConsumerGroup(key, groupName, position, createStream, flags); + } + + public StreamEntry[] StreamReadGroup(RedisKey key, RedisValue groupName, RedisValue consumerName, RedisValue? position = null, int? count = null, bool noAck = false, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.StreamReadGroup(key, groupName, consumerName, position, count, noAck, flags); + } + + public RedisStream[] StreamReadGroup(StreamPosition[] streamPositions, RedisValue groupName, RedisValue consumerName, int? countPerStream = null, bool noAck = false, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.StreamReadGroup(streamPositions, groupName, consumerName, countPerStream, noAck, flags); + } + + public RedisValue StringGetSetExpiry(RedisKey key, TimeSpan? expiry, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.StringGetSetExpiry(key, expiry, flags); + } + + public RedisValue StringGetSetExpiry(RedisKey key, DateTime expiry, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.StringGetSetExpiry(key, expiry, flags); + } + + public RedisValue StringGetDelete(RedisKey key, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + + var isInMemory = true; + var result = _dbData.MemoryStrings.GetFromMemory(key, () => + { + isInMemory = false; + return _redisDb.StringGetDelete(key, flags); + }); + + if (isInMemory) + { + _dbData.MemoryCache.Remove(new[] { key.ToString() }); + } + return result; + } + + public bool StringSet(RedisKey key, RedisValue value, TimeSpan? expiry = null, bool keepTtl = false, When when = When.Always, CommandFlags flags = CommandFlags.None) + { + _dbData.MemoryCache.Add(key, value, expiry, when); + return _redisDb == null || _redisDb.StringSet(key, value, expiry, keepTtl, when, flags); + } + + public RedisValue StringSetAndGet(RedisKey key, RedisValue value, TimeSpan? expiry, When when, CommandFlags flags) + { + if (_redisDb == null) throw new NotImplementedException(); + + _dbData.MemoryCache.Add(key, value, expiry, when); + return _redisDb.StringSetAndGet(key, value, expiry, when, flags); + } + + public RedisValue StringSetAndGet(RedisKey key, RedisValue value, TimeSpan? expiry = null, bool keepTtl = false, When when = When.Always, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + + _dbData.MemoryCache.Add(key, value, expiry, when); + return _redisDb.StringSetAndGet(key, value, expiry, keepTtl, when, flags); + } + + public bool KeyTouch(RedisKey key, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.KeyTouch(key, flags); + } + + public long KeyTouch(RedisKey[] keys, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.KeyTouch(keys, flags); + } + + public IAsyncEnumerable HashScanAsync(RedisKey key, RedisValue pattern = default, int pageSize = 250, long cursor = 0, int pageOffset = 0, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.HashScanAsync(key, pattern, pageSize, cursor, pageOffset, flags); + } + + public Task HashStringLengthAsync(RedisKey key, RedisValue hashField, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.HashStringLengthAsync(key, hashField, flags); + } + + public Task ListLeftPopAsync(RedisKey key, long count, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.ListLeftPopAsync(key, count, flags); + } + + public Task ListLeftPushAsync(RedisKey key, RedisValue[] values, When when = When.Always, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.ListLeftPushAsync(key, values, when, flags); + } + + public Task ListRightPopAsync(RedisKey key, long count, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.ListRightPopAsync(key, count, flags); + } + + public Task ListRightPushAsync(RedisKey key, RedisValue[] values, When when = When.Always, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.ListRightPushAsync(key, values, when, flags); + } + + public IAsyncEnumerable SetScanAsync(RedisKey key, RedisValue pattern = default, int pageSize = 250, long cursor = 0, int pageOffset = 0, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.SetScanAsync(key, pattern, pageSize, cursor, pageOffset, flags); + } + + public Task SortedSetRangeAndStoreAsync(RedisKey sourceKey, RedisKey destinationKey, RedisValue start, RedisValue stop, SortedSetOrder sortedSetOrder = SortedSetOrder.ByRank, Exclude exclude = Exclude.None, Order order = Order.Ascending, long skip = 0, long? take = null, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.SortedSetRangeAndStoreAsync(sourceKey, destinationKey, start, stop, sortedSetOrder, exclude, order, skip, take, flags); + } + + public IAsyncEnumerable SortedSetScanAsync(RedisKey key, RedisValue pattern = default, int pageSize = 250, long cursor = 0, int pageOffset = 0, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.SortedSetScanAsync(key, pattern, pageSize, cursor, pageOffset, flags); + } + + public Task StreamCreateConsumerGroupAsync(RedisKey key, RedisValue groupName, RedisValue? position = null, bool createStream = true, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.StreamCreateConsumerGroupAsync(key, groupName, position, createStream, flags); + } + + public Task StreamReadGroupAsync(RedisKey key, RedisValue groupName, RedisValue consumerName, RedisValue? position = null, int? count = null, bool noAck = false, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.StreamReadGroupAsync(key, groupName, consumerName, position, count, noAck, flags); + } + + public Task StreamReadGroupAsync(StreamPosition[] streamPositions, RedisValue groupName, RedisValue consumerName, int? countPerStream = null, bool noAck = false, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.StreamReadGroupAsync(streamPositions, groupName, consumerName, countPerStream, noAck, flags); + } + + public Task StringGetSetExpiryAsync(RedisKey key, TimeSpan? expiry, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.StringGetSetExpiryAsync(key, expiry, flags); + } + + public Task StringGetSetExpiryAsync(RedisKey key, DateTime expiry, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.StringGetSetExpiryAsync(key, expiry, flags); + } + + public async Task StringGetDeleteAsync(RedisKey key, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + + var isInMemory = true; + var result = await _dbData.MemoryStrings.GetFromMemoryAsync(key, async () => + { + isInMemory = false; + return await _redisDb.StringGetDeleteAsync(key, flags).ConfigureAwait(false); + }); + + if (isInMemory) + { + _dbData.MemoryCache.Remove(new[] { key.ToString() }); + } + return result; + } + + public Task StringSetAsync(RedisKey key, RedisValue value, TimeSpan? expiry = null, bool keepTtl = false, When when = When.Always, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + + _dbData.MemoryCache.Add(key, value, expiry, when); + return _redisDb.StringSetAsync(key, value, expiry, keepTtl, when, flags); + } + + public Task StringSetAndGetAsync(RedisKey key, RedisValue value, TimeSpan? expiry, When when, CommandFlags flags) + { + if (_redisDb == null) throw new NotImplementedException(); + + _dbData.MemoryCache.Add(key, value, expiry, when); + return _redisDb.StringSetAndGetAsync(key, value, expiry, when, flags); + } + + public Task StringSetAndGetAsync(RedisKey key, RedisValue value, TimeSpan? expiry = null, bool keepTtl = false, When when = When.Always, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + + _dbData.MemoryCache.Add(key, value, expiry, when); + return _redisDb.StringSetAndGetAsync(key, value, expiry, keepTtl, when, flags); + } + + public Task KeyTouchAsync(RedisKey key, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.KeyTouchAsync(key, flags); + } + + public Task KeyTouchAsync(RedisKey[] keys, CommandFlags flags = CommandFlags.None) + { + if (_redisDb == null) throw new NotImplementedException(); + return _redisDb.KeyTouchAsync(keys, flags); + } } } diff --git a/StackRedis.L1/StackRedis.L1.csproj b/StackRedis.L1/StackRedis.L1.csproj index e200eb8..ca613f4 100644 --- a/StackRedis.L1/StackRedis.L1.csproj +++ b/StackRedis.L1/StackRedis.L1.csproj @@ -1,11 +1,11 @@  - netstandard2.0;net472 + netstandard2.1;netstandard2.0;net472 StackRedis.L1 StackRedis.L1 Copyright © 2019 bin\$(Configuration)\ - 0.2.6 + 0.3.0 true johnnycardy, stepaside https://raw.githubusercontent.com/johnnycardy/StackRedis.L1/master/LICENSE @@ -20,7 +20,7 @@ pdbonly - - + + \ No newline at end of file