dalli 2.7.6 → 3.2.2

data/lib/rack/session/dalli.rb

@@ -1,89 +1,195 @@
+# frozen_string_literal: true
+
 require 'rack/session/abstract/id'
 require 'dalli'
+require 'connection_pool'
+require 'English'
 
 module Rack
   module Session
-    class Dalli < defined?(Abstract::Persisted) ? Abstract::Persisted : Abstract::ID
-      attr_reader :pool, :mutex
+    # Rack::Session::Dalli provides memcached based session management.
+    class Dalli < Abstract::PersistedSecure
+      attr_reader :data
 
-      DEFAULT_OPTIONS = Abstract::ID::DEFAULT_OPTIONS.merge \
-        :namespace => 'rack:session',
-        :memcache_server => 'localhost:11211'
+      # Don't freeze this until we fix the specs/implementation
+      # rubocop:disable Style/MutableConstant
+      DEFAULT_DALLI_OPTIONS = {
+        namespace: 'rack:session'
+      }
+      # rubocop:enable Style/MutableConstant
 
-      def initialize(app, 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
+      # such strings. For example:
+      #
+      #   use Rack::Session::Dalli,
+      #     :memcache_server => "mc.example.com:1234"
+      #
+      # If no `:memcache_server` option is specified, Rack::Session::Dalli will
+      # connect to localhost, port 11211 (the default memcached port). If
+      # `:memcache_server` is set to nil, Dalli::Client will look for
+      # ENV['MEMCACHE_SERVERS'] and use that value if it is available, or fall
+      # back to the same default behavior described above.
+      #
+      # 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'.
+      #
+      # 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
+      # aforementioned `:expire_after` option. Please see the documentation for
+      # Rack::Session::Abstract::Persisted for a detailed explanation of these
+      # options and their default values.
+      #
+      # Finally, if your web application is multithreaded, the
+      # Rack::Session::Dalli middleware can become a source of contention. You
+      # can use a connection pool of Dalli clients by passing in the
+      # `:pool_size` and/or `:pool_timeout` options. For example:
+      #
+      #   use Rack::Session::Dalli,
+      #     :memcache_server => "mc.example.com:1234",
+      #     :pool_size => 10
+      #
+      # You must include the `connection_pool` gem in your project if you wish
+      # to use pool support. Please see the documentation for ConnectionPool
+      # 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 = {})
+        # Parent uses DEFAULT_OPTIONS to build @default_options for Rack::Session
         super
-        @mutex = Mutex.new
-        mserv = @default_options[:memcache_server]
-        mopts = @default_options.reject{|k,v| !DEFAULT_OPTIONS.include? k }
-        @pool = options[:cache] || ::Dalli::Client.new(mserv, mopts)
-        @pool.alive!
+
+        # Determine the default TTL for newly-created sessions
+        @default_ttl = ttl(@default_options[:expire_after])
+        @data = build_data_source(options)
       end
 
-      if defined?(Abstract::Persisted)
-        def find_session(req, sid)
-          get_session req.env, sid
+      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 write_session(req, sid, session, options)
-          set_session req.env, 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]))
+          sid
         end
+      end
 
-        def delete_session(req, sid, options)
-          destroy_session req.env, sid, options
+      def delete_session(_req, sid, options)
+        with_dalli_client do |dc|
+          key = memcached_key_from_sid(sid)
+          dc.delete(key) if key
+          generate_sid_with(dc) unless options[:drop]
         end
       end
 
-      def generate_sid
-        while true
-          sid = super
-          break sid unless @pool.get(sid)
+      private
+
+      def memcached_key_from_sid(sid)
+        sid.private_id if sid.respond_to?(:private_id)
+      end
+
+      def existing_session_for_sid(client, sid)
+        return nil unless sid && !sid.empty?
+
+        key = memcached_key_from_sid(sid)
+        return nil if key.nil?
+
+        client.get(key)
+      end
+
+      def create_sid_with_empty_session(client)
+        loop do
+          sid = generate_sid_with(client)
+          key = memcached_key_from_sid(sid)
+
+          break sid if key && client.add(key, {}, @default_ttl)
         end
       end
 
-      def get_session(env, sid)
-        with_lock(env, [nil, {}]) do
-          unless sid and !sid.empty? and session = @pool.get(sid)
-            sid, session = generate_sid, {}
-            unless @pool.add(sid, session)
-              raise "Session collision on '#{sid.inspect}'"
-            end
-          end
-          [sid, session]
+      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
+          key = memcached_key_from_sid(sid)
+          break sid unless key && client.get(key)
         end
       end
 
-      def set_session(env, session_id, new_session, options)
-        return false unless session_id
-        expiry = options[:expire_after]
-        expiry = expiry.nil? ? 0 : expiry + 1
+      def build_data_source(options)
+        server_configurations, client_options, pool_options = extract_dalli_options(options)
 
-        with_lock(env, false) do
-          @pool.set session_id, new_session, expiry
-          session_id
+        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 destroy_session(env, session_id, options)
-        with_lock(env) do
-          @pool.delete(session_id)
-          generate_sid unless options[:drop]
+      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)
+
+        [server_configurations, client_options, retrieve_pool_options(options)]
+      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 }
+        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_lock(env, default=nil)
-        @mutex.lock if env['rack.multithread']
-        yield
+      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
-      ensure
-        @mutex.unlock if @mutex.locked?
+        result_on_error
       end
 
+      def ttl(expire_after)
+        expire_after.nil? ? 0 : expire_after + 1
+      end
     end
   end
 end

metadata

@@ -1,60 +1,80 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 2.7.6
+  version: 3.2.2
 platform: ruby
 authors:
 - Peter M. Goldstein
 - Mike Perham
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-02-14 00:00:00.000000000 Z
+date: 2022-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: connection_pool
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
 - !ruby/object:Gem::Dependency
-  name: mocha
+  name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        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: '0'
+        version: 2.2.0
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -68,7 +88,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: appraisal
+  name: rubocop-minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -82,7 +102,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: connection_pool
+  name: rubocop-performance
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -96,7 +116,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rdoc
+  name: rubocop-rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -135,42 +155,59 @@ files:
 - History.md
 - LICENSE
 - README.md
-- lib/action_dispatch/middleware/session/dalli_store.rb
-- lib/active_support/cache/dalli_store.rb
 - lib/dalli.rb
 - lib/dalli/cas/client.rb
 - lib/dalli/client.rb
 - lib/dalli/compressor.rb
+- lib/dalli/key_manager.rb
 - lib/dalli/options.rb
-- lib/dalli/railtie.rb
+- lib/dalli/pipelined_getter.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/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/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: {}
-post_install_message: 
-rdoc_options:
-- "--charset=UTF-8"
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5.1
-signing_key: 
+rubygems_version: 3.3.16
+signing_key:
 specification_version: 4
 summary: High performance memcached client for Ruby
 test_files: []

data/lib/action_dispatch/middleware/session/dalli_store.rb

@@ -1,81 +0,0 @@
-require 'active_support/cache'
-require 'action_dispatch/middleware/session/abstract_store'
-require 'dalli'
-
-# Dalli-based session store for Rails 3.0.
-module ActionDispatch
-  module Session
-    class DalliStore < AbstractStore
-      def initialize(app, options = {})
-        # Support old :expires option
-        options[:expire_after] ||= options[:expires]
-
-        super
-
-        @default_options = { :namespace => 'rack:session' }.merge(@default_options)
-
-        @pool = options[:cache] || begin
-          Dalli::Client.new(
-              @default_options[:memcache_server], @default_options)
-        end
-        @namespace = @default_options[:namespace]
-
-        @raise_errors = !!@default_options[:raise_errors]
-
-        super
-      end
-
-      def reset
-        @pool.reset
-      end
-
-      private
-
-      def get_session(env, sid)
-        sid = generate_sid unless sid and !sid.empty?
-        begin
-          session = @pool.get(sid) || {}
-        rescue Dalli::DalliError => ex
-          # re-raise ArgumentError so Rails' session abstract_store.rb can autoload any missing models
-          raise ArgumentError, ex.message if ex.message =~ /unmarshal/
-          Rails.logger.warn("Session::DalliStore#get: #{ex.message}")
-          session = {}
-        end
-        [sid, session]
-      end
-
-      def set_session(env, sid, session_data, options = nil)
-        options ||= env[ENV_SESSION_OPTIONS_KEY]
-        expiry  = options[:expire_after]
-        @pool.set(sid, session_data, expiry)
-        sid
-      rescue Dalli::DalliError
-        Rails.logger.warn("Session::DalliStore#set: #{$!.message}")
-        raise if @raise_errors
-        false
-      end
-
-      def destroy_session(env, session_id, options)
-        begin
-          @pool.delete(session_id)
-        rescue Dalli::DalliError
-          Rails.logger.warn("Session::DalliStore#destroy_session: #{$!.message}")
-          raise if @raise_errors
-        end
-        return nil if options[:drop]
-        generate_sid
-      end
-
-      def destroy(env)
-        if sid = current_session_id(env)
-          @pool.delete(sid)
-        end
-      rescue Dalli::DalliError
-        Rails.logger.warn("Session::DalliStore#destroy: #{$!.message}")
-        raise if @raise_errors
-        false
-      end
-
-    end
-  end
-end