dalli 2.7.4 → 3.2.5

data/lib/dalli/ring.rb

@@ -1,59 +1,103 @@
+# frozen_string_literal: true
+
 require 'digest/sha1'
 require 'zlib'
 
 module Dalli
+  ##
+  # An implementation of a consistent hash ring, designed to minimize
+  # the cache miss impact of adding or removing servers from the ring.
+  # That is, adding or removing a server from the ring should impact
+  # the key -> server mapping of ~ 1/N of the stored keys where N is the
+  # number of servers in the ring.  This is done by creating a large
+  # number of "points" per server, distributed over the space
+  # 0x00000000 - 0xFFFFFFFF. For a given key, we calculate the CRC32
+  # hash, and find the nearest "point" that is less than or equal to the
+  # the key's hash.  In this implemetation, each "point" is represented
+  # by a Dalli::Ring::Entry.
+  ##
   class Ring
+    # The number of entries on the continuum created per server
+    # in an equally weighted scenario.
     POINTS_PER_SERVER = 160 # this is the default in libmemcached
 
     attr_accessor :servers, :continuum
 
-    def initialize(servers, options)
-      @servers = servers
-      @continuum = nil
-      if servers.size > 1
-        total_weight = servers.inject(0) { |memo, srv| memo + srv.weight }
-        continuum = []
-        servers.each do |server|
-          entry_count_for(server, servers.size, total_weight).times do |idx|
-            hash = Digest::SHA1.hexdigest("#{server.name}:#{idx}")
-            value = Integer("0x#{hash[0..7]}")
-            continuum << Dalli::Ring::Entry.new(value, server)
-          end
-        end
-        @continuum = continuum.sort { |a, b| a.value <=> b.value }
+    def initialize(servers_arg, protocol_implementation, options)
+      @servers = servers_arg.map do |s|
+        protocol_implementation.new(s, options)
       end
+      @continuum = nil
+      @continuum = build_continuum(servers) if servers.size > 1
 
       threadsafe! unless options[:threadsafe] == false
       @failover = options[:failover] != false
     end
 
     def server_for_key(key)
-      if @continuum
-        hkey = hash_for(key)
-        20.times do |try|
-          entryidx = binary_search(@continuum, hkey)
-          server = @continuum[entryidx].server
-          return server if server.alive?
-          break unless @failover
-          hkey = hash_for("#{try}#{key}")
-        end
-      else
-        server = @servers.first
-        return server if server && server.alive?
+      server = if @continuum
+                 server_from_continuum(key)
+               else
+                 @servers.first
+               end
+
+      # Note that the call to alive? has the side effect of initializing
+      # the socket
+      return server if server&.alive?
+
+      raise Dalli::RingError, 'No server available'
+    end
+
+    def server_from_continuum(key)
+      hkey = hash_for(key)
+      20.times do |try|
+        server = server_for_hash_key(hkey)
+
+        # Note that the call to alive? has the side effect of initializing
+        # the socket
+        return server if server.alive?
+        break unless @failover
+
+        hkey = hash_for("#{try}#{key}")
       end
+      nil
+    end
 
-      raise Dalli::RingError, "No server available"
+    def keys_grouped_by_server(key_arr)
+      key_arr.group_by do |key|
+        server_for_key(key)
+      rescue Dalli::RingError
+        Dalli.logger.debug { "unable to get key #{key}" }
+        nil
+      end
     end
 
     def lock
-      @servers.each { |s| s.lock! }
+      @servers.each(&:lock!)
       begin
-        return yield
+        yield
       ensure
-        @servers.each { |s| s.unlock! }
+        @servers.each(&:unlock!)
       end
     end
 
+    def pipeline_consume_and_ignore_responses
+      @servers.each do |s|
+        s.request(:noop)
+      rescue Dalli::NetworkError
+        # Ignore this error, as it indicates the socket is unavailable
+        # and there's no need to flush
+      end
+    end
+
+    def socket_timeout
+      @servers.first.socket_timeout
+    end
+
+    def close
+      @servers.each(&:close)
+    end
+
     private
 
     def threadsafe!
@@ -70,73 +114,40 @@ 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
+    def server_for_hash_key(hash_key)
       # Find the closest index in the Ring with value <= the given value
-      def binary_search(ary, value)
-        upper = ary.size - 1
-        lower = 0
-        idx = 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
+      entryidx = @continuum.bsearch_index { |entry| entry.value > hash_key }
+      if entryidx.nil?
+        entryidx = @continuum.size - 1
+      else
+        entryidx -= 1
+      end
+      @continuum[entryidx].server
+    end
+
+    def build_continuum(servers)
+      continuum = []
+      total_weight = servers.inject(0) { |memo, srv| memo + srv.weight }
+      servers.each do |server|
+        entry_count_for(server, servers.size, total_weight).times do |idx|
+          hash = Digest::SHA1.hexdigest("#{server.name}:#{idx}")
+          value = Integer("0x#{hash[0..7]}")
+          continuum << Dalli::Ring::Entry.new(value, server)
         end
-        return upper
       end
+      continuum.sort_by(&:value)
     end
 
+    ##
+    # Represents a point in the consistent hash ring implementation.
+    ##
     class Entry
-      attr_reader :value
-      attr_reader :server
+      attr_reader :value, :server
 
       def initialize(val, srv)
         @value = val
         @server = srv
       end
     end
-
   end
 end