/// <summary>
/// 初始化数据库环境、实例化子类中，所有Set属性
/// </summary>
public void Initializer()
{
if (IsInitializer)
{
return;
}
_client = new RedisClient(_redisConnection);
IsInitializer = true;
Connection = new RedisConnection(_client);
Hash = new RedisHash(_client);
Key = new RedisKey(_client);
List = new RedisList(_client);
PubSub = new RedisPubSub(_client);
Script = new RedisScript(_client);
Server = new RedisServer(_client);
Set = new RedisSet(_client);
SortedSet = new RedisSortedSet(_client);
String = new RedisString(_client);
Transaction = new RedisTransaction(_client);
Bit = new RedisBit(_client);
Expire = new RedisExpire(_client);
Sort = new RedisSort(_client);
Number = new RedisNumber(_client);
}
public void Setup()
{
mainIndexManager = new Mock <IMainIndexManager>();
link = new Mock <IRedisLink>();
link.Setup(item => item.Resilience).Returns(new ResilienceHandler(new NullLogger <ResilienceHandler>(), new ResilienceConfig()));
transaction = new Mock <ITransaction>();
instance = new RedisTransaction(new NullLoggerFactory(), link.Object, transaction.Object, mainIndexManager.Object);
}
public RedisClient(IRedisSocket socket, EndPoint endpoint, int asyncConcurrency, int asyncBufferSize)
{
_connector = new RedisConnector(endpoint, socket, asyncConcurrency, asyncBufferSize);
_transaction = new RedisTransaction(_connector);
_subscription = new SubscriptionListener(_connector);
_monitor = new MonitorListener(_connector);
_subscription.MessageReceived += OnSubscriptionReceived;
_subscription.Changed += OnSubscriptionChanged;
_monitor.MonitorReceived += OnMonitorReceived;
_connector.Connected += OnConnectionConnected;
_transaction.TransactionQueued += OnTransactionQueued;
}
internal RedisClient(IRedisSocket socket, EndPoint endpoint, int asyncConcurrency, int asyncBufferSize)
{
// use invariant culture - we have to set it explicitly for every thread we create to
// prevent any floating-point problems (mostly because of number formats in non en-US cultures).
//CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture; 这行会影响 string.Compare 结果
_connector = new RedisConnector(endpoint, socket, asyncConcurrency, asyncBufferSize);
_transaction = new RedisTransaction(_connector);
_subscription = new SubscriptionListener(_connector);
_monitor = new MonitorListener(_connector);
_subscription.MessageReceived += OnSubscriptionReceived;
_subscription.Changed += OnSubscriptionChanged;
_monitor.MonitorReceived += OnMonitorReceived;
_connector.Connected += OnConnectionConnected;
_transaction.TransactionQueued += OnTransactionQueued;
}
internal RedisClient(IRedisConnector connector)
{
// use invariant culture - we have to set it explicitly for every thread we create to
// prevent any floating-point problems (mostly because of number formats in non en-US cultures).
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
_connector = connector;
_transaction = new RedisTransaction(_connector);
_subscription = new SubscriptionListener(_connector);
_monitor = new MonitorListener(_connector);
_subscription.MessageReceived += OnSubscriptionReceived;
_subscription.Changed += OnSubscriptionChanged;
_monitor.MonitorReceived += OnMonitorReceived;
_connector.Connected += OnConnectionConnected;
_transaction.TransactionQueued += OnTransactionQueued;
}
private Task <bool> ExecuteTransaction(RedisTransaction transaction, long?oldId, IList <Message> messages)
{
_trace.TraceVerbose("ExecuteTransaction({0})", oldId);
// New target id
long newId = (oldId ?? 0) + 1;
// TODO: Don't do this everytime
byte[] data = RedisMessage.ToBytes(newId, messages);
// These don't need to be observed
transaction.AddCondition(Condition.KeyEquals(_db, _key, oldId));
transaction.Strings.Increment(_db, _key);
transaction.Publish(_key, data);
// Execute the transaction
return(transaction.Execute());
}
private void OnTransactionComplete(RedisTransaction transaction, bool success, IList <Message> messages, TaskCompletionSource <object> tcs)
{
if (success)
{
_trace.TraceVerbose("Transaction completed successfully");
tcs.TrySetResult(null);
}
else
{
_trace.TraceVerbose("Transaction failed. Retrying...");
_trace.TraceVerbose("Transaction disposed");
// Dispose the transaction
transaction.Dispose();
SendImpl(messages, tcs);
}
}
/// <summary>
/// 初始化数据库环境、实例化子类中，所有Set属性
/// </summary>
public void Initializer()
{
if (IsInitializer) { return; }
_client = new RedisClient(_redisConnection);
IsInitializer = true;
Connection = new RedisConnection(_client);
Hash = new RedisHash(_client);
Key = new RedisKey(_client);
List = new RedisList(_client);
PubSub = new RedisPubSub(_client);
Script = new RedisScript(_client);
Server = new RedisServer(_client);
Set = new RedisSet(_client);
SortedSet = new RedisSortedSet(_client);
String = new RedisString(_client);
Transaction = new RedisTransaction(_client);
Bit = new RedisBit(_client);
Expire = new RedisExpire(_client);
Sort = new RedisSort(_client);
Number = new RedisNumber(_client);
}
private void OnTransactionCompleting(RedisTransaction transaction, Task <bool> transactionTask, IList <Message> messages, TaskCompletionSource <object> tcs)
{
if (transactionTask.IsCompleted)
{
try
{
OnTransactionComplete(transaction, transactionTask.Result, messages, tcs);
}
catch (OperationCanceledException)
{
tcs.TrySetCanceled();
}
catch (Exception ex)
{
tcs.TrySetException(ex);
}
}
else
{
transactionTask.Then(result => OnTransactionComplete(transaction, result, messages, tcs))
.ContinueWithNotComplete(tcs);
}
}
private void SendImpl(IList <Message> messages, TaskCompletionSource <object> tcs)
{
go:
Task <long?> task = _connection.Strings.GetInt64(_db, _key);
RedisTransaction transaction = null;
// Dispose the transaction after everything runs
tcs.Task.Finally(state =>
{
if (transaction != null)
{
_trace.TraceVerbose("Transaction disposed");
transaction.Dispose();
}
},
null);
if (task.IsCompleted)
{
try
{
task.Wait();
_trace.TraceVerbose("CreateTransaction({0})", task.Result);
transaction = _connection.CreateTransaction();
Task <bool> transactionTask = ExecuteTransaction(transaction, task.Result, messages);
if (transactionTask.IsCompleted)
{
transactionTask.Wait();
bool success = transactionTask.Result;
if (success)
{
OnTransactionComplete(transaction, success, messages, tcs);
}
else
{
_trace.TraceVerbose("Transaction failed. Retrying...");
_trace.TraceVerbose("Transaction disposed");
transaction.Dispose();
goto go;
}
}
else
{
OnTransactionCompleting(transaction, transactionTask, messages, tcs);
}
}
catch (OperationCanceledException)
{
tcs.TrySetCanceled();
}
catch (Exception ex)
{
tcs.TrySetException(ex);
}
}
else
{
task.Then(oldId =>
{
_trace.TraceVerbose("CreateTransaction({0})", oldId);
transaction = _connection.CreateTransaction();
Task <bool> transactionTask = ExecuteTransaction(transaction, oldId, messages);
OnTransactionCompleting(transaction, transactionTask, messages, tcs);
})
.ContinueWithNotComplete(tcs);
}
}
public override SessionStateStoreData GetItemExclusive(HttpContext context, string id, out bool locked, out TimeSpan lockAge, out object lockId, out SessionStateActions actions)
{
RedisConnection redisConnection = this.GetRedisConnection();
Task <byte[]> task1 = redisConnection.Hashes.Get(0, this.lockHashKey, id, false);
actions = SessionStateActions.None;
locked = false;
lockId = (object)null;
lockAge = TimeSpan.MinValue;
task1.Wait();
byte[] result1 = task1.Result;
if (result1 == null)
{
RedisSessionStateStore.LockData data = RedisSessionStateStore.LockData.New();
using (RedisTransaction transaction = redisConnection.CreateTransaction())
{
Task <bool> task2 = transaction.Hashes.SetIfNotExists(0, this.lockHashKey, id, data.ToByteArray(), false);
Task <Dictionary <string, byte[]> > all = transaction.Hashes.GetAll(0, this.GetKeyForSessionId(id), false);
transaction.Execute(false, (object)null);
task2.Wait();
if (task2.Result)
{
locked = true;
lockAge = new TimeSpan(0L);
lockId = (object)data.LockId;
SessionStateItemCollection stateItemCollection = new SessionStateItemCollection();
Dictionary <string, byte[]> dictionary = redisConnection.Wait <Dictionary <string, byte[]> >(all);
if (dictionary.Count == 3)
{
actions = (int)dictionary["initialize"][0] == 1 ? SessionStateActions.InitializeItem : SessionStateActions.None;
MemoryStream memoryStream = new MemoryStream(dictionary["data"]);
if (memoryStream.Length > 0L)
{
stateItemCollection = SessionStateItemCollection.Deserialize(new BinaryReader((Stream)memoryStream));
}
int int32 = BitConverter.ToInt32(dictionary["timeoutMinutes"], 0);
redisConnection.Keys.Expire(0, this.GetKeyForSessionId(id), int32 * 60, false);
}
return(new SessionStateStoreData((ISessionStateItemCollection)stateItemCollection, SessionStateUtility.GetSessionStaticObjects(context), this.redisConfig.SessionTimeout));
}
byte[] result2 = redisConnection.Hashes.Get(0, this.lockHashKey, id, false).Result;
if (result2 != null && RedisSessionStateStore.LockData.TryParse(result2, out data))
{
locked = true;
lockId = (object)data.LockId;
lockAge = DateTime.UtcNow - data.LockUtcTime;
}
return((SessionStateStoreData)null);
}
}
else
{
RedisSessionStateStore.LockData data;
if (RedisSessionStateStore.LockData.TryParse(result1, out data))
{
locked = true;
lockId = (object)data.LockId;
lockAge = DateTime.UtcNow - data.LockUtcTime;
}
return((SessionStateStoreData)null);
}
}
