sayso-dalli 1.0.3.001

data/lib/dalli/compatibility.rb

@@ -0,0 +1,52 @@
+class Dalli::Client
+
+  module MemcacheClientCompatibility
+
+    def initialize(*args)
+      Dalli.logger.error("Starting Dalli in memcache-client compatibility mode")
+      super(*args)
+    end
+
+    def set(key, value, ttl = nil, options = nil)
+      if options == true || options == false
+        Dalli.logger.error("Dalli: please use set(key, value, ttl, :raw => boolean): #{caller[0]}")
+        options = { :raw => options }
+      end
+      super(key, value, ttl, options) ? "STORED\r\n" : "NOT_STORED\r\n"
+
+    end
+
+    def add(key, value, ttl = nil, options = nil)
+      if options == true || options == false
+        Dalli.logger.error("Dalli: please use add(key, value, ttl, :raw => boolean): #{caller[0]}")
+        options = { :raw => options }
+      end
+      super(key, value, ttl, options) ? "STORED\r\n" : "NOT_STORED\r\n"
+    end
+
+    def replace(key, value, ttl = nil, options = nil)
+      if options == true || options == false
+        Dalli.logger.error("Dalli: please use replace(key, value, ttl, :raw => boolean): #{caller[0]}")
+        options = { :raw => options }
+      end
+      super(key, value, ttl, options) ? "STORED\r\n" : "NOT_STORED\r\n"
+    end
+
+    # Dalli does not unmarshall data that does not have the marshalled flag set so we need
+    # to unmarshall manually any marshalled data originally put in memcached by memcache-client.
+    # Peek at the data and see if it looks marshalled.
+    def get(key, options = nil)
+      value = super(key, options)
+      if value && value.is_a?(String) && !options && value.size > 2 &&
+              bytes = value.unpack('cc') && bytes[0] == 4 && bytes[1] == 8
+        return Marshal.load(value) rescue value
+      end
+      value
+    end
+
+    def delete(key)
+      super(key) ? "DELETED\r\n" : "NOT_DELETED\r\n"
+    end
+  end
+
+end

data/lib/dalli/memcache-client.rb

@@ -0,0 +1 @@
+Dalli::Client.compatibility_mode = true

data/lib/dalli/options.rb

@@ -0,0 +1,44 @@
+require 'thread'
+require 'monitor'
+
+module Dalli
+
+  # Make Dalli threadsafe by using a lock around all
+  # public server methods.
+  #
+  # Dalli::Server.extend(Dalli::Threadsafe)
+  #
+  module Threadsafe
+    def request(op, *args)
+      lock.synchronize do
+        super
+      end
+    end
+
+    def alive?
+      lock.synchronize do
+        super
+      end
+    end
+
+    def close
+      lock.synchronize do
+        super
+      end
+    end
+
+    def lock!
+      lock.mon_enter
+    end
+
+    def unlock!
+      lock.mon_exit
+    end
+
+    private
+    def lock
+      @lock ||= Monitor.new
+    end
+
+  end
+end

data/lib/dalli/ring.rb

@@ -0,0 +1,105 @@
+require 'digest/sha1'
+require 'zlib'
+
+module Dalli
+  class Ring
+    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.hostname}:#{server.port}:#{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 }
+      end
+
+      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 = self.class.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?
+      end
+
+      raise Dalli::RingError, "No server available"
+    end
+    
+    def lock
+      @servers.each { |s| s.lock! }
+      begin
+        return yield
+      ensure
+        @servers.each { |s| s.unlock! }
+      end
+    end
+    
+    private
+
+    def threadsafe!
+      @servers.each do |s|
+        s.extend(Dalli::Threadsafe)
+      end
+    end
+
+    def hash_for(key)
+      Zlib.crc32(key)
+    end
+
+    def entry_count_for(server, total_servers, total_weight)
+      ((total_servers * POINTS_PER_SERVER * server.weight) / Float(total_weight)).floor
+    end
+
+    # Find the closest index in the Ring with value <= the given value
+    def self.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
+      end
+      return upper
+    end
+
+    class Entry
+      attr_reader :value
+      attr_reader :server
+
+      def initialize(val, srv)
+        @value = val
+        @server = srv
+      end
+    end
+
+  end
+end