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);
}
public bool TryComplete(bool isAsync)
{
if (resultBox != null)
{
var ret = resultBox.TryComplete(isAsync);
if (ret && isAsync)
{
resultBox = null; // in async mode TryComplete will have unwrapped and recycled resultBox; ensure we no longer reference it via this message
}
performance?.SetCompleted();
return(ret);
}
else
{
ConnectionMultiplexer.TraceWithoutContext("No result-box to complete for " + Command, "Message");
performance?.SetCompleted();
return(true);
}
}
/// <summary>
/// Gets how many result-box instances were allocated
/// </summary>
public static long GetResultBoxAllocationCount()
{
return(ResultBox.GetAllocationCount());
}
public IEnumerable <Message> GetMessages(PhysicalConnection connection)
{
ResultBox lastBox = null;
try
{
// Important: if the server supports EXECABORT, then we can check the pre-conditions (pause there),
// which will usually be pretty small and cheap to do - if that passes, we can just isue all the commands
// and rely on EXECABORT to kick us if we are being idiotic inside the MULTI. However, if the server does
// *not* support EXECABORT, then we need to explicitly check for QUEUED anyway; we might as well defer
// checking the preconditions to the same time to avoid having to pause twice. This will mean that on
// up-version servers, pre-condition failures exit with UNWATCH; and on down-version servers pre-condition
// failures exit with DISCARD - but that's ok : both work fine
bool explicitCheckForQueued = !connection.Bridge.ServerEndPoint.GetFeatures().ExecAbort;
var multiplexer = connection.Multiplexer;
// PART 1: issue the pre-conditions
if (!IsAborted && conditions.Length != 0)
{
for (int i = 0; i < conditions.Length; i++)
{
// need to have locked them before sending them
// to guarantee that we see the pulse
ResultBox latestBox = conditions[i].GetBox();
Monitor.Enter(latestBox);
if (lastBox != null)
{
Monitor.Exit(lastBox);
}
lastBox = latestBox;
foreach (var msg in conditions[i].CreateMessages(Db))
{
msg.SetNoRedirect(); // need to keep them in the current context only
yield return(msg);
}
}
if (!explicitCheckForQueued && lastBox != null)
{
// need to get those sent ASAP; if they are stuck in the buffers, we die
multiplexer.Trace("Flushing and waiting for precondition responses");
connection.Flush();
if (Monitor.Wait(lastBox, multiplexer.TimeoutMilliseconds))
{
if (!AreAllConditionsSatisfied(multiplexer))
{
command = RedisCommand.UNWATCH; // somebody isn't happy
}
}
else
{ // timeout running pre-conditions
multiplexer.Trace("Timeout checking preconditions");
command = RedisCommand.UNWATCH;
}
Monitor.Exit(lastBox);
lastBox = null;
}
}
// PART 2: begin the transaction
if (!IsAborted)
{
multiplexer.Trace("Begining transaction");
yield return(SharedMulti);
}
// PART 3: issue the commands
if (!IsAborted && operations.Length != 0)
{
multiplexer.Trace("Issuing transaction operations");
foreach (var op in operations)
{
if (explicitCheckForQueued)
{ // need to have locked them before sending them
// to guarantee that we see the pulse
ResultBox thisBox = op.ResultBox;
if (thisBox != null)
{
Monitor.Enter(thisBox);
if (lastBox != null)
{
Monitor.Exit(lastBox);
}
lastBox = thisBox;
}
}
yield return(op);
}
if (explicitCheckForQueued && lastBox != null)
{
multiplexer.Trace("Flushing and waiting for precondition+queued responses");
connection.Flush(); // make sure they get sent, so we can check for QUEUED (and the pre-conditions if necessary)
if (Monitor.Wait(lastBox, multiplexer.TimeoutMilliseconds))
{
if (!AreAllConditionsSatisfied(multiplexer))
{
command = RedisCommand.DISCARD;
}
else
{
foreach (var op in operations)
{
if (!op.WasQueued)
{
multiplexer.Trace("Aborting: operation was not queued: " + op.Command);
command = RedisCommand.DISCARD;
break;
}
}
}
multiplexer.Trace("Confirmed: QUEUED x " + operations.Length);
}
else
{
multiplexer.Trace("Aborting: timeout checking queued messages");
command = RedisCommand.DISCARD;
}
Monitor.Exit(lastBox);
lastBox = null;
}
}
}
finally
{
if (lastBox != null)
{
Monitor.Exit(lastBox);
}
}
if (IsAborted)
{
connection.Multiplexer.Trace("Aborting: canceling wrapped messages");
var bridge = connection.Bridge;
foreach (var op in operations)
{
op.Wrapped.Cancel();
bridge.CompleteSyncOrAsync(op.Wrapped);
}
}
connection.Multiplexer.Trace("End ot transaction: " + Command);
yield return(this); // acts as either an EXEC or an UNWATCH, depending on "aborted"
}
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 ConditionResult(Condition condition)
{
this.Condition = condition;
resultBox = ResultBox <bool> .Get(condition);
}
internal abstract IEnumerable <Message> CreateMessages(int db, ResultBox resultBox);
/// <summary> /// Gets how many result-box instances were allocated /// </summary> public static long GetResultBoxAllocationCount() => ResultBox.GetAllocationCount();