internal override Task <T> ExecuteAsync <T>(Message message, ResultProcessor <T> processor, ServerEndPoint server = null)
{
if (message == null)
{
return(CompletedTask <T> .Default(asyncState));
}
multiplexer.CheckMessage(message);
// prepare the inner command as a task
Task <T> task;
if (message.IsFireAndForget)
{
task = CompletedTask <T> .Default(null); // F+F explicitly does not get async-state
}
else
{
var tcs = TaskSource.Create <T>(asyncState);
var source = ResultBox <T> .Get(tcs);
message.SetSource(source, processor);
task = tcs.Task;
}
// store it
(pending ?? (pending = new List <Message>())).Add(message);
return(task);
}
internal Task <T> WriteDirectAsync <T>(Message message, ResultProcessor <T> processor, object asyncState = null, PhysicalBridge bridge = null)
{
var tcs = TaskSource.Create <T>(asyncState);
var source = ResultBox <T> .Get(tcs);
message.SetSource(processor, source);
if (bridge == null)
{
bridge = GetBridge(message.Command);
}
WriteResult result;
if (bridge == null)
{
result = WriteResult.NoConnectionAvailable;
}
else
{
var write = bridge.TryWriteAsync(message, isSlave);
if (!write.IsCompletedSuccessfully)
{
return(WriteDirectAsync_Awaited <T>(this, message, write, tcs));
}
result = write.Result;
}
if (result != WriteResult.Success)
{
var ex = Multiplexer.GetException(result, message, this);
ConnectionMultiplexer.ThrowFailed(tcs, ex);
}
return(tcs.Task);
}
public static Task <T> FromResult(T value, object asyncState)
{
// note we do not need to deny exec-sync here; the value will be known
// before we hand it to them
var tcs = TaskSource.Create <T>(asyncState);
tcs.SetResult(value);
return(tcs.Task);
}
internal override Task <T> ExecuteAsync <T>(Message message, ResultProcessor <T> processor, ServerEndPoint server = null)
{
if (message == null)
{
return(CompletedTask <T> .Default(asyncState));
}
multiplexer.CheckMessage(message);
multiplexer.Trace("Wrapping " + message.Command, "Transaction");
// prepare the inner command as a task
Task <T> task;
if (message.IsFireAndForget)
{
task = CompletedTask <T> .Default(null); // F+F explicitly does not get async-state
}
else
{
var tcs = TaskSource.Create <T>(asyncState);
var source = ResultBox <T> .Get(tcs);
message.SetSource(source, processor);
task = tcs.Task;
}
// prepare an outer-command that decorates that, but expects QUEUED
var queued = new QueuedMessage(message);
var wasQueued = ResultBox <bool> .Get(null);
queued.SetSource(wasQueued, QueuedProcessor.Default);
// store it, and return the task of the *outer* command
// (there is no task for the inner command)
lock (SyncLock)
{
(_pending ?? (_pending = new List <QueuedMessage>())).Add(queued);
switch (message.Command)
{
case RedisCommand.UNKNOWN:
case RedisCommand.EVAL:
case RedisCommand.EVALSHA:
// people can do very naughty things in an EVAL
// including change the DB; change it back to what we
// think it should be!
var sel = PhysicalConnection.GetSelectDatabaseCommand(message.Db);
queued = new QueuedMessage(sel);
wasQueued = ResultBox <bool> .Get(null);
queued.SetSource(wasQueued, QueuedProcessor.Default);
_pending.Add(queued);
break;
}
}
return(task);
}
internal Task <T> QueueDirectAsync <T>(Message message, ResultProcessor <T> processor, object asyncState = null, PhysicalBridge bridge = null)
{
var tcs = TaskSource.Create <T>(asyncState);
var source = ResultBox <T> .Get(tcs);
message.SetSource(processor, source);
if (bridge == null)
{
bridge = GetBridge(message.Command);
}
if (!bridge.TryEnqueue(message, isSlave))
{
ConnectionMultiplexer.ThrowFailed(tcs, ExceptionFactory.NoConnectionAvailable(Multiplexer.IncludeDetailInExceptions, Multiplexer.IncludePerformanceCountersInExceptions, message.Command, message, this, Multiplexer.GetServerSnapshot()));
}
return(tcs.Task);
}
internal Task <T> WriteDirectAsync <T>(Message message, ResultProcessor <T> processor, object asyncState = null, PhysicalBridge bridge = null)
{
var tcs = TaskSource.Create <T>(asyncState);
var source = ResultBox <T> .Get(tcs);
message.SetSource(processor, source);
if (bridge == null)
{
bridge = GetBridge(message.Command);
}
var result = bridge.TryWrite(message, isSlave);
if (result != WriteResult.Success)
{
var ex = Multiplexer.GetException(result, message, this);
ConnectionMultiplexer.ThrowFailed(tcs, ex);
}
return(tcs.Task);
}
internal override Task <T> ExecuteAsync <T>(Message message, ResultProcessor <T> processor, ServerEndPoint server = null)
{ // inject our expected server automatically
if (server == null)
{
server = this.server;
}
FixFlags(message, server);
if (!server.IsConnected)
{
if (message == null)
{
return(CompletedTask <T> .Default(asyncState));
}
if (message.IsFireAndForget)
{
return(CompletedTask <T> .Default(null)); // F+F explicitly does not get async-state
}
// no need to deny exec-sync here; will be complete before they see if
var tcs = TaskSource.Create <T>(asyncState);
ConnectionMultiplexer.ThrowFailed(tcs, ExceptionFactory.NoConnectionAvailable(multiplexer.IncludeDetailInExceptions, message.Command, message, server));
return(tcs.Task);
}
return(base.ExecuteAsync <T>(message, processor, server));
}