dalli 3.0.6 → 3.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: adcf2507fd177cbc44167154462aae102a6f34f9cd6a85ba29ea9a26e87efce6
-  data.tar.gz: 57bd7da6c8c90fbcd99c4738bdb061df3630df0ff17ead1cc510d5d58f8677e2
+  metadata.gz: '0905b56adf194401de7755ab22ebef6b57f6e673e8332f7cb99b3ef9ed1dde63'
+  data.tar.gz: dac2014c748ef0c55fe171af0cec8dec807ae2468f758338c8968135acd47b92
 SHA512:
-  metadata.gz: cec1cceffc54713b77746ec455ddd3817b0dad37ceacb33d20f5f82a51015c7d82788ad78d043f4859d26a6c236bb57d8aac053770ea464827c5c22f07057d98
-  data.tar.gz: 70e93ae5cca84bc211315359391bad55b2f31908604ee195f42e701b472ab469074f3ee9350618491cfbf9d34b53f4e41950998e8e34cd446d8c4aca63d4b0d4
+  metadata.gz: 85d8382dfd13c2353a61c74525e17bd81e000308e8d476851ed25fdb6ef81e9aff4276eb0b1484e30c83001301a3500140cb46a595081e1b21f0801ea32d7e28
+  data.tar.gz: 7f0adfc09e31d435bbb3f6cff2f65392a58f81697e7025ca71d9423f9a536d9c984ed7ba0742d0c0f5de0e865a7ebd2dc5548a0406c86d7f1fe0c8135c7af363

data/History.md

@@ -1,6 +1,35 @@
 Dalli Changelog
 =====================
 
+Unreleased
+==========
+
+3.1.3
+==========
+
+- Restore falsey behavior on delete/delete_cas for nonexistent key (petergoldstein)
+
+3.1.2
+==========
+
+- Make quiet? / multi? public on Dalli::Protocol::Binary (petergoldstein)
+
+3.1.1
+==========
+
+- Add quiet support for incr, decr, append, depend, and flush (petergoldstein)
+- Additional refactoring to allow reuse of connection behavior (petergoldstein)
+- Fix issue in flush such that it wasn't passing the delay argument to memcached (petergoldstein)
+
+3.1.0
+==========
+
+- BREAKING CHANGE: Update Rack::Session::Dalli to inherit from Abstract::PersistedSecure.  This will invalidate existing sessions (petergoldstein)
+- BREAKING CHANGE: Use of unsupported operations in a multi block now raise an error. (petergoldstein)
+- Extract PipelinedGetter from Dalli::Client (petergoldstein)
+- Fix SSL socket so that it works with pipelined gets (petergoldstein)
+- Additional refactoring to split classes (petergoldstein)
+
 3.0.6
 ==========
 

data/lib/dalli/client.rb

@@ -49,7 +49,7 @@ module Dalli
     def initialize(servers = nil, options = {})
       @servers = ::Dalli::ServersArgNormalizer.normalize_servers(servers)
       @options = normalize_options(options)
-      @key_manager = ::Dalli::KeyManager.new(options)
+      @key_manager = ::Dalli::KeyManager.new(@options)
       @ring = nil
     end
 
@@ -58,24 +58,39 @@ module Dalli
     #
 
     ##
-    # Turn on quiet aka noreply support.
-    # All relevant operations within this block will be effectively
-    # pipelined as Dalli will use 'quiet' operations where possible.
-    # Currently supports the set, add, replace and delete operations.
-    def multi
-      old = Thread.current[:dalli_multi]
-      Thread.current[:dalli_multi] = true
-      yield
-    ensure
-      @ring&.flush_multi_responses
-      Thread.current[:dalli_multi] = old
+    # Get the value associated with the key.
+    # If a value is not found, then +nil+ is returned.
+    def get(key, req_options = nil)
+      perform(:get, key, req_options)
     end
 
     ##
-    # Get the value associated with the key.
+    # Gat (get and touch) fetch an item and simultaneously update its expiration time.
+    #
     # If a value is not found, then +nil+ is returned.
-    def get(key, options = nil)
-      perform(:get, key, options)
+    def gat(key, ttl = nil)
+      perform(:gat, key, ttl_or_default(ttl))
+    end
+
+    ##
+    # Touch updates expiration time for a given key.
+    #
+    # Returns true if key exists, otherwise nil.
+    def touch(key, ttl = nil)
+      resp = perform(:touch, key, ttl_or_default(ttl))
+      resp.nil? ? nil : true
+    end
+
+    ##
+    # Get the value and CAS ID associated with the key.  If a block is provided,
+    # value and CAS will be passed to the block.
+    def get_cas(key)
+      (value, cas) = perform(:cas, key)
+      #  TODO: This is odd.  Confirm this is working as expected.
+      value = nil if !value || value == 'Not found'
+      return [value, cas] unless block_given?
+
+      yield value, cas
     end
 
     ##
@@ -89,15 +104,29 @@ module Dalli
       return {} if keys.empty?
 
       if block_given?
-        get_multi_yielder(keys) { |k, data| yield k, data.first }
+        pipelined_getter.process(keys) { |k, data| yield k, data.first }
       else
         {}.tap do |hash|
-          get_multi_yielder(keys) { |k, data| hash[k] = data.first }
+          pipelined_getter.process(keys) { |k, data| hash[k] = data.first }
         end
       end
     end
 
-    CACHE_NILS = { cache_nils: true }.freeze
+    ##
+    # Fetch multiple keys efficiently, including available metadata such as CAS.
+    # If a block is given, yields key/data pairs one a time.  Data is an array:
+    # [value, cas_id]
+    # If no block is given, returns a hash of
+    #   { 'key' => [value, cas_id] }
+    def get_multi_cas(*keys)
+      if block_given?
+        pipelined_getter.process(keys) { |*args| yield(*args) }
+      else
+        {}.tap do |hash|
+          pipelined_getter.process(keys) { |k, data| hash[k] = data }
+        end
+      end
+    end
 
     # Fetch the value associated with the key.
     # If a value is found, then it is returned.
@@ -110,19 +139,11 @@ module Dalli
     def fetch(key, ttl = nil, req_options = nil)
       req_options = req_options.nil? ? CACHE_NILS : req_options.merge(CACHE_NILS) if cache_nils
       val = get(key, req_options)
-      if not_found?(val) && block_given?
-        val = yield
-        add(key, val, ttl_or_default(ttl), req_options)
-      end
-      val
-    end
+      return val unless block_given? && not_found?(val)
 
-    def not_found?(val)
-      cache_nils ? val == ::Dalli::NOT_FOUND : val.nil?
-    end
-
-    def cache_nils
-      @options[:cache_nils]
+      new_val = yield
+      add(key, new_val, ttl_or_default(ttl), req_options)
+      new_val
     end
 
     ##
@@ -136,8 +157,8 @@ module Dalli
     # - nil if the key did not exist.
     # - false if the value was changed by someone else.
     # - true if the value was successfully updated.
-    def cas(key, ttl = nil, options = nil, &block)
-      cas_core(key, false, ttl, options, &block)
+    def cas(key, ttl = nil, req_options = nil, &block)
+      cas_core(key, false, ttl, req_options, &block)
     end
 
     ##
@@ -147,30 +168,78 @@ module Dalli
     # Returns:
     # - false if the value was changed by someone else.
     # - true if the value was successfully updated.
-    def cas!(key, ttl = nil, options = nil, &block)
-      cas_core(key, true, ttl, options, &block)
+    def cas!(key, ttl = nil, req_options = nil, &block)
+      cas_core(key, true, ttl, req_options, &block)
+    end
+
+    ##
+    # Turn on quiet aka noreply support for a number of
+    # memcached operations.
+    #
+    # All relevant operations within this block will be effectively
+    # pipelined as Dalli will use 'quiet' versions.  The invoked methods
+    # will all return nil, rather than their usual response.  Method
+    # latency will be substantially lower, as the caller will not be
+    # blocking on responses.
+    #
+    # Currently supports storage (set, add, replace, append, prepend),
+    # arithmetic (incr, decr), flush and delete operations.  Use of
+    # unsupported operations inside a block will raise an error.
+    #
+    # Any error replies will be discarded at the end of the block, and
+    # Dalli client methods invoked inside the block will not
+    # have return values
+    def quiet
+      old = Thread.current[::Dalli::QUIET]
+      Thread.current[::Dalli::QUIET] = true
+      yield
+    ensure
+      @ring&.pipeline_consume_and_ignore_responses
+      Thread.current[::Dalli::QUIET] = old
     end
+    alias multi quiet
 
-    def set(key, value, ttl = nil, options = nil)
-      perform(:set, key, value, ttl_or_default(ttl), 0, options)
+    def set(key, value, ttl = nil, req_options = nil)
+      set_cas(key, value, 0, ttl, req_options)
+    end
+
+    ##
+    # Set the key-value pair, verifying existing CAS.
+    # Returns the resulting CAS value if succeeded, and falsy otherwise.
+    def set_cas(key, value, cas, ttl = nil, req_options = nil)
+      perform(:set, key, value, ttl_or_default(ttl), cas, req_options)
     end
 
     ##
     # Conditionally add a key/value pair, if the key does not already exist
     # on the server.  Returns truthy if the operation succeeded.
-    def add(key, value, ttl = nil, options = nil)
-      perform(:add, key, value, ttl_or_default(ttl), options)
+    def add(key, value, ttl = nil, req_options = nil)
+      perform(:add, key, value, ttl_or_default(ttl), req_options)
     end
 
     ##
     # Conditionally add a key/value pair, only if the key already exists
     # on the server.  Returns truthy if the operation succeeded.
-    def replace(key, value, ttl = nil, options = nil)
-      perform(:replace, key, value, ttl_or_default(ttl), 0, options)
+    def replace(key, value, ttl = nil, req_options = nil)
+      replace_cas(key, value, 0, ttl, req_options)
+    end
+
+    ##
+    # Conditionally add a key/value pair, verifying existing CAS, only if the
+    # key already exists on the server.  Returns the new CAS value if the
+    # operation succeeded, or falsy otherwise.
+    def replace_cas(key, value, cas, ttl = nil, req_options = nil)
+      perform(:replace, key, value, ttl_or_default(ttl), cas, req_options)
+    end
+
+    # Delete a key/value pair, verifying existing CAS.
+    # Returns true if succeeded, and falsy otherwise.
+    def delete_cas(key, cas = 0)
+      perform(:delete, key, cas)
     end
 
     def delete(key)
-      perform(:delete, key, 0)
+      delete_cas(key, 0)
     end
 
     ##
@@ -187,13 +256,6 @@ module Dalli
       perform(:prepend, key, value.to_s)
     end
 
-    def flush(delay = 0)
-      time = -delay
-      ring.servers.map { |s| s.request(:flush, time += delay) }
-    end
-
-    alias flush_all flush
-
     ##
     # Incr adds the given amount to the counter on the memcached server.
     # Amt must be a positive integer value.
@@ -205,8 +267,10 @@ module Dalli
     # Note that the ttl will only apply if the counter does not already
     # exist.  To increase an existing counter and update its TTL, use
     # #cas.
+    #
+    # If the value already exists, it must have been set with raw: true
     def incr(key, amt = 1, ttl = nil, default = nil)
-      raise ArgumentError, "Positive values only: #{amt}" if amt.negative?
+      check_positive!(amt)
 
       perform(:incr, key, amt.to_i, ttl_or_default(ttl), default)
     end
@@ -225,35 +289,31 @@ module Dalli
     # Note that the ttl will only apply if the counter does not already
     # exist.  To decrease an existing counter and update its TTL, use
     # #cas.
+    #
+    # If the value already exists, it must have been set with raw: true
     def decr(key, amt = 1, ttl = nil, default = nil)
-      raise ArgumentError, "Positive values only: #{amt}" if amt.negative?
+      check_positive!(amt)
 
       perform(:decr, key, amt.to_i, ttl_or_default(ttl), default)
     end
 
     ##
-    # Touch updates expiration time for a given key.
-    #
-    # Returns true if key exists, otherwise nil.
-    def touch(key, ttl = nil)
-      resp = perform(:touch, key, ttl_or_default(ttl))
-      resp.nil? ? nil : true
-    end
-
+    # Flush the memcached server, at 'delay' seconds in the future.
+    # Delay defaults to zero seconds, which means an immediate flush.
     ##
-    # Gat (get and touch) fetch an item and simultaneously update its expiration time.
-    #
-    # If a value is not found, then +nil+ is returned.
-    def gat(key, ttl = nil)
-      perform(:gat, key, ttl_or_default(ttl))
+    def flush(delay = 0)
+      ring.servers.map { |s| s.request(:flush, delay) }
     end
+    alias flush_all flush
+
+    ALLOWED_STAT_KEYS = %i[items slabs settings].freeze
 
     ##
     # Collect the stats for each server.
     # You can optionally pass a type including :items, :slabs or :settings to get specific stats
     # Returns a hash like { 'hostname:port' => { 'stat1' => 'value1', ... }, 'hostname2:port' => { ... } }
     def stats(type = nil)
-      type = nil unless [nil, :items, :slabs, :settings].include? type
+      type = nil unless ALLOWED_STAT_KEYS.include? type
       values = {}
       ring.servers.each do |server|
         values[server.name.to_s] = server.alive? ? server.request(:stats, type.to_s) : nil
@@ -269,12 +329,6 @@ module Dalli
       end
     end
 
-    ##
-    ## Make sure memcache servers are alive, or raise an Dalli::RingError
-    def alive!
-      ring.server_for_key('')
-    end
-
     ##
     ## Version of the memcache servers.
     def version
@@ -286,68 +340,30 @@ module Dalli
     end
 
     ##
-    # Get the value and CAS ID associated with the key.  If a block is provided,
-    # value and CAS will be passed to the block.
-    def get_cas(key)
-      (value, cas) = perform(:cas, key)
-      value = nil if !value || value == 'Not found'
-      if block_given?
-        yield value, cas
-      else
-        [value, cas]
-      end
-    end
-
-    ##
-    # Fetch multiple keys efficiently, including available metadata such as CAS.
-    # If a block is given, yields key/data pairs one a time.  Data is an array:
-    # [value, cas_id]
-    # If no block is given, returns a hash of
-    #   { 'key' => [value, cas_id] }
-    def get_multi_cas(*keys)
-      if block_given?
-        get_multi_yielder(keys) { |*args| yield(*args) }
-      else
-        {}.tap do |hash|
-          get_multi_yielder(keys) { |k, data| hash[k] = data }
-        end
-      end
-    end
-
-    ##
-    # Set the key-value pair, verifying existing CAS.
-    # Returns the resulting CAS value if succeeded, and falsy otherwise.
-    def set_cas(key, value, cas, ttl = nil, options = nil)
-      ttl ||= @options[:expires_in].to_i
-      perform(:set, key, value, ttl, cas, options)
-    end
-
-    ##
-    # Conditionally add a key/value pair, verifying existing CAS, only if the
-    # key already exists on the server.  Returns the new CAS value if the
-    # operation succeeded, or falsy otherwise.
-    def replace_cas(key, value, cas, ttl = nil, options = nil)
-      ttl ||= @options[:expires_in].to_i
-      perform(:replace, key, value, ttl, cas, options)
-    end
-
-    # Delete a key/value pair, verifying existing CAS.
-    # Returns true if succeeded, and falsy otherwise.
-    def delete_cas(key, cas = 0)
-      perform(:delete, key, cas)
+    ## Make sure memcache servers are alive, or raise an Dalli::RingError
+    def alive!
+      ring.server_for_key('')
     end
 
     ##
     # Close our connection to each server.
     # If you perform another operation after this, the connections will be re-established.
     def close
-      return unless @ring
-
-      @ring.servers.each(&:close)
+      @ring&.close
       @ring = nil
     end
     alias reset close
 
+    CACHE_NILS = { cache_nils: true }.freeze
+
+    def not_found?(val)
+      cache_nils ? val == ::Dalli::NOT_FOUND : val.nil?
+    end
+
+    def cache_nils
+      @options[:cache_nils]
+    end
+
     # Stub method so a bare Dalli client can pretend to be a connection pool.
     def with
       yield self
@@ -355,15 +371,23 @@ module Dalli
 
     private
 
-    def cas_core(key, always_set, ttl = nil, options = nil)
+    def check_positive!(amt)
+      raise ArgumentError, "Positive values only: #{amt}" if amt.negative?
+    end
+
+    def cas_core(key, always_set, ttl = nil, req_options = nil)
       (value, cas) = perform(:cas, key)
       value = nil if !value || value == 'Not found'
       return if value.nil? && !always_set
 
       newvalue = yield(value)
-      perform(:set, key, newvalue, ttl_or_default(ttl), cas, options)
+      perform(:set, key, newvalue, ttl_or_default(ttl), cas, req_options)
     end
 
+    ##
+    # Uses the argument TTL or the client-wide default.  Ensures
+    # that the value is an integer
+    ##
     def ttl_or_default(ttl)
       (ttl || @options[:expires_in]).to_i
     rescue NoMethodError
@@ -384,7 +408,16 @@ module Dalli
       @protocol_implementation ||= @options.fetch(:protocol_implementation, Dalli::Protocol::Binary)
     end
 
-    # Chokepoint method for instrumentation
+    ##
+    # Chokepoint method for memcached methods with a key argument.
+    # Validates the key, resolves the key to the appropriate server
+    # instance, and invokes the memcached method on the appropriate
+    # server.
+    #
+    # This method also forces retries on network errors - when
+    # a particular memcached instance becomes unreachable, or the
+    # operational times out.
+    ##
     def perform(*all_args)
       return yield if block_given?
 
@@ -402,145 +435,14 @@ module Dalli
     end
 
     def normalize_options(opts)
-      begin
-        opts[:expires_in] = opts[:expires_in].to_i if opts[:expires_in]
-      rescue NoMethodError
-        raise ArgumentError, "cannot convert :expires_in => #{opts[:expires_in].inspect} to an integer"
-      end
+      opts[:expires_in] = opts[:expires_in].to_i if opts[:expires_in]
       opts
+    rescue NoMethodError
+      raise ArgumentError, "cannot convert :expires_in => #{opts[:expires_in].inspect} to an integer"
     end
 
-    # TODO: Look at extracting below into separate MultiYielder class
-
-    ##
-    # Yields, one at a time, keys and their values+attributes.
-    #
-    def get_multi_yielder(keys, &block)
-      return {} if keys.empty?
-
-      ring.lock do
-        groups = groups_for_keys(keys)
-        if (unfound_keys = groups.delete(nil))
-          Dalli.logger.debug do
-            "unable to get keys for #{unfound_keys.length} keys "\
-              'because no matching server was found'
-          end
-        end
-        make_multi_get_requests(groups)
-
-        servers = groups.keys
-        return if servers.empty?
-
-        # TODO: How does this exit on a NetworkError
-        servers = perform_multi_response_start(servers)
-
-        timeout = servers.first.options[:socket_timeout]
-        start_time = Time.now
-        loop do
-          # remove any dead servers
-          # TODO: Is this well behaved in a multi-threaded environment?
-          # Accessing the server socket like this seems problematic
-          servers.delete_if { |s| s.sock.nil? }
-          break if servers.empty?
-
-          servers = multi_yielder_loop(servers, start_time, timeout, &block)
-        end
-      end
-    rescue NetworkError => e
-      Dalli.logger.debug { e.inspect }
-      Dalli.logger.debug { 'retrying multi yielder because of timeout' }
-      retry
-    end
-
-    def make_multi_get_requests(groups)
-      groups.each do |server, keys_for_server|
-        server.request(:send_multiget, keys_for_server)
-      rescue DalliError, NetworkError => e
-        Dalli.logger.debug { e.inspect }
-        Dalli.logger.debug { "unable to get keys for server #{server.name}" }
-      end
-    end
-
-    # raises Dalli::NetworkError
-    def perform_multi_response_start(servers)
-      deleted = []
-
-      servers.each do |server|
-        next unless server.alive?
-
-        begin
-          server.multi_response_start
-        rescue Dalli::NetworkError
-          abort_multi_response(servers)
-          raise
-        rescue Dalli::DalliError => e
-          Dalli.logger.debug { e.inspect }
-          Dalli.logger.debug { 'results from this server will be missing' }
-          deleted.append(server)
-        end
-      end
-
-      servers.delete_if { |server| deleted.include?(server) }
-    end
-
-    # Swallows Dalli::NetworkError
-    def abort_multi_response(servers)
-      servers.each(&:multi_response_abort)
-    end
-
-    def multi_yielder_loop(servers, start_time, timeout, &block)
-      time_left = remaining_time(start_time, timeout)
-      readable_servers = servers_with_data(servers, time_left)
-      if readable_servers.empty?
-        abort_multi_connections_w_timeout(servers)
-        return readable_servers
-      end
-
-      readable_servers.each do |server|
-        servers.delete(server) if respond_to_readable_server(server, &block)
-      end
-      servers
-    rescue NetworkError
-      abort_multi_response(servers)
-      raise
-    end
-
-    def remaining_time(start, timeout)
-      elapsed = Time.now - start
-      return 0 if elapsed > timeout
-
-      timeout - elapsed
-    end
-
-    # Swallows Dalli::NetworkError
-    def abort_multi_connections_w_timeout(servers)
-      abort_multi_response(servers)
-      servers.each do |server|
-        Dalli.logger.debug { "memcached at #{server.name} did not response within timeout" }
-      end
-
-      true # Required to simplify caller
-    end
-
-    def respond_to_readable_server(server)
-      server.multi_response_nonblock.each_pair do |key, value_list|
-        yield @key_manager.key_without_namespace(key), value_list
-      end
-
-      server.multi_response_completed?
-    end
-
-    def servers_with_data(servers, timeout)
-      readable, = IO.select(servers.map(&:sock), nil, nil, timeout)
-      return [] if readable.nil?
-
-      readable.map(&:server)
-    end
-
-    def groups_for_keys(*keys)
-      keys.flatten!
-      keys.map! { |a| @key_manager.validate_key(a.to_s) }
-      ring.keys_grouped_by_server(keys)
+    def pipelined_getter
+      PipelinedGetter.new(ring, @key_manager)
     end
   end
 end

data/lib/dalli/options.rb

@@ -31,19 +31,19 @@ module Dalli
       end
     end
 
-    def multi_response_start
+    def pipeline_response_setup
       @lock.synchronize do
         super
       end
     end
 
-    def multi_response_nonblock
+    def pipeline_next_responses
       @lock.synchronize do
         super
       end
     end
 
-    def multi_response_abort
+    def pipeline_abort
       @lock.synchronize do
         super
       end