dalli 3.2.8 → 5.0.5

data/lib/dalli/socket.rb

@@ -52,7 +52,7 @@ module Dalli
 
       FILTERED_OUT_OPTIONS = %i[username password].freeze
       def logged_options
-        options.reject { |k, _| FILTERED_OUT_OPTIONS.include? k }
+        options.except(*FILTERED_OUT_OPTIONS)
       end
     end
 
@@ -63,6 +63,7 @@ module Dalli
     ##
     class SSLSocket < ::OpenSSL::SSL::SSLSocket
       include Dalli::Socket::InstanceMethods
+
       def options
         io.options
       end
@@ -85,9 +86,16 @@ module Dalli
     ##
     class TCP < TCPSocket
       include Dalli::Socket::InstanceMethods
+
       # 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)
@@ -97,15 +105,25 @@ module Dalli
         end
       end
 
+      # Detect and cache whether TCPSocket supports the connect_timeout: keyword argument.
+      # Returns true for an unmodified TCPSocket on Ruby 3.0+, or for resolv-replace >= 0.2.0
+      # which forwards keyword arguments through its patch.
+      # Returns false when monkey-patched by gems like socksify or resolv-replace < 0.2.0.
+      # rubocop:disable ThreadSafety/ClassInstanceVariable
+      def self.supports_connect_timeout?
+        return @supports_connect_timeout if defined?(@supports_connect_timeout)
+
+        @supports_connect_timeout = RUBY_ENGINE == 'ruby' && RUBY_VERSION >= '3.0' &&
+                                    ::TCPSocket.instance_method(:initialize).parameters.then do |params|
+                                      params == TCPSOCKET_NATIVE_PARAMETERS || params.any? do |type, _|
+                                        type == :keyrest
+                                      end
+                                    end
+      end
+      # rubocop:enable ThreadSafety/ClassInstanceVariable
+
       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_instance_methods.include?(:original_resolv_initialize)
+        if supports_connect_timeout?
           sock = new(host, port, connect_timeout: options[:socket_timeout])
           yield(sock)
         else
@@ -117,19 +135,59 @@ module Dalli
       end
 
       def self.init_socket_options(sock, options)
+        configure_tcp_options(sock, options)
+        configure_socket_buffers(sock, options)
+        configure_timeout(sock, options)
+      end
+
+      def self.configure_tcp_options(sock, options)
         sock.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, true)
         sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE, true) if options[:keepalive]
+      end
+
+      def self.configure_socket_buffers(sock, options)
         sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_RCVBUF, options[:rcvbuf]) if options[:rcvbuf]
         sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_SNDBUF, options[:sndbuf]) if options[:sndbuf]
+      end
 
+      def self.configure_timeout(sock, options)
         return unless options[:socket_timeout]
 
-        seconds, fractional = options[:socket_timeout].divmod(1)
-        microseconds = fractional * 1_000_000
-        timeval = [seconds, microseconds].pack('l_2')
+        if sock.respond_to?(:timeout=)
+          # Ruby 3.2+ has IO#timeout for reliable cross-platform timeout handling
+          sock.timeout = options[:socket_timeout]
+        else
+          # Ruby 3.1 fallback using socket options
+          # struct timeval has architecture-dependent sizes (time_t, suseconds_t)
+          seconds, fractional = options[:socket_timeout].divmod(1)
+          microseconds = (fractional * 1_000_000).to_i
+          timeval = pack_timeval(sock, seconds, microseconds)
+
+          sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_RCVTIMEO, timeval)
+          sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_SNDTIMEO, timeval)
+        end
+      end
 
-        sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_RCVTIMEO, timeval)
-        sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_SNDTIMEO, timeval)
+      # Pack formats for struct timeval across architectures.
+      # Uses fixed-size formats for JRuby compatibility (JRuby doesn't support _ modifier on q).
+      # - ll: 8 bytes (32-bit time_t, 32-bit suseconds_t)
+      # - qq: 16 bytes (64-bit time_t, 64-bit suseconds_t or padded 32-bit)
+      TIMEVAL_PACK_FORMATS = %w[ll qq].freeze
+      TIMEVAL_TEST_VALUES = [0, 0].freeze
+
+      # Detect and cache the correct pack format for struct timeval on this platform.
+      # Different architectures have different sizes for time_t and suseconds_t.
+      # rubocop:disable ThreadSafety/ClassInstanceVariable
+      def self.timeval_pack_format(sock)
+        @timeval_pack_format ||= begin
+          expected_size = sock.getsockopt(::Socket::SOL_SOCKET, ::Socket::SO_RCVTIMEO).data.bytesize
+          TIMEVAL_PACK_FORMATS.find { |fmt| TIMEVAL_TEST_VALUES.pack(fmt).bytesize == expected_size } || 'll'
+        end
+      end
+      # rubocop:enable ThreadSafety/ClassInstanceVariable
+
+      def self.pack_timeval(sock, seconds, microseconds)
+        [seconds, microseconds].pack(timeval_pack_format(sock))
       end
 
       def self.wrapping_ssl_socket(tcp_socket, host, ssl_context)
@@ -168,9 +226,16 @@ module Dalli
           Timeout.timeout(options[:socket_timeout]) do
             sock = new(path)
             sock.options = { path: path }.merge(options)
+            init_socket_options(sock, options)
             sock
           end
         end
+
+        def self.init_socket_options(sock, options)
+          # https://man7.org/linux/man-pages/man7/unix.7.html
+          sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_SNDBUF, options[:sndbuf]) if options[:sndbuf]
+          sock.timeout = options[:socket_timeout] if options[:socket_timeout] && sock.respond_to?(:timeout=)
+        end
       end
     end
   end

data/lib/dalli/version.rb

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

data/lib/dalli.rb

@@ -4,8 +4,6 @@
 # Namespace for all Dalli code.
 ##
 module Dalli
-  autoload :Server, 'dalli/server'
-
   # generic error
   class DalliError < RuntimeError; end
 
@@ -27,6 +25,12 @@ module Dalli
   # operation is not permitted in a multi block
   class NotPermittedMultiOpError < DalliError; end
 
+  # 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
@@ -34,7 +38,7 @@ module Dalli
   QUIET = :dalli_multi
 
   def self.logger
-    @logger ||= rails_logger || default_logger
+    @logger ||= rails_logger || default_logger # rubocop:disable ThreadSafety/ClassInstanceVariable
   end
 
   def self.rails_logger
@@ -50,20 +54,23 @@ module Dalli
   end
 
   def self.logger=(logger)
-    @logger = logger
+    @logger = logger # rubocop:disable ThreadSafety/ClassInstanceVariable
   end
 end
 
 require_relative 'dalli/version'
+require_relative 'dalli/instrumentation'
 
+require_relative 'dalli/flags'
 require_relative 'dalli/compressor'
 require_relative 'dalli/client'
 require_relative 'dalli/key_manager'
 require_relative 'dalli/pipelined_getter'
+require_relative 'dalli/pipelined_setter'
+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'
@@ -71,6 +78,7 @@ require_relative 'dalli/protocol/server_config_parser'
 require_relative 'dalli/protocol/ttl_sanitizer'
 require_relative 'dalli/protocol/value_compressor'
 require_relative 'dalli/protocol/value_marshaller'
+require_relative 'dalli/protocol/string_marshaller'
 require_relative 'dalli/protocol/value_serializer'
 require_relative 'dalli/servers_arg_normalizer'
 require_relative 'dalli/socket'

data/lib/rack/session/dalli.rb

@@ -9,6 +9,10 @@ module Rack
   module Session
     # Rack::Session::Dalli provides memcached based session management.
     class Dalli < Abstract::PersistedSecure
+      class MissingSessionError < StandardError; end
+
+      RACK_SESSION_PERSISTED = 'rack.session.persisted'
+
       attr_reader :data
 
       # Don't freeze this until we fix the specs/implementation
@@ -70,23 +74,37 @@ module Rack
         @data = build_data_source(options)
       end
 
-      def find_session(_req, sid)
+      def call(*_args)
+        super
+      rescue MissingSessionError
+        [401, {}, ['Wrong session ID']]
+      end
+
+      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?
+          if existing_session.nil?
+            sid = create_sid_with_empty_session(dc)
+            existing_session = {}
+          end
 
-          [create_sid_with_empty_session(dc), {}]
+          update_session_persisted_data(req, { id: sid })
+          return [sid, existing_session]
         end
       end
 
-      def write_session(_req, sid, session, options)
+      def write_session(req, sid, session, options)
         return false unless sid
 
         key = memcached_key_from_sid(sid)
         return false unless key
 
         with_dalli_client(false) do |dc|
-          dc.set(memcached_key_from_sid(sid), session, ttl(options[:expire_after]))
+          write_session_safely!(
+            dc, sid, session_persisted_data(req),
+            write_args: [memcached_key_from_sid(sid), session, ttl(options[:expire_after])]
+          )
+
           sid
         end
       end
@@ -139,12 +157,21 @@ module Rack
           ::Dalli::Client.new(server_configurations, client_options)
         else
           ensure_connection_pool_added!
-          ConnectionPool.new(pool_options) do
+          ConnectionPool.new(**pool_options) do
             ::Dalli::Client.new(server_configurations, client_options.merge(threadsafe: false))
           end
         end
       end
 
+      def write_session_safely!(dalli_client, sid, persisted_data, write_args:)
+        if persisted_data && persisted_data[:id] == sid # That means that we update the existing session
+          # Override the session only if it still exists in the store!
+          raise MissingSessionError unless dalli_client.replace(*write_args)
+        else
+          dalli_client.set(*write_args)
+        end
+      end
+
       def extract_dalli_options(options)
         raise 'Rack::Session::Dalli no longer supports the :cache option.' if options[:cache]
 
@@ -175,8 +202,8 @@ module Rack
         raise e
       end
 
-      def with_dalli_client(result_on_error = nil, &block)
-        @data.with(&block)
+      def with_dalli_client(result_on_error = nil, &)
+        @data.with(&)
       rescue ::Dalli::DalliError, Errno::ECONNREFUSED
         raise if $ERROR_INFO.message.include?('undefined class')
 
@@ -190,6 +217,14 @@ module Rack
       def ttl(expire_after)
         expire_after.nil? ? 0 : expire_after + 1
       end
+
+      def session_persisted_data(req)
+        req.get_header RACK_SESSION_PERSISTED
+      end
+
+      def update_session_persisted_data(req, data)
+        req.set_header RACK_SESSION_PERSISTED, data
+      end
     end
   end
 end

metadata

@@ -1,16 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 3.2.8
+  version: 5.0.5
 platform: ruby
 authors:
 - Peter M. Goldstein
 - Mike Perham
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-12 00:00:00.000000000 Z
-dependencies: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: High performance memcached client for Ruby
 email:
 - peter.m.goldstein@gmail.com
@@ -27,30 +40,29 @@ files:
 - lib/dalli/cas/client.rb
 - lib/dalli/client.rb
 - lib/dalli/compressor.rb
+- lib/dalli/flags.rb
+- lib/dalli/instrumentation.rb
 - lib/dalli/key_manager.rb
 - lib/dalli/options.rb
 - lib/dalli/pid_cache.rb
+- lib/dalli/pipelined_deleter.rb
 - lib/dalli/pipelined_getter.rb
+- 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/ring.rb
-- lib/dalli/server.rb
 - lib/dalli/servers_arg_normalizer.rb
 - lib/dalli/socket.rb
 - lib/dalli/version.rb
@@ -62,7 +74,6 @@ metadata:
   bug_tracker_uri: https://github.com/petergoldstein/dalli/issues
   changelog_uri: https://github.com/petergoldstein/dalli/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -70,15 +81,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.6'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.6
-signing_key:
+rubygems_version: 4.0.12
 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