public void Quit(CommandFlags flags = CommandFlags.None) { var msg = Message.Create(-1, flags, RedisCommand.QUIT); ExecuteSync(msg, ResultProcessor.DemandOK); }
internal void AutoConfigure(PhysicalConnection connection) { if (serverType == ServerType.Twemproxy) { // don't try to detect configuration; all the config commands are disabled, and // the fallback master/replica detection won't help return; } var commandMap = Multiplexer.CommandMap; #pragma warning disable CS0618 const CommandFlags flags = CommandFlags.FireAndForget | CommandFlags.HighPriority | CommandFlags.NoRedirect; #pragma warning restore CS0618 var features = GetFeatures(); Message msg; #pragma warning disable CS0618 if (commandMap.IsAvailable(RedisCommand.CONFIG)) { if (Multiplexer.RawConfig.KeepAlive <= 0) { msg = Message.Create(-1, flags, RedisCommand.CONFIG, RedisLiterals.GET, RedisLiterals.timeout); msg.SetInternalCall(); WriteDirectOrQueueFireAndForgetSync(connection, msg, ResultProcessor.AutoConfigure); } msg = Message.Create(-1, flags, RedisCommand.CONFIG, RedisLiterals.GET, features.ReplicaCommands ? RedisLiterals.replica_read_only : RedisLiterals.slave_read_only); msg.SetInternalCall(); WriteDirectOrQueueFireAndForgetSync(connection, msg, ResultProcessor.AutoConfigure); msg = Message.Create(-1, flags, RedisCommand.CONFIG, RedisLiterals.GET, RedisLiterals.databases); msg.SetInternalCall(); WriteDirectOrQueueFireAndForgetSync(connection, msg, ResultProcessor.AutoConfigure); } if (commandMap.IsAvailable(RedisCommand.SENTINEL)) { msg = Message.Create(-1, flags, RedisCommand.SENTINEL, RedisLiterals.MASTERS); msg.SetInternalCall(); WriteDirectOrQueueFireAndForgetSync(connection, msg, ResultProcessor.AutoConfigure); } if (commandMap.IsAvailable(RedisCommand.INFO)) { lastInfoReplicationCheckTicks = Environment.TickCount; if (features.InfoSections) { msg = Message.Create(-1, flags, RedisCommand.INFO, RedisLiterals.replication); msg.SetInternalCall(); WriteDirectOrQueueFireAndForgetSync(connection, msg, ResultProcessor.AutoConfigure); msg = Message.Create(-1, flags, RedisCommand.INFO, RedisLiterals.server); msg.SetInternalCall(); WriteDirectOrQueueFireAndForgetSync(connection, msg, ResultProcessor.AutoConfigure); } else { msg = Message.Create(-1, flags, RedisCommand.INFO); msg.SetInternalCall(); WriteDirectOrQueueFireAndForgetSync(connection, msg, ResultProcessor.AutoConfigure); } } else if (commandMap.IsAvailable(RedisCommand.SET)) { // this is a nasty way to find if we are a replica, and it will only work on up-level servers, but... RedisKey key = Multiplexer.UniqueId; // the actual value here doesn't matter (we detect the error code if it fails); the value here is to at least give some // indication to anyone watching via "monitor", but we could send two guids (key/value) and it would work the same msg = Message.Create(0, flags, RedisCommand.SET, key, RedisLiterals.replica_read_only, RedisLiterals.PX, 1, RedisLiterals.NX); msg.SetInternalCall(); WriteDirectOrQueueFireAndForgetSync(connection, msg, ResultProcessor.AutoConfigure); } if (commandMap.IsAvailable(RedisCommand.CLUSTER)) { msg = Message.Create(-1, flags, RedisCommand.CLUSTER, RedisLiterals.NODES); msg.SetInternalCall(); WriteDirectOrQueueFireAndForgetSync(connection, msg, ResultProcessor.ClusterNodes); } #pragma warning restore CS0618 }
Task <string> IRedisAsync.ClientGetNameAsync(CommandFlags flags) { var msg = Message.Create(-1, flags, RedisCommand.CLIENT, RedisLiterals.GETNAME); return(ExecuteAsync(msg, ResultProcessor.String)); }
public Task ClientKillAsync(EndPoint endpoint, CommandFlags flags = CommandFlags.None) { var msg = Message.Create(-1, flags, RedisCommand.CLIENT, RedisLiterals.KILL, (RedisValue)Format.ToString(endpoint)); return(ExecuteAsync(msg, ResultProcessor.DemandOK)); }
public Task <ClusterConfiguration> ClusterNodesAsync(CommandFlags flags = CommandFlags.None) { var msg = Message.Create(-1, flags, RedisCommand.CLUSTER, RedisLiterals.NODES); return(ExecuteAsync(msg, ResultProcessor.ClusterNodes)); }
public Task <RedisValue> StringGetAsync(int db, RedisKey key, CommandFlags flags = CommandFlags.None) { var msg = Message.Create(db, flags, RedisCommand.GET, key); return(ExecuteAsync(msg, ResultProcessor.RedisValue)); }
public Task <long> SubscriptionSubscriberCountAsync(RedisChannel channel, CommandFlags flags = CommandFlags.None) { var msg = Message.Create(-1, flags, RedisCommand.PUBSUB, RedisLiterals.NUMSUB, channel); return(ExecuteAsync(msg, ResultProcessor.Int64)); }
public Task ConfigRewriteAsync(CommandFlags flags = CommandFlags.None) { var msg = Message.Create(-1, flags, RedisCommand.CONFIG, RedisLiterals.REWRITE); return(ExecuteAsync(msg, ResultProcessor.DemandOK)); }
public Task <long> DatabaseSizeAsync(int database = 0, CommandFlags flags = CommandFlags.None) { var msg = Message.Create(database, flags, RedisCommand.DBSIZE); return(ExecuteAsync(msg, ResultProcessor.Int64)); }
public void ConfigResetStatistics(CommandFlags flags = CommandFlags.None) { var msg = Message.Create(-1, flags, RedisCommand.CONFIG, RedisLiterals.RESETSTAT); ExecuteSync(msg, ResultProcessor.DemandOK); }
public void ConfigRewrite(CommandFlags flags = CommandFlags.None) { var msg = Message.Create(-1, flags, RedisCommand.CONFIG, RedisLiterals.REWRITE); ExecuteSync(msg, ResultProcessor.DemandOK); }
private void Handshake(PhysicalConnection connection, TextWriter log) { multiplexer.LogLocked(log, "Server handshake"); if (connection == null) { multiplexer.Trace("No connection!?"); return; } Message msg; string password = multiplexer.RawConfig.Password; if (!string.IsNullOrWhiteSpace(password)) { multiplexer.LogLocked(log, "Authenticating (password)"); msg = Message.Create(-1, CommandFlags.FireAndForget, RedisCommand.AUTH, (RedisValue)password); msg.SetInternalCall(); WriteDirectOrQueueFireAndForget(connection, msg, ResultProcessor.DemandOK); } if (multiplexer.CommandMap.IsAvailable(RedisCommand.CLIENT)) { string name = multiplexer.ClientName; if (!string.IsNullOrWhiteSpace(name)) { name = nameSanitizer.Replace(name, ""); if (!string.IsNullOrWhiteSpace(name)) { multiplexer.LogLocked(log, "Setting client name: {0}", name); msg = Message.Create(-1, CommandFlags.FireAndForget, RedisCommand.CLIENT, RedisLiterals.SETNAME, (RedisValue)name); msg.SetInternalCall(); WriteDirectOrQueueFireAndForget(connection, msg, ResultProcessor.DemandOK); } } } var connType = connection.Bridge.ConnectionType; if (connType == ConnectionType.Interactive) { multiplexer.LogLocked(log, "Auto-configure..."); AutoConfigure(connection); } multiplexer.LogLocked(log, "Sending critical tracer: {0}", connection.Bridge); var tracer = GetTracerMessage(true); tracer = LoggingMessage.Create(log, tracer); WriteDirectOrQueueFireAndForget(connection, tracer, ResultProcessor.EstablishConnection); // note: this **must** be the last thing on the subscription handshake, because after this // we will be in subscriber mode: regular commands cannot be sent if (connType == ConnectionType.Subscription) { var configChannel = multiplexer.ConfigurationChangedChannel; if (configChannel != null) { msg = Message.Create(-1, CommandFlags.FireAndForget, RedisCommand.SUBSCRIBE, (RedisChannel)configChannel); WriteDirectOrQueueFireAndForget(connection, msg, ResultProcessor.TrackSubscriptions); } } multiplexer.LogLocked(log, "Flushing outbound buffer"); connection.Flush(); }
internal static Message GetSelectDatabaseCommand(int targetDatabase) { return(targetDatabase < DefaultRedisDatabaseCount ? ReusableChangeDatabaseCommands[targetDatabase] // 0-15 by default : Message.Create(targetDatabase, CommandFlags.FireAndForget, RedisCommand.SELECT)); }
public Task QuitAsync(CommandFlags flags = CommandFlags.None) { var msg = Message.Create(-1, flags, RedisCommand.QUIT); return(ExecuteAsync(msg, ResultProcessor.DemandOK)); }
public void SlowlogReset(CommandFlags flags = CommandFlags.None) { var msg = Message.Create(-1, flags, RedisCommand.SLOWLOG, RedisLiterals.RESET); ExecuteSync(msg, ResultProcessor.DemandOK); }
public void FlushAllDatabases(CommandFlags flags = CommandFlags.None) { var msg = Message.Create(-1, flags, RedisCommand.FLUSHALL); ExecuteSync(msg, ResultProcessor.DemandOK); }
public Task SlowlogResetAsync(CommandFlags flags = CommandFlags.None) { var msg = Message.Create(-1, flags, RedisCommand.SLOWLOG, RedisLiterals.RESET); return(ExecuteAsync(msg, ResultProcessor.DemandOK)); }
public Task FlushAllDatabasesAsync(CommandFlags flags = CommandFlags.None) { var msg = Message.Create(-1, flags, RedisCommand.FLUSHALL); return(ExecuteAsync(msg, ResultProcessor.DemandOK)); }
public Task <long> SubscriptionPatternCountAsync(CommandFlags flags = CommandFlags.None) { var msg = Message.Create(-1, flags, RedisCommand.PUBSUB, RedisLiterals.NUMPAT); return(ExecuteAsync(msg, ResultProcessor.Int64)); }
public void FlushDatabase(int database = 0, CommandFlags flags = CommandFlags.None) { var msg = Message.Create(database, flags, RedisCommand.FLUSHDB); ExecuteSync(msg, ResultProcessor.DemandOK); }
public Task <DateTime> TimeAsync(CommandFlags flags = CommandFlags.None) { var msg = Message.Create(-1, flags, RedisCommand.TIME); return(ExecuteAsync(msg, ResultProcessor.DateTime)); }
public Task FlushDatabaseAsync(int database = 0, CommandFlags flags = CommandFlags.None) { var msg = Message.Create(database, flags, RedisCommand.FLUSHDB); return(ExecuteAsync(msg, ResultProcessor.DemandOK)); }
public Task <ClientInfo[]> ClientListAsync(CommandFlags flags = CommandFlags.None) { var msg = Message.Create(-1, flags, RedisCommand.CLIENT, RedisLiterals.LIST); return(ExecuteAsync(msg, ClientInfo.Processor)); }
public DateTime LastSave(CommandFlags flags = CommandFlags.None) { var msg = Message.Create(-1, flags, RedisCommand.LASTSAVE); return(ExecuteSync(msg, ResultProcessor.DateTime)); }
public string ClusterNodesRaw(CommandFlags flags = CommandFlags.None) { var msg = Message.Create(-1, flags, RedisCommand.CLUSTER, RedisLiterals.NODES); return(ExecuteSync(msg, ResultProcessor.ClusterNodesRaw)); }
public bool ScriptExists(string script, CommandFlags flags = CommandFlags.None) { var msg = Message.Create(-1, flags, RedisCommand.SCRIPT, RedisLiterals.EXISTS, ScriptHash.Hash(script)); return(ExecuteSync(msg, ResultProcessor.Boolean)); }
void IServer.Hang(TimeSpan duration, CommandFlags flags) { var msg = Message.Create(0, flags, RedisCommand.CLIENT, RedisLiterals.PAUSE, (long)duration.TotalMilliseconds); ExecuteSync(msg, ResultProcessor.DemandOK); }
public Task <bool> ScriptExistsAsync(byte[] sha1, CommandFlags flags = CommandFlags.None) { var msg = Message.Create(-1, flags, RedisCommand.SCRIPT, RedisLiterals.EXISTS, ScriptHash.Encode(sha1)); return(ExecuteAsync(msg, ResultProcessor.Boolean)); }
internal void AutoConfigure(PhysicalConnection connection) { if (serverType == ServerType.Twemproxy) { // don't try to detect configuration; all the config commands are disabled, and // the fallback master/slave detection won't help return; } var commandMap = Multiplexer.CommandMap; #pragma warning disable CS0618 const CommandFlags flags = CommandFlags.FireAndForget | CommandFlags.HighPriority | CommandFlags.NoRedirect; #pragma warning restore CS0618 var features = GetFeatures(); Message msg; #pragma warning disable CS0618 if (commandMap.IsAvailable(RedisCommand.CONFIG)) { if (Multiplexer.RawConfig.KeepAlive <= 0) { msg = Message.Create(-1, flags, RedisCommand.CONFIG, RedisLiterals.GET, RedisLiterals.timeout); msg.SetInternalCall(); WriteDirectOrQueueFireAndForgetSync(connection, msg, ResultProcessor.AutoConfigure); } msg = Message.Create(-1, flags, RedisCommand.CONFIG, RedisLiterals.GET, RedisLiterals.slave_read_only); msg.SetInternalCall(); WriteDirectOrQueueFireAndForgetSync(connection, msg, ResultProcessor.AutoConfigure); msg = Message.Create(-1, flags, RedisCommand.CONFIG, RedisLiterals.GET, RedisLiterals.databases); msg.SetInternalCall(); WriteDirectOrQueueFireAndForgetSync(connection, msg, ResultProcessor.AutoConfigure); } if (commandMap.IsAvailable(RedisCommand.INFO)) { lastInfoReplicationCheckTicks = Environment.TickCount; if (features.InfoSections) { msg = Message.Create(-1, flags, RedisCommand.INFO, RedisLiterals.replication); msg.SetInternalCall(); WriteDirectOrQueueFireAndForgetSync(connection, msg, ResultProcessor.AutoConfigure); msg = Message.Create(-1, flags, RedisCommand.INFO, RedisLiterals.server); msg.SetInternalCall(); WriteDirectOrQueueFireAndForgetSync(connection, msg, ResultProcessor.AutoConfigure); } else { msg = Message.Create(-1, flags, RedisCommand.INFO); msg.SetInternalCall(); WriteDirectOrQueueFireAndForgetSync(connection, msg, ResultProcessor.AutoConfigure); } } else if (commandMap.IsAvailable(RedisCommand.SET)) { // this is a nasty way to find if we are a slave, and it will only work on up-level servers, but... RedisKey key = Multiplexer.UniqueId; msg = Message.Create(0, flags, RedisCommand.SET, key, RedisLiterals.slave_read_only, RedisLiterals.PX, 1, RedisLiterals.NX); msg.SetInternalCall(); WriteDirectOrQueueFireAndForgetSync(connection, msg, ResultProcessor.AutoConfigure); } if (commandMap.IsAvailable(RedisCommand.CLUSTER)) { msg = Message.Create(-1, flags, RedisCommand.CLUSTER, RedisLiterals.NODES); msg.SetInternalCall(); WriteDirectOrQueueFireAndForgetSync(connection, msg, ResultProcessor.ClusterNodes); } #pragma warning restore CS0618 }
public Task <KeyValuePair <string, string>[][]> SentinelSlavesAsync(string serviceName, CommandFlags flags = CommandFlags.None) { var msg = Message.Create(-1, flags, RedisCommand.SENTINEL, RedisLiterals.SLAVES, (RedisValue)serviceName); return(ExecuteAsync(msg, ResultProcessor.SentinelArrayOfArrays)); }