nono-redis-store 1.0.0

data/lib/cache/merb/redis_store.rb

@@ -0,0 +1,75 @@
+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 => ["example.com:23682/1/theplaylist"]
+      #     # => host: example.com, port: 23682, db: 1, namespace: theplaylist
+      #
+      #   RedisStore.new :servers => ["localhost:6379/0", "localhost:6380/0"]
+      #     # => instantiate a cluster
+      def initialize(config = { })
+        @data = Redis::Factory.create config[:servers]
+      end
+
+      def writable?(key, parameters = {}, conditions = {})
+        true
+      end
+
+      def read(key, parameters = {}, conditions = {})
+        @data.get normalize(key, parameters), conditions
+      end
+
+      def write(key, data = nil, parameters = {}, conditions = {})
+        if writable?(key, parameters, conditions)
+          method = conditions && conditions[:unless_exist] ? :setnx : :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/sinatra/redis_store.rb

@@ -0,0 +1,126 @@
+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 "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)
+        if options && options[:unless_exist]
+          @data.setnx key, value, options
+        else
+          @data.set key, value, options
+        end
+      end
+
+      def read(key, options = nil)
+        @data.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/i18n/backend/redis.rb

@@ -0,0 +1,67 @@
+module I18n
+  module Backend
+    class Redis
+      include Base, Flatten
+      attr_accessor :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 "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)
+        @store = ::Redis::Factory.create(addresses)
+      end
+
+      def translate(locale, key, options = {})
+        options[:resolve] ||= false
+        super locale, key, options
+      end
+
+      def store_translations(locale, data, options = {})
+        escape = options.fetch(:escape, true)
+        flatten_translations(locale, data, escape, false).each do |key, value|
+          case value
+          when Proc
+            raise "Key-value stores cannot handle procs"
+          else
+            @store.set "#{locale}.#{key}", value
+          end
+        end
+      end
+
+      def available_locales
+        locales = @store.keys.map { |k| k =~ /\./; $` }
+        locales.uniq!
+        locales.compact!
+        locales.map! { |k| k.to_sym }
+        locales
+      end
+
+      protected
+        def lookup(locale, key, scope = [], options = {})
+          key = normalize_flat_keys(locale, key, scope, options[:separator])
+          @store.get "#{locale}.#{key}"
+        end
+
+        def resolve_link(locale, key)
+          key
+        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 Redis::Store 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 = ::Redis::Factory.create server
+        end
+
+        def read(key)
+          key = hexdigest(key)
+          cache.get(key) || []
+        end
+
+        def write(key, entries)
+          key = hexdigest(key)
+          cache.set(key, entries)
+        end
+
+        def purge(key)
+          cache.del(hexdigest(key))
+          nil
+        end
+      end
+
+      REDIS = Redis
+    end
+  end
+end

data/lib/rack/session/merb.rb

@@ -0,0 +1,32 @@
+module Merb
+  # HACK for cyclic dependency: redis-store is required before Merb session stores
+  class Mash < Hash; end
+  class SessionContainer < Mash; class_inheritable_accessor :session_store_type end
+  class SessionStoreContainer < SessionContainer; end
+
+  class RedisSession < SessionStoreContainer
+    self.session_store_type = :redis
+  end
+
+  module RedisStore
+    def retrieve_session(session_id)
+      get("session:#{session_id}")
+    end
+
+    def store_session(session_id, data)
+      set("session:#{session_id}", data)
+    end
+
+    def delete_session(session_id)
+      delete("session:#{session_id}")
+    end    
+  end
+end
+
+module Rack
+  module Session
+    class Redis
+      include Merb::RedisStore
+    end
+  end
+end

data/lib/rack/session/redis.rb

@@ -0,0 +1,81 @@
+module Rack
+  module Session
+    class Redis < Abstract::ID
+      attr_reader :mutex, :pool
+      DEFAULT_OPTIONS = Abstract::ID::DEFAULT_OPTIONS.merge :redis_server => "redis://127.0.0.1:6379/0"
+
+      def initialize(app, options = {})
+        super
+        @mutex = Mutex.new
+        @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)
+        end
+      end
+
+      def get_session(env, 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.set sid, session
+          raise "Session collision on '#{sid.inspect}'" unless ret
+        end
+        session.instance_variable_set('@old', {}.merge(session))
+        return [sid, session]
+      rescue Errno::ECONNREFUSED
+        warn "#{self} is unable to find server."
+        warn $!.inspect
+        return [ nil, {} ]
+      ensure
+        @mutex.unlock if env['rack.multithread']
+      end
+
+      def set_session(env, session_id, new_session, options)
+        @mutex.lock if env['rack.multithread']
+        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.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
+        return session_id
+      rescue Errno::ECONNREFUSED
+        warn "#{self} is unable to find server."
+        warn $!.inspect
+        return false
+      ensure
+        @mutex.unlock if env['rack.multithread']
+      end
+
+      private
+        def merge_sessions(sid, old, new, cur=nil)
+          cur ||= {}
+          unless Hash === old and Hash === new
+            warn 'Bad old or new sessions provided.'
+            return cur
+          end
+
+          delete = old.keys - new.keys
+          warn "//@#{sid}: dropping #{delete*','}" if $DEBUG and not delete.empty?
+          delete.each{|k| cur.delete k }
+
+          update = new.keys.select{|k| new[k] != old[k] }
+          warn "//@#{sid}: updating #{update*','}" if $DEBUG and not update.empty?
+          update.each{|k| cur[k] = new[k] }
+
+          cur
+        end
+    end
+  end
+end