nono-redis-store 1.0.0

data/spec/redis/distributed_store_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe "Redis::DistributedStore" do
+  before(:each) do
+    @dmr = Redis::DistributedStore.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.flushdb }
+  end
+
+  it "should accept connection params" do
+    dmr = Redis::DistributedStore.new [ :host => "localhost", :port => "6380", :db => "1" ]
+    dmr.ring.nodes.size == 1
+    mr = dmr.ring.nodes.first
+    mr.to_s.should == "Redis Client connected to localhost:6380 against DB 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
+
+  describe "namespace" do
+    before :each do
+      @dmr = Redis::DistributedStore.new [
+        {:host => "localhost", :port => "6380", :db => 0},
+        {:host => "localhost", :port => "6381", :db => 0}
+      ], :namespace => "theplaylist"
+    end
+
+    it "should use namespaced key" do
+      @dmr.should_receive(:node_for).with("theplaylist:rabbit").and_return @dmr.nodes.first
+      @dmr.get "rabbit"
+    end
+  end
+end

data/spec/redis/factory_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe "Redis::Factory" do
+  describe ".create" do
+    context "when not given any arguments" do
+      it "should instantiate a Redis::Store store" do
+        store = Redis::Factory.create
+        store.should be_kind_of(Redis::Store)
+        store.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0"
+      end
+    end
+
+    context "when given a Hash" do
+      it "should allow to specify host" do
+        store = Redis::Factory.create :host => "localhost"
+        store.to_s.should == "Redis Client connected to localhost:6379 against DB 0"
+      end
+
+      it "should allow to specify port" do
+        store = Redis::Factory.create :host => "localhost", :port => 6380
+        store.to_s.should == "Redis Client connected to localhost:6380 against DB 0"
+      end
+
+      it "should allow to specify db" do
+        store = Redis::Factory.create :host => "localhost", :port => 6380, :db => 13
+        store.to_s.should == "Redis Client connected to localhost:6380 against DB 13"
+      end
+
+      it "should allow to specify namespace" do
+        store = Redis::Factory.create :namespace => "theplaylist"
+        store.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist"
+      end
+
+      it "should allow to specify key_prefix as namespace" do
+        store = Redis::Factory.create :key_prefix => "theplaylist"
+        store.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist"
+      end
+
+      it "should allow to specify marshalling" do
+        store = Redis::Factory.create :marshalling => false
+        store.instance_variable_get(:@marshalling).should be_false
+      end
+
+      it "should allow to specify password" do
+        store = Redis::Factory.create :password => "secret"
+        store.instance_variable_get(:@client).password.should == "secret"
+      end
+
+      it "should instantiate a Redis::DistributedStore store" do
+        store = Redis::Factory.create(
+          {:host => "localhost", :port => 6379},
+          {:host => "localhost", :port => 6380}
+        )
+        store.should be_kind_of(Redis::DistributedStore)
+        store.nodes.map {|node| node.to_s}.should == [
+          "Redis Client connected to localhost:6379 against DB 0",
+          "Redis Client connected to localhost:6380 against DB 0",
+        ]
+      end
+    end
+
+    context "when given a String" do
+      it "should allow to specify host" do
+        store = Redis::Factory.create "redis://127.0.0.1"
+        store.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0"
+      end
+
+      it "should allow to specify port" do
+        store = Redis::Factory.create "redis://127.0.0.1:6380"
+        store.to_s.should == "Redis Client connected to 127.0.0.1:6380 against DB 0"
+      end
+
+      it "should allow to specify db" do
+        store = Redis::Factory.create "redis://127.0.0.1:6380/13"
+        store.to_s.should == "Redis Client connected to 127.0.0.1:6380 against DB 13"
+      end
+
+      it "should allow to specify namespace" do
+        store = Redis::Factory.create "redis://127.0.0.1:6379/0/theplaylist"
+        store.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist"
+      end
+
+      it "should allow to specify scheme" do
+        store = Redis::Factory.create "redis://127.0.0.1:6379/0/theplaylist"
+        store.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist"
+      end
+
+      it "should allow to specify password" do
+        store = Redis::Factory.create "redis://:secret@127.0.0.1:6379/0/theplaylist"
+        store.instance_variable_get(:@client).password.should == "secret"
+      end
+
+      it "should allow to specify password without scheme" do
+        suppress_warnings do
+          store = Redis::Factory.create ":secret@127.0.0.1:6379/0/theplaylist"
+          store.instance_variable_get(:@client).password.should == "secret"
+        end
+      end
+
+      it "should instantiate a Redis::DistributedStore store" do
+        store = Redis::Factory.create "redis://127.0.0.1:6379", "redis://127.0.0.1:6380"
+        store.should be_kind_of(Redis::DistributedStore)
+        store.nodes.map {|node| node.to_s}.should == [
+          "Redis Client connected to 127.0.0.1:6379 against DB 0",
+          "Redis Client connected to 127.0.0.1:6380 against DB 0",
+        ]
+      end
+    end
+  end
+end

data/spec/redis/store/interface_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+class InterfacedRedis < Redis
+  include Redis::Store::Interface
+end
+
+describe "Redis::Store::Interface" do
+  before :each do
+    @r = InterfacedRedis.new
+  end
+
+  it "should get an element" do
+    lambda { @r.get("key", :option => true) }.should_not raise_error
+  end
+
+  it "should set an element" do
+    lambda { @r.set("key", "value", :option => true) }.should_not raise_error
+  end
+
+  it "should setnx an element" do
+    lambda { @r.setnx("key", "value", :option => true) }.should_not raise_error
+  end
+end

data/spec/redis/store/marshalling_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe "Redis::Marshalling" do
+  before(:each) do
+    @store = Redis::Store.new :marshalling => true
+    @rabbit = OpenStruct.new :name => "bunny"
+    @white_rabbit = OpenStruct.new :color => "white"
+    @store.set "rabbit", @rabbit
+    @store.del "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
+
+  if RUBY_VERSION.match /1\.9/
+    it "should not unmarshal object on get if raw option is true" do
+      @store.get("rabbit", :raw => true).should == "\x04\bU:\x0FOpenStruct{\x06:\tnameI\"\nbunny\x06:\x06EF"
+    end
+  else
+    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
+  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.setnx "rabbit", @white_rabbit
+    @store.get("rabbit").should === @rabbit
+  end
+
+  it "should marshal object on set_unless_exists" do
+    @store.setnx "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.setnx "rabbit2", @white_rabbit, :raw => true
+    @store.get("rabbit2", :raw => true).should == %(#<OpenStruct color="white">)
+  end
+
+  it "should unmarshal object(s) on multi get" do
+    @store.set "rabbit2", @white_rabbit
+    rabbit, rabbit2 = @store.mget "rabbit", "rabbit2"
+    rabbit.should  == @rabbit
+    rabbit2.should == @white_rabbit
+  end
+
+  if RUBY_VERSION.match /1\.9/
+    it "should not unmarshal object(s) on multi get if raw option is true" do
+      @store.set "rabbit2", @white_rabbit
+      rabbit, rabbit2 = @store.mget "rabbit", "rabbit2", :raw => true
+      rabbit.should  == "\x04\bU:\x0FOpenStruct{\x06:\tnameI\"\nbunny\x06:\x06EF"
+      rabbit2.should == "\x04\bU:\x0FOpenStruct{\x06:\ncolorI\"\nwhite\x06:\x06EF"
+    end
+  else
+    it "should not unmarshal object(s) on multi get if raw option is true" do
+      @store.set "rabbit2", @white_rabbit
+      rabbit, rabbit2 = @store.mget "rabbit", "rabbit2", :raw => true
+      rabbit.should  == "\004\bU:\017OpenStruct{\006:\tname\"\nbunny"
+      rabbit2.should == "\004\bU:\017OpenStruct{\006:\ncolor\"\nwhite"
+    end
+  end
+end
+

data/spec/redis/store/namespace_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe "Redis::Store::Namespace" do
+  before :each do
+    @namespace = "theplaylist"
+    @store  = Redis::Store.new :namespace => @namespace, :marshalling => false # TODO remove mashalling option
+    @client = @store.instance_variable_get(:@client)
+    @rabbit = "bunny"
+  end
+
+  after :each do
+    @store.should_receive(:quit) # stupid rspec, meh!
+    @store.quit
+  end
+
+  it "should only decorate instances that needs to be namespaced" do
+    @store = Redis::Store.new
+    client = @store.instance_variable_get(:@client)
+    client.should_receive(:call).with(:get, "rabbit")
+    @store.get("rabbit")
+  end
+
+  it "should not namespace a key which is already namespaced" do
+    @store.send(:interpolate, "#{@namespace}:rabbit").should == "#{@namespace}:rabbit"
+  end
+
+  it "should namespace get" do
+    @client.should_receive(:call).with(:get, "#{@namespace}:rabbit")
+    @store.get("rabbit")
+  end
+
+  it "should namespace set" do
+    @client.should_receive(:call).with(:set, "#{@namespace}:rabbit", @rabbit)
+    @store.set "rabbit", @rabbit
+  end
+
+  it "should namespace setnx" do
+    @client.should_receive(:call).with(:setnx, "#{@namespace}:rabbit", @rabbit)
+    @store.setnx "rabbit", @rabbit
+  end
+
+  it "should namespace del with single key" do
+    @client.should_receive(:call).with(:del, "#{@namespace}:rabbit")
+    @store.del "rabbit"
+  end
+
+  it "should namespace del with multiple keys" do
+    @client.should_receive(:call).with(:del, "#{@namespace}:rabbit", "#{@namespace}:white_rabbit")
+    @store.del "rabbit", "white_rabbit"
+  end
+
+  it "should namespace keys" do
+    @client.should_receive(:call).with(:keys, "#{@namespace}:rabb*").and_return [ "#{@namespace}:rabbit" ]
+    @store.keys "rabb*"
+  end
+
+  it "should namespace exists" do
+    @client.should_receive(:call).with(:exists, "#{@namespace}:rabbit")
+    @store.exists "rabbit"
+  end
+
+  it "should namespace incrby" do
+    @client.should_receive(:call).with(:incrby, "#{@namespace}:counter", 1)
+    @store.incrby "counter", 1
+  end
+
+  it "should namespace decrby" do
+    @client.should_receive(:call).with(:decrby, "#{@namespace}:counter", 1)
+    @store.decrby "counter", 1
+  end
+
+  it "should namespace mget" do
+    @client.should_receive(:call).with(:mget, "#{@namespace}:rabbit", "#{@namespace}:white_rabbit")
+    @store.mget "rabbit", "white_rabbit"
+  end
+end

data/spec/redis/store/version_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Redis::Store::VERSION do
+  it "should describe Redis::Store version" do
+    Redis::Store::VERSION::STRING.should == "1.0.0"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,43 @@
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "/../lib")))
+ARGV << "-b"
+require "rubygems"
+require "bundler"
+Bundler.setup
+require "methopara" if RUBY_VERSION.match /1\.9/
+require "ostruct"
+require "spec"
+require "spec/autorun"
+require "redis"
+require "merb"
+require "i18n"
+require "rack/cache"
+require "rack/cache/metastore"
+require "rack/cache/entitystore"
+require "active_support"
+begin
+  require "action_controller/session/abstract_store" # Rails 2.3.x
+rescue LoadError
+  require "action_dispatch/middleware/session/abstract_store" # Rails 3.x
+  module Rails
+    module VERSION
+      MAJOR = 3
+    end
+  end unless defined?(Rails)
+end
+require "redis-store"
+require "active_support/cache/redis_store"
+require "action_controller/session/redis_session_store"
+require "cache/sinatra/redis_store"
+
+$DEBUG = ENV["DEBUG"] === "true"
+
+# http://mentalized.net/journal/2010/04/02/suppress_warnings_from_ruby/
+module Kernel
+  def suppress_warnings
+    original_verbosity = $VERBOSE
+    $VERBOSE = nil
+    result = yield
+    $VERBOSE = original_verbosity
+    return result
+  end
+end

data/tasks/redis.tasks.rb

@@ -0,0 +1,220 @@
+# inspired by old Rake tasks from redis-rb
+require 'rake'
+require 'fileutils'
+require 'open-uri'
+
+class RedisRunner
+  def self.port
+    6379
+  end
+
+  def self.redisdir
+    @@redisdir ||= File.expand_path File.join(File.dirname(__FILE__), '..', 'vendor', 'redis')
+  end
+
+  def self.redisconfdir
+    '/etc/redis.conf'
+  end
+
+  def self.dtach_socket
+    '/tmp/redis.dtach'
+  end
+
+  # Just check for existance of dtach socket
+  def self.running?
+    File.exists? dtach_socket
+  end
+
+  def self.start
+    puts 'Detach with Ctrl+\  Re-attach with rake redis:attach'
+    sleep 3
+    exec "dtach -A #{dtach_socket} redis-server #{redisconfdir}"
+  end
+
+  def self.start_detached
+    system "dtach -n #{dtach_socket} redis-server #{redisconfdir}"
+  end
+
+  def self.attach
+    exec "dtach -a #{dtach_socket}"
+  end
+
+  def self.stop
+    system %(echo "SHUTDOWN" | nc localhost #{port})
+  end
+end
+
+class SingleRedisRunner < RedisRunner
+  def self.redisconfdir
+    File.expand_path(File.dirname(__FILE__) + "/../spec/config/single.conf")
+  end
+end
+
+class MasterRedisRunner < RedisRunner
+  def self.redisconfdir
+    File.expand_path(File.dirname(__FILE__) + "/../spec/config/master.conf")
+  end
+
+  def self.dtach_socket
+    "/tmp/redis_master.dtach"
+  end
+
+  def self.port
+    6380
+  end
+end
+
+class SlaveRedisRunner < RedisRunner
+  def self.redisconfdir
+    File.expand_path(File.dirname(__FILE__) + "/../spec/config/slave.conf")
+  end
+
+  def self.dtach_socket
+    "/tmp/redis_slave.dtach"
+  end
+
+  def self.port
+    6381
+  end
+end
+
+class RedisClusterRunner
+  def self.runners
+    [ SingleRedisRunner, MasterRedisRunner, SlaveRedisRunner ]
+  end
+
+  def self.start_detached
+    runners.each do |runner|
+      runner.start_detached
+    end
+  end
+
+  def self.stop
+    runners.each do |runner|
+      runner.stop
+    end
+  end
+end
+
+namespace :redis do
+  desc 'About redis'
+  task :about do
+    puts "\nSee http://code.google.com/p/redis/ for information about redis.\n\n"
+  end
+
+  desc 'Start redis'
+  task :start do
+    RedisRunner.start
+  end
+
+  desc 'Stop redis'
+  task :stop do
+    RedisRunner.stop
+  end
+
+  desc 'Restart redis'
+  task :restart do
+    RedisRunner.stop
+    RedisRunner.start
+  end
+
+  desc 'Attach to redis dtach socket'
+  task :attach do
+    RedisRunner.attach
+  end
+
+  desc 'Install the lastest verison of Redis from Github (requires git, duh)'
+  task :install => [ :about, :download, :make ] do
+    %w(redis-benchmark redis-cli redis-server).each do |bin|
+      if File.exist?(path = "#{RedisRunner.redisdir}/src/#{bin}")
+        sh "sudo cp #{path} /usr/bin/"
+      else
+        sh "sudo cp #{RedisRunner.redisdir}/#{bin} /usr/bin/"
+      end
+    end
+
+    puts "Installed redis-benchmark, redis-cli and redis-server to /usr/bin/"
+
+    sh "sudo cp #{RedisRunner.redisdir}/redis.conf /etc/"
+    puts "Installed redis.conf to /etc/ \n You should look at this file!"
+  end
+
+  task :make do
+    sh "cd #{RedisRunner.redisdir} && make clean"
+    sh "cd #{RedisRunner.redisdir} && make"
+  end
+
+  desc "Download package"
+  task :download do
+    require 'git'
+
+    sh "rm -rf #{RedisRunner.redisdir} && mkdir -p vendor && rm -rf redis"
+    Git.clone("git://github.com/antirez/redis.git", "redis")
+    sh "mv redis vendor"
+
+    commit = case ENV['VERSION']
+      when "1.2.6" then "570e43c8285a4e5e3f31"
+    end
+
+    arguments = commit.nil? ? "pull origin master" : "reset --hard #{commit}"
+    sh "cd #{RedisRunner.redisdir} && git #{arguments}"
+  end
+
+  desc "Open an IRb session"
+  task :console do
+    RedisRunner.start_detached
+    system "bundle exec irb -I lib -I extra -r redis-store.rb"
+    RedisRunner.stop
+  end
+
+  namespace :cluster do
+    desc "Starts the redis_cluster"
+    task :start do
+      result = RedisClusterRunner.start_detached
+      raise("Could not start redis-server, aborting.") unless result
+    end
+
+    desc "Stops the redis_cluster"
+    task :stop do
+      RedisClusterRunner.stop
+    end
+  end  
+end
+
+namespace :dtach do
+  desc 'About dtach'
+  task :about do
+    puts "\nSee http://dtach.sourceforge.net/ for information about dtach.\n\n"
+  end
+
+  desc 'Install dtach 0.8 from source'
+  task :install => [:about] do
+
+    Dir.chdir('/tmp/')
+    unless File.exists?('/tmp/dtach-0.8.tar.gz')
+      require 'net/http'
+
+      url = 'http://downloads.sourceforge.net/project/dtach/dtach/0.8/dtach-0.8.tar.gz'
+      open('/tmp/dtach-0.8.tar.gz', 'wb') do |file| file.write(open(url).read) end
+    end
+
+    unless File.directory?('/tmp/dtach-0.8')
+      system('tar xzf dtach-0.8.tar.gz')
+    end
+
+    Dir.chdir('/tmp/dtach-0.8/')
+    sh 'cd /tmp/dtach-0.8/ && ./configure && make'
+    sh 'sudo cp /tmp/dtach-0.8/dtach /usr/bin/'
+
+    puts 'Dtach successfully installed to /usr/bin.'
+  end
+end
+
+def invoke_with_redis_cluster(task_name)
+  begin
+    Rake::Task["redis:cluster:start"].invoke
+    Rake::Task[task_name].invoke
+  ensure
+    Rake::Task["redis:cluster:stop"].invoke
+  end
+end