dalli 3.1.0 → 3.1.1

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

@@ -20,18 +20,21 @@ module Dalli
 
       # Attempts to process a single response from the buffer.  Starts
       # by advancing the buffer to the specified start position
-      def process_single_response(start_position = 0)
-        advance(start_position)
-        @response_processor.getk_response_from_buffer(@buffer)
+      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,
+      # Resets the internal buffer to an empty state,
       # so that we're ready to read pipelined responses
       def reset
         @buffer = +''
@@ -42,8 +45,8 @@ module Dalli
         @buffer = nil
       end
 
-      def completed?
-        @buffer.nil?
+      def in_progress?
+        !@buffer.nil?
       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/version.rb

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

data/lib/dalli.rb

@@ -31,7 +31,7 @@ module Dalli
   class NilObject; end # rubocop:disable Lint/EmptyClass
   NOT_FOUND = NilObject.new
 
-  MULTI_KEY = :dalli_multi
+  QUIET = :dalli_multi
 
   def self.logger
     @logger ||= (rails_logger || default_logger)
@@ -63,6 +63,7 @@ require_relative 'dalli/pipelined_getter'
 require_relative 'dalli/ring'
 require_relative 'dalli/protocol'
 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'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.1.1
 platform: ruby
 authors:
 - Peter M. Goldstein
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-03 00:00:00.000000000 Z
+date: 2021-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: connection_pool
@@ -126,6 +126,7 @@ files:
 - 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/response_buffer.rb
 - lib/dalli/protocol/server_config_parser.rb
 - lib/dalli/protocol/ttl_sanitizer.rb
@@ -158,7 +159,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.31
+rubygems_version: 3.2.33
 signing_key:
 specification_version: 4
 summary: High performance memcached client for Ruby