redis-store 0.3.7 → 0.3.8

data/.gitignore

@@ -1,7 +1,11 @@
 *.rdb
 *.swp
+*.gem
+*-redis-store.gemspec
 bin/
 coverage/
 pkg/
 vendor/
 tmp/
+.idea
+.bundle/

data/Gemfile

@@ -1,9 +1,15 @@
-# use ezmobius/redis-rb HEAD
-gem "redis-rb", "0.1", :git => "git://github.com/ezmobius/redis-rb.git"
+source :gemcutter
+gem "redis", "1.0.5"
 
 # testing gems
-gem "rspec",                :only => :testing
-gem "rack-cache",           :only => :testing
-gem "activesupport",        :only => :testing
-gem "merb",                 :only => :testing
-
+group :testing do
+  gem "ruby-debug"
+  gem "rspec"
+  gem "rack", "1.0.0"
+  gem "rack-cache"
+  gem "activesupport", "2.3.5"
+  gem "actionpack", "2.3.5"
+  gem "merb"
+  gem "jeweler"
+  gem "git"
+end

data/README.md

@@ -73,7 +73,17 @@ Provides a Redis store for Rack::Session. See [http://rack.rubyforge.org/doc/Rac
 
 ### Sinatra
 
-Sorry, but Sinatra application boot system [hardcode](http://github.com/sinatra/sinatra/blob/0f02bafe86f8dd9bba9ab425468cb1067caa83ff/lib/sinatra/base.rb#L785) `Rack::Session::Cookie`
+    require "sinatra"
+    require "redis-store"
+
+    class MyApp < Sinatra::Base
+      use Rack::Session::Redis
+
+      get "/" do
+        session[:visited_at] = DateTime.now.to_s # This is stored in Redis
+        "Hello, visitor."
+      end
+    end
 
 ## Rack::Cache
 

data/Rakefile

@@ -1,4 +1,5 @@
 $:.unshift 'lib'
+require 'rubygems'
 require 'rake'
 require 'rake/testtask'
 require 'rake/rdoctask'
@@ -9,17 +10,18 @@ task :default => "spec:suite"
 begin
   require "jeweler"
   Jeweler::Tasks.new do |gemspec|
-    gemspec.name        = "redis-store"
+    gemspec.name        = "#{ENV["GEM_PREFIX"]}redis-store"
     gemspec.summary     = "Rack::Session, Rack::Cache and cache Redis stores for Ruby web frameworks."
     gemspec.description = "Rack::Session, Rack::Cache and cache Redis stores for Ruby web frameworks."
     gemspec.email       = "guidi.luca@gmail.com"
     gemspec.homepage    = "http://github.com/jodosha/redis-store"
     gemspec.authors     = [ "Luca Guidi" ]
+    gemspec.executables = [ ]
   end
 
   Jeweler::GemcutterTasks.new
 rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install jeweler" 
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
 end
 
 namespace :spec do
@@ -44,14 +46,26 @@ Spec::Rake::SpecTask.new(:rcov_run) do |t|
   t.rcov = true
 end
 
+namespace :redis_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
+
 # courtesy of http://github.com/ezmobius/redis-rb team
 load "tasks/redis.tasks.rb"
 def invoke_with_redis_cluster(task_name)
   begin
-    result = RedisClusterRunner.start_detached
-    raise("Could not start redis-server, aborting.") unless result
+    Rake::Task["redis_cluster:start"].invoke
     Rake::Task[task_name].invoke
   ensure
-    RedisClusterRunner.stop
+    Rake::Task["redis_cluster:stop"].invoke
   end
 end

data/VERSION

@@ -1 +1 @@
-0.3.7
+0.3.8

data/lib/cache/merb/redis_store.rb

@@ -10,7 +10,7 @@ module Merb
       #   RedisStore.new :servers => ["example.com:23682/1"] # => host: example.com, port: 23682, db: 1
       #   RedisStore.new :servers => ["localhost:6379/0", "localhost:6380/0"] # => instantiate a cluster
       def initialize(config = {})
-        @data = RedisFactory.create config[:servers]
+        @data = Redis::Factory.create config[:servers]
       end
 
       def writable?(key, parameters = {}, conditions = {})
@@ -18,12 +18,12 @@ module Merb
       end
 
       def read(key, parameters = {}, conditions = {})
-        @data.get normalize(key, parameters), conditions
+        @data.marshalled_get normalize(key, parameters), conditions
       end
 
       def write(key, data = nil, parameters = {}, conditions = {})
         if writable?(key, parameters, conditions)
-          method = conditions && conditions[:unless_exist] ? :set_unless_exists : :set
+          method = conditions && conditions[:unless_exist] ? :marshalled_setnx : :marshalled_set
           @data.send method, normalize(key, parameters), data, conditions
         end
       end
@@ -37,15 +37,15 @@ module Merb
       end
 
       def exists?(key, parameters = {})
-        @data.key? normalize(key, parameters)
+        @data.exists normalize(key, parameters)
       end
 
       def delete(key, parameters = {})
-        @data.delete normalize(key, parameters)
+        @data.del normalize(key, parameters)
       end
 
       def delete_all
-        @data.flush_db
+        @data.flushdb
       end
 
       def delete_all!

data/lib/cache/rails/redis_store.rb

@@ -10,28 +10,28 @@ module ActiveSupport
       #   RedisStore.new "example.com:23682/1" # => host: example.com, port: 23682, db: 1
       #   RedisStore.new "localhost:6379/0", "localhost:6380/0" # => instantiate a cluster
       def initialize(*addresses)
-        @data = RedisFactory.create(addresses)
+        @data = Redis::Factory.create(addresses)
       end
 
       def write(key, value, options = nil)
         super
-        method = options && options[:unless_exist] ? :set_unless_exists : :set
+        method = options && options[:unless_exist] ? :marshalled_setnx : :marshalled_set
         @data.send method, key, value, options
       end
 
       def read(key, options = nil)
         super
-        @data.get key, options
+        @data.marshalled_get key, options
       end
 
       def delete(key, options = nil)
         super
-        @data.delete key
+        @data.del key
       end
 
       def exist?(key, options = nil)
         super
-        @data.key? key
+        @data.exists key
       end
 
       # Increment a key in the store.
@@ -57,7 +57,7 @@ module ActiveSupport
       #   cache.read "rabbit", :raw => true       # => "1"
       def increment(key, amount = 1)
         log "increment", key, amount
-        @data.incr key, amount
+        @data.incrby key, amount
       end
 
       # Decrement a key in the store
@@ -83,22 +83,22 @@ module ActiveSupport
       #   cache.read "rabbit", :raw => true       # => "-1"
       def decrement(key, amount = 1)
         log "decrement", key, amount
-        @data.decr key, amount
+        @data.decrby key, amount
       end
 
       # Delete objects for matched keys.
       #
       # Example:
-      #   cache.delete_matched "rab*"
+      #   cache.del_matched "rab*"
       def delete_matched(matcher, options = nil)
         super
-        @data.keys(matcher).each { |key| @data.delete key }
+        @data.keys(matcher).each { |key| @data.del key }
       end
 
       # Clear all the data from the store.
       def clear
         log "clear", nil, nil
-        @data.flush_db
+        @data.flushdb
       end
 
       def stats

data/lib/cache/sinatra/redis_store.rb

@@ -16,24 +16,27 @@ module Sinatra
       #   RedisStore.new "example.com:23682/1" # => host: example.com, port: 23682, db: 1
       #   RedisStore.new "localhost:6379/0", "localhost:6380/0" # => instantiate a cluster
       def initialize(*addresses)
-        @data = RedisFactory.create addresses
+        @data = Redis::Factory.create addresses
       end
 
       def write(key, value, options = nil)
-        method = options && options[:unless_exist] ? :set_unless_exists : :set
-        @data.send method, key, value, options
+        if options && options[:unless_exist]
+          @data.marshalled_setnx key, value, options
+        else
+          @data.marshalled_set key, value, options
+        end
       end
 
       def read(key, options = nil)
-        @data.get key, options
+        @data.marshalled_get(key, options)
       end
 
       def delete(key, options = nil)
-        @data.delete key
+        @data.del key
       end
 
       def exist?(key, options = nil)
-        @data.key? key
+        @data.exists key
       end
 
       # Increment a key in the store.
@@ -58,7 +61,7 @@ module Sinatra
       #   cache.increment "rabbit"
       #   cache.read "rabbit", :raw => true       # => "1"
       def increment(key, amount = 1)
-        @data.incr key, amount
+        @data.incrby key, amount
       end
 
       # Decrement a key in the store
@@ -83,15 +86,15 @@ module Sinatra
       #   cache.decrement "rabbit"
       #   cache.read "rabbit", :raw => true       # => "-1"
       def decrement(key, amount = 1)
-        @data.decr key, amount
+        @data.decrby key, amount
       end
 
       # Delete objects for matched keys.
       #
       # Example:
-      #   cache.delete_matched "rab*"
+      #   cache.del_matched "rab*"
       def delete_matched(matcher, options = nil)
-        @data.keys(matcher).each { |key| @data.delete key }
+        @data.keys(matcher).each { |key| @data.del key }
       end
 
       def fetch(key, options = {})
@@ -100,7 +103,7 @@ module Sinatra
 
       # Clear all the data from the store.
       def clear
-        @data.flush_db
+        @data.flushdb
       end
 
       def stats

data/lib/rack/cache/redis_entitystore.rb

@@ -26,7 +26,7 @@ module Rack
         end
 
         def exist?(key)
-          cache.key? key
+          cache.exists key
         end
 
         def read(key)
@@ -40,7 +40,7 @@ module Rack
         end
 
         def purge(key)
-          cache.delete key
+          cache.del key
           nil
         end
       end

data/lib/rack/cache/redis_metastore.rb

@@ -4,7 +4,7 @@ module Rack
       class RedisBase < MetaStore
         extend Rack::Utils
 
-        # The ::MarshaledRedis object used to communicate with the Redis daemon.
+        # The Redis::MarshaledClient object used to communicate with the Redis daemon.
         attr_reader :cache
 
         def self.resolve(uri)
@@ -17,21 +17,21 @@ module Rack
 
       class Redis < RedisBase
         def initialize(server, options = {})
-          @cache = ::MarshaledRedis.new server
+          @cache = ::Redis::MarshaledClient.new server
         end
 
         def read(key)
           key = hexdigest(key)
-          cache.get(key) || []
+          cache.marshalled_get(key) || []
         end
 
         def write(key, entries)
           key = hexdigest(key)
-          cache.set(key, entries)
+          cache.marshalled_set(key, entries)
         end
 
         def purge(key)
-          cache.delete(hexdigest(key))
+          cache.del(hexdigest(key))
           nil
         end
       end

data/lib/rack/session/rails.rb

@@ -0,0 +1,61 @@
+module ActionController
+  module Session
+# Redis session storage for Rails, and for Rails only. Derived from
+# the MemCacheStore code, simply dropping in Redis instead.
+#
+# Options:
+#  :key     => Same as with the other cookie stores, key name
+#  :secret  => Encryption secret for the key
+#  :host    => Redis host name, default is localhost
+#  :port    => Redis port, default is 6379
+#  :db      => Database number, defaults to 0. Useful to separate your session storage from other data
+#  :key_prefix  => Prefix for keys used in Redis, e.g. myapp-. Useful to separate session storage keys visibly from others
+#  :expire_after => A number in seconds to set the timeout interval for the session. Will map directly to expiry in Redis
+
+    class RedisSessionStore < ActionController::Session::AbstractStore
+
+      def initialize(app, options = {})
+        # Support old :expires option
+        options[:expire_after] ||= options[:expires]
+
+        super
+
+        @options = { :key_prefix => "" }.update(options)
+        servers = [options[:servers]].flatten.compact.map do |server_options|
+          {
+            :namespace => 'rack:session',
+            :host => 'localhost',
+            :port => '6379',
+            :db => 0
+          }.update(Redis::Factory.convert_to_redis_client_options(server_options))
+        end
+
+        @pool = Redis::Factory.create(*servers)
+      end
+
+      private
+      def prefixed(sid)
+        "#{@options[:key_prefix]}#{sid}"
+      end
+
+      def get_session(env, sid)
+        sid ||= generate_sid
+        begin
+          session = @pool.marshalled_get(prefixed(sid)) || {}
+        rescue Errno::ECONNREFUSED
+          session = {}
+        end
+        [sid, session]
+      end
+
+      def set_session(env, sid, session_data)
+        options = env['rack.session.options']
+        @pool.marshalled_set(prefixed(sid), session_data, options)
+        return true
+      rescue Errno::ECONNREFUSED
+        return false
+      end
+
+    end
+  end
+end

data/lib/rack/session/redis.rb

@@ -7,24 +7,24 @@ module Rack
       def initialize(app, options = {})
         super
         @mutex = Mutex.new
-        @pool = RedisFactory.create options[:redis_server] || @default_options[:redis_server]
+        @pool = ::Redis::Factory.create options[:redis_server] || @default_options[:redis_server]
       end
 
       def generate_sid
         loop do
           sid = super
-          break sid unless @pool.get(sid)
+          break sid unless @pool.marshalled_get(sid)
         end
       end
 
       def get_session(env, sid)
-        session = @pool.get(sid) if 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.set sid, session
+          ret = @pool.marshalled_set sid, session
           raise "Session collision on '#{sid.inspect}'" unless ret
         end
         session.instance_variable_set('@old', {}.merge(session))
@@ -39,16 +39,16 @@ module Rack
 
       def set_session(env, session_id, new_session, options)
         @mutex.lock if env['rack.multithread']
-        session = @pool.get(session_id) rescue {}
+        session = @pool.marshalled_get(session_id) rescue {}
         if options[:renew] or options[:drop]
-          @pool.delete session_id
+          @pool.del session_id
           return false if options[:drop]
           session_id = generate_sid
-          @pool.set session_id, 0
+          @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.set session_id, session, options
+        @pool.marshalled_set session_id, session, options
         return session_id
       rescue Errno::ECONNREFUSED
         warn "#{self} is unable to find server."
@@ -57,7 +57,7 @@ module Rack
       ensure
         @mutex.unlock if env['rack.multithread']
       end
-      
+
       private
         def merge_sessions(sid, old, new, cur=nil)
           cur ||= {}
@@ -68,7 +68,7 @@ module Rack
 
           delete = old.keys - new.keys
           warn "//@#{sid}: dropping #{delete*','}" if $DEBUG and not delete.empty?
-          delete.each{|k| cur.delete k }
+          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?