redis_buddy 0.1.1

data/README.md

@@ -0,0 +1,27 @@
+# a namespaced Redis Cache Store for Rails 3
+
+## Installation
+
+    gem install redis_buddy
+
+
+## Configuration
+
+### Gemfile
+
+    gem "redis_buddy"
+
+### config/application.rb
+
+    config.cache_store = :redis_buddy_store
+
+    or
+
+    config.cache_store = :redis_buddy_store, ['127.0.0.1', '1.2.3.4']
+
+
+## Copyright
+
+(c) 2010 Ole Riesenberg, released under the MIT license
+
+redis-store (c) 2009 Luca Guidi - [http://lucaguidi.com](http://lucaguidi.com), released under the MIT license

data/lib/redis/distributed_marshaled_redis.rb

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

data/lib/redis/marshaled_redis.rb

@@ -0,0 +1,36 @@
+# (c) 2009 Luca Guidi
+
+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,29 @@
+# (c) 2009 Luca Guidi
+
+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 = 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
+          result << address
+          result
+        end
+      end
+  end
+end

data/lib/redis_buddy/cache_store.rb

@@ -0,0 +1,64 @@
+module ActiveSupport
+  module Cache
+    class RedisBuddyStore < Store
+      def initialize(*adresses)
+        ns = Rails.application.class.to_s.split('::').first.downcase
+        @r = RedisFactory.create(adresses)
+        @data = Redis::Namespace.new(ns, :redis => @r)
+      end
+
+      def write(key, value, options = nil)
+        super do
+          method = options && options[:unless_exist] ? :set_unless_exists : :set
+          @data.send method, key, value, options
+          @data.expire key, options[:expire] if options && options[:expire]
+        end
+      end
+
+      def read(key, options = nil)
+        super do
+          @data.get key, options
+        end
+      end
+
+      def ttl(key, options = nil)
+        @data.ttl key, options
+      end
+
+      def delete(key, options = nil)
+        super do
+          @data.delete key
+        end
+      end
+
+      def exist?(key, options = nil)
+        super do
+          @data.key? key
+        end
+      end
+
+      def increment(key, amount = 1)
+        @data.incr key, amount
+      end
+
+      def decrement(key, amount = 1)
+        @data.decr key, amount
+      end
+
+      def delete_matched(matcher, options = nil)
+        super do
+          @data.keys(matcher).each { |key| @data.delete key }
+        end
+      end
+
+      def clear
+        @data.flush_db
+      end
+
+      def info
+        @data.info
+      end
+    end
+  end
+end
+

data/lib/redis_buddy.rb

@@ -0,0 +1,9 @@
+require 'redis'
+require 'redis/dist_redis'
+require 'redis/namespace'
+
+require 'redis/redis_factory'
+require 'redis/marshaled_redis'
+require 'redis/distributed_marshaled_redis'
+
+require 'redis_buddy/cache_store'

data/spec/cache/redis_buddy_store.rb

@@ -0,0 +1,173 @@
+require File.join(File.dirname(__FILE__), "/../spec_helper")
+
+module ActiveSupport
+  module Cache
+    describe "ActiveSupport::Cache::RedisBuddyStore" do
+      before(:each) do
+        @store  = ActiveSupport::Cache::RedisBuddyStore.new
+        @dstore = ActiveSupport::Cache::RedisBuddyStore.new "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 "counter"
+          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 read the data" do
+        with_store_management do |store|
+          store.read("rabbit").should === @rabbit
+        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 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 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 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 delete data" do
+        with_store_management do |store|
+          store.delete "rabbit"
+          store.read("rabbit").should be_nil
+        end
+      end
+
+      it "should delete matched data" do
+        with_store_management do |store|
+          store.delete_matched "rabb*"
+          store.read("rabbit").should be_nil
+        end
+      end
+
+      it "should verify existence of an object in the store" do
+        with_store_management do |store|
+          store.exist?("rabbit").should be_true
+          store.exist?("rab-a-dub").should be_false
+        end
+      end
+
+      it "should increment a key" do
+        with_store_management do |store|
+          3.times { store.increment "counter" }
+          store.read("counter", :raw => true).to_i.should == 3
+        end
+      end
+
+      it "should decrement a key" do
+        with_store_management do |store|
+          3.times { store.increment "counter" }
+          2.times { store.decrement "counter" }
+          store.read("counter", :raw => true).to_i.should == 1
+        end
+      end
+
+      it "should increment a key by given value" do
+        with_store_management do |store|
+          store.increment "counter", 3
+          store.read("counter", :raw => true).to_i.should == 3
+        end
+      end
+
+      it "should decrement a key by given value" do
+        with_store_management do |store|
+          3.times { store.increment "counter" }
+          store.decrement "counter", 2
+          store.read("counter", :raw => true).to_i.should == 1
+        end
+      end
+
+      it "should clear the store" do
+        with_store_management do |store|
+          store.clear
+          store.instance_variable_get(:@data).keys("*").flatten.should be_empty
+        end
+      end
+
+      it "should return store stats" do
+        with_store_management do |store|
+          store.stats.should_not be_empty
+        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"
+          store.fetch("rabbit", :force => true).should be_nil # force cache miss
+          store.fetch("rabbit", :force => true, :expires_in => 1.second) { @white_rabbit }
+          store.fetch("rabbit").should === @white_rabbit ; sleep 2
+          store.fetch("rabbit").should be_nil
+        end
+      end
+
+      private
+        def instantiate_store(addresses = nil)
+          ActiveSupport::Cache::RedisBuddyStore.new(addresses).instance_variable_get(:@data)
+        end
+
+        def with_store_management
+          yield @store
+          yield @dstore
+        end
+    end
+  end
+end

data/spec/redis/distributed_marshaled_redis_spec.rb

@@ -0,0 +1,35 @@
+require File.join(File.dirname(__FILE__), "/../spec_helper")
+
+describe "DistributedMarshaledRedis" do
+  before(:each) do
+    @dmr = DistributedMarshaledRedis.new [
+      {:host => "localhost", :port => "6380", :db => 0},
+      {:host => "localhost", :port => "6381", :db => 0}
+    ]
+    @rabbit = OpenStruct.new :name => "bunny"
+    @white_rabbit = OpenStruct.new :color => "white"
+    @dmr.set "rabbit", @rabbit
+  end
+
+  after(:all) do
+    @dmr.ring.nodes.each { |server| server.flush_db }
+  end
+
+  it "should accept connection params" do
+    dmr = DistributedMarshaledRedis.new [ :host => "localhost", :port => "6380", :db => "1" ]
+    dmr.ring.should have(1).node
+    mr = dmr.ring.nodes.first
+    mr.host.should == "localhost"
+    mr.port.should == 6380
+    mr.db.should == 1
+  end
+
+  it "should set an object" do
+    @dmr.set "rabbit", @white_rabbit
+    @dmr.get("rabbit").should == @white_rabbit
+  end
+
+  it "should get an object" do
+    @dmr.get("rabbit").should == @rabbit
+  end
+end

data/spec/redis/marshaled_redis_spec.rb

@@ -0,0 +1,54 @@
+require File.join(File.dirname(__FILE__), "/../spec_helper")
+
+describe "MarshaledRedis" do
+  before(:each) do
+    @store = MarshaledRedis.new
+    @rabbit = OpenStruct.new :name => "bunny"
+    @white_rabbit = OpenStruct.new :color => "white"
+    @store.set    "rabbit", @rabbit
+    @store.delete "rabbit2"
+  end
+
+  after :each do
+    @store.quit
+  end
+
+  it "should unmarshal an object on get" do
+    @store.get("rabbit").should === @rabbit
+  end
+
+  it "should marshal object on set" do
+    @store.set "rabbit", @white_rabbit
+    @store.get("rabbit").should === @white_rabbit
+  end
+
+  it "should not unmarshal object on get if raw option is true" do
+    @store.get("rabbit", :raw => true).should == "\004\bU:\017OpenStruct{\006:\tname\"\nbunny"
+  end
+
+  it "should not marshal object on set if raw option is true" do
+    @store.set "rabbit", @white_rabbit, :raw => true
+    @store.get("rabbit", :raw => true).should == %(#<OpenStruct color="white">)
+  end
+
+  it "should not unmarshal object if getting an empty string" do
+    @store.set "empty_string", ""
+    lambda { @store.get("empty_string").should == "" }.should_not raise_error
+  end
+
+  it "should not set an object if already exist" do
+    @store.set_unless_exists "rabbit", @white_rabbit
+    @store.get("rabbit").should === @rabbit
+  end
+
+  it "should marshal object on set_unless_exists" do
+    @store.set_unless_exists "rabbit2", @white_rabbit
+    @store.get("rabbit2").should === @white_rabbit
+  end
+
+  it "should not marshal object on set_unless_exists if raw option is true" do
+    @store.set_unless_exists "rabbit2", @white_rabbit, :raw => true
+    @store.get("rabbit2", :raw => true).should == %(#<OpenStruct color="white">)
+  end
+end
+

data/spec/redis/redis_factory_spec.rb

@@ -0,0 +1,34 @@
+require File.join(File.dirname(__FILE__), "/../spec_helper")
+
+describe "RedisFactory" do
+  it "should instantiate a MarshaledRedis store" do
+    store = RedisFactory.create
+    store.should be_kind_of(MarshaledRedis)
+    store.host.should == "127.0.0.1"
+    store.port.should == 6379
+    store.db.should == 0
+  end
+
+  it "should allow to specify host" do
+    store = RedisFactory.create "localhost"
+    store.host.should == "localhost"
+  end
+
+  it "should allow to specify port" do
+    store = RedisFactory.create "localhost:6380"
+    store.host.should == "localhost"
+    store.port.should == 6380
+  end
+
+  it "should allow to specify db" do
+    store = RedisFactory.create "localhost:6380/13"
+    store.host.should == "localhost"
+    store.port.should == 6380
+    store.db.should == 13
+  end
+
+  it "should instantiate a DistributedMarshaledRedis store" do
+    store = RedisFactory.create "localhost:6379", "localhost:6380"
+    store.should be_kind_of(DistributedMarshaledRedis)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+$: << File.join(File.dirname(__FILE__), "/../lib")
+require 'bundler'
+Bundler.setup :testing
+require "ostruct"
+require "spec"
+require "redis"
+require "rails"
+require "redis_buddy"
+
+require "cache/redis_buddy_store"
+
+class Redis; attr_reader :host, :port, :db end
+$DEBUG = ENV["DEBUG"] === "true"
+

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification 
+name: redis_buddy
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Ole Riesenberg
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-26 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: redis
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 2
+        - 0
+        version: 0.2.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: redis-namespace
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 3
+        - 0
+        version: 0.3.0
+  type: :runtime
+  version_requirements: *id002
+description: A namespaced Redis Cache Store for Rails 3, based on redis-store
+email: labs@buddybrand.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- lib/redis/distributed_marshaled_redis.rb
+- lib/redis/marshaled_redis.rb
+- lib/redis/redis_factory.rb
+- lib/redis_buddy.rb
+- lib/redis_buddy/cache_store.rb
+- README.md
+has_rdoc: true
+homepage: http://buddybrand.de
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A namespaced Redis Cache Store for Rails 3
+test_files: 
+- spec/spec_helper.rb
+- spec/redis/distributed_marshaled_redis_spec.rb
+- spec/redis/marshaled_redis_spec.rb
+- spec/redis/redis_factory_spec.rb
+- spec/cache/redis_buddy_store.rb