redis 4.4.0 → 4.8.1

data/lib/redis/commands/transactions.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+class Redis
+  module Commands
+    module Transactions
+      # Mark the start of a transaction block.
+      #
+      # Passing a block is optional.
+      #
+      # @example With a block
+      #   redis.multi do |multi|
+      #     multi.set("key", "value")
+      #     multi.incr("counter")
+      #   end # => ["OK", 6]
+      #
+      # @example Without a block
+      #   redis.multi
+      #     # => "OK"
+      #   redis.set("key", "value")
+      #     # => "QUEUED"
+      #   redis.incr("counter")
+      #     # => "QUEUED"
+      #   redis.exec
+      #     # => ["OK", 6]
+      #
+      # @yield [multi] the commands that are called inside this block are cached
+      #   and written to the server upon returning from it
+      # @yieldparam [Redis] multi `self`
+      #
+      # @return [String, Array<...>]
+      #   - when a block is not given, `OK`
+      #   - when a block is given, an array with replies
+      #
+      # @see #watch
+      # @see #unwatch
+      def multi(&block) # :nodoc:
+        if block_given?
+          if block&.arity == 0
+            Pipeline.deprecation_warning("multi", Kernel.caller_locations(1, 5))
+          end
+
+          synchronize do |prior_client|
+            pipeline = Pipeline::Multi.new(prior_client)
+            pipelined_connection = PipelinedConnection.new(pipeline)
+            yield pipelined_connection
+            prior_client.call_pipeline(pipeline)
+          end
+        else
+          send_command([:multi])
+        end
+      end
+
+      # Watch the given keys to determine execution of the MULTI/EXEC block.
+      #
+      # Using a block is optional, but is necessary for thread-safety.
+      #
+      # An `#unwatch` is automatically issued if an exception is raised within the
+      # block that is a subclass of StandardError and is not a ConnectionError.
+      #
+      # @example With a block
+      #   redis.watch("key") do
+      #     if redis.get("key") == "some value"
+      #       redis.multi do |multi|
+      #         multi.set("key", "other value")
+      #         multi.incr("counter")
+      #       end
+      #     else
+      #       redis.unwatch
+      #     end
+      #   end
+      #     # => ["OK", 6]
+      #
+      # @example Without a block
+      #   redis.watch("key")
+      #     # => "OK"
+      #
+      # @param [String, Array<String>] keys one or more keys to watch
+      # @return [Object] if using a block, returns the return value of the block
+      # @return [String] if not using a block, returns `OK`
+      #
+      # @see #unwatch
+      # @see #multi
+      def watch(*keys)
+        synchronize do |client|
+          res = client.call([:watch, *keys])
+
+          if block_given?
+            begin
+              yield(self)
+            rescue ConnectionError
+              raise
+            rescue StandardError
+              unwatch
+              raise
+            end
+          else
+            res
+          end
+        end
+      end
+
+      # Forget about all watched keys.
+      #
+      # @return [String] `OK`
+      #
+      # @see #watch
+      # @see #multi
+      def unwatch
+        send_command([:unwatch])
+      end
+
+      # Execute all commands issued after MULTI.
+      #
+      # Only call this method when `#multi` was called **without** a block.
+      #
+      # @return [nil, Array<...>]
+      #   - when commands were not executed, `nil`
+      #   - when commands were executed, an array with their replies
+      #
+      # @see #multi
+      # @see #discard
+      def exec
+        send_command([:exec])
+      end
+
+      # Discard all commands issued after MULTI.
+      #
+      # Only call this method when `#multi` was called **without** a block.
+      #
+      # @return [String] `"OK"`
+      #
+      # @see #multi
+      # @see #exec
+      def discard
+        send_command([:discard])
+      end
+    end
+  end
+end

data/lib/redis/commands.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require "redis/commands/bitmaps"
+require "redis/commands/cluster"
+require "redis/commands/connection"
+require "redis/commands/geo"
+require "redis/commands/hashes"
+require "redis/commands/hyper_log_log"
+require "redis/commands/keys"
+require "redis/commands/lists"
+require "redis/commands/pubsub"
+require "redis/commands/scripting"
+require "redis/commands/server"
+require "redis/commands/sets"
+require "redis/commands/sorted_sets"
+require "redis/commands/streams"
+require "redis/commands/strings"
+require "redis/commands/transactions"
+
+class Redis
+  module Commands
+    include Bitmaps
+    include Cluster
+    include Connection
+    include Geo
+    include Hashes
+    include HyperLogLog
+    include Keys
+    include Lists
+    include Pubsub
+    include Scripting
+    include Server
+    include Sets
+    include SortedSets
+    include Streams
+    include Strings
+    include Transactions
+
+    # Commands returning 1 for true and 0 for false may be executed in a pipeline
+    # where the method call will return nil. Propagate the nil instead of falsely
+    # returning false.
+    Boolify = lambda { |value|
+      case value
+      when Integer
+        value > 0
+      else
+        value
+      end
+    }
+
+    BoolifySet = lambda { |value|
+      case value
+      when "OK"
+        true
+      when nil
+        false
+      else
+        value
+      end
+    }
+
+    Hashify = lambda { |value|
+      if value.respond_to?(:each_slice)
+        value.each_slice(2).to_h
+      else
+        value
+      end
+    }
+
+    Pairify = lambda { |value|
+      if value.respond_to?(:each_slice)
+        value.each_slice(2).to_a
+      else
+        value
+      end
+    }
+
+    Floatify = lambda { |value|
+      case value
+      when "inf"
+        Float::INFINITY
+      when "-inf"
+        -Float::INFINITY
+      when String
+        Float(value)
+      else
+        value
+      end
+    }
+
+    FloatifyPairs = lambda { |value|
+      return value unless value.respond_to?(:each_slice)
+
+      value.each_slice(2).map do |member, score|
+        [member, Floatify.call(score)]
+      end
+    }
+
+    HashifyInfo = lambda { |reply|
+      lines = reply.split("\r\n").grep_v(/^(#|$)/)
+      lines.map! { |line| line.split(':', 2) }
+      lines.compact!
+      lines.to_h
+    }
+
+    HashifyStreams = lambda { |reply|
+      case reply
+      when nil
+        {}
+      else
+        reply.map { |key, entries| [key, HashifyStreamEntries.call(entries)] }.to_h
+      end
+    }
+
+    EMPTY_STREAM_RESPONSE = [nil].freeze
+    private_constant :EMPTY_STREAM_RESPONSE
+
+    HashifyStreamEntries = lambda { |reply|
+      reply.compact.map do |entry_id, values|
+        [entry_id, values&.each_slice(2)&.to_h]
+      end
+    }
+
+    HashifyStreamAutoclaim = lambda { |reply|
+      {
+        'next' => reply[0],
+        'entries' => reply[1].map { |entry| [entry[0], entry[1].each_slice(2).to_h] }
+      }
+    }
+
+    HashifyStreamAutoclaimJustId = lambda { |reply|
+      {
+        'next' => reply[0],
+        'entries' => reply[1]
+      }
+    }
+
+    HashifyStreamPendings = lambda { |reply|
+      {
+        'size' => reply[0],
+        'min_entry_id' => reply[1],
+        'max_entry_id' => reply[2],
+        'consumers' => reply[3].nil? ? {} : reply[3].to_h
+      }
+    }
+
+    HashifyStreamPendingDetails = lambda { |reply|
+      reply.map do |arr|
+        {
+          'entry_id' => arr[0],
+          'consumer' => arr[1],
+          'elapsed' => arr[2],
+          'count' => arr[3]
+        }
+      end
+    }
+
+    HashifyClusterNodeInfo = lambda { |str|
+      arr = str.split(' ')
+      {
+        'node_id' => arr[0],
+        'ip_port' => arr[1],
+        'flags' => arr[2].split(','),
+        'master_node_id' => arr[3],
+        'ping_sent' => arr[4],
+        'pong_recv' => arr[5],
+        'config_epoch' => arr[6],
+        'link_state' => arr[7],
+        'slots' => arr[8].nil? ? nil : Range.new(*arr[8].split('-'))
+      }
+    }
+
+    HashifyClusterSlots = lambda { |reply|
+      reply.map do |arr|
+        first_slot, last_slot = arr[0..1]
+        master = { 'ip' => arr[2][0], 'port' => arr[2][1], 'node_id' => arr[2][2] }
+        replicas = arr[3..-1].map { |r| { 'ip' => r[0], 'port' => r[1], 'node_id' => r[2] } }
+        {
+          'start_slot' => first_slot,
+          'end_slot' => last_slot,
+          'master' => master,
+          'replicas' => replicas
+        }
+      end
+    }
+
+    HashifyClusterNodes = lambda { |reply|
+      reply.split(/[\r\n]+/).map { |str| HashifyClusterNodeInfo.call(str) }
+    }
+
+    HashifyClusterSlaves = lambda { |reply|
+      reply.map { |str| HashifyClusterNodeInfo.call(str) }
+    }
+
+    Noop = ->(reply) { reply }
+
+    # Sends a command to Redis and returns its reply.
+    #
+    # Replies are converted to Ruby objects according to the RESP protocol, so
+    # you can expect a Ruby array, integer or nil when Redis sends one. Higher
+    # level transformations, such as converting an array of pairs into a Ruby
+    # hash, are up to consumers.
+    #
+    # Redis error replies are raised as Ruby exceptions.
+    def call(*command)
+      send_command(command)
+    end
+
+    # Interact with the sentinel command (masters, master, slaves, failover)
+    #
+    # @param [String] subcommand e.g. `masters`, `master`, `slaves`
+    # @param [Array<String>] args depends on subcommand
+    # @return [Array<String>, Hash<String, String>, String] depends on subcommand
+    def sentinel(subcommand, *args)
+      subcommand = subcommand.to_s.downcase
+      send_command([:sentinel, subcommand] + args) do |reply|
+        case subcommand
+        when "get-master-addr-by-name"
+          reply
+        else
+          if reply.is_a?(Array)
+            if reply[0].is_a?(Array)
+              reply.map(&Hashify)
+            else
+              Hashify.call(reply)
+            end
+          else
+            reply
+          end
+        end
+      end
+    end
+
+    private
+
+    def method_missing(*command) # rubocop:disable Style/MissingRespondToMissing
+      send_command(command)
+    end
+  end
+end

data/lib/redis/connection/command_helper.rb

@@ -12,11 +12,13 @@ class Redis
           if i.is_a? Array
             i.each do |j|
               j = j.to_s
+              j = j.encoding == Encoding::BINARY ? j : j.b
               command << "$#{j.bytesize}"
               command << j
             end
           else
             i = i.to_s
+            i = i.encoding == Encoding::BINARY ? i : i.b
             command << "$#{i.bytesize}"
             command << i
           end

data/lib/redis/connection/hiredis.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require_relative "registry"
-require_relative "../errors"
+require "redis/connection/registry"
+require "redis/errors"
+
 require "hiredis/connection"
 require "timeout"
 

data/lib/redis/connection/ruby.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
-require_relative "registry"
-require_relative "command_helper"
-require_relative "../errors"
+require "redis/connection/registry"
+require "redis/connection/command_helper"
+require "redis/errors"
+
 require "socket"
 require "timeout"
 
@@ -21,7 +22,7 @@ class Redis
         super(*args)
 
         @timeout = @write_timeout = nil
-        @buffer = "".dup
+        @buffer = "".b
       end
 
       def timeout=(timeout)
@@ -35,7 +36,8 @@ class Redis
       def read(nbytes)
         result = @buffer.slice!(0, nbytes)
 
-        result << _read_from_socket(nbytes - result.bytesize) while result.bytesize < nbytes
+        buffer = String.new(capacity: nbytes, encoding: Encoding::ASCII_8BIT)
+        result << _read_from_socket(nbytes - result.bytesize, buffer) while result.bytesize < nbytes
 
         result
       end
@@ -48,9 +50,9 @@ class Redis
         @buffer.slice!(0, crlf + CRLF.bytesize)
       end
 
-      def _read_from_socket(nbytes)
+      def _read_from_socket(nbytes, buffer = nil)
         loop do
-          case chunk = read_nonblock(nbytes, exception: false)
+          case chunk = read_nonblock(nbytes, buffer, exception: false)
           when :wait_readable
             unless wait_readable(@timeout)
               raise Redis::TimeoutError
@@ -132,7 +134,9 @@ class Redis
           # says it is readable (1.6.6, in both 1.8 and 1.9 mode).
           # Use the blocking #readpartial method instead.
 
-          def _read_from_socket(nbytes)
+          def _read_from_socket(nbytes, _buffer = nil)
+            # JRuby: Throw away the buffer as we won't need it
+            # but still need to support the max arity of 2
             readpartial(nbytes)
           rescue EOFError
             raise Errno::ECONNRESET
@@ -239,7 +243,7 @@ class Redis
         end
 
         def self.connect(host, port, timeout, ssl_params)
-          # Note: this is using Redis::Connection::TCPSocket
+          # NOTE: this is using Redis::Connection::TCPSocket
           tcp_sock = TCPSocket.connect(host, port, timeout)
 
           ctx = OpenSSL::SSL::SSLContext.new
@@ -380,6 +384,12 @@ class Redis
         format_reply(reply_type, line)
       rescue Errno::EAGAIN
         raise TimeoutError
+      rescue OpenSSL::SSL::SSLError => ssl_error
+        if ssl_error.message.match?(/SSL_read: unexpected eof while reading/i)
+          raise EOFError, ssl_error.message
+        else
+          raise
+        end
       end
 
       def format_reply(reply_type, line)

data/lib/redis/connection/synchrony.rb

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
-require_relative "command_helper"
-require_relative "registry"
-require_relative "../errors"
+require "redis/connection/registry"
+require "redis/connection/command_helper"
+require "redis/errors"
+
 require "em-synchrony"
 require "hiredis/reader"
 
-Kernel.warn(
-  "The redis synchrony driver is deprecated and will be removed in redis-rb 5.0. " \
+::Redis.deprecate!(
+  "The redis synchrony driver is deprecated and will be removed in redis-rb 5.0.0. " \
   "We're looking for people to maintain it as a separate gem, see https://github.com/redis/redis-rb/issues/915"
 )
 
@@ -129,11 +130,12 @@ class Redis
       def read
         type, payload = @connection.read
 
-        if type == :reply
+        case type
+        when :reply
           payload
-        elsif type == :error
+        when :error
           raise payload
-        elsif type == :timeout
+        when :timeout
           raise TimeoutError
         else
           raise "Unknown type #{type.inspect}"

data/lib/redis/connection.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "connection/registry"
+require "redis/connection/registry"
 
 # If a connection driver was required before this file, the array
 # Redis::Connection.drivers will contain one or more classes. The last driver