memcache 1.2.0 → 1.2.1

data/lib/memcache/local_server.rb

@@ -1,5 +1,5 @@
 class Memcache
-  class LocalServer
+  class LocalServer < Base
     def initialize
       @data = {}
       @expiry = {}
@@ -22,10 +22,6 @@ class Memcache
       @expiry.clear
     end
 
-    def gets(keys)
-      get(keys, true)
-    end
-
     def get(keys, cas = false)
       if keys.kind_of?(Array)
         hash = {}
@@ -36,7 +32,7 @@ class Memcache
         end
         hash
       else
-        key = keys.to_s
+        key = cache_key(keys)
         if @expiry[key] and Time.now > @expiry[key]
           @data[key]   = nil
           @expiry[key] = nil
@@ -45,63 +41,21 @@ class Memcache
       end
     end
 
-    def incr(key, amount = 1)
-      key = key.to_s
-      value = get(key)
-      return unless value
-      return unless value =~ /^\d+$/
-
-      value = value.to_i + amount
-      value = 0 if value < 0
-      @data[key] = value.to_s
-      value
-    end
-
-    def decr(key, amount = 1)
-      incr(key, -amount)
-    end
-
-    def delete(key)
-      @data.delete(key.to_s)
-    end
-
     def set(key, value, expiry = 0, flags = 0)
-      key = key.to_s
+      key = cache_key(key)
       @data[key] = value.to_s
+      expiry = Time.at(expiry) if expiry > 60*60*24*30
       if expiry.kind_of?(Time)
         @expiry[key] = expiry
-      else  
+      else
         expiry = expiry.to_i
         @expiry[key] = expiry == 0 ? nil : Time.now + expiry
       end
       value
     end
 
-    def cas(key, value, cas, expiry = 0, flags = 0)
-      # No cas implementation yet, just do a set for now.
-      set(key, value, expiry, flags)
-    end
-
-    def add(key, value, expiry = 0, flags = 0)
-      return nil if get(key)
-      set(key, value, expiry)
-    end
-
-    def replace(key, value, expiry = 0, flags = 0)
-      return nil if get(key).nil?
-      set(key, value, expiry)
-    end
-
-    def append(key, value)
-      existing = get(key)
-      return nil if existing.nil?
-      set(key, existing + value)
-    end
-
-    def prepend(key, value)
-      existing = get(key)
-      return nil if existing.nil?
-      set(key, value + existing)
+    def delete(key)
+      @data.delete(cache_key(key)) && true
     end
   end
 end

data/lib/memcache/migration.rb

@@ -3,19 +3,20 @@ class Memcache
     class << self
       attr_accessor :table
     end
-    
+
     def self.up
       create_table table, :id => false do |t|
-        t.string    :key
-        t.text      :value
+        t.string    :prefix, :null => false
+        t.string    :key,    :null => false
+        t.text      :value,  :null => false
         t.timestamp :expires_at
         t.timestamp :updated_at
       end
-      
-      add_index table, [:key], :unique => true
+
+      add_index table, [:prefix, :key], :unique => true
       add_index table, [:expires_at]
     end
-    
+
     def self.down
       drop_table table
     end

data/lib/memcache/null_server.rb

@@ -1,5 +1,5 @@
 class Memcache
-  class NullServer
+  class NullServer < Base
     def name
       "null"
     end

data/lib/memcache/pg_server.rb

@@ -1,8 +1,14 @@
 require 'active_record'
 require 'memcache/migration'
 
+class PGconn
+  def self.quote_ident(name)
+    %("#{name}")
+  end
+end
+
 class Memcache
-  class PGServer
+  class PGServer < Base
     attr_reader :db, :table
 
     def initialize(opts)
@@ -23,11 +29,12 @@ class Memcache
 
     def get(keys)
       return get([keys])[keys.to_s] unless keys.kind_of?(Array)
+      return {} if keys.empty?
 
       keys = keys.collect {|key| quote(key.to_s)}.join(',')
       sql = %{
         SELECT key, value FROM #{table}
-          WHERE key IN (#{keys}) AND #{expiry_clause}
+          WHERE key IN (#{keys}) AND #{prefix_clause} AND #{expiry_clause}
       }
       results = {}
       db.query(sql).each do |key, value|
@@ -39,14 +46,14 @@ class Memcache
     def incr(key, amount = 1)
       transaction do
         value = get(key)
-        return unless value        
+        return unless value
         return unless value =~ /^\d+$/
-        
+
         value = value.to_i + amount
         value = 0 if value < 0
         db.exec %{
           UPDATE #{table} SET value = #{quote(value)}, updated_at = NOW()
-            WHERE key = #{quote(key)}
+            WHERE key = #{quote(key)} AND #{prefix_clause}
         }
         value
       end
@@ -59,8 +66,9 @@ class Memcache
     def delete(key)
       result = db.exec %{
         DELETE FROM #{table}
-          WHERE key = #{quote(key)}
+          WHERE key = #{quote(key)} AND #{prefix_clause}
       }
+      result.cmdtuples == 1
     end
 
     def set(key, value, expiry = 0)
@@ -79,38 +87,38 @@ class Memcache
       nil
     end
 
-    def replace(key, value, expiry = 0)      
+    def replace(key, value, expiry = 0)
       delete_expired(key)
       result = update(key, value, expiry)
       result.cmdtuples == 1 ? value : nil
     end
 
-    def append(key, value)      
+    def append(key, value)
       delete_expired(key)
       result = db.exec %{
         UPDATE #{table}
           SET value = value || #{quote(value)}, updated_at = NOW()
-          WHERE key = #{quote(key)}
+          WHERE key = #{quote(key)} AND #{prefix_clause}
       }
       result.cmdtuples == 1
     end
 
-    def prepend(key, value)      
+    def prepend(key, value)
       delete_expired(key)
       result = db.exec %{
         UPDATE #{table}
           SET value = #{quote(value)} || value, updated_at = NOW()
-          WHERE key = #{quote(key)}
+          WHERE key = #{quote(key)} AND #{prefix_clause}
       }
       result.cmdtuples == 1
     end
 
   private
- 
+
     def insert(key, value, expiry = 0)
       db.exec %{
-        INSERT INTO #{table} (key, value, updated_at, expires_at)
-          VALUES (#{quote(key)}, #{quote(value)}, NOW(), #{expiry_sql(expiry)})
+        INSERT INTO #{table} (prefix, key, value, updated_at, expires_at)
+          VALUES (#{quoted_prefix}, #{quote(key)}, #{quote(value)}, NOW(), #{expiry_sql(expiry)})
       }
     end
 
@@ -118,14 +126,14 @@ class Memcache
       db.exec %{
         UPDATE #{table}
           SET value = #{quote(value)}, updated_at = NOW(), expires_at = #{expiry_sql(expiry)}
-          WHERE key = #{quote(key)}
+          WHERE key = #{quote(key)} AND #{prefix_clause}
       }
     end
 
     def transaction
       return yield if @in_transaction
-      
-      begin 
+
+      begin
         @in_transaction = true
         db.exec('BEGIN')
         value = yield
@@ -138,26 +146,35 @@ class Memcache
         @in_transaction = false
       end
     end
-      
+
     def quote(string)
       string.to_s.gsub(/'/,"\'")
       "'#{string}'"
     end
 
     def delete_expired(key)
-      db.exec "DELETE FROM #{table} WHERE key = #{quote(key)} AND NOT (#{expiry_clause})"
+      db.exec "DELETE FROM #{table} WHERE key = #{quote(key)} AND #{prefix_clause} AND NOT (#{expiry_clause})"
     end
-    
+
     def expiry_clause
       "expires_at IS NULL OR expires_at > NOW()"
     end
 
     def expiry_sql(expiry)
+      expiry = Time.at(expiry) if expiry > 60*60*24*30
       if expiry.kind_of?(Time)
         quote(expiry.to_s(:db))
       else
         expiry == 0 ? 'NULL' : "NOW() + interval '#{expiry} seconds'"
       end
     end
+
+    def quoted_prefix
+      quote(prefix || '')
+    end
+
+    def prefix_clause
+      "prefix = #{quoted_prefix}"
+    end
   end
 end

data/lib/memcache/{segmented_server.rb → segmented.rb}

@@ -1,15 +1,15 @@
 require 'digest/sha1'
 
 class Memcache
-  class SegmentedServer < Server
+  module Segmented
     MAX_SIZE = 1000000 # bytes
     PARTIAL_VALUE = 0x40000000
-    
+
     def get(keys, cas = nil)
       return get([keys], cas)[keys.to_s] unless keys.kind_of?(Array)
       return {} if keys.empty?
 
-      results = super
+      results = super(keys, cas)
       keys = {}
       keys_to_fetch = []
       results.each do |key, value|
@@ -19,14 +19,14 @@ class Memcache
         num.to_i.times do |i|
           hash_key = "#{hash}:#{i}"
           keys_to_fetch << hash_key
-          keys[key]     << hash_key 
+          keys[key]     << hash_key
         end
       end
-      
+
       parts = super(keys_to_fetch)
       keys.each do |key, hashes|
         value = ''
-        hashes.each do |hash_key|          
+        hashes.each do |hash_key|
           if part = parts[hash_key]
             value << part
           else
@@ -45,23 +45,23 @@ class Memcache
     end
 
     def set(key, value, expiry = 0, flags = 0)
-      value, flags = store_segments(key, value, expiry, flags)
-      super(key, value, expiry, flags) && value
+      hash, flags = store_segments(key, value, expiry, flags)
+      super(key, hash, expiry, flags) && value
     end
 
     def cas(key, value, cas, expiry = 0, flags = 0)
-      value, flags = store_segments(key, value, expiry, flags)
-      super(key, value, cas, expiry, flags)
+      hash, flags = store_segments(key, value, expiry, flags)
+      super(key, hash, cas, expiry, flags) && value
     end
 
     def add(key, value, expiry = 0, flags = 0)
-      value, flags = store_segments(key, value, expiry, flags)
-      super(key, value, expiry, flags)
+      hash, flags = store_segments(key, value, expiry, flags)
+      super(key, hash, expiry, flags) && value
     end
 
     def replace(key, value, expiry = 0, flags = 0)
-      value, flags = store_segments(key, value, expiry, flags)
-      super(key, value, expiry, flags)
+      hash, flags = store_segments(key, value, expiry, flags)
+      super(key, hash, expiry, flags) && value
     end
 
   private
@@ -81,7 +81,7 @@ class Memcache
       master_key = "#{hash}:#{parts.size}"
       [master_key, parts]
     end
-    
+
     def store_segments(key, value, expiry = 0, flags = 0)
       if value and value.size > MAX_SIZE
         master_key, parts = segment(key, value)
@@ -95,4 +95,14 @@ class Memcache
       end
     end
   end
+
+  class SegmentedServer < Server
+    include Memcache::Segmented
+  end
+
+  if defined?(NativeServer)
+    class SegmentedNativeServer < NativeServer
+      include Memcache::Segmented
+    end
+  end
 end

data/lib/memcache/server.rb

@@ -3,7 +3,7 @@ require 'thread'
 require 'timeout'
 
 class Memcache
-  class Server
+  class Server < Base
     CONNECT_TIMEOUT  = 1.0
     READ_RETRY_DELAY = 5.0
     DEFAULT_PORT     = 11211
@@ -13,13 +13,12 @@ class Memcache
     def initialize(opts)
       @host         = opts[:host]
       @port         = opts[:port] || DEFAULT_PORT
-      @readonly     = opts[:readonly]
       @strict_reads = opts[:strict_reads]
       @status       = 'NOT CONNECTED'
     end
 
     def clone
-      self.class.new(:host => host, :port => port, :readonly => readonly?, :strict_reads => strict_reads?)
+      self.class.new(:host => host, :port => port, :strict_reads => strict_reads?)
     end
 
     def inspect
@@ -34,10 +33,6 @@ class Memcache
       @retry_at.nil? or @retry_at < Time.now
     end
 
-    def readonly?
-      @readonly
-    end
-
     def strict_reads?
       @strict_reads
     end
@@ -46,7 +41,7 @@ class Memcache
       # Close the socket. If there is an error, mark the server dead.
       @socket.close if @socket and not @socket.closed?
       @socket = nil
-      
+
       if error
         @retry_at = Time.now + READ_RETRY_DELAY
         @status   = "DEAD: %s: %s, will retry at %s" % [error.class, error.message, @retry_at]
@@ -71,22 +66,15 @@ class Memcache
       end
       stats
     end
-    
+
     def count
       stats['curr_items']
     end
 
     def flush_all(delay = nil)
-      check_writable!
       write_command("flush_all #{delay}")
     end
 
-    alias clear flush_all
-
-    def gets(keys)
-      get(keys, true)
-    end
-
     def get(keys, cas = nil)
       return get([keys], cas)[keys.to_s] unless keys.kind_of?(Array)
       return {} if keys.empty?
@@ -94,99 +82,99 @@ class Memcache
       method = cas ? 'gets' : 'get'
 
       results = {}
+      keys = keys.collect {|key| cache_key(key)}
+
       read_command("#{method} #{keys.join(' ')}") do |response|
         if cas
           key, flags, length, cas = match_response!(response, /^VALUE ([^\s]+) ([^\s]+) ([^\s]+) ([^\s]+)/)
         else
           key, flags, length = match_response!(response, /^VALUE ([^\s]+) ([^\s]+) ([^\s]+)/)
         end
-          
+
         value = socket.read(length.to_i)
         match_response!(socket.read(2), "\r\n")
 
         value.memcache_flags = flags.to_i
         value.memcache_cas   = cas
+
+        key = input_key(key)
         results[key] = value
       end
       results
     end
 
     def incr(key, amount = 1)
-      check_writable!
       raise Error, "incr requires unsigned value" if amount < 0
-      response = write_command("incr #{key} #{amount}")
-      response == "NOT_FOUND\r\n" ? nil : response.to_i
+      response = write_command("incr #{cache_key(key)} #{amount}")
+      response == "NOT_FOUND\r\n" ? nil : response.slice(0..-3).to_i
     end
 
     def decr(key, amount = 1)
-      check_writable!
       raise Error, "decr requires unsigned value" if amount < 0
-      response = write_command("decr #{key} #{amount}")
-      response == "NOT_FOUND\r\n" ? nil : response.to_i
+      response = write_command("decr #{cache_key(key)} #{amount}")
+      response == "NOT_FOUND\r\n" ? nil : response.slice(0..-3).to_i
     end
 
     def delete(key)
-      check_writable!
-      write_command("delete #{key}") == "DELETED\r\n" ? true : nil
+      write_command("delete #{cache_key(key)}") == "DELETED\r\n" ? true : nil
     end
 
     def set(key, value, expiry = 0, flags = 0)
       return delete(key) if value.nil?
-      check_writable!
-      write_command("set #{key} #{flags.to_i} #{expiry.to_i} #{value.to_s.size}", value)
+      write_command("set #{cache_key(key)} #{flags.to_i} #{expiry.to_i} #{value.to_s.size}", value)
       value
     end
 
     def cas(key, value, cas, expiry = 0, flags = 0)
-      check_writable!
-      response = write_command("cas #{key} #{flags.to_i} #{expiry.to_i} #{value.to_s.size} #{cas.to_i}", value)
+      response = write_command("cas #{cache_key(key)} #{flags.to_i} #{expiry.to_i} #{value.to_s.size} #{cas.to_i}", value)
       response == "STORED\r\n" ? value : nil
     end
 
     def add(key, value, expiry = 0, flags = 0)
-      check_writable!
-      response = write_command("add #{key} #{flags.to_i} #{expiry.to_i} #{value.to_s.size}", value)
+      response = write_command("add #{cache_key(key)} #{flags.to_i} #{expiry.to_i} #{value.to_s.size}", value)
       response == "STORED\r\n" ? value : nil
     end
 
     def replace(key, value, expiry = 0, flags = 0)
-      check_writable!
-      response = write_command("replace #{key} #{flags.to_i} #{expiry.to_i} #{value.to_s.size}", value)
+      response = write_command("replace #{cache_key(key)} #{flags.to_i} #{expiry.to_i} #{value.to_s.size}", value)
       response == "STORED\r\n" ? value : nil
     end
 
     def append(key, value)
-      check_writable!
-      response = write_command("append #{key} 0 0 #{value.to_s.size}", value)
+      response = write_command("append #{cache_key(key)} 0 0 #{value.to_s.size}", value)
       response == "STORED\r\n"
     end
 
     def prepend(key, value)
-      check_writable!
-      response = write_command("prepend #{key} 0 0 #{value.to_s.size}", value)
+      response = write_command("prepend #{cache_key(key)} 0 0 #{value.to_s.size}", value)
       response == "STORED\r\n"
     end
 
-    class Error < StandardError; end
-    class ConnectionError < Error
-      def initialize(e)
-        if e.kind_of?(String)
-          super
-        else
-          super("(#{e.class}) #{e.message}")
-          set_backtrace(e.backtrace)
-        end
-      end
-    end
-    class ServerError < Error; end
-    class ClientError < Error; end
+  protected
 
-  private
+    ESCAPE = {
+      " "   => '\s',
+      "\t"  => '\t',
+      "\n"  => '\n',
+      "\v"  => '\v',
+      "\f"  => '\f',
+      "\\"  => '\\\\',
+    }
+    UNESCAPE = ESCAPE.invert
+
+    def input_key(key)
+      key = key[prefix.size..-1] if prefix # Remove prefix from key.
+      key = key.gsub(/\\./) {|c| UNESCAPE[c]}
+      key
+    end
 
-    def check_writable!
-      raise Error, "Update of readonly cache" if readonly?
+    def cache_key(key)
+      key = key.gsub(/[\s\\]/) {|c| ESCAPE[c]}
+      super(key)
     end
 
+  private
+
     def match_response!(response, regexp)
       # Make sure that the response matches the protocol.
       unexpected_eof! if response.nil?
@@ -200,12 +188,12 @@ class Memcache
       command = command.join("\r\n")
       socket.write("#{command}\r\n")
       response = socket.gets
-      
+
       unexpected_eof! if response.nil?
       if response =~ /^(ERROR|CLIENT_ERROR|SERVER_ERROR) (.*)\r\n/
         raise ($1 == 'SERVER_ERROR' ? ServerError : ClientError), $2
       end
-      
+
       block_given? ? yield(response) : response
     rescue Exception => e
       close(e) # Mark dead.
@@ -251,7 +239,7 @@ class Memcache
         if Socket.constants.include? 'TCP_NODELAY'
           @socket.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
         end
-        
+
         @retry_at = nil
         @status   = 'CONNECTED'
       end