dalli 5.2.1 → 5.2.3

data/lib/dalli/protocol/value_compressor.rb

@@ -84,11 +84,13 @@ module Dalli
       end
 
       # Checks whether we should apply compression when serializing a value
-      # based on the specified options.  Returns false unless the value
-      # is greater than the minimum compression size.  Otherwise returns
-      # based on a method-level option if specified, falling back to the
-      # server default.
+      # based on the specified options.  Returns false for a raw request
+      # (raw reads ignore bitflags, so the value must be stored as given) or
+      # unless the value is greater than the minimum compression size.
+      # Otherwise returns based on a method-level option if specified,
+      # falling back to the server default.
       def compress_value?(value, req_options)
+        return false if req_options&.dig(:raw)
         return false unless value.bytesize >= compression_min_size
         return compress_by_default? unless req_options && !req_options[:compress].nil?
 

data/lib/dalli/protocol/value_marshaller.rb

@@ -13,12 +13,30 @@ module Dalli
       extend Forwardable
 
       DEFAULTS = {
-        # max size of value in bytes (default is 1 MB, can be overriden with "memcached -I <size>")
+        # max memcached item size in bytes: value + key + ITEM_OVERHEAD_BYTES. Set it to
+        # memcached's -I value (default 1 MB).
         value_max_bytes: 1024 * 1024
       }.freeze
 
       OPTIONS = DEFAULTS.keys.freeze
 
+      # memcached's -I limit applies to the whole item, not just the value. On
+      # 64-bit memcached 1.6 an item takes the value, the key, and 63 bytes of
+      # overhead: a 48-byte header, 8 bytes of CAS, 4 bytes of client flags,
+      # the key's NUL terminator and the value's trailing CRLF. (Measured
+      # against memcached 1.6.45 with -I 512k, 1m, 2m and 5m; an item stored
+      # with zero flags or with CAS disabled needs a few bytes less.)
+      ITEM_OVERHEAD_BYTES = 63
+
+      def self.error_if_over_max_value_bytes(key, value, value_max_bytes)
+        item_bytes = value.bytesize + key.bytesize + ITEM_OVERHEAD_BYTES
+        return if item_bytes <= value_max_bytes
+
+        message = "Value for #{key} over max size: #{value_max_bytes} <= #{item_bytes} " \
+                  "(#{value.bytesize} value bytes + #{key.bytesize} key bytes + #{ITEM_OVERHEAD_BYTES} item overhead)"
+        raise Dalli::ValueOverMaxSize, message
+      end
+
       def_delegators :@value_serializer, :serializer
       def_delegators :@value_compressor, :compressor, :compression_min_size, :compress_by_default?
 
@@ -28,6 +46,7 @@ module Dalli
 
         @marshal_options =
           DEFAULTS.merge(client_options.slice(*OPTIONS))
+        @marshal_options[:value_max_bytes] = @marshal_options[:value_max_bytes].to_i
       end
 
       def store(key, value, options = nil)
@@ -49,10 +68,7 @@ module Dalli
       end
 
       def error_if_over_max_value_bytes(key, value)
-        return if value.bytesize <= value_max_bytes
-
-        message = "Value for #{key} over max size: #{value_max_bytes} <= #{value.bytesize}"
-        raise Dalli::ValueOverMaxSize, message
+        self.class.error_if_over_max_value_bytes(key, value, value_max_bytes)
       end
     end
   end

data/lib/dalli/protocol.rb

@@ -16,9 +16,9 @@ module Dalli
         [Timeout::Error]
       end
 
-    # SSL errors that occur during read/write operations (not during initial
-    # handshake) should trigger reconnection. These indicate transient network
-    # issues, not configuration problems.
+    # SSL errors during the handshake or during read/write operations count as
+    # a failed request: they trigger reconnection and, after
+    # socket_max_failures, mark the server down.
     SSL_ERRORS =
       if defined?(OpenSSL::SSL::SSLError)
         [OpenSSL::SSL::SSLError]

data/lib/dalli/socket.rb

@@ -8,6 +8,12 @@ module Dalli
   # Various socket implementations used by Dalli.
   ##
   module Socket
+    # Timeout for establishing a connection: connect_timeout if set,
+    # otherwise socket_timeout.
+    def self.connect_timeout_for(options)
+      options[:connect_timeout] || options[:socket_timeout]
+    end
+
     ##
     # Common methods for all socket implementations.
     ##
@@ -162,11 +168,13 @@ module Dalli
       end
 
       def self.create_socket_with_timeout(host, port, options)
+        timeout = Dalli::Socket.connect_timeout_for(options)
         if supports_connect_timeout?
-          sock = new(host, port, connect_timeout: options[:socket_timeout])
+          # resolv_timeout bounds the DNS lookup, which connect_timeout doesn't cover
+          sock = new(host, port, connect_timeout: timeout, resolv_timeout: timeout)
           yield(sock)
         else
-          Timeout.timeout(options[:socket_timeout]) do
+          Timeout.timeout(timeout) do
             sock = new(host, port)
             yield(sock)
           end
@@ -228,12 +236,41 @@ 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
 
@@ -261,7 +298,7 @@ module Dalli
         attr_accessor :options
 
         def self.open(path, options = {})
-          Timeout.timeout(options[:socket_timeout]) do
+          Timeout.timeout(Dalli::Socket.connect_timeout_for(options)) do
             sock = new(path)
             sock.options = { path: path }.merge(options)
             init_socket_options(sock, options)

data/lib/dalli/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Dalli
-  VERSION = '5.2.1'
+  VERSION = '5.2.3'
 
   MIN_SUPPORTED_MEMCACHED_VERSION = '1.6.27'
 end

data/lib/dalli.rb

@@ -31,6 +31,10 @@ module Dalli
   # socket/server communication error that can be retried
   class RetryableNetworkError < NetworkError; end
 
+  # a multi-get reply named a key that wasn't requested, so the rest of that
+  # server's replies can't be trusted
+  class UnexpectedReplyKeyError < 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

data/lib/rack/session/dalli.rb

@@ -2,7 +2,6 @@
 
 require 'rack/session/abstract/id'
 require 'dalli'
-require 'connection_pool'
 require 'English'
 
 module Rack
@@ -21,6 +20,11 @@ module Rack
         namespace: 'rack:session'
       }
 
+      # Our pool options and the ConnectionPool options they set. These are
+      # not passed on to Dalli::Client.
+      POOL_OPTIONS = { pool_size: :size, pool_timeout: :timeout }.freeze
+      private_constant :POOL_OPTIONS
+
       # Brings in a new Rack::Session::Dalli middleware with the given
       # `:memcache_server`. The server is either a hostname, or a
       # host-with-port string in the form of "host_name:port", or an array of
@@ -73,10 +77,18 @@ module Rack
         @data = build_data_source(options)
       end
 
-      def call(*_args)
-        super
+      # If the session is deleted from memcached while a request is running
+      # (for example, by a logout in another request), the session is not
+      # written back, so a logged-out session can't come back. The app's
+      # response is replaced with a 401 that expires the session cookie.
+      # The app has already run by then, so any side effects it had (database
+      # writes, emails, and so on) have happened.
+      def context(env, app = @app)
+        body = nil
+        super(env, ->(app_env) { app.call(app_env).tap { |response| body = response[2] } })
       rescue MissingSessionError
-        [401, {}, ['Wrong session ID']]
+        body.close if body.respond_to?(:close)
+        missing_session_response(env)
       end
 
       def find_session(req, sid)
@@ -111,13 +123,23 @@ module Rack
       def delete_session(_req, sid, options)
         with_dalli_client do |dc|
           key = memcached_key_from_sid(sid)
-          dc.delete(key) if key
+          delete_session_key(dc, key) if key
           generate_sid_with(dc) unless options[:drop]
         end
       end
 
       private
 
+      # A failed delete leaves the old session readable in memcached (e.g.
+      # after logout), so always log it, even though with_dalli_client then
+      # handles the error as before.
+      def delete_session_key(client, key)
+        client.delete(key)
+      rescue ::Dalli::DalliError, Errno::ECONNREFUSED => e
+        ::Dalli.logger.warn("#{self.class} failed to delete a session from memcached: #{e.class}: #{e.message}")
+        raise
+      end
+
       def memcached_key_from_sid(sid)
         sid.private_id if sid.respond_to?(:private_id)
       end
@@ -162,6 +184,12 @@ module Rack
         end
       end
 
+      def missing_session_response(env)
+        options = env[Rack::RACK_SESSION_OPTIONS] || @default_options
+        cookie = Rack::Utils.delete_set_cookie_header(key, options.slice(:path, :domain))
+        [401, { 'content-type' => 'text/plain', 'set-cookie' => cookie }, ['Wrong session ID']]
+      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!
@@ -181,15 +209,14 @@ module Rack
       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 }
+        # Filter out Rack::Session-specific and pool options and apply our defaults
+        filtered_opts = options.reject { |k, _| DEFAULT_OPTIONS.key?(k) || POOL_OPTIONS.key?(k) }
         DEFAULT_DALLI_OPTIONS.merge(filtered_opts)
       end
 
       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]
+        POOL_OPTIONS.each_with_object({}) do |(option, pool_option), pool_options|
+          pool_options[pool_option] = options[option] if options[option]
         end
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 5.2.1
+  version: 5.2.3
 platform: ruby
 authors:
 - Peter M. Goldstein
@@ -89,7 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.21
+rubygems_version: 4.0.23
 specification_version: 4
 summary: High performance memcached client for Ruby
 test_files: []