/// <summary>
///
/// </summary>
/// <param name="trans"></param>
/// <param name="dataList"></param>
/// <returns></returns>
public static void TransUpdateEntity(IRedisTransaction trans, IEnumerable <ISqlEntity> dataList)
{
var groupList = dataList.GroupBy(t => t.GetType().FullName);
foreach (var g in groupList)
{
string typeName = g.Key;
var keys = new List <byte[]>();
var values = new List <byte[]>();
var removeKeys = new List <byte[]>();
var enm = g.GetEnumerator();
while (enm.MoveNext())
{
var entity = enm.Current;
string keyCode = entity.GetKeyCode();
var keybytes = ToByteKey(keyCode);
if (entity.IsDelete)
{
removeKeys.Add(keybytes);
continue;
}
entity.Reset();
keys.Add(keybytes);
values.Add(_serializer.Serialize(entity));
}
TransUpdateEntity(trans, typeName, keys.ToArray(), values.ToArray(), removeKeys.ToArray());
}
}
public int Transaction()
{
string fromAccID = textBox3.Text;
string toAccID = textBox5.Text;
Double ammount = textBox6.Text.ToDouble();
string[] watchFromKeys = { $"account:{textBox3.Text}", "Balance" };
string[] watchToKeys = { $"account:{ textBox5.Text}", "Balance" };
redisClient.Watch(watchFromKeys);
redisClient.Watch(watchToKeys);
using (IRedisTransaction trans = redisClient.CreateTransaction())
{
Double balanceFrom = GetBalanceInfo(fromAccID);
Double balanceTo = GetBalanceInfo(toAccID);
if (balanceFrom >= ammount)
{
balanceFrom -= ammount;
balanceTo += ammount;
trans.QueueCommand(redisClient => redisClient.SetEntryInHash($"account:{fromAccID}", "Balance", balanceFrom.ToString()));
trans.QueueCommand(redisClient => redisClient.SetEntryInHash($"account:{toAccID}", "Balance", balanceTo.ToString()));
return(trans.Commit() == false ? 0 : 1); //TODO: limit cycles
}
else
{
return(-1);
}
}
}
/// <inheritdoc />
public void Add(Guid taskId, ITask task)
{
Trace.WriteLine("ENTER: Adding task '{0}' with ID '{1}' ...".FormatInvariant(task, taskId));
if (task == null)
{
throw new ArgumentNullException(nameof(task));
}
string taskIdAsString = RedisConverter.ToString(taskId);
if (this.serializer.CanDetermineEntityTypeFromContent)
{
this.provider.SetHashValue(RedisTaskRepository.TasksHashKey, taskIdAsString, this.serializer.Serialize(task));
}
else
{
using (IRedisTransaction transaction = this.provider.CreateTransaction())
{
transaction.SetHashValue(RedisTaskRepository.TasksHashKey, taskIdAsString, this.serializer.Serialize(task));
transaction.SetHashValue(RedisTaskRepository.TasksHashKey, taskIdAsString + "$Type", RedisConverter.ToString(task.GetType(), true));
transaction.Commit();
}
}
Trace.WriteLine("EXIT: Task '{0}' with ID '{1}' added.".FormatInvariant(task, taskId));
}
/// <inheritdoc />
public void Add(Guid taskId, ITaskSummary summary)
{
Trace.WriteLine("ENTER: Adding summary '{0}' for task '{1}' ...".FormatInvariant(summary, taskId));
if (summary == null)
{
throw new ArgumentNullException(nameof(summary));
}
string taskIdAsString = RedisConverter.ToString(taskId);
byte[] content = this.serializer.Serialize(summary);
if (this.serializer.CanDetermineEntityTypeFromContent)
{
this.provider.SetHashValue(RedisTaskSummaryRepository.RedisTaskSummaryHashKey, taskIdAsString, content);
}
else
{
using (IRedisTransaction transaction = this.provider.CreateTransaction())
{
transaction.SetHashValue(RedisTaskSummaryRepository.RedisTaskSummaryHashKey, taskIdAsString, content);
transaction.SetHashValue(RedisTaskSummaryRepository.RedisTaskSummaryHashKey, taskIdAsString + "$Type", RedisConverter.ToString(summary.GetType(), false));
transaction.Commit();
}
}
Trace.WriteLine("EXIT: Summary '{0}' added for task '{1}'.".FormatInvariant(summary, taskId));
}
public static void QueueCommandMap(this IRedisTransaction transaction, Func <IRedisClient, byte[][]> command, Action <IDictionary <string, byte[]> > onSuccessCallback)
{
transaction.QueueCommand(command, (multiData) =>
{
onSuccessCallback(RedisClientExtensions.MultiByteArrayToDictionary(multiData));
});
}
/// <inheritdoc />
public void Fail(Guid taskId, DateTime timestampUtc, Exception error)
{
if (error == null)
{
throw new ArgumentNullException(nameof(error));
}
Trace.WriteLine("ENTER: Record task '{0}' failed with error '{1}' ...".FormatInvariant(taskId, error.Message));
string taskIdAsString = RedisConverter.ToString(taskId);
string entityKey = RedisTaskRuntimeInfoRepository.GetEntityKey(taskIdAsString);
RedisTaskRuntimeInfo taskInfo = this.GetById(taskId, false);
taskInfo.Status = TaskStatus.Failed;
taskInfo.CompletedUtc = timestampUtc;
taskInfo.Error = error.ToString();
byte[] content = this.serializer.Serialize(taskInfo);
using (IRedisTransaction transaction = this.Provider.CreateTransaction())
{
transaction.RemoveKey(entityKey);
transaction.RemoveFromList(RedisTaskRuntimeInfoRepository.ActiveTasksList, taskIdAsString);
transaction.AddToList(RedisTaskRuntimeInfoRepository.FailedTasksList, taskIdAsString);
transaction.SetHashValue(RedisTaskRuntimeInfoRepository.ArchiveTasksHash, taskIdAsString, content);
transaction.Commit();
}
Trace.WriteLine("EXIT: Task '{0}' failed with error '{1}' recorded.".FormatInvariant(taskId, error.Message));
}
/// <inheritdoc />
public void Complete(Guid taskId, DateTime timestampUtc)
{
Trace.WriteLine("ENTER: Record task '{0}' completed ...".FormatInvariant(taskId));
string taskIdAsString = RedisConverter.ToString(taskId);
string entityKey = RedisTaskRuntimeInfoRepository.GetEntityKey(taskIdAsString);
RedisTaskRuntimeInfo taskInfo = this.GetById(taskId, false);
taskInfo.Percentage = 100;
taskInfo.Status = TaskStatus.Success;
taskInfo.CompletedUtc = timestampUtc;
byte[] content = this.serializer.Serialize(taskInfo);
using (IRedisTransaction transaction = this.Provider.CreateTransaction())
{
transaction.RemoveKey(entityKey);
transaction.RemoveFromList(RedisTaskRuntimeInfoRepository.ActiveTasksList, taskIdAsString);
transaction.SetHashValue(RedisTaskRuntimeInfoRepository.ArchiveTasksHash, taskIdAsString, content);
transaction.Commit();
}
Trace.WriteLine("EXIT: Task '{0}' completed recorded.".FormatInvariant(taskId));
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public bool Commit()
{
bool result = _transaction != null && _transaction.Commit();
_transaction = null;
return(result);
}
private void OnSwitchTo(object sender, RoutedEventArgs e)
{
string newID = thisWindowRedis.Incr(taskID).ToString();
MenuItem selectMenuItem = sender as MenuItem;
List <string> newTaskProperities = new List <string>();
{
newTaskProperities.Add(MainWindow.myUsername);
newTaskProperities.Add(((MenuItem)selectMenuItem.Parent).Name);
newTaskProperities.Add("Waiting");
newTaskProperities.Add(TimeStyle.ConvertDateTimeInt(thisWindowRedis.GetServerTime().AddHours(8)).ToString());
newTaskProperities.Add("2");
newTaskProperities.Add(((Server)serverListView.SelectedItem).ServerID);
newTaskProperities.Add(selectMenuItem.Tag.ToString());
}
for (int j = 0; j < newTaskProperities.Count; j++)
{
thisWindowRedis.Set <string>(RedisKeyName.taskPrefix + newID + taskProperities[j], newTaskProperities[j]);
}
using (IRedisTransaction IRT = thisWindowRedis.CreateTransaction())
{
IRT.QueueCommand(r => r.AddItemToList(RedisKeyName.waitingTaskList, newID));
IRT.QueueCommand(r => r.AddItemToList(RedisKeyName.waitingTaskListCopy, newID));
IRT.Commit();
}
}
private void AddOrUpdate(IScheduledTask scheduledTask)
{
string taskIdAsString = RedisConverter.ToString(scheduledTask.Id);
if (this.serializer.CanDetermineEntityTypeFromContent)
{
this.provider.SetHashValues(
RedisScheduledTaskRepository.ScheduledTasksHashKey,
new Dictionary <string, byte[]>()
{
{ taskIdAsString + "$Content", this.serializer.Serialize(scheduledTask) },
{ taskIdAsString + "$RecurrenceDefinition", this.serializer.Serialize(scheduledTask.Schedule) }
});
}
else
{
using (IRedisTransaction transaction = this.provider.CreateTransaction())
{
transaction.SetHashValue(RedisScheduledTaskRepository.ScheduledTasksHashKey, taskIdAsString + "$Content", this.serializer.Serialize(scheduledTask));
transaction.SetHashValue(RedisScheduledTaskRepository.ScheduledTasksHashKey, taskIdAsString + "$Type", RedisConverter.ToString(scheduledTask.GetType(), false));
transaction.SetHashValue(RedisScheduledTaskRepository.ScheduledTasksHashKey, taskIdAsString + "$RecurrenceDefinition", this.serializer.Serialize(scheduledTask.Schedule));
transaction.SetHashValue(RedisScheduledTaskRepository.ScheduledTasksHashKey, taskIdAsString + "$RecurrenceDefinition$Type", RedisConverter.ToString(scheduledTask.Schedule.GetType(), false));
transaction.Commit();
}
}
}
public void BeginTransaction(IsolationLevel isolationLevel = IsolationLevel.ReadCommitted)
{
if (trans == null)
{
trans = redis.CreateTransaction();
}
}
public async Task WriteAsync(Namespace name, object obj, TimeSpan?TTL = null, bool useTransaction = true)
{
//Set the connection to a new transaction
if (useTransaction)
{
Transaction = Client.CreateTransaction();
}
//Prepare the type
Type type = obj.GetType();
var serializer = GetSerializerForType(type, options: type.GetCustomAttribute <RedisOptionAttribute>());
Debug.Assert(serializer != null);
//Serialzie the content
await serializer.WriteAsync(this, type, obj, name, TTL);
//Execute the transaction and clear it
if (useTransaction)
{
await Transaction.ExecuteAsync();
Transaction = null;
}
}
/// <inheritdoc />
public void Update(ITaskProcessorRuntimeInfo taskProcessorInfo)
{
if (taskProcessorInfo == null)
{
throw new ArgumentNullException("taskProcessorInfo");
}
Trace.WriteLine("ENTER: Updating {0} ...".FormatInvariant(taskProcessorInfo));
string entityKey = RedisTaskProcessorRuntimeInfoRepository.GetEntityKey(taskProcessorInfo.TaskProcessorId);
IReadOnlyDictionary <string, string> values = RedisTaskProcessorRuntimeInfoRepository.Serialize(taskProcessorInfo);
using (IRedisTransaction transaction = this.provider.CreateTransaction())
{
transaction.RemoveKey(entityKey);
transaction.SetHashValues(entityKey, values);
if (this.expiration < TimeSpan.MaxValue)
{
transaction.ExpireKeyIn(entityKey, this.expiration);
}
transaction.Commit();
}
Trace.WriteLine("EXIT: {0} updated.".FormatInvariant(taskProcessorInfo));
}
protected override async Task BeforeSaving(IRedisTransaction transaction, IDataKey key, SimpleItem entity)
{
var identity = new Identity();
identity.InstanceId = "One";
await inner.Save(identity, transaction).ConfigureAwait(false);
}
private void UseTransaction(IRedisClient client, System.Action <IRedisTransaction> action)
{
using (IRedisTransaction transaction = client.CreateTransaction())
{
action(transaction);
transaction.Commit();
}
}
public RedisWriteOnlyTransaction(IRedisTransaction transaction)
{
if (transaction == null)
{
throw new ArgumentNullException("transaction");
}
_transaction = transaction;
}
protected override Task BeforeSaving(IRedisTransaction transaction, IDataKey key, T entity)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
key.AddIndex(Active);
return(base.BeforeSaving(transaction, key, entity));
}
public static IRedisTransaction CreateInstance(IRedisClient client)
{
lock (locked)
{
if (_redisTransaction == null)
{
_redisTransaction = client.CreateTransaction();
}
return(_redisTransaction);
}
}
private Double GetBalanceInfo(string accID, IRedisTransaction trans)
{
using (trans)
{
string balanceSt = "";
trans.QueueCommand(redisClient => redisClient.GetValueFromHash($"account:{accID}", "Balance"), x => balanceSt = x);
trans.Commit();
Double balance = balanceSt.ToDouble();
return(balance);
}
}
public static bool TransactionSet(string key, string value)
{
var redisClient = basicRedisClientManager.GetClient();
using (IRedisTransaction IRT = redisClient.CreateTransaction())
{
IRT.QueueCommand(r => r.Set <string>(key, value));
IRT.QueueCommand(r => r.Increment(key, 1));
return(IRT.Commit()); // 提交事务
}
}
/// <inheritdoc />
public void Delete(Guid taskProcessorId)
{
string entityKey = RedisTaskProcessorRuntimeInfoRepository.GetEntityKey(taskProcessorId);
using (IRedisTransaction transaction = this.provider.CreateTransaction())
{
transaction.RemoveFromSet(RedisTaskProcessorRuntimeInfoRepository.EntitySetKey, RedisConverter.ToString(taskProcessorId));
transaction.RemoveKey(entityKey);
transaction.Commit();
}
}
public override void ResetItemTimeout(HttpContext context, string id)
{
var key = GetSessionIdKey(id);
using (var client = GetClient())
{
IRedisTransaction transaction = client.CreateTransaction();
using (transaction)
{
transaction.QueueCommand(c => c.ExpireEntryIn(key, TimeSpan.FromMinutes(sessionTimeoutMinutes)));
}
}
}
private void btnResetRedisPKid_Click(object sender, EventArgs e)
{
I_Dblink I_DBL = (new DBFactory()).DbLinkSqlMain("");
Hashtable htInput = new Hashtable();
htInput.Add("@date", null);
Hashtable htres = I_DBL.RunProc_CMD("[dbo].[AAA_getTableMaxNum_redis]", "tab", htInput);
DataSet ds = new DataSet();
if ((bool)htres["return_float"])
{
ds = (DataSet)htres["return_ds"];
}
else
{
ds = null;
}
if (ds != null && ds.Tables.Contains("tab") && ds.Tables["tab"].Rows.Count > 0)
{
RedisClient RC = RedisClass.GetRedisClient("OnlyOpenOneCheckRedis");
string txt = "TableName MaxNum MaxId" + Environment.NewLine + "-------------------------------------" + Environment.NewLine;
//-------计算有效期截止时间---------------
DateTime dateStart = DateTime.Now;
//获取当月最后一天的时间
DateTime dateEnd = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 1).AddMonths(1).AddDays(-1);
//获取当前时间与当月最后一天相差的秒数作为键值的生命周期
TimeSpan ts = dateEnd.Subtract(dateStart).Duration();
string seconds = ts.TotalSeconds.ToString("0");
using (IRedisTransaction IRT = RC.CreateTransaction())
{//使用事务提交所有重置键值的操作语句
foreach (DataRow dr in ds.Tables[0].Rows)
{
txt += dr["tname"].ToString() + " " + dr["maxnum"].ToString() + " " + dr["maxid"].ToString() + Environment.NewLine;
string key = "str:TablePK:" + dr["tname"].ToString() + DateTime.Now.ToString("yyyyMM");
IRT.QueueCommand(r => r.Set(key, Convert.ToInt32(dr["maxid"].ToString())));
IRT.QueueCommand(r => r.ExpireEntryAt(key, dateEnd));
}
IRT.Commit(); // 提交事务
}
//将待处理的表信息显示在界面上
richTextBox1.Text = txt;
}
else
{
richTextBox1.Text = "没有需要处理的信息！";
}
}
private static void DemoRedisTransaction()
{
using (IRedisClient redisClient = new RedisClient())
{
const string key = "abc";
IRedisTransaction transaction = redisClient.CreateTransaction();
transaction.QueueCommand(c => c.Set(key, 1));
transaction.QueueCommand(c => c.Increment(key, 1));
transaction.Commit();
int result = redisClient.Get <int>(key);
Console.WriteLine($"Result = {result}");
}
}
private void RemoveFromFetchedList(IRedisTransaction transaction)
{
transaction.QueueCommand(x => x.RemoveItemFromList(
String.Format(RedisStorage.Prefix + "queue:{0}:dequeued", Queue),
JobId,
-1));
transaction.QueueCommand(x => x.RemoveEntryFromHash(
String.Format(RedisStorage.Prefix + "job:{0}", JobId),
"Fetched"));
transaction.QueueCommand(x => x.RemoveEntryFromHash(
String.Format(RedisStorage.Prefix + "job:{0}", JobId),
"Checked"));
}
/// <summary>
/// 正常执行事物
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnCommit_Click(object sender, EventArgs e)
{
using (IRedisTransaction IRT = client.CreateTransaction())
{
//设置一个key=key value=20的数据
IRT.QueueCommand(r => r.Set("key", 20));
//然后让该数据++1
IRT.QueueCommand(r => r.Increment("key", 1));
IRT.Commit(); // 提交事务
//最终该变量的值是21
}
btnGet_Click(null, null);
}
private void RemoveFromFetchedList(IRedisTransaction transaction)
{
transaction.QueueCommand(x => x.RemoveItemFromList(
String.Format(RedisStorage.Prefix + "queue:{0}:dequeued", Queue),
JobId,
-1));
transaction.QueueCommand(x => x.RemoveEntryFromHash(
String.Format(RedisStorage.Prefix + "job:{0}", JobId),
"Fetched"));
transaction.QueueCommand(x => x.RemoveEntryFromHash(
String.Format(RedisStorage.Prefix + "job:{0}", JobId),
"Checked"));
}
public Task Deactivate(string id, IRedisTransaction transaction = null)
{
if (id == null)
{
throw new ArgumentNullException(nameof(id));
}
var key = Entity.GetKey(id);
var client = (IDatabase)transaction?.Transaction ?? Redis.Multiplexer.Database;
var activeTask = Redis.IndexManager.GetManager(Active).RemoveIndex(client, key, Active);
var inactiveTask = Redis.IndexManager.GetManager(InActive).AddIndex(client, key, InActive);
return(Task.WhenAll(activeTask, inactiveTask));
}
/// <inheritdoc />
public void SetMaster(Guid taskProcessorId)
{
Trace.WriteLine("ENTER: Setting master task processor ID to '{0}' ...".FormatInvariant(taskProcessorId));
using (IRedisTransaction transaction = this.provider.CreateTransaction())
{
transaction.SetValue(RedisTaskProcessorRuntimeInfoRepository.MasterTaskProcessorIdKey, RedisConverter.ToString(taskProcessorId));
transaction.ExpireKeyIn(RedisTaskProcessorRuntimeInfoRepository.MasterTaskProcessorIdKey, this.Expiration);
transaction.Commit();
}
Trace.WriteLine("EXIT: Master task processor ID set to '{0}'.".FormatInvariant(taskProcessorId));
}
/// <inheritdoc />
public void Add(ITaskRuntimeInfo taskInfo)
{
if (taskInfo == null)
{
throw new ArgumentNullException("taskInfo");
}
Trace.WriteLine("ENTER: Adding runtime information for task '{0}' of type '{1}' with priority '{2}' in polling queue '{3}' ...".FormatInvariant(taskInfo.TaskId, taskInfo.TaskType, taskInfo.Priority, taskInfo.PollingQueue));
taskInfo.ValidateForAdd();
string entityKey = RedisTaskRuntimeInfoRepository.GetEntityKey(taskInfo.TaskId);
string addToListKey;
Dictionary <string, string> values = new Dictionary <string, string>()
{
{ "Id", RedisConverter.ToString(taskInfo.TaskId) },
{ "TaskType", RedisConverter.ToString(taskInfo.TaskType, true) },
{ "SubmittedUtc", RedisConverter.ToString(taskInfo.SubmittedUtc) },
{ "Status", RedisConverter.ToString(taskInfo.Status) }
};
if (string.IsNullOrEmpty(taskInfo.PollingQueue))
{
values.Add("Priority", RedisConverter.ToString(taskInfo.Priority));
addToListKey = RedisTaskRuntimeInfoRepository.PendingTasksList;
}
else
{
values.Add("PollingQueue", taskInfo.PollingQueue);
addToListKey = RedisTaskRuntimeInfoRepository.GetPollingQueueRedisKey(taskInfo.PollingQueue, TaskStatus.Pending);
}
using (IRedisTransaction transaction = this.Provider.CreateTransaction())
{
transaction.SetHashValues(entityKey, values);
transaction.AddToList(addToListKey, RedisConverter.ToString(taskInfo.TaskId));
transaction.Commit();
}
Trace.WriteLine("EXIT: Runtime information for task '{0}' of type '{1}' with priority '{2}' in polling queue '{3}' added.".FormatInvariant(taskInfo.TaskId, taskInfo.TaskType, taskInfo.Priority, taskInfo.PollingQueue));
}
public void Transcation()
{
using (IRedisTransaction irt = this.iClient.CreateTransaction())
{
try
{
irt.QueueCommand(r => r.Set("key", 20));
irt.QueueCommand(r => r.Increment("key", 1));
irt.Commit(); // 提交事务
}
catch (Exception ex)
{
irt.Rollback();
throw ex;
}
}
}
private IRedisTransaction GetRedisTransaction()
{
if (redisTransaction != null)
return redisTransaction;
redisClient = new RedisClient(destination.Server);
redisTransaction = redisClient.CreateTransaction();
return redisTransaction;
}
public RedisWriteOnlyTransaction(IRedisTransaction transaction)
{
if (transaction == null) throw new ArgumentNullException("transaction");
_transaction = transaction;
}
