redis-objects 1.4.0 → 1.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: b251574cff0d3540f3cf018eb1b8bc0a5fa84ff8
-  data.tar.gz: 0415ef6e0c853df6a864dcf994b5b644cd2fb722
+SHA256:
+  metadata.gz: 7d42c057174f5a48560f104f08c5cf9bb25bd1772dd0684912a0094c4158840b
+  data.tar.gz: a0f945a9aede01c5623486576444c370cacd0e8a4fa2315511e7c1245339e489
 SHA512:
-  metadata.gz: 76da3c02a6cbd7b221bd2b53dad1fdf54d3ad8efebb26c7e6fc79be8f5775c37113c572facfb362820f255b2fad94cef7eeb8010a24ab0a7c54f2f94cd4c20c1
-  data.tar.gz: 588c4caa7ff2518b190d6970d3725d48caac5d1f9ad8faef894c815d9cf97716cdacff58acefb545d47df37c8129cdcb1dd108d7f6ab5d328b9be7fb744e791f
+  metadata.gz: 7dec3f8e9925f49601f629786a2e01ff4524483235831fc4afe02d7dd7491fb7723a8a3bf0b8034712c2bba6c9071ad00c03c214ffe5e7ddfed9e0749fb48ab4
+  data.tar.gz: 7055d7720a3512215a9e3f63426ffe4d81ff06ce4d118a2e6ce05193362cd50052e95269cd2aa56e8a97703ad1349181d5790e2e7aedbc13d04e68f84f2597b6

data/.travis.yml

@@ -5,9 +5,7 @@ before_install:
   - gem install bundler
 
 rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1
   - 2.2
   - 2.3.3
   - 2.4.0
+  - 2.5.1

data/lib/redis/list.rb

@@ -29,8 +29,9 @@ class Redis
     # Add a member to the end of the list. Redis: RPUSH
     def push(*values)
       allow_expiration do
-        redis.rpush(key, values.map{|v| marshal(v) })
+        count = redis.rpush(key, values.map{|v| marshal(v) })
         redis.ltrim(key, -options[:maxlength], -1) if options[:maxlength]
+        count
       end
     end
 
@@ -62,8 +63,9 @@ class Redis
     # Add a member to the start of the list. Redis: LPUSH
     def unshift(*values)
       allow_expiration do
-        redis.lpush(key, values.map{|v| marshal(v) })
+        count = redis.lpush(key, values.map{|v| marshal(v) })
         redis.ltrim(key, 0, options[:maxlength] - 1) if options[:maxlength]
+        count
       end
     end
 

data/lib/redis/lock.rb

@@ -33,28 +33,28 @@ class Redis
     # 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)
-      expiration = nil
+    def lock
+      raise ArgumentError, 'Block not given' unless block_given?
+      expiration = generate_expiration
+      end_time = nil
       try_until_timeout do
-        expiration = generate_expiration
-        # Use the expiration as the value of the lock.
-        break if redis.setnx(key, expiration)
+        end_time = Time.now.to_i + expiration
+        # 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, nx: true)
 
-        # Lock is being held.  Now check to see if it's expired (if we're using
-        # lock expiration).
-        # See "Handling Deadlocks" section on http://redis.io/commands/setnx
-        if !@options[:expiration].nil?
+        # Backward compatibility code
+        # TODO: remove at the next major release for performance
+        unless @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.
+          # 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 = 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.
-            break if old_expiration < Time.now.to_f
+            end_time = Time.now.to_i + expiration
+            break if redis.set(key, nil, px: expiration)
           end
         end
       end
@@ -66,14 +66,15 @@ class Redis
         # 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
+        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 : (Time.now + @options[:expiration].to_f + 1).to_f
+      ((@options[:expiration].nil? ? 1 : @options[:expiration].to_f) * 1000).to_i
     end
 
     private

data/lib/redis/objects.rb

@@ -61,10 +61,11 @@ class Redis
 
     class << self
       def redis=(conn)
-        @redis = Objects::ConnectionPoolProxy.proxy_if_needed(conn)
+        Thread.current[:__redis_objects_redis] = Objects::ConnectionPoolProxy.proxy_if_needed(conn)
       end
+
       def redis
-        @redis || $redis || Redis.current ||
+        Thread.current[:__redis_objects_redis] || $redis || Redis.current ||
           raise(NotConnected, "Redis::Objects.redis not set to a Redis.new connection")
       end
 
@@ -90,11 +91,11 @@ class Redis
     module ClassMethods
       # Enable per-class connections (eg, User and Post can use diff redis-server)
       def redis=(conn)
-        @redis = Objects::ConnectionPoolProxy.proxy_if_needed(conn)
+        Thread.current[:__redis_objects_redis] = Objects::ConnectionPoolProxy.proxy_if_needed(conn)
       end
 
       def redis
-        @redis || Objects.redis
+        Thread.current[:__redis_objects_redis] || Objects.redis
       end
 
       # Internal list of objects

data/lib/redis/objects/version.rb

@@ -1,5 +1,5 @@
 class Redis
   module Objects
-    VERSION = "1.4.0"
+    VERSION = "1.4.2"
   end
 end

data/spec/redis_objects_conn_spec.rb

@@ -41,6 +41,21 @@ describe 'Connection tests' do
     obj.default_redis_value.clear
   end
 
+  it "should be thread-safe when setting Redis::Objects.redis connection" do
+    Redis::Objects.redis = Redis.new(:host => REDIS_HOST, :port => REDIS_PORT, :db => 23)
+
+    thr = Thread.new do
+      Redis::Objects.redis = Redis.new(:host => REDIS_HOST, :port => REDIS_PORT, :db => 24)
+      Redis::Objects.redis.connection[:id].ends_with?("/24").should == true
+    end
+
+    Redis::Objects.redis.connection[:id].ends_with?("/23").should == true
+
+    thr.join
+
+    Redis::Objects.redis.connection[:id].ends_with?("/23").should == true
+  end
+
   it "should support mget" do
     class CustomConnectionObject
       include Redis::Objects

data/spec/redis_objects_instance_spec.rb

@@ -568,16 +568,15 @@ describe Redis::Lock do
     REDIS_HANDLE.flushall
   end
 
-  it "should set the value to the expiration" do
-    start = Time.now
+  it "should ttl to the expiration" do
     expiry = 15
     lock = Redis::Lock.new(:test_lock, :expiration => expiry)
     lock.lock do
-      expiration = REDIS_HANDLE.get("test_lock").to_f
+      expiration = REDIS_HANDLE.ttl("test_lock")
 
       # The expiration stored in redis should be 15 seconds from when we started
       # or a little more
-      expiration.should.be.close((start + expiry).to_f, 2.0)
+      expiration.should.be.close(expiration, 2.0)
     end
 
     # key should have been cleaned up
@@ -587,30 +586,13 @@ describe Redis::Lock do
   it "should set value to 1 when no expiration is set" do
     lock = Redis::Lock.new(:test_lock)
     lock.lock do
-      REDIS_HANDLE.get('test_lock').should == '1'
+      REDIS_HANDLE.ttl('test_lock').should == 1
     end
 
     # key should have been cleaned up
     REDIS_HANDLE.get("test_lock").should.be.nil
   end
 
-  it "should let lock be gettable when lock is expired" do
-    expiry = 15
-    lock = Redis::Lock.new(:test_lock, :expiration => expiry, :timeout => 0.1)
-
-    # create a fake lock in the past
-    REDIS_HANDLE.set("test_lock", Time.now-(expiry + 60))
-
-    gotit = false
-    lock.lock do
-      gotit = true
-    end
-
-    # should get the lock because it has expired
-    gotit.should.be.true
-    REDIS_HANDLE.get("test_lock").should.be.nil
-  end
-
   it "should not let non-expired locks be gettable" do
     expiry = 15
     lock = Redis::Lock.new(:test_lock, :expiration => expiry, :timeout => 0.1)
@@ -636,15 +618,15 @@ describe Redis::Lock do
     REDIS_HANDLE.get("test_lock").should.not.be.nil
   end
 
-  it "should not remove the key if lock is held past expiration" do
-    lock = Redis::Lock.new(:test_lock, :expiration => 0.0)
+  it "Redis should remove the key if lock is held past expiration" do
+    lock = Redis::Lock.new(:test_lock, :expiration => 0.1)
 
     lock.lock do
-      sleep 1.1
+      sleep 0.2
     end
 
     # lock value should still be set since the lock was held for more than the expiry
-    REDIS_HANDLE.get("test_lock").should.not.be.nil
+    REDIS_HANDLE.get("test_lock").should.be.nil
   end
 
   it "should respond to #to_json" do
@@ -654,6 +636,26 @@ describe Redis::Lock do
   it "should respond to #as_json" do
     Redis::Lock.new(:test_lock).as_json.should.be.kind_of(Hash)
   end
+
+  it "should deal with old lock format" do
+    expiry = 15
+    lock = Redis::Lock.new(:test_lock, expiration: expiry, timeout: 0.1)
+
+    # create a fake lock in the past
+    REDIS_HANDLE.set("test_lock", (Time.now - expiry).to_f)
+
+    gotit = false
+    lock.lock do
+      gotit = true
+    end
+
+    # should have the lock
+    gotit.should.be.true
+
+    # lock value should be unset
+    REDIS_HANDLE.get("test_lock").should.be.nil
+  end
+
 end
 
 describe Redis::HashKey do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-objects
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.4.2
 platform: ruby
 authors:
 - Nate Wiger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-07 00:00:00.000000000 Z
+date: 2018-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -185,7 +185,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: Map Redis types directly to Ruby objects