nofxx-tokyo_store 0.1.7 → 0.1.8

data/README.rdoc

@@ -3,7 +3,7 @@
 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
+Demo:: http://github.com/nofxx/tokyo_webapps under rails/tokyo_store
 
 
 == Require
@@ -16,6 +16,8 @@ Rufus Tokyo:: http://github.com/jmettraux/rufus-tokyo
 
   gem install nofxx-tokyo_store
 
+Rails (enviroment.rb)
+
   config.gem 'nofxx-tokyo_store', :lib => 'tokyo_store'
   ActionController::Base.session_store = Rack::Session::Tokyo
 

data/VERSION

@@ -1 +1 @@
-0.1.7
+0.1.8

data/benchmark/{tokyo_store.rb → cache.rb}

@@ -7,20 +7,21 @@ require 'rubygems'
 require 'active_support'
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'tokyo_store'
+require 'cache/tokyo_store'
 #include TokyoCabinet
 
 P = "x" * 100
 M = P * 10
 G = M * 10
-OBJ = { :small => P, :medium => M, :big => G}
+X = { :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
+puts " Write"
+puts "--------------"
 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 }}
@@ -31,15 +32,6 @@ Benchmark.bmbm do |b|
   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 }}
@@ -51,13 +43,27 @@ Benchmark.bmbm do |b|
   b.report("MemCacheT # -") { 10_000.times { |i| @memto.decrement i.to_s }}
 end
 
+puts " Read"
+puts "--------------"
+#TODO: implement read with diff data. ALl should probably be 0 here
+Benchmark.bmbm do |b|
+  b.report("TokyoStore# Seq") { 10_000.times { |i| @tokyo.read i.to_s }}
+  b.report("MemCacheD # Seq") { 10_000.times { |i| @memca.read i.to_s }}
+  b.report("MemCacheT # Seq") { 10_000.times { |i| @memto.read i.to_s }}
+  b.report("TokyoStore# Rand") { 10_000.times { |i| @tokyo.read rand(i).to_s }}
+  b.report("MemCacheD # Rand") { 10_000.times { |i| @memca.read rand(i).to_s }}
+  b.report("MemCacheT # Rand") { 10_000.times { |i| @memto.read rand(i).to_s }}
+  b.report("TokyoStore# Exist") { 10_000.times { |i| @tokyo.exist? i.to_s }}
+  b.report("MemCacheD # Exist") { 10_000.times { |i| @memca.exist? i.to_s }}
+  b.report("MemCacheT # Exist") { 10_000.times { |i| @memto.exist? 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 # W") {  100.times { |j| thr << Thread.new { 100.times { |i| @tokyo.write "#{j}-#{i}", X }}};  thr.each { |t| t.join }; thr = [] }
+  b.report("MemCa # W") {  100.times { |j| thr << Thread.new { 100.times { |i| @memca.write "#{j}-#{i}", X}}};  thr.each { |t| t.join }; thr = [] }
+  b.report("MemTo # W") {  100.times { |j| thr << Thread.new { 100.times { |i| @memto.write "#{j}-#{i}", X}}};  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 = [] }
@@ -69,6 +75,8 @@ __END__
 
 Core 2 Duo 8500 - 3.16Ghz
 ------------------------------------------------------------
+ Write
+-------------
 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)
@@ -78,18 +86,9 @@ 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# X    0.480000   0.130000   0.610000 (  1.299556)
+MemCacheD # X    1.460000   0.280000   1.740000 (  1.980678)
+MemCacheT # X    1.230000   0.230000   1.460000 (  1.856561)
 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)
@@ -100,9 +99,22 @@ 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)
+ Read
+--------------
+TokyoStore# Seq     0.440000   0.150000   0.590000 (  0.858501)
+MemCacheD # Seq     0.830000   0.220000   1.050000 (  1.135630)
+MemCacheT # Seq     1.210000   0.190000   1.400000 (  1.754004)
+TokyoStore# Rand    0.490000   0.200000   0.690000 (  1.003466)
+MemCacheD # Rand    0.870000   0.170000   1.040000 (  1.135382)
+MemCacheT # Rand    1.410000   0.230000   1.640000 (  1.971372)
+TokyoStore# Exist   0.460000   0.140000   0.600000 (  0.845920)
+MemCacheD # Exist   0.810000   0.220000   1.030000 (  1.138310)
+MemCacheT # Exist   1.150000   0.250000   1.400000 (  1.760770)
+
+
+Tokyo # W   0.510000   0.150000   0.660000 (  1.023739)
+MemCa # W   2.530000   0.210000   2.740000 (  3.072881)
+MemTo # W   2.600000   0.280000   2.880000 (  3.344125)
+Tokyo # R   0.680000   0.210000   0.890000 (  2.547828)
+MemCa # R   2.190000   0.240000   2.430000 (  2.977408)
+MemTo # R   3.210000   0.330000   3.540000 (  4.298882)

data/lib/{rack/cache/tokyo_cache_store.rb → cache/tokyo_store.rb}

@@ -1,6 +1,5 @@
 require 'rufus/tokyo/tyrant'
 # require 'tokyocabinet'
-
 module ActiveSupport
   module Cache
 

data/lib/rack/session/tokyo.rb

@@ -5,20 +5,14 @@ module Rack
       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] ||
+        host, port = *options[:tyrant_server] || @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
@@ -30,9 +24,9 @@ module Rack
 
       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
+        session = Marshal.load(@pool[sid]) rescue session if sid
+        unless sid && session
           env['rack.errors'].puts("Session '#{sid.inspect}' not found, initializing...") if $VERBOSE and not sid.nil?
           session = {}
           sid = generate_sid
@@ -49,27 +43,26 @@ module Rack
 
       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]
+        session = Marshal.load(session) if session = @pool[sid]
+        if options[:renew] || options[:drop]
           @pool.delete sid
           return false if options[:drop]
           sid = generate_sid
-          @pool[sid] = 0
+          @pool[sid] = ""
         end
         old_session = new_session.instance_variable_get('@old') || {}
         session = merge_sessions sid, old_session, new_session, session
-        @pool[sid] = Marshal.dump(session) #, options])
+        @pool[sid] = options && options[:raw] ? session : Marshal.dump(session)
         return sid
       rescue => e
-        warn "#{self} is unable to find server. #{e}"
+        warn "#{self} is unable to find server, error: #{e}"
         warn $!.inspect
         return false
       ensure
         @mutex.unlock if env['rack.multithread']
       end
 
-      def merge_sessions(sid, old, new, cur=nil)
-        cur ||= {}
+      def merge_sessions(sid, old, new, cur={})
         unless Hash === old and Hash === new
           warn 'Bad old or new sessions provided.'
           return cur

data/lib/tokyo_store.rb

@@ -6,18 +6,10 @@ if defined?(Rack::Session)
   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"
+#   require "cache/sinatra/tokyo_store"
 # elsif defined?(Rails)
-#   require "cache/rails/redis_store"
+#   require "cache/rails/tokyo_store"
 # end
 

data/spec/cache/tokyo_store_spec.rb

@@ -0,0 +1,253 @@
+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", :raw => true).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
+      pending "It's on the rails tests..."
+      @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

@@ -29,8 +29,8 @@ module Rack
       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.host.should eql("localhost")
+        pool.port.should eql(1978)
 
         # pool = Rack::Session::Tokyo.new(@incrementor, :tokyo_server => ["localhost:6379", "localhost:6380"]).pool
         # pool.should be_kind_of(DistributedMarshaledTokyo)
@@ -40,7 +40,7 @@ module Rack
         pool = Rack::Session::Tokyo.new(@incrementor)
         res = Rack::MockRequest.new(pool).get("/")
         res["Set-Cookie"].should match(/#{@session_key}=/)
-        res.body.should == '{"counter"=>1}'
+        res.body.should eql('{"counter"=>1}')
       end
 
       it "determines session from a cookie" do
@@ -48,36 +48,34 @@ module Rack
         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}'
+        req.get("/", "HTTP_COOKIE" => cookie).body.should eql('{"counter"=>2}')
+        req.get("/", "HTTP_COOKIE" => cookie).body.should eql('{"counter"=>3}')
       end
 
       it "survives nonexistant cookies" do
-        bad_cookie = "rack.session=blarghfasel"
+        bad_cookie = "rack.session=blsarghfasel"
         pool = Rack::Session::Tokyo.new(@incrementor)
-        res = Rack::MockRequest.new(pool).
-          get("/", "HTTP_COOKIE" => bad_cookie)
-        res.body.should == '{"counter"=>1}'
+        res = Rack::MockRequest.new(pool).get("/", "HTTP_COOKIE" => bad_cookie)
+        res.body.should eql('{"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
+      # Expire isn't supported by cabinet. Implement in ruby?
+      # 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)
@@ -233,6 +231,10 @@ module Rack
         session['counter'].should be_nil
         session['foo'].should == 'bar'
       end
+
+      after(:all) do
+         Rack::Session::Tokyo.new(@incrementor).pool.clear
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,33 +1,11 @@
 $: << 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'))
+%W{rubygems spec rack/cache activesupport }.each { |l| require l }
 require 'tokyo_store'
 require 'rack/session/tokyo'
+require 'cache/tokyo_store'
 #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|
+class City;  attr_accessor :name, :pop;end
 
-end
+Spec::Runner.configure do |config|;end

data/tokyo_store.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{tokyo_store}
-  s.version = "0.1.7"
+  s.version = "0.1.8"
 
   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.date = %q{2009-07-04}
   s.email = %q{x@nofxx.com}
   s.extra_rdoc_files = [
     "LICENSE",
@@ -19,11 +19,14 @@ Gem::Specification.new do |s|
      "README.rdoc",
      "Rakefile",
      "VERSION",
-     "benchmark/tokyo_store.rb",
-     "lib/rack/cache/tokyo_cache_store.rb",
+     "benchmark/cache.rb",
+     "lib/cache/tokyo_store.rb",
+     "lib/rack/cache/tokyo_entitystore.rb",
+     "lib/rack/cache/tokyo_metastore.rb",
      "lib/rack/session/tokyo.rb",
      "lib/tokyo_store.rb",
-     "spec/rack/cache/tokyo_cache_spec.rb",
+     "spec/cache/tokyo_store_spec.rb",
+     "spec/rack/cache/tokyo_spec.rb",
      "spec/rack/session/tokyo_spec.rb",
      "spec/spec.opts",
      "spec/spec_helper.rb",
@@ -36,9 +39,10 @@ Gem::Specification.new do |s|
   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/cache/tokyo_spec.rb",
      "spec/rack/session/tokyo_spec.rb",
      "spec/tokyo_store_spec.rb",
+     "spec/cache/tokyo_store_spec.rb",
      "spec/spec_helper.rb"
   ]
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: nofxx-tokyo_store
 version: !ruby/object:Gem::Version 
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors: 
 - Marcos Piccinini
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-03 00:00:00 -07:00
+date: 2009-07-04 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -29,11 +29,14 @@ files:
 - README.rdoc
 - Rakefile
 - VERSION
-- benchmark/tokyo_store.rb
-- lib/rack/cache/tokyo_cache_store.rb
+- benchmark/cache.rb
+- lib/cache/tokyo_store.rb
+- lib/rack/cache/tokyo_entitystore.rb
+- lib/rack/cache/tokyo_metastore.rb
 - lib/rack/session/tokyo.rb
 - lib/tokyo_store.rb
-- spec/rack/cache/tokyo_cache_spec.rb
+- spec/cache/tokyo_store_spec.rb
+- spec/rack/cache/tokyo_spec.rb
 - spec/rack/session/tokyo_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
@@ -66,7 +69,8 @@ signing_key:
 specification_version: 3
 summary: Tokyo Tyrant rails session store
 test_files: 
-- spec/rack/cache/tokyo_cache_spec.rb
+- spec/rack/cache/tokyo_spec.rb
 - spec/rack/session/tokyo_spec.rb
 - spec/tokyo_store_spec.rb
+- spec/cache/tokyo_store_spec.rb
 - spec/spec_helper.rb

data/spec/rack/cache/tokyo_cache_spec.rb

@@ -1,252 +0,0 @@
-# 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