nono-redis-store 1.0.0

data/lib/redis-store.rb

@@ -0,0 +1,44 @@
+require "redis"
+require "redis/distributed"
+require "redis/factory"
+require "redis/store/interface"
+require "redis/store/ttl"
+require "redis/store/namespace"
+require "redis/store/marshalling"
+require "redis/store/version"
+require "redis/store"
+require "redis/distributed_store"
+
+# 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"
+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
+
+# ActionDispatch::Session
+if ::Redis::Store.rails3?
+  require "action_controller/session/redis_session_store"
+end
+
+# Rack::Cache
+if defined?(Rack::Cache)
+  require "rack/cache/key"
+  require "rack/cache/redis_metastore"
+  require "rack/cache/redis_entitystore"
+end
+
+if defined?(I18n)
+  require "i18n/backend/redis"
+end

data/lib/redis/distributed_store.rb

@@ -0,0 +1,35 @@
+class Redis
+  class DistributedStore < Distributed
+    attr_reader :ring
+
+    def initialize(addresses, options = { })
+      nodes = addresses.map do |address|
+        ::Redis::Store.new address
+      end
+      _extend_namespace options
+      @ring = Redis::HashRing.new nodes
+    end
+
+    def nodes
+      ring.nodes
+    end
+
+    def set(key, value, options = nil)
+      node_for(key).set(key, value, options)
+    end
+
+    def get(key, options = nil)
+      node_for(key).get(key, options)
+    end
+
+    def setnx(key, value, options = nil)
+      node_for(key).setnx(key, value, options)
+    end
+
+    private
+      def _extend_namespace(options)
+        @namespace = options[:namespace]
+        extend ::Redis::Store::Namespace if @namespace
+      end
+  end
+end

data/lib/redis/factory.rb

@@ -0,0 +1,46 @@
+class Redis
+  class Factory
+    def self.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
+        ::Redis::DistributedStore.new redis_client_options
+      else
+        ::Redis::Store.new redis_client_options.first || {}
+      end
+    end
+
+    def self.convert_to_redis_client_options(address_or_options)
+      if address_or_options.is_a?(Hash)
+        options = address_or_options.dup
+        options[:namespace] ||= options.delete(:key_prefix) # RailsSessionStore
+        options
+      else
+        if address_or_options =~ /redis\:\/\//
+          require 'uri'
+          uri = URI.parse address_or_options
+          _, db, namespace = if uri.path
+            uri.path.split /\//
+          end
+        else
+          warn "[DEPRECATION] `#{address_or_options}` is deprecated. Please use `redis://#{address_or_options}` instead."
+          address_or_options, password = address_or_options.split(/\@/).reverse
+          password = password.gsub(/\:/, "") if password
+          host, port = address_or_options.split /\:/
+          port, db, namespace = port.split /\// if port
+        end
+
+        options = {}
+        options[:host] = host || uri && uri.host
+        options[:port] = port || uri && uri.port
+        options[:db]  = db.to_i if db
+        options[:namespace] = namespace if namespace
+        options[:password]  = password || uri && uri.password
+        options[:marshalling] = false if RUBY_VERSION =~ /1\.9/
+        options
+      end
+    end
+  end
+end

data/lib/redis/store.rb

@@ -0,0 +1,30 @@
+class Redis
+  class Store < self
+    include Ttl, Interface
+
+    def initialize(options = { })
+      super
+      _extend_marshalling options
+      _extend_namespace   options
+    end
+
+    def self.rails3? #:nodoc:
+      defined?(::Rails) && ::Rails::VERSION::MAJOR == 3
+    end
+
+    def to_s
+      "Redis Client connected to #{@client.host}:#{@client.port} against DB #{@client.db}"
+    end
+
+    private
+      def _extend_marshalling(options)
+        @marshalling = !(options[:marshalling] === false) # HACK - TODO delegate to Factory
+        extend Marshalling if @marshalling
+      end
+
+      def _extend_namespace(options)
+        @namespace = options[:namespace]
+        extend Namespace if @namespace
+      end
+  end
+end

data/lib/redis/store/interface.rb

@@ -0,0 +1,17 @@
+class Redis
+  class Store < self
+    module Interface
+      def get(key, options = nil)
+        super(key)
+      end
+
+      def set(key, value, options = nil)
+        super(key, value)
+      end
+
+      def setnx(key, value, options = nil)
+        super(key, value)
+      end
+    end
+  end
+end

data/lib/redis/store/marshalling.rb

@@ -0,0 +1,41 @@
+class Redis
+  class Store < self
+    module Marshalling
+      def set(key, value, options = nil)
+        _marshal(value, options) { |value| super key, value, options }
+      end
+
+      def setnx(key, value, options = nil)
+        _marshal(value, options) { |value| super key, value, options }
+      end
+
+      def get(key, options = nil)
+        _unmarshal super(key), options
+      end
+
+      def mget(*keys)
+        options = keys.flatten.pop if keys.flatten.last.is_a?(Hash)
+        super(*keys).map do |result|
+          _unmarshal result, options
+        end
+      end
+
+      private
+        def _marshal(val, options)
+          yield marshal?(options) ? val : Marshal.dump(val)
+        end
+
+        def _unmarshal(val, options)
+          unmarshal?(val, options) ? Marshal.load(val) : val
+        end
+
+        def marshal?(options)
+          options && options[:raw]
+        end
+
+        def unmarshal?(result, options)
+          result && result.size > 0 && !marshal?(options)
+        end
+    end
+  end
+end

data/lib/redis/store/namespace.rb

@@ -0,0 +1,54 @@
+class Redis
+  class Store < self
+    module Namespace
+      def set(key, val, options = nil)
+        namespace(key) { |key| super(key, val, options) }
+      end
+
+      def setnx(key, val, options = nil)
+        namespace(key) { |key| super(key, val, options) }
+      end
+
+      def get(key, options = nil)
+        namespace(key) { |key| super(key, options) }
+      end
+
+      def exists(key)
+        namespace(key) { |key| super(key) }
+      end
+
+      def incrby(key, increment)
+        namespace(key) { |key| super(key, increment) }
+      end
+
+      def decrby(key, increment)
+        namespace(key) { |key| super(key, increment) }
+      end
+
+      def keys(pattern = "*")
+        namespace(pattern) { |pattern| super(pattern) }
+      end
+
+      def del(*keys)
+        super *keys.map {|key| interpolate(key) }
+      end
+
+      def mget(*keys)
+        super *keys.map {|key| interpolate(key) }
+      end
+
+      def to_s
+        "#{super} with namespace #{@namespace}"
+      end
+
+      private
+        def namespace(key)
+          yield interpolate(key)
+        end
+
+        def interpolate(key)
+          key.match(%r{^#{@namespace}\:}) ? key : "#{@namespace}:#{key}"
+        end
+    end
+  end
+end

data/lib/redis/store/ttl.rb

@@ -0,0 +1,37 @@
+class Redis
+  class Store < self
+    module Ttl
+      def set(key, value, options = nil)
+        if ttl = expires_in(options)
+          setex(key, ttl, value)
+        else
+          super(key, value)
+        end
+      end
+
+      def setnx(key, value, options = nil)
+        if ttl = expires_in(options)
+          setnx_with_expire(key, value, ttl)
+        else
+          super(key, value)
+        end
+      end
+
+      protected
+        def setnx_with_expire(key, value, ttl)
+          multi do
+            setnx(key, value)
+            expire(key, expires_in)
+          end
+        end
+
+      private
+        def expires_in(options)
+          if options
+            # Rack::Session           Merb                    Rails/Sinatra
+            options[:expire_after] || options[:expires_in] || options[:expire_in]
+          end
+        end
+    end
+  end
+end

data/lib/redis/store/version.rb

@@ -0,0 +1,11 @@
+class Redis
+  class Store < self
+    module VERSION #:nodoc:
+      MAJOR = 1
+      MINOR = 0
+      TINY  = 0
+
+      STRING = [MAJOR, MINOR, TINY].join('.')
+    end
+  end
+end

data/redis-store.gemspec

@@ -0,0 +1,103 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{nono-redis-store}
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Luca Guidi", "Bruno Michel"]
+  s.date = %q{2010-11-15}
+  s.description = %q{Namespaced Rack::Session, Rack::Cache, I18n and cache Redis stores for Ruby web frameworks.}
+  s.email = %q{brmichel@free.fr}
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    ".gitignore",
+     "CHANGELOG",
+     "Gemfile",
+     "Gemfile.lock",
+     "MIT-LICENSE",
+     "README.md",
+     "Rakefile",
+     "VERSION",
+     "lib/action_controller/session/redis_session_store.rb",
+     "lib/active_support/cache/redis_store.rb",
+     "lib/cache/merb/redis_store.rb",
+     "lib/cache/sinatra/redis_store.rb",
+     "lib/i18n/backend/redis.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_store.rb",
+     "lib/redis/factory.rb",
+     "lib/redis/store.rb",
+     "lib/redis/store/interface.rb",
+     "lib/redis/store/marshalling.rb",
+     "lib/redis/store/namespace.rb",
+     "lib/redis/store/ttl.rb",
+     "lib/redis/store/version.rb",
+     "redis-store.gemspec",
+     "spec/action_controller/session/redis_session_store_spec.rb",
+     "spec/active_support/cache/redis_store_spec.rb",
+     "spec/cache/merb/redis_store_spec.rb",
+     "spec/cache/sinatra/redis_store_spec.rb",
+     "spec/config/master.conf",
+     "spec/config/single.conf",
+     "spec/config/slave.conf",
+     "spec/i18n/backend/redis_spec.rb",
+     "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_store_spec.rb",
+     "spec/redis/factory_spec.rb",
+     "spec/redis/store/interface_spec.rb",
+     "spec/redis/store/marshalling_spec.rb",
+     "spec/redis/store/namespace_spec.rb",
+     "spec/redis/store/version_spec.rb",
+     "spec/spec_helper.rb",
+     "tasks/redis.tasks.rb"
+  ]
+  s.homepage = %q{http://github.com/nono/redis-store/tree/nono}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Namespaced Rack::Session, Rack::Cache, I18n and cache Redis stores for Ruby web frameworks.}
+  s.test_files = [
+    "spec/action_controller/session/redis_session_store_spec.rb",
+     "spec/active_support/cache/redis_store_spec.rb",
+     "spec/cache/merb/redis_store_spec.rb",
+     "spec/cache/sinatra/redis_store_spec.rb",
+     "spec/i18n/backend/redis_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_store_spec.rb",
+     "spec/redis/factory_spec.rb",
+     "spec/redis/store/interface_spec.rb",
+     "spec/redis/store/marshalling_spec.rb",
+     "spec/redis/store/namespace_spec.rb",
+     "spec/redis/store/version_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::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<redis>, [">= 2.0.0"])
+    else
+      s.add_dependency(%q<redis>, [">= 2.0.0"])
+    end
+  else
+    s.add_dependency(%q<redis>, [">= 2.0.0"])
+  end
+end
+

data/spec/action_controller/session/redis_session_store_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+RAILS_SESSION_STORE_CLASS = ::Redis::Store.rails3? ? ActionDispatch::Session::RedisSessionStore : ActionController::Session::RedisSessionStore
+
+describe RAILS_SESSION_STORE_CLASS do
+  attr_reader :app
+
+  before :each do
+    @app = Object.new
+    @store  = RAILS_SESSION_STORE_CLASS.new(app)
+    @dstore = RAILS_SESSION_STORE_CLASS.new app, :servers => ["redis://127.0.0.1:6380/1", "redis://127.0.0.1:6381/1"]
+    @rabbit = OpenStruct.new :name => "bunny"
+    @white_rabbit = OpenStruct.new :color => "white"
+    @sid = "rabbit"
+    @env = {'rack.session.options' => {:id => @sid}}
+    with_store_management do |store|
+      class << store
+        attr_reader :pool
+        public :get_session, :set_session, :destroy
+      end
+      store.set_session(@env, @sid, @rabbit)
+      store.pool.del "counter"
+      store.pool.del "rub-a-dub"
+    end
+  end
+
+  it "should accept string 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 => "redis://localhost"
+    redis.to_s.should == "Redis Client connected to localhost:6379 against DB 0"
+
+    redis = instantiate_store :servers => "redis://localhost:6380"
+    redis.to_s.should == "Redis Client connected to localhost:6380 against DB 0"
+
+    redis = instantiate_store :servers => "redis://localhost:6380/13"
+    redis.to_s.should == "Redis Client connected to localhost:6380 against DB 13"
+
+    redis = instantiate_store :servers => "redis://localhost:6380/13/theplaylist"
+    redis.to_s.should == "Redis Client connected to localhost:6380 against DB 13 with namespace theplaylist"
+  end
+
+  it "should accept hash connection params" do
+    redis = instantiate_store :servers => [{ :host => "192.168.0.1" }]
+    redis.to_s.should == "Redis Client connected to 192.168.0.1:6379 against DB 0"
+
+    redis = instantiate_store :servers => [{ :port => "6380" }]
+    redis.to_s.should == "Redis Client connected to localhost:6380 against DB 0"
+
+    redis = instantiate_store :servers => [{ :db => 13 }]
+    redis.to_s.should == "Redis Client connected to localhost:6379 against DB 13"
+
+    redis = instantiate_store :servers => [{ :key_prefix => "theplaylist" }]
+    redis.to_s.should == "Redis Client connected to localhost:6379 against DB 0 with namespace theplaylist"
+  end
+
+  it "should instantiate a ring" do
+    store = instantiate_store
+    store.should be_kind_of(Redis::Store)
+    store = instantiate_store :servers => ["redis://127.0.0.1:6379/0", "redis://127.0.0.1:6379/1"]
+    store.should be_kind_of(Redis::DistributedStore)
+  end
+
+  it "should read the data" do
+    with_store_management do |store|
+      store.get_session(@env, @sid).should === [@sid, @rabbit]
+    end
+  end
+
+  it "should write the data" do
+    with_store_management do |store|
+      store.set_session(@env, @sid, @white_rabbit)
+      store.get_session(@env, @sid).should === [@sid, @white_rabbit]
+    end
+  end
+
+  it "should delete the data" do
+    with_store_management do |store|
+      store.destroy(@env)
+      store.get_session(@env, @sid).should === [@sid, {}]
+    end
+  end
+
+  it "should write the data with expiration time" do
+    with_store_management do |store|
+      @env['rack.session.options'].merge!(:expires_in => 1.second)
+      store.set_session(@env, @sid, @white_rabbit)
+      store.get_session(@env, @sid).should === [@sid, @white_rabbit]; sleep 2
+      store.get_session(@env, @sid).should === [@sid, {}]
+    end
+  end
+
+  describe "namespace" do
+    before :each do
+      @namespace = "theplaylist"
+      @store  = RAILS_SESSION_STORE_CLASS.new(lambda {|| }, :servers => [{ :namespace => @namespace }])
+      @pool   = @store.instance_variable_get(:@pool)
+      @client = @pool.instance_variable_get(:@client)
+    end
+
+    it "should read the data" do
+      @client.should_receive(:call).with(:get, "#{@namespace}:#{@sid}")
+      @store.send :get_session, @env, @sid
+    end
+
+    it "should write the data" do
+      @client.should_receive(:call).with(:set, "#{@namespace}:#{@sid}", Marshal.dump(@white_rabbit))
+      @store.send :set_session, @env, @sid, @white_rabbit
+    end
+  end
+
+  private
+    def instantiate_store(params = { })
+      RAILS_SESSION_STORE_CLASS.new(app, params).instance_variable_get(:@pool)
+    end
+
+    def with_store_management
+      yield @store
+      yield @dstore
+    end
+end