dalli 4.3.4 → 5.0.0

data/lib/dalli/protocol/{meta/response_processor.rb → response_processor.rb}

@@ -147,6 +147,14 @@ module Dalli
           true
         end
 
+        def tokens_from_header_buffer(buf)
+          header = header_from_buffer(buf)
+          tokens = header.split
+          header_len = header.bytesize + TERMINATOR.length
+          body_len = body_len_from_tokens(tokens)
+          [tokens, header_len, body_len]
+        end
+
         def full_response_from_buffer(tokens, body, resp_size)
           value = @value_marshaller.retrieve(body, bitflags_from_tokens(tokens))
           [resp_size, tokens.first == VA, cas_from_tokens(tokens), key_from_tokens(tokens), value]
@@ -162,15 +170,11 @@ module Dalli
         # The remaining three values in the array are the ResponseHeader,
         # key, and value.
         ##
-        def getk_response_from_buffer(buf, offset = 0)
-          # Find the header terminator starting from offset
-          term_idx = buf.index(TERMINATOR, offset)
-          return [0, nil, nil, nil, nil] unless term_idx
+        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)
 
-          header = buf.byteslice(offset, term_idx - offset)
-          tokens = header.split
-          header_len = header.bytesize + TERMINATOR.length
-          body_len = body_len_from_tokens(tokens)
+          tokens, header_len, body_len = tokens_from_header_buffer(buf)
 
           # We have a complete response that has no body.
           # This is either the response to the terminating
@@ -181,14 +185,22 @@ module Dalli
           resp_size = header_len + body_len + TERMINATOR.length
           # 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 >= offset + resp_size
+          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(offset + header_len, body_len)
+          body = buf.slice(header_len, body_len)
           full_response_from_buffer(tokens, body, resp_size)
         end
 
+        def contains_header?(buf)
+          buf.include?(TERMINATOR)
+        end
+
+        def header_from_buffer(buf)
+          buf.split(TERMINATOR, 2).first
+        end
+
         def error_on_unexpected!(expected_codes)
           tokens = next_line_to_tokens
 

data/lib/dalli/protocol/server_config_parser.rb

@@ -6,7 +6,7 @@ module Dalli
   module Protocol
     ##
     # Dalli::Protocol::ServerConfigParser parses a server string passed to
-    # a Dalli::Protocol::Binary instance into the hostname, port, weight, and
+    # a Dalli::Protocol::Meta instance into the hostname, port, weight, and
     # socket_type.
     ##
     class ServerConfigParser

data/lib/dalli/ring.rb

@@ -23,9 +23,9 @@ module Dalli
 
     attr_accessor :servers, :continuum
 
-    def initialize(servers_arg, protocol_implementation, options)
+    def initialize(servers_arg, options)
       @servers = servers_arg.map do |s|
-        protocol_implementation.new(s, options)
+        Dalli::Protocol::Meta.new(s, options)
       end
       @continuum = nil
       @continuum = build_continuum(servers) if servers.size > 1

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/version.rb

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

data/lib/dalli.rb

@@ -62,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'
@@ -71,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.4
+  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
@@ -77,7 +71,7 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/petergoldstein/dalli/issues
-  changelog_uri: https://github.com/petergoldstein/dalli/blob/v4.3/CHANGELOG.md
+  changelog_uri: https://github.com/petergoldstein/dalli/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -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.21
+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,229 +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
-
-        ##
-        # 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, offset = 0)
-          # There's no header in the buffer, so don't advance
-          return [0, nil, nil, nil, nil] unless buf && buf.bytesize >= offset + ResponseHeader::SIZE
-
-          resp_header = ResponseHeader.new(buf.byteslice(offset, ResponseHeader::SIZE))
-          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 >= offset + resp_size
-
-          # The full response is in our buffer, so parse it and return
-          # the values
-          body = buf.byteslice(offset + 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