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); } } } }