dalli 3.0.6 → 3.1.3

data/lib/dalli/protocol/connection_manager.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require 'English'
+require 'socket'
+require 'timeout'
+
+module Dalli
+  module Protocol
+    ##
+    # Manages the socket connection to the server, including ensuring liveness
+    # and retries.
+    ##
+    class ConnectionManager
+      DEFAULTS = {
+        # seconds between trying to contact a remote server
+        down_retry_delay: 30,
+        # connect/read/write timeout for socket operations
+        socket_timeout: 1,
+        # times a socket operation may fail before considering the server dead
+        socket_max_failures: 2,
+        # amount of time to sleep between retries when a failure occurs
+        socket_failure_delay: 0.1,
+        # Set keepalive
+        keepalive: true
+      }.freeze
+
+      attr_accessor :hostname, :port, :socket_type, :options
+      attr_reader :sock
+
+      def initialize(hostname, port, socket_type, client_options)
+        @hostname = hostname
+        @port = port
+        @socket_type = socket_type
+        @options = DEFAULTS.merge(client_options)
+        @request_in_progress = false
+        @sock = nil
+        @pid = nil
+
+        reset_down_info
+      end
+
+      def name
+        if socket_type == :unix
+          hostname
+        else
+          "#{hostname}:#{port}"
+        end
+      end
+
+      def establish_connection
+        Dalli.logger.debug { "Dalli::Server#connect #{name}" }
+
+        @sock = memcached_socket
+        @pid = Process.pid
+      rescue SystemCallError, Timeout::Error, EOFError, SocketError => e
+        # SocketError = DNS resolution failure
+        error_on_request!(e)
+      end
+
+      def reconnect_down_server?
+        return true unless @last_down_at
+
+        time_to_next_reconnect = @last_down_at + options[:down_retry_delay] - Time.now
+        return true unless time_to_next_reconnect.positive?
+
+        Dalli.logger.debug do
+          format('down_retry_delay not reached for %<name>s (%<time>.3f seconds left)', name: name,
+                                                                                        time: time_to_next_reconnect)
+        end
+        false
+      end
+
+      def up!
+        log_up_detected
+        reset_down_info
+      end
+
+      # Marks the server instance as down.  Updates the down_at state
+      # and raises an Dalli::NetworkError that includes the underlying
+      # error in the message.  Calls close to clean up socket state
+      def down!
+        close
+        log_down_detected
+
+        @error = $ERROR_INFO&.class&.name
+        @msg ||= $ERROR_INFO&.message
+        raise_down_error
+      end
+
+      def raise_down_error
+        raise Dalli::NetworkError, "#{name} is down: #{@error} #{@msg}"
+      end
+
+      def socket_timeout
+        @socket_timeout ||= @options[:socket_timeout]
+      end
+
+      def confirm_ready!
+        error_on_request!(RuntimeError.new('Already writing to socket')) if request_in_progress?
+        close_on_fork if fork_detected?
+      end
+
+      def close
+        return unless @sock
+
+        begin
+          @sock.close
+        rescue StandardError
+          nil
+        end
+        @sock = nil
+        @pid = nil
+        abort_request!
+      end
+
+      def connected?
+        !@sock.nil?
+      end
+
+      def request_in_progress?
+        @request_in_progress
+      end
+
+      def start_request!
+        @request_in_progress = true
+      end
+
+      def finish_request!
+        @request_in_progress = false
+      end
+
+      def abort_request!
+        @request_in_progress = false
+      end
+
+      def read(count)
+        start_request!
+        data = @sock.readfull(count)
+        finish_request!
+        data
+      rescue SystemCallError, Timeout::Error, EOFError => e
+        error_on_request!(e)
+      end
+
+      def write(bytes)
+        start_request!
+        result = @sock.write(bytes)
+        finish_request!
+        result
+      rescue SystemCallError, Timeout::Error => e
+        error_on_request!(e)
+      end
+
+      # Non-blocking read.  Should only be used in the context
+      # of a caller who has called start_request!, but not yet
+      # called finish_request!.  Here to support the operation
+      # of the get_multi operation
+      def read_nonblock
+        @sock.read_available
+      end
+
+      def max_allowed_failures
+        @max_allowed_failures ||= @options[:socket_max_failures] || 2
+      end
+
+      def error_on_request!(err_or_string)
+        log_warn_message(err_or_string)
+
+        @fail_count += 1
+        if @fail_count >= max_allowed_failures
+          down!
+        else
+          # Closes the existing socket, setting up for a reconnect
+          # on next request
+          reconnect!('Socket operation failed, retrying...')
+        end
+      end
+
+      def reconnect!(message)
+        close
+        sleep(options[:socket_failure_delay]) if options[:socket_failure_delay]
+        raise Dalli::NetworkError, message
+      end
+
+      def reset_down_info
+        @fail_count = 0
+        @down_at = nil
+        @last_down_at = nil
+        @msg = nil
+        @error = nil
+      end
+
+      def memcached_socket
+        if socket_type == :unix
+          Dalli::Socket::UNIX.open(hostname, options)
+        else
+          Dalli::Socket::TCP.open(hostname, port, options)
+        end
+      end
+
+      def log_warn_message(err_or_string)
+        detail = err_or_string.is_a?(String) ? err_or_string : "#{err_or_string.class}: #{err_or_string.message}"
+        Dalli.logger.warn do
+          detail = err_or_string.is_a?(String) ? err_or_string : "#{err_or_string.class}: #{err_or_string.message}"
+          "#{name} failed (count: #{@fail_count}) #{detail}"
+        end
+      end
+
+      def close_on_fork
+        message = 'Fork detected, re-connecting child process...'
+        Dalli.logger.info { message }
+        # Close socket on a fork, setting us up for reconnect
+        # on next request.
+        close
+        raise Dalli::NetworkError, message
+      end
+
+      def fork_detected?
+        @pid && @pid != Process.pid
+      end
+
+      def log_down_detected
+        @last_down_at = Time.now
+
+        if @down_at
+          time = Time.now - @down_at
+          Dalli.logger.debug { format('%<name>s is still down (for %<time>.3f seconds now)', name: name, time: time) }
+        else
+          @down_at = @last_down_at
+          Dalli.logger.warn("#{name} is down")
+        end
+      end
+
+      def log_up_detected
+        return unless @down_at
+
+        time = Time.now - @down_at
+        Dalli.logger.warn { format('%<name>s is back (downtime was %<time>.3f seconds)', name: name, time: time) }
+      end
+    end
+  end
+end

data/lib/dalli/protocol/response_buffer.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'timeout'
+
+module Dalli
+  module Protocol
+    ##
+    # Manages the buffer for responses from memcached.
+    ##
+    class ResponseBuffer
+      def initialize(io_source, response_processor)
+        @io_source = io_source
+        @response_processor = response_processor
+      end
+
+      def read
+        @buffer << @io_source.read_nonblock
+      end
+
+      # Attempts to process a single response from the buffer.  Starts
+      # by advancing the buffer to the specified start position
+      def process_single_getk_response
+        bytes, resp_header, key, value = @response_processor.getk_response_from_buffer(@buffer)
+        advance(bytes)
+        [resp_header, key, value]
+      end
+
+      # Advances the internal response buffer by bytes_to_advance
+      # bytes.  The
+      def advance(bytes_to_advance)
+        return unless bytes_to_advance.positive?
+
+        @buffer = @buffer[bytes_to_advance..-1]
+      end
+
+      # Resets the internal buffer to an empty state,
+      # so that we're ready to read pipelined responses
+      def reset
+        @buffer = +''
+      end
+
+      # Clear the internal response buffer
+      def clear
+        @buffer = nil
+      end
+
+      def in_progress?
+        !@buffer.nil?
+      end
+    end
+  end
+end

data/lib/dalli/protocol/server_config_parser.rb

@@ -19,22 +19,22 @@ module Dalli
       DEFAULT_PORT = 11_211
       DEFAULT_WEIGHT = 1
 
-      def self.parse(str, client_options)
-        return parse_non_uri(str, client_options) unless str.start_with?(MEMCACHED_URI_PROTOCOL)
+      def self.parse(str)
+        return parse_non_uri(str) unless str.start_with?(MEMCACHED_URI_PROTOCOL)
 
-        parse_uri(str, client_options)
+        parse_uri(str)
       end
 
-      def self.parse_uri(str, client_options)
+      def self.parse_uri(str)
         uri = URI.parse(str)
         auth_details = {
           username: uri.user,
           password: uri.password
         }
-        [uri.host, normalize_port(uri.port), DEFAULT_WEIGHT, :tcp, client_options.merge(auth_details)]
+        [uri.host, normalize_port(uri.port), :tcp, DEFAULT_WEIGHT, auth_details]
       end
 
-      def self.parse_non_uri(str, client_options)
+      def self.parse_non_uri(str)
         res = deconstruct_string(str)
 
         hostname = normalize_host_from_match(str, res)
@@ -45,7 +45,7 @@ module Dalli
           socket_type = :tcp
           port, weight = attributes_for_tcp_socket(res)
         end
-        [hostname, port, weight, socket_type, client_options]
+        [hostname, port, socket_type, weight, {}]
       end
 
       def self.deconstruct_string(str)

data/lib/dalli/ring.rb

@@ -79,7 +79,7 @@ module Dalli
       end
     end
 
-    def flush_multi_responses
+    def pipeline_consume_and_ignore_responses
       @servers.each do |s|
         s.request(:noop)
       rescue Dalli::NetworkError
@@ -92,6 +92,10 @@ module Dalli
       @servers.first.socket_timeout
     end
 
+    def close
+      @servers.each(&:close)
+    end
+
     private
 
     def threadsafe!

data/lib/dalli/socket.rb

@@ -85,13 +85,13 @@ module Dalli
     ##
     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
           init_socket_options(sock, options)
 
           options[:ssl_context] ? wrapping_ssl_socket(sock, host, options[:ssl_context]) : sock
@@ -132,13 +132,15 @@ module Dalli
       ##
       class UNIX < UNIXSocket
         include Dalli::Socket::InstanceMethods
-        attr_accessor :options, :server
 
-        def self.open(path, server, options = {})
+        # 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.server = server
             sock
           end
         end

data/lib/dalli/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Dalli
-  VERSION = '3.0.6'
+  VERSION = '3.1.3'
 
   MIN_SUPPORTED_MEMCACHED_VERSION = '1.4'
 end

data/lib/dalli.rb

@@ -24,10 +24,15 @@ module Dalli
   # 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
 
+  QUIET = :dalli_multi
+
   def self.logger
     @logger ||= (rails_logger || default_logger)
   end
@@ -54,9 +59,13 @@ 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/base'
 require_relative 'dalli/protocol/binary'
+require_relative 'dalli/protocol/connection_manager'
+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'

data/lib/rack/session/dalli.rb

@@ -8,14 +8,13 @@ require 'English'
 module Rack
   module Session
     # Rack::Session::Dalli provides memcached based session management.
-    class Dalli < Abstract::Persisted
-      attr_reader :pool
+    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
 
@@ -33,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.
+      # 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'.
       #
-      # 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".
-      #
-      # 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
@@ -78,87 +66,108 @@ module Rack
         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 && !sid.empty? && (session = dc.get(sid))
-            old_sid = sid
-            sid = generate_sid_with(dc)
-            session = {}
-            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 build_data_source(options)
+        server_configurations, client_options, pool_options = extract_dalli_options(options)
+
+        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]
 
-        # Filter out Rack::Session-specific options and apply our defaults
+        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 }
-        mopts = DEFAULT_DALLI_OPTIONS.merge(filtered_opts)
-        mserv = mopts.delete :memcache_server
-
-        popts = {}
-        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
-        end
-
-        [mserv, mopts, popts]
+        DEFAULT_DALLI_OPTIONS.merge(filtered_opts)
       end
 
-      def generate_sid_with(client)
-        loop do
-          sid = generate_sid
-          break sid unless client.get(sid)
+      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 /undefined class/.match?($ERROR_INFO.message)
 
@@ -166,7 +175,7 @@ module Rack
           warn "#{self} is unable to find memcached server."
           warn $ERROR_INFO.inspect
         end
-        default
+        result_on_error
       end
 
       def ttl(expire_after)