public void GetLockAge_ValidTicks()
{
var mockRedisClient = A.Fake<IRedisClientConnection>();
RedisConnectionWrapper.sharedConnection = new RedisSharedConnection(null, null);
RedisConnectionWrapper.sharedConnection.connection = mockRedisClient;
RedisConnectionWrapper redisConn = new RedisConnectionWrapper(Utility.GetDefaultConfigUtility(), "");
Assert.NotNull(redisConn.GetLockAge(DateTime.Now.Ticks));
}
public void GetLockAge_InValidTicks()
{
var mockRedisClient = A.Fake<IRedisClientConnection>();
RedisConnectionWrapper.sharedConnection = new RedisSharedConnection(null, null);
RedisConnectionWrapper.sharedConnection.connection = mockRedisClient;
RedisConnectionWrapper redisConn = new RedisConnectionWrapper(Utility.GetDefaultConfigUtility(), "");
Assert.NotEqual(0, redisConn.GetLockAge("Invalid-tics").TotalHours);
}
private RedisConnectionWrapper GetRedisConnectionWrapperWithUniqueSession(ProviderConfiguration pc)
{
string id = Guid.NewGuid().ToString();
uniqueSessionNumber++;
// Initial connection with redis
RedisConnectionWrapper.sharedConnection = null;
RedisConnectionWrapper redisConn = new RedisConnectionWrapper(pc, id);
return redisConn;
}
public void UpdateExpiryTime_Valid()
{
string sessionId = "session_id";
var mockRedisClient = A.Fake<IRedisClientConnection>();
RedisConnectionWrapper.sharedConnection = new RedisSharedConnection(null, null);
RedisConnectionWrapper.sharedConnection.connection = mockRedisClient;
RedisConnectionWrapper redisConn = new RedisConnectionWrapper(Utility.GetDefaultConfigUtility(), sessionId);
redisConn.UpdateExpiryTime(90);
A.CallTo(() => mockRedisClient.Eval(A<string>.Ignored, A<string[]>.That.Matches(s => s.Length == 2),
A<object[]>.That.Matches(o => o.Length == 1))).MustHaveHappened();
}
public void Set_NullData()
{
var mockRedisClient = A.Fake<IRedisClientConnection>();
RedisConnectionWrapper.sharedConnection = new RedisSharedConnection(null, null);
RedisConnectionWrapper.sharedConnection.connection = mockRedisClient;
string sessionId = "session_id";
RedisConnectionWrapper redisConn = new RedisConnectionWrapper(Utility.GetDefaultConfigUtility(), sessionId);
redisConn.Set(null, 90);
A.CallTo(() => mockRedisClient.Eval(A<string>.Ignored, A<string[]>.Ignored, A<object[]>.Ignored)).MustNotHaveHappened();
}
public void Set_ValidData()
{
string sessionId = "session_id";
var mockRedisClient = A.Fake<IRedisClientConnection>();
RedisConnectionWrapper.sharedConnection = new RedisSharedConnection(null, null);
RedisConnectionWrapper.sharedConnection.connection = mockRedisClient;
RedisConnectionWrapper redisConn = new RedisConnectionWrapper(Utility.GetDefaultConfigUtility(), sessionId);
ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection();
data["key"] = "value";
redisConn.Set(data, 90);
A.CallTo(() => mockRedisClient.Eval(A<string>.Ignored, A<string[]>.That.Matches(s => s.Length == 2),
A<object[]>.That.Matches(o => o.Length == 4))).MustHaveHappened();
}
public void Set_ValidData_WithCustomSerializer()
{
// this also tests host:port config part
ProviderConfiguration pc = Utility.GetDefaultConfigUtility();
pc.RedisSerializerType = typeof(TestSerializer).AssemblyQualifiedName;
pc.ApplicationName = "APPTEST";
pc.Port = 6379;
RedisUtility testSerializerRedisUtility = new RedisUtility(pc);
using (RedisServer redisServer = new RedisServer())
{
RedisConnectionWrapper redisConn = GetRedisConnectionWrapperWithUniqueSession(pc);
// Inserting data into redis server
ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection(testSerializerRedisUtility);
data["key"] = "value";
data["key1"] = "value1";
redisConn.Set(data, 900);
// Get actual connection and get data blob from redis
IDatabase actualConnection = GetRealRedisConnection(redisConn);
HashEntry[] sessionDataFromRedis = actualConnection.HashGetAll(redisConn.Keys.DataKey);
// Check that data shoud be same as what inserted
Assert.Equal(2, sessionDataFromRedis.Length);
ChangeTrackingSessionStateItemCollection dataFromRedis = new ChangeTrackingSessionStateItemCollection(testSerializerRedisUtility);
foreach (HashEntry entry in sessionDataFromRedis)
{
dataFromRedis[entry.Name] = testSerializerRedisUtility.GetObjectFromBytes(entry.Value).ToString();
}
Assert.Equal("value", dataFromRedis["key"]);
Assert.Equal("value1", dataFromRedis["key1"]);
// remove data from redis
actualConnection.KeyDelete(redisConn.Keys.DataKey);
DisposeRedisConnectionWrapper(redisConn);
}
}
public void TryTakeWriteLockAndGetData_Valid()
{
string id = "session_id";
DateTime lockTime = DateTime.Now;
int lockTimeout = 90;
object lockId;
ISessionStateItemCollection data;
RedisConnectionWrapper.sharedConnection = A.Fake <RedisSharedConnection>();
RedisConnectionWrapper redisConn = new RedisConnectionWrapper(Utility.GetDefaultConfigUtility(), id);
redisConn.redisConnection = A.Fake <IRedisClientConnection>();
object[] sessionData = { "Key", RedisUtility.GetBytesFromObject("Key", "value") };
object[] returnFromRedis = { lockTime.Ticks.ToString(), sessionData, "15", false };
ChangeTrackingSessionStateItemCollection sessionDataReturn = Utility.GetChangeTrackingSessionStateItemCollection();
sessionDataReturn["key"] = "value";
A.CallTo(() => redisConn.redisConnection.Eval(A <string> .Ignored, A <string[]> .That.Matches(s => s.Length == 3),
A <object[]> .That.Matches(o => o.Length == 2))).Returns(returnFromRedis);
A.CallTo(() => redisConn.redisConnection.GetLockId(A <object> .Ignored)).Returns(lockTime.Ticks.ToString());
A.CallTo(() => redisConn.redisConnection.IsLocked(A <object> .Ignored)).Returns(false);
A.CallTo(() => redisConn.redisConnection.GetSessionData(A <object> .Ignored)).Returns(sessionDataReturn);
A.CallTo(() => redisConn.redisConnection.GetSessionTimeout(A <object> .Ignored)).Returns(15);
int sessionTimeout;
Assert.True(redisConn.TryTakeWriteLockAndGetData(lockTime, lockTimeout, out lockId, out data, out sessionTimeout));
Assert.Equal(lockTime.Ticks.ToString(), lockId);
Assert.Equal(1, data.Count);
Assert.Equal(15, sessionTimeout);
A.CallTo(() => redisConn.redisConnection.Eval(A <string> .Ignored, A <string[]> .That.Matches(s => s.Length == 3),
A <object[]> .That.Matches(o => o.Length == 2))).MustHaveHappened();
A.CallTo(() => redisConn.redisConnection.GetLockId(A <object> .Ignored)).MustHaveHappened();
A.CallTo(() => redisConn.redisConnection.IsLocked(A <object> .Ignored)).MustHaveHappened();
A.CallTo(() => redisConn.redisConnection.GetSessionData(A <object> .Ignored)).MustHaveHappened();
A.CallTo(() => redisConn.redisConnection.GetSessionTimeout(A <object> .Ignored)).MustHaveHappened();
}
public static IServiceCollection AddBasicServices(this IServiceCollection collection)
{
var config = collection.GetConfiguration();
var env = collection.GetHostingEnvironment();
if (collection.Where(x => x.ServiceType == typeof(ISerializeProvider)).IsEmpty_())
{
AddBasicNoDependencyServices(collection);
}
//加密相关
var data_protect_builder = collection.AddFileBasedDataProtection_(config, env);
//----------------------------------------------------------------------------------
//redis-connection
var redis_server = config.GetRedisConnectionString();
if (ValidateHelper.IsNotEmpty(redis_server))
{
var redis_wrapper = new RedisConnectionWrapper(redis_server);
collection.AddDisposableSingleInstanceService(redis_wrapper);
//redis kv存储
collection.AddScoped <IRedisAll>(provider =>
{
var kv_db = (int)ConfigSet.Redis.KV存储;
var serializer = provider.Resolve_ <ISerializeProvider>();
var helper = new RedisHelper(redis_wrapper.Connection, kv_db, serializer);
return(helper);
});
//使用redis替换内存缓存
collection.AddRedisCacheProvider_(redis_server);
//加密私钥
var db = (int)ConfigSet.Redis.加密KEY;
var app_name = config.GetAppName();
data_protect_builder.PersistKeysToStackExchangeRedis(
() => redis_wrapper.Connection.SelectDatabase(db),
$"data_protection_key:{app_name}");
}
return(collection);
}
public void Set_ExpireData()
{
using (RedisServer redisServer = new RedisServer())
{
RedisConnectionWrapper redisConn = GetRedisConnectionWrapperWithUniqueSession();
// Inserting data into redis server that expires after 1 second
ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection();
data["key"] = "value";
redisConn.Set(data, 1);
// Wait for 2 seconds so that data will expire
System.Threading.Thread.Sleep(1100);
// Get actual connection and get data blob from redis
IDatabase actualConnection = GetRealRedisConnection(redisConn);
HashEntry[] sessionDataFromRedis = actualConnection.HashGetAll(redisConn.Keys.DataKey);
// Check that data shoud not be there
Assert.Equal(0, sessionDataFromRedis.Length);
DisposeRedisConnectionWrapper(redisConn);
}
}
public void TryUpdateIfLockIdMatch_ExpiryTime_OnValidData()
{
ProviderConfiguration pc = Utility.GetDefaultConfigUtility();
using (RedisServer redisServer = new RedisServer())
{
RedisConnectionWrapper redisConn = GetRedisConnectionWrapperWithUniqueSession();
// Inserting data into redis server
ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection(new RedisUtility(pc));
data["key"] = "value";
data["key1"] = "value1";
redisConn.Set(data, 900);
// Check that data shoud exists
int lockTimeout = 90;
DateTime lockTime = DateTime.Now;
object lockId;
ISessionStateItemCollection dataFromRedis;
int sessionTimeout;
redisConn.TryTakeWriteLockAndGetData(lockTime, lockTimeout, out lockId, out dataFromRedis, out sessionTimeout);
Assert.Equal(2, dataFromRedis.Count);
// Update expiry time to only 1 sec and than verify that.
redisConn.TryUpdateAndReleaseLockIfLockIdMatch(lockId, dataFromRedis, 1);
// Wait for 1.1 seconds so that data will expire
System.Threading.Thread.Sleep(1100);
// Get data blob from redis
IDatabase actualConnection = GetRealRedisConnection(redisConn);
HashEntry[] sessionDataFromRedisAfterExpire = actualConnection.HashGetAll(redisConn.Keys.DataKey);
// Check that data shoud not be there
Assert.Equal(0, sessionDataFromRedisAfterExpire.Length);
DisposeRedisConnectionWrapper(redisConn);
}
}
public void TryTakeWriteLockAndGetData_WriteLockWithOtherWriteLockWithSameLockId()
{
using (RedisServer redisServer = new RedisServer())
{
RedisConnectionWrapper redisConn = GetRedisConnectionWrapperWithUniqueSession();
// Inserting data into redis server
ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection();
data["key"] = "value";
redisConn.Set(data, 900);
int lockTimeout = 900;
// Same LockId
DateTime lockTime = DateTime.Now;
// Takewrite lock successfully first time
object lockId_1;
ISessionStateItemCollection dataFromRedis_1;
int sessionTimeout;
Assert.True(redisConn.TryTakeWriteLockAndGetData(lockTime, lockTimeout, out lockId_1, out dataFromRedis_1, out sessionTimeout));
Assert.Equal(lockTime.Ticks.ToString(), lockId_1.ToString());
Assert.Equal(1, dataFromRedis_1.Count);
// try to take write lock and fail and get earlier lock id
object lockId_2;
ISessionStateItemCollection dataFromRedis_2;
Assert.False(redisConn.TryTakeWriteLockAndGetData(lockTime, lockTimeout, out lockId_2, out dataFromRedis_2, out sessionTimeout));
Assert.Equal(lockTime.Ticks.ToString(), lockId_2.ToString());
Assert.Equal(null, dataFromRedis_2);
// Get actual connection
IDatabase actualConnection = GetRealRedisConnection(redisConn);
// remove data and lock from redis
actualConnection.KeyDelete(redisConn.Keys.DataKey);
actualConnection.KeyDelete(redisConn.Keys.LockKey);
DisposeRedisConnectionWrapper(redisConn);
}
}
public void TryTakeReadLockAndGetData_WithOtherWriteLock()
{
ProviderConfiguration pc = Utility.GetDefaultConfigUtility();
using (RedisServer redisServer = new RedisServer())
{
RedisConnectionWrapper redisConn = GetRedisConnectionWrapperWithUniqueSession();
// Inserting data into redis server
ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection(new RedisUtility(pc));
data["key"] = "value";
redisConn.Set(data, 900);
int lockTimeout = 900;
DateTime lockTime_1 = DateTime.Now;
object lockId_1;
ISessionStateItemCollection dataFromRedis_1;
int sessionTimeout;
Assert.True(redisConn.TryTakeWriteLockAndGetData(lockTime_1, lockTimeout, out lockId_1, out dataFromRedis_1, out sessionTimeout));
Assert.Equal(lockTime_1.Ticks.ToString(), lockId_1.ToString());
Assert.Equal(1, dataFromRedis_1.Count);
object lockId_2;
ISessionStateItemCollection dataFromRedis_2;
Assert.False(redisConn.TryCheckWriteLockAndGetData(out lockId_2, out dataFromRedis_2, out sessionTimeout));
Assert.Equal(lockTime_1.Ticks.ToString(), lockId_2.ToString());
Assert.Equal(null, dataFromRedis_2);
// Get actual connection
// remove data and lock from redis
IDatabase actualConnection = GetRealRedisConnection(redisConn);
actualConnection.KeyDelete(redisConn.Keys.DataKey);
actualConnection.KeyDelete(redisConn.Keys.LockKey);
DisposeRedisConnectionWrapper(redisConn);
}
}
public void TryReleaseLockIfLockIdMatch_InvalidWriteLockRelease()
{
ProviderConfiguration pc = Utility.GetDefaultConfigUtility();
using (RedisServer redisServer = new RedisServer())
{
RedisConnectionWrapper redisConn = GetRedisConnectionWrapperWithUniqueSession();
// Inserting data into redis server
ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection(new RedisUtility(pc));
data["key"] = "value";
redisConn.Set(data, 900);
int lockTimeout = 900;
DateTime lockTime = DateTime.Now;
object lockId;
ISessionStateItemCollection dataFromRedis;
int sessionTimeout;
Assert.True(redisConn.TryTakeWriteLockAndGetData(lockTime, lockTimeout, out lockId, out dataFromRedis, out sessionTimeout));
Assert.Equal(lockTime.Ticks.ToString(), lockId.ToString());
Assert.Equal(1, dataFromRedis.Count);
object wrongLockId = lockTime.AddSeconds(1).Ticks.ToString();
redisConn.TryReleaseLockIfLockIdMatch(wrongLockId, 900);
// Get actual connection and check that lock do not exists
IDatabase actualConnection = GetRealRedisConnection(redisConn);
string lockValueFromRedis = actualConnection.StringGet(redisConn.Keys.LockKey);
Assert.Equal(lockId, lockValueFromRedis);
// remove data from redis
actualConnection.KeyDelete(redisConn.Keys.DataKey);
actualConnection.KeyDelete(redisConn.Keys.LockKey);
DisposeRedisConnectionWrapper(redisConn);
}
}
public void TryCheckWriteLockAndGetData_Valid()
{
string id = "session_id";
object lockId;
ISessionStateItemCollection data;
object[] sessionData = { "Key", RedisUtility.GetBytesFromObject("value") };
object[] returnFromRedis = { "", sessionData, "15" };
ChangeTrackingSessionStateItemCollection sessionDataReturn = new ChangeTrackingSessionStateItemCollection();
sessionDataReturn["key"] = "value";
var mockRedisClient = A.Fake <IRedisClientConnection>();
A.CallTo(() => mockRedisClient.Eval(A <string> .Ignored, A <string[]> .That.Matches(s => s.Length == 3),
A <object[]> .That.Matches(o => o.Length == 0))).Returns(returnFromRedis);
A.CallTo(() => mockRedisClient.GetLockId(A <object> .Ignored)).Returns("");
A.CallTo(() => mockRedisClient.GetSessionData(A <object> .Ignored)).Returns(sessionDataReturn);
A.CallTo(() => mockRedisClient.GetSessionTimeout(A <object> .Ignored)).Returns(15);
RedisConnectionWrapper.sharedConnection = new RedisSharedConnection(null, null);
RedisConnectionWrapper.sharedConnection.connection = mockRedisClient;
RedisConnectionWrapper redisConn = new RedisConnectionWrapper(Utility.GetDefaultConfigUtility(), id);
int sessionTimeout;
Assert.True(redisConn.TryCheckWriteLockAndGetData(out lockId, out data, out sessionTimeout));
Assert.Equal(null, lockId);
Assert.Equal(1, data.Count);
Assert.Equal(15, sessionTimeout);
A.CallTo(() => mockRedisClient.Eval(A <string> .Ignored, A <string[]> .That.Matches(s => s.Length == 3),
A <object[]> .That.Matches(o => o.Length == 0))).MustHaveHappened();
A.CallTo(() => mockRedisClient.GetLockId(A <object> .Ignored)).MustHaveHappened();
A.CallTo(() => mockRedisClient.GetSessionData(A <object> .Ignored)).MustHaveHappened();
A.CallTo(() => mockRedisClient.GetSessionTimeout(A <object> .Ignored)).MustHaveHappened();
}
public void TryTakeWriteLockAndGetData_ExpireWriteLock()
{
ProviderConfiguration pc = Utility.GetDefaultConfigUtility();
using (RedisServer redisServer = new RedisServer())
{
RedisConnectionWrapper redisConn = GetRedisConnectionWrapperWithUniqueSession();
// Inserting data into redis server
ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection(new RedisUtility(pc));
data["key"] = "value";
redisConn.Set(data, 900);
int lockTimeout = 1;
DateTime lockTime = DateTime.Now;
object lockId;
ISessionStateItemCollection dataFromRedis;
int sessionTimeout;
Assert.True(redisConn.TryTakeWriteLockAndGetData(lockTime, lockTimeout, out lockId, out dataFromRedis, out sessionTimeout));
Assert.Equal(lockTime.Ticks.ToString(), lockId.ToString());
Assert.Equal(1, dataFromRedis.Count);
// Wait for 2 seconds so that lock will expire
System.Threading.Thread.Sleep(1100);
// Get actual connection and check that lock do not exists
IDatabase actualConnection = GetRealRedisConnection(redisConn);
string lockValueFromRedis = actualConnection.StringGet(redisConn.Keys.LockKey);
Assert.Equal(null, lockValueFromRedis);
// remove data from redis
actualConnection.KeyDelete(redisConn.Keys.DataKey);
DisposeRedisConnectionWrapper(redisConn);
}
}
private void DisposeRedisConnectionWrapper(RedisConnectionWrapper redisConn)
{
redisConn.redisConnection.Close();
RedisConnectionWrapper.sharedConnection = null;
}
private void DisposeRedisConnectionWrapper(RedisConnectionWrapper redisConn)
{
redisConn.redisConnection.Close();
RedisConnectionWrapper.sharedConnection = null;
}
public void TryTakeWriteLockAndGetData_UnableToLock()
{
string id = "session_id";
DateTime lockTime = DateTime.Now;
int lockTimeout = 90;
object lockId;
ISessionStateItemCollection data;
object[] returnFromRedis = { "Diff-lock-id", "", "15", true };
var mockRedisClient = A.Fake<IRedisClientConnection>();
A.CallTo(() => mockRedisClient.Eval(A<string>.Ignored, A<string[]>.That.Matches(s => s.Length == 3),
A<object[]>.That.Matches(o => o.Length == 2))).Returns(returnFromRedis);
A.CallTo(() => mockRedisClient.GetLockId(A<object>.Ignored)).Returns("Diff-lock-id");
A.CallTo(() => mockRedisClient.IsLocked(A<object>.Ignored)).Returns(true);
A.CallTo(() => mockRedisClient.GetSessionTimeout(A<object>.Ignored)).Returns(15);
RedisConnectionWrapper.sharedConnection = new RedisSharedConnection(null, null);
RedisConnectionWrapper.sharedConnection.connection = mockRedisClient;
RedisConnectionWrapper redisConn = new RedisConnectionWrapper(Utility.GetDefaultConfigUtility(), id);
int sessionTimeout;
Assert.False(redisConn.TryTakeWriteLockAndGetData(lockTime, lockTimeout, out lockId, out data, out sessionTimeout));
Assert.Equal("Diff-lock-id", lockId);
Assert.Null(data);
Assert.Equal(15, sessionTimeout);
A.CallTo(() => mockRedisClient.Eval(A<string>.Ignored, A<string[]>.That.Matches(s => s.Length == 3),
A<object[]>.That.Matches(o => o.Length == 2))).MustHaveHappened();
A.CallTo(() => mockRedisClient.GetLockId(A<object>.Ignored)).MustHaveHappened();
A.CallTo(() => mockRedisClient.IsLocked(A<object>.Ignored)).MustHaveHappened();
A.CallTo(() => mockRedisClient.GetSessionData(A<object>.Ignored)).MustNotHaveHappened();
A.CallTo(() => mockRedisClient.GetSessionTimeout(A<object>.Ignored)).MustHaveHappened();
}
public RedisCacheProvider_(IServiceProvider provider, RedisConnectionWrapper con, int db, ILogger <RedisCacheProvider_> logger)
{
this._redis = new RedisHelper(con.Connection, db, provider.ResolveSerializer());
this._db = this._redis.Database;
this._logger = logger;
}
public RedisDatabaseSelector(RedisConnectionWrapper redisConnectionWrapper)
{
var db = (int)WCloud.Core.ConfigSet.Redis.消息队列;
this.database = redisConnectionWrapper.Connection.GetDatabase(db);
}
static void Main(string[] args)
{
var redisConnectionWrapper = new RedisConnectionWrapper("***,defaultDatabase=0,password=***");
#region 手动发布-信道a
//using (var redisManager = new RedisCacheManager(redisConnectionWrapper))
//{
// for (int i = 0; i < 10000; i++)
// {
// Thread.Sleep(1000);
// redisManager.PublishAsync("a", i.ToString()).Wait();
// Console.WriteLine($"发布信道a...值：{i}");
// }
//}
#endregion
#region 修改键mykey,测试键监听订阅
//因为开启键空间通知功能需要消耗一些 CPU ， 所以在默认配置下， 该功能处于关闭状态。
//可以通过修改 redis.conf 文件， 或者直接使用 CONFIG SET 命令来开启或关闭键空间通知功能：
//当 notify-keyspace - events 选项的参数为空字符串时，功能关闭。
//另一方面，当参数不是空字符串时，功能开启。
//notify - keyspace - events 的参数可以是以下字符的任意组合， 它指定了服务器该发送哪些类型的通知：
//\begin{ array}
// [b] {| c |}
//\hline 字符 &发送的通知 \\
//\hline K &键空间通知，所有通知以 `__keyspace@< db > __` 为前缀 \\
//\hline E &键事件通知，所有通知以 `__keyevent@< db > __` 为前缀 \\
//\hline g &DEL 、 EXPIRE 、 RENAME 等类型无关的通用命令的通知 \\
//\hline $ &字符串命令的通知 \\
//\hline l &列表命令的通知 \\
//\hline s &集合命令的通知 \\
//\hline h &哈希命令的通知 \\
//\hline z &有序集合命令的通知 \\
//\hline x &过期事件：每当有过期键被删除时发送 \\
//\hline e &驱逐(evict)事件：每当有键因为 maxmemory 政策而被删除时发送 \\
//\hline A &参数 g$lshzxe 的别名，即all \\
//\end{ array} \\
//输入的参数中至少要有一个 K 或者 E ， 否则的话， 不管其余的参数是什么， 都不会有任何通知被分发。
//举个例子， 如果只想订阅键空间中和列表相关的通知， 那么参数就应该设为 Kl ， 诸如此类。
//将参数设为字符串 "AKE" 表示发送所有类型的通知。
using (var redis = new RedisCacheManager(redisConnectionWrapper))
{
for (int i = 0; i < 100000; i++)
{
Thread.Sleep(1000);
redis.Set("mykey", i, 1000);
Console.WriteLine($"写入mykey:{i}");
}
}
#endregion
Console.ReadKey();
}
public RedisCacheProvider_(RedisConnectionWrapper con, int db)
{
this._redis = new RedisHelper(con.Connection, db);
this._db = this._redis.Database;
}
private void DisposeRedisConnectionWrapper(RedisConnectionWrapper redisConn)
{
RedisConnectionWrapper.sharedConnection = null;
}
public void TryUpdateIfLockIdMatchPrepare_Valid_OneUpdateOneDelete()
{
string id = "session_id";
int sessionTimeout = 900;
object lockId = DateTime.Now.Ticks;
ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection();
data["KeyDel"] = "valueDel";
data["Key"] = "value";
data.Remove("KeyDel");
var mockRedisClient = A.Fake<IRedisClientConnection>();
RedisConnectionWrapper.sharedConnection = new RedisSharedConnection(null, null);
RedisConnectionWrapper.sharedConnection.connection = mockRedisClient;
RedisConnectionWrapper redisConn = new RedisConnectionWrapper(Utility.GetDefaultConfigUtility(), id);
redisConn.TryUpdateAndReleaseLockIfLockIdMatch(lockId, data, sessionTimeout);
A.CallTo(() => mockRedisClient.Eval(A<string>.Ignored, A<string[]>.That.Matches(s => s.Length == 3), A<object[]>.That.Matches(
o => o.Length == 11 &&
o[2].Equals(1) &&
o[3].Equals(9) &&
o[4].Equals(9) &&
o[5].Equals(1) &&
o[6].Equals(10) &&
o[7].Equals(11)
))).MustHaveHappened();
}
/// <summary>
/// Helper method for serializing objects to Redis
/// </summary>
/// <param name="confirmedChangedObjects">keys and values that have definitely changed</param>
/// <param name="allObjects">keys and values that have been accessed during the current HttpContext</param>
/// <param name="allObjectsOriginalState">keys and serialized values before we tampered with them</param>
/// <param name="deletedObjects">keys that were deleted during the current HttpContext</param>
/// <param name="currentRedisHashId">The current Redis key name</param>
/// <param name="redisConn">A connection to Redis</param>
public static void SerializeToRedis(
HttpContextBase context,
RedisSessionStateItemCollection redisItems,
string currentRedisHashId,
TimeSpan expirationTimeout)
{
List <HashEntry> setItems = new List <HashEntry>();
List <RedisValue> delItems = new List <RedisValue>();
RedisConnectionWrapper rConnWrap = RedisSessionStateStoreProvider.RedisConnWrapperFromContext(
context);
// Determine if we are adding or removing keys, separate them into their own lists
// note that redisItems.GetChangedObjectsEnumerator contains complex logic
foreach (KeyValuePair <string, string> changedObj in
redisItems.GetChangedObjectsEnumerator())
{
if (changedObj.Value != null)
{
setItems.Add(
new HashEntry(
changedObj.Key,
changedObj.Value));
}
else
{
delItems.Add(changedObj.Key);
}
}
IDatabase redisConn = rConnWrap.GetConnection();
if (setItems.Count > 0)
{
HashEntry[] writeItems = setItems.ToArray();
redisConn.HashSet(
currentRedisHashId,
writeItems,
CommandFlags.FireAndForget);
// call appropriate delegate if set for changing keys
if (RedisSessionConfig.RedisWriteFieldDel != null)
{
RedisSessionConfig.RedisWriteFieldDel(
context,
writeItems,
currentRedisHashId);
}
}
if (delItems != null && delItems.Count > 0)
{
RedisValue[] removeItems = delItems.ToArray();
redisConn.HashDelete(
currentRedisHashId,
removeItems,
CommandFlags.FireAndForget);
// call appropriate delegate if set for removing keys
if (RedisSessionConfig.RedisRemoveFieldDel != null)
{
RedisSessionConfig.RedisRemoveFieldDel(
context,
removeItems,
currentRedisHashId);
}
}
// always refresh the timeout of the session hash
redisConn.KeyExpire(
currentRedisHashId,
expirationTimeout,
CommandFlags.FireAndForget);
}
public MainHub()
{
var wrapper = new RedisConnectionWrapper("redisblorem");
_cache = new RedisCacheManager(wrapper);
}
private IDatabase GetRealRedisConnection(RedisConnectionWrapper redisConn)
{
return((IDatabase)((StackExchangeClientConnection)redisConn.redisConnection).RealConnection);
}
public void TryCheckWriteLockAndGetData_Valid()
{
string id = "session_id";
object lockId;
ISessionStateItemCollection data;
object[] sessionData = { "Key", RedisUtility.GetBytesFromObject("value") };
object[] returnFromRedis = { "", sessionData, "15" };
ChangeTrackingSessionStateItemCollection sessionDataReturn = new ChangeTrackingSessionStateItemCollection();
sessionDataReturn["key"] = "value";
var mockRedisClient = A.Fake<IRedisClientConnection>();
A.CallTo(() => mockRedisClient.Eval(A<string>.Ignored, A<string[]>.That.Matches(s => s.Length == 3),
A<object[]>.That.Matches(o => o.Length == 0))).Returns(returnFromRedis);
A.CallTo(() => mockRedisClient.GetLockId(A<object>.Ignored)).Returns("");
A.CallTo(() => mockRedisClient.GetSessionData(A<object>.Ignored)).Returns(sessionDataReturn);
A.CallTo(() => mockRedisClient.GetSessionTimeout(A<object>.Ignored)).Returns(15);
RedisConnectionWrapper.sharedConnection = new RedisSharedConnection(null, null);
RedisConnectionWrapper.sharedConnection.connection = mockRedisClient;
RedisConnectionWrapper redisConn = new RedisConnectionWrapper(Utility.GetDefaultConfigUtility(), id);
int sessionTimeout;
Assert.True(redisConn.TryCheckWriteLockAndGetData(out lockId, out data, out sessionTimeout));
Assert.Equal(null, lockId);
Assert.Equal(1, data.Count);
Assert.Equal(15, sessionTimeout);
A.CallTo(() => mockRedisClient.Eval(A<string>.Ignored, A<string[]>.That.Matches(s => s.Length == 3),
A<object[]>.That.Matches(o => o.Length == 0))).MustHaveHappened();
A.CallTo(() => mockRedisClient.GetLockId(A<object>.Ignored)).MustHaveHappened();
A.CallTo(() => mockRedisClient.GetSessionData(A<object>.Ignored)).MustHaveHappened();
A.CallTo(() => mockRedisClient.GetSessionTimeout(A<object>.Ignored)).MustHaveHappened();
}
private IDatabase GetRealRedisConnection(RedisConnectionWrapper redisConn)
{
return (IDatabase)((StackExchangeClientConnection)redisConn.redisConnection).RealConnection;
}
public void TryRemoveIfLockIdMatch_Valid()
{
string id = "session_id";
object lockId = DateTime.Now.Ticks;
var mockRedisClient = A.Fake<IRedisClientConnection>();
RedisConnectionWrapper.sharedConnection = new RedisSharedConnection(null, null);
RedisConnectionWrapper.sharedConnection.connection = mockRedisClient;
RedisConnectionWrapper redisConn = new RedisConnectionWrapper(Utility.GetDefaultConfigUtility(), id);
redisConn.TryRemoveAndReleaseLockIfLockIdMatch(lockId);
A.CallTo(() => mockRedisClient.Eval(A<string>.Ignored, A<string[]>.That.Matches(s => s.Length == 3),
A<object[]>.That.Matches(o => o.Length == 1))).MustHaveHappened();
}
