nofxx-tokyo_store 0.1.7

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,6 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+*.tch

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Marcos Piccinini
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,39 @@
+= TokyoStore
+
+Rack based Tokyo stored (FAST!) Rails session store.
+
+Code:: http://github.com/nofxx/tokyo_store
+Demo:: http://github.com/nofxx/tokyo_webapps under rails/session
+
+
+== Require
+
+Tokyo Cabinet/Tyrant:: http://tokyocabinet.sourceforge.net
+Rufus Tokyo:: http://github.com/jmettraux/rufus-tokyo
+
+
+== Install
+
+  gem install nofxx-tokyo_store
+
+  config.gem 'nofxx-tokyo_store', :lib => 'tokyo_store'
+  ActionController::Base.session_store = Rack::Session::Tokyo
+
+
+== Run
+
+Just start tyrant
+
+  ttserver data.tch
+
+
+== Thanks
+
+Mikio Hirabayashi:: tokyo products
+John Mettraux:: rufus-tokyo
+Luca Guidi:: redis-store - Rack code stolen from here =D
+
+
+== Copyright
+
+Copyright (c) 2009 Marcos Piccinini. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "tokyo_store"
+    gem.summary = "Tokyo Tyrant rails session store"
+    gem.email = "x@nofxx.com"
+    gem.homepage = "http://github.com/nofxx/tokyo_store"
+    gem.authors = ["Marcos Piccinini"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.verbose = true
+end
+
+task :default => :spec
+

data/VERSION

@@ -0,0 +1 @@
+0.1.7

data/benchmark/tokyo_store.rb

@@ -0,0 +1,108 @@
+#
+# Tokyo Store
+#
+# Benchmark vs MemCacheStore on memcached and tyrant
+#
+require 'rubygems'
+require 'active_support'
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'tokyo_store'
+#include TokyoCabinet
+
+P = "x" * 100
+M = P * 10
+G = M * 10
+OBJ = { :small => P, :medium => M, :big => G}
+
+#TODO: Cabinet & memcached C bindings
+@tokyo = ActiveSupport::Cache.lookup_store :tokyo_store, "localhost:1978"
+@memca = ActiveSupport::Cache.lookup_store :mem_cache_store, "localhost:11211"
+@memto = ActiveSupport::Cache.lookup_store :mem_cache_store, "localhost:1978"
+
+# # # Read & Write
+Benchmark.bmbm do |b|
+  b.report("TokyoStore# P") { 10_000.times { |i| @tokyo.write i.to_s, P }}
+  b.report("MemCacheD # P") { 10_000.times { |i| @memca.write i.to_s, P }}
+  b.report("MemCacheT # P") { 10_000.times { |i| @memto.write i.to_s, P }}
+  b.report("TokyoStore# M") { 10_000.times { |i| @tokyo.write i.to_s, M }}
+  b.report("MemCacheD # M") { 10_000.times { |i| @memca.write i.to_s, M }}
+  b.report("MemCacheT # M") { 10_000.times { |i| @memto.write i.to_s, M }}
+  b.report("TokyoStore# G") { 10_000.times { |i| @tokyo.write i.to_s, G }}
+  b.report("MemCacheD # G") { 10_000.times { |i| @memca.write i.to_s, G }}
+  b.report("MemCacheT # G") { 10_000.times { |i| @memto.write i.to_s, G }}
+  b.report("TokyoStore# OB") { 10_000.times { |i| @tokyo.write i.to_s, OBJ }}
+  b.report("MemCacheD # OB") { 10_000.times { |i| @memca.write i.to_s, OBJ }}
+  b.report("MemCacheT # OB") { 10_000.times { |i| @memto.write i.to_s, OBJ }}
+  b.report("TokyoStore# R") { 10_000.times { |i| @tokyo.read i.to_s }}
+  b.report("MemCacheD # R") { 10_000.times { |i| @memca.read i.to_s }}
+  b.report("MemCacheT # R") { 10_000.times { |i| @memto.read i.to_s }}
+  b.report("TokyoStore# E") { 10_000.times { |i| @tokyo.exist? i.to_s }}
+  b.report("MemCacheD # E") { 10_000.times { |i| @memca.exist? i.to_s }}
+  b.report("MemCacheT # E") { 10_000.times { |i| @memto.exist? i.to_s }}
+  b.report("TokyoStore# D") { 10_000.times { |i| @tokyo.delete i.to_s }}
+  b.report("MemCacheD # D") { 10_000.times { |i| @memca.delete i.to_s }}
+  b.report("MemCacheT # D") { 10_000.times { |i| @memto.delete i.to_s }}
+  b.report("TokyoStore# +") { 10_000.times { |i| @tokyo.increment i.to_s }}
+  b.report("MemCacheD # +") { 10_000.times { |i| @memca.increment i.to_s }}
+  b.report("MemCacheT # +") { 10_000.times { |i| @memto.increment i.to_s }}
+  b.report("TokyoStore# -") { 10_000.times { |i| @tokyo.decrement i.to_s }}
+  b.report("MemCacheD # -") { 10_000.times { |i| @memca.decrement i.to_s }}
+  b.report("MemCacheT # -") { 10_000.times { |i| @memto.decrement i.to_s }}
+end
+
+puts
+thr = []
+# # Read & Write
+Benchmark.bmbm do |b|
+  b.report("Tokyo # W") {  100.times { |j| thr << Thread.new { 100.times { |i| @tokyo.write "#{j}-#{i}", OBJ }}};  thr.each { |t| t.join }; thr = [] }
+  b.report("MemCa # W") {  100.times { |j| thr << Thread.new { 100.times { |i| @memca.write "#{j}-#{i}", OBJ}}};  thr.each { |t| t.join }; thr = [] }
+  b.report("MemTo # W") {  100.times { |j| thr << Thread.new { 100.times { |i| @memto.write "#{j}-#{i}", OBJ}}};  thr.each { |t| t.join }; thr = [] }
+  b.report("Tokyo # R") {  100.times { |j| thr << Thread.new { 100.times { |i| @tokyo.read "#{j}-#{i}" }}};  thr.each { |t| t.join }; thr = [] }
+  b.report("MemCa # R") {  100.times { |j| thr << Thread.new { 100.times { |i| @memca.read "#{j}-#{i}"}}};  thr.each { |t| t.join }; thr = [] }
+  b.report("MemTo # R") {  100.times { |j| thr << Thread.new { 100.times { |i| @memto.read "#{j}-#{i}"}}};  thr.each { |t| t.join }; thr = [] }
+end
+
+__END__
+
+
+
+Core 2 Duo 8500 - 3.16Ghz
+------------------------------------------------------------
+TokyoStore# P    0.140000   0.090000   0.230000 (  0.367587)
+MemCacheD # P    0.570000   0.160000   0.730000 (  0.829167)
+MemCacheT # P    0.560000   0.170000   0.730000 (  0.897084)
+TokyoStore# M    0.170000   0.100000   0.270000 (  0.448071)
+MemCacheD # M    0.610000   0.140000   0.750000 (  0.878559)
+MemCacheT # M    0.630000   0.140000   0.770000 (  0.951748)
+TokyoStore# G    0.410000   0.090000   0.500000 (  0.976746)
+MemCacheD # G    1.000000   0.200000   1.200000 (  1.429635)
+MemCacheT # G    1.060000   0.170000   1.230000 (  1.558731)
+TokyoStore# OB   0.480000   0.130000   0.610000 (  1.299556)
+MemCacheD # OB   1.460000   0.280000   1.740000 (  1.980678)
+MemCacheT # OB   1.230000   0.230000   1.460000 (  1.856561)
+TokyoStore# R    0.620000   0.230000   0.850000 (  1.204192)
+MemCacheD # R    0.550000   0.110000   0.660000 (  0.748446)
+MemCacheT # R    1.490000   0.260000   1.750000 (  2.142504)
+TokyoStore# P    0.150000   0.090000   0.240000 (  0.393119)
+MemCacheD # P    0.640000   0.150000   0.790000 (  0.896260)
+MemCacheT # P    0.660000   0.170000   0.830000 (  0.966585)
+TokyoStore# E    0.120000   0.100000   0.220000 (  0.359803)
+MemCacheD # E    0.720000   0.130000   0.850000 (  0.969214)
+MemCacheT # E    0.820000   0.160000   0.980000 (  1.195356)
+TokyoStore# D    0.220000   0.170000   0.390000 (  0.707877)
+MemCacheD # D    0.560000   0.110000   0.670000 (  0.775865)
+MemCacheT # D    0.560000   0.140000   0.700000 (  0.860964)
+TokyoStore# +    0.230000   0.190000   0.420000 (  0.654690)
+MemCacheD # +    0.570000   0.130000   0.700000 (  0.801407)
+MemCacheT # +    0.540000   0.190000   0.730000 (  0.937882)
+TokyoStore# -    0.200000   0.210000   0.410000 (  0.669899)
+MemCacheD # -    0.600000   0.100000   0.700000 (  0.778212)
+MemCacheT # -    0.600000   0.140000   0.740000 (  0.983345)
+
+Tokyo # W   0.500000   0.100000   0.600000 (  1.189529)
+MemCa # W   2.390000   0.250000   2.640000 (  2.942472)
+MemTo # W   2.550000   0.260000   2.810000 (  3.121612)
+Tokyo # R   0.660000   0.230000   0.890000 (  1.266911)
+MemCa # R   1.550000   0.190000   1.740000 (  1.824773)
+MemTo # R   3.170000   0.280000   3.450000 (  3.908895)

data/lib/rack/cache/tokyo_cache_store.rb

@@ -0,0 +1,138 @@
+require 'rufus/tokyo/tyrant'
+# require 'tokyocabinet'
+
+module ActiveSupport
+  module Cache
+
+    # A cache store implementation which stores data in Tokyo Cabinet
+    #
+    # Special features:
+    # - Clustering and load balancing. TODO
+    # - Time-based expiry support. TODO (Lua)
+    # - Per-request in memory cache for all communication with the Tokyo server(s).
+    class TokyoStore < Store
+
+      def self.build_tokyo(*store)
+        store = store.flatten
+        options = store.extract_options!
+        #TODO: multiple instances
+        store = store.empty? ? ["localhost", 1978]  : store[0].split(":")
+
+        #TODO: Auto choice between tyrant ffi x tyrant pure ruby x cabinet C
+        # Tyrant FFI
+        Rufus::Tokyo::Tyrant.new(store[0], store[1].to_i)
+
+        # Cabinet C
+        #hdb = HDB.new
+        # if !hdb.open(store[0], HDB::OWRITER | HDB::OCREAT)
+        #   ecode = hdb.ecode
+        #   STDERR.printf("open error: %s\n", hdb.errmsg(ecode))
+        # end
+        # hdb
+      end
+
+      # Creates a new TokyoStore object, with the given tyrant server
+      # addresses. Each address is either a host name, or a host-with-port string
+      # in the form of "host_name:port". For example:
+      #
+      #   ActiveSupport::Cache::TokyoStore.new("localhost", "server-downstairs.localnetwork:8229")
+      #
+      # If no addresses are specified, then TokyoStore will connect to
+      # localhost port 1978 (the default tyrant port).
+      def initialize(*store)
+        if store.first.respond_to?(:get)
+          @data = store.first
+        else
+          @data = self.class.build_tokyo(*store)
+        end
+
+        extend Strategy::LocalCache
+      end
+
+      # Reads multiple keys from the cache.
+      def read_multi(*keys)
+        #keys.inject({ }){ |h,k| h.merge({ k => read(k)}) }
+        @data.lget(keys).inject({ }) { |h, k| h.merge({ k[0] => Marshal.load(k[1])})} #
+      end
+
+      def read(key, options = nil) # :nodoc:
+        # TODO: benchmark [key] vs .get(key)
+        super
+        return nil unless val = @data[key]
+        val = Marshal.load(val) unless raw?(options)
+        val
+        # if str = @data.get(key)
+        #   Marshal.load str
+        #   else
+        #   STDERR.printf("get error: %s\n", @data.errmsg(@data.ecode))
+        #   end
+        # logger.error("TokyoError (#{e}): #{e.message}")
+        # nil
+      end
+
+      # Writes a value to the cache.
+      #
+      # Possible options:
+      # - +:unless_exist+ - set to true if you don't want to update the cache
+      #   if the key is already set.
+      def write(key, value, options = nil)
+        super
+        method = options && options[:unless_exist] ? :add : :set
+        # will break the connection if you send it an integer
+        # in raw mode, so we convert it to a string to be sure it continues working.
+        value = raw?(options) ? value.to_s : Marshal.dump(value) # if value.instance_of? Hash
+
+        @data[key] = value
+        ###response = @data.put(key, value) || STDERR.printf("get error: %s\n", @data.errmsg(@data.ecode))#, expires_in(options), raw?(options))
+        # logger.error("TokyoError (#{e}): #{e.message}")
+        # false
+      end
+
+      def delete(key, options = nil) # :nodoc:
+        super
+        @data.delete(key) #= nil #, expires_in(options))
+      end
+
+      def exist?(key, options = nil) # :nodoc:
+        # Local cache is checked first?
+       !read(key, options).nil?
+      end
+
+      def increment(key, amount = 1) # :nodoc:
+        #NATIVE breaks...rufus integer prob?
+        # @data.incr(key, amount)
+        @data[key] = (@data[key].to_i + amount).to_s
+      end
+
+      def decrement(key, amount = 1) # :nodoc:
+        # @data.incr(key, -amount)
+        increment(key, -amount)
+      end
+
+      def delete_matched(matcher, options = nil) # :nodoc:
+        #TODO @data.ldelete?
+      end
+
+      def clear
+        @data.clear
+      end
+
+      def stats
+        @data.stat
+      end
+
+      private
+        #TODO
+        # def expires_in(options)
+        #   (options && options[:expires_in]) || 0
+        # end
+
+        def raw?(options)
+          options && options[:raw]
+        end
+
+
+    end
+
+  end
+end

data/lib/rack/session/tokyo.rb

@@ -0,0 +1,93 @@
+module Rack
+  module Session
+    class Tokyo < Abstract::ID
+      attr_reader :mutex, :pool
+      DEFAULT_OPTIONS = Abstract::ID::DEFAULT_OPTIONS.merge :tyrant_server => "localhost:1978"
+
+      def initialize(app, options = {})
+        # Support old :expires option
+        #options[:expire_after] ||= options[:expires]
+        super
+        @mutex = Mutex.new
+        # @default_options = {        #   :namespace => 'rack:session',        # }.merge(@default_options)
+        host, port = *@default_options[:tyrant_server].split(":") # @default_options)        #options[:cache] ||
+        begin
+          @pool =  Rufus::Tokyo::Tyrant.new(host, port.to_i)
+        rescue => e
+          "No server avaiable or #{e}"
+        end
+        # unless @pool.servers.any? { |s| s.alive? }
+        #   raise "#{self} unable to find server during initialization."
+        # end
+      end
+
+      def generate_sid
+        loop do
+          sid = super
+          break sid unless @pool[sid]
+        end
+      end
+
+      private
+      def get_session(env, sid)
+        session = Marshal.load(@pool[sid]) if sid && sid != "" #sid ||= generate_sid
+        @mutex.lock if env['rack.multithread']
+        unless sid and session
+          env['rack.errors'].puts("Session '#{sid.inspect}' not found, initializing...") if $VERBOSE and not sid.nil?
+          session = {}
+          sid = generate_sid
+          ret = @pool[sid] = Marshal.dump(session)
+          raise "Session collision on '#{sid.inspect}'" unless ret
+        end
+        session.instance_variable_set('@old', {}.merge(session))
+        return [sid, session]
+      rescue => e
+        session = {}
+      ensure
+        @mutex.unlock if env['rack.multithread']
+      end
+
+      def set_session(env, sid, new_session, options)
+        @mutex.lock if env['rack.multithread']
+        session = Marshal.load(@pool[sid]) rescue {}
+        if options[:renew] or options[:drop]
+          @pool.delete sid
+          return false if options[:drop]
+          sid = generate_sid
+          @pool[sid] = 0
+        end
+        old_session = new_session.instance_variable_get('@old') || {}
+        session = merge_sessions sid, old_session, new_session, session
+        @pool[sid] = Marshal.dump(session) #, options])
+        return sid
+      rescue => e
+        warn "#{self} is unable to find server. #{e}"
+        warn $!.inspect
+        return false
+      ensure
+        @mutex.unlock if env['rack.multithread']
+      end
+
+      def merge_sessions(sid, old, new, cur=nil)
+        cur ||= {}
+        unless Hash === old and Hash === new
+          warn 'Bad old or new sessions provided.'
+          return cur
+        end
+
+        delete = old.keys - new.keys
+        warn "//@#{sid}: dropping #{delete*','}" if $DEBUG and not delete.empty?
+        delete.each{|k| cur.delete k }
+
+        update = new.keys.select{|k| new[k] != old[k] }
+        warn "//@#{sid}: updating #{update*','}" if $DEBUG and not update.empty?
+        update.each{|k| cur[k] = new[k] }
+
+        cur
+      end
+
+    end
+
+  end
+
+end

data/lib/tokyo_store.rb

@@ -0,0 +1,23 @@
+require 'rufus/tokyo/tyrant'
+
+# Rack Session
+if defined?(Rack::Session)
+  require "rack/session/abstract/id"
+  require "rack/session/tokyo"
+end
+
+
+
+
+
+# # Cache store
+# if defined?(Sinatra)
+#   require "cache/sinatra/redis_store"
+# elsif defined?(Merb)
+#   # HACK for cyclic dependency: redis-store is required before merb-cache
+#   module Merb; module Cache; class AbstractStore; end end end
+#   require "cache/merb/redis_store"
+# elsif defined?(Rails)
+#   require "cache/rails/redis_store"
+# end
+

data/spec/rack/cache/tokyo_cache_spec.rb

@@ -0,0 +1,252 @@
+# require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+# describe "TokyoStore" do
+#   it "should store fragment cache" do
+#     Rufus::Tokyo::Tyrant.should_receive(:new).and_return(@mock_tyrant = mock("Tyrant"))
+#     store = ActiveSupport::Cache.lookup_store :tokyo_store, "data.tch"
+#     store.should be_kind_of ActiveSupport::Cache::TokyoStore
+#   end
+
+#   it "should fail" do
+#     tokyo = Rufus::Tokyo::Tyrant.new('localhost', 1978)
+#     Rufus::Tokyo::Tyrant.should_not_receive(:new)
+#     store = ActiveSupport::Cache.lookup_store :tokyo_store, tokyo
+#     store.should be_kind_of ActiveSupport::Cache::TokyoStore
+#   end
+
+#   describe "Similar" do
+
+#     before(:each) do
+#       @cache = ActiveSupport::Cache::TokyoStore.new 'localhost:1978'
+#       @cache.clear
+#     end
+
+#     it "should return true on success" do
+#       @cache.write('foo', 'bar').should be_true
+#     end
+
+#     it "should read and write strings" do
+#       @cache.write('foo', 'bar')
+#       @cache.read('foo').should eql('bar')
+#     end
+
+#     it "should read and write hash" do
+#       @cache.write('foo', {:a => "b"})
+#       @cache.read('foo').should eql({:a => "b"})
+#     end
+
+#     it "should write integers" do
+#       @cache.write('foo', 1)
+#       @cache.read('foo').should eql(1)
+#     end
+
+#     it "should write nil" do
+#       @cache.write('foo', nil)
+#       @cache.read('foo').should eql(nil)
+#     end
+
+#     it "should have a cache miss block" do
+#       @cache.write('foo', 'bar')
+#       @cache.fetch('foo') { 'baz' }.should eql('bar')
+#     end
+
+#     it "should have a cache miss block" do
+#       @cache.fetch('foo') { 'baz' }.should eql('baz')
+#     end
+
+#     it "should have a forced cache miss block" do
+#       @cache.fetch('foo', :force => true).should be_nil
+#     end
+
+#     it "should read and write hash" do
+#       @cache.write('foo', {:a => "b", :c => "d"})
+#       @cache.read('foo').should eql({:a => "b", :c => "d"})
+#     end
+
+#     it "should read and write array" do
+#       @cache.write('foo', [1,2,3])
+#       @cache.read('foo').should eql([1,2,3])
+#     end
+
+#     it "should read and write obj" do
+#       obj = City.new; obj.name = "Acapulco"; obj.pop = 717766
+#       @cache.write('foo', obj)
+#       @cache.read('foo').should be_instance_of City
+#       @cache.read('foo').name.should eql("Acapulco")
+#     end
+
+#     it "should read multiples" do
+#       @cache.write('a', 1)
+#       @cache.write('b', 2)
+#       @cache.read_multi('a','b').should eql({ 'a' => 1, 'b' => 2})
+#     end
+
+#     it "should clear all" do
+#       @cache.write("erase_me", 1).should be_true
+#       @cache.delete("erase_me")
+#       @cache.exist?("erase_me").should be_false
+#     end
+
+#     it "should check if exists" do
+#       @cache.exist?("new_one").should be_false
+#       @cache.write("new_one", 1)
+#       @cache.exist?("new_one").should be_true
+#     end
+
+#     it "should increment value" do
+#       @cache.write('val', 1, :raw => true)
+#       @cache.read("val", :raw => true).to_i.should eql 1
+#       @cache.increment('val')
+#       @cache.read("val", :raw => true).to_i.should eql 2
+#       @cache.increment('val')
+#       @cache.read("val", :raw => true).to_i.should eql 3
+#     end
+
+#     it "should decrement value" do
+#       @cache.write('val', 3, :raw => true)
+#       @cache.read("val", :raw => true).to_i.should eql 3
+#       @cache.decrement('val')
+#       @cache.read("val", :raw => true).to_i.should eql 2
+#       @cache.decrement('val')
+#       @cache.read("val", :raw => true).to_i.should eql 1
+#     end
+
+#     it "should clear all" do
+#       @cache.increment("val")
+#       @cache.exist?("val").should be_true
+#       @cache.clear
+#       @cache.exist?("val").should be_false
+#     end
+
+#     it "should show some stats" do
+#       @cache.stats.should be_instance_of Hash #== hash_including({ :type => "hash"})
+#     end
+
+#     it "store objects should be immutable" do
+#       @cache.with_local_cache do
+#         @cache.write('foo', 'bar')
+#         @cache.read('foo').gsub!(/.*/, 'baz')# }.should raise_error(ActiveSupport::FrozenObjectError)
+#         @cache.read('foo').should ==  'bar'
+#       end
+#     end
+
+#     it "stored objects should not be frozen" do
+#       @cache.with_local_cache do
+#         @cache.write('foo', 'bar')
+#       end
+#       @cache.with_local_cache do
+#         @cache.read('foo').should_not be_frozen
+#       end
+#     end
+
+#     it "should delete matched" do
+#       @cache.write("val", 1)
+#       @cache.write("value", 1)
+#       @cache.write("not", 1)
+#       @cache.delete_matched('val')
+#     end
+
+#   end
+
+#   describe "backed store" do
+#     before(:each) do
+#       @cache = ActiveSupport::Cache.lookup_store(:tokyo_store)
+#       @data = @cache.instance_variable_get(:@data)
+#       @cache.clear
+#     end
+
+#     it "local_writes_are_persistent_on_the_remote_cache" do
+#       @cache.with_local_cache do
+#         @cache.write('foo', 'bar')
+#       end
+
+#       @cache.read('foo').should eql('bar')
+#     end
+
+#     it "test_clear_also_clears_local_cache" do
+#       @cache.with_local_cache do
+#         @cache.write('foo', 'bar')
+#         @cache.clear
+#         @cache.read('foo').should be_nil
+#       end
+#     end
+
+#     it "test_local_cache_of_read_and_write" do
+#       @cache.with_local_cache do
+#         @cache.write('foo', 'bar')
+#         @data.clear # Clear remote cache
+#         @cache.read('foo').should eql('bar')
+#       end
+#     end
+
+#     it "test_local_cache_should_read_and_write_integer" do
+#       @cache.with_local_cache do
+#         @cache.write('foo', 1)
+#         @cache.read('foo').should eql(1)
+#       end
+#     end
+
+#     it "test_local_cache_of_delete" do
+#       @cache.with_local_cache do
+#         @cache.write('foo', 'bar')
+#         @cache.delete('foo')
+#         @data.clear # Clear remote cache
+#         @cache.read('foo').should be_nil
+#       end
+#     end
+
+#     it "test_local_cache_of_exist" do
+#       @cache.with_local_cache do
+#         @cache.write('foo', 'bar')
+#         @cache.instance_variable_set(:@data, nil)
+#         @data.clear # Clear remote cache
+#         @cache.exist?('foo').should be_true
+#       end
+#     end
+
+#     it "test_local_cache_of_increment" do
+#       @cache.with_local_cache do
+#         @cache.write('foo', 1, :raw => true)
+#         @cache.increment('foo')
+#         @data.clear # Clear remote cache
+#         @cache.read('foo', :raw => true).to_i.should eql(2)
+#       end
+#     end
+
+#     it "test_local_cache_of_decrement" do
+#       @cache.with_local_cache do
+#         @cache.write('foo', 1, :raw => true)
+#         @cache.decrement('foo')
+#         @data.clear # Clear remote cache
+#         @cache.read('foo', :raw => true).to_i.should be_zero
+#       end
+#     end
+
+#     it "test_exist_with_nulls_cached_locally" do
+#       @cache.with_local_cache do
+#         @cache.write('foo', 'bar')
+#         @cache.delete('foo')
+#         @cache.exist?('foo').should be_false
+#       end
+#     end
+
+#     it "test_multi_get" do
+#       @cache.with_local_cache do
+#         @cache.write('foo', 1)
+#         @cache.write('goo', 2)
+#         @cache.read_multi('foo', 'goo').should eql({'foo' => 1, 'goo' => 2})
+#       end
+#     end
+
+#     it "test_middleware" do
+#       app = lambda { |env|
+#         result = @cache.write('foo', 'bar')
+#         @cache.read('foo').should eql('bar') # make sure 'foo' was written
+#       }
+#       app = @cache.middleware.new(app)
+#       app.call({})
+#     end
+
+#   end
+
+# end

data/spec/rack/session/tokyo_spec.rb

@@ -0,0 +1,238 @@
+# Code from http://github.com/jodosha/redis-store
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+module Rack
+  module Session
+    describe "Rack::Session::Tokyo" do
+      before(:each) do
+        @session_key = Rack::Session::Tokyo::DEFAULT_OPTIONS[:key]
+        @session_match = /#{@session_key}=[0-9a-fA-F]+;/
+        @incrementor = lambda do |env|
+          env["rack.session"]["counter"] ||= 0
+          env["rack.session"]["counter"] += 1
+          Rack::Response.new(env["rack.session"].inspect).to_a
+        end
+        @drop_session = proc do |env|
+          env['rack.session.options'][:drop] = true
+          @incrementor.call(env)
+        end
+        @renew_session = proc do |env|
+          env['rack.session.options'][:renew] = true
+          @incrementor.call(env)
+        end
+        @defer_session = proc do |env|
+          env['rack.session.options'][:defer] = true
+          @incrementor.call(env)
+        end
+      end
+
+      it "should specify connection params" do
+        pool = Rack::Session::Tokyo.new(@incrementor, :tokyo_server => "localhost:6380/1").pool
+        pool.should be_kind_of(Rufus::Tokyo::Tyrant)
+        pool.host.should == "localhost"
+        pool.port.should == 1978
+
+        # pool = Rack::Session::Tokyo.new(@incrementor, :tokyo_server => ["localhost:6379", "localhost:6380"]).pool
+        # pool.should be_kind_of(DistributedMarshaledTokyo)
+      end
+
+      it "creates a new cookie" do
+        pool = Rack::Session::Tokyo.new(@incrementor)
+        res = Rack::MockRequest.new(pool).get("/")
+        res["Set-Cookie"].should match(/#{@session_key}=/)
+        res.body.should == '{"counter"=>1}'
+      end
+
+      it "determines session from a cookie" do
+        pool = Rack::Session::Tokyo.new(@incrementor)
+        req = Rack::MockRequest.new(pool)
+        res = req.get("/")
+        cookie = res["Set-Cookie"]
+        req.get("/", "HTTP_COOKIE" => cookie).
+          body.should == '{"counter"=>2}'
+        req.get("/", "HTTP_COOKIE" => cookie).
+          body.should == '{"counter"=>3}'
+      end
+
+      it "survives nonexistant cookies" do
+        bad_cookie = "rack.session=blarghfasel"
+        pool = Rack::Session::Tokyo.new(@incrementor)
+        res = Rack::MockRequest.new(pool).
+          get("/", "HTTP_COOKIE" => bad_cookie)
+        res.body.should == '{"counter"=>1}'
+        cookie = res["Set-Cookie"][@session_match]
+        cookie.should_not match(/#{bad_cookie}/)
+      end
+
+      it "should maintain freshness" do
+        pool = Rack::Session::Tokyo.new(@incrementor, :expire_after => 3)
+        res = Rack::MockRequest.new(pool).get('/')
+        res.body.should include('"counter"=>1')
+        cookie = res["Set-Cookie"]
+        res = Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie)
+        res["Set-Cookie"].should == cookie
+        res.body.should include('"counter"=>2')
+        puts 'Sleeping to expire session' if $DEBUG
+        sleep 4
+        res = Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie)
+        res["Set-Cookie"].should_not == cookie
+        res.body.should include('"counter"=>1')
+      end
+
+      it "deletes cookies with :drop option" do
+        pool = Rack::Session::Tokyo.new(@incrementor)
+        req = Rack::MockRequest.new(pool)
+        drop = Rack::Utils::Context.new(pool, @drop_session)
+        dreq = Rack::MockRequest.new(drop)
+
+        res0 = req.get("/")
+        session = (cookie = res0["Set-Cookie"])[@session_match]
+        res0.body.should == '{"counter"=>1}'
+
+        res1 = req.get("/", "HTTP_COOKIE" => cookie)
+        res1["Set-Cookie"][@session_match].should == session
+        res1.body.should == '{"counter"=>2}'
+
+        res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
+        res2["Set-Cookie"].should be_nil
+        res2.body.should == '{"counter"=>3}'
+
+        res3 = req.get("/", "HTTP_COOKIE" => cookie)
+        res3["Set-Cookie"][@session_match].should_not == session
+        res3.body.should == '{"counter"=>1}'
+      end
+
+      it "provides new session id with :renew option" do
+        pool = Rack::Session::Tokyo.new(@incrementor)
+        req = Rack::MockRequest.new(pool)
+        renew = Rack::Utils::Context.new(pool, @renew_session)
+        rreq = Rack::MockRequest.new(renew)
+
+        res0 = req.get("/")
+        session = (cookie = res0["Set-Cookie"])[@session_match]
+        res0.body.should == '{"counter"=>1}'
+
+        res1 = req.get("/", "HTTP_COOKIE" => cookie)
+        res1["Set-Cookie"][@session_match].should == session
+        res1.body.should == '{"counter"=>2}'
+
+        res2 = rreq.get("/", "HTTP_COOKIE" => cookie)
+        new_cookie = res2["Set-Cookie"]
+        new_session = new_cookie[@session_match]
+        new_session.should_not == session
+        res2.body.should == '{"counter"=>3}'
+
+        res3 = req.get("/", "HTTP_COOKIE" => new_cookie)
+        res3["Set-Cookie"][@session_match].should == new_session
+        res3.body.should == '{"counter"=>4}'
+      end
+
+      specify "omits cookie with :defer option" do
+        pool = Rack::Session::Tokyo.new(@incrementor)
+        req = Rack::MockRequest.new(pool)
+        defer = Rack::Utils::Context.new(pool, @defer_session)
+        dreq = Rack::MockRequest.new(defer)
+
+        res0 = req.get("/")
+        session = (cookie = res0["Set-Cookie"])[@session_match]
+        res0.body.should == '{"counter"=>1}'
+
+        res1 = req.get("/", "HTTP_COOKIE" => cookie)
+        res1["Set-Cookie"][@session_match].should == session
+        res1.body.should == '{"counter"=>2}'
+
+        res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
+        res2["Set-Cookie"].should be_nil
+        res2.body.should == '{"counter"=>3}'
+
+        res3 = req.get("/", "HTTP_COOKIE" => cookie)
+        res3["Set-Cookie"][@session_match].should == session
+        res3.body.should == '{"counter"=>4}'
+      end
+
+      # anyone know how to do this better?
+      specify "multithread: should cleanly merge sessions" do
+        next unless $DEBUG
+        warn 'Running multithread test for Session::Tokyo'
+        pool = Rack::Session::Tokyo.new(@incrementor)
+        req = Rack::MockRequest.new(pool)
+
+        res = req.get('/')
+        res.body.should == '{"counter"=>1}'
+        cookie = res["Set-Cookie"]
+        sess_id = cookie[/#{pool.key}=([^,;]+)/,1]
+
+        delta_incrementor = lambda do |env|
+          # emulate disconjoinment of threading
+          env['rack.session'] = env['rack.session'].dup
+          Thread.stop
+          env['rack.session'][(Time.now.usec*rand).to_i] = true
+          @incrementor.call(env)
+        end
+        tses = Rack::Utils::Context.new pool, delta_incrementor
+        treq = Rack::MockRequest.new(tses)
+        tnum = rand(7).to_i+5
+        r = Array.new(tnum) do
+          Thread.new(treq) do |run|
+            run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
+          end
+        end.reverse.map{|t| t.run.join.value }
+        r.each do |res|
+          res['Set-Cookie'].should == cookie
+          res.body.should include('"counter"=>2')
+        end
+
+        session = pool.pool.get(sess_id)
+        session.size.should == tnum+1 # counter
+        session['counter'].should == 2 # meeeh
+
+        tnum = rand(7).to_i+5
+        r = Array.new(tnum) do |i|
+          delta_time = proc do |env|
+            env['rack.session'][i]  = Time.now
+            Thread.stop
+            env['rack.session']     = env['rack.session'].dup
+            env['rack.session'][i] -= Time.now
+            @incrementor.call(env)
+          end
+          app = Rack::Utils::Context.new pool, time_delta
+          req = Rack::MockRequest.new app
+          Thread.new(req) do |run|
+            run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
+          end
+        end.reverse.map{|t| t.run.join.value }
+        r.each do |res|
+          res['Set-Cookie'].should == cookie
+          res.body.should include('"counter"=>3')
+        end
+
+        session = pool.pool.get(sess_id)
+        session.size.should == tnum+1
+        session['counter'].should == 3
+
+        drop_counter = proc do |env|
+          env['rack.session'].delete 'counter'
+          env['rack.session']['foo'] = 'bar'
+          [200, {'Content-Type'=>'text/plain'}, env['rack.session'].inspect]
+        end
+        tses = Rack::Utils::Context.new pool, drop_counter
+        treq = Rack::MockRequest.new(tses)
+        tnum = rand(7).to_i+5
+        r = Array.new(tnum) do
+          Thread.new(treq) do |run|
+            run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
+          end
+        end.reverse.map{|t| t.run.join.value }
+        r.each do |res|
+          res['Set-Cookie'].should == cookie
+          res.body.should include('"foo"=>"bar"')
+        end
+
+        session = pool.pool.get(sess_id)
+        session.size.should == r.size+1
+        session['counter'].should be_nil
+        session['foo'].should == 'bar'
+      end
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--colour
+--loadby mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+$: << File.join(File.dirname(__FILE__), "/../lib")
+require 'rubygems'
+require 'spec'
+require 'rack'
+# $LOAD_PATH.unshift(File.dirname(__FILE__))
+# $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'tokyo_store'
+require 'rack/session/tokyo'
+#require 'rack/cache/tokyo'
+#ENV["RAILS_ENV"] = "test"
+require 'activesupport'
+require 'active_support'
+require 'actionpack'
+require 'action_controller'
+# require 'action_controller/test_process'
+# require 'action_pack'
+
+# ActionController::Base.session_store = :tokyo_store
+# #ActionController::Base.ignore_missing_templates = true
+
+# DispatcherApp = ActionController::Dispatcher.new
+#     TokyoStoreStoreApp = ActionController::Session::TokyoStore.new(
+#                          DispatcherApp, :key => '_s_id')
+
+#Simple class to test marshal
+class City
+  attr_accessor :name, :pop
+end
+#require 'spec/rails'
+
+Spec::Runner.configure do |config|
+
+end

data/spec/tokyo_store_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+if ENV['CABINET']
+  describe "TokyoStore" do
+    it "should store fragment cache" do
+      HDB.should_receive(:new).and_return(@mock_hdb = mock("HDB"))
+      @mock_hdb.should_receive(:open).with('data.tch', 6).and_return(true)
+      store = ActiveSupport::Cache.lookup_store :tokyo_store, "data.tch"
+      store.should be_kind_of ActiveSupport::Cache::TokyoStore
+    end
+
+    it "should fail" do
+      tokyo =  HDB.new
+      tokyo.open('data.tch')
+      HDB.should_not_receive(:new)
+      store = ActiveSupport::Cache.lookup_store :tokyo_store, tokyo
+      store.should be_kind_of ActiveSupport::Cache::TokyoStore
+    end
+
+    describe "Similar" do
+
+      before(:all) do
+        @cache = ActiveSupport::Cache::TokyoStore.new 'data.tcb'
+      end
+
+      it "test_should_read_and_write_strings" do
+        @cache.write('foo', 'bar')
+        @cache.read('foo').should eql('bar')
+      end
+
+      it "test_should_read_and_write_hash" do
+        @cache.write('foo', {:a => "b"})
+        @cache.read('foo').should eql({:a => "b"})
+      end
+
+      it "test_should_read_and_write_hash" do
+        @cache.write('foo', {:a => "b", :c => "d"})
+        @cache.read('foo').should eql({:a => "b", :c => "d"})
+      end
+    end
+
+  end
+end

data/tokyo_store.gemspec

@@ -0,0 +1,54 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{tokyo_store}
+  s.version = "0.1.7"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Marcos Piccinini"]
+  s.date = %q{2009-07-03}
+  s.email = %q{x@nofxx.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "benchmark/tokyo_store.rb",
+     "lib/rack/cache/tokyo_cache_store.rb",
+     "lib/rack/session/tokyo.rb",
+     "lib/tokyo_store.rb",
+     "spec/rack/cache/tokyo_cache_spec.rb",
+     "spec/rack/session/tokyo_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb",
+     "spec/tokyo_store_spec.rb",
+     "tokyo_store.gemspec"
+  ]
+  s.homepage = %q{http://github.com/nofxx/tokyo_store}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.4}
+  s.summary = %q{Tokyo Tyrant rails session store}
+  s.test_files = [
+    "spec/rack/cache/tokyo_cache_spec.rb",
+     "spec/rack/session/tokyo_spec.rb",
+     "spec/tokyo_store_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: nofxx-tokyo_store
+version: !ruby/object:Gem::Version 
+  version: 0.1.7
+platform: ruby
+authors: 
+- Marcos Piccinini
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-03 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: x@nofxx.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- benchmark/tokyo_store.rb
+- lib/rack/cache/tokyo_cache_store.rb
+- lib/rack/session/tokyo.rb
+- lib/tokyo_store.rb
+- spec/rack/cache/tokyo_cache_spec.rb
+- spec/rack/session/tokyo_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/tokyo_store_spec.rb
+- tokyo_store.gemspec
+has_rdoc: false
+homepage: http://github.com/nofxx/tokyo_store
+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.2.0
+signing_key: 
+specification_version: 3
+summary: Tokyo Tyrant rails session store
+test_files: 
+- spec/rack/cache/tokyo_cache_spec.rb
+- spec/rack/session/tokyo_spec.rb
+- spec/tokyo_store_spec.rb
+- spec/spec_helper.rb