valkey-rb 1.0.0

data/lib/valkey/commands/cluster_commands.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+class Valkey
+  module Commands
+    # This module contains commands related to Redis Cluster management.
+    #
+    # @see https://valkey.io/commands/#cluster
+    #
+    module ClusterCommands
+      # Send ASKING command to the server.
+      #
+      # @return [String] `"OK"`
+      def asking
+        send_command(RequestType::ASKING)
+      end
+
+      # Add slots to the cluster.
+      #
+      # @param [Array<Integer>] slots array of slot numbers
+      # @return [String] `"OK"`
+      def cluster_addslots(*slots)
+        send_command(RequestType::CLUSTER_ADD_SLOTS, slots)
+      end
+
+      # Add a range of slots to the cluster.
+      #
+      # @param [Integer] start_slot starting slot number
+      # @param [Integer] end_slot ending slot number
+      # @return [String] `"OK"`
+      def cluster_addslotsrange(start_slot, end_slot)
+        send_command(RequestType::CLUSTER_ADD_SLOTS_RANGE, [start_slot, end_slot])
+      end
+
+      # Bump the epoch of the cluster.
+      #
+      # @return [String] `"OK"`
+      def cluster_bumpepoch
+        send_command(RequestType::CLUSTER_BUMP_EPOCH)
+      end
+
+      # Count failure reports for a node.
+      #
+      # @param [String] node_id the node ID
+      # @return [Integer] number of failure reports
+      def cluster_count_failure_reports(node_id)
+        send_command(RequestType::CLUSTER_COUNT_FAILURE_REPORTS, [node_id])
+      end
+
+      # Count keys in a specific slot.
+      #
+      # @param [Integer] slot the slot number
+      # @return [Integer] number of keys in the slot
+      def cluster_countkeysinslot(slot)
+        send_command(RequestType::CLUSTER_COUNT_KEYS_IN_SLOT, [slot])
+      end
+
+      # Delete slots from the cluster.
+      #
+      # @param [Array<Integer>] slots array of slot numbers
+      # @return [String] `"OK"`
+      def cluster_delslots(*slots)
+        send_command(RequestType::CLUSTER_DEL_SLOTS, slots)
+      end
+
+      # Delete a range of slots from the cluster.
+      #
+      # @param [Integer] start_slot starting slot number
+      # @param [Integer] end_slot ending slot number
+      # @return [String] `"OK"`
+      def cluster_delslotsrange(start_slot, end_slot)
+        send_command(RequestType::CLUSTER_DEL_SLOTS_RANGE, [start_slot, end_slot])
+      end
+
+      # Force a failover of the cluster.
+      #
+      # @param [String] force force the failover
+      # @return [String] `"OK"`
+      def cluster_failover(force = nil)
+        args = []
+        args << "FORCE" if force
+        send_command(RequestType::CLUSTER_FAILOVER, args)
+      end
+
+      # Flush all slots from the cluster.
+      #
+      # @return [String] `"OK"`
+      def cluster_flushslots
+        send_command(RequestType::CLUSTER_FLUSH_SLOTS)
+      end
+
+      # Remove a node from the cluster.
+      #
+      # @param [String] node_id the node ID to forget
+      # @return [String] `"OK"`
+      def cluster_forget(node_id)
+        send_command(RequestType::CLUSTER_FORGET, [node_id])
+      end
+
+      # Get keys in a specific slot.
+      #
+      # @param [Integer] slot the slot number
+      # @param [Integer] count maximum number of keys to return
+      # @return [Array<String>] array of keys
+      def cluster_getkeysinslot(slot, count)
+        send_command(RequestType::CLUSTER_GET_KEYS_IN_SLOT, [slot, count])
+      end
+
+      # Get information about the cluster.
+      #
+      # @return [Hash<String, String>] cluster information
+      def cluster_info
+        send_command(RequestType::CLUSTER_INFO) do |reply|
+          Utils::HashifyInfo.call(reply)
+        end
+      end
+
+      # Get the slot for a key.
+      #
+      # @param [String] key the key name
+      # @return [Integer] slot number
+      def cluster_keyslot(key)
+        send_command(RequestType::CLUSTER_KEY_SLOT, [key])
+      end
+
+      # Get information about cluster links.
+      #
+      # @return [Array<Hash>] array of link information
+      def cluster_links
+        send_command(RequestType::CLUSTER_LINKS)
+      end
+
+      # Meet another node in the cluster.
+      #
+      # @param [String] ip IP address of the node
+      # @param [Integer] port port of the node
+      # @return [String] `"OK"`
+      def cluster_meet(ip, port)
+        send_command(RequestType::CLUSTER_MEET, [ip, port])
+      end
+
+      # Get the ID of the current node.
+      #
+      # @return [String] node ID
+      def cluster_myid
+        send_command(RequestType::CLUSTER_MY_ID)
+      end
+
+      # Get the shard ID of the current node.
+      #
+      # @return [String] shard ID
+      def cluster_myshardid
+        send_command(RequestType::CLUSTER_MY_SHARD_ID)
+      end
+
+      # Get information about all nodes in the cluster.
+      #
+      # @return [Array<Hash>] array of node information
+      def cluster_nodes
+        send_command(RequestType::CLUSTER_NODES) do |reply|
+          Utils::HashifyClusterNodes.call(reply)
+        end
+      end
+
+      # Get information about replica nodes.
+      #
+      # @param [String] node_id the master node ID
+      # @return [Array<Hash>] array of replica information
+      def cluster_replicas(node_id)
+        send_command(RequestType::CLUSTER_REPLICAS, [node_id]) do |reply|
+          Utils::HashifyClusterSlaves.call(reply)
+        end
+      end
+
+      # Set a node as a replica of another node.
+      #
+      # @param [String] node_id the master node ID
+      # @return [String] `"OK"`
+      def cluster_replicate(node_id)
+        send_command(RequestType::CLUSTER_REPLICATE, [node_id])
+      end
+
+      # Reset the cluster.
+      #
+      # @param [String] hard hard reset
+      # @return [String] `"OK"`
+      def cluster_reset(hard = nil)
+        args = []
+        args << "HARD" if hard
+        send_command(RequestType::CLUSTER_RESET, args)
+      end
+
+      # Save the cluster configuration.
+      #
+      # @return [String] `"OK"`
+      def cluster_saveconfig
+        send_command(RequestType::CLUSTER_SAVE_CONFIG)
+      end
+
+      # Set the config epoch for a node.
+      #
+      # @param [Integer] epoch the config epoch
+      # @return [String] `"OK"`
+      def cluster_set_config_epoch(epoch)
+        send_command(RequestType::CLUSTER_SET_CONFIG_EPOCH, [epoch])
+      end
+
+      # Set the state of a slot.
+      #
+      # @param [Integer] slot the slot number
+      # @param [String] state the state (importing, migrating, node, stable)
+      # @param [String] node_id the node ID (optional)
+      # @return [String] `"OK"`
+      def cluster_setslot(slot, state, node_id = nil)
+        args = [slot, state]
+        args << node_id if node_id
+        send_command(RequestType::CLUSTER_SETSLOT, args)
+      end
+
+      # Get information about cluster shards.
+      #
+      # @return [Array<Hash>] array of shard information
+      def cluster_shards
+        send_command(RequestType::CLUSTER_SHARDS)
+      end
+
+      # Get information about slave nodes (deprecated, use cluster_replicas).
+      #
+      # @return [Array<Hash>] array of slave information
+      def cluster_slaves(node_id)
+        send_command(RequestType::CLUSTER_SLAVES, [node_id]) do |reply|
+          Utils::HashifyClusterSlaves.call(reply)
+        end
+      end
+
+      # Get information about cluster slots.
+      #
+      # @return [Array<Hash>] array of slot information
+      def cluster_slots
+        send_command(RequestType::CLUSTER_SLOTS) do |reply|
+          Utils::HashifyClusterSlots.call(reply)
+        end
+      end
+
+      # Set the connection to read-only mode.
+      #
+      # @return [String] "OK"
+      def readonly
+        send_command(RequestType::READ_ONLY)
+      end
+
+      # Set the connection to read-write mode.
+      #
+      # @return [String] "OK"
+      def readwrite
+        send_command(RequestType::READ_WRITE)
+      end
+    end
+  end
+end

data/lib/valkey/commands/connection_commands.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+class Valkey
+  module Commands
+    # This module contains commands related to connection management.
+    #
+    # @see https://valkey.io/commands/#connection
+    #
+    module ConnectionCommands
+      # Authenticate to the server.
+      #
+      # @param [Array<String>] args includes both username and password
+      #   or only password
+      # @return [String] `OK`
+      def auth(*args)
+        send_command(RequestType::AUTH, args)
+      end
+
+      # Ping the server.
+      #
+      # @param [optional, String] message
+      # @return [String] `PONG`
+      def ping(message = nil)
+        send_command(RequestType::PING, [message].compact)
+      end
+
+      # Echo the given string.
+      #
+      # @param [String] value
+      # @return [String]
+      def echo(value)
+        send_command(RequestType::ECHO, [value])
+      end
+
+      # Change the selected database for the current connection.
+      #
+      # @param [Integer] db zero-based index of the DB to use (0 to 15)
+      # @return [String] `OK`
+      def select(db)
+        send_command(RequestType::SELECT, [db])
+      end
+
+      # Close the connection.
+      #
+      # @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.
+      #
+      # @return [String] `OK` or nil if connection already closed
+      # @see https://redis.io/docs/latest/commands/quit/
+      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
+
+      # Switch to a different protocol version and handshake with the server.
+      #
+      # @param [Integer] protover Protocol version (2 or 3)
+      # @param [Hash] options Optional parameters like AUTH, SETNAME
+      # @return [Array] Server information as flat array (TODO: should be Hash for RESP3)
+      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
+
+      # Reset the connection state.
+      #
+      # @return [String] `RESET`
+      def reset
+        send_command(RequestType::RESET)
+      end
+
+      # Send a generic CLIENT subcommand.
+      #
+      # @param [Symbol, String] subcommand The CLIENT subcommand to run, e.g. :list, :id, :kill, etc.
+      # @param [Array] args Arguments for the subcommand
+      # @return [Object] Depends on subcommand
+      # @example
+      #   client(:id)                  # => 12345
+      #   client(:set_name, "my_app")  # => "OK"
+      #   client(:list)                # => [{"id" => "1", ...}, ...]
+      def client(subcommand, *args)
+        send("client_#{subcommand.to_s.downcase}", *args)
+      end
+
+      # Get the current client's ID.
+      #
+      # @return [Integer] Unique client ID
+      def client_id
+        send_command(RequestType::CLIENT_ID)
+      end
+
+      # Get the current client's name.
+      #
+      # @return [String, nil] Client name or nil if not set
+      def client_get_name
+        send_command(RequestType::CLIENT_GET_NAME)
+      end
+
+      # Set the current client's name.
+      #
+      # @param [String] name New name for the client connection
+      # @return [String] `OK`
+      def client_set_name(name)
+        send_command(RequestType::CLIENT_SET_NAME, [name])
+      end
+
+      # Get a list of client connections.
+      #
+      # @param [String] type Optional filter by client type (normal, master, slave, pubsub)
+      # @param [Array<String>] ids Optional filter by client IDs
+      # @return [Array<Hash>] List of clients, each represented as a Hash of attributes
+      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|
+            entries = line.chomp.split(/[ =]/)
+            entries.each_slice(2).to_a.to_h
+          end
+        end
+      end
+
+      # Get information about the current client connection.
+      #
+      # @return [String] Client connection information
+      def client_info
+        send_command(RequestType::CLIENT_INFO)
+      end
+
+      # Kill client connections.
+      #
+      # @param [String] addr Client address (ip:port)
+      # @param [Hash] options Optional filters (id, type, user, addr, laddr, skipme)
+      # @return [Integer] Number of clients killed
+      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
+
+      # Kill a client connection by address (simple form).
+      #
+      # @param [String] addr Client address (ip:port)
+      # @return [String] `OK`
+      def client_kill_simple(addr)
+        send_command(RequestType::CLIENT_KILL_SIMPLE, [addr])
+      end
+
+      private
+
+      def build_client_kill_args(addr, options)
+        args = []
+        args << "ADDR" << addr if addr
+        options.each do |key, value|
+          case key
+          when :id then args << "ID" << value.to_s
+          when :type then args << "TYPE" << value.to_s
+          when :user then args << "USER" << value.to_s
+          when :addr then args << "ADDR" << value.to_s
+          when :laddr then args << "LADDR" << value.to_s
+          when :skipme then args << "SKIPME" << (value ? "yes" : "no")
+          end
+        end
+        args
+      end
+
+      public
+
+      # Pause client processing.
+      #
+      # @param [Integer] timeout Pause duration in milliseconds
+      # @param [String] mode Optional mode (WRITE, ALL)
+      # @return [String] `OK`
+      def client_pause(timeout, mode = nil)
+        args = [timeout]
+        args << mode if mode
+        send_command(RequestType::CLIENT_PAUSE, args)
+      end
+
+      # Unpause client processing.
+      #
+      # @return [String] `OK`
+      def client_unpause
+        send_command(RequestType::CLIENT_UNPAUSE)
+      end
+
+      # Configure client reply mode.
+      #
+      # @param [String] mode Reply mode (ON, OFF, SKIP)
+      # @return [String] `OK`
+      def client_reply(mode)
+        send_command(RequestType::CLIENT_REPLY, [mode])
+      end
+
+      # Unblock a client blocked in a blocking operation.
+      #
+      # @param [Integer] client_id ID of the client to unblock
+      # @param [String] unblock_type Optional unblock type (TIMEOUT, ERROR)
+      # @return [Integer] 1 if client was unblocked, 0 otherwise
+      def client_unblock(client_id, unblock_type = nil)
+        args = [client_id]
+        args << unblock_type if unblock_type
+        send_command(RequestType::CLIENT_UNBLOCK, args)
+      end
+
+      # Set client connection information.
+      #
+      # @param [String] attr Attribute to set (lib-name, lib-ver)
+      # @param [String] value Value to set for the attribute
+      # @return [String] `OK`
+      def client_set_info(attr, value)
+        send_command(RequestType::CLIENT_SET_INFO, [attr, value])
+      end
+
+      # Enable/disable client caching.
+      #
+      # @param [String] mode Caching mode (YES, NO)
+      # @return [String] `OK`
+      def client_caching(mode)
+        send_command(RequestType::CLIENT_CACHING, [mode])
+      end
+
+      # Configure client tracking.
+      #
+      # @param [String] status Tracking status (ON, OFF)
+      # @param [Array] args Additional positional arguments (REDIRECT, PREFIX, BCAST, OPTIN, OPTOUT, NOLOOP)
+      # @param [Hash] options Optional parameters (for keyword argument style)
+      # @return [String] `OK`
+      # @example Positional style
+      #   client_tracking("ON", "OPTIN")
+      # @example Keyword style
+      #   client_tracking("ON", optin: true, redirect: 123)
+      def client_tracking(status, *args, **options)
+        cmd_args = [status]
+        cmd_args.concat(args.any? ? args : build_client_tracking_args(options))
+        send_command(RequestType::CLIENT_TRACKING, cmd_args)
+      end
+
+      # Get client tracking information.
+      #
+      # @return [Array] Tracking information
+      def client_tracking_info
+        send_command(RequestType::CLIENT_TRACKING_INFO)
+      end
+
+      # Get the client ID used for tracking redirection.
+      #
+      # @return [Integer] Client ID for tracking redirection
+      def client_getredir
+        send_command(RequestType::CLIENT_GET_REDIR)
+      end
+
+      # Enable/disable client no-evict mode.
+      #
+      # @param [String] mode Mode (ON, OFF)
+      # @return [String] `OK`
+      def client_no_evict(mode)
+        send_command(RequestType::CLIENT_NO_EVICT, [mode.to_s.upcase])
+      end
+
+      # Enable/disable client no-touch mode.
+      #
+      # @param [String] mode Mode (ON, OFF)
+      # @return [String] `OK`
+      def client_no_touch(mode)
+        send_command(RequestType::CLIENT_NO_TOUCH, [mode.to_s.upcase])
+      end
+
+      private
+
+      def build_client_tracking_args(options)
+        args = []
+        options.each do |key, value|
+          case key
+          when :redirect
+            args << "REDIRECT" << value.to_s
+          when :prefix
+            args << "PREFIX"
+            Array(value).each { |prefix| args << prefix }
+          when :bcast
+            args << "BCAST" if value
+          when :optin
+            args << "OPTIN" if value
+          when :optout
+            args << "OPTOUT" if value
+          when :noloop
+            args << "NOLOOP" if value
+          end
+        end
+        args
+      end
+    end
+  end
+end