tokyo_store 0.3.0

data/lib/rack/session/cabinet.rb

@@ -0,0 +1,70 @@
+require 'tokyocabinet'
+module Rack
+  module Session
+    class Cabinet < Abstract::ID
+      include TokyoCabinet
+      attr_reader :mutex, :pool
+      DEFAULT_OPTIONS = Abstract::ID::DEFAULT_OPTIONS.merge :cabinet_file => "/tmp/session.tch"
+
+      def initialize(app, options = {})
+        super
+        @mutex = Mutex.new
+        @db = options[:cabinet_file] || @default_options[:cabinet_file]
+        tokyo_connect
+      end
+
+      private
+      def tokyo_connect
+        @pool = HDB.new
+        unless @pool.open(@db, HDB::OREADER | HDB::OWRITER | HDB::OCREAT)
+          warn "Can't open db file '#{@db}', #{@pool.errmsg}."
+        end
+      end
+
+      def get_session(env, sid)
+        session = Marshal.load(@pool.get(sid)) rescue session if sid && session = @pool.get(sid)
+        @mutex.lock if env['rack.multithread']
+        unless sid && session
+          env['rack.errors'].puts("Session '#{sid.inspect}' not found, initializing...") if $VERBOSE and not sid.nil?
+          session = {}
+          sid = generate_sid
+          ret = @pool.put(sid, Marshal.dump(session))
+          raise "Session collision on '#{sid.inspect}'" unless ret
+        end
+        return [sid, session]
+      rescue Rufus::Tokyo::TokyoError => e
+        return [nil,  {}]
+      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(session) rescue session if session = @pool.get(sid)
+        if options[:renew] || options[:drop]
+          @pool.out(sid)
+          return false if options[:drop]
+          sid = generate_sid
+          @pool.put(sid, "")
+        end
+        @pool.put(sid, options && options[:raw] ? new_session : Marshal.dump(new_session))
+        return sid
+      rescue Rufus::Tokyo::TokyoError => e
+        warn "#{self} is unable to find server, error: #{e}"
+        warn $!.inspect
+      ensure
+        @mutex.unlock if env['rack.multithread']
+      end
+
+      def generate_sid
+        loop do
+          sid = super
+          break sid unless @pool.get(sid)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/rack/session/rufus_tyrant.rb

@@ -0,0 +1,81 @@
+require 'rufus/tokyo/tyrant'
+
+module Rack
+  module Session
+    class RufusTyrant < Abstract::ID
+      attr_reader :mutex, :pool
+      DEFAULT_OPTIONS = Abstract::ID::DEFAULT_OPTIONS.merge :tyrant_server => "localhost:1978"
+
+      def initialize(app, options = {})
+        super
+        @mutex = Mutex.new
+        @host, @port = *(options[:tyrant_server] || @default_options[:tyrant_server]).split(":") # @default_options)        #options[:cache] ||
+        # connecting & closing on each get and put
+        # not sure if this is the best option, but otherwise it'll keep
+        # opening connections until tyrant freezes... =/
+         tokyo_connect
+      end
+
+      private
+      def tokyo_connect
+        begin
+        @pool ||= Rufus::Tokyo::Tyrant.new(@host, @port.to_i)
+        rescue Rufus::Tokyo::TokyoError => e
+          warn "Can't connect to Tyrant #{e}"
+        end
+      end
+
+      def get_session(env, sid)
+      #  tokyo_connect
+        session = Marshal.load(@pool[sid]) rescue session if sid && session = @pool[sid]
+        @mutex.lock if env['rack.multithread']
+        unless sid && 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 Rufus::Tokyo::TokyoError => e
+        return [nil,  {}]
+      ensure
+        @mutex.unlock if env['rack.multithread']
+      #  @pool.close
+      end
+
+      def set_session(env, sid, new_session, options)
+      #  tokyo_connect
+        @mutex.lock if env['rack.multithread']
+        session = Marshal.load(session) rescue session if session = @pool[sid]
+        if options[:renew] || options[:drop]
+          @pool.delete sid
+          return false if options[:drop]
+          sid = generate_sid
+          @pool[sid] = ""
+        end
+        old_session = new_session.instance_variable_get('@old') || {}
+        session = new_session
+        @pool[sid] = options && options[:raw] ? session : Marshal.dump(session)
+        return sid
+      rescue Rufus::Tokyo::TokyoError => e
+        warn "#{self} is unable to find server, error: #{e}"
+        warn $!.inspect
+      ensure
+        @mutex.unlock if env['rack.multithread']
+     #   @pool.close
+      end
+
+      def generate_sid
+        loop do
+          sid = super
+          break sid unless @pool[sid]
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/rack/session/tyrant.rb

@@ -0,0 +1,70 @@
+require 'tokyotyrant'
+module Rack
+  module Session
+    class Tyrant < Abstract::ID
+      include TokyoTyrant
+      attr_reader :mutex, :pool
+      DEFAULT_OPTIONS = Abstract::ID::DEFAULT_OPTIONS.merge :tyrant_server => "localhost:1978"
+
+      def initialize(app, options = {})
+        super
+        @mutex = Mutex.new
+        @host, @port = *(options[:tyrant_server] || @default_options[:tyrant_server]).split(":")
+        tokyo_connect
+      end
+
+      private
+      def tokyo_connect
+        @pool = RDB.new
+        unless @pool.open(@host, @port.to_i)
+          warn "Can't connect to Tyrant #{@host}:#{@port}"
+        end
+      end
+
+      def get_session(env, sid)
+        session = Marshal.load(@pool.get(sid)) rescue session if sid && session = @pool.get(sid)
+        @mutex.lock if env['rack.multithread']
+        unless sid && session
+          env['rack.errors'].puts("Session '#{sid.inspect}' not found, initializing...") if $VERBOSE and not sid.nil?
+          session = {}
+          sid = generate_sid
+          ret = @pool.put(sid, Marshal.dump(session))
+          raise "Session collision on '#{sid.inspect}'" unless ret
+        end
+        return [sid, session]
+      rescue Rufus::Tokyo::TokyoError => e
+        return [nil,  {}]
+      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(session) rescue session if session = @pool.get(sid)
+        if options[:renew] || options[:drop]
+          @pool.delete sid
+          return false if options[:drop]
+          sid = generate_sid
+          @pool.put(sid, "")
+        end
+        @pool.put(sid, options && options[:raw] ? new_session : Marshal.dump(new_session))
+        return sid
+      rescue Rufus::Tokyo::TokyoError => e
+        warn "#{self} is unable to find server, error: #{e}"
+        warn $!.inspect
+      ensure
+        @mutex.unlock if env['rack.multithread']
+      end
+
+      def generate_sid
+        loop do
+          sid = super
+          break sid unless @pool.get(sid)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/tokyo_store.rb

@@ -0,0 +1,16 @@
+
+# Rack Session
+if defined?(Rack::Session)
+  require "rack/session/abstract/id"
+  require "rack/session/tyrant"
+  #require "rack/session/cabinet"
+  #require "rack/session/rufus_tyrant"
+end
+
+# # Cache store
+# if defined?(Sinatra)
+#   require "cache/sinatra/tokyo_store"
+# elsif defined?(Rails)
+#   require "cache/rails/tokyo_store"
+# end
+

data/spec/cache/tokyo_store_spec.rb

@@ -0,0 +1,256 @@
+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
+      ["val", "value", "vall", "val/1", "vla", "xla", "xla/1"].each do |v|
+        @cache.write(v, 1)
+      end
+
+      @cache.delete_matched('val')
+      ["val", "value", "vall", "val/1"].each { |v| @cache.read(v).should be_nil }
+      ["vla", "xla", "xla/1"].each { |v| @cache.read(v).should eql(1) }
+    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