redlock 0.2.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 70744bd95881adacc0fc6623a3ba75ee0840339e
-  data.tar.gz: 3b5b971c30395079d645eab57504ba002b7bed61
+  metadata.gz: 12311731641f60b7873ced7fcb039d073fc21525
+  data.tar.gz: 58bc941bc7bbebc10b3fcc32a32e970c3abcefe8
 SHA512:
-  metadata.gz: 3e468fb7a3a98f4cb896a8d6ac6bed4ed25574ae20b6bd9f66c478674f8a3346404dcfc063bc82e74c1669e3e5402f8b1423e381c6e520073baf652b38ef69b1
-  data.tar.gz: 91506cfd3c6913f84cb50ce243ad13e4b9c4593a093872f83ac9518227ca477416f022b564f4aaa9004dab6c6f083614934283f58219b0970aa0cb33140d27f7
+  metadata.gz: 719b17fb2701e48d3f574f198bafd078fd0f9b6ec91f686e4ece547e222c1b4bf09f5ee94868f1d1417c2e6c87d5c3b4742a185c13bb005fc83d868b2b5d0bc1
+  data.tar.gz: cc759db7fe3ba5f8cf09f1f1427564d1c338a97dc1959304e7fdc561f2817e5f133a54b381382ca1b96712e3109f41247ffa5da4a40bf6fd05a8bfb2d875832b

data/Gemfile.lock

@@ -1,23 +1,23 @@
 PATH
   remote: .
   specs:
-    redlock (0.2.2)
+    redlock (1.0.0)
       redis (>= 3.0.0, < 5.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    coveralls (0.8.19)
+    coveralls (0.8.22)
       json (>= 1.8, < 3)
-      simplecov (~> 0.12.0)
+      simplecov (~> 0.16.1)
       term-ansicolor (~> 1.3)
-      thor (~> 0.19.1)
+      thor (~> 0.19.4)
       tins (~> 1.6)
     diff-lcs (1.3)
-    docile (1.1.5)
-    json (2.0.3)
+    docile (1.3.1)
+    json (2.1.0)
     rake (11.3.0)
-    redis (4.0.1)
+    redis (4.0.3)
     rspec (3.5.0)
       rspec-core (~> 3.5.0)
       rspec-expectations (~> 3.5.0)
@@ -31,24 +31,24 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.5.0)
     rspec-support (3.5.0)
-    simplecov (0.12.0)
-      docile (~> 1.1.0)
+    simplecov (0.16.1)
+      docile (~> 1.1)
       json (>= 1.8, < 3)
       simplecov-html (~> 0.10.0)
-    simplecov-html (0.10.0)
-    term-ansicolor (1.4.0)
+    simplecov-html (0.10.2)
+    term-ansicolor (1.6.0)
       tins (~> 1.0)
     thor (0.19.4)
-    tins (1.13.0)
+    tins (1.16.3)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  coveralls (~> 0.8.13)
+  coveralls (~> 0.8)
   rake (~> 11.1, >= 11.1.2)
   redlock!
   rspec (~> 3, >= 3.0.0)
 
 BUNDLED WITH
-   1.16.0
+   1.17.2

data/README.md

@@ -43,30 +43,27 @@ Or install it yourself as:
 
 ## Usage example
 
+### Acquiring a lock
+
 ```ruby
   # Locking
   lock_manager = Redlock::Client.new([ "redis://127.0.0.1:7777", "redis://127.0.0.1:7778", "redis://127.0.0.1:7779" ])
   first_try_lock_info = lock_manager.lock("resource_key", 2000)
   second_try_lock_info = lock_manager.lock("resource_key", 2000)
 
-  # it prints lock info {validity: 1987, resource: "resource_key", value: "generated_uuid4"}
   p first_try_lock_info
-  # it prints false
+  # => {validity: 1987, resource: "resource_key", value: "generated_uuid4"}
+
   p second_try_lock_info
+  # => false
 
   # Unlocking
   lock_manager.unlock(first_try_lock_info)
+
   second_try_lock_info = lock_manager.lock("resource_key", 2000)
 
-  # now it prints lock info
   p second_try_lock_info
-```
-
-Redlock works seamlessly with [redis sentinel](http://redis.io/topics/sentinel), which is supported in redis 3.2+. It also allows clients to set any other arbitrary options on the Redis connection, e.g. password, driver, and more.
-
-```ruby
-servers = [ 'redis://localhost:6379', Redis.new(:url => 'redis://someotherhost:6379') ]
-redlock = Redlock::Client.new(servers)
+  # => {validity: 1962, resource: "resource_key", value: "generated_uuid5"}
 ```
 
 There's also a block version that automatically unlocks the lock:
@@ -81,7 +78,7 @@ lock_manager.lock("resource_key", 2000) do |locked|
 end
 ```
 
-There's also a bang version that only executes the block if the lock is successfully acquired, returning the block's value as a result, or raising an exception otherwise:
+There's also a bang version that only executes the block if the lock is successfully acquired, returning the block's value as a result, or raising an exception otherwise. Passing a block is mandatory.
 
 ```ruby
 begin
@@ -93,34 +90,43 @@ rescue Redlock::LockError
 end
 ```
 
+### Extending a lock
+
 To extend the life of the lock:
 
 ```ruby
 begin
-  block_result = lock_manager.lock!("resource_key", 2000) do |lock_info|
-    # critical code
-    lock_manager.lock("resource key", 3000, extend: lock_info)
-    # more critical code
+  lock_info = lock_manager.lock("resource_key", 2000)
+  while lock_info
+    # Critical code
+
+    # Time up and more work to do? Extend the lock.
+    lock_info = lock_manager.lock("resource key", 3000, extend: lock_info)
   end
 rescue Redlock::LockError
   # error handling
 end
 ```
 
-The above code will also acquire the lock if the previous lock has expired and the lock is currently free. Keep in mind that this means the lock could have been acquired by someone else in the meantime. To only extend the life of the lock if currently locked by yourself, use `extend_life` parameter:
+The above code will also acquire the lock if the previous lock has expired and the lock is currently free. Keep in mind that this means the lock could have been acquired by someone else in the meantime. To only extend the life of the lock if currently locked by yourself, use the `extend_life` parameter:
 
 ```ruby
-begin
-  block_result = lock_manager.lock!("resource_key", 2000) do |lock_info|
-    # critical code
-    lock_manager.lock("resource key", 3000, extend: lock_info, extend_life: true)
-    # more critical code, only if lock was still hold
-  end
-rescue Redlock::LockError
-  # error handling
-end
+lock_manager.lock("resource key", 3000, extend: lock_info, extend_life: true)
+```
+
+## Redis client configuration
+
+`Redlock::Client` expects URLs or Redis objects on initialization. Redis objects should be used for configuring the connection in more detail, i.e. setting username and password.
+
+```ruby
+servers = [ 'redis://localhost:6379', Redis.new(:url => 'redis://someotherhost:6379') ]
+redlock = Redlock::Client.new(servers)
 ```
 
+Redlock works seamlessly with [redis sentinel](http://redis.io/topics/sentinel), which is supported in redis 3.2+.
+
+## Redlock configuration
+
 It's possible to customize the retry logic providing the following options:
 
 ```ruby
@@ -135,7 +141,6 @@ It's possible to customize the retry logic providing the following options:
 
 For more information you can check [documentation](http://www.rubydoc.info/gems/redlock/Redlock%2FClient:initialize).
 
-
 ## Run tests
 
 Make sure you have [docker installed](https://docs.docker.com/engine/installation/).

data/lib/redlock/client.rb

@@ -12,14 +12,27 @@ module Redlock
     DEFAULT_RETRY_JITTER  = 50
     CLOCK_DRIFT_FACTOR    = 0.01
 
+    ##
+    # Returns default time source function depending on CLOCK_MONOTONIC availability.
+    #
+    def self.default_time_source
+      if defined?(Process::CLOCK_MONOTONIC)
+        proc { (Process.clock_gettime(Process::CLOCK_MONOTONIC) * 1000).to_i }
+      else
+        proc { (Time.now.to_f * 1000).to_i }
+      end
+    end
+
     # Create a distributed lock manager implementing redlock algorithm.
     # Params:
     # +servers+:: The array of redis connection URLs or Redis connection instances. Or a mix of both.
-    # +options+:: You can override the default value for `retry_count`, `retry_delay` and `retry_gitter`.
+    # +options+::
     #    * `retry_count`   being how many times it'll try to lock a resource (default: 3)
     #    * `retry_delay`   being how many ms to sleep before try to lock again (default: 200)
     #    * `retry_jitter`  being how many ms to jitter retry delay (default: 50)
     #    * `redis_timeout` being how the Redis timeout will be set in seconds (default: 0.1)
+    #    * `time_source`   being a callable object returning a monotonic time in milliseconds
+    #                      (default: see #default_time_source)
     def initialize(servers = DEFAULT_REDIS_URLS, options = {})
       redis_timeout = options[:redis_timeout] || DEFAULT_REDIS_TIMEOUT
       @servers = servers.map do |server|
@@ -33,6 +46,7 @@ module Redlock
       @retry_count = options[:retry_count] || DEFAULT_RETRY_COUNT
       @retry_delay = options[:retry_delay] || DEFAULT_RETRY_DELAY
       @retry_jitter = options[:retry_jitter] || DEFAULT_RETRY_JITTER
+      @time_source = options[:time_source] || self.class.default_time_source
     end
 
     # Locks a resource for a given time.
@@ -112,6 +126,8 @@ module Redlock
         recover_from_script_flush do
           @redis.evalsha @lock_script_sha, keys: [resource], argv: [val, ttl, allow_new_lock]
         end
+      rescue Redis::CannotConnectError
+        false
       end
 
       def unlock(resource, val)
@@ -149,7 +165,7 @@ module Redlock
     end
 
     def try_lock_instances(resource, ttl, options)
-      tries = options[:extend] ? 1 : @retry_count
+      tries = options[:extend] ? 1 : (@retry_count + 1)
 
       tries.times do |attempt_number|
         # Wait a random delay before retrying.
@@ -188,8 +204,8 @@ module Redlock
     end
 
     def timed
-      start_time = (Time.now.to_f * 1000).to_i
-      [yield, (Time.now.to_f * 1000).to_i - start_time]
+      start_time = @time_source.call()
+      [yield, @time_source.call() - start_time]
     end
   end
 end

data/lib/redlock/version.rb

@@ -1,3 +1,3 @@
 module Redlock
-  VERSION = '0.2.2'
+  VERSION = '1.0.0'
 end

data/redlock.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'redis', '>= 3.0.0', '< 5.0'
 
-  spec.add_development_dependency "coveralls", "~> 0.8.13"
+  spec.add_development_dependency "coveralls", "~> 0.8"
   spec.add_development_dependency 'rake', '~> 11.1', '>= 11.1.2'
   spec.add_development_dependency 'rspec', '~> 3', '>= 3.0.0'
 end

data/spec/client_spec.rb

@@ -1,10 +1,12 @@
 require 'spec_helper'
 require 'securerandom'
+require 'redis'
 
 RSpec.describe Redlock::Client do
   # It is recommended to have at least 3 servers in production
   let(:lock_manager_opts) { { retry_count: 3 } }
   let(:lock_manager) { Redlock::Client.new(Redlock::Client::DEFAULT_REDIS_URLS, lock_manager_opts) }
+  let(:redis_client) { Redis.new }
   let(:resource_key) { SecureRandom.hex(3)  }
   let(:ttl) { 1000 }
   let(:redis1_host) { ENV["REDIS1_HOST"] || "localhost" }
@@ -14,7 +16,6 @@ RSpec.describe Redlock::Client do
 
   describe 'initialize' do
     it 'accepts both redis URLs and Redis objects' do
-      print redis1_host
       servers = [ "redis://#{redis1_host}:#{redis1_port}", Redis.new(url: "redis://#{redis2_host}:#{redis2_port}") ]
       redlock = Redlock::Client.new(servers)
 
@@ -42,6 +43,12 @@ RSpec.describe Redlock::Client do
         expect(@lock_info).to be_lock_info_for(resource_key)
       end
 
+      it 'interprets lock time as milliseconds' do
+        ttl = 20000
+        @lock_info = lock_manager.lock(resource_key, ttl)
+        expect(redis_client.pttl(resource_key)).to be_within(200).of(ttl)
+      end
+
       it 'can extend its own lock' do
         my_lock_info = lock_manager.lock(resource_key, ttl)
         @lock_info = lock_manager.lock(resource_key, ttl, extend: my_lock_info)
@@ -64,6 +71,16 @@ RSpec.describe Redlock::Client do
         end
       end
 
+      it '(when extending) resets the TTL, rather than adding extra time to it' do
+        ttl = 20000
+        lock_info = lock_manager.lock(resource_key, ttl)
+        expect(resource_key).to_not be_lockable(lock_manager, ttl)
+
+        lock_info = lock_manager.lock(resource_key, ttl, extend: lock_info, extend_life: true)
+        expect(lock_info).not_to be_nil
+        expect(redis_client.pttl(resource_key)).to be_within(200).of(ttl)
+      end
+
       context 'when extend_only_if_life flag is not given' do
         it "sets the given value when trying to extend a non-existent lock" do
           @lock_info = lock_manager.lock(resource_key, ttl, extend: {value: 'hello world'}, extend_only_if_life: false)
@@ -95,14 +112,14 @@ RSpec.describe Redlock::Client do
         expect(lock_info).to eql(false)
       end
 
-      it 'retries up to \'retry_count\' times' do
+      it 'tries up to \'retry_count\' + 1 times' do
         expect(lock_manager).to receive(:lock_instances).exactly(
-          lock_manager_opts[:retry_count]).times.and_return(false)
+          lock_manager_opts[:retry_count] + 1).times.and_return(false)
         lock_manager.lock(resource_key, ttl)
       end
 
       it 'sleeps in between retries' do
-        expect(lock_manager).to receive(:sleep).exactly(lock_manager_opts[:retry_count] - 1).times
+        expect(lock_manager).to receive(:sleep).exactly(lock_manager_opts[:retry_count]).times
         lock_manager.lock(resource_key, ttl)
       end
 
@@ -123,6 +140,29 @@ RSpec.describe Redlock::Client do
       end
     end
 
+    context 'when a server goes away' do
+      it 'does not raise an error on connection issues' do
+        # We re-route the lock manager to a (hopefully) non-existent Redis URL.
+        redis_instance = lock_manager.instance_variable_get(:@servers).first
+        redis_instance.instance_variable_set(:@redis, Redis.new(url: 'redis://localhost:46864'))
+
+        expect {
+          expect(lock_manager.lock(resource_key, ttl)).to be_falsey
+        }.to_not raise_error
+      end
+    end
+
+    context 'when a server comes back' do
+      it 'recovers from connection issues' do
+        # Same as above.
+        redis_instance = lock_manager.instance_variable_get(:@servers).first
+        redis_instance.instance_variable_set(:@redis, Redis.new(url: 'redis://localhost:46864'))
+        expect(lock_manager.lock(resource_key, ttl)).to be_falsey
+        redis_instance.instance_variable_set(:@redis, Redis.new(url: "redis://#{redis1_host}:#{redis1_port}"))
+        expect(lock_manager.lock(resource_key, ttl)).to be_truthy
+      end
+    end
+
     context 'when script cache has been flushed' do
       before(:each) do
         @manipulated_instance = lock_manager.instance_variable_get(:@servers).first
@@ -267,4 +307,23 @@ RSpec.describe Redlock::Client do
       end
     end
   end
+
+  describe '#default_time_source' do
+    context 'when CLOCK_MONOTONIC is available (MRI, JRuby)' do
+      it 'returns a callable using Process.clock_gettime()' do
+        skip 'CLOCK_MONOTONIC not defined' unless defined?(Process::CLOCK_MONOTONIC)
+        expect(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_call_original
+        Redlock::Client.default_time_source.call()
+      end
+    end
+
+    context 'when CLOCK_MONOTONIC is not available' do
+      it 'returns a callable using Time.now()' do
+        cm = Process.send(:remove_const, :CLOCK_MONOTONIC)
+        expect(Time).to receive(:now).and_call_original
+        Redlock::Client.default_time_source.call()
+        Process.const_set(:CLOCK_MONOTONIC, cm) if cm
+      end
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -41,3 +41,11 @@ RSpec::Matchers.define :be_lockable do |lock_manager, ttl|
     "expected that #{resource_key} would be lockable"
   end
 end
+
+RSpec.configure do |c|
+  # NOTE: this protects against erroneous "focus: true" commits
+  unless ENV['CI'] == 'true'
+    c.filter_run focus: true
+    c.run_all_when_everything_filtered = true
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redlock
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Leandro Moreira
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-22 00:00:00.000000000 Z
+date: 2018-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -36,14 +36,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.13
+        version: '0.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.13
+        version: '0.8'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -131,7 +131,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2.1
+rubygems_version: 2.5.2.3
 signing_key: 
 specification_version: 4
 summary: Distributed lock using Redis written in Ruby.