dalli 4.3.10 → 5.0.0

data/lib/dalli/socket.rb

@@ -181,41 +181,12 @@ module Dalli
         [seconds, microseconds].pack(timeval_pack_format(sock))
       end
 
-      # Closes the TCP socket if the handshake fails or times out, so a failed
-      # attempt doesn't hold a file descriptor until GC.
       def self.wrapping_ssl_socket(tcp_socket, host, ssl_context)
-        warn_if_unverified(ssl_context)
-        connected = false
         ssl_socket = Dalli::Socket::SSLSocket.new(tcp_socket, ssl_context)
         ssl_socket.hostname = host
         ssl_socket.sync_close = true
         ssl_socket.connect
-        connected = true
         ssl_socket
-      ensure
-        tcp_socket.close unless connected
-      end
-
-      # Class variable to track whether the TLS verification warning has been logged
-      @@ssl_verification_warning_logged = false # rubocop:disable Style/ClassVars
-
-      # Verification comes entirely from the caller's ssl_context, and a bare
-      # SSLContext.new verifies nothing, so warn (once per process) when the
-      # certificate or the hostname won't be checked.
-      def self.warn_if_unverified(ssl_context)
-        return if @@ssl_verification_warning_logged
-
-        problem = if !ssl_context.verify_mode.to_i.anybits?(::OpenSSL::SSL::VERIFY_PEER)
-                    'verify_mode is VERIFY_NONE, so the server certificate is not checked'
-                  elsif !ssl_context.verify_hostname
-                    'verify_hostname is false, so the certificate is not checked against the hostname'
-                  end
-        return unless problem
-
-        Dalli.logger.warn "SECURITY WARNING: Dalli's ssl_context #{problem}. " \
-                          'Use ssl_context.set_params(verify_mode: OpenSSL::SSL::VERIFY_PEER, ' \
-                          'verify_hostname: true) to verify the server.'
-        @@ssl_verification_warning_logged = true # rubocop:disable Style/ClassVars
       end
     end
 

data/lib/dalli/version.rb

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

data/lib/dalli.rb

@@ -62,8 +62,6 @@ require_relative 'dalli/version'
 require_relative 'dalli/instrumentation'
 
 require_relative 'dalli/compressor'
-require_relative 'dalli/json_serializer'
-require_relative 'dalli/protocol_deprecations'
 require_relative 'dalli/client'
 require_relative 'dalli/key_manager'
 require_relative 'dalli/pipelined_getter'
@@ -72,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'

data/lib/rack/session/dalli.rb

@@ -16,10 +16,11 @@ module Rack
       attr_reader :data
 
       # Don't freeze this until we fix the specs/implementation
-      # rubocop:disable-next Style/MutableConstant
+      # rubocop:disable Style/MutableConstant
       DEFAULT_DALLI_OPTIONS = {
         namespace: 'rack:session'
       }
+      # rubocop:enable Style/MutableConstant
 
       # Brings in a new Rack::Session::Dalli middleware with the given
       # `:memcache_server`. The server is either a hostname, or a

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 4.3.10
+  version: 5.0.0
 platform: ruby
 authors:
 - Peter M. Goldstein
@@ -41,7 +41,6 @@ files:
 - lib/dalli/client.rb
 - lib/dalli/compressor.rb
 - lib/dalli/instrumentation.rb
-- lib/dalli/json_serializer.rb
 - lib/dalli/key_manager.rb
 - lib/dalli/options.rb
 - lib/dalli/pid_cache.rb
@@ -50,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
@@ -78,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:
@@ -87,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.23
+rubygems_version: 4.0.6
 specification_version: 4
 summary: High performance memcached client for Ruby
 test_files: []

data/lib/dalli/json_serializer.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-
-module Dalli
-  ##
-  # A serializer that stores values as JSON and never creates Ruby objects
-  # from what it reads.
-  #
-  # Passing the JSON module itself as the serializer (serializer: JSON) reads
-  # values back with JSON.load, which on json gem versions before 3.0 honors
-  # "json_class" and instantiates other classes when the json gem's additions
-  # are loaded. This serializer reads with JSON.parse, so a value written to
-  # memcached by someone else can only come back as plain hashes, arrays,
-  # strings, numbers, booleans and nil.
-  #
-  #   Dalli::Client.new(servers, serializer: Dalli::JSONSerializer)
-  ##
-  module JSONSerializer
-    def self.dump(value)
-      JSON.generate(value)
-    end
-
-    def self.load(data)
-      JSON.parse(data)
-    end
-  end
-end

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

@@ -1,116 +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-next 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
-
-        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,245 +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
-
-        # raw: true returns the value as stored, without deserializing or
-        # decompressing it, whatever flags it was stored with
-        def get(cache_nils: false, raw: 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, !raw).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
-
-        # raw: true returns the value as stored; see #get
-        def data_cas_response(raw: false)
-          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, !raw).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.
-        ##
-        # memcached can't store an item larger than 1 GiB (its -I maximum). A
-        # pipelined reply claiming an impossible size would otherwise have the
-        # buffer wait for (and accumulate) that many bytes.
-        MAX_BODY_BYTES = 1024 * 1024 * 1024
-
-        def check_body_size!(size)
-          return if size <= MAX_BODY_BYTES
-
-          raise Dalli::DalliError, "Reply body size #{size} is out of range"
-        end
-
-        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?
-
-          check_body_size!(body_len)
-
-          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