nono-redis-store 1.0.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 - 2010 Luca Guidi
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,191 @@
+# Namespaced Rack::Session, Rack::Cache, I18n and cache Redis stores for Ruby web frameworks
+
+## Installation
+
+Download and install Redis from [http://code.google.com/p/redis/](http://code.google.com/p/redis/)
+
+    wget http://redis.googlecode.com/files/redis-2.0.0.tar.gz
+    tar -zxf redis-2.0.0.tar.gz
+    mv redis-2.0.0 redis
+    cd redis
+    make
+
+Install the gem
+
+    sudo gem install redis-store
+
+## Options
+There are two ways to configure the Redis server options: by an URI string and by an hash.
+By default each store try to connect on `localhost` with the port `6379` and the db `0`.
+
+### String
+
+    "redis://:secret@192.168.1.100:23682/13/theplaylist"
+
+    host: 192.168.1.100
+    port: 23682
+    db: 13
+    namespace: theplaylist
+    password: secret
+
+If you want to specify the `namespace` optional, you have to pass the `db` param too.
+#### __Important__: for now (beta3) `namespace` is only supported for single, non-distributed stores.
+
+### Hash
+
+    { :host => 192.168.1.100, :port => 23682, :db => 13, :namespace => "theplaylist", :password => "secret" }
+
+#### __Important__: for now (beta3) `namespace` is only supported for single, non-distributed stores.
+
+## Cache store
+
+Provides a cache store for your Ruby web framework of choice.
+
+### Rails 2.x
+
+    config.gem "redis-store"
+    config.cache_store = :redis_store
+
+### Rails 2.x (with Bundler)
+
+    # Gemfile
+    gem "redis-store"
+
+    # in your configuration
+    config.gem "redis-store"
+    config.cache_store = :redis_store
+
+### Rails 3.x
+
+    # Gemfile
+    gem 'rails', '3.0.0'
+    gem 'redis'
+    gem 'redis-store', '1.0.0.beta3'
+
+    # config/environments/production.rb
+    config.cache_store = :redis_store
+
+For advanced configurations scenarios please visit [the wiki](http://wiki.github.com/jodosha/redis-store/rails).
+
+### Merb
+
+    dependency "redis-store", "1.0.0.beta3"
+    dependency("merb-cache", merb_gems_version) do
+      Merb::Cache.setup do
+        register(:redis, Merb::Cache::RedisStore, :servers => ["127.0.0.1:6379"])
+      end
+    end
+
+### Sinatra
+
+    require "sinatra"
+    require "redis-store"
+    class MyApp < Sinatra::Base
+      register Sinatra::Cache
+      get "/hi" do
+        cache.fetch("greet") { "Hello, World!" }
+      end
+    end
+
+## Rack::Session
+
+Provides a Redis store for Rack::Session. See [http://rack.rubyforge.org/doc/Rack/Session.html](http://rack.rubyforge.org/doc/Rack/Session.html)
+
+### Rack application
+
+    require "rack"
+    require "redis-store"
+    require "application"
+    use Rack::Session::Redis
+    run Application.new
+
+### Rails 2.x
+
+    config.gem "redis-store"
+    ActionController::Base.session_store = :redis_session_store
+
+### Rails 2.x (with Bundler)
+
+    # Gemfile
+    gem "redis-store"
+
+    # in your configuration
+    config.gem "redis-store"
+
+    # config/initializers/session_store.rb
+    ActionController::Base.session_store = :redis_session_store
+
+### Rails 3.x
+
+    # Gemfile
+    gem 'rails', '3.0.0'
+    gem 'redis'
+    gem 'redis-store', '1.0.0.beta3'
+
+    # config/initializers/session_store.rb
+    MyApp::Application.config.session_store :redis_session_store
+
+For advanced configurations scenarios please visit [the wiki](http://wiki.github.com/jodosha/redis-store/rails).
+
+### Merb
+
+    dependency "redis-store", "1.0.0.beta3"
+    Merb::Config.use do |c|
+      c[:session_store] = "redis"
+    end
+    Merb::BootLoader.before_app_loads do
+      Merb::SessionContainer.subclasses << "Merb::RedisSession"
+    end
+
+### Sinatra
+
+    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
+
+Provides a Redis store for HTTP caching. See [http://github.com/rtomayko/rack-cache](http://github.com/rtomayko/rack-cache)
+
+    require "rack"
+    require "rack/cache"
+    require "redis-store"
+    require "application"
+    use Rack::Cache,
+      :metastore   => 'redis://localhost:6379/0',
+      :entitystore => 'redis://localhost:6380/1'
+    run Application.new
+
+## I18n
+
+    require "i18n"
+    require "redis-store"
+    I18n.backend = I18n::Backend::Redis.new
+
+The backend accepts the uri string and hash options.
+
+## Running specs
+
+    gem install jeweler bundler
+    git clone git://github.com/jodosha/redis-store.git
+    cd redis-store
+    bundle install
+    REDIS_STORE_ENV=rails3 bundle install # to install Rails 3 gems
+    rake dtach:install
+    rake redis:install
+    rake
+    REDIS_STORE_ENV=rails3 rake # to test against Rails 3
+
+If you are on **Snow Leopard** you have to run `env ARCHFLAGS="-arch x86_64" bundle install`
+
+## Copyright
+
+(c) 2009 - 2010 Luca Guidi - [http://lucaguidi.com](http://lucaguidi.com), released under the MIT license

data/Rakefile

@@ -0,0 +1,60 @@
+$:.unshift 'lib'
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+
+task :default => "spec:suite"
+
+begin
+  require "jeweler"
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name        = "#{ENV["GEM_PREFIX"]}redis-store"
+    gemspec.summary     = "Namespaced Rack::Session, Rack::Cache, I18n and cache Redis stores for Ruby web frameworks."
+    gemspec.description = "Namespaced Rack::Session, Rack::Cache, I18n 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 = [ ]
+    gemspec.add_dependency "redis", ">= 2.0.0"
+  end
+
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
+end
+
+namespace :spec do
+  desc "Run all the examples by starting a detached Redis instance"
+  task :suite => :prepare do
+    invoke_with_redis_cluster "spec:run"
+  end
+
+  Spec::Rake::SpecTask.new(:run) do |t|
+    t.spec_files = FileList['spec/**/*_spec.rb']
+    t.spec_opts = %w(-fs --color)
+  end
+end
+
+desc "Run all examples with RCov"
+task :rcov => :prepare do
+  invoke_with_redis_cluster "rcov_run"
+end
+
+Spec::Rake::SpecTask.new(:rcov_run) do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.rcov = true
+end
+
+task :prepare do
+  `mkdir -p tmp && rm tmp/*.rdb`
+end
+
+namespace :bundle do
+  task :clean do
+    system "rm -rf ~/.bundle/ ~/.gem/ .bundle/ Gemfile.lock"
+  end
+end
+
+load "tasks/redis.tasks.rb"

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/action_controller/session/redis_session_store.rb

@@ -0,0 +1,74 @@
+require "redis-store"
+
+module RedisStore
+  module Rack
+    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
+      module Rails
+        def initialize(app, options = {})
+          # Support old :expires option
+          options[:expire_after] ||= options[:expires]
+
+          super
+
+          servers = [options[:servers]].flatten.compact.map do |server_options|
+            {
+              :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 get_session(env, sid)
+            sid ||= generate_sid
+            begin
+              session = @pool.get(sid) || {}
+            rescue Errno::ECONNREFUSED
+              session = {}
+            end
+            [sid, session]
+          end
+
+          def set_session(env, sid, session_data)
+            options = env['rack.session.options']
+            @pool.set(sid, session_data, options)
+            return(::Redis::Store.rails3? ? sid : true)
+          rescue Errno::ECONNREFUSED
+            return false
+          end
+
+          def destroy(env)
+            if sid = current_session_id(env)
+              @pool.del(sid)
+            end
+          rescue Errno::ECONNREFUSED
+            false
+          end
+      end
+    end
+  end
+end
+
+if ::Redis::Store.rails3?
+  class ActionDispatch::Session::RedisSessionStore < ActionDispatch::Session::AbstractStore
+    include RedisStore::Rack::Session::Rails
+  end
+else
+  class ActionController::Session::RedisSessionStore < ActionController::Session::AbstractStore
+    include RedisStore::Rack::Session::Rails
+  end
+end

data/lib/active_support/cache/redis_store.rb

@@ -0,0 +1,228 @@
+require "redis-store"
+
+module RedisStore
+  module Cache
+    module Rails2
+      # Instantiate the store.
+      #
+      # Example:
+      #   RedisStore.new
+      #     # => host: localhost,   port: 6379,  db: 0
+      #
+      #   RedisStore.new "example.com"
+      #     # => host: example.com, port: 6379,  db: 0
+      #
+      #   RedisStore.new "example.com:23682"
+      #     # => host: example.com, port: 23682, db: 0
+      #
+      #   RedisStore.new "example.com:23682/1"
+      #     # => host: example.com, port: 23682, db: 1
+      #
+      #   RedisStore.new "example.com:23682/1/theplaylist"
+      #     # => host: example.com, port: 23682, db: 1, namespace: theplaylist
+      #
+      #   RedisStore.new "localhost:6379/0", "localhost:6380/0"
+      #     # => instantiate a cluster
+      def initialize(*addresses)
+        @data = ::Redis::Factory.create(addresses)
+      end
+
+      def write(key, value, options = nil)
+        super
+        method = options && options[:unless_exist] ? :setnx : :set
+        @data.send method, key, value, options
+      end
+
+      def read(key, options = nil)
+        super
+        @data.get key, options
+      end
+
+      def delete(key, options = nil)
+        super
+        @data.del key
+      end
+
+      def exist?(key, options = nil)
+        super
+        @data.exists key
+      end
+
+      # Delete objects for matched keys.
+      #
+      # Example:
+      #   cache.del_matched "rab*"
+      def delete_matched(matcher, options = nil)
+        instrument(:delete_matched, matcher, options) do
+          @data.keys(matcher).each { |key| @data.del key }
+        end
+      end
+
+      private
+        def instrument(operation, key, options = nil)
+          log(operation.to_s, key, options)
+          yield
+        end
+    end
+
+    module Rails3
+      # Instantiate the store.
+      #
+      # Example:
+      #   RedisStore.new
+      #     # => host: localhost,   port: 6379,  db: 0
+      #
+      #   RedisStore.new "example.com"
+      #     # => host: example.com, port: 6379,  db: 0
+      #
+      #   RedisStore.new "example.com:23682"
+      #     # => host: example.com, port: 23682, db: 0
+      #
+      #   RedisStore.new "example.com:23682/1"
+      #     # => host: example.com, port: 23682, db: 1
+      #
+      #   RedisStore.new "example.com:23682/1/theplaylist"
+      #     # => host: example.com, port: 23682, db: 1, namespace: theplaylist
+      #
+      #   RedisStore.new "localhost:6379/0", "localhost:6380/0"
+      #     # => instantiate a cluster
+      def initialize(*addresses)
+        @data = ::Redis::Factory.create(addresses)
+        super(addresses.extract_options!)
+      end
+
+      # Delete objects for matched keys.
+      #
+      # Example:
+      #   cache.del_matched "rab*"
+      def delete_matched(matcher, options = nil)
+        options = merged_options(options)
+        instrument(:delete_matched, matcher.inspect) do
+          matcher = key_matcher(matcher, options)
+          @data.keys(matcher).each { |key| delete_entry(key, options) }
+        end
+      end
+
+      protected
+        def write_entry(key, entry, options)
+          method = options && options[:unless_exist] ? :setnx : :set
+          entry = entry.value.to_s if entry.is_a? ActiveSupport::Cache::Entry
+          @data.send method, key, entry, options
+        end
+
+        def read_entry(key, options)
+          raw_value = @data.get key, options
+          if raw_value
+            entry = Marshal.load(raw_value) rescue raw_value
+            entry.is_a?(ActiveSupport::Cache::Entry) ? entry : ActiveSupport::Cache::Entry.new(entry)
+          else
+            nil
+          end
+        end
+
+        def delete_entry(key, options)
+          key.include?("*") ? delete_matched(key, options) : @data.del(key)
+        end
+
+        # Add the namespace defined in the options to a pattern designed to match keys.
+        #
+        # This implementation is __different__ than ActiveSupport:
+        # __it doesn't accept Regular expressions__, because the Redis matcher is designed
+        # only for strings with wildcards.
+        def key_matcher(pattern, options)
+          prefix = options[:namespace].is_a?(Proc) ? options[:namespace].call : options[:namespace]
+          if prefix
+            raise "Regexps aren't supported, please use string with wildcards." if pattern.is_a?(Regexp)
+            "#{prefix}:#{pattern}"
+          else
+            pattern
+          end
+        end
+    end
+
+    Store = ::Redis::Store.rails3? ? Rails3 : Rails2
+  end
+end
+
+module ActiveSupport
+  module Cache
+    class RedisStore < Store
+      include ::RedisStore::Cache::Store
+
+      # Reads multiple keys from the cache using a single call to the
+      # servers for all keys. Options can be passed in the last argument.
+      #
+      # Example:
+      #   cache.read_multi "rabbit", "white-rabbit"
+      #   cache.read_multi "rabbit", "white-rabbit", :raw => true
+      def read_multi(*names)
+        @data.mget *names
+      end
+
+      # Increment a key in the store.
+      #
+      # If the key doesn't exist it will be initialized on 0.
+      # If the key exist but it isn't a Fixnum it will be initialized on 0.
+      #
+      # Example:
+      #   We have two objects in cache:
+      #     counter # => 23
+      #     rabbit  # => #<Rabbit:0x5eee6c>
+      #
+      #   cache.increment "counter"
+      #   cache.read "counter", :raw => true      # => "24"
+      #
+      #   cache.increment "counter", 6
+      #   cache.read "counter", :raw => true      # => "30"
+      #
+      #   cache.increment "a counter"
+      #   cache.read "a counter", :raw => true    # => "1"
+      #
+      #   cache.increment "rabbit"
+      #   cache.read "rabbit", :raw => true       # => "1"
+      def increment(key, amount = 1)
+        instrument(:increment, key, :amount => amount) do
+          @data.incrby key, amount
+        end
+      end
+
+      # Decrement a key in the store
+      #
+      # If the key doesn't exist it will be initialized on 0.
+      # If the key exist but it isn't a Fixnum it will be initialized on 0.
+      #
+      # Example:
+      #   We have two objects in cache:
+      #     counter # => 23
+      #     rabbit  # => #<Rabbit:0x5eee6c>
+      #
+      #   cache.decrement "counter"
+      #   cache.read "counter", :raw => true      # => "22"
+      #
+      #   cache.decrement "counter", 2
+      #   cache.read "counter", :raw => true      # => "20"
+      #
+      #   cache.decrement "a counter"
+      #   cache.read "a counter", :raw => true    # => "-1"
+      #
+      #   cache.decrement "rabbit"
+      #   cache.read "rabbit", :raw => true       # => "-1"
+      def decrement(key, amount = 1)
+        instrument(:decrement, key, :amount => amount) do
+          @data.decrby key, amount
+        end
+      end
+
+      # Clear all the data from the store.
+      def clear
+        instrument(:clear, nil, nil) do
+          @data.flushdb
+        end
+      end
+
+      def stats
+        @data.info
+      end
+    end
+  end
+end