redis_support 0.0.6 → 0.0.9

data/lib/redis_support.rb

@@ -8,7 +8,11 @@ require 'redis_support/locks'
 
 module RedisSupport
   def redis
-    self.class.redis
+    if( self.class.respond_to?(:redis) )
+      self.class.redis
+    else
+      @redis || RedisSupport.redis
+    end
   end
 
   def keys

data/lib/redis_support/locks.rb

@@ -1,98 +1,100 @@
 # Locking support
 #
 module RedisSupport
+  
+  module ClassMethods
+    # Lock a block of code so it can only be accessed by one thread in
+    # our system at a time.
+    #
+    # See 'acquire_redis_lock' for details on parameters.
+    #
+    # Returns nothing.
+    def redis_lock( key_to_lock, expiration = 30, interval = 1 )
+      acquire_redis_lock( key_to_lock, expiration, interval )
+      yield
+    ensure
+      release_redis_lock( key_to_lock )
+    end
 
-  # Lock a block of code so it can only be accessed by one thread in
-  # our system at a time.
-  #
-  # See 'acquire_redis_lock' for details on parameters.
-  #
-  # Returns nothing.
-  def redis_lock( key_to_lock, expiration = 30, interval = 1 )
-    acquire_redis_lock( key_to_lock, expiration, interval )
-    yield
-  ensure
-    release_redis_lock( key_to_lock )
-  end
-
-  # Acquire a lock on a key in our Redis database. This is a blocking
-  # call. It sleeps until the lock has been successfully acquired.
-  #
-  # Basic usage:
-  #
-  #   acquire_redis_lock( key.my_key )
-  #   # do some stuff on my_key
-  #   release_redis_lock( key.my_key )
-  #
-  # Described in detail here:
-  #
-  #   http://code.google.com/p/redis/wiki/SetnxCommand
-  #
-  # key_to_lock - the key to lock. the actual key for the lock in redis will
-  #               be this value with 'lock.' prepended, which lets this whole
-  #               acquire_lock business act like a standard ruby object or
-  #               synchronize lock. Also it ensures that all locks in the database
-  #               can be easily viewed using redis.keys("lock.*")
-  #
-  # expiration  - the expiration for the lock, expressed as an Integer. default is
-  #               30 seconds from when the lock is acquired. Note that this is the
-  #               amount of time others will wait for you, not the amount of time
-  #               you will wait to acquire the lock.
-  #
-  # interval    - sleep interval for checking the lock's status.
-  #   
-  # Returns nothing.
-  def acquire_redis_lock( key_to_lock, expiration = 30, interval = 1 )
-    key = lock_key( key_to_lock )
-    until redis.setnx key, timeout_i( expiration )
-      if redis.get( key ).to_i < Time.now.to_i
-        old_timeout = redis.getset( key, timeout_i( expiration ) ).to_i
-        if old_timeout < Time.now.to_i
-          return # got it!
+    # Acquire a lock on a key in our Redis database. This is a blocking
+    # call. It sleeps until the lock has been successfully acquired.
+    #
+    # Basic usage:
+    #
+    #   acquire_redis_lock( key.my_key )
+    #   # do some stuff on my_key
+    #   release_redis_lock( key.my_key )
+    #
+    # Described in detail here:
+    #
+    #   http://code.google.com/p/redis/wiki/SetnxCommand
+    #
+    # key_to_lock - the key to lock. the actual key for the lock in redis will
+    #               be this value with 'lock.' prepended, which lets this whole
+    #               acquire_lock business act like a standard ruby object or
+    #               synchronize lock. Also it ensures that all locks in the database
+    #               can be easily viewed using redis.keys("lock.*")
+    #
+    # expiration  - the expiration for the lock, expressed as an Integer. default is
+    #               30 seconds from when the lock is acquired. Note that this is the
+    #               amount of time others will wait for you, not the amount of time
+    #               you will wait to acquire the lock.
+    #
+    # interval    - sleep interval for checking the lock's status.
+    #   
+    # Returns nothing.
+    def acquire_redis_lock( key_to_lock, expiration = 30, interval = 1 )
+      key = lock_key( key_to_lock )
+      until redis.setnx key, timeout_i( expiration )
+        if redis.get( key ).to_i < Time.now.to_i
+          old_timeout = redis.getset( key, timeout_i( expiration ) ).to_i
+          if old_timeout < Time.now.to_i
+            return # got it!
+          end
+        else
+          sleep interval
         end
-      else
-        sleep interval
       end
     end
-  end
 
-  # Acquire a redis lock only if it can be acquired
-  # is a nonblocking action
-  #
-  # Returns true on success and false on failure
-  def acquire_redis_lock_nonblock( key_to_lock, expiration = 30 ) 
-    key = lock_key( key_to_lock ) 
-    redis.setnx key, timeout_i( expiration )
-  end
-  
-  # See docs for acquire_redis_lock above
-  #
-  # Returns nothing.
-  def release_redis_lock( locked_key )
-    redis.del lock_key( locked_key )
-  end
+    # Acquire a redis lock only if it can be acquired
+    # is a nonblocking action
+    #
+    # Returns true on success and false on failure
+    def acquire_redis_lock_nonblock( key_to_lock, expiration = 30 ) 
+      key = lock_key( key_to_lock ) 
+      redis.setnx key, timeout_i( expiration )
+    end
+    
+    # See docs for acquire_redis_lock above
+    #
+    # Returns nothing.
+    def release_redis_lock( locked_key )
+      redis.del lock_key( locked_key )
+    end
 
-  def has_redis_lock?( locked_key )
-    redis.exists lock_key(locked_key) 
-  end
+    def has_redis_lock?( locked_key )
+      redis.exists lock_key(locked_key) 
+    end
 
-  private
+    private
 
-  def lock_key( key_to_lock )
-    "lock.#{key_to_lock}"
-  end
+    def lock_key( key_to_lock )
+      "lock.#{key_to_lock}"
+    end
 
-  # Converts an Integer number of seconds into a future timestamp that
-  # can be used with Redis.
-  #
-  # Examples
-  # 
-  #   timeout_i(expiration)
-  #   # => 1274955869
-  #
-  # Returns the timestamp.
-  def timeout_i( timeout )
-    timeout.seconds.from_now.to_i
-  end
+    # Converts an Integer number of seconds into a future timestamp that
+    # can be used with Redis.
+    #
+    # Examples
+    # 
+    #   timeout_i(expiration)
+    #   # => 1274955869
+    #
+    # Returns the timestamp.
+    def timeout_i( timeout )
+      timeout.seconds.from_now.to_i
+    end
 
+  end
 end

data/test/test_redis_support.rb

@@ -52,8 +52,13 @@ context "Redis Support" do
   end
 
   test "redis keys are not created if the keyname was previously used" do
-    assert_raise(RedisSupport::DuplicateRedisKeyDefinitionError) do
-      TestClass.redis_key :test_var, "this:should:fail"
+    # assert_raise(RedisSupport::DuplicateRedisKeyDefinitionError) do
+    #   TestClass.redis_key :test_var, "this:should:fail"
+    # end
+    
+    # we are currently not using this feature
+    assert_nothing_raised do
+      TestClass.redis_key :test_var, "this:shouldnot:fail:anymore"
     end
   end
 
@@ -113,3 +118,24 @@ context "Including Redis Support" do
     end
   end
 end
+
+
+context "Including Redis Support in Module" do
+  setup do
+    RedisSupport.redis = Redis.new(:port => 9999, :host => "localhost")
+    
+    module FooBar
+      include RedisSupport
+      extend self
+
+      redis_key :tester, "testing:include"
+    end
+
+    FooBar.redis = "localhost:1234"
+  end
+
+  test "the include of RedisSupport in a module" do
+    assert_equal 1234, FooBar.redis.client.port
+    assert_equal 9999, RedisSupport.redis.client.port
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: redis_support
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 13
   prerelease: false
   segments: 
   - 0
   - 0
-  - 6
-  version: 0.0.6
+  - 9
+  version: 0.0.9
 platform: ruby
 authors: 
 - Brian P O'Rourke
@@ -16,12 +16,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-23 00:00:00 -07:00
+date: 2010-06-24 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: redis
-  prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -34,6 +32,8 @@ dependencies:
         - 4
         version: 1.0.4
   type: :runtime
+  name: redis
+  prerelease: false
   version_requirements: *id001
 description: "Module for adding redis functionality to classes: simple key namespacing and locking and connections"
 email: dolores@doloreslabs.com