honkster-redis-store 0.3.10

data/lib/rack/session/merb.rb

@@ -0,0 +1,32 @@
+module Merb
+  # HACK for cyclic dependency: redis-store is required before Merb session stores
+  class Mash < Hash; end
+  class SessionContainer < Mash; class_inheritable_accessor :session_store_type end
+  class SessionStoreContainer < SessionContainer; end
+
+  class RedisSession < SessionStoreContainer
+    self.session_store_type = :redis
+  end
+
+  module RedisStore
+    def retrieve_session(session_id)
+      get("session:#{session_id}")
+    end
+
+    def store_session(session_id, data)
+      set("session:#{session_id}", data)
+    end
+
+    def delete_session(session_id)
+      delete("session:#{session_id}")
+    end    
+  end
+end
+
+module Rack
+  module Session
+    class Redis
+      include Merb::RedisStore
+    end
+  end
+end

data/lib/rack/session/redis.rb

@@ -0,0 +1,81 @@
+module Rack
+  module Session
+    class Redis < Abstract::ID
+      attr_reader :mutex, :pool
+      DEFAULT_OPTIONS = Abstract::ID::DEFAULT_OPTIONS.merge :redis_server => "localhost:6379"
+
+      def initialize(app, options = {})
+        super
+        @mutex = Mutex.new
+        @pool = RedisFactory.create options[:redis_server] || @default_options[:redis_server]
+      end
+
+      def generate_sid
+        loop do
+          sid = super
+          break sid unless @pool.marshalled_get(sid)
+        end
+      end
+
+      def get_session(env, sid)
+        session = @pool.marshalled_get(sid) if 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.marshalled_set sid, session
+          raise "Session collision on '#{sid.inspect}'" unless ret
+        end
+        session.instance_variable_set('@old', {}.merge(session))
+        return [sid, session]
+      rescue Errno::ECONNREFUSED
+        warn "#{self} is unable to find server."
+        warn $!.inspect
+        return [ nil, {} ]
+      ensure
+        @mutex.unlock if env['rack.multithread']
+      end
+
+      def set_session(env, session_id, new_session, options)
+        @mutex.lock if env['rack.multithread']
+        session = @pool.marshalled_get(session_id) rescue {}
+        if options[:renew] or options[:drop]
+          @pool.del session_id
+          return false if options[:drop]
+          session_id = generate_sid
+          @pool.marshalled_set session_id, 0
+        end
+        old_session = new_session.instance_variable_get('@old') || {}
+        session = merge_sessions session_id, old_session, new_session, session
+        @pool.marshalled_set session_id, session, options
+        return session_id
+      rescue Errno::ECONNREFUSED
+        warn "#{self} is unable to find server."
+        warn $!.inspect
+        return false
+      ensure
+        @mutex.unlock if env['rack.multithread']
+      end
+
+      private
+        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.del 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/redis/distributed_marshaled_redis.rb

@@ -0,0 +1,16 @@
+class DistributedMarshaledRedis < DistRedis
+  attr_reader :ring
+
+  def initialize(addresses)
+    nodes = addresses.map do |address|
+      MarshaledRedis.new address
+    end
+    @ring = Redis::HashRing.new nodes
+  end
+
+  def nodes
+    ring.nodes
+  end
+
+  alias_method :flushdb, :delete_cloud!
+end

data/lib/redis/marshaled_redis.rb

@@ -0,0 +1,52 @@
+class MarshaledRedis < Redis::Client
+  def marshalled_set(key, val, options = nil)
+    val = marshal_value(val, options)
+    if expires_in = expires_in(options)
+      set_with_expire key, val, expires_in
+    else
+      set key, val
+    end
+  end
+
+  def marshalled_setnx(key, val, options = nil)
+    val = marshal_value(val, options)
+    if expires_in = expires_in(options)
+      setnx_with_expire key, val, expires_in
+    else
+      setnx key, val
+    end
+  end
+
+  def setnx_with_expire(key, value, ttl)
+    multi do
+      setnx(key, val)
+      expire(key, expires_in)
+    end
+  end
+
+  def marshalled_get(key, options = nil)
+    result = call_command([:get, key])
+    result = Marshal.load result if unmarshal?(result, options)
+    result
+  end
+
+  private
+    def marshal_value(val, options)
+      raw?(options) ? val : Marshal.dump(val)
+    end
+
+    def unmarshal?(result, options)
+      result && result.size > 0 && !raw?(options)
+    end
+
+    def raw?(options)
+      options && options[:raw]
+    end
+
+    def expires_in(options)
+      if options
+        # Rack::Session           Merb                    Rails/Sinatra
+        options[:expire_after] || options[:expires_in] || options[:expire_in]
+      end
+    end
+end

data/lib/redis/redis_factory.rb

@@ -0,0 +1,26 @@
+class RedisFactory
+  class << self
+    def create(*redis_client_options)
+      redis_client_options = redis_client_options.flatten.compact.inject([]) do |result, address|
+        result << convert_to_redis_client_options(address)
+        result
+      end
+      if redis_client_options.size > 1
+        DistributedMarshaledRedis.new redis_client_options
+      else
+        MarshaledRedis.new redis_client_options.first || {}
+      end
+    end
+
+    def convert_to_redis_client_options(address_or_options)
+      return address_or_options if address_or_options.is_a?(Hash)
+      host, port = address_or_options.split /\:/
+      port, db   = port.split /\// if port
+      options = {}
+      options[:host] = host if host
+      options[:port] = port if port
+      options[:db]  = db.to_i if db
+      options
+    end
+  end
+end

data/lib/redis-store.rb

@@ -0,0 +1,33 @@
+require "redis"
+require "redis/dist_redis"
+require "redis/redis_factory"
+require "redis/marshaled_redis"
+require "redis/distributed_marshaled_redis"
+
+# 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"
+  require "cache/rails/redis_session_store"
+end
+
+# Rack::Session
+if defined?(Rack::Session)
+  require "rack/session/abstract/id"
+  require "rack/session/redis"
+  if defined?(Merb)
+    require "rack/session/merb"
+  end
+end
+
+# Rack::Cache
+if defined?(Rack::Cache)
+  require "rack/cache/key"
+  require "rack/cache/redis_metastore"
+  require "rack/cache/redis_entitystore"
+end

data/redis-store.gemspec

@@ -0,0 +1,80 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{redis-store}
+  s.version = "0.3.7"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Luca Guidi"]
+  s.date = %q{2009-11-15}
+  s.description = %q{Rack::Session, Rack::Cache and cache Redis stores for Ruby web frameworks.}
+  s.email = %q{guidi.luca@gmail.com}
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    ".gitignore",
+     "Gemfile",
+     "MIT-LICENSE",
+     "README.md",
+     "Rakefile",
+     "VERSION",
+     "lib/cache/merb/redis_store.rb",
+     "lib/cache/rails/redis_store.rb",
+     "lib/cache/sinatra/redis_store.rb",
+     "lib/rack/cache/redis_entitystore.rb",
+     "lib/rack/cache/redis_metastore.rb",
+     "lib/rack/session/merb.rb",
+     "lib/rack/session/redis.rb",
+     "lib/redis-store.rb",
+     "lib/redis/distributed_marshaled_redis.rb",
+     "lib/redis/marshaled_redis.rb",
+     "lib/redis/redis_factory.rb",
+     "redis-store.gemspec",
+     "spec/cache/merb/redis_store_spec.rb",
+     "spec/cache/rails/redis_store_spec.rb",
+     "spec/cache/sinatra/redis_store_spec.rb",
+     "spec/config/master.conf",
+     "spec/config/single.conf",
+     "spec/config/slave.conf",
+     "spec/rack/cache/entitystore/pony.jpg",
+     "spec/rack/cache/entitystore/redis_spec.rb",
+     "spec/rack/cache/metastore/redis_spec.rb",
+     "spec/rack/session/redis_spec.rb",
+     "spec/redis/distributed_marshaled_redis_spec.rb",
+     "spec/redis/marshaled_redis_spec.rb",
+     "spec/redis/redis_factory_spec.rb",
+     "spec/spec_helper.rb",
+     "tasks/redis.tasks.rb"
+  ]
+  s.homepage = %q{http://github.com/jodosha/redis-store}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Rack::Session, Rack::Cache and cache Redis stores for Ruby web frameworks.}
+  s.test_files = [
+    "spec/cache/merb/redis_store_spec.rb",
+     "spec/cache/rails/redis_store_spec.rb",
+     "spec/cache/sinatra/redis_store_spec.rb",
+     "spec/rack/cache/entitystore/redis_spec.rb",
+     "spec/rack/cache/metastore/redis_spec.rb",
+     "spec/rack/session/redis_spec.rb",
+     "spec/redis/distributed_marshaled_redis_spec.rb",
+     "spec/redis/marshaled_redis_spec.rb",
+     "spec/redis/redis_factory_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

data/spec/cache/merb/redis_store_spec.rb

@@ -0,0 +1,140 @@
+require File.join(File.dirname(__FILE__), "/../../spec_helper")
+
+module Merb
+  module Cache
+    describe "Merb::Cache::RedisStore" do
+      before(:each) do
+        @store  = Merb::Cache::RedisStore.new
+        @dstore = Merb::Cache::RedisStore.new :servers => ["localhost:6380/1", "localhost:6381/1"]
+        @rabbit = OpenStruct.new :name => "bunny"
+        @white_rabbit = OpenStruct.new :color => "white"
+        with_store_management do |store|
+          store.write "rabbit", @rabbit
+          store.delete "rub-a-dub"
+        end
+      end
+
+      it "should accept connection params" do
+        redis = instantiate_store
+        redis.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0"
+
+        redis = instantiate_store "localhost"
+        redis.to_s.should == "Redis Client connected to localhost:6379 against DB 0"
+
+        redis = instantiate_store "localhost:6380"
+        redis.to_s.should == "Redis Client connected to localhost:6380 against DB 0"
+
+        redis = instantiate_store "localhost:6380/13"
+        redis.to_s.should == "Redis Client connected to localhost:6380 against DB 13"
+      end
+
+      it "should instantiate a ring" do
+        store = instantiate_store
+        store.should be_kind_of(MarshaledRedis)
+        store = instantiate_store ["localhost:6379/0", "localhost:6379/1"]
+        store.should be_kind_of(DistributedMarshaledRedis)
+      end
+
+      it "should verify if writable" do
+        with_store_management do |store|
+          store.writable?("rabbit").should be_true
+        end
+      end
+
+      it "should read the data" do
+        with_store_management do |store|
+          store.read("rabbit").should === @rabbit
+        end
+      end
+
+      it "should read raw data" do
+        with_store_management do |store|
+          store.read("rabbit", {}, :raw => true).should == "\004\bU:\017OpenStruct{\006:\tname\"\nbunny"
+        end
+      end
+
+      it "should write the data" do
+        with_store_management do |store|
+          store.write "rabbit", @white_rabbit
+          store.read("rabbit").should === @white_rabbit
+        end
+      end
+
+      it "should write raw data" do
+        with_store_management do |store|
+          store.write "rabbit", @white_rabbit, {}, :raw => true
+          store.read("rabbit", {}, :raw => true).should == %(#<OpenStruct color="white">)
+        end
+      end
+
+      it "should write the data with expiration time" do
+        with_store_management do |store|
+          store.write "rabbit", @white_rabbit, {}, :expires_in => 1.second
+          store.read("rabbit").should === @white_rabbit ; sleep 2
+          store.read("rabbit").should be_nil
+        end
+      end
+
+      it "should not write data if :unless_exist option is true" do
+        with_store_management do |store|
+          store.write "rabbit", @white_rabbit, {}, :unless_exist => true
+          store.read("rabbit").should === @rabbit
+        end
+      end
+
+      it "should write all the data" do
+        with_store_management do |store|
+          store.write_all "rabbit", @white_rabbit
+          store.read("rabbit").should === @white_rabbit
+        end
+      end
+
+      it "should fetch data" do
+        with_store_management do |store|
+          store.fetch("rabbit").should == @rabbit
+          store.fetch("rub-a-dub").should be_nil
+          store.fetch("rub-a-dub") { "Flora de Cana" }
+          store.fetch("rub-a-dub").should === "Flora de Cana"
+        end
+      end
+
+      it "should verify existence" do
+        with_store_management do |store|
+          store.exists?("rabbit").should be_true
+          store.exists?("rab-a-dub").should be_false
+        end
+      end
+
+      it "should delete data" do
+        with_store_management do |store|
+          store.delete "rabbit"
+          store.read("rabbit").should be_nil
+        end
+      end
+
+      it "should delete all the data" do
+        with_store_management do |store|
+          store.delete_all
+          store.instance_variable_get(:@data).keys("*").flatten.should be_empty
+        end
+      end
+
+      it "should delete all the data with bang method" do
+        with_store_management do |store|
+          store.delete_all!
+          store.instance_variable_get(:@data).keys("*").flatten.should be_empty
+        end
+      end
+
+      private
+        def instantiate_store(addresses = nil)
+          Merb::Cache::RedisStore.new(:servers => [addresses].flatten).instance_variable_get(:@data)
+        end
+
+        def with_store_management
+          yield @store
+          yield @dstore
+        end
+    end
+  end
+end

data/spec/cache/rails/redis_session_store_spec.rb

@@ -0,0 +1,77 @@
+require File.join(File.dirname(__FILE__), "/../../spec_helper")
+
+module ActionController
+  module Session
+    describe "ActionController::Session::RedisSessionStore" do
+      attr_reader :app
+      before(:each) do
+        @app = Object.new
+        @store  = ActionController::Session::RedisSessionStore.new(app)
+        @dstore = ActionController::Session::RedisSessionStore.new app, :servers => ["localhost:6380/1", "localhost:6381/1"]
+        @rabbit = OpenStruct.new :name => "bunny"
+        @white_rabbit = OpenStruct.new :color => "white"
+        with_store_management do |store|
+          class << store
+            attr_reader :pool
+            public :get_session, :set_session
+          end
+          store.set_session({'rack.session.options' => {}}, "rabbit", @rabbit)
+          store.pool.del "counter"
+          store.pool.del "rub-a-dub"
+        end
+      end
+
+      it "should accept connection params" do
+        redis = instantiate_store
+        redis.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0"
+
+        redis = instantiate_store :servers => "localhost"
+        redis.to_s.should == "Redis Client connected to localhost:6379 against DB 0"
+
+        redis = instantiate_store :servers => "localhost:6380"
+        redis.to_s.should == "Redis Client connected to localhost:6380 against DB 0"
+
+        redis = instantiate_store :servers => "localhost:6380/13"
+        redis.to_s.should == "Redis Client connected to localhost:6380 against DB 13"
+      end
+
+      it "should instantiate a ring" do
+        store = instantiate_store
+        store.should be_kind_of(MarshaledRedis)
+        store = instantiate_store :servers => ["localhost:6379/0", "localhost:6379/1"]
+        store.should be_kind_of(DistributedMarshaledRedis)
+      end
+
+      it "should read the data" do
+        with_store_management do |store|
+          store.get_session({}, "rabbit").should === ["rabbit", @rabbit]
+        end
+      end
+
+      it "should write the data" do
+        with_store_management do |store|
+          store.set_session({"rack.session.options" => {}}, "rabbit", @white_rabbit)
+          store.get_session({}, "rabbit").should === ["rabbit", @white_rabbit]
+        end
+      end
+
+      it "should write the data with expiration time" do
+        with_store_management do |store|
+          store.set_session({"rack.session.options" => {:expires_in => 1.second}}, "rabbit", @white_rabbit)
+          store.get_session({}, "rabbit").should === ["rabbit", @white_rabbit]; sleep 2
+          store.get_session({}, "rabbit").should === ["rabbit", {}]
+        end
+      end
+
+      private
+        def instantiate_store(params={})
+          ActionController::Session::RedisSessionStore.new(app, params).instance_variable_get(:@pool)
+        end
+
+        def with_store_management
+          yield @store
+          yield @dstore
+        end
+    end
+  end
+end