dalli 3.0.6 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: adcf2507fd177cbc44167154462aae102a6f34f9cd6a85ba29ea9a26e87efce6
-  data.tar.gz: 57bd7da6c8c90fbcd99c4738bdb061df3630df0ff17ead1cc510d5d58f8677e2
+  metadata.gz: 5450b3f6caa26344dbcf9718ee2e12c98d593df098d5aec6f41655783675e2b8
+  data.tar.gz: fdc8ff913351a2ed85fb34c0aa50506f5014e29c3671cbf312eaf7255b526742
 SHA512:
-  metadata.gz: cec1cceffc54713b77746ec455ddd3817b0dad37ceacb33d20f5f82a51015c7d82788ad78d043f4859d26a6c236bb57d8aac053770ea464827c5c22f07057d98
-  data.tar.gz: 70e93ae5cca84bc211315359391bad55b2f31908604ee195f42e701b472ab469074f3ee9350618491cfbf9d34b53f4e41950998e8e34cd446d8c4aca63d4b0d4
+  metadata.gz: 226719cde318de90be8fb77160b926ddbc75002ab0632494c7de0d1917bc88a8fde01b0e827765db3baa5f439c42f840a298c546d56473109e65003509d452ff
+  data.tar.gz: 6b9ca93a048ae7a5074bd128432ceb1f19497e16c773a4a246ba1da13ecb1d7e9024c41f9e112ecea2244205afded043d893c8368fcf5c137b14f134b9f1548e

data/History.md

@@ -1,6 +1,15 @@
 Dalli Changelog
 =====================
 
+3.1.0
+==========
+
+- BREAKING CHANGE: Update Rack::Session::Dalli to inherit from Abstract::PersistedSecure.  This will invalidate existing sessions (petergoldstein)
+- BREAKING CHANGE: Use of unsupported operations in a multi block now raise an error. (petergoldstein)
+- Extract PipelinedGetter from Dalli::Client (petergoldstein)
+- Fix SSL socket so that it works with pipelined gets (petergoldstein)
+- Additional refactoring to split classes (petergoldstein)
+
 3.0.6
 ==========
 

data/lib/dalli/client.rb

@@ -63,12 +63,12 @@ module Dalli
     # pipelined as Dalli will use 'quiet' operations where possible.
     # Currently supports the set, add, replace and delete operations.
     def multi
-      old = Thread.current[:dalli_multi]
-      Thread.current[:dalli_multi] = true
+      old = Thread.current[::Dalli::MULTI_KEY]
+      Thread.current[::Dalli::MULTI_KEY] = true
       yield
     ensure
-      @ring&.flush_multi_responses
-      Thread.current[:dalli_multi] = old
+      @ring&.pipeline_consume_and_ignore_responses
+      Thread.current[::Dalli::MULTI_KEY] = old
     end
 
     ##
@@ -89,10 +89,10 @@ module Dalli
       return {} if keys.empty?
 
       if block_given?
-        get_multi_yielder(keys) { |k, data| yield k, data.first }
+        pipelined_getter.process(keys) { |k, data| yield k, data.first }
       else
         {}.tap do |hash|
-          get_multi_yielder(keys) { |k, data| hash[k] = data.first }
+          pipelined_getter.process(keys) { |k, data| hash[k] = data.first }
         end
       end
     end
@@ -306,10 +306,10 @@ module Dalli
     #   { 'key' => [value, cas_id] }
     def get_multi_cas(*keys)
       if block_given?
-        get_multi_yielder(keys) { |*args| yield(*args) }
+        pipelined_getter.process(keys) { |*args| yield(*args) }
       else
         {}.tap do |hash|
-          get_multi_yielder(keys) { |k, data| hash[k] = data }
+          pipelined_getter.process(keys) { |k, data| hash[k] = data }
         end
       end
     end
@@ -341,9 +341,7 @@ module Dalli
     # Close our connection to each server.
     # If you perform another operation after this, the connections will be re-established.
     def close
-      return unless @ring
-
-      @ring.servers.each(&:close)
+      @ring&.close
       @ring = nil
     end
     alias reset close
@@ -402,145 +400,14 @@ module Dalli
     end
 
     def normalize_options(opts)
-      begin
-        opts[:expires_in] = opts[:expires_in].to_i if opts[:expires_in]
-      rescue NoMethodError
-        raise ArgumentError, "cannot convert :expires_in => #{opts[:expires_in].inspect} to an integer"
-      end
+      opts[:expires_in] = opts[:expires_in].to_i if opts[:expires_in]
       opts
+    rescue NoMethodError
+      raise ArgumentError, "cannot convert :expires_in => #{opts[:expires_in].inspect} to an integer"
     end
 
-    # TODO: Look at extracting below into separate MultiYielder class
-
-    ##
-    # Yields, one at a time, keys and their values+attributes.
-    #
-    def get_multi_yielder(keys, &block)
-      return {} if keys.empty?
-
-      ring.lock do
-        groups = groups_for_keys(keys)
-        if (unfound_keys = groups.delete(nil))
-          Dalli.logger.debug do
-            "unable to get keys for #{unfound_keys.length} keys "\
-              'because no matching server was found'
-          end
-        end
-        make_multi_get_requests(groups)
-
-        servers = groups.keys
-        return if servers.empty?
-
-        # TODO: How does this exit on a NetworkError
-        servers = perform_multi_response_start(servers)
-
-        timeout = servers.first.options[:socket_timeout]
-        start_time = Time.now
-        loop do
-          # remove any dead servers
-          # TODO: Is this well behaved in a multi-threaded environment?
-          # Accessing the server socket like this seems problematic
-          servers.delete_if { |s| s.sock.nil? }
-          break if servers.empty?
-
-          servers = multi_yielder_loop(servers, start_time, timeout, &block)
-        end
-      end
-    rescue NetworkError => e
-      Dalli.logger.debug { e.inspect }
-      Dalli.logger.debug { 'retrying multi yielder because of timeout' }
-      retry
-    end
-
-    def make_multi_get_requests(groups)
-      groups.each do |server, keys_for_server|
-        server.request(:send_multiget, keys_for_server)
-      rescue DalliError, NetworkError => e
-        Dalli.logger.debug { e.inspect }
-        Dalli.logger.debug { "unable to get keys for server #{server.name}" }
-      end
-    end
-
-    # raises Dalli::NetworkError
-    def perform_multi_response_start(servers)
-      deleted = []
-
-      servers.each do |server|
-        next unless server.alive?
-
-        begin
-          server.multi_response_start
-        rescue Dalli::NetworkError
-          abort_multi_response(servers)
-          raise
-        rescue Dalli::DalliError => e
-          Dalli.logger.debug { e.inspect }
-          Dalli.logger.debug { 'results from this server will be missing' }
-          deleted.append(server)
-        end
-      end
-
-      servers.delete_if { |server| deleted.include?(server) }
-    end
-
-    # Swallows Dalli::NetworkError
-    def abort_multi_response(servers)
-      servers.each(&:multi_response_abort)
-    end
-
-    def multi_yielder_loop(servers, start_time, timeout, &block)
-      time_left = remaining_time(start_time, timeout)
-      readable_servers = servers_with_data(servers, time_left)
-      if readable_servers.empty?
-        abort_multi_connections_w_timeout(servers)
-        return readable_servers
-      end
-
-      readable_servers.each do |server|
-        servers.delete(server) if respond_to_readable_server(server, &block)
-      end
-      servers
-    rescue NetworkError
-      abort_multi_response(servers)
-      raise
-    end
-
-    def remaining_time(start, timeout)
-      elapsed = Time.now - start
-      return 0 if elapsed > timeout
-
-      timeout - elapsed
-    end
-
-    # Swallows Dalli::NetworkError
-    def abort_multi_connections_w_timeout(servers)
-      abort_multi_response(servers)
-      servers.each do |server|
-        Dalli.logger.debug { "memcached at #{server.name} did not response within timeout" }
-      end
-
-      true # Required to simplify caller
-    end
-
-    def respond_to_readable_server(server)
-      server.multi_response_nonblock.each_pair do |key, value_list|
-        yield @key_manager.key_without_namespace(key), value_list
-      end
-
-      server.multi_response_completed?
-    end
-
-    def servers_with_data(servers, timeout)
-      readable, = IO.select(servers.map(&:sock), nil, nil, timeout)
-      return [] if readable.nil?
-
-      readable.map(&:server)
-    end
-
-    def groups_for_keys(*keys)
-      keys.flatten!
-      keys.map! { |a| @key_manager.validate_key(a.to_s) }
-      ring.keys_grouped_by_server(keys)
+    def pipelined_getter
+      PipelinedGetter.new(ring, @key_manager)
     end
   end
 end

data/lib/dalli/options.rb

@@ -31,19 +31,19 @@ module Dalli
       end
     end
 
-    def multi_response_start
+    def pipeline_response_start
       @lock.synchronize do
         super
       end
     end
 
-    def multi_response_nonblock
+    def process_outstanding_pipeline_requests
       @lock.synchronize do
         super
       end
     end
 
-    def multi_response_abort
+    def pipeline_response_abort
       @lock.synchronize do
         super
       end

data/lib/dalli/pipelined_getter.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Dalli
+  ##
+  # Contains logic for the pipelined gets implemented by the client.
+  ##
+  class PipelinedGetter
+    def initialize(ring, key_manager)
+      @ring = ring
+      @key_manager = key_manager
+    end
+
+    ##
+    # Yields, one at a time, keys and their values+attributes.
+    #
+    def process(keys, &block)
+      return {} if keys.empty?
+
+      @ring.lock do
+        servers = setup_requests(keys)
+        start_time = Time.now
+        loop do
+          # Remove any servers which are not connected
+          servers.delete_if { |s| !s.connected? }
+          break if servers.empty?
+
+          servers = fetch_responses(servers, start_time, @ring.socket_timeout, &block)
+        end
+      end
+    rescue NetworkError => e
+      Dalli.logger.debug { e.inspect }
+      Dalli.logger.debug { 'retrying pipelined gets because of timeout' }
+      retry
+    end
+
+    def setup_requests(keys)
+      groups = groups_for_keys(keys)
+      make_getkq_requests(groups)
+
+      # TODO: How does this exit on a NetworkError
+      finish_queries(groups.keys)
+    end
+
+    ##
+    # Loop through the server-grouped sets of keys, writing
+    # the corresponding getkq requests to the appropriate servers
+    ##
+    def make_getkq_requests(groups)
+      groups.each do |server, keys_for_server|
+        server.request(:pipelined_get, keys_for_server)
+      rescue DalliError, NetworkError => e
+        Dalli.logger.debug { e.inspect }
+        Dalli.logger.debug { "unable to get keys for server #{server.name}" }
+      end
+    end
+
+    ##
+    # This loops through the servers that have keys in
+    # our set, sending the noop to terminate the set of queries.
+    ##
+    def finish_queries(servers)
+      deleted = []
+
+      servers.each do |server|
+        next unless server.alive?
+
+        begin
+          finish_query_for_server(server)
+        rescue Dalli::NetworkError
+          raise
+        rescue Dalli::DalliError
+          deleted.append(server)
+        end
+      end
+
+      servers.delete_if { |server| deleted.include?(server) }
+    rescue Dalli::NetworkError
+      abort_without_timeout(servers)
+      raise
+    end
+
+    def finish_query_for_server(server)
+      server.pipeline_response_start
+    rescue Dalli::NetworkError
+      raise
+    rescue Dalli::DalliError => e
+      Dalli.logger.debug { e.inspect }
+      Dalli.logger.debug { "Results from server: #{server.name} will be missing from the results" }
+      raise
+    end
+
+    # Swallows Dalli::NetworkError
+    def abort_without_timeout(servers)
+      servers.each(&:pipeline_response_abort)
+    end
+
+    def fetch_responses(servers, start_time, timeout, &block)
+      time_left = remaining_time(start_time, timeout)
+      readable_servers = servers_with_response(servers, time_left)
+      if readable_servers.empty?
+        abort_with_timeout(servers)
+        return []
+      end
+
+      # Loop through the servers with responses, and
+      # delete any from our list that are finished
+      readable_servers.each do |server|
+        servers.delete(server) if process_server(server, &block)
+      end
+      servers
+    rescue NetworkError
+      # Abort and raise if we encountered a network error.  This triggers
+      # a retry at the top level.
+      abort_without_timeout(servers)
+      raise
+    end
+
+    def remaining_time(start, timeout)
+      elapsed = Time.now - start
+      return 0 if elapsed > timeout
+
+      timeout - elapsed
+    end
+
+    # Swallows Dalli::NetworkError
+    def abort_with_timeout(servers)
+      abort_without_timeout(servers)
+      servers.each do |server|
+        Dalli.logger.debug { "memcached at #{server.name} did not response within timeout" }
+      end
+
+      true # Required to simplify caller
+    end
+
+    # Processes responses from a server.  Returns true if there are no
+    # additional responses from this server.
+    def process_server(server)
+      server.process_outstanding_pipeline_requests.each_pair do |key, value_list|
+        yield @key_manager.key_without_namespace(key), value_list
+      end
+
+      server.pipeline_response_completed?
+    end
+
+    def servers_with_response(servers, timeout)
+      return [] if servers.empty?
+
+      # TODO: - This is a bit challenging.  Essentially the PipelinedGetter
+      # is a reactor, but without the benefit of a Fiber or separate thread.
+      # My suspicion is that we may want to try and push this down into the
+      # individual servers, but I'm not sure.  For now, we keep the
+      # mapping between the alerted object (the socket) and the
+      # corrresponding server here.
+      server_map = servers.each_with_object({}) { |s, h| h[s.sock] = s }
+
+      readable, = IO.select(server_map.keys, nil, nil, timeout)
+      return [] if readable.nil?
+
+      readable.map { |sock| server_map[sock] }
+    end
+
+    def groups_for_keys(*keys)
+      keys.flatten!
+      keys.map! { |a| @key_manager.validate_key(a.to_s) }
+      groups = @ring.keys_grouped_by_server(keys)
+      if (unfound_keys = groups.delete(nil))
+        Dalli.logger.debug do
+          "unable to get keys for #{unfound_keys.length} keys "\
+            'because no matching server was found'
+        end
+      end
+      groups
+    end
+  end
+end

data/lib/dalli/protocol/binary/response_header.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Dalli
+  module Protocol
+    class Binary
+      ##
+      # Class that encapsulates data parsed from a memcached response header.
+      ##
+      class ResponseHeader
+        SIZE = 24
+        FMT = '@2nCCnNNQ'
+
+        attr_reader :key_len, :extra_len, :data_type, :status, :body_len, :opaque, :cas
+
+        def initialize(buf)
+          raise ArgumentError, "Response buffer must be at least #{SIZE} bytes" unless buf.bytesize >= SIZE
+
+          @key_len, @extra_len, @data_type, @status, @body_len, @opaque, @cas = buf.unpack(FMT)
+        end
+
+        def ok?
+          status.zero?
+        end
+
+        def not_found?
+          status == 1
+        end
+
+        NOT_STORED_STATUSES = [2, 5].freeze
+        def not_stored?
+          NOT_STORED_STATUSES.include?(status)
+        end
+      end
+    end
+  end
+end

data/lib/dalli/protocol/binary/response_processor.rb

@@ -9,9 +9,6 @@ module Dalli
       # and parsing into local values.  Handles errors on unexpected values.
       ##
       class ResponseProcessor
-        RESP_HEADER = '@2nCCnNNQ'
-        RESP_HEADER_SIZE = 24
-
         # Response codes taken from:
         # https://github.com/memcached/memcached/wiki/BinaryProtocolRevamped#response-status
         RESPONSE_CODES = {
@@ -44,14 +41,9 @@ module Dalli
         end
 
         def read_response
-          status, extra_len, key_len, body_len, cas = unpack_header(read_header)
-          body = read(body_len) if body_len.positive?
-          [status, extra_len, body, cas, key_len]
-        end
-
-        def unpack_header(header)
-          (key_len, extra_len, _, status, body_len, _, cas) = header.unpack(RESP_HEADER)
-          [status, extra_len, key_len, body_len, cas]
+          resp_header = ResponseHeader.new(read_header)
+          body = read(resp_header.body_len) if resp_header.body_len.positive?
+          [resp_header, body]
         end
 
         def unpack_response_body(extra_len, key_len, body, unpack)
@@ -63,45 +55,36 @@ module Dalli
         end
 
         def read_header
-          read(RESP_HEADER_SIZE) || raise(Dalli::NetworkError, 'No response')
+          read(ResponseHeader::SIZE) || raise(Dalli::NetworkError, 'No response')
         end
 
-        def not_found?(status)
-          status == 1
-        end
+        def raise_on_not_ok_status!(resp_header)
+          return if resp_header.ok?
 
-        NOT_STORED_STATUSES = [2, 5].freeze
-        def not_stored?(status)
-          NOT_STORED_STATUSES.include?(status)
-        end
-
-        def raise_on_not_ok_status!(status)
-          return if status.zero?
-
-          raise Dalli::DalliError, "Response error #{status}: #{RESPONSE_CODES[status]}"
+          raise Dalli::DalliError, "Response error #{resp_header.status}: #{RESPONSE_CODES[resp_header.status]}"
         end
 
         def generic_response(unpack: false, cache_nils: false)
-          status, extra_len, body, _, key_len = read_response
+          resp_header, body = read_response
 
-          return cache_nils ? ::Dalli::NOT_FOUND : nil if not_found?(status)
-          return false if not_stored?(status) # Not stored, normal status for add operation
+          return cache_nils ? ::Dalli::NOT_FOUND : nil if resp_header.not_found?
+          return false if resp_header.not_stored? # Not stored, normal status for add operation
 
-          raise_on_not_ok_status!(status)
+          raise_on_not_ok_status!(resp_header)
           return true unless body
 
-          unpack_response_body(extra_len, key_len, body, unpack).last
+          unpack_response_body(resp_header.extra_len, resp_header.key_len, body, unpack).last
         end
 
         def data_cas_response
-          status, extra_len, body, cas, key_len = read_response
-          return [nil, cas] if not_found?(status)
-          return [nil, false] if not_stored?(status)
+          resp_header, body = read_response
+          return [nil, resp_header.cas] if resp_header.not_found?
+          return [nil, false] if resp_header.not_stored?
 
-          raise_on_not_ok_status!(status)
-          return [nil, cas] unless body
+          raise_on_not_ok_status!(resp_header)
+          return [nil, resp_header.cas] unless body
 
-          [unpack_response_body(extra_len, key_len, body, true).last, cas]
+          [unpack_response_body(resp_header.extra_len, resp_header.key_len, body, true).last, resp_header.cas]
         end
 
         def cas_response
@@ -111,17 +94,17 @@ module Dalli
         def multi_with_keys_response
           hash = {}
           loop do
-            status, extra_len, body, _, key_len = read_response
+            resp_header, body = read_response
             # This is the response to the terminating noop / end of stat
-            return hash if status.zero? && key_len.zero?
+            return hash if resp_header.ok? && resp_header.key_len.zero?
 
             # Ignore any responses with non-zero status codes,
             # such as errors from set operations.  That allows
             # this code to be used at the end of a multi
             # block to clear any error responses from inside the multi.
-            next unless status.zero?
+            next unless resp_header.ok?
 
-            key, value = unpack_response_body(extra_len, key_len, body, true)
+            key, value = unpack_response_body(resp_header.extra_len, resp_header.key_len, body, true)
             hash[key] = value
           end
         end
@@ -137,11 +120,57 @@ module Dalli
           raise Dalli::NetworkError, "Unexpected message format: #{extra_len} #{count}"
         end
 
-        def auth_response
-          (_, extra_len, _, status, body_len,) = read_header.unpack(RESP_HEADER)
-          validate_auth_format(extra_len, body_len)
+        def auth_response(buf = read_header)
+          resp_header = ResponseHeader.new(buf)
+          body_len = resp_header.body_len
+          validate_auth_format(resp_header.extra_len, body_len)
           content = read(body_len) if body_len.positive?
-          [status, content]
+          [resp_header.status, content]
+        end
+
+        def contains_header?(buf)
+          return false unless buf
+
+          buf.bytesize >= ResponseHeader::SIZE
+        end
+
+        def response_header_from_buffer(buf)
+          header = buf.slice(0, ResponseHeader::SIZE)
+          ResponseHeader.new(header)
+        end
+
+        ##
+        # This method returns an array of values used in a pipelined
+        # getk process.  The first value is the number of bytes by
+        # which to advance the pointer in the buffer.  If the
+        # complete response is found in the buffer, this will
+        # be the response size.  Otherwise it is zero.
+        #
+        # The remaining four values in the array are the status, key,
+        # value, and cas returned from the response.
+        ##
+        def getk_response_from_buffer(buf)
+          # There's no header in the buffer, so don't advance
+          return [0, 0, nil, nil, nil] unless contains_header?(buf)
+
+          resp_header = response_header_from_buffer(buf)
+          body_len = resp_header.body_len
+
+          # The response has no body - so we need to advance the
+          # buffer.  This is either the response to the terminating
+          # noop or, if the status is not zero, an intermediate
+          # error response that needs to be discarded.
+          return [ResponseHeader::SIZE, resp_header.status, nil, nil, resp_header.cas] if body_len.zero?
+
+          # The header is in the buffer, but the body is not
+          resp_size = ResponseHeader::SIZE + body_len
+          return [0, resp_header.status, nil, nil, nil] unless buf.bytesize >= resp_size
+
+          # The full response is in our buffer, so parse it and return
+          # the values
+          body = buf.slice(ResponseHeader::SIZE, body_len)
+          key, value = unpack_response_body(resp_header.extra_len, resp_header.key_len, body, true)
+          [resp_size, resp_header.status, key, value, resp_header.cas]
         end
       end
     end

data/lib/dalli/protocol/binary.rb

@@ -6,6 +6,7 @@ require 'socket'
 require 'timeout'
 
 require_relative 'binary/request_formatter'
+require_relative 'binary/response_header'
 require_relative 'binary/response_processor'
 require_relative 'binary/sasl_authentication'
 
@@ -32,9 +33,7 @@ module Dalli
         # times a socket operation may fail before considering the server dead
         socket_max_failures: 2,
         # amount of time to sleep between retries when a failure occurs
-        socket_failure_delay: 0.1,
-        username: nil,
-        password: nil
+        socket_failure_delay: 0.1
       }.freeze
 
       def initialize(attribs, options = {})
@@ -42,6 +41,7 @@ module Dalli
         @options = DEFAULTS.merge(options)
         @value_marshaller = ValueMarshaller.new(@options)
         @response_processor = ResponseProcessor.new(self, @value_marshaller)
+        @response_buffer = ResponseBuffer.new(self, @response_processor)
 
         reset_down_info
         @sock = nil
@@ -49,6 +49,10 @@ module Dalli
         @request_in_progress = false
       end
 
+      def response_buffer
+        @response_buffer ||= ResponseBuffer.new(self, @response_processor)
+      end
+
       def name
         if socket_type == :unix
           hostname
@@ -58,8 +62,8 @@ module Dalli
       end
 
       # Chokepoint method for error handling and ensuring liveness
-      def request(opcode, *args)
-        verify_state
+      def request(opkey, *args)
+        verify_state(opkey)
         # The alive? call has the side effect of connecting the underlying
         # socket if it is not connected, or there's been a disconnect
         # because of timeout or other error.  Method raises an error
@@ -67,7 +71,7 @@ module Dalli
         raise_memcached_down_err unless alive?
 
         begin
-          send(opcode, *args)
+          send(opkey, *args)
         rescue Dalli::MarshalError => e
           log_marshall_err(args.first, e)
           raise
@@ -145,80 +149,79 @@ module Dalli
       # flushing responses for kv pairs that were found.
       #
       # Returns nothing.
-      def multi_response_start
-        verify_state
+      def pipeline_response_start
+        verify_state(:getkq)
         write_noop
-        @multi_buffer = +''
-        @position = 0
+        response_buffer.reset
         start_request!
       end
 
-      # Did the last call to #multi_response_start complete successfully?
-      def multi_response_completed?
-        @multi_buffer.nil?
+      # Did the last call to #pipeline_response_start complete successfully?
+      def pipeline_response_completed?
+        response_buffer.completed?
+      end
+
+      def pipeline_response(bytes_to_advance = 0)
+        response_buffer.process_single_response(bytes_to_advance)
+      end
+
+      def reconnect_on_pipeline_complete!
+        reconnect! 'multi_response has completed' if pipeline_response_completed?
       end
 
       # Attempt to receive and parse as many key/value pairs as possible
-      # from this server. After #multi_response_start, this should be invoked
+      # from this server. After #pipeline_response_start, this should be invoked
       # repeatedly whenever this server's socket is readable until
-      # #multi_response_completed?.
+      # #pipeline_response_completed?.
       #
       # Returns a Hash of kv pairs received.
-      def multi_response_nonblock
-        reconnect! 'multi_response has completed' if @multi_buffer.nil?
-
-        @multi_buffer << @sock.read_available
-        buf = @multi_buffer
-        pos = @position
+      def process_outstanding_pipeline_requests
+        reconnect_on_pipeline_complete!
         values = {}
 
-        while buf.bytesize - pos >= ResponseProcessor::RESP_HEADER_SIZE
-          header = buf.slice(pos, ResponseProcessor::RESP_HEADER_SIZE)
-          _, extra_len, key_len, body_len, cas = @response_processor.unpack_header(header)
+        response_buffer.read
 
-          # We've reached the noop at the end of the pipeline
-          if key_len.zero?
-            finish_multi_response
+        bytes_to_advance, status, key, value, cas = pipeline_response
+        # Loop while we have at least a complete header in the buffer
+        while bytes_to_advance.positive?
+          # If the status and key length are both zero, then this is the response
+          # to the noop at the end of the pipeline
+          if status.zero? && key.nil?
+            finish_pipeline
             break
           end
 
-          # Break and read more unless we already have the entire response for this header
-          resp_size = ResponseProcessor::RESP_HEADER_SIZE + body_len
-          break unless buf.bytesize - pos >= resp_size
-
-          body = buf.slice(pos + ResponseProcessor::RESP_HEADER_SIZE, body_len)
-          begin
-            key, value = @response_processor.unpack_response_body(extra_len, key_len, body, true)
-            values[key] = [value, cas]
-          rescue DalliError
-            # TODO: Determine if we should be swallowing
-            # this error
-          end
+          # If the status is zero and the key len is positive, then this is a
+          # getkq response with a value that we want to set in the response hash
+          values[key] = [value, cas] unless key.nil?
 
-          pos = pos + ResponseProcessor::RESP_HEADER_SIZE + body_len
+          # Get the next set of bytes from the buffer
+          bytes_to_advance, status, key, value, cas = pipeline_response(bytes_to_advance)
         end
-        # TODO: We should be discarding the already processed buffer at this point
-        @position = pos
 
         values
       rescue SystemCallError, Timeout::Error, EOFError => e
         failure!(e)
       end
 
-      def finish_multi_response
-        @multi_buffer = nil
-        @position = nil
+      def read_nonblock
+        @sock.read_available
+      end
+
+      # Called after the noop response is received at the end of a set
+      # of pipelined gets
+      def finish_pipeline
+        response_buffer.clear
         finish_request!
       end
 
-      # Abort an earlier #multi_response_start. Used to signal an external
+      # Abort an earlier #pipeline_response_start. Used to signal an external
       # timeout. The underlying socket is disconnected, and the exception is
       # swallowed.
       #
       # Returns nothing.
-      def multi_response_abort
-        @multi_buffer = nil
-        @position = nil
+      def pipeline_response_abort
+        response_buffer.clear
         abort_request!
         return true unless @sock
 
@@ -245,6 +248,10 @@ module Dalli
         failure!(e)
       end
 
+      def connected?
+        !@sock.nil?
+      end
+
       def socket_timeout
         @socket_timeout ||= @options[:socket_timeout]
       end
@@ -269,15 +276,23 @@ module Dalli
         @request_in_progress = false
       end
 
-      def verify_state
+      def verify_state(opkey)
         failure!(RuntimeError.new('Already writing to socket')) if request_in_progress?
         reconnect_on_fork if fork_detected?
+        verify_allowed_multi!(opkey) if multi?
       end
 
       def fork_detected?
         @pid && @pid != Process.pid
       end
 
+      ALLOWED_MULTI_OPS = %i[add addq delete deleteq replace replaceq set setq noop].freeze
+      def verify_allowed_multi!(opkey)
+        return if ALLOWED_MULTI_OPS.include?(opkey)
+
+        raise Dalli::NotPermittedMultiOpError, "The operation #{opkey} is not allowed in a multi block."
+      end
+
       def reconnect_on_fork
         message = 'Fork detected, re-connecting child process...'
         Dalli.logger.info { message }
@@ -351,7 +366,7 @@ module Dalli
       end
 
       def multi?
-        Thread.current[:dalli_multi]
+        Thread.current[::Dalli::MULTI_KEY]
       end
 
       def cache_nils?(opts)
@@ -366,12 +381,12 @@ module Dalli
         @response_processor.generic_response(unpack: true, cache_nils: cache_nils?(options))
       end
 
-      def send_multiget(keys)
+      def pipelined_get(keys)
         req = +''
         keys.each do |key|
           req << RequestFormatter.standard_request(opkey: :getkq, key: key)
         end
-        # Could send noop here instead of in multi_response_start
+        # Could send noop here instead of in pipeline_response_start
         write(req)
       end
 
@@ -520,9 +535,9 @@ module Dalli
 
       def memcached_socket
         if socket_type == :unix
-          Dalli::Socket::UNIX.open(hostname, self, options)
+          Dalli::Socket::UNIX.open(hostname, options)
         else
-          Dalli::Socket::TCP.open(hostname, port, self, options)
+          Dalli::Socket::TCP.open(hostname, port, options)
         end
       end
 

data/lib/dalli/protocol/response_buffer.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'timeout'
+
+module Dalli
+  module Protocol
+    ##
+    # Manages the buffer for responses from memcached.
+    ##
+    class ResponseBuffer
+      def initialize(io_source, response_processor)
+        @io_source = io_source
+        @response_processor = response_processor
+      end
+
+      def read
+        @buffer << @io_source.read_nonblock
+      end
+
+      # Attempts to process a single response from the buffer.  Starts
+      # by advancing the buffer to the specified start position
+      def process_single_response(start_position = 0)
+        advance(start_position)
+        @response_processor.getk_response_from_buffer(@buffer)
+      end
+
+      # Advances the internal response buffer by bytes_to_advance
+      # bytes.  The
+      def advance(bytes_to_advance)
+        @buffer = @buffer[bytes_to_advance..-1]
+      end
+
+      # Resets the internal  buffer to an empty state,
+      # so that we're ready to read pipelined responses
+      def reset
+        @buffer = +''
+      end
+
+      # Clear the internal response buffer
+      def clear
+        @buffer = nil
+      end
+
+      def completed?
+        @buffer.nil?
+      end
+    end
+  end
+end

data/lib/dalli/ring.rb

@@ -79,7 +79,7 @@ module Dalli
       end
     end
 
-    def flush_multi_responses
+    def pipeline_consume_and_ignore_responses
       @servers.each do |s|
         s.request(:noop)
       rescue Dalli::NetworkError
@@ -92,6 +92,10 @@ module Dalli
       @servers.first.socket_timeout
     end
 
+    def close
+      @servers.each(&:close)
+    end
+
     private
 
     def threadsafe!

data/lib/dalli/socket.rb

@@ -85,13 +85,13 @@ module Dalli
     ##
     class TCP < TCPSocket
       include Dalli::Socket::InstanceMethods
-      attr_accessor :options, :server
+      # options - supports enhanced logging in the case of a timeout
+      attr_accessor :options
 
-      def self.open(host, port, server, options = {})
+      def self.open(host, port, options = {})
         Timeout.timeout(options[:socket_timeout]) do
           sock = new(host, port)
           sock.options = { host: host, port: port }.merge(options)
-          sock.server = server
           init_socket_options(sock, options)
 
           options[:ssl_context] ? wrapping_ssl_socket(sock, host, options[:ssl_context]) : sock
@@ -132,13 +132,15 @@ module Dalli
       ##
       class UNIX < UNIXSocket
         include Dalli::Socket::InstanceMethods
-        attr_accessor :options, :server
 
-        def self.open(path, server, options = {})
+        # options - supports enhanced logging in the case of a timeout
+        # server  - used to support IO.select in the pipelined getter
+        attr_accessor :options
+
+        def self.open(path, options = {})
           Timeout.timeout(options[:socket_timeout]) do
             sock = new(path)
             sock.options = { path: path }.merge(options)
-            sock.server = server
             sock
           end
         end

data/lib/dalli/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Dalli
-  VERSION = '3.0.6'
+  VERSION = '3.1.0'
 
   MIN_SUPPORTED_MEMCACHED_VERSION = '1.4'
 end

data/lib/dalli.rb

@@ -24,10 +24,15 @@ module Dalli
   # payload too big for memcached
   class ValueOverMaxSize < DalliError; end
 
+  # operation is not permitted in a multi block
+  class NotPermittedMultiOpError < DalliError; end
+
   # Implements the NullObject pattern to store an application-defined value for 'Key not found' responses.
   class NilObject; end # rubocop:disable Lint/EmptyClass
   NOT_FOUND = NilObject.new
 
+  MULTI_KEY = :dalli_multi
+
   def self.logger
     @logger ||= (rails_logger || default_logger)
   end
@@ -54,9 +59,11 @@ require_relative 'dalli/version'
 require_relative 'dalli/compressor'
 require_relative 'dalli/client'
 require_relative 'dalli/key_manager'
+require_relative 'dalli/pipelined_getter'
 require_relative 'dalli/ring'
 require_relative 'dalli/protocol'
 require_relative 'dalli/protocol/binary'
+require_relative 'dalli/protocol/response_buffer'
 require_relative 'dalli/protocol/server_config_parser'
 require_relative 'dalli/protocol/ttl_sanitizer'
 require_relative 'dalli/protocol/value_compressor'

data/lib/rack/session/dalli.rb

@@ -8,14 +8,13 @@ require 'English'
 module Rack
   module Session
     # Rack::Session::Dalli provides memcached based session management.
-    class Dalli < Abstract::Persisted
-      attr_reader :pool
+    class Dalli < Abstract::PersistedSecure
+      attr_reader :data
 
       # Don't freeze this until we fix the specs/implementation
       # rubocop:disable Style/MutableConstant
       DEFAULT_DALLI_OPTIONS = {
-        namespace: 'rack:session',
-        memcache_server: 'localhost:11211'
+        namespace: 'rack:session'
       }
       # rubocop:enable Style/MutableConstant
 
@@ -33,25 +32,14 @@ module Rack
       # ENV['MEMCACHE_SERVERS'] and use that value if it is available, or fall
       # back to the same default behavior described above.
       #
-      # Rack::Session::Dalli is intended to be a drop-in replacement for
-      # Rack::Session::Memcache. It accepts additional options that control the
-      # behavior of Rack::Session, Dalli::Client, and an optional
-      # ConnectionPool. First and foremost, if you wish to instantiate your own
-      # Dalli::Client (or ConnectionPool) and use that instead of letting
-      # Rack::Session::Dalli instantiate it on your behalf, simply pass it in
-      # as the `:cache` option. Please note that you will be responsible for
-      # setting the namespace and any other options on Dalli::Client.
+      # Rack::Session::Dalli accepts the same options as Dalli::Client, so
+      # it's worth reviewing its documentation. Perhaps most importantly,
+      # if you don't specify a `:namespace` option, Rack::Session::Dalli
+      # will default to using 'rack:session'.
       #
-      # Secondly, if you're not using the `:cache` option, Rack::Session::Dalli
-      # accepts the same options as Dalli::Client, so it's worth reviewing its
-      # documentation. Perhaps most importantly, if you don't specify a
-      # `:namespace` option, Rack::Session::Dalli will default to using
-      # "rack:session".
-      #
-      # Whether you are using the `:cache` option or not, it is not recommend
-      # to set `:expires_in`. Instead, use `:expire_after`, which will control
-      # both the expiration of the client cookie as well as the expiration of
-      # the corresponding entry in memcached.
+      # It is not recommended to set `:expires_in`. Instead, use `:expire_after`,
+      # which will control both the expiration of the client cookie as well
+      # as the expiration of the corresponding entry in memcached.
       #
       # Rack::Session::Dalli also accepts a host of options that control how
       # the sessions and session cookies are managed, including the
@@ -78,87 +66,108 @@ module Rack
         super
 
         # Determine the default TTL for newly-created sessions
-        @default_ttl = ttl @default_options[:expire_after]
-
-        # Normalize and validate passed options
-        mserv, mopts, popts = extract_dalli_options(options)
-
-        @pool = ConnectionPool.new(popts || {}) { ::Dalli::Client.new(mserv, mopts) }
+        @default_ttl = ttl(@default_options[:expire_after])
+        @data = build_data_source(options)
       end
 
-      def get_session(_env, sid)
-        with_block([nil, {}]) do |dc|
-          unless sid && !sid.empty? && (session = dc.get(sid))
-            old_sid = sid
-            sid = generate_sid_with(dc)
-            session = {}
-            unless dc.add(sid, session, @default_ttl)
-              sid = old_sid
-              redo # generate a new sid and try again
-            end
-          end
-          [sid, session]
+      def find_session(_req, sid)
+        with_dalli_client([nil, {}]) do |dc|
+          existing_session = existing_session_for_sid(dc, sid)
+          return [sid, existing_session] unless existing_session.nil?
+
+          [create_sid_with_empty_session(dc), {}]
         end
       end
 
-      def set_session(_env, session_id, new_session, options)
-        return false unless session_id
+      def write_session(_req, sid, session, options)
+        return false unless sid
 
-        with_block(false) do |dc|
-          dc.set(session_id, new_session, ttl(options[:expire_after]))
-          session_id
+        with_dalli_client(false) do |dc|
+          dc.set(memcached_key_from_sid(sid), session, ttl(options[:expire_after]))
+          sid
         end
       end
 
-      def destroy_session(_env, session_id, options)
-        with_block do |dc|
-          dc.delete(session_id)
+      def delete_session(_req, sid, options)
+        with_dalli_client do |dc|
+          dc.delete(memcached_key_from_sid(sid))
           generate_sid_with(dc) unless options[:drop]
         end
       end
 
-      def find_session(req, sid)
-        get_session req.env, sid
+      private
+
+      def memcached_key_from_sid(sid)
+        sid.private_id
       end
 
-      def write_session(req, sid, session, options)
-        set_session req.env, sid, session, options
+      def existing_session_for_sid(client, sid)
+        return nil unless sid && !sid.empty?
+
+        client.get(memcached_key_from_sid(sid))
       end
 
-      def delete_session(req, sid, options)
-        destroy_session req.env, sid, options
+      def create_sid_with_empty_session(client)
+        loop do
+          sid = generate_sid_with(client)
+
+          break sid if client.add(memcached_key_from_sid(sid), {}, @default_ttl)
+        end
       end
 
-      private
+      def generate_sid_with(client)
+        loop do
+          raw_sid = generate_sid
+          sid = raw_sid.is_a?(String) ? Rack::Session::SessionId.new(raw_sid) : raw_sid
+          break sid unless client.get(memcached_key_from_sid(sid))
+        end
+      end
+
+      def build_data_source(options)
+        server_configurations, client_options, pool_options = extract_dalli_options(options)
+
+        if pool_options.empty?
+          ::Dalli::Client.new(server_configurations, client_options)
+        else
+          ensure_connection_pool_added!
+          ConnectionPool.new(pool_options) do
+            ::Dalli::Client.new(server_configurations, client_options.merge(threadsafe: false))
+          end
+        end
+      end
 
       def extract_dalli_options(options)
         raise 'Rack::Session::Dalli no longer supports the :cache option.' if options[:cache]
 
-        # Filter out Rack::Session-specific options and apply our defaults
+        client_options = retrieve_client_options(options)
+        server_configurations = client_options.delete(:memcache_server)
+
+        [server_configurations, client_options, retrieve_pool_options(options)]
+      end
+
+      def retrieve_client_options(options)
         # Filter out Rack::Session-specific options and apply our defaults
         filtered_opts = options.reject { |k, _| DEFAULT_OPTIONS.key? k }
-        mopts = DEFAULT_DALLI_OPTIONS.merge(filtered_opts)
-        mserv = mopts.delete :memcache_server
-
-        popts = {}
-        if mopts[:pool_size] || mopts[:pool_timeout]
-          popts[:size] = mopts.delete :pool_size if mopts[:pool_size]
-          popts[:timeout] = mopts.delete :pool_timeout if mopts[:pool_timeout]
-          mopts[:threadsafe] = true
-        end
-
-        [mserv, mopts, popts]
+        DEFAULT_DALLI_OPTIONS.merge(filtered_opts)
       end
 
-      def generate_sid_with(client)
-        loop do
-          sid = generate_sid
-          break sid unless client.get(sid)
+      def retrieve_pool_options(options)
+        {}.tap do |pool_options|
+          pool_options[:size] = options.delete(:pool_size) if options[:pool_size]
+          pool_options[:timeout] = options.delete(:pool_timeout) if options[:pool_timeout]
         end
       end
 
-      def with_block(default = nil, &block)
-        @pool.with(&block)
+      def ensure_connection_pool_added!
+        require 'connection_pool'
+      rescue LoadError => e
+        warn "You don't have connection_pool installed in your application. "\
+             'Please add it to your Gemfile and run bundle install'
+        raise e
+      end
+
+      def with_dalli_client(result_on_error = nil, &block)
+        @data.with(&block)
       rescue ::Dalli::DalliError, Errno::ECONNREFUSED
         raise if /undefined class/.match?($ERROR_INFO.message)
 
@@ -166,7 +175,7 @@ module Rack
           warn "#{self} is unable to find memcached server."
           warn $ERROR_INFO.inspect
         end
-        default
+        result_on_error
       end
 
       def ttl(expire_after)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 3.0.6
+  version: 3.1.0
 platform: ruby
 authors:
 - Peter M. Goldstein
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-30 00:00:00.000000000 Z
+date: 2021-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: connection_pool
@@ -29,16 +29,22 @@ dependencies:
   name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.2.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.2.0
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -113,11 +119,14 @@ files:
 - lib/dalli/compressor.rb
 - lib/dalli/key_manager.rb
 - lib/dalli/options.rb
+- lib/dalli/pipelined_getter.rb
 - lib/dalli/protocol.rb
 - lib/dalli/protocol/binary.rb
 - lib/dalli/protocol/binary/request_formatter.rb
+- lib/dalli/protocol/binary/response_header.rb
 - lib/dalli/protocol/binary/response_processor.rb
 - lib/dalli/protocol/binary/sasl_authentication.rb
+- lib/dalli/protocol/response_buffer.rb
 - lib/dalli/protocol/server_config_parser.rb
 - lib/dalli/protocol/ttl_sanitizer.rb
 - lib/dalli/protocol/value_compressor.rb