dalli 3.1.3 → 3.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0905b56adf194401de7755ab22ebef6b57f6e673e8332f7cb99b3ef9ed1dde63'
-  data.tar.gz: dac2014c748ef0c55fe171af0cec8dec807ae2468f758338c8968135acd47b92
+  metadata.gz: e687040436582dd13519490544b2b493c424dca476a2a9173a68dc216c61d7ba
+  data.tar.gz: 293d5d74a31562116c17a24b02192504483d066f03418fe44d99694092595f0e
 SHA512:
-  metadata.gz: 85d8382dfd13c2353a61c74525e17bd81e000308e8d476851ed25fdb6ef81e9aff4276eb0b1484e30c83001301a3500140cb46a595081e1b21f0801ea32d7e28
-  data.tar.gz: 7f0adfc09e31d435bbb3f6cff2f65392a58f81697e7025ca71d9423f9a536d9c984ed7ba0742d0c0f5de0e865a7ebd2dc5548a0406c86d7f1fe0c8135c7af363
+  metadata.gz: d47dc643fb3722b2718a6fd612525574ec1355889515b70499f56fb102f731a0be11ec010dec5e670bab1740f40e40b099347a5bf341c5754a97cf1a09206396
+  data.tar.gz: 6e993408f8ad08c275399d8f93542da58673207435fb171f9dcb39871f11d799bec412b721bb6c0bb3364d9d58fc1e1020533ed565e213db9b65cd2744505980

data/History.md

@@ -4,6 +4,13 @@ Dalli Changelog
 Unreleased
 ==========
 
+3.1.4
+==========
+
+- Improve response parsing performance (casperisfine)
+- Reorganize binary protocol parsing a bit (petergoldstein)
+- Fix handling of non-ASCII keys in get_multi (petergoldstein)
+
 3.1.3
 ==========
 

data/lib/dalli/protocol/base.rb

@@ -83,20 +83,20 @@ module Dalli
 
         response_buffer.read
 
-        resp_header, key, value = pipeline_response
-        # resp_header is not nil only if we have a full response to parse
+        status, cas, key, value = response_buffer.process_single_getk_response
+        # status is not nil only if we have a full response to parse
         # in the buffer
-        while resp_header
+        until status.nil?
           # If the status is ok and key is nil, then this is the response
           # to the noop at the end of the pipeline
-          finish_pipeline && break if resp_header.ok? && key.nil?
+          finish_pipeline && break if status && key.nil?
 
           # 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, resp_header.cas] unless key.nil?
+          values[key] = [value, cas] unless key.nil?
 
           # Get the next response from the buffer
-          resp_header, key, value = pipeline_response
+          status, cas, key, value = response_buffer.process_single_getk_response
         end
 
         values
@@ -207,10 +207,6 @@ module Dalli
         @response_buffer ||= ResponseBuffer.new(@connection_manager, response_processor)
       end
 
-      def pipeline_response
-        response_buffer.process_single_getk_response
-      end
-
       # Called after the noop response is received at the end of a set
       # of pipelined gets
       def finish_pipeline

data/lib/dalli/protocol/binary/response_processor.rb

@@ -46,11 +46,13 @@ module Dalli
           [resp_header, body]
         end
 
-        def unpack_response_body(extra_len, key_len, body, unpack)
-          bitflags = extra_len.positive? ? body.byteslice(0, extra_len).unpack1('N') : 0x0
-          key = body.byteslice(extra_len, key_len) if key_len.positive?
-          value = body.byteslice(extra_len + key_len, body.bytesize - (extra_len + key_len))
-          value = unpack ? @value_marshaller.retrieve(value, bitflags) : value
+        def unpack_response_body(resp_header, body, parse_as_stored_value)
+          extra_len = resp_header.extra_len
+          key_len = resp_header.key_len
+          bitflags = extra_len.positive? ? body.unpack1('N') : 0x0
+          key = body.byteslice(extra_len, key_len).force_encoding('UTF-8') if key_len.positive?
+          value = body.byteslice((extra_len + key_len)..-1)
+          value = parse_as_stored_value ? @value_marshaller.retrieve(value, bitflags) : value
           [key, value]
         end
 
@@ -64,7 +66,7 @@ module Dalli
           raise Dalli::DalliError, "Response error #{resp_header.status}: #{RESPONSE_CODES[resp_header.status]}"
         end
 
-        def generic_response(unpack: false, cache_nils: false)
+        def get(cache_nils: false)
           resp_header, body = read_response
 
           return false if resp_header.not_stored? # Not stored, normal status for add operation
@@ -73,7 +75,7 @@ module Dalli
           raise_on_not_ok!(resp_header)
           return true unless body
 
-          unpack_response_body(resp_header.extra_len, resp_header.key_len, body, unpack).last
+          unpack_response_body(resp_header, body, true).last
         end
 
         ##
@@ -89,7 +91,7 @@ module Dalli
           resp_header.cas
         end
 
-        def delete_response
+        def delete
           resp_header, = read_response
           return false if resp_header.not_found? || resp_header.not_stored?
 
@@ -97,15 +99,7 @@ module Dalli
           true
         end
 
-        def no_body_response
-          resp_header, = read_response
-          return false if resp_header.not_stored? # Not stored, possible status for append/prepend
-
-          raise_on_not_ok!(resp_header)
-          true
-        end
-
-        def data_cas_response(unpack: true)
+        def data_cas_response
           resp_header, body = read_response
           return [nil, resp_header.cas] if resp_header.not_found?
           return [nil, false] if resp_header.not_stored?
@@ -113,14 +107,16 @@ module Dalli
           raise_on_not_ok!(resp_header)
           return [nil, resp_header.cas] unless body
 
-          [unpack_response_body(resp_header.extra_len, resp_header.key_len, body, unpack).last, resp_header.cas]
+          [unpack_response_body(resp_header, body, true).last, resp_header.cas]
         end
 
-        def cas_response
-          data_cas_response.last
+        # Returns the new value for the key, if found and updated
+        def decr_incr
+          body = generic_response
+          body ? body.unpack1('Q>') : body
         end
 
-        def multi_with_keys_response
+        def stats
           hash = {}
           loop do
             resp_header, body = read_response
@@ -133,14 +129,49 @@ module Dalli
             # block to clear any error responses from inside the multi.
             next unless resp_header.ok?
 
-            key, value = unpack_response_body(resp_header.extra_len, resp_header.key_len, body, true)
+            key, value = unpack_response_body(resp_header, body, true)
             hash[key] = value
           end
         end
 
-        def decr_incr_response
-          body = generic_response
-          body ? body.unpack1('Q>') : body
+        def flush
+          no_body_response
+        end
+
+        def reset
+          generic_response
+        end
+
+        def version
+          generic_response
+        end
+
+        def consume_all_responses_until_noop
+          loop do
+            resp_header, = read_response
+            # This is the response to the terminating noop / end of stat
+            return true if resp_header.ok? && resp_header.key_len.zero?
+          end
+        end
+
+        def generic_response
+          resp_header, body = read_response
+
+          return false if resp_header.not_stored? # Not stored, normal status for add operation
+          return nil if resp_header.not_found?
+
+          raise_on_not_ok!(resp_header)
+          return true unless body
+
+          unpack_response_body(resp_header, body, false).last
+        end
+
+        def no_body_response
+          resp_header, = read_response
+          return false if resp_header.not_stored? # Not stored, possible status for append/prepend/delete
+
+          raise_on_not_ok!(resp_header)
+          true
         end
 
         def validate_auth_format(extra_len, count)
@@ -164,8 +195,7 @@ module Dalli
         end
 
         def response_header_from_buffer(buf)
-          header = buf.slice(0, ResponseHeader::SIZE)
-          ResponseHeader.new(header)
+          ResponseHeader.new(buf)
         end
 
         ##
@@ -180,7 +210,7 @@ module Dalli
         ##
         def getk_response_from_buffer(buf)
           # There's no header in the buffer, so don't advance
-          return [0, nil, nil, nil] unless contains_header?(buf)
+          return [0, nil, nil, nil, nil] unless contains_header?(buf)
 
           resp_header = response_header_from_buffer(buf)
           body_len = resp_header.body_len
@@ -189,18 +219,18 @@ module Dalli
           # This is either the response to the terminating
           # noop or, if the status is not zero, an intermediate
           # error response that needs to be discarded.
-          return [ResponseHeader::SIZE, resp_header, nil, nil] if body_len.zero?
+          return [ResponseHeader::SIZE, resp_header.ok?, resp_header.cas, nil, nil] if body_len.zero?
 
           resp_size = ResponseHeader::SIZE + body_len
           # The header is in the buffer, but the body is not.  As we don't have
           # a complete response, don't advance the buffer
-          return [0, nil, nil, nil] unless buf.bytesize >= resp_size
+          return [0, nil, nil, nil, nil] unless buf.bytesize >= resp_size
 
           # The full response is in our buffer, so parse it and return
           # the values
-          body = buf.slice(ResponseHeader::SIZE, body_len)
-          key, value = unpack_response_body(resp_header.extra_len, resp_header.key_len, body, true)
-          [resp_size, resp_header, key, value]
+          body = buf.byteslice(ResponseHeader::SIZE, body_len)
+          key, value = unpack_response_body(resp_header, body, true)
+          [resp_size, resp_header.ok?, resp_header.cas, key, value]
         end
       end
     end

data/lib/dalli/protocol/binary.rb

@@ -29,7 +29,7 @@ module Dalli
       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))
+        response_processor.get(cache_nils: cache_nils?(options))
       end
 
       def quiet_get_request(key)
@@ -40,7 +40,7 @@ module Dalli
         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))
+        response_processor.get(cache_nils: cache_nils?(options))
       end
 
       def touch(key, ttl)
@@ -106,7 +106,7 @@ module Dalli
         opkey = quiet? ? :deleteq : :delete
         req = RequestFormatter.standard_request(opkey: opkey, key: key, cas: cas)
         write(req)
-        response_processor.delete_response unless quiet?
+        response_processor.delete unless quiet?
       end
 
       # Arithmetic Commands
@@ -132,7 +132,7 @@ module Dalli
         initial ||= 0
         write(RequestFormatter.decr_incr_request(opkey: opkey, key: key,
                                                  count: count, initial: initial, expiry: expiry))
-        response_processor.decr_incr_response unless quiet?
+        response_processor.decr_incr unless quiet?
       end
 
       # Other Commands
@@ -146,23 +146,23 @@ module Dalli
       # We need to read all the responses at once.
       def noop
         write_noop
-        response_processor.multi_with_keys_response
+        response_processor.consume_all_responses_until_noop
       end
 
       def stats(info = '')
         req = RequestFormatter.standard_request(opkey: :stat, key: info)
         write(req)
-        response_processor.multi_with_keys_response
+        response_processor.stats
       end
 
       def reset_stats
         write(RequestFormatter.standard_request(opkey: :stat, key: 'reset'))
-        response_processor.generic_response
+        response_processor.reset
       end
 
       def version
         write(RequestFormatter.standard_request(opkey: :version))
-        response_processor.generic_response
+        response_processor.version
       end
 
       def write_noop

data/lib/dalli/protocol/response_buffer.rb

@@ -21,9 +21,9 @@ module Dalli
       # 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)
+        bytes, status, cas, key, value = @response_processor.getk_response_from_buffer(@buffer)
         advance(bytes)
-        [resp_header, key, value]
+        [status, cas, key, value]
       end
 
       # Advances the internal response buffer by bytes_to_advance
@@ -31,13 +31,13 @@ module Dalli
       def advance(bytes_to_advance)
         return unless bytes_to_advance.positive?
 
-        @buffer = @buffer[bytes_to_advance..-1]
+        @buffer = @buffer.byteslice(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 = +''
+        @buffer = ''.b
       end
 
       # Clear the internal response buffer

data/lib/dalli/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 3.1.3
+  version: 3.1.4
 platform: ruby
 authors:
 - Peter M. Goldstein
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-14 00:00:00.000000000 Z
+date: 2021-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: connection_pool