dalli 3.0.4 → 3.1.0

data/lib/dalli/socket.rb

@@ -4,99 +4,145 @@ require 'openssl'
 require 'rbconfig'
 
 module Dalli
+  ##
+  # Various socket implementations used by Dalli.
+  ##
   module Socket
+    ##
+    # Common methods for all socket implementations.
+    ##
     module InstanceMethods
-
       def readfull(count)
-        value = +""
+        value = +''
         loop do
           result = read_nonblock(count - value.bytesize, exception: false)
-          if result == :wait_readable
-            raise Timeout::Error, "IO timeout: #{safe_options.inspect}" unless IO.select([self], nil, nil, options[:socket_timeout])
-          elsif result == :wait_writable
-            raise Timeout::Error, "IO timeout: #{safe_options.inspect}" unless IO.select(nil, [self], nil, options[:socket_timeout])
-          elsif result
-            value << result
-          else
-            raise Errno::ECONNRESET, "Connection reset: #{safe_options.inspect}"
-          end
+          value << result if append_to_buffer?(result)
           break if value.bytesize == count
         end
         value
       end
 
       def read_available
-        value = +""
+        value = +''
         loop do
           result = read_nonblock(8196, exception: false)
-          if result == :wait_readable
-            break
-          elsif result == :wait_writable
-            break
-          elsif result
-            value << result
-          else
-            raise Errno::ECONNRESET, "Connection reset: #{safe_options.inspect}"
-          end
+          break if WAIT_RCS.include?(result)
+          raise Errno::ECONNRESET, "Connection reset: #{logged_options.inspect}" unless result
+
+          value << result
         end
         value
       end
 
-      def safe_options
-        options.reject { |k, v| [:username, :password].include? k }
+      WAIT_RCS = %i[wait_writable wait_readable].freeze
+
+      def append_to_buffer?(result)
+        raise Timeout::Error, "IO timeout: #{logged_options.inspect}" if nonblock_timed_out?(result)
+        raise Errno::ECONNRESET, "Connection reset: #{logged_options.inspect}" unless result
+
+        !WAIT_RCS.include?(result)
+      end
+
+      def nonblock_timed_out?(result)
+        return true if result == :wait_readable && !wait_readable(options[:socket_timeout])
+
+        # TODO: Do we actually need this?  Looks to be only used in read_nonblock
+        result == :wait_writable && !wait_writable(options[:socket_timeout])
+      end
+
+      FILTERED_OUT_OPTIONS = %i[username password].freeze
+      def logged_options
+        options.reject { |k, _| FILTERED_OUT_OPTIONS.include? k }
       end
     end
 
+    ##
+    # Wraps the below TCP socket class in the case where the client
+    # has configured a TLS/SSL connection between Dalli and the
+    # Memcached server.
+    ##
     class SSLSocket < ::OpenSSL::SSL::SSLSocket
       include Dalli::Socket::InstanceMethods
       def options
         io.options
       end
+
+      unless method_defined?(:wait_readable)
+        def wait_readable(timeout = nil)
+          to_io.wait_readable(timeout)
+        end
+      end
+
+      unless method_defined?(:wait_writable)
+        def wait_writable(timeout = nil)
+          to_io.wait_writable(timeout)
+        end
+      end
     end
 
+    ##
+    # A standard TCP socket between the Dalli client and the Memcached server.
+    ##
     class TCP < TCPSocket
       include Dalli::Socket::InstanceMethods
-      attr_accessor :options, :server
+      # options - supports enhanced logging in the case of a timeout
+      attr_accessor :options
 
-      def self.open(host, port, server, options = {})
+      def self.open(host, port, options = {})
         Timeout.timeout(options[:socket_timeout]) do
           sock = new(host, port)
-          sock.options = {host: host, port: port}.merge(options)
-          sock.server = server
-          sock.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, true)
-          sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE, true) if options[:keepalive]
-          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]
-
-          return sock unless options[:ssl_context]
-
-          ssl_socket = Dalli::Socket::SSLSocket.new(sock, options[:ssl_context])
-          ssl_socket.hostname = host
-          ssl_socket.sync_close = true
-          ssl_socket.connect
-          ssl_socket
+          sock.options = { host: host, port: port }.merge(options)
+          init_socket_options(sock, options)
+
+          options[:ssl_context] ? wrapping_ssl_socket(sock, host, options[:ssl_context]) : sock
         end
       end
-    end
-  end
 
-  if RbConfig::CONFIG['host_os'] =~ /mingw|mswin/
-    class Dalli::Socket::UNIX
-      def initialize(*args)
-        raise Dalli::DalliError, 'Unix sockets are not supported on Windows platform.'
+      def self.init_socket_options(sock, options)
+        sock.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, true)
+        sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE, true) if options[:keepalive]
+        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.wrapping_ssl_socket(tcp_socket, host, ssl_context)
+        ssl_socket = Dalli::Socket::SSLSocket.new(tcp_socket, ssl_context)
+        ssl_socket.hostname = host
+        ssl_socket.sync_close = true
+        ssl_socket.connect
+        ssl_socket
       end
     end
-  else
-    class Dalli::Socket::UNIX < UNIXSocket
-      include Dalli::Socket::InstanceMethods
-      attr_accessor :options, :server
 
-      def self.open(path, server, options = {})
-        Timeout.timeout(options[:socket_timeout]) do
-          sock = new(path)
-          sock.options = {path: path}.merge(options)
-          sock.server = server
-          sock
+    if /mingw|mswin/.match?(RbConfig::CONFIG['host_os'])
+      ##
+      # UNIX domain sockets are not supported on Windows platforms.
+      ##
+      class UNIX
+        def initialize(*_args)
+          raise Dalli::DalliError, 'Unix sockets are not supported on Windows platform.'
+        end
+      end
+    else
+
+      ##
+      # UNIX represents a UNIX domain socket, which is an interprocess communication
+      # mechanism between processes on the same host.  Used when the Memcached server
+      # is running on the same machine as the Dalli client.
+      ##
+      class UNIX < UNIXSocket
+        include Dalli::Socket::InstanceMethods
+
+        # options - supports enhanced logging in the case of a timeout
+        # server  - used to support IO.select in the pipelined getter
+        attr_accessor :options
+
+        def self.open(path, options = {})
+          Timeout.timeout(options[:socket_timeout]) do
+            sock = new(path)
+            sock.options = { path: path }.merge(options)
+            sock
+          end
         end
       end
     end

data/lib/dalli/version.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
 module Dalli
-  VERSION = "3.0.4"
+  VERSION = '3.1.0'
+
+  MIN_SUPPORTED_MEMCACHED_VERSION = '1.4'
 end

data/lib/dalli.rb

@@ -1,33 +1,38 @@
 # frozen_string_literal: true
 
-require "dalli/compressor"
-require "dalli/client"
-require "dalli/ring"
-require "dalli/protocol"
-require "dalli/protocol/binary"
-require "dalli/protocol/server_config_parser"
-require "dalli/protocol/ttl_sanitizer"
-require 'dalli/protocol/value_compressor'
-require "dalli/socket"
-require "dalli/version"
-require "dalli/options"
-
+##
+# Namespace for all Dalli code.
+##
 module Dalli
-  autoload :Server, "dalli/server"
+  autoload :Server, 'dalli/server'
 
   # generic error
   class DalliError < RuntimeError; end
+
   # socket/server communication error
   class NetworkError < DalliError; end
+
   # no server available/alive error
   class RingError < DalliError; end
+
   # application error in marshalling serialization
   class MarshalError < DalliError; end
+
   # application error in marshalling deserialization or decompression
   class UnmarshalError < DalliError; end
+
   # payload too big for memcached
   class ValueOverMaxSize < DalliError; end
 
+  # operation is not permitted in a multi block
+  class NotPermittedMultiOpError < 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
+
+  MULTI_KEY = :dalli_multi
+
   def self.logger
     @logger ||= (rails_logger || default_logger)
   end
@@ -38,7 +43,7 @@ module Dalli
   end
 
   def self.default_logger
-    require "logger"
+    require 'logger'
     l = Logger.new($stdout)
     l.level = Logger::INFO
     l
@@ -48,3 +53,22 @@ module Dalli
     @logger = logger
   end
 end
+
+require_relative 'dalli/version'
+
+require_relative 'dalli/compressor'
+require_relative 'dalli/client'
+require_relative 'dalli/key_manager'
+require_relative 'dalli/pipelined_getter'
+require_relative 'dalli/ring'
+require_relative 'dalli/protocol'
+require_relative 'dalli/protocol/binary'
+require_relative 'dalli/protocol/response_buffer'
+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/value_serializer'
+require_relative 'dalli/servers_arg_normalizer'
+require_relative 'dalli/socket'
+require_relative 'dalli/options'

data/lib/rack/session/dalli.rb

@@ -1,17 +1,22 @@
 # frozen_string_literal: true
+
 require 'rack/session/abstract/id'
 require 'dalli'
 require 'connection_pool'
+require 'English'
 
 module Rack
   module Session
-    class Dalli < Abstract::Persisted
-      attr_reader :pool
+    # Rack::Session::Dalli provides memcached based session management.
+    class Dalli < Abstract::PersistedSecure
+      attr_reader :data
 
+      # Don't freeze this until we fix the specs/implementation
+      # rubocop:disable Style/MutableConstant
       DEFAULT_DALLI_OPTIONS = {
-        :namespace => 'rack:session',
-        :memcache_server => 'localhost:11211'
+        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
@@ -27,25 +32,14 @@ module Rack
       # ENV['MEMCACHE_SERVERS'] and use that value if it is available, or fall
       # back to the same default behavior described above.
       #
-      # Rack::Session::Dalli is intended to be a drop-in replacement for
-      # Rack::Session::Memcache. It accepts additional options that control the
-      # behavior of Rack::Session, Dalli::Client, and an optional
-      # ConnectionPool. First and foremost, if you wish to instantiate your own
-      # Dalli::Client (or ConnectionPool) and use that instead of letting
-      # Rack::Session::Dalli instantiate it on your behalf, simply pass it in
-      # as the `:cache` option. Please note that you will be responsible for
-      # setting the namespace and any other options on Dalli::Client.
-      #
-      # Secondly, if you're not using the `:cache` option, Rack::Session::Dalli
-      # accepts the same options as Dalli::Client, so it's worth reviewing its
-      # documentation. Perhaps most importantly, if you don't specify a
-      # `:namespace` option, Rack::Session::Dalli will default to using
-      # "rack:session".
+      # Rack::Session::Dalli accepts the same options as Dalli::Client, so
+      # it's worth reviewing its documentation. Perhaps most importantly,
+      # if you don't specify a `:namespace` option, Rack::Session::Dalli
+      # will default to using 'rack:session'.
       #
-      # Whether you are using the `:cache` option or not, it is not recommend
-      # to set `:expires_in`. Instead, use `:expire_after`, which will control
-      # both the expiration of the client cookie as well as the expiration of
-      # the corresponding entry in memcached.
+      # It is not recommended to set `:expires_in`. Instead, use `:expire_after`,
+      # which will control both the expiration of the client cookie as well
+      # as the expiration of the corresponding entry in memcached.
       #
       # Rack::Session::Dalli also accepts a host of options that control how
       # the sessions and session cookies are managed, including the
@@ -67,96 +61,121 @@ module Rack
       # for more information about it and its default options (which would only
       # be applicable if you supplied one of the two options, but not both).
       #
-      def initialize(app, options={})
+      def initialize(app, options = {})
         # Parent uses DEFAULT_OPTIONS to build @default_options for Rack::Session
         super
 
         # Determine the default TTL for newly-created sessions
-        @default_ttl = ttl @default_options[:expire_after]
-
-        # Normalize and validate passed options
-        mserv, mopts, popts = extract_dalli_options(options)
-
-        @pool = ConnectionPool.new(popts || {}) { ::Dalli::Client.new(mserv, mopts) }
+        @default_ttl = ttl(@default_options[:expire_after])
+        @data = build_data_source(options)
       end
 
-      def get_session(env, sid)
-        with_block([nil, {}]) do |dc|
-          unless sid and !sid.empty? and session = dc.get(sid)
-            old_sid, sid, session = sid, generate_sid_with(dc), {}
-            unless dc.add(sid, session, @default_ttl)
-              sid = old_sid
-              redo # generate a new sid and try again
-            end
-          end
-          [sid, session]
+      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?
+
+          [create_sid_with_empty_session(dc), {}]
         end
       end
 
-      def set_session(env, session_id, new_session, options)
-        return false unless session_id
+      def write_session(_req, sid, session, options)
+        return false unless sid
 
-        with_block(false) do |dc|
-          dc.set(session_id, new_session, ttl(options[:expire_after]))
-          session_id
+        with_dalli_client(false) do |dc|
+          dc.set(memcached_key_from_sid(sid), session, ttl(options[:expire_after]))
+          sid
         end
       end
 
-      def destroy_session(env, session_id, options)
-        with_block do |dc|
-          dc.delete(session_id)
+      def delete_session(_req, sid, options)
+        with_dalli_client do |dc|
+          dc.delete(memcached_key_from_sid(sid))
           generate_sid_with(dc) unless options[:drop]
         end
       end
 
-      def find_session(req, sid)
-        get_session req.env, sid
+      private
+
+      def memcached_key_from_sid(sid)
+        sid.private_id
       end
 
-      def write_session(req, sid, session, options)
-        set_session req.env, sid, session, options
+      def existing_session_for_sid(client, sid)
+        return nil unless sid && !sid.empty?
+
+        client.get(memcached_key_from_sid(sid))
       end
 
-      def delete_session(req, sid, options)
-        destroy_session req.env, sid, options
+      def create_sid_with_empty_session(client)
+        loop do
+          sid = generate_sid_with(client)
+
+          break sid if client.add(memcached_key_from_sid(sid), {}, @default_ttl)
+        end
       end
 
-      private
+      def generate_sid_with(client)
+        loop do
+          raw_sid = generate_sid
+          sid = raw_sid.is_a?(String) ? Rack::Session::SessionId.new(raw_sid) : raw_sid
+          break sid unless client.get(memcached_key_from_sid(sid))
+        end
+      end
 
-      def extract_dalli_options(options)
-        raise "Rack::Session::Dalli no longer supports the :cache option." if options[:cache]
+      def build_data_source(options)
+        server_configurations, client_options, pool_options = extract_dalli_options(options)
 
-        popts = {}
-        # Filter out Rack::Session-specific options and apply our defaults
-        mopts = DEFAULT_DALLI_OPTIONS.merge \
-          options.reject {|k, _| DEFAULT_OPTIONS.key? k }
-        mserv = mopts.delete :memcache_server
-
-        if mopts[:pool_size] || mopts[:pool_timeout]
-          popts[:size] = mopts.delete :pool_size if mopts[:pool_size]
-          popts[:timeout] = mopts.delete :pool_timeout if mopts[:pool_timeout]
-          mopts[:threadsafe] = true
+        if pool_options.empty?
+          ::Dalli::Client.new(server_configurations, client_options)
+        else
+          ensure_connection_pool_added!
+          ConnectionPool.new(pool_options) do
+            ::Dalli::Client.new(server_configurations, client_options.merge(threadsafe: false))
+          end
         end
+      end
+
+      def extract_dalli_options(options)
+        raise 'Rack::Session::Dalli no longer supports the :cache option.' if options[:cache]
+
+        client_options = retrieve_client_options(options)
+        server_configurations = client_options.delete(:memcache_server)
 
-        [mserv, mopts, popts]
+        [server_configurations, client_options, retrieve_pool_options(options)]
       end
 
-      def generate_sid_with(dc)
-        while true
-          sid = generate_sid
-          break sid unless dc.get(sid)
+      def retrieve_client_options(options)
+        # Filter out Rack::Session-specific options and apply our defaults
+        filtered_opts = options.reject { |k, _| DEFAULT_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]
         end
       end
 
-      def with_block(default=nil, &block)
-        @pool.with(&block)
+      def ensure_connection_pool_added!
+        require 'connection_pool'
+      rescue LoadError => e
+        warn "You don't have connection_pool installed in your application. "\
+             'Please add it to your Gemfile and run bundle install'
+        raise e
+      end
+
+      def with_dalli_client(result_on_error = nil, &block)
+        @data.with(&block)
       rescue ::Dalli::DalliError, Errno::ECONNREFUSED
-        raise if $!.message =~ /undefined class/
+        raise if /undefined class/.match?($ERROR_INFO.message)
+
         if $VERBOSE
           warn "#{self} is unable to find memcached server."
-          warn $!.inspect
+          warn $ERROR_INFO.inspect
         end
-        default
+        result_on_error
       end
 
       def ttl(expire_after)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 3.0.4
+  version: 3.1.0
 platform: ruby
 authors:
 - Peter M. Goldstein
@@ -9,10 +9,44 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-27 00:00:00.000000000 Z
+date: 2021-12-03 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -26,7 +60,35 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: connection_pool
+  name: rubocop-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -55,21 +117,32 @@ files:
 - lib/dalli/cas/client.rb
 - lib/dalli/client.rb
 - lib/dalli/compressor.rb
+- lib/dalli/key_manager.rb
 - lib/dalli/options.rb
+- lib/dalli/pipelined_getter.rb
 - lib/dalli/protocol.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/response_buffer.rb
 - lib/dalli/protocol/server_config_parser.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
 - lib/rack/session/dalli.rb
 homepage: https://github.com/petergoldstein/dalli
 licenses:
 - MIT
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -78,14 +151,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.30
+rubygems_version: 3.2.31
 signing_key:
 specification_version: 4
 summary: High performance memcached client for Ruby