tokyo_cache_cow 0.0.4

data/README.rdoc

@@ -0,0 +1,93 @@
+= Tokyo Cache Cow
+
+Tokyo Cache Cow is MemCache protocol speaking cache server. It offers the ability to delete keys based on a substring.
+
+== Motivation
+
+Cache sweepers in rails do not currently operate with memcache because the memcache server itself does not support key matching removal operations. After reading http://www.igvita.com/2009/02/13/tokyo-cabinet-beyond-key-value-store/ and seeing the performance characteristics of that database, I thought I'd give it a go. Event Machine does the heavy lifting on the network end. Performance is currently comparable to memcached.
+
+== Prerequisites
+
+You'll need the eventmachine gem installed. As well, you'll have to install Tokyo Cabinet itself (available at http://tokyocabinet.sourceforge.net/index.html) and the Tokyo Cabinet Ruby bindings (available at http://tokyocabinet.sourceforge.net/rubypkg/)
+
+== Example (using the rails client under script/console)
+  
+Lets write four keys: <i>other_key</i>, <i>test_key</i>, <i>test_key2</i> and <i>test_key3</i>.
+  
+  >> Rails.cache.write('other_key', 'other_value')
+  => true
+  >> Rails.cache.write('test_key', 'test_value')
+  => true
+  >> Rails.cache.write('test_key2', 'test_value2')
+  => true
+  >> Rails.cache.write('test_key3', 'test_value3')
+  => true
+
+Read back <i>test_key</i> and make sure life is still good.
+
+  >> Rails.cache.read('test_key2')
+  => "test_value2"
+
+But lets delete <i>test_key2</i> for fun.
+
+  >> Rails.cache.delete('test_key2')
+  => true
+
+Confirm that <i>test_key2</i> is really gone.
+
+  >> Rails.cache.read('test_key2')
+  => nil
+
+.. but our other keys (namely, <i>test_key</i>) are just fine, thank you.
+
+  >> Rails.cache.read('test_key')
+  => "test_value"
+
+.. lets nuke *EVERYTHING* with <i>test_key</i> in it though.
+
+  >> Rails.cache.delete_matched('test_key')
+  => true
+
+Now <i>test_key</i> and <i>test_key3</i> are both nuked.
+
+  >> Rails.cache.read('test_key')
+  => nil
+  >> Rails.cache.read('test_key3')
+  => nil
+
+But <i>other_key</i> is still peachy.
+
+  >> Rails.cache.read('other_key')
+  => "other_value"
+
+
+== Usage
+
+=== Server
+
+
+  >> tokyo_cache_cow --help
+
+  Usage: tokyo_cache_cow [options]
+  Options:
+      -p, --port[OPTIONAL]             Port (default: 11211)
+      -a, --address[OPTIONAL]          Address (default: 0.0.0.0)
+      -c, --class[OPTIONAL]            Cache provider class (default: TokyoCacheCow::Cache::TokyoCabinetMemcache)
+      -r, --require[OPTIONAL]          require
+      -f, --file[OPTIONAL]             File (default: /tmp/tcc-cache)
+      -d, --daemonize[OPTIONAL]        Daemonize (default: false)
+      -P, --pid[OPTIONAL]              Pid file (default: /tmp/tcc.pid)
+      -m, --matcher[OPTIONAL]          Special flag for doing matched deletes (not enabled by default)
+      -h, --help                       Show this help message.
+
+=== Client
+
+Any standard memcache client will do, however, there is a special initialize for Rails to enable delete_matched functionality within the built-in memcache client there. To install this into rails:
+
+  script/plugin install git://github.com/joshbuddy/tokyo-cache-cow.git
+  
+== Caveats
+
+Right now there is no compression on disk. Things could get big, but Tokyo Cabinet does support various compression schemes, so exposing that to the runner should be trivial. Potentially performance could degrade after time, but I have yet to seriously investigate if thats the case.
+
+Feel the moo.

data/Rakefile

@@ -0,0 +1,33 @@
+require 'rubygems'
+require 'lib/tokyo_cache_cow'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "tokyo_cache_cow"
+    s.description = s.summary = ""
+    s.email = "joshbuddy@gmail.com"
+    s.homepage = "http://github.com/joshbuddy/tokyo_cache_cow"
+    s.authors = ["Joshua Hull"]
+    s.files = FileList["[A-Z]*", "{lib,spec,rails,bin}/**/*"]
+    s.executables = ['tokyo_cache_cow']
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'spec'
+require 'spec/rake/spectask'
+
+task :spec => 'spec:all'
+namespace(:spec) do
+  Spec::Rake::SpecTask.new(:all) do |t|
+    t.spec_opts ||= []
+    t.spec_opts << "-rubygems"
+    t.spec_opts << "--options" << "spec/spec.opts"
+    t.spec_files = FileList['spec/**/*_spec.rb']
+  end
+
+end
+

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 4
+:major: 0
+:minor: 0

data/bin/tokyo_cache_cow

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby -rubygems
+# Tokyo cache cow command line interface script.
+# Run <tt>tokyo_cache_cow -h</tt> to get more usage.
+require File.dirname(__FILE__) + '/../lib/tokyo_cache_cow'
+
+TokyoCacheCow::Runner.new(ARGV).start!

data/lib/tokyo_cache_cow/cache/base.rb

@@ -0,0 +1,15 @@
+class TokyoCacheCow
+  class Cache
+    class Base
+      
+      def process_time(time)
+        time = case time
+        when 0, nil: 0
+        when 1..2592000: (Time.now.to_i + time.to_i)
+        else time
+        end
+      end
+      
+    end
+  end
+end

data/lib/tokyo_cache_cow/cache/file_memcache.rb

@@ -0,0 +1,113 @@
+require 'yaml'
+require 'fileutils'
+require 'cgi'
+
+class TokyoCacheCow
+  class Cache
+    class FileMemcache < Base
+      
+      def process_time(time)
+        time = case time
+        when 0, nil: 0
+        when 1..2592000: (Time.now.to_i + time.to_i)
+        else time
+        end
+      end
+
+      def initialize(options = {})
+        @path = options[:file] or raise('must supply file')
+        flush_all
+      end
+      
+      def time_expired?(time)
+        time.to_i == 0 ? false : time < Time.now.to_i
+      end
+
+      def generate_data_hash(value, options)
+        {
+          :value => value,
+          :expires => process_time(options[:expires] || 0),
+          :flags => options[:flags] || 0
+        }
+      end
+      
+      def add(key, value, options = {})
+        if (data = get_raw(key)) && !time_expired?(data[:expired])
+          nil
+        else
+          set(key, value, options) and true
+        end
+      end
+
+      def delete_match(key)
+        FileUtils.rm Dir.glob(File.join(@path, "*#{CGI.escape(key)}*"))
+      end
+
+      def replace(key, value, options = {})
+        set(key, value, options) if File.exists?(path_for_key(key))
+      end
+
+      def append(key, val)
+        if data = get(key)
+          data[:value] << val
+          set_raw(key, data)
+          true
+        else
+          false
+        end
+      end
+
+      def incr(key, value)
+        if data = get(key)
+          new_value = data[:value].to_i + value
+          set(key, new_value.to_s, :expires => data[:expires], :flags => data[:flags])
+          new_value
+        end
+      end
+    
+      def decr(key, value)
+        incr(key, -value)
+      end
+      
+      def flush_all
+        FileUtils.rm_rf(@path)
+        FileUtils.mkdir_p(@path)
+        true
+      end
+
+      def delete(key, expires = nil)
+        FileUtils.rm(Dir.glob(path_for_key(key))) and true
+      end
+      
+      def path_for_key(key)
+        File.join(@path, CGI.escape(key))
+      end
+      
+      def get_raw(key)
+        File.exists?(path_for_key(key)) ? YAML::load( File.open( path_for_key(key) ) ) : nil
+      end
+      
+      def set_raw(key, data)
+        File.open(path_for_key(key), 'w') do |out|
+          YAML.dump(data, out)
+        end
+      end
+      
+      def get(key)
+        if data = get_raw(key)
+          if time_expired?(data[:expires])
+            delete(key)
+            nil
+          else
+            data
+          end
+        end
+      end
+
+      def set(key, value, options = {})
+        set_raw(key, generate_data_hash(value, options))
+      end
+
+    end
+  end
+end

data/lib/tokyo_cache_cow/cache/hash_memcache.rb

@@ -0,0 +1,92 @@
+class TokyoCacheCow
+  class Cache
+    class HashMemcache < Base
+      
+      def process_time(time)
+        time = case time
+        when 0, nil: 0
+        when 1..2592000: (Time.now.to_i + time.to_i)
+        else time
+        end
+      end
+
+      def initialize(options = {})
+        @cache = {}
+      end
+      
+      def time_expired?(time)
+        time.to_i == 0 ? false : time < Time.now.to_i
+      end
+
+      def generate_data_hash(value, options)
+        {
+          :value => value,
+          :expires => process_time(options[:expires] || 0),
+          :flags => options[:flags] || 0
+        }
+      end
+      
+      def add(key, value, options = {})
+        if (data = @cache[key]) && !time_expired?(data[:expired])
+          nil
+        else
+          set(key, value, options) and true
+        end
+      end
+
+      def delete_match(key)
+        @cache.delete_if{ |key, value| key.index(key) }
+      end
+
+      def replace(key, value, options = {})
+        set(key, value, options) if @cache.key?(key)
+      end
+
+      def append(key, val)
+        if data = get(key)
+          data[:value] << val
+          @cache[key] = data
+          true
+        else
+          false
+        end
+      end
+
+      def incr(key, value)
+        if data = get(key)
+          new_value = data[:value].to_i + value
+          set(key, new_value.to_s, :expires => data[:expires], :flags => data[:flags])
+          new_value
+        end
+      end
+    
+      def decr(key, value)
+        incr(key, -value)
+      end
+      
+      def flush_all
+        @cache.clear and true
+      end
+
+      def delete(key, expires = nil)
+        @cache.delete(key)
+      end
+      
+      def get(key)
+        if data = @cache[key]
+          if time_expired?(data[:expires])
+            @cache.delete(key)
+            nil
+          else
+            data
+          end
+        end
+      end
+
+      def set(key, value, options = {})
+        @cache[key] = generate_data_hash(value, options)
+      end
+
+    end
+  end
+end

data/lib/tokyo_cache_cow/cache/tokyo_cabinet_memcache.rb

@@ -0,0 +1,125 @@
+require 'tokyocabinet'
+
+class TokyoCacheCow
+  class Cache
+    class TokyoCabinetMemcache < Base
+
+      include TokyoCabinet
+
+      def process_time(time)
+        time = case time_i = Integer(time)
+        when 0: '0'
+        when 1..2592000: (Time.now.to_i + time_i).to_s
+        else time
+        end
+      end
+    
+      def flush_all
+        @cache.vanish
+      end
+
+      def get(key, cas = nil)
+        if (data = @cache.get(key)) && data['expired']
+          nil
+        elsif data
+          expires = data['expires'] && data['expires'].to_i
+          flags = data['flags'] && data['flags'].to_i
+          if expires != 0 && expires < Time.now.to_i
+            delete(key)
+            nil
+          else
+            { :value => data['value'], :expires => expires, :flags => flags }
+          end
+        end 
+      end
+    
+      def incr(key, value)
+        if data = get(key)
+          new_value = data[:value].to_i + value
+          set(key, new_value.to_s, :expires => data[:expires], :flags => data[:flags])
+          new_value
+        end
+      end
+    
+      def decr(key, value)
+        incr(key, -value)
+      end
+    
+      def append(key, val)
+        if data = get(key)
+          data[:value] << val
+          set(key, data[:value], :expires => data[:expires], :flags => data[:flags])
+          true
+        else
+          false
+        end
+      end
+
+      def prepend(key, val)
+        if data = @cache.get(key)
+          data[:data][0,0] = val
+          put(key, data[:value], :expires => data[:expires], :flags => data[:flags])
+          true
+        else
+          false
+        end
+      end
+    
+      def generate_data_hash(value, options)
+        expires = options[:expires] && options[:expires].to_s || '0'
+        flags = options[:flags] && options[:flags].to_s || '0'
+        { 'value' => value, 'expires' => process_time(expires), 'flags' => flags }
+      end
+    
+      def time_expired?(time)
+        time == '0' ? false : time.to_i < Time.now.to_i
+      end
+    
+    
+      def set(key, value, options = {})
+        @cache.put(key, generate_data_hash(value, options))
+      end
+
+      def add(key, value, options = {})
+        if data = @cache.get(key)
+          time_expired?(data[:expired]) ?
+            nil : @cache.putkeep(key, generate_data_hash(value, options))
+        else
+          @cache.putkeep(key, generate_data_hash(value, options))
+        end
+      end
+
+      def replace(key, value, options = {})
+        get(key) ? @cache.put(key, generate_data_hash(value, options)) : nil
+      end
+
+      def delete(key, opts = {})
+        if opts[:expires] && opts[:expires] != 0
+          @cache.put(key, {'expired' => process_time(opts[:expires])})
+        else
+          @cache.out(key)
+        end
+      end
+
+      def delete_match(match)
+        q = TDBQRY.new(@cache)
+        q.addcond('', TDBQRY::QCSTRINC, match)
+        q.search
+        q.searchout
+      end
+
+      def initialize(options = {})
+        @cache = TDB::new # hash database
+        raise('must supply file') unless options[:file]
+        if @cache.open(options[:file], TDB::OWRITER | TDB::OCREAT | TDB::OTRUNC)
+          @cache.setxmsiz(500_000_000)
+        else
+          puts @cache.ecode
+          puts @cache.errmsg(@cache.ecode)
+          raise
+        end
+      end
+
+    end
+  end
+end

data/lib/tokyo_cache_cow/cache.rb

@@ -0,0 +1,11 @@
+$:.unshift(File.dirname(__FILE__))
+
+class TokyoCacheCow
+  class Cache
+    self.autoload :Base, 'cache/base'
+    self.autoload :FileMemcache, 'cache/file_memcache'
+    self.autoload :TokyoCabinetMemcache, 'cache/tokyo_cabinet_memcache'
+    self.autoload :HashMemcache, 'cache/hash_memcache'
+  end
+end
+

data/lib/tokyo_cache_cow/providers.rb

@@ -0,0 +1,13 @@
+class TokyoCacheCow
+  
+  autoload :TokyoCabinetMemcache, 'lib/tokyo_cache_cow/tokyo_cabinet_memcache'
+
+  class Providers
+    
+    def self.provide_cache
+      #require 'lib/tokyo_cache_cow/tokyo_cabinet_memcache'
+      @@cache ||= TokyoCacheCow::TokyoCabinetMemcache.new('/tmp/tcc')
+    end
+    
+  end
+end

data/lib/tokyo_cache_cow/runner.rb

@@ -0,0 +1,110 @@
+require 'eventmachine'
+require 'optparse'
+
+class TokyoCacheCow
+  class Runner
+
+    attr_reader :options
+    
+    def initialize(argv)
+      @argv = argv
+      # Default options values
+      @options = {
+        :chdir                 => Dir.pwd,
+        :address               => '0.0.0.0',
+        :port                  => Server::DefaultPort,
+        :class                 => 'TokyoCacheCow::Cache::TokyoCabinetMemcache',
+        :require               => [],
+        :file                  => '/tmp/tcc-cache',
+        :pid                   => '/tmp/tcc.pid',
+        :special_delete_prefix => nil,
+        :daemonize             => false
+      }
+      
+      parse!
+    end
+
+    def parser
+      OptionParser.new do |opts|
+        opts.banner = "Usage: tokyo_cache_cow [options]"
+
+        opts.separator ""
+        opts.separator "Options:"
+
+        opts.on("-p[OPTIONAL]", "--port", "Port (default: #{options[:port]})") do |v|
+          options[:port] = v
+        end
+
+        opts.on("-a[OPTIONAL]", "--address", "Address (default: #{options[:address]})") do |v|
+          options[:address] = v
+        end
+
+        opts.on("-c[OPTIONAL]", "--class", "Cache provider class (default: #{options[:class]})") do |v|
+          options[:provider] = v
+        end
+
+        opts.on("-r[OPTIONAL]", "--require", "require") do |v|
+          options[:require] << v
+        end
+
+        opts.on("-f[OPTIONAL]", "--file", "File (default: #{options[:file]})") do |v|
+          options[:file] = v
+        end
+
+        opts.on("-d[OPTIONAL]", "--daemonize", "Daemonize (default: #{options[:daemonize]})") do |v|
+          options[:daemonize] = true
+        end
+
+        opts.on("-P[OPTIONAL]", "--pid", "Pid file (default: #{options[:pid]})") do |v|
+          options[:pid] = true
+        end
+
+        opts.on("-m[OPTIONAL]", "--matcher", "Special flag for doing matched deletes (not enabled by default)") do |v|
+          options[:special_delete_char] = v
+        end
+
+        opts.on_tail("-h", "--help", "Show this help message.") { puts opts; exit }
+
+      end
+    end
+
+    def parse!
+      parser.parse!(@argv)
+    end
+    
+    def start!
+      @options[:require].each {|r| require r}
+      
+      clazz = @options[:class].to_s.split('::').inject(Kernel) do |parent, mod|
+        parent.const_get(mod)
+      end
+      
+      
+      address = @options[:address]
+      port = @options[:port]
+      special_delete_char = @options[:special_delete_char]
+      puts "Starting the tokyo cache cow #{address} #{port}"
+      pid = EM.fork_reactor do
+        cache = clazz.new(:file => @options[:file])
+        trap("INT") { EM.stop; puts "\nmoooooooo ya later"; exit(0)}
+        EM.run do
+          EM.start_server(address, port, TokyoCacheCow::Server) do |c|
+            c.cache = cache
+            c.special_delete_char = special_delete_char if special_delete_char
+          end
+        end
+      end
+      
+      if @options[:daemonize]
+        File.open(options[:pid], 'w') {|f| f << pid}
+        Process.detach(pid)
+      else
+        trap("INT") { }
+        Process.wait(pid)
+      end
+      
+      pid
+    end
+    
+  end
+end

data/lib/tokyo_cache_cow/server.rb

@@ -0,0 +1,216 @@
+require 'strscan'
+require 'eventmachine'
+
+class TokyoCacheCow
+  class Server < EventMachine::Protocols::LineAndTextProtocol
+    
+    DefaultPort = 11211
+    
+    Terminator = "\r\n"
+    
+    #set
+    SetCommand = /(\S+) +(\d+) +(\d+) +(\d+)( +noreply)?/
+    CasCommand = /(\S+) +(\d+) +(\d+) +(\d+) +(\d+)( +noreply)?/
+    
+    StoredReply = "STORED\r\n"
+    NotStoredReply = "NOT_STORED\r\n"
+    ExistsReply = "EXISTS\r\n"
+    NotFoundReply = "NOT_FOUND\r\n"
+    
+    GetValueReply = "VALUE %s %d %d\r\n"
+    CasValueReply = "VALUE %d %d %d %d\r\n"
+    EndReply = "END\r\n"
+    
+    #delete
+    DeleteCommand = /(\S+) *(noreply)?/
+    DeleteWithTimeoutCommand = /(\S+) +(\d+) *(noreply)?/
+    
+    DeletedReply = "DELETED\r\n"
+    NotDeletedReply = "NOT_DELETED\r\n"
+    
+    #delete_match
+    DeleteMatchCommand = /(\S+)( +noreply)?/
+
+    #Increment/Decrement
+    IncrementDecrementCommand = /(\S+) +(\d+)( +noreply)?/
+    
+    ValueReply = "%d\r\n"
+    
+    #errors
+    OK = "OK\r\n" 
+    Error = "ERROR\r\n" 
+    ClientError = "CLIENT_ERROR %s\r\n"
+    ServerError = "SERVER_ERROR %s\r\n"
+    
+    TerminatorRegex = /\r\n/
+    
+    attr_accessor :cache, :special_delete_char
+    
+    def send_client_error(message = "invalid arguments")
+      send_data(ClientError % message.to_s)
+    end
+    
+    def send_server_error(message = "there was a problem")
+      send_data(ServerError % message.to_s)
+    end
+    
+    def validate_key(key)
+      if key.nil?
+        send_data(ClientError % "key cannot be blank")
+      elsif key && key.index(' ')
+        send_data(ClientError % "key cannot contain spaces")
+        nil
+      elsif key.size > 250
+        send_data(ClientError % "key must be less than 250 characters")
+        nil
+      else
+        key
+      end
+    end
+    
+    def set_incomplete(ss, length, part)
+      if ss.rest.size < length
+        @expected_size = length + ss.pre_match.size + 2
+        if @body
+          @body << ss.string
+        else
+          @body = part
+          @body << ss.rest
+        end
+        true
+      else
+        false
+      end
+    end
+    
+    def receive_data(data)
+      if @body
+        @body << data
+        return if @body.size < @expected_size
+      end
+      
+      ss = StringScanner.new(@body || data)
+      
+      while part = ss.scan_until(TerminatorRegex)
+        begin
+          command_argument_separator_index = part.index(/\s/)
+          command = part[0, command_argument_separator_index]
+          args = part[command_argument_separator_index + 1, part.size - command_argument_separator_index - 3]
+          case command
+          when 'get', 'gets'
+            keys = args.split(/\s+/)
+            keys.each do |k|
+              next unless validate_key(k)
+              if data = @cache.get(k)
+                if command == 'get'
+                  send_data(GetValueReply % [k, data[:flags], data[:value].size])
+                else
+                  send_data(CasValueReply % [k, data[:flags], data[:value].size, data[:value].hash])
+                end
+                send_data(data[:value])
+                send_data(Terminator)
+              end
+            end
+            send_data(EndReply)
+          when 'set'
+            SetCommand.match(args) or (send_client_error and next)
+            (key, flags, expires, bytes, noreply) = [$1, Integer($2), Integer($3), Integer($4), !$5.nil?]
+            next unless validate_key(key)
+            return if set_incomplete(ss, bytes, part)
+            send_data(@cache.set(key, ss.rest[0, bytes.to_i], :flags => flags, :expires => expires) ?
+              StoredReply : NotStoredReply)
+            @body = nil
+            ss.pos += bytes + 2 
+          when 'add'
+            SetCommand.match(args)
+            (key, flags, expires, bytes, noreply) = [$1, $2.to_i, $3.to_i, $4, !$5.nil?]
+            return if set_incomplete(ss, bytes, part)
+            send_data(@cache.add(key, ss.rest[0, bytes.to_i], :flags => flags, :expires => expires) ?
+              StoredReply : NotStoredReply)
+            @body = nil
+            ss.pos += bytes + 2 
+          when 'replace'
+            SetCommand.match(args)
+            (key, flags, expires, bytes, noreply) = [$1, $2.to_i, $3.to_i, $4, !$5.nil?]
+            return if set_incomplete(ss, bytes, part)
+            send_data(@cache.replace(key, ss.rest[0, bytes.to_i], :flags => flags, :expires => expires) ?
+              StoredReply : NotStoredReply)
+            @body = nil
+            ss.pos += bytes + 2 
+          when 'append'
+            SetCommand.match(args)
+            (key, flags, expires, bytes, noreply) = [$1, $2.to_i, $3.to_i, $4, !$5.nil?]
+            return if set_incomplete(ss, bytes, part)
+            send_data(@cache.append(key, ss.rest[0, bytes.to_i], :flags => flags, :expires => expires) ?
+              StoredReply : NotStoredReply)
+            @body = nil
+            ss.pos += bytes + 2 
+          when 'prepend'
+            SetCommand.match(args)
+            (key, flags, expires, bytes, noreply) = [$1, $2.to_i, $3.to_i, $4, !$5.nil?]
+            return if set_incomplete(ss, bytes, part)
+            send_data(@cache.prepend(key, ss.rest[0, bytes.to_i], :flags => flags, :expires => expires) ?
+              StoredReply : NotStoredReply)
+            @body = nil
+            ss.pos += bytes + 2 
+          when 'cas'
+            # do something
+          when 'delete'
+            case args
+            when DeleteWithTimeoutCommand
+              (key, timeout, noreply) = [$1.chomp, $2, !$3.nil?]
+              next unless validate_key(key)
+              send_data(@cache.delete_expire(key, timeout) ?
+                DeletedReply : NotDeletedReply)
+            when DeleteCommand
+              (key, noreply) = [$1.chomp, !$2.nil?]
+              next unless validate_key(key)
+              if special_delete_char && key.index(special_delete_char) == 0
+                key.slice!(0,special_delete_char.size)
+                @cache.delete_match(key)
+                send_data(DeletedReply)
+              else
+                send_data @cache.delete(key) ?
+                  DeletedReply : NotDeletedReply
+              end
+            end
+          when 'delete_match'
+            DeleteMatchCommand.match(args)
+            (key, noreply) = [$1.chomp, !$2.nil?]
+            next unless validate_key(key)
+            @cache.delete_match(key)
+            send_data(DeletedReply)
+          when 'incr', 'decr'
+            IncrementDecrementCommand.match(args)
+            (key, value, noreply) = [$1, $2.to_i, !$3.nil?]
+            next unless validate_key(key)
+            send_data(if d = @cache.get(key)
+              value = -value if command == 'decr'
+              d['data'] = (val = (d['data'].to_i + value)).to_s
+              @cache.put(key, d)
+              ValueReply % val
+            else
+              NotFoundReply
+            end)
+          when 'stats'
+            send_data(Error)
+          when 'flush_all'
+            send_data(@cache.flush_all ? OK : Error)
+          when 'version'
+            send_data(Error)
+          when 'quit'
+            close_connection_after_writing
+          else
+            send_data(Error)
+          end
+        rescue
+          puts $!
+          puts $!.backtrace
+          send_server_error($!)
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/tokyo_cache_cow.rb

@@ -0,0 +1,5 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'tokyo_cache_cow/runner'
+require 'tokyo_cache_cow/server'
+require 'tokyo_cache_cow/cache'

data/rails/init.rb

@@ -0,0 +1,43 @@
+module ::ActiveSupport
+  module Cache
+    class MemCacheStore < Store
+
+      def delete_matched(matcher, options = nil) # :nodoc:
+        super
+        response = @data.delete_match(matcher)
+        response == Response::DELETED
+      rescue MemCache::MemCacheError => e
+        logger.error("MemCacheError (#{e}): #{e.message}")
+        false
+      end
+
+    end
+  end
+end
+
+class ::MemCache
+
+  def delete_match(key)
+    @mutex.lock if @multithread
+
+    raise MemCacheError, "No active servers" unless active?
+    cache_key = make_cache_key key
+    server = get_server_for_key cache_key
+
+    sock = server.socket
+    raise MemCacheError, "No connection to server" if sock.nil?
+
+    begin
+      sock.write "delete_match #{cache_key}\r\n"
+      result = sock.gets
+      raise_on_error_response! result
+      result
+    rescue SocketError, SystemCallError, IOError => err
+      server.close
+      raise MemCacheError, err.message
+    end
+  ensure
+    @mutex.unlock if @multithread
+  end
+
+end

data/spec/cache_spec.rb

@@ -0,0 +1,152 @@
+require 'benchmark'
+require 'lib/tokyo_cache_cow/cache'
+
+{
+  'tokyo cabinet memcache' => TokyoCacheCow::Cache::TokyoCabinetMemcache.new(:file => '/tmp/tcc1'),
+  'hash memcache' => TokyoCacheCow::Cache::HashMemcache.new,
+  'file memcache' => TokyoCacheCow::Cache::FileMemcache.new(:file => '/tmp/filecache')
+}.each do |name, cache|
+  describe name do
+  
+    before(:each) do
+      cache.flush_all.should == true
+    end
+
+    it "should add" do
+      cache.get('added_key').should == nil
+      cache.add('added_key','zig').should == true
+      cache.get('added_key')[:value].should == 'zig'
+      cache.add('added_key','ziglar')
+      cache.get('added_key')[:value].should == 'zig'
+    end
+
+    it "should put & get" do
+      100.times do |i|
+        cache.set("/blog/show/#{i}","this is a big ol' blog post!!! #{i}")
+      end
+    
+      100.times do |i|
+        cache.get("/blog/show/#{i}")[:value].should == "this is a big ol' blog post!!! #{i}"
+      end
+    end
+  
+    it "should delete" do
+      cache.set("key-set-123","you should never see me")
+      cache.get("key-set-123")[:value].should == "you should never see me"
+      cache.delete("key-set-123")
+      cache.get("key-set-123").should == nil
+    end
+  
+    it "should delete (with expiry)" do
+      cache.set('delete-with-expiry', 'hillbillies')
+      cache.get('delete-with-expiry')[:value].should == 'hillbillies'
+      cache.delete('delete-with-expiry', :expires => 3)
+      cache.get('delete-with-expiry').should == nil
+      cache.replace('delete-with-expiry', 'more hillbillies')
+      cache.get('delete-with-expiry').should == nil
+      sleep(5)
+      cache.get('delete-with-expiry').should == nil
+      cache.set('delete-with-expiry', 'more hillbillies')
+      cache.get('delete-with-expiry')[:value].should == 'more hillbillies'
+    end
+  
+    it "should delete (with expiry) and set again" do
+      cache.set('delete-with-expiry', 'hillbillies')
+      cache.get('delete-with-expiry')[:value].should == 'hillbillies'
+      cache.delete('delete-with-expiry', 3)
+      cache.get('delete-with-expiry').should == nil
+      cache.set('delete-with-expiry', 'more hillbillies')
+      cache.get('delete-with-expiry')[:value].should == 'more hillbillies'
+      sleep(5)
+      cache.get('delete-with-expiry')[:value].should == 'more hillbillies'
+    end
+  
+    it "should delete_match" do
+      100.times do
+        cache.set("asd/qwe/zxc/10","you should never see me")
+        cache.set("asd/qwe/zxc/20","you should never see me")
+        cache.set("asd/qwe/zxc/30","you should never see me")
+        cache.set("asd/qwe/zxc/40","you should never see me")
+        cache.set("asd/qwe/zxc/11","you should never see me")
+        cache.set("asd/qwe/zxc/21","you should never see me")
+        cache.set("asd/qwe/zxc/31","you should never see me")
+        cache.set("asd/qwe/zxc/41","you should never see me")
+        cache.set("asd/qwe/zxc/12","you should never see me")
+        cache.set("asd/qwe/zxc/22","you should never see me")
+        cache.set("asd/qwe/zxc/32","you should never see me")
+        cache.set("asd/qwe/zxc/42","you should never see me")
+        cache.set("asd/qwe/zxc/101","you should never see me")
+        cache.set("asd/qwe/zxc/201","you should never see me")
+        cache.set("asd/qwe/zxc/301","you should never see me")
+        cache.set("asd/qwe/zxc/401","you should never see me")
+        cache.set("asd/qwe/zxc/111","you should never see me")
+        cache.set("asd/qwe/zxc/211","you should never see me")
+        cache.set("asd/qwe/zxc/311","you should never see me")
+        cache.set("asd/qwe/zxc/411","you should never see me")
+        cache.set("asd/qwe/zxc/121","you should never see me")
+        cache.set("asd/qwe/zxc/221","you should never see me")
+        cache.set("asd/qwe/zxc/321","you should never see me")
+        cache.set("asd/qwe/zxc/421","you should never see me")
+        cache.delete_match("asd/qwe/zxc")
+        cache.get("asd/qwe/zxc/40").should == nil
+        cache.get("asd/qwe/zxc/30").should == nil
+        cache.get("asd/qwe/zxc/20").should == nil
+        cache.get("asd/qwe/zxc/10").should == nil
+        cache.get("asd/qwe/zxc/41").should == nil
+        cache.get("asd/qwe/zxc/31").should == nil
+        cache.get("asd/qwe/zxc/21").should == nil
+        cache.get("asd/qwe/zxc/11").should == nil
+        cache.get("asd/qwe/zxc/42").should == nil
+        cache.get("asd/qwe/zxc/32").should == nil
+        cache.get("asd/qwe/zxc/22").should == nil
+        cache.get("asd/qwe/zxc/12").should == nil
+        cache.get("asd/qwe/zxc/401").should == nil
+        cache.get("asd/qwe/zxc/301").should == nil
+        cache.get("asd/qwe/zxc/201").should == nil
+        cache.get("asd/qwe/zxc/101").should == nil
+        cache.get("asd/qwe/zxc/411").should == nil
+        cache.get("asd/qwe/zxc/311").should == nil
+        cache.get("asd/qwe/zxc/211").should == nil
+        cache.get("asd/qwe/zxc/111").should == nil
+        cache.get("asd/qwe/zxc/421").should == nil
+        cache.get("asd/qwe/zxc/321").should == nil
+        cache.get("asd/qwe/zxc/221").should == nil
+        cache.get("asd/qwe/zxc/121").should == nil
+      end
+    end
+
+    it "should expire" do
+      cache.set("expiring key","you should never see me", :expires => 1)
+      sleep(3)
+      cache.get("expiring key").should == nil
+    end
+
+    it "should replace" do
+      cache.replace("replacing-key", "newkey")
+      cache.get("replacing-key").should == nil
+      cache.set("replacing-key", "oldkey")
+      cache.replace("replacing-key", "newkey")
+      cache.get("replacing-key")[:value].should == 'newkey'
+    end
+  
+    it "should append" do
+      cache.set("appending-key", "test1")
+      cache.get("appending-key")[:value].should == "test1"
+      cache.append("appending-key", "test2")
+      cache.get("appending-key")[:value].should == "test1test2"
+    end
+  
+    it "should incr" do
+      cache.set("incr-key", 123)
+      cache.incr("incr-key", 20).should == 143
+      cache.get("incr-key")[:value].should == '143'
+    end
+  
+    it "should decr" do
+      cache.set("decr-key", 123)
+      cache.decr("decr-key", 20).should == 103
+      cache.get("decr-key")[:value].should == '103'
+    end
+  
+  end
+end

data/spec/server_spec.rb

@@ -0,0 +1,70 @@
+require 'rubygems'
+require 'memcached'
+require 'benchmark'
+require 'lib/tokyo_cache_cow'
+
+cache = Memcached.new('127.0.0.1:11211')
+
+describe 'memcache server' do
+  
+  before(:all) do
+    runner = TokyoCacheCow::Runner.new(['--daemonize'])
+    @pid = runner.start!
+    sleep(1)
+  end
+  
+  before(:each) do 
+    cache.flush
+  end
+  
+  it "should get & set" do
+    cache.set('asd', "qweqweasd" * 20000)
+    cache.get('asd').should == "qweqweasd" * 20000
+  end
+  
+  it "should delete" do
+    cache.set('asd', 'qwe')
+    cache.delete('asd')
+    proc {cache.get('asd')}.should raise_error Memcached::NotFound
+  end
+
+  after(:all) do
+    Process.kill('INT', @pid)
+  end
+  
+  
+end
+
+describe 'memcache server with special delete support' do
+  
+  before(:all) do
+    runner = TokyoCacheCow::Runner.new(['--daemonize', '-m...'])
+    @pid = runner.start!
+    sleep(1)
+  end
+  
+  before(:each) do 
+    cache.flush
+  end
+  
+  it "should delete match through special char " do
+    cache.set('asd123', "qweqweasd")
+    cache.set('asd456', "qweqweasd")
+    cache.set('asd678', "qweqweasd")
+    cache.set('qwe678', "qweqweasd")
+    cache.set('qwe679', "qweqweasd")
+    cache.delete('...asd')
+    proc {cache.get('asd123')}.should raise_error Memcached::NotFound
+    proc {cache.get('asd456')}.should raise_error Memcached::NotFound
+    proc {cache.get('asd678')}.should raise_error Memcached::NotFound
+    cache.delete('...qwe678')
+    proc {cache.get('qwe678')}.should raise_error Memcached::NotFound
+    cache.get('qwe679').should=='qweqweasd'
+  end
+  
+  after(:all) do
+    Process.kill('INT', @pid)
+  end
+  
+  
+end

data/spec/spec.opts

@@ -0,0 +1,8 @@
+-rubygems
+--colour
+--format
+specdoc
+--loadby
+mtime
+--reverse
+--backtrace

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: tokyo_cache_cow
+version: !ruby/object:Gem::Version 
+  version: 0.0.4
+platform: ruby
+authors: 
+- Joshua Hull
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-24 00:00:00 -05:00
+default_executable: tokyo_cache_cow
+dependencies: []
+
+description: ""
+email: joshbuddy@gmail.com
+executables: 
+- tokyo_cache_cow
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- bin/tokyo_cache_cow
+- lib/tokyo_cache_cow.rb
+- lib/tokyo_cache_cow/cache.rb
+- lib/tokyo_cache_cow/cache/base.rb
+- lib/tokyo_cache_cow/cache/file_memcache.rb
+- lib/tokyo_cache_cow/cache/hash_memcache.rb
+- lib/tokyo_cache_cow/cache/tokyo_cabinet_memcache.rb
+- lib/tokyo_cache_cow/providers.rb
+- lib/tokyo_cache_cow/runner.rb
+- lib/tokyo_cache_cow/server.rb
+- rails/init.rb
+- spec/cache_spec.rb
+- spec/server_spec.rb
+- spec/spec.opts
+has_rdoc: true
+homepage: http://github.com/joshbuddy/tokyo_cache_cow
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: ""
+test_files: 
+- spec/cache_spec.rb
+- spec/server_spec.rb