dalli 3.0.3 → 3.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4afe70ee94b027c2934fa368a16ca42bf41b7a844c0785c706e2035dba372f66
-  data.tar.gz: 340cf977e332834bfae268995e2d5c70158813f5405fbeee7764e3cc8fa1eb9f
+  metadata.gz: de12f6f4e7e074752c4b3d2ccaa24450fd081e6e4ded890c632158858e5aa939
+  data.tar.gz: '01093957dc00b0742995b5d9198014dc480bd08788f4f3c2e5160cd2a6ca8725'
 SHA512:
-  metadata.gz: a3f8a4ca2792149afa6c5b125edad177a69f2bfdaba5106632da7e1ff8c80d0549ea9f4077240d853115caa1711e10e0e966191b9fbb4a5f7103a95bd70629b2
-  data.tar.gz: 28b0926d7367973a0aa57b1d9c95b57f82bf3d7ffd1874259715285538eaa3ab07ab40b67d7c7444734d23da8b20c8f099b1c5c7664f43028aa01715efd48239
+  metadata.gz: c073d5ce9922b8617c11c507b8b90603ccdf304419c2fe395af33467f880c75e4a22e9e5e6eae387c78ae937b6b8de5d68eba87b323967cce03a8aaffeeba1d8
+  data.tar.gz: f7fd88ee88a887c44a1b94d0e3c6c7b0d210d08c38db39ea387585a18a82c5cd0a4e9a57daaa444e927e4c47f81fbd404daeec139ded6d8ff6d39fe3e565022d

data/History.md

@@ -1,6 +1,12 @@
 Dalli Changelog
 =====================
 
+3.0.4
+==========
+
+- Clean connections and retry after NetworkError in get_multi (andrejbl)
+- Internal refactoring and cleanup (petergoldstein)
+
 3.0.3
 ==========
 

data/lib/dalli/client.rb

@@ -374,17 +374,24 @@ module Dalli
     end
 
     def perform_multi_response_start(servers)
+      deleted = []
+  
       servers.each do |server|
         next unless server.alive?
+  
         begin
           server.multi_response_start
-        rescue DalliError, NetworkError => e
+        rescue Dalli::NetworkError
+          servers.each { |s| s.multi_response_abort unless s.sock.nil?  }
+          raise
+        rescue Dalli::DalliError => e
           Dalli.logger.debug { e.inspect }
           Dalli.logger.debug { "results from this server will be missing" }
-          servers.delete(server)
+          deleted.append(server)
         end
       end
-      servers
+  
+      servers.delete_if { |server| deleted.include?(server) }
     end
 
     ##
@@ -428,12 +435,13 @@ module Dalli
 
     # Chokepoint method for instrumentation
     def perform(*all_args)
-      return yield if block_given?
-      op, key, *args = all_args
-
-      key = key.to_s
-      key = validate_key(key)
       begin
+        return yield if block_given?
+        op, key, *args = all_args
+
+        key = key.to_s
+        key = validate_key(key)
+      
         server = ring.server_for_key(key)
         server.request(op, key, *args)
       rescue NetworkError => e
@@ -534,7 +542,8 @@ module Dalli
                     servers.delete(server)
                   end
                 rescue NetworkError
-                  servers.delete(server)
+                  servers.each { |s| s.multi_response_abort unless s.sock.nil? }
+                  raise
                 end
               end
             end

data/lib/dalli/protocol/binary.rb

@@ -13,8 +13,6 @@ module Dalli
       attr_reader :sock
       attr_reader :socket_type # possible values: :unix, :tcp
 
-      DEFAULT_PORT = 11211
-      DEFAULT_WEIGHT = 1
       DEFAULTS = {
         # seconds between trying to contact a remote server
         down_retry_delay: 30,
@@ -37,7 +35,7 @@ module Dalli
       }
 
       def initialize(attribs, options = {})
-        @hostname, @port, @weight, @socket_type = parse_hostname(attribs)
+        @hostname, @port, @weight, @socket_type = ServerConfigParser.parse(attribs)
         @fail_count = 0
         @down_at = nil
         @last_down_at = nil
@@ -278,7 +276,7 @@ module Dalli
 
       def set(key, value, ttl, cas, options)
         (value, flags) = serialize(key, value, options)
-        ttl = sanitize_ttl(ttl)
+        ttl = TtlSanitizer.sanitize(ttl)
 
         guard_max_value(key, value)
 
@@ -289,7 +287,7 @@ module Dalli
 
       def add(key, value, ttl, options)
         (value, flags) = serialize(key, value, options)
-        ttl = sanitize_ttl(ttl)
+        ttl = TtlSanitizer.sanitize(ttl)
 
         guard_max_value(key, value)
 
@@ -300,7 +298,7 @@ module Dalli
 
       def replace(key, value, ttl, cas, options)
         (value, flags) = serialize(key, value, options)
-        ttl = sanitize_ttl(ttl)
+        ttl = TtlSanitizer.sanitize(ttl)
 
         guard_max_value(key, value)
 
@@ -322,7 +320,7 @@ module Dalli
       end
 
       def decr_incr(opcode, key, count, ttl, default)
-        expiry = default ? sanitize_ttl(ttl) : 0xFFFFFFFF
+        expiry = default ? TtlSanitizer.sanitize(ttl) : 0xFFFFFFFF
         default ||= 0
         (h, l) = split(count)
         (dh, dl) = split(default)
@@ -390,12 +388,12 @@ module Dalli
       end
 
       def touch(key, ttl)
-        ttl = sanitize_ttl(ttl)
+        ttl = TtlSanitizer.sanitize(ttl)
         write_generic [REQUEST, OPCODES[:touch], key.bytesize, 4, 0, 0, key.bytesize + 4, 0, 0, ttl, key].pack(FORMAT[:touch])
       end
 
       def gat(key, ttl, options = nil)
-        ttl = sanitize_ttl(ttl)
+        ttl = TtlSanitizer.sanitize(ttl)
         req = [REQUEST, OPCODES[:gat], key.bytesize, 4, 0, 0, key.bytesize + 4, 0, 0, ttl, key].pack(FORMAT[:gat])
         write(req)
         generic_response(true, !!(options && options.is_a?(Hash) && options[:cache_nils]))
@@ -472,18 +470,6 @@ module Dalli
         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
@@ -712,26 +698,6 @@ module Dalli
         # (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
     end
   end
 end

data/lib/dalli/protocol/server_config_parser.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Dalli
+  module Protocol
+    ##
+    # Dalli::Protocol::ServerConfigParser parses a server string passed to
+    # a Dalli::Protocol::Binary instance into the hostname, port, weight, and
+    # socket_type.
+    ##
+    class ServerConfigParser
+      # TODO: Revisit this, especially the IP/domain part.  Likely
+      # can limit character set to LDH + '.'.  Hex digit section
+      # appears to have been added to support IPv6, but as far as
+      # I can tell it doesn't work
+      SERVER_CONFIG_REGEXP = /\A(\[([\h:]+)\]|[^:]+)(?::(\d+))?(?::(\d+))?\z/.freeze
+
+      DEFAULT_PORT = 11_211
+      DEFAULT_WEIGHT = 1
+
+      def self.parse(str)
+        res = deconstruct_string(str)
+
+        hostname = normalize_hostname(str, res)
+        if hostname.start_with?('/')
+          socket_type = :unix
+          port, weight = attributes_for_unix_socket(res)
+        else
+          socket_type = :tcp
+          port, weight = attributes_for_tcp_socket(res)
+        end
+        [hostname, port, weight, socket_type]
+      end
+
+      def self.deconstruct_string(str)
+        mtch = str.match(SERVER_CONFIG_REGEXP)
+        raise Dalli::DalliError, "Could not parse hostname #{str}" if mtch.nil? || mtch[1] == '[]'
+
+        mtch
+      end
+
+      def self.attributes_for_unix_socket(res)
+        # in case of unix socket, allow only setting of weight, not port
+        raise Dalli::DalliError, "Could not parse hostname #{res[0]}" if res[4]
+
+        [nil, normalize_weight(res[3])]
+      end
+
+      def self.attributes_for_tcp_socket(res)
+        [normalize_port(res[3]), normalize_weight(res[4])]
+      end
+
+      def self.normalize_hostname(str, res)
+        raise Dalli::DalliError, "Could not parse hostname #{str}" if res.nil? || res[1] == '[]'
+
+        res[2] || res[1]
+      end
+
+      def self.normalize_port(port)
+        Integer(port || DEFAULT_PORT)
+      end
+
+      def self.normalize_weight(weight)
+        Integer(weight || DEFAULT_WEIGHT)
+      end
+    end
+  end
+end

data/lib/dalli/protocol/ttl_sanitizer.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Dalli
+  module Protocol
+    ##
+    # Utility class for sanitizing TTL arguments based on Memcached rules.
+    # TTLs are either expirations times in seconds (with a maximum value of
+    # 30 days) or expiration timestamps.  This class sanitizes TTLs to ensure
+    # they meet those restrictions.
+    ##
+    class TtlSanitizer
+      # 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
+
+      # Ensures the TTL passed to Memcached is a valid TTL in the expected format.
+      def self.sanitize(ttl)
+        ttl_as_i = ttl.to_i
+        return ttl_as_i if less_than_max_expiration_interval?(ttl_as_i)
+
+        as_timestamp(ttl_as_i)
+      end
+
+      def self.less_than_max_expiration_interval?(ttl_as_i)
+        ttl_as_i <= MAX_ACCEPTABLE_EXPIRATION_INTERVAL
+      end
+
+      def self.as_timestamp(ttl_as_i)
+        now = current_timestamp
+        return ttl_as_i if ttl_as_i > now # Already a timestamp
+
+        Dalli.logger.debug "Expiration interval (#{ttl_as_i}) too long for Memcached " \
+                           'and too short to be a future timestamp,' \
+                           'converting to an expiration timestamp'
+        now + ttl_as_i
+      end
+
+      # Pulled out into a method so it's easy to stub time
+      def self.current_timestamp
+        Time.now.to_i
+      end
+    end
+  end
+end

data/lib/dalli/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Dalli
-  VERSION = "3.0.3"
+  VERSION = "3.0.4"
 end

data/lib/dalli.rb

@@ -5,6 +5,8 @@ require "dalli/client"
 require "dalli/ring"
 require "dalli/protocol"
 require "dalli/protocol/binary"
+require "dalli/protocol/server_config_parser"
+require "dalli/protocol/ttl_sanitizer"
 require 'dalli/protocol/value_compressor'
 require "dalli/socket"
 require "dalli/version"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 3.0.3
+  version: 3.0.4
 platform: ruby
 authors:
 - Peter M. Goldstein
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-21 00:00:00.000000000 Z
+date: 2021-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -58,6 +58,8 @@ files:
 - lib/dalli/options.rb
 - lib/dalli/protocol.rb
 - lib/dalli/protocol/binary.rb
+- lib/dalli/protocol/server_config_parser.rb
+- lib/dalli/protocol/ttl_sanitizer.rb
 - lib/dalli/protocol/value_compressor.rb
 - lib/dalli/ring.rb
 - lib/dalli/server.rb
@@ -83,7 +85,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.29
+rubygems_version: 3.2.30
 signing_key:
 specification_version: 4
 summary: High performance memcached client for Ruby