Module: Valkey::Commands::ConnectionCommands

Included in:
Valkey::Commands
Defined in:
lib/valkey/commands/connection_commands.rb

Overview

This module contains commands related to connection management.

See Also:

Instance Method Summary collapse

Instance Method Details

#auth(*args) ⇒ String

Authenticate to the server.

Parameters:

  • args (Array<String>) —

    includes both username and password or only password

Returns:

  • (String) —

    OK



15
16
17
 
# File 'lib/valkey/commands/connection_commands.rb', line 15

def auth(*args)
  send_command(RequestType::AUTH, args)
end

#client(subcommand, *args) ⇒ Object

Send a generic CLIENT subcommand.

Examples:

client(:id)                  # => 12345
client(:set_name, "my_app")  # => "OK"
client(:list)                # => [{"id" => "1", ...}, ...]

Parameters:

  • subcommand (Symbol, String) —

    The CLIENT subcommand to run, e.g. :list, :id, :kill, etc.

  • args (Array) —

    Arguments for the subcommand

Returns:

  • (Object) —

    Depends on subcommand



103
104
105
 
# File 'lib/valkey/commands/connection_commands.rb', line 103

def client(subcommand, *args)
  public_send("client_#{subcommand.to_s.downcase}", *args)
end

#client_get_name ⇒ String?

Get the current client's name.

Returns:

  • (String, nil) —

    Client name or nil if not set



118
119
120
 
# File 'lib/valkey/commands/connection_commands.rb', line 118

def client_get_name
  send_command(RequestType::CLIENT_GET_NAME)
end

#client_id(route: nil) ⇒ Integer

Get the current client's ID.

Parameters:

  • route (Valkey::Route, nil) (defaults to: nil) —

    cluster routing. When routed, may return a Hash of node => value.

Returns:

  • (Integer) 


111
112
113
 
# File 'lib/valkey/commands/connection_commands.rb', line 111

def client_id(route: nil)
  send_command(RequestType::CLIENT_ID, [], route: route)
end

#client_info ⇒ String

Get information about the current client connection.

Returns:

  • (String) —

    Client connection information



158
159
160
 
# File 'lib/valkey/commands/connection_commands.rb', line 158

def client_info
  send_command(RequestType::CLIENT_INFO)
end

#client_kill(addr = nil, **options) ⇒ Integer

Kill client connections.

Parameters:

  • addr (String) (defaults to: nil) —

    Client address (ip:port)

  • options (Hash) —

    Optional filters (id, type, user, addr, laddr, skipme)

Returns:

  • (Integer) —

    Number of clients killed



167
168
169
170
171
172
173
 
# File 'lib/valkey/commands/connection_commands.rb', line 167

def client_kill(addr = nil, **options)
  if addr && options.empty?
    send_command(RequestType::CLIENT_KILL_SIMPLE, [addr])
  else
    send_command(RequestType::CLIENT_KILL, build_client_kill_args(addr, options))
  end
end

#client_kill_simple(addr) ⇒ String

Kill a client connection by address (simple form).

Parameters:

  • addr (String) —

    Client address (ip:port)

Returns:

  • (String) —

    OK



179
180
181
 
# File 'lib/valkey/commands/connection_commands.rb', line 179

def client_kill_simple(addr)
  send_command(RequestType::CLIENT_KILL_SIMPLE, [addr])
end

#client_list(type: nil, ids: nil) ⇒ Array<Hash>

Get a list of client connections.

Parameters:

  • type (String) (defaults to: nil) —

    Optional filter by client type (normal, master, slave, pubsub)

  • ids (Array<String>) (defaults to: nil) —

    Optional filter by client IDs

Returns:

  • (Array<Hash>) —

    List of clients, each represented as a Hash of attributes



135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
 
# File 'lib/valkey/commands/connection_commands.rb', line 135

def client_list(type: nil, ids: nil)
  args = []

  args << "TYPE" << type if type

  if ids
    args << "ID"
    args.concat(Array(ids))
  end

  send_command(RequestType::CLIENT_LIST, args) do |reply|
    reply.lines.map do |line|
      line.chomp.split.each_with_object({}) do |pair, hash|
        key, value = pair.split("=", 2)
        hash[key] = value || ""
      end
    end
  end
end

#client_no_evict(mode) ⇒ String

Enable/disable client no-evict mode.

Parameters:

  • mode (String) —

    Mode (ON, OFF)

Returns:

  • (String) —

    OK



292
293
294
 
# File 'lib/valkey/commands/connection_commands.rb', line 292

def client_no_evict(mode)
  send_command(RequestType::CLIENT_NO_EVICT, [mode.to_s.upcase])
end

#client_no_touch(mode) ⇒ String

Enable/disable client no-touch mode.

Parameters:

  • mode (String) —

    Mode (ON, OFF)

Returns:

  • (String) —

    OK



300
301
302
 
# File 'lib/valkey/commands/connection_commands.rb', line 300

def client_no_touch(mode)
  send_command(RequestType::CLIENT_NO_TOUCH, [mode.to_s.upcase])
end

#client_pause(timeout, mode = nil) ⇒ String

Pause client processing.

Parameters:

  • timeout (Integer) —

    Pause duration in milliseconds

  • mode (String) (defaults to: nil) —

    Optional mode (WRITE, ALL)

Returns:

  • (String) —

    OK



208
209
210
211
212
 
# File 'lib/valkey/commands/connection_commands.rb', line 208

def client_pause(timeout, mode = nil)
  args = [timeout]
  args << mode if mode
  send_command(RequestType::CLIENT_PAUSE, args)
end

#client_reply(mode) ⇒ String

Configure client reply mode.

Parameters:

  • mode (String) —

    Reply mode (ON, OFF, SKIP)

Returns:

  • (String) —

    OK



226
227
228
 
# File 'lib/valkey/commands/connection_commands.rb', line 226

def client_reply(mode)
  send_command(RequestType::CLIENT_REPLY, [mode])
end

#client_set_info(attr, value) ⇒ String

Set client connection information.

Parameters:

  • attr (String) —

    Attribute to set (lib-name, lib-ver)

  • value (String) —

    Value to set for the attribute

Returns:

  • (String) —

    OK



246
247
248
 
# File 'lib/valkey/commands/connection_commands.rb', line 246

def client_set_info(attr, value)
  send_command(RequestType::CLIENT_SET_INFO, [attr, value])
end

#client_set_name(name) ⇒ String

Set the current client's name.

Parameters:

  • name (String) —

    New name for the client connection

Returns:

  • (String) —

    OK



126
127
128
 
# File 'lib/valkey/commands/connection_commands.rb', line 126

def client_set_name(name)
  send_command(RequestType::CLIENT_SET_NAME, [name])
end

#client_unblock(client_id, unblock_type = nil) ⇒ Integer

Unblock a client blocked in a blocking operation.

Parameters:

  • client_id (Integer) —

    ID of the client to unblock

  • unblock_type (String) (defaults to: nil) —

    Optional unblock type (TIMEOUT, ERROR)

Returns:

  • (Integer) —

    1 if client was unblocked, 0 otherwise



235
236
237
238
239
 
# File 'lib/valkey/commands/connection_commands.rb', line 235

def client_unblock(client_id, unblock_type = nil)
  args = [client_id]
  args << unblock_type if unblock_type
  send_command(RequestType::CLIENT_UNBLOCK, args)
end

#client_unpause(route: nil) ⇒ String

Unpause client processing.

Parameters:

  • route (Valkey::Route, nil) (defaults to: nil) —

    cluster routing.

Returns:

  • (String) —

    OK



218
219
220
 
# File 'lib/valkey/commands/connection_commands.rb', line 218

def client_unpause(route: nil)
  send_command(RequestType::CLIENT_UNPAUSE, [], route: route)
end

#echo(value, route: nil) ⇒ String

Echo the given string.

Parameters:

  • value (String)
  • route (Valkey::Route, nil) (defaults to: nil) —

    cluster routing. When routed, may return a Hash of node => value.

Returns:

  • (String) 


38
39
40
 
# File 'lib/valkey/commands/connection_commands.rb', line 38

def echo(value, route: nil)
  send_command(RequestType::ECHO, [value], route: route)
end

#hello(protover = 3, **options) ⇒ Hash

Switch to a different protocol version and handshake with the server.

Parameters:

  • protover (Integer) (defaults to: 3) —

    Protocol version (2 or 3)

  • options (Hash) —

    Optional parameters like AUTH, SETNAME

Returns:

  • (Hash) —

    Server information (server, version, proto, id, mode, role, modules)



74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/valkey/commands/connection_commands.rb', line 74

def hello(protover = 3, **options)
  args = [protover]

  if options[:auth]
    args << "AUTH"
    args.concat(Array(options[:auth]))
  end

  args << "SETNAME" << options[:setname] if options[:setname]

  send_command(RequestType::HELLO, args)
end

#ping(message = nil, route: nil) ⇒ String

Ping the server.

Examples:

ping             #=> "PONG"
ping("hello")    #=> "hello"
ping(route: Valkey::Route.all_nodes)  #=> Hash (multi-node)

Parameters:

  • message (String, nil) (defaults to: nil) —

    optional message to echo back

  • route (Valkey::Route, nil) (defaults to: nil) —

    cluster routing. When routed, may return a Hash of node => value.

Returns:

  • (String) 


29
30
31
 
# File 'lib/valkey/commands/connection_commands.rb', line 29

def ping(message = nil, route: nil)
  send_command(RequestType::PING, [message].compact, route: route)
end

#quit ⇒ String

Deprecated.

The QUIT command is deprecated since Redis 7.2.0 / Valkey 7.2+. Clients should use the close method directly instead. This avoids lingering TIME_WAIT sockets on the server side.

Close the connection.

Returns:

  • (String) —

    OK or nil if connection already closed

See Also:



58
59
60
61
62
63
64
65
66
67
 
# File 'lib/valkey/commands/connection_commands.rb', line 58

def quit
  # For compatibility, we still support QUIT but recommend using close() instead
  send_command(RequestType::QUIT)
rescue ConnectionError
  # Server closes connection immediately after QUIT
  nil
ensure
  # Clean up our side of the connection
  close if respond_to?(:close)
end

#reset ⇒ String

Reset the connection state.

Returns:

  • (String) —

    RESET



90
91
92
 
# File 'lib/valkey/commands/connection_commands.rb', line 90

def reset
  send_command(RequestType::RESET)
end

#select(db) ⇒ String

Change the selected database for the current connection.

Parameters:

  • db (Integer) —

    zero-based index of the DB to use (0 to 15)

Returns:

  • (String) —

    OK



46
47
48
 
# File 'lib/valkey/commands/connection_commands.rb', line 46

def select(db)
  send_command(RequestType::SELECT, [db])
end