dalli 4.3.0 → 5.0.0

data/lib/dalli/servers_arg_normalizer.rb

@@ -16,7 +16,7 @@ module Dalli
   #     weight are optional (e.g. 'localhost', 'abc.com:12345', 'example.org:22222:3')
   #   * A colon separated string of (UNIX socket, weight) where the weight is optional
   #     (e.g. '/var/run/memcached/socket', '/tmp/xyz:3') (not supported on Windows)
-  #   * A URI with a 'memcached' protocol, which will typically include a username/password
+  #   * A URI with a 'memcached' protocol (e.g. 'memcached://localhost:11211')
   #
   # The methods in this module do not validate the format of individual server strings, but
   # rather normalize the argument into a compact array, wherein each array entry corresponds

data/lib/dalli/socket.rb

@@ -90,6 +90,12 @@ module Dalli
       # options - supports enhanced logging in the case of a timeout
       attr_accessor :options
 
+      # Expected parameter signature for unmodified TCPSocket#initialize.
+      # Used to detect when gems like socksify or resolv-replace have monkey-patched
+      # TCPSocket, which breaks the connect_timeout: keyword argument.
+      TCPSOCKET_NATIVE_PARAMETERS = [[:rest]].freeze
+      private_constant :TCPSOCKET_NATIVE_PARAMETERS
+
       def self.open(host, port, options = {})
         create_socket_with_timeout(host, port, options) do |sock|
           sock.options = { host: host, port: port }.merge(options)
@@ -99,15 +105,18 @@ module Dalli
         end
       end
 
+      # Detect and cache whether TCPSocket supports the connect_timeout: keyword argument.
+      # Returns false if TCPSocket#initialize has been monkey-patched by gems like
+      # socksify or resolv-replace, which don't support keyword arguments.
+      def self.supports_connect_timeout?
+        return @supports_connect_timeout if defined?(@supports_connect_timeout)
+
+        @supports_connect_timeout = RUBY_VERSION >= '3.0' &&
+                                    ::TCPSocket.instance_method(:initialize).parameters == TCPSOCKET_NATIVE_PARAMETERS
+      end
+
       def self.create_socket_with_timeout(host, port, options)
-        # Check that TCPSocket#initialize was not overwritten by resolv-replace gem
-        # (part of ruby standard library since 3.0.0, should be removed in 3.4.0),
-        # as it does not handle keyword arguments correctly.
-        # To check this we are using the fact that resolv-replace
-        # aliases TCPSocket#initialize method to #original_resolv_initialize.
-        # https://github.com/ruby/resolv-replace/blob/v0.1.1/lib/resolv-replace.rb#L21
-        if RUBY_VERSION >= '3.0' &&
-           !::TCPSocket.private_method_defined?(:original_resolv_initialize)
+        if supports_connect_timeout?
           sock = new(host, port, connect_timeout: options[:socket_timeout])
           yield(sock)
         else

data/lib/dalli/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Dalli
-  VERSION = '4.3.0'
+  VERSION = '5.0.0'
 
-  MIN_SUPPORTED_MEMCACHED_VERSION = '1.4'
+  MIN_SUPPORTED_MEMCACHED_VERSION = '1.6'
 end

data/lib/dalli.rb

@@ -28,6 +28,9 @@ module Dalli
   # raised when Memcached response with a SERVER_ERROR
   class ServerError < DalliError; end
 
+  # socket/server communication error that can be retried
+  class RetryableNetworkError < NetworkError; 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
@@ -59,7 +62,6 @@ require_relative 'dalli/version'
 require_relative 'dalli/instrumentation'
 
 require_relative 'dalli/compressor'
-require_relative 'dalli/protocol_deprecations'
 require_relative 'dalli/client'
 require_relative 'dalli/key_manager'
 require_relative 'dalli/pipelined_getter'
@@ -68,7 +70,6 @@ require_relative 'dalli/pipelined_deleter'
 require_relative 'dalli/ring'
 require_relative 'dalli/protocol'
 require_relative 'dalli/protocol/base'
-require_relative 'dalli/protocol/binary'
 require_relative 'dalli/protocol/connection_manager'
 require_relative 'dalli/protocol/meta'
 require_relative 'dalli/protocol/response_buffer'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 4.3.0
+  version: 5.0.0
 platform: ruby
 authors:
 - Peter M. Goldstein
@@ -49,24 +49,18 @@ files:
 - lib/dalli/pipelined_setter.rb
 - lib/dalli/protocol.rb
 - lib/dalli/protocol/base.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/connection_manager.rb
+- lib/dalli/protocol/key_regularizer.rb
 - lib/dalli/protocol/meta.rb
-- lib/dalli/protocol/meta/key_regularizer.rb
-- lib/dalli/protocol/meta/request_formatter.rb
-- lib/dalli/protocol/meta/response_processor.rb
+- lib/dalli/protocol/request_formatter.rb
 - lib/dalli/protocol/response_buffer.rb
+- lib/dalli/protocol/response_processor.rb
 - lib/dalli/protocol/server_config_parser.rb
 - lib/dalli/protocol/string_marshaller.rb
 - lib/dalli/protocol/ttl_sanitizer.rb
 - lib/dalli/protocol/value_compressor.rb
 - lib/dalli/protocol/value_marshaller.rb
 - lib/dalli/protocol/value_serializer.rb
-- lib/dalli/protocol_deprecations.rb
 - lib/dalli/ring.rb
 - lib/dalli/servers_arg_normalizer.rb
 - lib/dalli/socket.rb
@@ -86,14 +80,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.1'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.4
+rubygems_version: 4.0.6
 specification_version: 4
 summary: High performance memcached client for Ruby
 test_files: []

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

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-module Dalli
-  module Protocol
-    class Binary
-      ##
-      # Class that encapsulates logic for formatting binary protocol requests
-      # to memcached.
-      ##
-      class RequestFormatter
-        REQUEST = 0x80
-
-        OPCODES = {
-          get: 0x00,
-          set: 0x01,
-          add: 0x02,
-          replace: 0x03,
-          delete: 0x04,
-          incr: 0x05,
-          decr: 0x06,
-          flush: 0x08,
-          noop: 0x0A,
-          version: 0x0B,
-          getkq: 0x0D,
-          append: 0x0E,
-          prepend: 0x0F,
-          stat: 0x10,
-          setq: 0x11,
-          addq: 0x12,
-          replaceq: 0x13,
-          deleteq: 0x14,
-          incrq: 0x15,
-          decrq: 0x16,
-          flushq: 0x18,
-          appendq: 0x19,
-          prependq: 0x1A,
-          touch: 0x1C,
-          gat: 0x1D,
-          auth_negotiation: 0x20,
-          auth_request: 0x21,
-          auth_continue: 0x22
-        }.freeze
-
-        REQ_HEADER_FORMAT = 'CCnCCnNNQ'
-
-        KEY_ONLY = 'a*'
-        TTL_AND_KEY = 'Na*'
-        KEY_AND_VALUE = 'a*a*'
-        INCR_DECR = 'NNNNNa*'
-        TTL_ONLY = 'N'
-        NO_BODY = ''
-
-        BODY_FORMATS = {
-          get: KEY_ONLY,
-          getkq: KEY_ONLY,
-          delete: KEY_ONLY,
-          deleteq: KEY_ONLY,
-          stat: KEY_ONLY,
-
-          append: KEY_AND_VALUE,
-          prepend: KEY_AND_VALUE,
-          appendq: KEY_AND_VALUE,
-          prependq: KEY_AND_VALUE,
-          auth_request: KEY_AND_VALUE,
-          auth_continue: KEY_AND_VALUE,
-
-          set: 'NNa*a*',
-          setq: 'NNa*a*',
-          add: 'NNa*a*',
-          addq: 'NNa*a*',
-          replace: 'NNa*a*',
-          replaceq: 'NNa*a*',
-
-          incr: INCR_DECR,
-          decr: INCR_DECR,
-          incrq: INCR_DECR,
-          decrq: INCR_DECR,
-
-          flush: TTL_ONLY,
-          flushq: TTL_ONLY,
-
-          noop: NO_BODY,
-          auth_negotiation: NO_BODY,
-          version: NO_BODY,
-
-          touch: TTL_AND_KEY,
-          gat: TTL_AND_KEY
-        }.freeze
-        FORMAT = BODY_FORMATS.transform_values { |v| REQ_HEADER_FORMAT + v }
-
-        # rubocop:disable Metrics/ParameterLists
-        def self.standard_request(opkey:, key: nil, value: nil, opaque: 0, cas: 0, bitflags: nil, ttl: nil)
-          extra_len = (bitflags.nil? ? 0 : 4) + (ttl.nil? ? 0 : 4)
-          key_len = key.nil? ? 0 : key.bytesize
-          value_len = value.nil? ? 0 : value.bytesize
-          header = [REQUEST, OPCODES[opkey], key_len, extra_len, 0, 0, extra_len + key_len + value_len, opaque, cas]
-          body = [bitflags, ttl, key, value].compact
-          (header + body).pack(FORMAT[opkey])
-        end
-        # rubocop:enable Metrics/ParameterLists
-
-        def self.decr_incr_request(opkey:, key: nil, count: nil, initial: nil, expiry: nil)
-          extra_len = 20
-          (h, l) = as_8byte_uint(count)
-          (dh, dl) = as_8byte_uint(initial)
-          header = [REQUEST, OPCODES[opkey], key.bytesize, extra_len, 0, 0, key.bytesize + extra_len, 0, 0]
-          body = [h, l, dh, dl, expiry, key]
-          (header + body).pack(FORMAT[opkey])
-        end
-
-        def self.as_8byte_uint(val)
-          [val >> 32, val & 0xFFFFFFFF]
-        end
-      end
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-# 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

@@ -1,239 +0,0 @@
-# frozen_string_literal: true
-
-module Dalli
-  module Protocol
-    class Binary
-      ##
-      # Class that encapsulates logic for processing binary protocol responses
-      # from memcached.  Includes logic for pulling data from an IO source
-      # and parsing into local values.  Handles errors on unexpected values.
-      ##
-      class ResponseProcessor
-        # Response codes taken from:
-        # https://github.com/memcached/memcached/wiki/BinaryProtocolRevamped#response-status
-        RESPONSE_CODES = {
-          0 => 'No error',
-          1 => 'Key not found',
-          2 => 'Key exists',
-          3 => 'Value too large',
-          4 => 'Invalid arguments',
-          5 => 'Item not stored',
-          6 => 'Incr/decr on a non-numeric value',
-          7 => 'The vbucket belongs to another server',
-          8 => 'Authentication error',
-          9 => 'Authentication continue',
-          0x20 => 'Authentication required',
-          0x81 => 'Unknown command',
-          0x82 => 'Out of memory',
-          0x83 => 'Not supported',
-          0x84 => 'Internal error',
-          0x85 => 'Busy',
-          0x86 => 'Temporary failure'
-        }.freeze
-
-        def initialize(io_source, value_marshaller)
-          @io_source = io_source
-          @value_marshaller = value_marshaller
-        end
-
-        def read(num_bytes)
-          @io_source.read(num_bytes)
-        end
-
-        def read_response
-          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(resp_header, body, parse_as_stored_value)
-          extra_len = resp_header.extra_len
-          key_len = resp_header.key_len
-          bitflags = extra_len.positive? ? body.unpack1('N') : 0x0
-          key = body.byteslice(extra_len, key_len).force_encoding(Encoding::UTF_8) if key_len.positive?
-          value = body.byteslice((extra_len + key_len)..-1)
-          value = @value_marshaller.retrieve(value, bitflags) if parse_as_stored_value
-          [key, value]
-        end
-
-        def read_header
-          read(ResponseHeader::SIZE) || raise(Dalli::NetworkError, 'No response')
-        end
-
-        def raise_on_not_ok!(resp_header)
-          return if resp_header.ok?
-
-          raise Dalli::DalliError, "Response error #{resp_header.status}: #{RESPONSE_CODES[resp_header.status]}"
-        end
-
-        def get(cache_nils: false)
-          resp_header, body = read_response
-
-          return false if resp_header.not_stored? # Not stored, normal status for add operation
-          return cache_nils ? ::Dalli::NOT_FOUND : nil if resp_header.not_found?
-
-          raise_on_not_ok!(resp_header)
-          return true unless body
-
-          unpack_response_body(resp_header, body, true).last
-        end
-
-        ##
-        # Response for a storage operation.  Returns the cas on success.  False
-        # if the value wasn't stored.  And raises an error on all other error
-        # codes from memcached.
-        ##
-        def storage_response
-          resp_header, = read_response
-          return nil if resp_header.not_found?
-          return false if resp_header.not_stored? # Not stored, normal status for add operation
-
-          raise_on_not_ok!(resp_header)
-          resp_header.cas
-        end
-
-        def delete
-          resp_header, = read_response
-          return false if resp_header.not_found? || resp_header.not_stored?
-
-          raise_on_not_ok!(resp_header)
-          true
-        end
-
-        def data_cas_response
-          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!(resp_header)
-          return [nil, resp_header.cas] unless body
-
-          [unpack_response_body(resp_header, body, true).last, resp_header.cas]
-        end
-
-        # Returns the new value for the key, if found and updated
-        def decr_incr
-          body = generic_response
-          body ? body.unpack1('Q>') : body
-        end
-
-        def stats
-          hash = {}
-          loop do
-            resp_header, body = read_response
-            # This is the response to the terminating noop / end of stat
-            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 resp_header.ok?
-
-            key, value = unpack_response_body(resp_header, body, true)
-            hash[key] = value
-          end
-        end
-
-        def flush
-          no_body_response
-        end
-
-        def reset
-          generic_response
-        end
-
-        def version
-          generic_response
-        end
-
-        def consume_all_responses_until_noop
-          loop do
-            resp_header, = read_response
-            # This is the response to the terminating noop / end of stat
-            return true if resp_header.ok? && resp_header.key_len.zero?
-          end
-        end
-
-        def generic_response
-          resp_header, body = read_response
-
-          return false if resp_header.not_stored? # Not stored, normal status for add operation
-          return nil if resp_header.not_found?
-
-          raise_on_not_ok!(resp_header)
-          return true unless body
-
-          unpack_response_body(resp_header, body, false).last
-        end
-
-        def no_body_response
-          resp_header, = read_response
-          return false if resp_header.not_stored? # Not stored, possible status for append/prepend/delete
-
-          raise_on_not_ok!(resp_header)
-          true
-        end
-
-        def validate_auth_format(extra_len, count)
-          return if extra_len.zero?
-
-          raise Dalli::NetworkError, "Unexpected message format: #{extra_len} #{count}"
-        end
-
-        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?
-          [resp_header.status, content]
-        end
-
-        def contains_header?(buf)
-          return false unless buf
-
-          buf.bytesize >= ResponseHeader::SIZE
-        end
-
-        def response_header_from_buffer(buf)
-          ResponseHeader.new(buf)
-        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 three values in the array are the ResponseHeader,
-        # key, and value.
-        ##
-        def getk_response_from_buffer(buf)
-          # There's no header in the buffer, so don't advance
-          return [0, nil, nil, nil, nil] unless contains_header?(buf)
-
-          resp_header = response_header_from_buffer(buf)
-          body_len = resp_header.body_len
-
-          # We have a complete response that has no body.
-          # 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.ok?, resp_header.cas, nil, nil] if body_len.zero?
-
-          resp_size = ResponseHeader::SIZE + body_len
-          # The header is in the buffer, but the body is not.  As we don't have
-          # a complete response, don't advance the buffer
-          return [0, nil, nil, nil, nil] unless buf.bytesize >= resp_size
-
-          # The full response is in our buffer, so parse it and return
-          # the values
-          body = buf.byteslice(ResponseHeader::SIZE, body_len)
-          key, value = unpack_response_body(resp_header, body, true)
-          [resp_size, resp_header.ok?, resp_header.cas, key, value]
-        end
-      end
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-module Dalli
-  module Protocol
-    class Binary
-      ##
-      # Code to support SASL authentication
-      ##
-      module SaslAuthentication
-        def perform_auth_negotiation
-          write(RequestFormatter.standard_request(opkey: :auth_negotiation))
-
-          status, content = response_processor.auth_response
-          return [status, []] if content.nil?
-
-          # Substitute spaces for the \x00 returned by
-          # memcached as a separator for easier
-          content&.tr!("\u0000", ' ')
-          mechanisms = content&.split
-          [status, mechanisms]
-        end
-
-        PLAIN_AUTH = 'PLAIN'
-
-        def supported_mechanisms!(mechanisms)
-          unless mechanisms.include?(PLAIN_AUTH)
-            raise NotImplementedError,
-                  'Dalli only supports the PLAIN authentication mechanism'
-          end
-          [PLAIN_AUTH]
-        end
-
-        def authenticate_with_plain
-          write(RequestFormatter.standard_request(opkey: :auth_request,
-                                                  key: PLAIN_AUTH,
-                                                  value: "\x0#{username}\x0#{password}"))
-          @response_processor.auth_response
-        end
-
-        def authenticate_connection
-          Dalli.logger.info { "Dalli/SASL authenticating as #{username}" }
-
-          status, mechanisms = perform_auth_negotiation
-          return Dalli.logger.debug('Authentication not required/supported by server') if status == 0x81
-
-          supported_mechanisms!(mechanisms)
-          status, content = authenticate_with_plain
-
-          return Dalli.logger.info("Dalli/SASL: #{content}") if status.zero?
-
-          raise Dalli::DalliError, "Error authenticating: 0x#{status.to_s(16)}" unless status == 0x21
-
-          raise NotImplementedError, 'No two-step authentication mechanisms supported'
-          # (step, msg) = sasl.receive('challenge', content)
-          # raise Dalli::NetworkError, "Authentication failed" if sasl.failed? || step != 'response'
-        end
-      end
-    end
-  end
-end