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.CreateDenyExecSync <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 AddSubscription(RedisChannel channel, Action <RedisChannel, RedisValue> handler, CommandFlags flags, object asyncState) { if (handler != null) { lock (subscriptions) { Subscription sub; if (subscriptions.TryGetValue(channel, out sub)) { sub.Add(handler); } else { sub = new Subscription(handler); subscriptions.Add(channel, sub); var task = sub.SubscribeToServer(this, channel, flags, asyncState, false); if (task != null) { return(task); } } } } return(CompletedTask <bool> .Default(asyncState)); }
internal virtual Task <T> ExecuteAsync <T>(Message message, ResultProcessor <T> processor, ServerEndPoint server = null) { if (message == null) { return(CompletedTask <T> .Default(asyncState)); } multiplexer.CheckMessage(message); return(multiplexer.ExecuteAsyncImpl <T>(message, processor, asyncState, server)); }
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.CreateDenyExecSync <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) (pending ?? (pending = new List <QueuedMessage>())).Add(queued); switch (message.Command) { 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 Close() { var tmp = interactive; Task result; if (tmp == null || !tmp.IsConnected || !multiplexer.CommandMap.IsAvailable(RedisCommand.QUIT)) { result = CompletedTask <bool> .Default(null); } else { result = QueueDirectAsync(Message.Create(-1, CommandFlags.None, RedisCommand.QUIT), ResultProcessor.DemandOK, bridge: interactive); } return(result); }
internal Task RemoveAllSubscriptions(CommandFlags flags, object asyncState) { Task last = CompletedTask <bool> .Default(asyncState); lock (subscriptions) { foreach (var pair in subscriptions) { pair.Value.Remove(null); // always wipes var task = pair.Value.UnsubscribeFromServer(pair.Key, flags, asyncState, false); if (task != null) { last = task; } } subscriptions.Clear(); } return(last); }
internal Task RemoveSubscription(RedisChannel channel, Action <RedisChannel, RedisValue> handler, CommandFlags flags, object asyncState) { lock (subscriptions) { Subscription sub; if (subscriptions.TryGetValue(channel, out sub)) { if (sub.Remove(handler)) { subscriptions.Remove(channel); var task = sub.UnsubscribeFromServer(channel, flags, asyncState, false); if (task != null) { return(task); } } } } return(CompletedTask <bool> .Default(asyncState)); }
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, multiplexer.GetServerSnapshot())); return(tcs.Task); } return(base.ExecuteAsync <T>(message, processor, server)); }