redis-store 1.0.0.beta2 → 1.0.0.beta3

data/lib/rack/session/redis.rb

@@ -2,7 +2,7 @@ module Rack
   module Session
     class Redis < Abstract::ID
       attr_reader :mutex, :pool
-      DEFAULT_OPTIONS = Abstract::ID::DEFAULT_OPTIONS.merge :redis_server => "localhost:6379"
+      DEFAULT_OPTIONS = Abstract::ID::DEFAULT_OPTIONS.merge :redis_server => "redis://127.0.0.1:6379/0"
 
       def initialize(app, options = {})
         super
@@ -13,18 +13,18 @@ module Rack
       def generate_sid
         loop do
           sid = super
-          break sid unless @pool.marshalled_get(sid)
+          break sid unless @pool.get(sid)
         end
       end
 
       def get_session(env, sid)
-        session = @pool.marshalled_get(sid) if sid
+        session = @pool.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.marshalled_set sid, session
+          ret = @pool.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.marshalled_get(session_id) rescue {}
+        session = @pool.get(session_id) rescue {}
         if options[:renew] or options[:drop]
           @pool.del session_id
           return false if options[:drop]
           session_id = generate_sid
-          @pool.marshalled_set session_id, 0
+          @pool.set session_id, 0
         end
         old_session = new_session.instance_variable_get('@old') || {}
         session = merge_sessions session_id, old_session, new_session, session
-        @pool.marshalled_set session_id, session, options
+        @pool.set session_id, session, options
         return session_id
       rescue Errno::ECONNREFUSED
         warn "#{self} is unable to find server."

data/lib/redis-store.rb

@@ -1,15 +1,13 @@
 require "redis"
 require "redis/distributed"
 require "redis/factory"
-require "redis/marshaled_client"
-require "redis/distributed_marshaled"
-require "redis_store/version"
-
-module ::RedisStore
-  def self.rails3? #:nodoc:
-    defined?(::Rails) && ::Rails.version =~ /3\.0\.0/
-  end
-end
+require "redis/store/interface"
+require "redis/store/ttl"
+require "redis/store/namespace"
+require "redis/store/marshalling"
+require "redis/store/version"
+require "redis/store"
+require "redis/distributed_store"
 
 # Cache store
 if defined?(Sinatra)
@@ -18,8 +16,6 @@ elsif defined?(Merb)
   # HACK for cyclic dependency: redis-store is required before merb-cache
   module Merb; module Cache; class AbstractStore; end end end
   require "cache/merb/redis_store"
-elsif defined?(Rails)
-  require "cache/rails/redis_store"
 end
 
 # Rack::Session
@@ -29,9 +25,11 @@ if defined?(Rack::Session)
   if defined?(Merb)
     require "rack/session/merb"
   end
-  if defined?(Rails)
-    require "rack/session/rails"
-  end
+end
+
+# ActionDispatch::Session
+if ::Redis::Store.rails3?
+  require "action_controller/session/redis_session_store"
 end
 
 # Rack::Cache
@@ -40,3 +38,7 @@ if defined?(Rack::Cache)
   require "rack/cache/redis_metastore"
   require "rack/cache/redis_entitystore"
 end
+
+if defined?(I18n)
+  require "i18n/backend/redis"
+end

data/lib/redis/distributed_store.rb

@@ -0,0 +1,35 @@
+class Redis
+  class DistributedStore < Distributed
+    attr_reader :ring
+
+    def initialize(addresses, options = { })
+      nodes = addresses.map do |address|
+        ::Redis::Store.new address
+      end
+      _extend_namespace options
+      @ring = Redis::HashRing.new nodes
+    end
+
+    def nodes
+      ring.nodes
+    end
+
+    def set(key, value, options = nil)
+      node_for(key).set(key, value, options)
+    end
+
+    def get(key, options = nil)
+      node_for(key).get(key, options)
+    end
+
+    def setnx(key, value, options = nil)
+      node_for(key).setnx(key, value, options)
+    end
+
+    private
+      def _extend_namespace(options)
+        @namespace = options[:namespace]
+        extend ::Redis::Store::Namespace if @namespace
+      end
+  end
+end

data/lib/redis/factory.rb

@@ -6,21 +6,40 @@ class Redis
         result
       end
       if redis_client_options.size > 1
-        DistributedMarshaled.new redis_client_options
+        ::Redis::DistributedStore.new redis_client_options
       else
-        MarshaledClient.new redis_client_options.first || {}
+        ::Redis::Store.new redis_client_options.first || {}
       end
     end
 
     def self.convert_to_redis_client_options(address_or_options)
-      return address_or_options if address_or_options.is_a?(Hash)
-      host, port = address_or_options.split /\:/
-      port, db   = port.split /\// if port
-      options = {}
-      options[:host] = host if host
-      options[:port] = port if port
-      options[:db]  = db.to_i if db
-      options
+      if address_or_options.is_a?(Hash)
+        options = address_or_options.dup
+        options[:namespace] ||= options.delete(:key_prefix) # RailsSessionStore
+        options
+      else
+        if address_or_options =~ /redis\:\/\//
+          require 'uri'
+          uri = URI.parse address_or_options
+          _, db, namespace = if uri.path
+            uri.path.split /\//
+          end
+        else
+          warn "[DEPRECATION] `#{address_or_options}` is deprecated. Please use `redis://#{address_or_options}` instead."
+          address_or_options, password = address_or_options.split(/\@/).reverse
+          password = password.gsub(/\:/, "") if password
+          host, port = address_or_options.split /\:/
+          port, db, namespace = port.split /\// if port
+        end
+
+        options = {}
+        options[:host] = host || uri.host
+        options[:port] = port || uri.port
+        options[:db]  = db.to_i if db
+        options[:namespace] = namespace if namespace
+        options[:password]  = password || uri.password
+        options
+      end
     end
   end
 end

data/lib/redis/store.rb

@@ -0,0 +1,30 @@
+class Redis
+  class Store < self
+    include Ttl, Interface
+
+    def initialize(options = { })
+      super
+      _extend_marshalling options
+      _extend_namespace   options
+    end
+
+    def self.rails3? #:nodoc:
+      defined?(::Rails) && ::Rails.version =~ /3\.0\.0/
+    end
+
+    def to_s
+      "Redis Client connected to #{@client.host}:#{@client.port} against DB #{@client.db}"
+    end
+
+    private
+      def _extend_marshalling(options)
+        @marshalling = !(options[:marshalling] === false) # HACK - TODO delegate to Factory
+        extend Marshalling if @marshalling
+      end
+
+      def _extend_namespace(options)
+        @namespace = options[:namespace]
+        extend Namespace if @namespace
+      end
+  end
+end

data/lib/redis/store/interface.rb

@@ -0,0 +1,17 @@
+class Redis
+  class Store < self
+    module Interface
+      def get(key, options = nil)
+        super(key)
+      end
+
+      def set(key, value, options = nil)
+        super(key, value)
+      end
+
+      def setnx(key, value, options = nil)
+        super(key, value)
+      end
+    end
+  end
+end

data/lib/redis/store/marshalling.rb

@@ -0,0 +1,41 @@
+class Redis
+  class Store < self
+    module Marshalling
+      def set(key, value, options = nil)
+        _marshal(value, options) { |value| super key, value, options }
+      end
+
+      def setnx(key, value, options = nil)
+        _marshal(value, options) { |value| super key, value, options }
+      end
+
+      def get(key, options = nil)
+        _unmarshal super(key), options
+      end
+
+      def mget(*keys)
+        options = keys.flatten.pop if keys.flatten.last.is_a?(Hash)
+        super(*keys).map do |result|
+          _unmarshal result, options
+        end
+      end
+
+      private
+        def _marshal(val, options)
+          yield marshal?(options) ? val : Marshal.dump(val)
+        end
+
+        def _unmarshal(val, options)
+          unmarshal?(val, options) ? Marshal.load(val) : val
+        end
+
+        def marshal?(options)
+          options && options[:raw]
+        end
+
+        def unmarshal?(result, options)
+          result && result.size > 0 && !marshal?(options)
+        end
+    end
+  end
+end

data/lib/redis/store/namespace.rb

@@ -0,0 +1,54 @@
+class Redis
+  class Store < self
+    module Namespace
+      def set(key, val, options = nil)
+        namespace(key) { |key| super(key, val, options) }
+      end
+
+      def setnx(key, val, options = nil)
+        namespace(key) { |key| super(key, val, options) }
+      end
+
+      def get(key, options = nil)
+        namespace(key) { |key| super(key, options) }
+      end
+
+      def exists(key)
+        namespace(key) { |key| super(key) }
+      end
+
+      def incrby(key, increment)
+        namespace(key) { |key| super(key, increment) }
+      end
+
+      def decrby(key, increment)
+        namespace(key) { |key| super(key, increment) }
+      end
+
+      def keys(pattern = "*")
+        namespace(pattern) { |pattern| super(pattern) }
+      end
+
+      def del(*keys)
+        super *keys.map {|key| interpolate(key) }
+      end
+
+      def mget(*keys)
+        super *keys.map {|key| interpolate(key) }
+      end
+
+      def to_s
+        "#{super} with namespace #{@namespace}"
+      end
+
+      private
+        def namespace(key)
+          yield interpolate(key)
+        end
+
+        def interpolate(key)
+          key.match(%r{^#{@namespace}\:}) ? key : "#{@namespace}:#{key}"
+        end
+    end
+  end
+end

data/lib/redis/store/ttl.rb

@@ -0,0 +1,37 @@
+class Redis
+  class Store < self
+    module Ttl
+      def set(key, value, options = nil)
+        if ttl = expires_in(options)
+          setex(key, ttl, value)
+        else
+          super(key, value)
+        end
+      end
+
+      def setnx(key, value, options = nil)
+        if ttl = expires_in(options)
+          setnx_with_expire(key, value, ttl)
+        else
+          super(key, value)
+        end
+      end
+
+      protected
+        def setnx_with_expire(key, value, ttl)
+          multi do
+            setnx(key, value)
+            expire(key, expires_in)
+          end
+        end
+
+      private
+        def expires_in(options)
+          if options
+            # Rack::Session           Merb                    Rails/Sinatra
+            options[:expire_after] || options[:expires_in] || options[:expire_in]
+          end
+        end
+    end
+  end
+end

data/lib/redis/store/version.rb

@@ -0,0 +1,12 @@
+class Redis
+  class Store < self
+    module VERSION #:nodoc:
+      MAJOR = 1
+      MINOR = 0
+      TINY  = 0
+      BUILD = "beta3"
+
+      STRING = [MAJOR, MINOR, TINY, BUILD].join('.')
+    end
+  end
+end

data/redis-store.gemspec

@@ -5,12 +5,12 @@
 
 Gem::Specification.new do |s|
   s.name = %q{redis-store}
-  s.version = "1.0.0.beta2"
+  s.version = "1.0.0.beta3"
 
   s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
   s.authors = ["Luca Guidi"]
-  s.date = %q{2010-06-12}
-  s.description = %q{Rack::Session, Rack::Cache and cache Redis stores for Ruby web frameworks.}
+  s.date = %q{2010-09-10}
+  s.description = %q{Namespaced Rack::Session, Rack::Cache, I18n and cache Redis stores for Ruby web frameworks.}
   s.email = %q{guidi.luca@gmail.com}
   s.extra_rdoc_files = [
     "README.md"
@@ -19,39 +19,48 @@ Gem::Specification.new do |s|
     ".gitignore",
      "CHANGELOG",
      "Gemfile",
+     "Gemfile.lock",
      "MIT-LICENSE",
      "README.md",
      "Rakefile",
      "VERSION",
+     "lib/action_controller/session/redis_session_store.rb",
+     "lib/active_support/cache/redis_store.rb",
      "lib/cache/merb/redis_store.rb",
-     "lib/cache/rails/redis_store.rb",
      "lib/cache/sinatra/redis_store.rb",
+     "lib/i18n/backend/redis.rb",
      "lib/rack/cache/redis_entitystore.rb",
      "lib/rack/cache/redis_metastore.rb",
      "lib/rack/session/merb.rb",
-     "lib/rack/session/rails.rb",
      "lib/rack/session/redis.rb",
      "lib/redis-store.rb",
-     "lib/redis/distributed_marshaled.rb",
+     "lib/redis/distributed_store.rb",
      "lib/redis/factory.rb",
-     "lib/redis/marshaled_client.rb",
-     "lib/redis_store/version.rb",
+     "lib/redis/store.rb",
+     "lib/redis/store/interface.rb",
+     "lib/redis/store/marshalling.rb",
+     "lib/redis/store/namespace.rb",
+     "lib/redis/store/ttl.rb",
+     "lib/redis/store/version.rb",
      "redis-store.gemspec",
+     "spec/action_controller/session/redis_session_store_spec.rb",
+     "spec/active_support/cache/redis_store_spec.rb",
      "spec/cache/merb/redis_store_spec.rb",
-     "spec/cache/rails/redis_store_spec.rb",
      "spec/cache/sinatra/redis_store_spec.rb",
      "spec/config/master.conf",
      "spec/config/single.conf",
      "spec/config/slave.conf",
+     "spec/i18n/backend/redis_spec.rb",
      "spec/rack/cache/entitystore/pony.jpg",
      "spec/rack/cache/entitystore/redis_spec.rb",
      "spec/rack/cache/metastore/redis_spec.rb",
-     "spec/rack/session/redis_session_store_spec.rb",
      "spec/rack/session/redis_spec.rb",
-     "spec/redis/distributed_marshaled_redis_spec.rb",
+     "spec/redis/distributed_store_spec.rb",
      "spec/redis/factory_spec.rb",
-     "spec/redis/marshaled_client_spec.rb",
-     "spec/redis_store/version_spec.rb",
+     "spec/redis/store/interface_spec.rb",
+     "spec/redis/store/marshalling_spec.rb",
+     "spec/redis/store/namespace_spec.rb",
+     "spec/redis/store/version_spec.rb",
      "spec/spec_helper.rb",
      "tasks/redis.tasks.rb"
   ]
@@ -59,19 +68,22 @@ Gem::Specification.new do |s|
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.rubygems_version = %q{1.3.7}
-  s.summary = %q{Rack::Session, Rack::Cache and cache Redis stores for Ruby web frameworks.}
+  s.summary = %q{Namespaced Rack::Session, Rack::Cache, I18n and cache Redis stores for Ruby web frameworks.}
   s.test_files = [
-    "spec/cache/merb/redis_store_spec.rb",
-     "spec/cache/rails/redis_store_spec.rb",
+    "spec/action_controller/session/redis_session_store_spec.rb",
+     "spec/active_support/cache/redis_store_spec.rb",
+     "spec/cache/merb/redis_store_spec.rb",
      "spec/cache/sinatra/redis_store_spec.rb",
+     "spec/i18n/backend/redis_spec.rb",
      "spec/rack/cache/entitystore/redis_spec.rb",
      "spec/rack/cache/metastore/redis_spec.rb",
-     "spec/rack/session/redis_session_store_spec.rb",
      "spec/rack/session/redis_spec.rb",
-     "spec/redis/distributed_marshaled_redis_spec.rb",
+     "spec/redis/distributed_store_spec.rb",
      "spec/redis/factory_spec.rb",
-     "spec/redis/marshaled_client_spec.rb",
-     "spec/redis_store/version_spec.rb",
+     "spec/redis/store/interface_spec.rb",
+     "spec/redis/store/marshalling_spec.rb",
+     "spec/redis/store/namespace_spec.rb",
+     "spec/redis/store/version_spec.rb",
      "spec/spec_helper.rb"
   ]