xlymian-redis-store 0.3.8

data/lib/rack/cache/redis_entitystore.rb

@@ -0,0 +1,51 @@
+module Rack
+  module Cache
+    class EntityStore
+      class RedisBase < EntityStore
+        # The underlying ::Redis instance used to communicate with the Redis daemon.
+        attr_reader :cache
+
+        extend Rack::Utils
+
+        def open(key)
+          data = read(key)
+          data && [data]
+        end
+
+        def self.resolve(uri)
+          db = uri.path.sub(/^\//, '')
+          db = "0" if db.empty?
+          server = { :host => uri.host, :port => uri.port || "6379", :db => db }
+          new server
+        end
+      end
+
+      class Redis < RedisBase
+        def initialize(server, options = {})
+          @cache = ::Redis.new server
+        end
+
+        def exist?(key)
+          cache.key? key
+        end
+
+        def read(key)
+          cache.get key
+        end
+
+        def write(body)
+          buf = StringIO.new
+          key, size = slurp(body){|part| buf.write(part) }
+          [key, size] if cache.set(key, buf.string)
+        end
+
+        def purge(key)
+          cache.delete key
+          nil
+        end
+      end
+
+      REDIS = Redis
+    end
+  end
+end

data/lib/rack/cache/redis_metastore.rb

@@ -0,0 +1,42 @@
+module Rack
+  module Cache
+    class MetaStore
+      class RedisBase < MetaStore
+        extend Rack::Utils
+
+        # The ::MarshaledRedis object used to communicate with the Redis daemon.
+        attr_reader :cache
+
+        def self.resolve(uri)
+          db = uri.path.sub(/^\//, '')
+          db = "0" if db.empty?
+          server = { :host => uri.host, :port => uri.port || "6379", :db => db }
+          new server
+        end
+      end
+
+      class Redis < RedisBase
+        def initialize(server, options = {})
+          @cache = ::MarshaledRedis.new server
+        end
+
+        def read(key)
+          key = hexdigest(key)
+          cache.get(key) || []
+        end
+
+        def write(key, entries)
+          key = hexdigest(key)
+          cache.set(key, entries)
+        end
+
+        def purge(key)
+          cache.delete(hexdigest(key))
+          nil
+        end
+      end
+
+      REDIS = Redis
+    end
+  end
+end

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.get(sid)
+        end
+      end
+
+      def get_session(env, sid)
+        session = @pool.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.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.get(session_id) rescue {}
+        if options[:renew] or options[:drop]
+          @pool.delete session_id
+          return false if options[:drop]
+          session_id = generate_sid
+          @pool.set session_id, 0
+        end
+        old_session = new_session.instance_variable_get('@old') || {}
+        session = merge_sessions session_id, old_session, new_session, session
+        @pool.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.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/redis-store.rb

@@ -0,0 +1,32 @@
+require "redis"
+require "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"
+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/lib/redis/distributed_marshaled_redis.rb

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

data/lib/redis/marshaled_redis.rb

@@ -0,0 +1,33 @@
+class MarshaledRedis < Redis
+  def set(key, val, options = nil)
+    val = Marshal.dump val unless raw?(options)
+    super key, val, expires_in(options)
+  end
+
+  def set_unless_exists(key, val, options = nil)
+    val = Marshal.dump val unless raw?(options)
+    super key, val    
+  end
+
+  def get(key, options = nil)
+    result = call_command([:get, key])
+    result = Marshal.load result if unmarshal?(result, options)
+    result
+  end
+
+  private
+    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,28 @@
+class RedisFactory
+  class << self
+    def create(*addresses)
+      addresses = extract_addresses(addresses)
+      if addresses.size > 1
+        DistributedMarshaledRedis.new addresses
+      else
+        MarshaledRedis.new addresses.first || {}
+      end
+    end
+    
+    private
+      def extract_addresses(addresses)
+        addresses = addresses.flatten.compact
+        addresses.inject([]) do |result, address|
+          host, port, password = address.split /\:/
+          port, db   = port.split /\// if port
+          address = {}
+          address[:host] = host if host
+          address[:port] = port if port
+          address[:db]  = db.to_i if db
+          address[:password] = password if password
+          result << address
+          result
+        end
+      end
+  end
+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,145 @@
+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.host.should == "127.0.0.1"
+        redis.port.should == 6379
+        redis.db.should == 0
+
+        redis = instantiate_store "localhost"
+        redis.host.should == "localhost"
+
+        redis = instantiate_store "localhost:6380"
+        redis.host.should == "localhost"
+        redis.port.should == 6380
+
+        redis = instantiate_store "localhost:6380/13"
+        redis.host.should == "localhost"
+        redis.port.should == 6380
+        redis.db.should == 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