void IMessageResult.Complete(RedisResult result, RedisMessage message, bool includeDetail)
{
if (result.IsCancellation)
{
RedisConnectionBase.Trace("transaction", "cancelled");
SetInnerReplies(result);
completion.TrySetCanceled();
}
else if (result.IsError)
{
RedisConnectionBase.Trace("transaction", "error");
SetInnerReplies(result);
completion.SafeSetException(result.Error());
}
else
{
try
{
if (result.IsNil)
{ // aborted
RedisConnectionBase.Trace("transaction", "aborted");
SetInnerReplies(RedisResult.Cancelled);
completion.TrySetResult(false);
}
else
{
var items = result.ValueItems;
if (items.Length != (queued == null ? 0 : queued.Length))
{
throw new InvalidOperationException(string.Format("{0} results expected, {1} received", queued.Length, items.Length));
}
RedisConnectionBase.Trace("transaction", "success");
for (int i = 0; i < items.Length; i++)
{
RedisResult reply = items[i];
RedisConnectionBase.CallbackMode callbackMode;
var ctx = parent.ProcessReply(ref reply, queued[i].InnerMessage, out callbackMode);
RedisConnectionBase.Trace("transaction", "{0} = {1}", ctx, reply);
parent.ProcessCallbacks(ctx, reply, callbackMode);
}
completion.TrySetResult(true);
}
}
catch (Exception ex)
{
completion.SafeSetException(ex);
throw;
}
}
}
public void Complete(RedisResult result, RedisMessage message, bool includeDetail)
{
if (result.IsCancellation)
{
source.TrySetCanceled();
}
else if (result.IsError)
{
ProcessError(result, message, includeDetail);
}
else
{
T value;
try
{
value = GetValue(result);
}
catch (Exception ex)
{
source.SafeSetException(ex);
return;
}
source.TrySetResult(value);
}
}
private Task <long> ExecMultiAddRemove(int db, RedisLiteral command, string key, byte[][] values, bool queueJump)
{
RedisFeatures features;
if (values.Length > 1 && ((features = Features) == null || !features.SetVaradicAddRemove))
{
RedisTransaction tran = this as RedisTransaction;
bool execute = false;
if (tran == null)
{
tran = CreateTransaction();
execute = true;
}
Task <bool>[] tasks = new Task <bool> [values.Length];
for (int i = 0; i < values.Length; i++)
{
tasks[i] = ExecuteBoolean(RedisMessage.Create(db, command, key, values[i]), queueJump);
}
TaskCompletionSource <long> final = new TaskCompletionSource <long>();
tasks[values.Length - 1].ContinueWith(t =>
{
try
{
if (t.ShouldSetResult(final))
{
long count = 0;
for (int i = 0; i < tasks.Length; i++)
{
if (tran.Wait(tasks[i]))
{
count++;
}
}
final.TrySetResult(count);
}
}
catch (Exception ex)
{
final.SafeSetException(ex);
}
});
if (execute)
{
tran.Execute(queueJump);
}
return(final.Task);
}
else
{
var args = new RedisMessage.RedisParameter[values.Length + 1];
args[0] = key;
for (int i = 0; i < values.Length; i++)
{
args[i + 1] = values[i];
}
return(ExecuteInt64(RedisMessage.Create(db, command, args), queueJump));
}
}
Task <long> IHashCommands.Remove(int db, string key, string[] fields, bool queueJump)
{
RedisFeatures features;
if (fields.Length > 1 && ((features = Features) == null || !features.HashVaradicDelete))
{
RedisTransaction tran = this as RedisTransaction;
bool execute = false;
if (tran == null)
{
tran = CreateTransaction();
execute = true;
}
Task <bool>[] tasks = new Task <bool> [fields.Length];
var hashes = tran.Hashes;
for (int i = 0; i < fields.Length; i++)
{
tasks[i] = hashes.Remove(db, key, fields[i], queueJump);
}
TaskCompletionSource <long> final = new TaskCompletionSource <long>();
tasks[fields.Length - 1].ContinueWith(t =>
{
try
{
if (t.ShouldSetResult(final))
{
long count = 0;
for (int i = 0; i < tasks.Length; i++)
{
if (tran.Wait(tasks[i]))
{
count++;
}
}
final.TrySetResult(count);
}
}
catch (Exception ex)
{
final.SafeSetException(ex);
}
});
if (execute)
{
tran.Execute(queueJump);
}
return(final.Task);
}
else
{
return(ExecuteInt64(RedisMessage.Create(db, RedisLiteral.HDEL, key, fields), queueJump));
}
}
internal static bool ShouldSetResult <T>(this Task task, TaskCompletionSource <T> source)
{
if (task.IsFaulted)
{
source.SafeSetException(task.Exception);
}
else if (task.IsCanceled)
{
source.TrySetCanceled();
}
else if (task.IsCompleted)
{
return(true);
}
return(false);
}
private Task<long> ExecMultiAddRemove(int db, RedisLiteral command, string key, byte[][] values, bool queueJump)
{
RedisFeatures features;
if (values.Length > 1 && ((features = Features) == null || !features.SetVaradicAddRemove))
{
RedisTransaction tran = this as RedisTransaction;
bool execute = false;
if (tran == null)
{
tran = CreateTransaction();
execute = true;
}
Task<bool>[] tasks = new Task<bool>[values.Length];
for (int i = 0; i < values.Length; i++)
{
tasks[i] = ExecuteBoolean(RedisMessage.Create(db, command, key, values[i]), queueJump);
}
TaskCompletionSource<long> final = new TaskCompletionSource<long>();
tasks[values.Length - 1].ContinueWith(t =>
{
try
{
if (t.ShouldSetResult(final))
{
long count = 0;
for (int i = 0; i < tasks.Length; i++)
{
if (tran.Wait(tasks[i]))
{
count++;
}
}
final.TrySetResult(count);
}
}
catch (Exception ex)
{
final.SafeSetException(ex);
}
});
if (execute) tran.Execute(queueJump);
return final.Task;
}
else
{
var args = new RedisMessage.RedisParameter[values.Length + 1];
args[0] = key;
for (int i = 0; i < values.Length; i++)
{
args[i + 1] = values[i];
}
return ExecuteInt64(RedisMessage.Create(db, command, args), queueJump);
}
}
Task<long> IHashCommands.Remove(int db, string key, string[] fields, bool queueJump)
{
RedisFeatures features;
if (fields.Length > 1 && ((features = Features) == null || !features.HashVaradicDelete))
{
RedisTransaction tran = this as RedisTransaction;
bool execute = false;
if (tran == null)
{
tran = CreateTransaction();
execute = true;
}
Task<bool>[] tasks = new Task<bool>[fields.Length];
var hashes = tran.Hashes;
for (int i = 0; i < fields.Length; i++)
{
tasks[i] = hashes.Remove(db, key, fields[i], queueJump);
}
TaskCompletionSource<long> final = new TaskCompletionSource<long>();
tasks[fields.Length - 1].ContinueWith(t =>
{
try
{
if (t.ShouldSetResult(final))
{
long count = 0;
for (int i = 0; i < tasks.Length; i++)
{
if (tran.Wait(tasks[i]))
{
count++;
}
}
final.TrySetResult(count);
}
}
catch (Exception ex)
{
final.SafeSetException(ex);
}
});
if (execute) tran.Execute(queueJump);
return final.Task;
}
else
{
return ExecuteInt64(RedisMessage.Create(db, RedisLiteral.HDEL, key, fields), queueJump);
}
}
