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 override T ExecuteSync <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 || message.IsFireAndForget)
{
return(default(T));
}
throw ExceptionFactory.NoConnectionAvailable(multiplexer.IncludeDetailInExceptions, message.Command, message, server);
}
return(base.ExecuteSync <T>(message, processor, server));
}
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);
}
private Message CreateMessage(CommandFlags flags, out ResultProcessor <bool> processor)
{
var work = pending;
pending = null; // any new operations go into a different queue
var cond = conditions;
conditions = null; // any new conditions go into a different queue
if ((work == null || work.Count == 0) && (cond == null || cond.Count == 0))
{
if ((flags & CommandFlags.FireAndForget) != 0)
{
processor = null;
return(null); // they won't notice if we don't do anything...
}
processor = ResultProcessor.DemandPONG;
return(Message.Create(-1, flags, RedisCommand.PING));
}
processor = TransactionProcessor.Default;
return(new TransactionMessage(Database, flags, cond, work));
}
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));
}
internal override T ExecuteSync <T>(Message message, ResultProcessor <T> processor, ServerEndPoint server = null)
{
throw new NotSupportedException("ExecuteSync cannot be used inside a transaction");
}
internal void SetSource <T>(ResultBox <T> resultBox, ResultProcessor <T> resultProcessor)
{
this.resultBox = resultBox;
this.resultProcessor = resultProcessor;
}
internal void SetSource(ResultProcessor resultProcessor, ResultBox resultBox)
{ // note order here reversed to prevent overload resolution errors
this.resultBox = resultBox;
this.resultProcessor = resultProcessor;
}
internal void WriteDirectOrQueueFireAndForget <T>(PhysicalConnection connection, Message message, ResultProcessor <T> processor)
{
if (message != null)
{
message.SetSource(processor, null);
if (connection == null)
{
multiplexer.Trace("Enqueue: " + message);
GetBridge(message.Command).TryEnqueue(message, isSlave);
}
else
{
multiplexer.Trace("Writing direct: " + message);
connection.Bridge.WriteMessageDirect(connection, message);
}
}
}
internal ValueTask WriteDirectOrQueueFireAndForgetAsync <T>(PhysicalConnection connection, Message message, ResultProcessor <T> processor)
{
async ValueTask Awaited(ValueTask <WriteResult> l_result) => await l_result.ForAwait();
if (message != null)
{
message.SetSource(processor, null);
ValueTask <WriteResult> result;
if (connection == null)
{
Multiplexer.Trace("Enqueue: " + message);
result = GetBridge(message.Command).TryWriteAsync(message, isSlave);
}
else
{
Multiplexer.Trace("Writing direct: " + message);
var bridge = connection.BridgeCouldBeNull;
if (bridge == null)
{
throw new ObjectDisposedException(connection.ToString());
}
else
{
result = bridge.WriteMessageTakingWriteLockAsync(connection, message);
}
}
if (!result.IsCompletedSuccessfully)
{
return(Awaited(result));
}
}
return(default);
internal void WriteDirectOrQueueFireAndForget <T>(PhysicalConnection connection, Message message, ResultProcessor <T> processor)
{
if (message != null)
{
message.SetSource(processor, null);
if (connection == null)
{
Multiplexer.Trace("Enqueue: " + message);
GetBridge(message.Command).TryWrite(message, isSlave);
}
else
{
Multiplexer.Trace("Writing direct: " + message);
var bridge = connection.BridgeCouldBeNull;
if (bridge == null)
{
throw new ObjectDisposedException(connection.ToString());
}
else
{
bridge.WriteMessageTakingWriteLock(connection, message);
}
}
}
}
