chimera 0.0.1

data/lib/redis/list.rb

@@ -0,0 +1,122 @@
+class Redis
+  #
+  # Class representing a Redis list.  Instances of Redis::List are designed to 
+  # behave as much like Ruby arrays as possible.
+  #
+  class List
+    require 'enumerator'
+    include Enumerable
+    require 'redis/helpers/core_commands'
+    include Redis::Helpers::CoreCommands
+    require 'redis/helpers/serialize'
+    include Redis::Helpers::Serialize
+
+    attr_reader :key, :options, :redis
+    
+    def initialize(key, redis=$redis, options={})
+      @key = key
+      @redis = redis
+      @options = options
+    end
+    
+    # Works like push.  Can chain together: list << 'a' << 'b'
+    def <<(value)
+      push(value)
+      self  # for << 'a' << 'b'
+    end
+
+    # Add a member to the end of the list. Redis: RPUSH
+    def push(value)
+      redis.rpush(key, to_redis(value))
+    end
+
+    # Remove a member from the end of the list. Redis: RPOP
+    def pop
+      from_redis redis.rpop(key)
+    end
+
+    # Add a member to the start of the list. Redis: LPUSH
+    def unshift(value)
+      redis.lpush(key, to_redis(value))
+    end
+
+    # Remove a member from the start of the list. Redis: LPOP
+    def shift
+      from_redis redis.lpop(key)
+    end
+
+    # Return all values in the list. Redis: LRANGE(0,-1)
+    def values
+      from_redis range(0, -1)
+    end
+    alias_method :get, :values
+
+    # Same functionality as Ruby arrays.  If a single number is given, return
+    # just the element at that index using Redis: LINDEX. Otherwise, return
+    # a range of values using Redis: LRANGE.
+    def [](index, length=nil)
+      if index.is_a? Range
+        range(index.first, index.last)
+      elsif length
+        range(index, length)
+      else
+        at(index)
+      end
+    end
+    
+    # Delete the element(s) from the list that match name. If count is specified,
+    # only the first-N (if positive) or last-N (if negative) will be removed.
+    # Use .del to completely delete the entire key.
+    # Redis: LREM
+    def delete(name, count=0)
+      redis.lrem(key, count, name)  # weird api
+    end
+
+    # Iterate through each member of the set.  Redis::Objects mixes in Enumerable,
+    # so you can also use familiar methods like +collect+, +detect+, and so forth.
+    def each(&block)
+      values.each(&block)
+    end
+
+    # Return a range of values from +start_index+ to +end_index+.  Can also use
+    # the familiar list[start,end] Ruby syntax. Redis: LRANGE
+    def range(start_index, end_index)
+      from_redis redis.lrange(key, start_index, end_index)
+    end
+
+    # Return the value at the given index. Can also use familiar list[index] syntax.
+    # Redis: LINDEX
+    def at(index)
+      from_redis redis.lindex(key, index)
+    end
+
+    # Return the first element in the list. Redis: LINDEX(0)
+    def first
+      at(0)
+    end
+
+    # Return the last element in the list. Redis: LINDEX(-1)
+    def last
+      at(-1)
+    end
+
+    # Return the length of the list. Aliased as size. Redis: LLEN
+    def length
+      redis.llen(key)
+    end
+    alias_method :size, :length
+   
+    # Returns true if there are no elements in the list. Redis: LLEN == 0
+    def empty?
+      length == 0
+    end
+ 
+    def ==(x)
+      values == x
+    end
+    
+    def to_s
+      values.join(', ')
+    end
+  end
+end

data/lib/redis/lock.rb

@@ -0,0 +1,83 @@
+class Redis
+  #
+  # Class representing a lock.  This functions like a proxy class, in
+  # that you can say @object.lock_name { block } to use the lock and also
+  # @object.counter_name.clear to reset on it.  You can use this
+  # directly, but it is better to use the lock :foo class method in your
+  # class to define a lock.
+  #
+  class Lock
+    class LockTimeout < StandardError; end #:nodoc:
+
+    attr_reader :key, :options, :redis
+    def initialize(key, redis=$redis, options={})
+      @key = key
+      @redis = redis
+      @options = options
+      @options[:timeout] ||= 5
+      @redis.setnx(key, @options[:start]) unless @options[:start] == 0 || @options[:init] === false
+    end
+
+    # Clear the lock.  Should only be needed if there's a server crash
+    # or some other event that gets locks in a stuck state.
+    def clear
+      redis.del(key)
+    end
+    alias_method :delete, :clear
+
+    # Get the lock and execute the code block. Any other code that needs the lock
+    # (on any server) will spin waiting for the lock up to the :timeout
+    # that was specified when the lock was defined.
+    def lock(&block)
+      start = Time.now
+      gotit = false
+      expiration = nil
+      while Time.now - start < @options[:timeout]
+        expiration = generate_expiration
+        # Use the expiration as the value of the lock.
+        gotit = redis.setnx(key, expiration)
+        break if gotit
+
+        # Lock is being held.  Now check to see if it's expired (if we're using
+        # lock expiration).
+        # See "Handling Deadlocks" section on http://code.google.com/p/redis/wiki/SetnxCommand
+        if !@options[:expiration].nil?
+          old_expiration = redis.get(key).to_f
+
+          if old_expiration < Time.now.to_f
+            # If it's expired, use GETSET to update it.
+            expiration = generate_expiration
+            old_expiration = redis.getset(key, expiration).to_f
+
+            # Since GETSET returns the old value of the lock, if the old expiration
+            # is still in the past, we know no one else has expired the locked
+            # and we now have it.
+            if old_expiration < Time.now.to_f
+              gotit = true
+              break
+            end
+          end
+        end
+
+        sleep 0.1
+      end
+      raise LockTimeout, "Timeout on lock #{key} exceeded #{@options[:timeout]} sec" unless gotit
+      begin
+        yield
+      ensure
+        # We need to be careful when cleaning up the lock key.  If we took a really long
+        # time for some reason, and the lock expired, someone else may have it, and
+        # it's not safe for us to remove it.  Check how much time has passed since we
+        # wrote the lock key and only delete it if it hasn't expired (or we're not using
+        # lock expiration)
+        if @options[:expiration].nil? || expiration > Time.now.to_f
+          redis.del(key)
+        end
+      end
+    end
+
+    def generate_expiration
+      @options[:expiration].nil? ? 1 : (Time.now + @options[:expiration].to_f + 1).to_f
+    end
+  end
+end

data/lib/redis/objects.rb

@@ -0,0 +1,100 @@
+# Redis::Objects - Lightweight object layer around redis-rb
+# See README.rdoc for usage and approach.
+
+class Redis
+  #
+  # Redis::Objects enables high-performance atomic operations in your app
+  # by leveraging the atomic features of the Redis server.  To use Redis::Objects,
+  # first include it in any class you want.  (This example uses an ActiveRecord
+  # subclass, but that is *not* required.) Then, use +counter+ and +lock+
+  # to define your primitives:
+  #
+  #   class Game < ActiveRecord::Base
+  #     include Redis::Objects
+  #
+  #     counter :joined_players
+  #     counter :active_players
+  #     set :player_ids
+  #     lock :archive_game
+  #   end
+  # 
+  # The, you can use these counters both for bookeeping and as atomic actions:
+  #
+  #   @game = Game.find(id)
+  #   @game_user = @game.joined_players.increment do |val|
+  #     break if val > @game.max_players
+  #     gu = @game.game_users.create!(:user_id => @user.id)
+  #     @game.active_players.increment
+  #     gu
+  #   end
+  #   if @game_user.nil?
+  #     # game is full - error screen
+  #   else
+  #     # success
+  #   end
+  #
+  #
+  #
+  module Objects
+    dir = File.expand_path(__FILE__.sub(/\.rb$/,''))
+
+    autoload :Counters, File.join(dir, 'counters')
+    autoload :Values, File.join(dir, 'values')
+    autoload :Lists, File.join(dir, 'lists')
+    autoload :Sets, File.join(dir, 'sets')
+    autoload :Locks, File.join(dir, 'locks')
+
+    class NotConnected  < StandardError; end
+
+    class << self
+      # def redis=(conn) @redis = conn end
+      # def redis
+      #   @redis ||= $redis || raise(NotConnected, "Redis::Objects.redis not set to a Redis.new connection")
+      # end
+
+      def included(klass)
+        # Core (this file)
+        #klass.instance_variable_set('@redis', @redis)
+        klass.instance_variable_set('@redis_objects', {})
+        klass.send :include, InstanceMethods
+        klass.extend ClassMethods
+        
+        # Pull in each object type
+        klass.send :include, Redis::Objects::Counters
+        klass.send :include, Redis::Objects::Values
+        klass.send :include, Redis::Objects::Lists
+        klass.send :include, Redis::Objects::Sets
+        klass.send :include, Redis::Objects::Locks
+      end
+    end
+
+    # Class methods that appear in your class when you include Redis::Objects.
+    module ClassMethods
+      #attr_accessor :redis, :redis_objects
+      attr_accessor :redis_objects
+
+      # Set the Redis prefix to use. Defaults to model_name
+      def prefix=(prefix) @prefix = prefix end
+      def prefix #:nodoc:
+        @prefix ||= self.name.to_s.
+          sub(%r{(.*::)}, '').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          downcase
+      end
+      
+      def field_key(name, id) #:nodoc:
+        "#{prefix}:#{id}:#{name}"
+      end
+
+    end
+
+    # Instance methods that appear in your class when you include Redis::Objects.
+    module InstanceMethods
+      def redis() self.class.connection end
+      def field_key(name) #:nodoc:
+        self.class.field_key(name, id)
+      end
+    end
+  end
+end

data/lib/redis/objects/counters.rb

@@ -0,0 +1,132 @@
+# This is the class loader, for use as "include Redis::Objects::Counters"
+# For the object itself, see "Redis::Counter"
+require 'redis/counter'
+class Redis
+  module Objects
+    class UndefinedCounter < StandardError; end #:nodoc:
+    class MissingID < StandardError; end #:nodoc:
+
+    module Counters
+      def self.included(klass)
+        klass.instance_variable_set('@initialized_counters', {})
+        klass.send :include, InstanceMethods
+        klass.extend ClassMethods
+      end
+
+      # Class methods that appear in your class when you include Redis::Objects.
+      module ClassMethods
+        attr_reader :initialized_counters
+
+        # Define a new counter.  It will function like a regular instance
+        # method, so it can be used alongside ActiveRecord, DataMapper, etc.
+        def counter(name, options={})
+          options[:start] ||= 0
+          options[:type]  ||= options[:start] == 0 ? :increment : :decrement
+          @redis_objects[name] = options.merge(:type => :counter)
+          if options[:global]
+            instance_eval <<-EndMethods
+              def #{name}
+                @#{name} ||= Redis::Counter.new(field_key(:#{name}, ''), redis, @redis_objects[:#{name}])
+              end
+            EndMethods
+            class_eval <<-EndMethods
+              def #{name}
+                self.class.#{name}
+              end
+            EndMethods
+          else
+            class_eval <<-EndMethods
+              def #{name}
+                @#{name} ||= Redis::Counter.new(field_key(:#{name}), redis, self.class.redis_objects[:#{name}])
+              end
+            EndMethods
+          end
+        end
+
+        # Get the current value of the counter. It is more efficient
+        # to use the instance method if possible.
+        def get_counter(name, id=nil)
+          verify_counter_defined!(name, id)
+          initialize_counter!(name, id)
+          redis.get(field_key(name, id)).to_i
+        end
+
+        # Increment a counter with the specified name and id.  Accepts a block
+        # like the instance method.  See Redis::Objects::Counter for details.
+        def increment_counter(name, id=nil, by=1, &block)
+          verify_counter_defined!(name, id)
+          initialize_counter!(name, id)
+          value = redis.incr(field_key(name, id), by).to_i
+          block_given? ? rewindable_block(:decrement_counter, name, id, value, &block) : value
+        end
+
+        # Decrement a counter with the specified name and id.  Accepts a block
+        # like the instance method.  See Redis::Objects::Counter for details.
+        def decrement_counter(name, id=nil, by=1, &block)
+          verify_counter_defined!(name, id)
+          initialize_counter!(name, id)
+          value = redis.decr(field_key(name, id), by).to_i
+          block_given? ? rewindable_block(:increment_counter, name, id, value, &block) : value
+        end
+
+        # Reset a counter to its starting value.
+        def reset_counter(name, id=nil, to=nil)
+          verify_counter_defined!(name, id)
+          to = @redis_objects[name][:start] if to.nil?
+          redis.set(field_key(name, id), to)
+        end
+        
+        private
+        
+        def verify_counter_defined!(name, id) #:nodoc:
+          raise Redis::Objects::UndefinedCounter, "Undefined counter :#{name} for class #{self.name}" unless @redis_objects.has_key?(name)
+          if id.nil? and !@redis_objects[name][:global]
+            raise Redis::Objects::MissingID, "Missing ID for non-global counter #{self.name}##{name}"
+          end
+        end
+        
+        def initialize_counter!(name, id) #:nodoc:
+          key = field_key(name, id)
+          unless @initialized_counters[key]
+            redis.setnx(key, @redis_objects[name][:start])
+          end
+          @initialized_counters[key] = true
+        end
+        
+        # Implements increment/decrement blocks on a class level
+        def rewindable_block(rewind, name, id, value, &block) #:nodoc:
+          # Unfortunately this is almost exactly duplicated from Redis::Counter
+          raise ArgumentError, "Missing block to rewindable_block somehow" unless block_given?
+          ret = nil
+          begin
+            ret = yield value
+          rescue
+            send(rewind, name, id)
+            raise
+          end
+          send(rewind, name, id) if ret.nil?
+          ret
+        end
+      end
+
+      # Instance methods that appear in your class when you include Redis::Objects.
+      module InstanceMethods
+        # Increment a counter.
+        # It is more efficient to use increment_[counter_name] directly.
+        # This is mainly just for completeness to override ActiveRecord.
+        def increment(name, by=1)
+          raise(ActiveRedis::Errors::NotSavedError) if self.new?
+          send(name).increment(by)
+        end
+
+        # Decrement a counter.
+        # It is more efficient to use increment_[counter_name] directly.
+        # This is mainly just for completeness to override ActiveRecord.
+        def decrement(name, by=1)
+          raise(ActiveRedis::Errors::NotSavedError) if self.new?
+          send(name).decrement(by)
+        end
+      end
+    end
+  end
+end

data/lib/redis/objects/lists.rb

@@ -0,0 +1,45 @@
+# This is the class loader, for use as "include Redis::Objects::Lists"
+# For the object itself, see "Redis::List"
+require 'redis/list'
+class Redis
+  module Objects
+    module Lists
+      def self.included(klass)
+        klass.send :include, InstanceMethods
+        klass.extend ClassMethods
+      end
+
+      # Class methods that appear in your class when you include Redis::Objects.
+      module ClassMethods
+        # Define a new list.  It will function like a regular instance
+        # method, so it can be used alongside ActiveRecord, DataMapper, etc.
+        def list(name, options={})
+          @redis_objects[name] = options.merge(:type => :list)
+          if options[:global]
+            instance_eval <<-EndMethods
+              def #{name}
+                @#{name} ||= Redis::List.new(field_key(:#{name}, ''), redis, @redis_objects[:#{name}])
+              end
+            EndMethods
+            class_eval <<-EndMethods
+              def #{name}
+                self.class.#{name}
+              end
+            EndMethods
+          else
+            class_eval <<-EndMethods
+              def #{name}
+                raise(ActiveRedis::Errors::NotSavedError) if self.new?
+                @#{name} ||= Redis::List.new(field_key(:#{name}), redis, self.class.redis_objects[:#{name}])
+              end
+            EndMethods
+          end
+        end
+      end
+
+      # Instance methods that appear in your class when you include Redis::Objects.
+      module InstanceMethods
+      end
+    end
+  end
+end