redis-objects-legacy 1.6.0

data/lib/redis/counter.rb

@@ -0,0 +1,145 @@
+require File.dirname(__FILE__) + '/base_object'
+
+class Redis
+  #
+  # Class representing a Redis counter.  This functions like a proxy class, in
+  # that you can say @object.counter_name to get the value and then
+  # @object.counter_name.increment to operate on it.  You can use this
+  # directly, or you can use the counter :foo class method in your
+  # class to define a counter.
+  #
+  class Counter < BaseObject
+    def initialize(key, *args)
+      super(key, *args)
+      @options[:start] ||= @options[:default] || 0
+      raise ArgumentError, "Marshalling redis counters does not make sense" if @options[:marshal]
+      redis.setnx(key, @options[:start]) unless @options[:start] == 0 || @options[:init] === false
+    end
+
+    # Reset the counter to its starting value.  Not atomic, so use with care.
+    # Normally only useful if you're discarding all sub-records associated
+    # with a parent and starting over (for example, restarting a game and
+    # disconnecting all players).
+    def reset(to=options[:start])
+      allow_expiration do
+        redis.set key, to.to_i
+        true  # hack for redis-rb regression
+      end
+    end
+
+    # Reset the counter to its starting value, and return previous value.
+    # Use this to "reap" the counter and save it somewhere else. This is
+    # atomic in that no increments or decrements are lost if you process
+    # the returned value.
+    def getset(to=options[:start])
+      redis.getset(key, to.to_i).to_i
+    end
+
+    # Returns the current value of the counter.  Normally just calling the
+    # counter will lazily fetch the value, and only update it if increment
+    # or decrement is called.  This forces a network call to redis-server
+    # to get the current value.
+    def value
+      redis.get(key).to_i
+    end
+    alias_method :get, :value
+
+    def value=(val)
+      allow_expiration do
+        if val.nil?
+          delete
+        else
+          redis.set key, val
+        end
+      end
+    end
+    alias_method :set, :value=
+
+    # Like .value but casts to float since Redis addresses these differently.
+    def to_f
+      redis.get(key).to_f
+    end
+
+    # Increment the counter atomically and return the new value.  If passed
+    # a block, that block will be evaluated with the new value of the counter
+    # as an argument. If the block returns nil or throws an exception, the
+    # counter will automatically be decremented to its previous value.  This
+    # method is aliased as incr() for brevity.
+    def increment(by=1, &block)
+      allow_expiration do
+        val = redis.incrby(key, by).to_i
+        block_given? ? rewindable_block(:decrement, by, val, &block) : val
+      end
+    end
+    alias_method :incr, :increment
+    alias_method :incrby, :increment
+
+    # Decrement the counter atomically and return the new value.  If passed
+    # a block, that block will be evaluated with the new value of the counter
+    # as an argument. If the block returns nil or throws an exception, the
+    # counter will automatically be incremented to its previous value.  This
+    # method is aliased as decr() for brevity.
+    def decrement(by=1, &block)
+      allow_expiration do
+        val = redis.decrby(key, by).to_i
+        block_given? ? rewindable_block(:increment, by, val, &block) : val
+      end
+    end
+    alias_method :decr, :decrement
+    alias_method :decrby, :decrement
+
+    # Increment a floating point counter atomically.
+    # Redis uses separate API's to interact with integers vs floats.
+    def incrbyfloat(by=1.0, &block)
+      allow_expiration do
+        val = redis.incrbyfloat(key, by).to_f
+        block_given? ? rewindable_block(:decrbyfloat, by, val, &block) : val
+      end
+    end
+
+    # Decrement a floating point counter atomically.
+    # Redis uses separate API's to interact with integers vs floats.
+    def decrbyfloat(by=1.0, &block)
+      allow_expiration do
+        val = redis.incrbyfloat(key, -by).to_f
+        block_given? ? rewindable_block(:incrbyfloat, by, val, &block) : val
+      end
+    end
+
+    ##
+    # Proxy methods to help make @object.counter == 10 work
+    def to_s; value.to_s; end
+    alias_method :to_i, :value
+
+    def nil?
+      !redis.exists?(key)
+    end
+
+    ##
+    # Math ops
+    # This needs to handle +/- either actual integers or other Redis::Counters
+    %w(+ - == < > <= >=).each do |m|
+      class_eval <<-EndOverload
+        def #{m}(what)
+          value.to_i #{m} what.to_i
+        end
+      EndOverload
+    end
+
+    private
+
+    # Implements atomic increment/decrement blocks
+    def rewindable_block(rewind, by, value, &block)
+      raise ArgumentError, "Missing block to rewindable_block somehow" unless block_given?
+      ret = nil
+      begin
+        ret = yield value
+      rescue
+        send(rewind, by)
+        raise
+      end
+      send(rewind, by) if ret.nil?
+      ret
+    end
+  end
+end

data/lib/redis/enumerable_object.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/base_object'
+
+class Redis
+  #
+  # Class representing a Redis enumerable type (list, set, sorted set, or hash).
+  #
+  class EnumerableObject < BaseObject
+    include Enumerable
+
+    # Iterate through each member. Redis::Objects mixes in Enumerable,
+    # so you can also use familiar methods like +collect+, +detect+, and so forth.
+    def each(&block)
+      value.each(&block)
+    end
+
+    def sort(options={})
+      return super() if block_given?
+      options[:order] = "asc alpha" if options.keys.count == 0  # compat with Ruby
+      val = redis.sort(key, **options)
+      val.is_a?(Array) ? val.map{|v| unmarshal(v)} : val
+    end
+
+    # ActiveSupport's core extension `Enumerable#as_json` implementation is incompatible with ours.
+    def as_json(*)
+      to_hash
+    end
+  end
+end

data/lib/redis/hash_key.rb

@@ -0,0 +1,163 @@
+require File.dirname(__FILE__) + '/enumerable_object'
+
+class Redis
+  #
+  # Class representing a Redis hash.
+  #
+  class HashKey < EnumerableObject
+    def initialize(key, *args)
+      super
+      @options[:marshal_keys] ||= {}
+    end
+
+    # Redis: HSET
+    def store(field, value)
+      allow_expiration do
+        redis.hset(key, field, marshal(value, options[:marshal_keys][field]))
+      end
+    end
+    alias_method :[]=, :store
+
+    # Redis: HGET
+    def hget(field)
+      unmarshal redis.hget(key, field), options[:marshal_keys][field]
+    end
+    alias_method :get, :hget
+    alias_method :[],  :hget
+
+    # Verify that a field exists. Redis: HEXISTS
+    def has_key?(field)
+      redis.hexists(key, field)
+    end
+    alias_method :include?, :has_key?
+    alias_method :key?, :has_key?
+    alias_method :member?, :has_key?
+
+    # Delete fields. Redis: HDEL
+    def delete(*field)
+      redis.hdel(key, field)
+    end
+
+    # Fetch a key in a way similar to Ruby's Hash#fetch
+    def fetch(field, *args, &block)
+      value = hget(field)
+      default = args[0]
+
+      return value if value || (!default && !block_given?)
+
+      block_given? ? block.call(field) : default
+    end
+
+    # Return all the keys of the hash. Redis: HKEYS
+    def keys
+      redis.hkeys(key)
+    end
+
+    # Return all the values of the hash. Redis: HVALS
+    def values
+      redis.hvals(key).map{|v| unmarshal(v) }
+    end
+    alias_method :vals, :values
+
+    # Retrieve the entire hash.  Redis: HGETALL
+    def all
+      h = redis.hgetall(key) || {}
+      h.each{|k,v| h[k] = unmarshal(v, options[:marshal_keys][k]) }
+      h
+    end
+    alias_method :clone, :all
+    alias_method :value, :all
+
+    # Enumerate through each keys. Redis: HKEYS
+    def each_key(&block)
+      keys.each(&block)
+    end
+
+    # Enumerate through all values. Redis: HVALS
+    def each_value(&block)
+      values.each(&block)
+    end
+
+    # Return the size of the dict. Redis: HLEN
+    def size
+      redis.hlen(key)
+    end
+    alias_method :length, :size
+    alias_method :count, :size
+
+    # Returns true if dict is empty
+    def empty?
+      true if size == 0
+    end
+
+    # Set keys in bulk, takes a hash of field/values {'field1' => 'val1'}. Redis: HMSET
+    def bulk_set(*args)
+      raise ArgumentError, "Argument to bulk_set must be hash of key/value pairs" unless args.last.is_a?(::Hash)
+      allow_expiration do
+        redis.hmset(key, *args.last.inject([]){ |arr,kv|
+          arr + [kv[0], marshal(kv[1], options[:marshal_keys][kv[0]])]
+        })
+      end
+    end
+    alias_method :update, :bulk_set
+
+    # Set keys in bulk if they do not exist. Takes a hash of field/values {'field1' => 'val1'}. Redis: HSETNX
+    def fill(pairs={})
+      raise ArgumentError, "Argument to fill must be a hash of key/value pairs" unless pairs.is_a?(::Hash)
+      allow_expiration do
+        pairs.each do |field, value|
+          redis.hsetnx(key, field, marshal(value, options[:marshal_keys][field]))
+        end
+      end
+    end
+
+    # Get keys in bulk, takes an array of fields as arguments. Redis: HMGET
+    def bulk_get(*fields)
+      hsh = {}
+      get_fields = *fields.flatten
+      return hsh if get_fields.empty?
+      res = redis.hmget(key, get_fields)
+      get_fields.each do |k|
+        hsh[k] = unmarshal(res.shift, options[:marshal_keys][k])
+      end
+      hsh
+    end
+
+    # Get values in bulk, takes an array of fields as arguments.
+    # Values are returned in a collection in the same order than their keys in *keys Redis: HMGET
+    def bulk_values(*fields)
+      get_fields = *fields.flatten
+      return [] if get_fields.empty?
+      res = redis.hmget(key, get_fields)
+      get_fields.collect{|k| unmarshal(res.shift, options[:marshal_keys][k])}
+    end
+
+    # Increment value by integer at field. Redis: HINCRBY
+    def incrby(field, by=1)
+      allow_expiration do
+        ret = redis.hincrby(key, field, by)
+        ret.to_i
+      end
+    end
+    alias_method :incr, :incrby
+
+    # Decrement value by integer at field. Redis: HINCRBY
+    def decrby(field, by=1)
+      incrby(field, -by)
+    end
+    alias_method :decr, :decrby
+
+    # Increment value by float at field. Redis: HINCRBYFLOAT
+    def incrbyfloat(field, by=1.0)
+      allow_expiration do
+        ret = redis.hincrbyfloat(key, field, by)
+        ret.to_f
+      end
+    end
+
+    # Decrement value by float at field. Redis: HINCRBYFLOAT
+    def decrbyfloat(field, by=1.0)
+      incrbyfloat(field, -by)
+    end
+  end
+end

data/lib/redis/helpers/core_commands.rb

@@ -0,0 +1,89 @@
+class Redis
+  module Helpers
+    # These are core commands that all types share (rename, etc)
+    module CoreCommands
+      def exists
+        redis.exists key
+      end
+
+      def exists?
+        redis.exists? key
+      end
+
+      # Delete key. Redis: DEL
+      def delete
+        redis.del key
+      end
+      alias_method :del, :delete
+      alias_method :clear, :delete
+
+      def type
+        redis.type key
+      end
+
+      def rename(name, setkey=true)
+        dest = name.is_a?(self.class) ? name.key : name
+        ret  = redis.rename key, dest
+        @key = dest if ret && setkey
+        ret
+      end
+
+      def renamenx(name, setkey=true)
+        dest = name.is_a?(self.class) ? name.key : name
+        ret  = redis.renamenx key, dest
+        @key = dest if ret && setkey
+        ret
+      end
+
+      def expire(seconds)
+        redis.expire key, seconds
+      end
+
+      def expireat(unixtime)
+        redis.expireat key, unixtime
+      end
+
+      def persist
+        redis.persist key
+      end
+
+      def ttl
+        redis.ttl(@key)
+      end
+
+      def move(dbindex)
+        redis.move key, dbindex
+      end
+
+      def serializer
+        options[:serializer] || Marshal
+      end
+
+      def marshal(value, domarshal=false)
+        if options[:marshal] || domarshal
+          dump_args = options[:marshal_dump_args] || []
+          serializer.dump(value, *(dump_args.is_a?(Array) ? dump_args : [dump_args]))
+        else
+          value
+        end
+      end
+
+      def unmarshal(value, domarshal=false)
+        if value.nil?
+          nil
+        elsif options[:marshal] || domarshal
+          if value.is_a?(Array)
+            value.map{|v| unmarshal(v, domarshal)}
+          elsif !value.is_a?(String)
+            value
+          else
+            load_args = options[:marshal_load_args] || []
+            serializer.load(value, *(load_args.is_a?(Array) ? load_args : [load_args]))
+          end
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/redis/list.rb

@@ -0,0 +1,160 @@
+require File.dirname(__FILE__) + '/enumerable_object'
+
+class Redis
+  #
+  # Class representing a Redis list.  Instances of Redis::List are designed to
+  # behave as much like Ruby arrays as possible.
+  #
+  class List < EnumerableObject
+    # Works like push.  Can chain together: list << 'a' << 'b'
+    def <<(value)
+      push(value) # marshal in push()
+      self  # for << 'a' << 'b'
+    end
+
+    # Add a member before or after pivot in the list. Redis: LINSERT
+    def insert(where,pivot,value)
+      allow_expiration do
+        redis.linsert(key,where,marshal(pivot),marshal(value))
+      end
+    end
+
+    # Add a member to the end of the list. Redis: RPUSH
+    def push(*values)
+      allow_expiration do
+        count = redis.rpush(key, values.map{|v| marshal(v) })
+        redis.ltrim(key, -options[:maxlength], -1) if options[:maxlength]
+        count
+      end
+    end
+
+    # Remove a member from the end of the list. Redis: RPOP
+    def pop(n=nil)
+      if n
+        result, = redis.multi do
+          redis.lrange(key, -n, -1)
+          redis.ltrim(key, 0, -n - 1)
+        end
+        unmarshal result
+      else
+        unmarshal redis.rpop(key)
+      end
+    end
+
+    # Atomically pops a value from one list, pushes to another and returns the
+    # value.  Destination can be a String or a Redis::List
+    #
+    #   list.rpoplpush(destination)
+    #
+    # Returns the popped/pushed value.
+    #
+    # Redis: RPOPLPUSH
+    def rpoplpush(destination)
+      unmarshal redis.rpoplpush(key, destination.is_a?(Redis::List) ? destination.key : destination.to_s)
+    end
+
+    # Add a member to the start of the list. Redis: LPUSH
+    def unshift(*values)
+      allow_expiration do
+        count = redis.lpush(key, values.map{|v| marshal(v) })
+        redis.ltrim(key, 0, options[:maxlength] - 1) if options[:maxlength]
+        count
+      end
+    end
+
+    # Remove a member from the start of the list. Redis: LPOP
+    def shift(n=nil)
+      if n
+        result, = redis.multi do
+          redis.lrange(key, 0, n - 1)
+          redis.ltrim(key, n, -1)
+        end
+        unmarshal result
+      else
+        unmarshal redis.lpop(key)
+      end
+    end
+
+    # Return all values in the list. Redis: LRANGE(0,-1)
+    def values
+      vals = range(0, -1)
+      vals.nil? ? [] : vals
+    end
+    alias_method :get, :values
+    alias_method :value, :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.max)
+      elsif length
+        case length <=> 0
+        when 1  then range(index, index + length - 1)
+        when 0  then []
+        when -1 then nil  # Ruby does this (a bit weird)
+        end
+      else
+        at(index)
+      end
+    end
+    alias_method :slice, :[]
+
+    # Same functionality as Ruby arrays.
+    def []=(index, value)
+      allow_expiration do
+        redis.lset(key, index, marshal(value))
+      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, marshal(name))  # weird api
+    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)
+      redis.lrange(key, start_index, end_index).map{|v| unmarshal(v) }
+    end
+
+    # Return the value at the given index. Can also use familiar list[index] syntax.
+    # Redis: LINDEX
+    def at(index)
+      unmarshal 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,89 @@
+require File.dirname(__FILE__) + '/base_object'
+
+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 < BaseObject
+    class LockTimeout < StandardError; end #:nodoc:
+
+    def initialize(key, *args)
+      super(key, *args)
+      @options[:timeout] ||= 5
+      @options[:init] = false if @options[:init].nil? # default :init to false
+      redis.setnx(key, @options[:start]) unless @options[:start] == 0 || @options[:init] === false
+    end
+
+    def value
+      nil
+    end
+
+    # 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
+      raise ArgumentError, 'Block not given' unless block_given?
+      expiration_ms = generate_expiration
+      expiration_s  = expiration_ms / 1000.0
+      end_time = nil
+      try_until_timeout do
+        end_time = Time.now.to_i + expiration_s
+        # Set a NX record and use the Redis expiration mechanism.
+        # Empty value because the presence of it is enough to lock
+        # `px` only except an Integer in millisecond
+        break if redis.set(key, nil, px: expiration_ms, nx: true)
+
+        # Backward compatibility code
+        # TODO: remove at the next major release for performance
+        unless @options[:expiration].nil?
+          old_expiration = redis.get(key).to_f
+
+          # Check it was not an empty string with `zero?` and
+          # the expiration time is passed.
+          if !old_expiration.zero? && old_expiration < Time.now.to_f
+            expiration_ms = generate_expiration
+            expiration_s  = expiration_ms / 1000.0
+            end_time = Time.now.to_i + expiration_s
+            break if redis.set(key, nil, px: expiration_ms)
+          end
+        end
+      end
+      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? || end_time > Time.now.to_f
+          redis.del(key)
+        end
+      end
+    end
+
+    # Return expiration in milliseconds
+    def generate_expiration
+      ((@options[:expiration].nil? ? 1 : @options[:expiration].to_f) * 1000).to_i
+    end
+
+    private
+
+    def try_until_timeout
+      if @options[:timeout] == 0
+        yield
+      else
+        start = Time.now
+        while Time.now - start < @options[:timeout]
+          yield
+          sleep 0.1
+        end
+      end
+      raise LockTimeout, "Timeout on lock #{key} exceeded #{@options[:timeout]} sec"
+    end
+  end
+end

data/lib/redis/objects/connection_pool_proxy.rb

@@ -0,0 +1,31 @@
+class Redis
+  module Objects
+    class ConnectionPoolProxy
+      def initialize(pool)
+        raise ArgumentError "Should only proxy ConnectionPool!" unless self.class.should_proxy?(pool)
+        @pool = pool
+      end
+
+      def method_missing(name, *args, &block)
+        @pool.with { |x| x.send(name, *args, &block) }
+      end
+      ruby2_keywords :method_missing if respond_to?(:ruby2_keywords, true)
+
+      def respond_to_missing?(name, include_all = false)
+        @pool.with { |x| x.respond_to?(name, include_all) }
+      end
+
+      def self.should_proxy?(conn)
+        defined?(::ConnectionPool) && conn.is_a?(::ConnectionPool)
+      end
+
+      def self.proxy_if_needed(conn)
+        if should_proxy?(conn)
+          ConnectionPoolProxy.new(conn)
+        else
+          conn
+        end
+      end
+    end
+  end
+end