honkster-redis-store 0.3.10

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,14 @@
+gem "redis", "1.0.5"
+
+# testing gems
+group :testing do
+  gem "ruby-debug"
+  gem "rspec"
+  gem "rack", "1.1.0"
+  gem "rack-cache"
+  gem "activesupport"
+  gem "actionpack"
+  gem "merb"
+  gem "jeweler"
+  gem "git"
+end

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 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,105 @@
+# Rack::Session, Rack::Cache 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/)
+
+    curl -OL http://redis.googlecode.com/files/redis-1.02.tar.gz
+    tar -zxvf redis-1.02.tar.gz
+    mv redis-1.02 redis
+    cd redis
+    make
+
+Install the gems
+
+    sudo gem install redis-rb redis-store
+
+## Cache store
+
+Provides a cache store for your Ruby web framework of choice.
+
+### Rails
+
+    config.gem "redis-store", :source => "http://gemcutter.org", :lib => "redis-store"
+    require "redis-store"
+    config.cache_store = :redis_store
+
+### Merb
+
+    dependency "redis-store", "0.3.7"
+    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
+
+    config.gem "redis-store", :source => "http://gemcutter.org", :lib => "redis-store"
+    ActionController::Base.session_store = Rack::Session::Redis
+
+### Merb
+
+    dependency "redis-store", "0.3.7"
+    Merb::Config.use do |c|
+      c[:session_store] = "redis"
+    end
+    Merb::BootLoader.before_app_loads do
+      Merb::SessionContainer.subclasses << "Merb::RedisSession"
+    end
+
+### Sinatra
+
+Sorry, but Sinatra application boot system [hardcode](http://github.com/sinatra/sinatra/blob/0f02bafe86f8dd9bba9ab425468cb1067caa83ff/lib/sinatra/base.rb#L785) `Rack::Session::Cookie`
+
+## 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
+
+## Running specs
+
+    gem install jeweler bundler
+    git clone git://github.com/jodosha/redis-store.git
+    cd redis-store
+    gem bundle
+    rake dtach:install
+    rake redis:install
+    rake
+
+If you are on **Snow Leopard** you have to run `env ARCHFLAGS="-arch x86_64" gem bundle`
+
+## Copyright
+
+(c) 2009 Luca Guidi - [http://lucaguidi.com](http://lucaguidi.com), released under the MIT license

data/Rakefile

@@ -0,0 +1,70 @@
+$:.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     = "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" ]
+  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 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 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
+
+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
+    Rake::Task["redis_cluster:start"].invoke
+    Rake::Task[task_name].invoke
+  ensure
+    Rake::Task["redis_cluster:stop"].invoke
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+0.3.10

data/lib/cache/merb/redis_store.rb

@@ -0,0 +1,63 @@
+module Merb
+  module Cache
+    class RedisStore < AbstractStore
+      # Instantiate the store.
+      #
+      # Example:
+      #   RedisStore.new                                     # => host: localhost,   port: 6379,  db: 0
+      #   RedisStore.new :servers => ["example.com"]         # => host: example.com, port: 6379,  db: 0
+      #   RedisStore.new :servers => ["example.com:23682"]   # => host: example.com, port: 23682, db: 0
+      #   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]
+      end
+
+      def writable?(key, parameters = {}, conditions = {})
+        true
+      end
+
+      def read(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] ? :marshalled_setnx : :marshalled_set
+          @data.send method, normalize(key, parameters), data, conditions
+        end
+      end
+
+      def write_all(key, data = nil, parameters = {}, conditions = {})
+        write key, data, parameters, conditions
+      end
+
+      def fetch(key, parameters = {}, conditions = {}, &blk)
+        read(key, parameters) || (write key, yield, parameters, conditions if block_given?)
+      end
+
+      def exists?(key, parameters = {})
+        @data.exists normalize(key, parameters)
+      end
+
+      def delete(key, parameters = {})
+        @data.del normalize(key, parameters)
+      end
+
+      def delete_all
+        @data.flushdb
+      end
+
+      def delete_all!
+        delete_all
+      end
+
+      private
+        # Returns cache key calculated from base key
+        # and SHA2 hex from parameters.
+        def normalize(key, parameters = {})
+          parameters.empty? ? "#{key}" : "#{key}--#{parameters.to_sha2}"
+        end
+    end
+  end
+end

data/lib/cache/rails/redis_session_store.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(RedisFactory.convert_to_redis_client_options(server_options))
+        end
+
+        @pool = RedisFactory.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/cache/rails/redis_store.rb

@@ -0,0 +1,109 @@
+module ActiveSupport
+  module Cache
+    class RedisStore < Store
+      # 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 "localhost:6379/0", "localhost:6380/0" # => instantiate a cluster
+      def initialize(*addresses)
+        @data = RedisFactory.create(addresses)
+      end
+
+      def write(key, value, options = nil)
+        super
+        method = options && options[:unless_exist] ? :marshalled_setnx : :marshalled_set
+        @data.send method, key, value, options
+      end
+
+      def read(key, options = nil)
+        super
+        @data.marshalled_get key, options
+      end
+
+      def delete(key, options = nil)
+        super
+        @data.del key
+      end
+
+      def exist?(key, options = nil)
+        super
+        @data.exists key
+      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)
+        log "increment", key, amount
+        @data.incrby key, amount
+      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)
+        log "decrement", key, amount
+        @data.decrby key, amount
+      end
+
+      # Delete objects for matched keys.
+      #
+      # Example:
+      #   cache.del_matched "rab*"
+      def delete_matched(matcher, options = nil)
+        super
+        @data.keys(matcher).each { |key| @data.del key }
+      end
+
+      # Clear all the data from the store.
+      def clear
+        log "clear", nil, nil
+        @data.flushdb
+      end
+
+      def stats
+        @data.info
+      end
+    end
+  end
+end

data/lib/cache/sinatra/redis_store.rb

@@ -0,0 +1,118 @@
+module Sinatra
+  module Cache
+    class << self
+      def register(app)
+        app.set :cache, RedisStore.new
+      end
+    end
+
+    class RedisStore
+      # 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 "localhost:6379/0", "localhost:6380/0" # => instantiate a cluster
+      def initialize(*addresses)
+        @data = RedisFactory.create addresses
+      end
+
+      def write(key, value, options = nil)
+        if options
+          if options[:unless_exist]
+            @data.marshalled_setnx key, value, options
+          else
+            @data.marshalled_set key, value, options
+          end
+        else
+          @data.marshalled_set key, value
+        end
+      end
+
+      def read(key, options = nil)
+        @data.marshalled_get(key, options)
+      end
+
+      def delete(key, options = nil)
+        @data.del key
+      end
+
+      def exist?(key, options = nil)
+        @data.exists key
+      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)
+        @data.incrby key, amount
+      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)
+        @data.decrby key, amount
+      end
+
+      # Delete objects for matched keys.
+      #
+      # Example:
+      #   cache.del_matched "rab*"
+      def delete_matched(matcher, options = nil)
+        @data.keys(matcher).each { |key| @data.del key }
+      end
+
+      def fetch(key, options = {})
+        (!options[:force] && data = read(key, options)) || (write key, yield, options if block_given?)
+      end
+
+      # Clear all the data from the store.
+      def clear
+        @data.flushdb
+      end
+
+      def stats
+        @data.info
+      end
+    end
+  end
+end

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.exists 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.del 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.marshalled_get(key) || []
+        end
+
+        def write(key, entries)
+          key = hexdigest(key)
+          cache.marshalled_set(key, entries)
+        end
+
+        def purge(key)
+          cache.del(hexdigest(key))
+          nil
+        end
+      end
+
+      REDIS = Redis
+    end
+  end
+end