dalli 3.1.0 → 3.1.1

data/lib/dalli/protocol/binary.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'English'
 require 'forwardable'
 require 'socket'
 require 'timeout'
@@ -20,62 +19,30 @@ module Dalli
     class Binary
       extend Forwardable
 
-      attr_accessor :hostname, :port, :weight, :options
-      attr_reader :sock, :socket_type
+      attr_accessor :weight, :options
 
       def_delegators :@value_marshaller, :serializer, :compressor, :compression_min_size, :compress_by_default?
+      def_delegators :@connection_manager, :name, :sock, :hostname, :port, :close, :connected?, :socket_timeout,
+                     :socket_type, :up!, :down!, :write, :reconnect_down_server?, :raise_down_error
 
-      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
-      }.freeze
-
-      def initialize(attribs, options = {})
-        @hostname, @port, @weight, @socket_type, options = ServerConfigParser.parse(attribs, options)
-        @options = DEFAULTS.merge(options)
+      def initialize(attribs, client_options = {})
+        hostname, port, socket_type, @weight, user_creds = ServerConfigParser.parse(attribs)
+        @options = client_options.merge(user_creds)
         @value_marshaller = ValueMarshaller.new(@options)
-        @response_processor = ResponseProcessor.new(self, @value_marshaller)
-        @response_buffer = ResponseBuffer.new(self, @response_processor)
-
-        reset_down_info
-        @sock = nil
-        @pid = nil
-        @request_in_progress = false
-      end
-
-      def response_buffer
-        @response_buffer ||= ResponseBuffer.new(self, @response_processor)
-      end
-
-      def name
-        if socket_type == :unix
-          hostname
-        else
-          "#{hostname}:#{port}"
-        end
+        @connection_manager = ConnectionManager.new(hostname, port, socket_type, @options)
+        @response_processor = ResponseProcessor.new(@connection_manager, @value_marshaller)
       end
 
       # Chokepoint method for error handling and ensuring liveness
       def request(opkey, *args)
         verify_state(opkey)
-        # The alive? call has the side effect of connecting the underlying
-        # socket if it is not connected, or there's been a disconnect
-        # because of timeout or other error.  Method raises an error
-        # if it can't connect
-        raise_memcached_down_err unless alive?
 
         begin
           send(opkey, *args)
         rescue Dalli::MarshalError => e
-          log_marshall_err(args.first, e)
+          log_marshal_err(args.first, e)
           raise
-        rescue Dalli::DalliError, Dalli::NetworkError, Dalli::ValueOverMaxSize, Timeout::Error
+        rescue Dalli::DalliError
           raise
         rescue StandardError => e
           log_unexpected_err(e)
@@ -83,63 +50,17 @@ module Dalli
         end
       end
 
-      def raise_memcached_down_err
-        raise Dalli::NetworkError,
-              "#{name} is down: #{@error} #{@msg}. If you are sure it is running, "\
-              "ensure memcached version is > #{::Dalli::MIN_SUPPORTED_MEMCACHED_VERSION}."
-      end
-
-      def log_marshall_err(key, err)
-        Dalli.logger.error "Marshalling error for key '#{key}': #{err.message}"
-        Dalli.logger.error 'You are trying to cache a Ruby object which cannot be serialized to memcached.'
-      end
-
-      def log_unexpected_err(err)
-        Dalli.logger.error "Unexpected exception during Dalli request: #{err.class.name}: #{err.message}"
-        Dalli.logger.error err.backtrace.join("\n\t")
-      end
-
-      # The socket connection to the underlying server is initialized as a side
-      # effect of this call.  In fact, this is the ONLY place where that
-      # socket connection is initialized.
+      ##
+      # Boolean method used by clients of this class to determine if this
+      # particular memcached instance is available for use.
       def alive?
-        return true if @sock
-        return false unless reconnect_down_server?
-
-        connect
-        !!@sock
+        ensure_connected!
       rescue Dalli::NetworkError
+        # ensure_connected! raises a NetworkError if connection fails.  We
+        # want to capture that error and convert it to a boolean value here.
         false
       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
-
-      # Closes the underlying socket and cleans up
-      # socket state.
-      def close
-        return unless @sock
-
-        begin
-          @sock.close
-        rescue StandardError
-          nil
-        end
-        @sock = nil
-        @pid = nil
-        abort_request!
-      end
-
       def lock!; end
 
       def unlock!; end
@@ -149,224 +70,125 @@ module Dalli
       # flushing responses for kv pairs that were found.
       #
       # Returns nothing.
-      def pipeline_response_start
+      def pipeline_response_setup
         verify_state(:getkq)
         write_noop
         response_buffer.reset
-        start_request!
-      end
-
-      # Did the last call to #pipeline_response_start complete successfully?
-      def pipeline_response_completed?
-        response_buffer.completed?
-      end
-
-      def pipeline_response(bytes_to_advance = 0)
-        response_buffer.process_single_response(bytes_to_advance)
-      end
-
-      def reconnect_on_pipeline_complete!
-        reconnect! 'multi_response has completed' if pipeline_response_completed?
+        @connection_manager.start_request!
       end
 
       # Attempt to receive and parse as many key/value pairs as possible
-      # from this server. After #pipeline_response_start, this should be invoked
+      # from this server. After #pipeline_response_setup, this should be invoked
       # repeatedly whenever this server's socket is readable until
-      # #pipeline_response_completed?.
+      # #pipeline_complete?.
       #
       # Returns a Hash of kv pairs received.
-      def process_outstanding_pipeline_requests
+      def pipeline_next_responses
         reconnect_on_pipeline_complete!
         values = {}
 
         response_buffer.read
 
-        bytes_to_advance, status, key, value, cas = pipeline_response
-        # Loop while we have at least a complete header in the buffer
-        while bytes_to_advance.positive?
-          # If the status and key length are both zero, then this is the response
+        resp_header, key, value = pipeline_response
+        # resp_header is not nil only if we have a full response to parse
+        # in the buffer
+        while resp_header
+          # If the status is ok and key is nil, then this is the response
           # to the noop at the end of the pipeline
-          if status.zero? && key.nil?
-            finish_pipeline
-            break
-          end
+          finish_pipeline && break if resp_header.ok? && key.nil?
 
-          # If the status is zero and the key len is positive, then this is a
+          # If the status is ok and the key is not nil, then this is a
           # getkq response with a value that we want to set in the response hash
-          values[key] = [value, cas] unless key.nil?
+          values[key] = [value, resp_header.cas] unless key.nil?
 
-          # Get the next set of bytes from the buffer
-          bytes_to_advance, status, key, value, cas = pipeline_response(bytes_to_advance)
+          # Get the next response from the buffer
+          resp_header, key, value = pipeline_response
         end
 
         values
       rescue SystemCallError, Timeout::Error, EOFError => e
-        failure!(e)
-      end
-
-      def read_nonblock
-        @sock.read_available
-      end
-
-      # Called after the noop response is received at the end of a set
-      # of pipelined gets
-      def finish_pipeline
-        response_buffer.clear
-        finish_request!
+        @connection_manager.error_on_request!(e)
       end
 
-      # Abort an earlier #pipeline_response_start. Used to signal an external
-      # timeout. The underlying socket is disconnected, and the exception is
-      # swallowed.
+      # Abort current pipelined get. Generally used to signal an external
+      # timeout during pipelined get.  The underlying socket is
+      # disconnected, and the exception is swallowed.
       #
       # Returns nothing.
-      def pipeline_response_abort
+      def pipeline_abort
         response_buffer.clear
-        abort_request!
-        return true unless @sock
+        @connection_manager.abort_request!
+        return true unless connected?
 
-        failure!(RuntimeError.new('External timeout'))
+        # Closes the connection, which ensures that our connection
+        # is in a clean state for future requests
+        @connection_manager.error_on_request!('External timeout')
       rescue NetworkError
         true
       end
 
-      def read(count)
-        start_request!
-        data = @sock.readfull(count)
-        finish_request!
-        data
-      rescue SystemCallError, Timeout::Error, EOFError => e
-        failure!(e)
+      # Did the last call to #pipeline_response_setup complete successfully?
+      def pipeline_complete?
+        !response_buffer.in_progress?
       end
 
-      def write(bytes)
-        start_request!
-        result = @sock.write(bytes)
-        finish_request!
-        result
-      rescue SystemCallError, Timeout::Error => e
-        failure!(e)
+      def username
+        @options[:username] || ENV['MEMCACHE_USERNAME']
       end
 
-      def connected?
-        !@sock.nil?
+      def password
+        @options[:password] || ENV['MEMCACHE_PASSWORD']
       end
 
-      def socket_timeout
-        @socket_timeout ||= @options[:socket_timeout]
+      def require_auth?
+        !username.nil?
       end
 
       # NOTE: Additional public methods should be overridden in Dalli::Threadsafe
 
       private
 
-      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
-
+      ##
+      # Checks to see if we can execute the specified operation.  Checks
+      # whether the connection is in use, and whether the command is allowed
+      ##
       def verify_state(opkey)
-        failure!(RuntimeError.new('Already writing to socket')) if request_in_progress?
-        reconnect_on_fork if fork_detected?
-        verify_allowed_multi!(opkey) if multi?
-      end
-
-      def fork_detected?
-        @pid && @pid != Process.pid
-      end
-
-      ALLOWED_MULTI_OPS = %i[add addq delete deleteq replace replaceq set setq noop].freeze
-      def verify_allowed_multi!(opkey)
-        return if ALLOWED_MULTI_OPS.include?(opkey)
-
-        raise Dalli::NotPermittedMultiOpError, "The operation #{opkey} is not allowed in a multi block."
-      end
-
-      def reconnect_on_fork
-        message = 'Fork detected, re-connecting child process...'
-        Dalli.logger.info { message }
-        reconnect! message
-      end
-
-      # Marks the server instance as needing reconnect.  Raises a
-      # Dalli::NetworkError with the specified message.  Calls close
-      # to clean up socket state
-      def reconnect!(message)
-        close
-        sleep(options[:socket_failure_delay]) if options[:socket_failure_delay]
-        raise Dalli::NetworkError, message
-      end
-
-      # Raises Dalli::NetworkError
-      def failure!(exception)
-        message = "#{name} failed (count: #{@fail_count}) #{exception.class}: #{exception.message}"
-        Dalli.logger.warn { message }
-
-        @fail_count += 1
-        if @fail_count >= options[:socket_max_failures]
-          down!
-        else
-          reconnect! 'Socket operation failed, retrying...'
-        end
-      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
+        @connection_manager.confirm_ready!
+        verify_allowed_quiet!(opkey) if quiet?
 
-        @error = $ERROR_INFO&.class&.name
-        @msg ||= $ERROR_INFO&.message
-        raise Dalli::NetworkError, "#{name} is down: #{@error} #{@msg}"
-      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
+        # The ensure_connected call has the side effect of connecting the
+        # underlying socket if it is not connected, or there's been a disconnect
+        # because of timeout or other error.  Method raises an error
+        # if it can't connect
+        raise_down_error unless ensure_connected!
       end
 
-      def log_up_detected
-        return unless @down_at
+      # The socket connection to the underlying server is initialized as a side
+      # effect of this call.  In fact, this is the ONLY place where that
+      # socket connection is initialized.
+      #
+      # Both this method and connect need to be in this class so we can do auth
+      # as required
+      #
+      # Since this is invoked exclusively in verify_state!, we don't need to worry about
+      # thread safety.  Using it elsewhere may require revisiting that assumption.
+      def ensure_connected!
+        return true if connected?
+        return false unless reconnect_down_server?
 
-        time = Time.now - @down_at
-        Dalli.logger.warn { format('%<name>s is back (downtime was %<time>.3f seconds)', name: name, time: time) }
+        connect # This call needs to be in this class so we can do auth
+        connected?
       end
 
-      def up!
-        log_up_detected
-        reset_down_info
-      end
+      ALLOWED_QUIET_OPS = %i[add replace set delete incr decr append prepend flush noop].freeze
+      def verify_allowed_quiet!(opkey)
+        return if ALLOWED_QUIET_OPS.include?(opkey)
 
-      def reset_down_info
-        @fail_count = 0
-        @down_at = nil
-        @last_down_at = nil
-        @msg = nil
-        @error = nil
+        raise Dalli::NotPermittedMultiOpError, "The operation #{opkey} is not allowed in a quiet block."
       end
 
-      def multi?
-        Thread.current[::Dalli::MULTI_KEY]
+      def quiet?
+        Thread.current[::Dalli::QUIET]
       end
 
       def cache_nils?(opts)
@@ -375,39 +197,52 @@ module Dalli
         opts[:cache_nils] ? true : false
       end
 
+      # Retrieval Commands
       def get(key, options = nil)
         req = RequestFormatter.standard_request(opkey: :get, key: key)
         write(req)
         @response_processor.generic_response(unpack: true, cache_nils: cache_nils?(options))
       end
 
-      def pipelined_get(keys)
-        req = +''
-        keys.each do |key|
-          req << RequestFormatter.standard_request(opkey: :getkq, key: key)
-        end
-        # Could send noop here instead of in pipeline_response_start
+      def gat(key, ttl, options = nil)
+        ttl = TtlSanitizer.sanitize(ttl)
+        req = RequestFormatter.standard_request(opkey: :gat, key: key, ttl: ttl)
         write(req)
+        @response_processor.generic_response(unpack: true, cache_nils: cache_nils?(options))
       end
 
+      def touch(key, ttl)
+        ttl = TtlSanitizer.sanitize(ttl)
+        write(RequestFormatter.standard_request(opkey: :touch, key: key, ttl: ttl))
+        @response_processor.generic_response
+      end
+
+      # TODO: This is confusing, as there's a cas command in memcached
+      # and this isn't it.  Maybe rename?  Maybe eliminate?
+      def cas(key)
+        req = RequestFormatter.standard_request(opkey: :get, key: key)
+        write(req)
+        @response_processor.data_cas_response
+      end
+
+      # Storage Commands
       def set(key, value, ttl, cas, options)
-        opkey = multi? ? :setq : :set
-        process_value_req(opkey, key, value, ttl, cas, options)
+        opkey = quiet? ? :setq : :set
+        storage_req(opkey, key, value, ttl, cas, options)
       end
 
       def add(key, value, ttl, options)
-        opkey = multi? ? :addq : :add
-        cas = 0
-        process_value_req(opkey, key, value, ttl, cas, options)
+        opkey = quiet? ? :addq : :add
+        storage_req(opkey, key, value, ttl, 0, options)
       end
 
       def replace(key, value, ttl, cas, options)
-        opkey = multi? ? :replaceq : :replace
-        process_value_req(opkey, key, value, ttl, cas, options)
+        opkey = quiet? ? :replaceq : :replace
+        storage_req(opkey, key, value, ttl, cas, options)
       end
 
       # rubocop:disable Metrics/ParameterLists
-      def process_value_req(opkey, key, value, ttl, cas, options)
+      def storage_req(opkey, key, value, ttl, cas, options)
         (value, bitflags) = @value_marshaller.store(key, value, options)
         ttl = TtlSanitizer.sanitize(ttl)
 
@@ -415,21 +250,42 @@ module Dalli
                                                 value: value, bitflags: bitflags,
                                                 ttl: ttl, cas: cas)
         write(req)
-        @response_processor.cas_response unless multi?
+        @response_processor.storage_response unless quiet?
       end
       # rubocop:enable Metrics/ParameterLists
 
+      def append(key, value)
+        opkey = quiet? ? :appendq : :append
+        write_append_prepend opkey, key, value
+      end
+
+      def prepend(key, value)
+        opkey = quiet? ? :prependq : :prepend
+        write_append_prepend opkey, key, value
+      end
+
+      def write_append_prepend(opkey, key, value)
+        write(RequestFormatter.standard_request(opkey: opkey, key: key, value: value))
+        @response_processor.no_body_response unless quiet?
+      end
+
+      # Delete Commands
       def delete(key, cas)
-        opkey = multi? ? :deleteq : :delete
+        opkey = quiet? ? :deleteq : :delete
         req = RequestFormatter.standard_request(opkey: opkey, key: key, cas: cas)
         write(req)
-        @response_processor.generic_response unless multi?
+        @response_processor.no_body_response unless quiet?
       end
 
-      def flush(ttl = 0)
-        req = RequestFormatter.standard_request(opkey: :flush, ttl: ttl)
-        write(req)
-        @response_processor.generic_response
+      # Arithmetic Commands
+      def decr(key, count, ttl, initial)
+        opkey = quiet? ? :decrq : :decr
+        decr_incr opkey, key, count, ttl, initial
+      end
+
+      def incr(key, count, ttl, initial)
+        opkey = quiet? ? :incrq : :incr
+        decr_incr opkey, key, count, ttl, initial
       end
 
       # This allows us to special case a nil initial value, and
@@ -444,29 +300,14 @@ module Dalli
         initial ||= 0
         write(RequestFormatter.decr_incr_request(opkey: opkey, key: key,
                                                  count: count, initial: initial, expiry: expiry))
-        @response_processor.decr_incr_response
+        @response_processor.decr_incr_response unless quiet?
       end
 
-      def decr(key, count, ttl, initial)
-        decr_incr :decr, key, count, ttl, initial
-      end
-
-      def incr(key, count, ttl, initial)
-        decr_incr :incr, key, count, ttl, initial
-      end
-
-      def write_append_prepend(opkey, key, value)
-        write_generic RequestFormatter.standard_request(opkey: opkey, key: key, value: value)
-      end
-
-      def write_generic(bytes)
-        write(bytes)
-        @response_processor.generic_response
-      end
-
-      def write_noop
-        req = RequestFormatter.standard_request(opkey: :noop)
-        write(req)
+      # Other Commands
+      def flush(ttl = 0)
+        opkey = quiet? ? :flushq : :flush
+        write(RequestFormatter.standard_request(opkey: opkey, ttl: ttl))
+        @response_processor.no_body_response unless quiet?
       end
 
       # Noop is a keepalive operation but also used to demarcate the end of a set of pipelined commands.
@@ -476,14 +317,6 @@ module Dalli
         @response_processor.multi_with_keys_response
       end
 
-      def append(key, value)
-        write_append_prepend :append, key, value
-      end
-
-      def prepend(key, value)
-        write_append_prepend :prepend, key, value
-      end
-
       def stats(info = '')
         req = RequestFormatter.standard_request(opkey: :stat, key: info)
         write(req)
@@ -491,66 +324,67 @@ module Dalli
       end
 
       def reset_stats
-        write_generic RequestFormatter.standard_request(opkey: :stat, key: 'reset')
+        write(RequestFormatter.standard_request(opkey: :stat, key: 'reset'))
+        @response_processor.generic_response
       end
 
-      def cas(key)
-        req = RequestFormatter.standard_request(opkey: :get, key: key)
-        write(req)
-        @response_processor.data_cas_response
+      def version
+        write(RequestFormatter.standard_request(opkey: :version))
+        @response_processor.generic_response
       end
 
-      def version
-        write_generic RequestFormatter.standard_request(opkey: :version)
+      def write_noop
+        req = RequestFormatter.standard_request(opkey: :noop)
+        write(req)
       end
 
-      def touch(key, ttl)
-        ttl = TtlSanitizer.sanitize(ttl)
-        write_generic RequestFormatter.standard_request(opkey: :touch, key: key, ttl: ttl)
+      def connect
+        @connection_manager.establish_connection
+        authenticate_connection if require_auth?
+        @version = version # Connect socket if not authed
+        up!
+      rescue Dalli::DalliError
+        raise
       end
 
-      def gat(key, ttl, options = nil)
-        ttl = TtlSanitizer.sanitize(ttl)
-        req = RequestFormatter.standard_request(opkey: :gat, key: key, ttl: ttl)
+      def pipelined_get(keys)
+        req = +''
+        keys.each do |key|
+          req << RequestFormatter.standard_request(opkey: :getkq, key: key)
+        end
+        # Could send noop here instead of in pipeline_response_setup
         write(req)
-        @response_processor.generic_response(unpack: true, cache_nils: cache_nils?(options))
       end
 
-      def connect
-        Dalli.logger.debug { "Dalli::Server#connect #{name}" }
+      def response_buffer
+        @response_buffer ||= ResponseBuffer.new(@connection_manager, @response_processor)
+      end
 
-        begin
-          @pid = Process.pid
-          @sock = memcached_socket
-          authenticate_connection if require_auth?
-          @version = version # Connect socket if not authed
-          up!
-        rescue Dalli::DalliError # SASL auth failure
-          raise
-        rescue SystemCallError, Timeout::Error, EOFError, SocketError => e
-          # SocketError = DNS resolution failure
-          failure!(e)
-        end
+      def pipeline_response
+        response_buffer.process_single_getk_response
       end
 
-      def memcached_socket
-        if socket_type == :unix
-          Dalli::Socket::UNIX.open(hostname, options)
-        else
-          Dalli::Socket::TCP.open(hostname, port, options)
-        end
+      # Called after the noop response is received at the end of a set
+      # of pipelined gets
+      def finish_pipeline
+        response_buffer.clear
+        @connection_manager.finish_request!
+
+        true # to simplify response
       end
 
-      def require_auth?
-        !username.nil?
+      def reconnect_on_pipeline_complete!
+        @connection_manager.reconnect! 'pipelined get has completed' if pipeline_complete?
       end
 
-      def username
-        @options[:username] || ENV['MEMCACHE_USERNAME']
+      def log_marshal_err(key, err)
+        Dalli.logger.error "Marshalling error for key '#{key}': #{err.message}"
+        Dalli.logger.error 'You are trying to cache a Ruby object which cannot be serialized to memcached.'
       end
 
-      def password
-        @options[:password] || ENV['MEMCACHE_PASSWORD']
+      def log_unexpected_err(err)
+        Dalli.logger.error "Unexpected exception during Dalli request: #{err.class.name}: #{err.message}"
+        Dalli.logger.error err.backtrace.join("\n\t")
       end
 
       include SaslAuthentication