dalli 3.0.1 → 3.0.5

data/lib/dalli/protocol/binary.rb

@@ -1,20 +1,29 @@
 # frozen_string_literal: true
 
-require "socket"
-require "timeout"
+require 'English'
+require 'forwardable'
+require 'socket'
+require 'timeout'
+
+require_relative 'binary/request_formatter'
+require_relative 'binary/response_processor'
+require_relative 'binary/sasl_authentication'
 
 module Dalli
   module Protocol
+    ##
+    # Access point for a single Memcached server, accessed via Memcached's binary
+    # protocol.  Contains logic for managing connection state to the server (retries, etc),
+    # formatting requests to the server, and unpacking responses.
+    ##
     class Binary
-      attr_accessor :hostname
-      attr_accessor :port
-      attr_accessor :weight
-      attr_accessor :options
-      attr_reader :sock
-      attr_reader :socket_type # possible values: :unix, :tcp
-
-      DEFAULT_PORT = 11211
-      DEFAULT_WEIGHT = 1
+      extend Forwardable
+
+      attr_accessor :hostname, :port, :weight, :options
+      attr_reader :sock, :socket_type
+
+      def_delegators :@value_marshaller, :serializer, :compressor, :compression_min_size, :compress_by_default?
+
       DEFAULTS = {
         # seconds between trying to contact a remote server
         down_retry_delay: 30,
@@ -24,33 +33,20 @@ module Dalli
         socket_max_failures: 2,
         # amount of time to sleep between retries when a failure occurs
         socket_failure_delay: 0.1,
-        # max size of value in bytes (default is 1 MB, can be overriden with "memcached -I <size>")
-        value_max_bytes: 1024 * 1024,
-        compress: true,
-        compressor: Compressor,
-        # min byte size to attempt compression
-        compression_min_size: 4 * 1024,
-        serializer: Marshal,
         username: nil,
-        password: nil,
-        keepalive: true,
-        # max byte size for SO_SNDBUF
-        sndbuf: nil,
-        # max byte size for SO_RCVBUF
-        rcvbuf: nil
-      }
+        password: nil
+      }.freeze
 
       def initialize(attribs, options = {})
-        @hostname, @port, @weight, @socket_type = parse_hostname(attribs)
-        @fail_count = 0
-        @down_at = nil
-        @last_down_at = nil
+        @hostname, @port, @weight, @socket_type, options = ServerConfigParser.parse(attribs, options)
         @options = DEFAULTS.merge(options)
+        @value_marshaller = ValueMarshaller.new(@options)
+        @response_processor = ResponseProcessor.new(self, @value_marshaller)
+
+        reset_down_info
         @sock = nil
-        @msg = nil
-        @error = nil
         @pid = nil
-        @inprogress = nil
+        @request_in_progress = false
       end
 
       def name
@@ -61,33 +57,50 @@ module Dalli
         end
       end
 
-      # Chokepoint method for instrumentation
-      def request(op, *args)
+      # Chokepoint method for error handling and ensuring liveness
+      def request(opcode, *args)
         verify_state
-        raise Dalli::NetworkError, "#{name} is down: #{@error} #{@msg}. If you are sure it is running, ensure memcached version is > 1.4." unless alive?
+        # 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(op, *args)
-        rescue Dalli::MarshalError => ex
-          Dalli.logger.error "Marshalling error for key '#{args.first}': #{ex.message}"
-          Dalli.logger.error "You are trying to cache a Ruby object which cannot be serialized to memcached."
+          send(opcode, *args)
+        rescue Dalli::MarshalError => e
+          log_marshall_err(args.first, e)
           raise
         rescue Dalli::DalliError, Dalli::NetworkError, Dalli::ValueOverMaxSize, Timeout::Error
           raise
-        rescue => ex
-          Dalli.logger.error "Unexpected exception during Dalli request: #{ex.class.name}: #{ex.message}"
-          Dalli.logger.error ex.backtrace.join("\n\t")
+        rescue StandardError => e
+          log_unexpected_err(e)
           down!
         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.
       def alive?
         return true if @sock
-
-        if @last_down_at && @last_down_at + options[:down_retry_delay] >= Time.now
-          time = @last_down_at + options[:down_retry_delay] - Time.now
-          Dalli.logger.debug { "down_retry_delay not reached for #{name} (%.3f seconds left)" % time }
-          return false
-        end
+        return false unless reconnect_down_server?
 
         connect
         !!@sock
@@ -95,31 +108,37 @@ module Dalli
         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
+        rescue StandardError
           nil
         end
         @sock = nil
         @pid = nil
-        @inprogress = false
-      end
-
-      def lock!
+        abort_request!
       end
 
-      def unlock!
-      end
+      def lock!; end
 
-      def serializer
-        @options[:serializer]
-      end
-
-      def compressor
-        @options[:compressor]
-      end
+      def unlock!; end
 
       # Start reading key/value pairs from this connection. This is usually called
       # after a series of GETKQ commands. A NOOP is sent, and the server begins
@@ -129,9 +148,9 @@ module Dalli
       def multi_response_start
         verify_state
         write_noop
-        @multi_buffer = +""
+        @multi_buffer = +''
         @position = 0
-        @inprogress = true
+        start_request!
       end
 
       # Did the last call to #multi_response_start complete successfully?
@@ -146,41 +165,39 @@ module Dalli
       #
       # Returns a Hash of kv pairs received.
       def multi_response_nonblock
-        reconnect! "multi_response has completed" if @multi_buffer.nil?
+        reconnect! 'multi_response has completed' if @multi_buffer.nil?
 
         @multi_buffer << @sock.read_available
         buf = @multi_buffer
         pos = @position
         values = {}
 
-        while buf.bytesize - pos >= 24
-          header = buf.slice(pos, 24)
-          (key_length, _, body_length, cas) = header.unpack(KV_HEADER)
+        while buf.bytesize - pos >= ResponseProcessor::RESP_HEADER_SIZE
+          header = buf.slice(pos, ResponseProcessor::RESP_HEADER_SIZE)
+          _, extra_len, key_len, body_len, cas = @response_processor.unpack_header(header)
 
-          if key_length == 0
-            # all done!
-            @multi_buffer = nil
-            @position = nil
-            @inprogress = false
+          # We've reached the noop at the end of the pipeline
+          if key_len.zero?
+            finish_multi_response
             break
+          end
 
-          elsif buf.bytesize - pos >= 24 + body_length
-            flags = buf.slice(pos + 24, 4).unpack1("N")
-            key = buf.slice(pos + 24 + 4, key_length)
-            value = buf.slice(pos + 24 + 4 + key_length, body_length - key_length - 4) if body_length - key_length - 4 > 0
-
-            pos = pos + 24 + body_length
-
-            begin
-              values[key] = [deserialize(value, flags), cas]
-            rescue DalliError
-            end
+          # Break and read more unless we already have the entire response for this header
+          resp_size = ResponseProcessor::RESP_HEADER_SIZE + body_len
+          break unless buf.bytesize - pos >= resp_size
 
-          else
-            # not enough data yet, wait for more
-            break
+          body = buf.slice(pos + ResponseProcessor::RESP_HEADER_SIZE, body_len)
+          begin
+            key, value = @response_processor.unpack_response_body(extra_len, key_len, body, true)
+            values[key] = [value, cas]
+          rescue DalliError
+            # TODO: Determine if we should be swallowing
+            # this error
           end
+
+          pos = pos + ResponseProcessor::RESP_HEADER_SIZE + body_len
         end
+        # TODO: We should be discarding the already processed buffer at this point
         @position = pos
 
         values
@@ -188,6 +205,12 @@ module Dalli
         failure!(e)
       end
 
+      def finish_multi_response
+        @multi_buffer = nil
+        @position = nil
+        finish_request!
+      end
+
       # Abort an earlier #multi_response_start. Used to signal an external
       # timeout. The underlying socket is disconnected, and the exception is
       # swallowed.
@@ -196,31 +219,81 @@ module Dalli
       def multi_response_abort
         @multi_buffer = nil
         @position = nil
-        @inprogress = false
-        failure!(RuntimeError.new("External timeout"))
+        abort_request!
+        return true unless @sock
+
+        failure!(RuntimeError.new('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)
+      end
+
+      def write(bytes)
+        start_request!
+        result = @sock.write(bytes)
+        finish_request!
+        result
+      rescue SystemCallError, Timeout::Error => e
+        failure!(e)
+      end
+
+      def socket_timeout
+        @socket_timeout ||= @options[:socket_timeout]
+      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
+
       def verify_state
-        failure!(RuntimeError.new("Already writing to socket")) if @inprogress
-        if @pid && @pid != Process.pid
-          message = "Fork detected, re-connecting child process..."
-          Dalli.logger.info { message }
-          reconnect! message
-        end
+        failure!(RuntimeError.new('Already writing to socket')) if request_in_progress?
+        reconnect_on_fork if fork_detected?
+      end
+
+      def fork_detected?
+        @pid && @pid != Process.pid
       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 }
@@ -229,34 +302,47 @@ module Dalli
         if @fail_count >= options[:socket_max_failures]
           down!
         else
-          reconnect! "Socket operation failed, retrying..."
+          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
+
+        @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 { "#{name} is still down (for %.3f seconds now)" % time }
+          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" }
+          Dalli.logger.warn("#{name} is down")
         end
+      end
 
-        @error = $!&.class&.name
-        @msg ||= $!&.message
-        raise Dalli::NetworkError, "#{name} is down: #{@error} #{@msg}"
+      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
 
       def up!
-        if @down_at
-          time = Time.now - @down_at
-          Dalli.logger.warn { "#{name} is back (downtime was %.3f seconds)" % time }
-        end
+        log_up_detected
+        reset_down_info
+      end
 
+      def reset_down_info
         @fail_count = 0
         @down_at = nil
         @last_down_at = nil
@@ -268,96 +354,103 @@ module Dalli
         Thread.current[:dalli_multi]
       end
 
+      def cache_nils?(opts)
+        return false unless opts.is_a?(Hash)
+
+        opts[:cache_nils] ? true : false
+      end
+
       def get(key, options = nil)
-        req = [REQUEST, OPCODES[:get], key.bytesize, 0, 0, 0, key.bytesize, 0, 0, key].pack(FORMAT[:get])
+        req = RequestFormatter.standard_request(opkey: :get, key: key)
         write(req)
-        generic_response(true, !!(options && options.is_a?(Hash) && options[:cache_nils]))
+        @response_processor.generic_response(unpack: true, cache_nils: cache_nils?(options))
       end
 
       def send_multiget(keys)
-        req = +""
+        req = +''
         keys.each do |key|
-          req << [REQUEST, OPCODES[:getkq], key.bytesize, 0, 0, 0, key.bytesize, 0, 0, key].pack(FORMAT[:getkq])
+          req << RequestFormatter.standard_request(opkey: :getkq, key: key)
         end
         # Could send noop here instead of in multi_response_start
         write(req)
       end
 
       def set(key, value, ttl, cas, options)
-        (value, flags) = serialize(key, value, options)
-        ttl = sanitize_ttl(ttl)
-
-        guard_max_value(key, value)
-
-        req = [REQUEST, OPCODES[multi? ? :setq : :set], key.bytesize, 8, 0, 0, value.bytesize + key.bytesize + 8, 0, cas, flags, ttl, key, value].pack(FORMAT[:set])
-        write(req)
-        cas_response unless multi?
+        opkey = multi? ? :setq : :set
+        process_value_req(opkey, key, value, ttl, cas, options)
       end
 
       def add(key, value, ttl, options)
-        (value, flags) = serialize(key, value, options)
-        ttl = sanitize_ttl(ttl)
-
-        guard_max_value(key, value)
-
-        req = [REQUEST, OPCODES[multi? ? :addq : :add], key.bytesize, 8, 0, 0, value.bytesize + key.bytesize + 8, 0, 0, flags, ttl, key, value].pack(FORMAT[:add])
-        write(req)
-        cas_response unless multi?
+        opkey = multi? ? :addq : :add
+        cas = 0
+        process_value_req(opkey, key, value, ttl, cas, options)
       end
 
       def replace(key, value, ttl, cas, options)
-        (value, flags) = serialize(key, value, options)
-        ttl = sanitize_ttl(ttl)
+        opkey = multi? ? :replaceq : :replace
+        process_value_req(opkey, key, value, ttl, cas, options)
+      end
 
-        guard_max_value(key, value)
+      # rubocop:disable Metrics/ParameterLists
+      def process_value_req(opkey, key, value, ttl, cas, options)
+        (value, bitflags) = @value_marshaller.store(key, value, options)
+        ttl = TtlSanitizer.sanitize(ttl)
 
-        req = [REQUEST, OPCODES[multi? ? :replaceq : :replace], key.bytesize, 8, 0, 0, value.bytesize + key.bytesize + 8, 0, cas, flags, ttl, key, value].pack(FORMAT[:replace])
+        req = RequestFormatter.standard_request(opkey: opkey, key: key,
+                                                value: value, bitflags: bitflags,
+                                                ttl: ttl, cas: cas)
         write(req)
-        cas_response unless multi?
+        @response_processor.cas_response unless multi?
       end
+      # rubocop:enable Metrics/ParameterLists
 
       def delete(key, cas)
-        req = [REQUEST, OPCODES[multi? ? :deleteq : :delete], key.bytesize, 0, 0, 0, key.bytesize, 0, cas, key].pack(FORMAT[:delete])
+        opkey = multi? ? :deleteq : :delete
+        req = RequestFormatter.standard_request(opkey: opkey, key: key, cas: cas)
         write(req)
-        generic_response unless multi?
+        @response_processor.generic_response unless multi?
       end
 
-      def flush(ttl)
-        req = [REQUEST, OPCODES[:flush], 0, 4, 0, 0, 4, 0, 0, 0].pack(FORMAT[:flush])
+      def flush(ttl = 0)
+        req = RequestFormatter.standard_request(opkey: :flush, ttl: ttl)
         write(req)
-        generic_response
+        @response_processor.generic_response
       end
 
-      def decr_incr(opcode, key, count, ttl, default)
-        expiry = default ? sanitize_ttl(ttl) : 0xFFFFFFFF
-        default ||= 0
-        (h, l) = split(count)
-        (dh, dl) = split(default)
-        req = [REQUEST, OPCODES[opcode], key.bytesize, 20, 0, 0, key.bytesize + 20, 0, 0, h, l, dh, dl, expiry, key].pack(FORMAT[opcode])
-        write(req)
-        body = generic_response
-        body ? body.unpack1("Q>") : body
+      # This allows us to special case a nil initial value, and
+      # handle it differently than a zero.  This special value
+      # for expiry causes memcached to return a not found
+      # if the key doesn't already exist, rather than
+      # setting the initial value
+      NOT_FOUND_EXPIRY = 0xFFFFFFFF
+
+      def decr_incr(opkey, key, count, ttl, initial)
+        expiry = initial ? TtlSanitizer.sanitize(ttl) : NOT_FOUND_EXPIRY
+        initial ||= 0
+        write(RequestFormatter.decr_incr_request(opkey: opkey, key: key,
+                                                 count: count, initial: initial, expiry: expiry))
+        @response_processor.decr_incr_response
       end
 
-      def decr(key, count, ttl, default)
-        decr_incr :decr, key, count, ttl, default
+      def decr(key, count, ttl, initial)
+        decr_incr :decr, key, count, ttl, initial
       end
 
-      def incr(key, count, ttl, default)
-        decr_incr :incr, key, count, ttl, default
+      def incr(key, count, ttl, initial)
+        decr_incr :incr, key, count, ttl, initial
       end
 
-      def write_append_prepend(opcode, key, value)
-        write_generic [REQUEST, OPCODES[opcode], key.bytesize, 0, 0, 0, value.bytesize + key.bytesize, 0, 0, key, value].pack(FORMAT[opcode])
+      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)
-        generic_response
+        @response_processor.generic_response
       end
 
       def write_noop
-        req = [REQUEST, OPCODES[:noop], 0, 0, 0, 0, 0, 0, 0].pack(FORMAT[:noop])
+        req = RequestFormatter.standard_request(opkey: :noop)
         write(req)
       end
 
@@ -365,7 +458,7 @@ module Dalli
       # We need to read all the responses at once.
       def noop
         write_noop
-        multi_response
+        @response_processor.multi_with_keys_response
       end
 
       def append(key, value)
@@ -376,209 +469,36 @@ module Dalli
         write_append_prepend :prepend, key, value
       end
 
-      def stats(info = "")
-        req = [REQUEST, OPCODES[:stat], info.bytesize, 0, 0, 0, info.bytesize, 0, 0, info].pack(FORMAT[:stat])
+      def stats(info = '')
+        req = RequestFormatter.standard_request(opkey: :stat, key: info)
         write(req)
-        keyvalue_response
+        @response_processor.multi_with_keys_response
       end
 
       def reset_stats
-        write_generic [REQUEST, OPCODES[:stat], "reset".bytesize, 0, 0, 0, "reset".bytesize, 0, 0, "reset"].pack(FORMAT[:stat])
+        write_generic RequestFormatter.standard_request(opkey: :stat, key: 'reset')
       end
 
       def cas(key)
-        req = [REQUEST, OPCODES[:get], key.bytesize, 0, 0, 0, key.bytesize, 0, 0, key].pack(FORMAT[:get])
+        req = RequestFormatter.standard_request(opkey: :get, key: key)
         write(req)
-        data_cas_response
+        @response_processor.data_cas_response
       end
 
       def version
-        write_generic [REQUEST, OPCODES[:version], 0, 0, 0, 0, 0, 0, 0].pack(FORMAT[:noop])
+        write_generic RequestFormatter.standard_request(opkey: :version)
       end
 
       def touch(key, ttl)
-        ttl = sanitize_ttl(ttl)
-        write_generic [REQUEST, OPCODES[:touch], key.bytesize, 4, 0, 0, key.bytesize + 4, 0, 0, ttl, key].pack(FORMAT[:touch])
+        ttl = TtlSanitizer.sanitize(ttl)
+        write_generic RequestFormatter.standard_request(opkey: :touch, key: key, ttl: ttl)
       end
 
       def gat(key, ttl, options = nil)
-        ttl = sanitize_ttl(ttl)
-        req = [REQUEST, OPCODES[:gat], key.bytesize, 4, 0, 0, key.bytesize + 4, 0, 0, ttl, key].pack(FORMAT[:gat])
+        ttl = TtlSanitizer.sanitize(ttl)
+        req = RequestFormatter.standard_request(opkey: :gat, key: key, ttl: ttl)
         write(req)
-        generic_response(true, !!(options && options.is_a?(Hash) && options[:cache_nils]))
-      end
-
-      # http://www.hjp.at/zettel/m/memcached_flags.rxml
-      # Looks like most clients use bit 0 to indicate native language serialization
-      # and bit 1 to indicate gzip compression.
-      FLAG_SERIALIZED = 0x1
-      FLAG_COMPRESSED = 0x2
-
-      def serialize(key, value, options = nil)
-        marshalled = false
-        value = if options && options[:raw]
-          value.to_s
-        else
-          marshalled = true
-          begin
-            serializer.dump(value)
-          rescue Timeout::Error => e
-            raise e
-          rescue => ex
-            # Marshalling can throw several different types of generic Ruby exceptions.
-            # Convert to a specific exception so we can special case it higher up the stack.
-            exc = Dalli::MarshalError.new(ex.message)
-            exc.set_backtrace ex.backtrace
-            raise exc
-          end
-        end
-        compressed = false
-        set_compress_option = true if options && options[:compress]
-        if (@options[:compress] || set_compress_option) && value.bytesize >= @options[:compression_min_size]
-          value = compressor.compress(value)
-          compressed = true
-        end
-
-        flags = 0
-        flags |= FLAG_COMPRESSED if compressed
-        flags |= FLAG_SERIALIZED if marshalled
-        [value, flags]
-      end
-
-      def deserialize(value, flags)
-        value = compressor.decompress(value) if (flags & FLAG_COMPRESSED) != 0
-        value = serializer.load(value) if (flags & FLAG_SERIALIZED) != 0
-        value
-      rescue TypeError
-        raise unless /needs to have method `_load'|exception class\/object expected|instance of IO needed|incompatible marshal file format/.match?($!.message)
-        raise UnmarshalError, "Unable to unmarshal value: #{$!.message}"
-      rescue ArgumentError
-        raise unless /undefined class|marshal data too short/.match?($!.message)
-        raise UnmarshalError, "Unable to unmarshal value: #{$!.message}"
-      rescue NameError
-        raise unless /uninitialized constant/.match?($!.message)
-        raise UnmarshalError, "Unable to unmarshal value: #{$!.message}"
-      rescue Zlib::Error
-        raise UnmarshalError, "Unable to uncompress value: #{$!.message}"
-      end
-
-      def data_cas_response
-        (extras, _, status, count, _, cas) = read_header.unpack(CAS_HEADER)
-        data = read(count) if count > 0
-        if status == 1
-          nil
-        elsif status != 0
-          raise Dalli::DalliError, "Response error #{status}: #{RESPONSE_CODES[status]}"
-        elsif data
-          flags = data[0...extras].unpack1("N")
-          value = data[extras..-1]
-          data = deserialize(value, flags)
-        end
-        [data, cas]
-      end
-
-      CAS_HEADER = "@4CCnNNQ"
-      NORMAL_HEADER = "@4CCnN"
-      KV_HEADER = "@2n@6nN@16Q"
-
-      def guard_max_value(key, value)
-        return if value.bytesize <= @options[:value_max_bytes]
-
-        message = "Value for #{key} over max size: #{@options[:value_max_bytes]} <= #{value.bytesize}"
-        raise Dalli::ValueOverMaxSize, message
-      end
-
-      # https://github.com/memcached/memcached/blob/master/doc/protocol.txt#L79
-      # > An expiration time, in seconds. Can be up to 30 days. After 30 days, is treated as a unix timestamp of an exact date.
-      MAX_ACCEPTABLE_EXPIRATION_INTERVAL = 30 * 24 * 60 * 60 # 30 days
-      def sanitize_ttl(ttl)
-        ttl_as_i = ttl.to_i
-        return ttl_as_i if ttl_as_i <= MAX_ACCEPTABLE_EXPIRATION_INTERVAL
-        now = Time.now.to_i
-        return ttl_as_i if ttl_as_i > now # already a timestamp
-        Dalli.logger.debug "Expiration interval (#{ttl_as_i}) too long for Memcached, converting to an expiration timestamp"
-        now + ttl_as_i
-      end
-
-      # Implements the NullObject pattern to store an application-defined value for 'Key not found' responses.
-      class NilObject; end
-      NOT_FOUND = NilObject.new
-
-      def generic_response(unpack = false, cache_nils = false)
-        (extras, _, status, count) = read_header.unpack(NORMAL_HEADER)
-        data = read(count) if count > 0
-        if status == 1
-          cache_nils ? NOT_FOUND : nil
-        elsif status == 2 || status == 5
-          false # Not stored, normal status for add operation
-        elsif status != 0
-          raise Dalli::DalliError, "Response error #{status}: #{RESPONSE_CODES[status]}"
-        elsif data
-          flags = data.byteslice(0, extras).unpack1("N")
-          value = data.byteslice(extras, data.bytesize - extras)
-          unpack ? deserialize(value, flags) : value
-        else
-          true
-        end
-      end
-
-      def cas_response
-        (_, _, status, count, _, cas) = read_header.unpack(CAS_HEADER)
-        read(count) if count > 0 # this is potential data that we don't care about
-        if status == 1
-          nil
-        elsif status == 2 || status == 5
-          false # Not stored, normal status for add operation
-        elsif status != 0
-          raise Dalli::DalliError, "Response error #{status}: #{RESPONSE_CODES[status]}"
-        else
-          cas
-        end
-      end
-
-      def keyvalue_response
-        hash = {}
-        loop do
-          (key_length, _, body_length, _) = read_header.unpack(KV_HEADER)
-          return hash if key_length == 0
-          key = read(key_length)
-          value = read(body_length - key_length) if body_length - key_length > 0
-          hash[key] = value
-        end
-      end
-
-      def multi_response
-        hash = {}
-        loop do
-          (key_length, _, body_length, _) = read_header.unpack(KV_HEADER)
-          return hash if key_length == 0
-          flags = read(4).unpack1("N")
-          key = read(key_length)
-          value = read(body_length - key_length - 4) if body_length - key_length - 4 > 0
-          hash[key] = deserialize(value, flags)
-        end
-      end
-
-      def write(bytes)
-        @inprogress = true
-        result = @sock.write(bytes)
-        @inprogress = false
-        result
-      rescue SystemCallError, Timeout::Error => e
-        failure!(e)
-      end
-
-      def read(count)
-        @inprogress = true
-        data = @sock.readfull(count)
-        @inprogress = false
-        data
-      rescue SystemCallError, Timeout::Error, EOFError => e
-        failure!(e)
-      end
-
-      def read_header
-        read(24) || raise(Dalli::NetworkError, "No response")
+        @response_processor.generic_response(unpack: true, cache_nils: cache_nils?(options))
       end
 
       def connect
@@ -586,13 +506,9 @@ module Dalli
 
         begin
           @pid = Process.pid
-          @sock = if socket_type == :unix
-            Dalli::Socket::UNIX.open(hostname, self, options)
-          else
-            Dalli::Socket::TCP.open(hostname, port, self, options)
-          end
-          sasl_authentication if need_auth?
-          @version = version # trigger actual connect
+          @sock = memcached_socket
+          authenticate_connection if require_auth?
+          @version = version # Connect socket if not authed
           up!
         rescue Dalli::DalliError # SASL auth failure
           raise
@@ -602,152 +518,27 @@ module Dalli
         end
       end
 
-      def split(n)
-        [n >> 32, 0xFFFFFFFF & n]
-      end
-
-      REQUEST = 0x80
-      RESPONSE = 0x81
-
-      # Response codes taken from:
-      # https://github.com/memcached/memcached/wiki/BinaryProtocolRevamped#response-status
-      RESPONSE_CODES = {
-        0 => "No error",
-        1 => "Key not found",
-        2 => "Key exists",
-        3 => "Value too large",
-        4 => "Invalid arguments",
-        5 => "Item not stored",
-        6 => "Incr/decr on a non-numeric value",
-        7 => "The vbucket belongs to another server",
-        8 => "Authentication error",
-        9 => "Authentication continue",
-        0x20 => "Authentication required",
-        0x81 => "Unknown command",
-        0x82 => "Out of memory",
-        0x83 => "Not supported",
-        0x84 => "Internal error",
-        0x85 => "Busy",
-        0x86 => "Temporary failure"
-      }
-
-      OPCODES = {
-        get: 0x00,
-        set: 0x01,
-        add: 0x02,
-        replace: 0x03,
-        delete: 0x04,
-        incr: 0x05,
-        decr: 0x06,
-        flush: 0x08,
-        noop: 0x0A,
-        version: 0x0B,
-        getkq: 0x0D,
-        append: 0x0E,
-        prepend: 0x0F,
-        stat: 0x10,
-        setq: 0x11,
-        addq: 0x12,
-        replaceq: 0x13,
-        deleteq: 0x14,
-        incrq: 0x15,
-        decrq: 0x16,
-        auth_negotiation: 0x20,
-        auth_request: 0x21,
-        auth_continue: 0x22,
-        touch: 0x1C,
-        gat: 0x1D
-      }
-
-      HEADER = "CCnCCnNNQ"
-      OP_FORMAT = {
-        get: "a*",
-        set: "NNa*a*",
-        add: "NNa*a*",
-        replace: "NNa*a*",
-        delete: "a*",
-        incr: "NNNNNa*",
-        decr: "NNNNNa*",
-        flush: "N",
-        noop: "",
-        getkq: "a*",
-        version: "",
-        stat: "a*",
-        append: "a*a*",
-        prepend: "a*a*",
-        auth_request: "a*a*",
-        auth_continue: "a*a*",
-        touch: "Na*",
-        gat: "Na*"
-      }
-      FORMAT = OP_FORMAT.each_with_object({}) { |(k, v), memo| memo[k] = HEADER + v; }
-
-      #######
-      # SASL authentication support for NorthScale
-      #######
-
-      def need_auth?
-        @options[:username] || ENV["MEMCACHE_USERNAME"]
+      def memcached_socket
+        if socket_type == :unix
+          Dalli::Socket::UNIX.open(hostname, self, options)
+        else
+          Dalli::Socket::TCP.open(hostname, port, self, options)
+        end
+      end
+
+      def require_auth?
+        !username.nil?
       end
 
       def username
-        @options[:username] || ENV["MEMCACHE_USERNAME"]
+        @options[:username] || ENV['MEMCACHE_USERNAME']
       end
 
       def password
-        @options[:password] || ENV["MEMCACHE_PASSWORD"]
+        @options[:password] || ENV['MEMCACHE_PASSWORD']
       end
 
-      def sasl_authentication
-        Dalli.logger.info { "Dalli/SASL authenticating as #{username}" }
-
-        # negotiate
-        req = [REQUEST, OPCODES[:auth_negotiation], 0, 0, 0, 0, 0, 0, 0].pack(FORMAT[:noop])
-        write(req)
-
-        (extras, _type, status, count) = read_header.unpack(NORMAL_HEADER)
-        raise Dalli::NetworkError, "Unexpected message format: #{extras} #{count}" unless extras == 0 && count > 0
-        content = read(count).tr("\u0000", " ")
-        return Dalli.logger.debug("Authentication not required/supported by server") if status == 0x81
-        mechanisms = content.split(" ")
-        raise NotImplementedError, "Dalli only supports the PLAIN authentication mechanism" unless mechanisms.include?("PLAIN")
-
-        # request
-        mechanism = "PLAIN"
-        msg = "\x0#{username}\x0#{password}"
-        req = [REQUEST, OPCODES[:auth_request], mechanism.bytesize, 0, 0, 0, mechanism.bytesize + msg.bytesize, 0, 0, mechanism, msg].pack(FORMAT[:auth_request])
-        write(req)
-
-        (extras, _type, status, count) = read_header.unpack(NORMAL_HEADER)
-        raise Dalli::NetworkError, "Unexpected message format: #{extras} #{count}" unless extras == 0 && count > 0
-        content = read(count)
-        return Dalli.logger.info("Dalli/SASL: #{content}") if status == 0
-
-        raise Dalli::DalliError, "Error authenticating: #{status}" unless status == 0x21
-        raise NotImplementedError, "No two-step authentication mechanisms supported"
-        # (step, msg) = sasl.receive('challenge', content)
-        # raise Dalli::NetworkError, "Authentication failed" if sasl.failed? || step != 'response'
-      end
-
-      def parse_hostname(str)
-        res = str.match(/\A(\[([\h:]+)\]|[^:]+)(?::(\d+))?(?::(\d+))?\z/)
-        raise Dalli::DalliError, "Could not parse hostname #{str}" if res.nil? || res[1] == "[]"
-        hostnam = res[2] || res[1]
-        if hostnam.start_with?("/")
-          socket_type = :unix
-          # in case of unix socket, allow only setting of weight, not port
-          raise Dalli::DalliError, "Could not parse hostname #{str}" if res[4]
-          weigh = res[3]
-        else
-          socket_type = :tcp
-          por = res[3] || DEFAULT_PORT
-          por = Integer(por)
-          weigh = res[4]
-        end
-        weigh ||= DEFAULT_WEIGHT
-        weigh = Integer(weigh)
-        [hostnam, por, weigh, socket_type]
-      end
+      include SaslAuthentication
     end
   end
 end