dalli 2.7.11 → 3.0.4

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/protocol/value_compressor.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'English'
+
+module Dalli
+  module Protocol
+    ##
+    # Dalli::Protocol::ValueCompressor compartmentalizes the logic for managing
+    # compression and decompression of stored values.  It manages interpreting
+    # relevant options from both client and request, determining whether to
+    # compress/decompress on store/retrieve, and processes bitflags as necessary.
+    ##
+    class ValueCompressor
+      DEFAULTS = {
+        compress: true,
+        compressor: ::Dalli::Compressor,
+        # min byte size to attempt compression
+        compression_min_size: 4 * 1024 # 4K
+      }.freeze
+
+      OPTIONS = DEFAULTS.keys.freeze
+
+      # https://www.hjp.at/zettel/m/memcached_flags.rxml
+      # Looks like most clients use bit 1 to indicate gzip compression.
+      FLAG_COMPRESSED = 0x2
+
+      def initialize(client_options)
+        # Support the deprecated compression option, but don't allow it to override
+        # an explicit compress
+        # Remove this with 4.0
+        if client_options.key?(:compression) && !client_options.key?(:compress)
+          Dalli.logger.warn "DEPRECATED: Dalli's :compression option is now just 'compress: true'.  " \
+                            'Please update your configuration.'
+          client_options[:compress] = client_options.delete(:compression)
+        end
+
+        @compression_options =
+          DEFAULTS.merge(client_options.select { |k, _| OPTIONS.include?(k) })
+      end
+
+      def store(value, req_options, bitflags)
+        do_compress = compress_value?(value, req_options)
+        store_value = do_compress ? compressor.compress(value) : value
+        bitflags |= FLAG_COMPRESSED if do_compress
+
+        [store_value, bitflags]
+      end
+
+      def retrieve(value, bitflags)
+        compressed = (bitflags & FLAG_COMPRESSED) != 0
+        compressed ? compressor.decompress(value) : value
+
+      # TODO: We likely want to move this rescue into the Dalli::Compressor / Dalli::GzipCompressor
+      # itself, since not all compressors necessarily use Zlib.  For now keep it here, so the behavior
+      # of custom compressors doesn't change.
+      rescue Zlib::Error
+        raise UnmarshalError, "Unable to uncompress value: #{$ERROR_INFO.message}"
+      end
+
+      def compress_by_default?
+        @compression_options[:compress]
+      end
+
+      def compressor
+        @compression_options[:compressor]
+      end
+
+      def compression_min_size
+        @compression_options[:compression_min_size]
+      end
+
+      # Checks whether we should apply compression when serializing a value
+      # based on the specified options.  Returns false unless the value
+      # is greater than the minimum compression size.  Otherwise returns
+      # based on a method-level option if specified, falling back to the
+      # server default.
+      def compress_value?(value, req_options)
+        return false unless value.bytesize >= compression_min_size
+        return compress_by_default? unless req_options && !req_options[:compress].nil?
+
+        req_options[:compress]
+      end
+    end
+  end
+end

data/lib/dalli/protocol.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Dalli
+  module Protocol
+    # Implements the NullObject pattern to store an application-defined value for 'Key not found' responses.
+    class NilObject; end
+    NOT_FOUND = NilObject.new
+  end
+end

data/lib/dalli/ring.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
-require 'digest/sha1'
-require 'zlib'
+
+require "digest/sha1"
+require "zlib"
 
 module Dalli
   class Ring
@@ -32,7 +33,13 @@ module Dalli
       if @continuum
         hkey = hash_for(key)
         20.times do |try|
-          entryidx = binary_search(@continuum, hkey)
+          # Find the closest index in the Ring with value <= the given value
+          entryidx = @continuum.bsearch_index { |entry| entry.value > hkey }
+          if entryidx.nil?
+            entryidx = @continuum.size - 1
+          else
+            entryidx -= 1
+          end
           server = @continuum[entryidx].server
           return server if server.alive?
           break unless @failover
@@ -40,7 +47,7 @@ module Dalli
         end
       else
         server = @servers.first
-        return server if server && server.alive?
+        return server if server&.alive?
       end
 
       raise Dalli::RingError, "No server available"
@@ -49,7 +56,7 @@ module Dalli
     def lock
       @servers.each(&:lock!)
       begin
-        return yield
+        yield
       ensure
         @servers.each(&:unlock!)
       end
@@ -71,63 +78,6 @@ module Dalli
       ((total_servers * POINTS_PER_SERVER * server.weight) / Float(total_weight)).floor
     end
 
-    # Native extension to perform the binary search within the continuum
-    # space.  Fallback to a pure Ruby version if the compilation doesn't work.
-    # optional for performance and only necessary if you are using multiple
-    # memcached servers.
-    begin
-      require 'inline'
-      inline do |builder|
-        builder.c <<-EOM
-        int binary_search(VALUE ary, unsigned int r) {
-            long upper = RARRAY_LEN(ary) - 1;
-            long lower = 0;
-            long idx = 0;
-            ID value = rb_intern("value");
-            VALUE continuumValue;
-            unsigned int l;
-
-            while (lower <= upper) {
-                idx = (lower + upper) / 2;
-
-                continuumValue = rb_funcall(RARRAY_PTR(ary)[idx], value, 0);
-                l = NUM2UINT(continuumValue);
-                if (l == r) {
-                    return idx;
-                }
-                else if (l > r) {
-                    upper = idx - 1;
-                }
-                else {
-                    lower = idx + 1;
-                }
-            }
-            return upper;
-        }
-        EOM
-      end
-    rescue LoadError
-      # Find the closest index in the Ring with value <= the given value
-      def binary_search(ary, value)
-        upper = ary.size - 1
-        lower = 0
-
-        while (lower <= upper) do
-          idx = (lower + upper) / 2
-          comp = ary[idx].value <=> value
-
-          if comp == 0
-            return idx
-          elsif comp > 0
-            upper = idx - 1
-          else
-            lower = idx + 1
-          end
-        end
-        upper
-      end
-    end
-
     class Entry
       attr_reader :value
       attr_reader :server
@@ -137,6 +87,5 @@ module Dalli
         @server = srv
       end
     end
-
   end
 end