redlock 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3ee0172835a0683dc875747ab8e69c893d63d5ad
-  data.tar.gz: be871d82dfeba63e0c602378fabd6e78e245fa2e
+  metadata.gz: 89b482115278216ae9e620ce8f7430bf4fe36715
+  data.tar.gz: 75f2da7d8d167fea72815ca9e4ea3242425dfd9a
 SHA512:
-  metadata.gz: da22d2d16562ffb6a35756bd356b2c6c27941049083596d1f5f9bb1315f3b0e0f316d1e4ae91a6b7ee5216b35c4c821f56c862080ad51f936dbb6641cb4916ec
-  data.tar.gz: 688aaa7b6474f3c399dbebd647b3daef565a076df5a0967a492b45227b1407ce56972d26f4bbe1ddd10104b1aaddfcc97729678b10ce11e547c3da9970d052db
+  metadata.gz: 33c9ef53d6833e461ac6c805748fcf20923f29e2fde681c684992cd2ff2fe607d84b5e17b95515331470bce0aa39a7662e5f5dc7a83941a17c9b647072145742
+  data.tar.gz: 068c9b13201e315d9060ed6e646f1e19a6371a0892ece0d9f2fd719d45dee65aa622324a25d06a290e5e56638079f91da58d97fb2b214eea0c2230c185cc6ca4

data/.gitignore

@@ -1 +1,2 @@
 *.gem
+coverage/

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+services:
+    - redis-server
+rvm:
+  - "1.9.2"
+  - "1.9.3"
+  - "2.0.0"
+script: bundle exec rspec spec

data/Gemfile.lock

@@ -2,12 +2,27 @@ PATH
   remote: .
   specs:
     redlock (0.0.1)
+      redis (~> 3, >= 3.0.5)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    coveralls (0.7.11)
+      multi_json (~> 1.10)
+      rest-client (>= 1.6.8, < 2)
+      simplecov (~> 0.9.1)
+      term-ansicolor (~> 1.3)
+      thor (~> 0.19.1)
     diff-lcs (1.2.5)
+    docile (1.1.5)
+    mime-types (2.4.3)
+    multi_json (1.11.0)
+    netrc (0.10.3)
     rake (10.3.2)
+    redis (3.2.1)
+    rest-client (1.7.3)
+      mime-types (>= 1.16, < 3.0)
+      netrc (~> 0.7)
     rspec (3.1.0)
       rspec-core (~> 3.1.0)
       rspec-expectations (~> 3.1.0)
@@ -20,12 +35,22 @@ GEM
     rspec-mocks (3.1.3)
       rspec-support (~> 3.1.0)
     rspec-support (3.1.2)
+    simplecov (0.9.2)
+      docile (~> 1.1.0)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.9.0)
+    simplecov-html (0.9.0)
+    term-ansicolor (1.3.0)
+      tins (~> 1.0)
+    thor (0.19.1)
+    tins (1.3.5)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   bundler (~> 1.7)
+  coveralls
   rake (~> 10.0)
   redlock!
-  rspec (~> 3.1.0)
+  rspec (~> 3.1)

data/README.md

@@ -1,10 +1,10 @@
-# RedlockRb - A ruby distributed lock using redis.
+# Redlock - A ruby distributed lock using redis.
 
-Distributed locks are a very useful primitive in many environments where different processes require to operate with shared resources in a mutually exclusive way.
+> Distributed locks are a very useful primitive in many environments where different processes require to operate  with shared resources in a mutually exclusive way.
+> 
+> There are a number of libraries and blog posts describing how to implement a DLM (Distributed Lock Manager) with Redis, but every library uses a different approach, and many use a simple approach with lower guarantees compared to what can be achieved with slightly more complex designs.
 
-There are a number of libraries and blog posts describing how to implement a DLM (Distributed Lock Manager) with Redis, but every library uses a different approach, and many use a simple approach with lower guarantees compared to what can be achieved with slightly more complex designs.
-
-This lib is an attempt to provide an implementation to a proposed distributed locks with Redis. Totally inspired by: ( http://redis.io/topics/distlock )
+This is an implementation of a proposed [distributed lock algorithm with Redis](http://redis.io/topics/distlock). It started as a fork from [antirez implementation.](https://github.com/antirez/redlock-rb)
 
 ## Installation
 
@@ -22,6 +22,10 @@ Or install it yourself as:
 
     $ gem install redlock
 
+## Documentation
+
+[RubyDoc 0.0.1](http://www.rubydoc.info/gems/redlock/0.0.1/frames)
+
 ## Usage example
 
 ```ruby
@@ -30,7 +34,7 @@ Or install it yourself as:
   first_try_lock_info = lock_manager.lock("resource_key", 2000)
   second_try_lock_info = lock_manager.lock("resource_key", 2000)
 
-  # it prints lock info
+  # it prints lock info {validity: 1987, resource: "resource_key", value: "generated_uuid4"}
   p first_try_lock_info
   # it prints false
   p second_try_lock_info
@@ -43,6 +47,18 @@ Or install it yourself as:
   p second_try_lock_info
 ```
 
+There's also a block version that automatically unlocks the lock:
+
+```ruby
+lock_manager.lock("resource_key", 2000) do |locked|
+  if locked
+    # critical code
+  else
+    # error handling
+  end
+end
+```
+
 ## Run tests
 
 Make sure you have at least 3 redis instances `redis-server --port 777[7-9]`
@@ -51,7 +67,7 @@ Make sure you have at least 3 redis instances `redis-server --port 777[7-9]`
 
 ## Contributing
 
-1. Fork it ( https://github.com/leandromoreira/redlock_rb/fork )
+1. [Fork it](https://github.com/leandromoreira/redlock-rb/fork)
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/lib/redlock/client.rb

@@ -3,6 +3,7 @@ require 'securerandom'
 
 module Redlock
   class Client
+    DEFAULT_REDIS_URLS  = ['redis://localhost:6379']
     DEFAULT_RETRY_COUNT = 3
     DEFAULT_RETRY_DELAY = 200
     CLOCK_DRIFT_FACTOR = 0.01
@@ -20,7 +21,7 @@ module Redlock
     # +options+:: You can override the default value for `retry_count` and `retry_delay`.
     #    * `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)
-    def initialize(server_urls, options={})
+    def initialize(server_urls=DEFAULT_REDIS_URLS, options={})
       @servers = server_urls.map {|url| Redis.new(url: url)}
       @quorum = server_urls.length / 2 + 1
       @retry_count = options[:retry_count] || DEFAULT_RETRY_COUNT
@@ -29,11 +30,35 @@ module Redlock
 
     # Locks a resource for a given time. (in milliseconds)
     # Params:
-    # +resource+:: the resource(or key) string to be locked.
+    # +resource+:: the resource (or key) string to be locked.
     # +ttl+:: The time-to-live in ms for the lock.
-    def lock(resource, ttl)
+    def lock(resource, ttl, &block)
+      lock_info = lock_instances(resource, ttl)
+
+      if block_given?
+        begin
+          yield lock_info
+          !!lock_info
+        ensure
+          unlock(lock_info) if lock_info
+        end
+      else
+        lock_info
+      end
+    end
+
+    # Unlocks a resource.
+    # Params:
+    # +lock_info+:: the lock that has been acquired when you locked the resource.
+    def unlock(lock_info)
+      @servers.each{|s| unlock_instance(s, lock_info[:resource], lock_info[:value])}
+    end
+
+    private
+
+    def lock_instances(resource, ttl)
       value = SecureRandom.uuid
-      @retry_count.times {
+      @retry_count.times do
         locked_instances = 0
         start_time = (Time.now.to_f * 1000).to_i
         @servers.each do |s|
@@ -55,18 +80,11 @@ module Redlock
         end
         # Wait a random delay before to retry
         sleep(rand(@retry_delay).to_f / 1000)
-      }
-      return false
-    end
+      end
 
-    # Unlocks a resource.
-    # Params:
-    # +lock_info+:: the has acquired when you locked the resource.
-    def unlock(lock_info)
-      @servers.each{|s| unlock_instance(s, lock_info[:resource], lock_info[:value])}
+      return false
     end
 
-    private
     def lock_instance(redis, resource, val, ttl)
       begin
         return redis.client.call([:set, resource, val, :nx, :px, ttl])

data/lib/redlock/version.rb

@@ -1,3 +1,3 @@
 module Redlock
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/redlock.gemspec

@@ -18,7 +18,10 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.add_dependency 'redis', '~> 3', '>= 3.0.5'
+
   spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "coveralls"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.1"
 end

data/spec/client_spec.rb

@@ -1,25 +1,97 @@
 require 'spec_helper'
+require 'securerandom'
 
 RSpec.describe Redlock::Client do
-  let(:lock_manager) { Redlock::Client.new([ "redis://127.0.0.1:7777", "redis://127.0.0.1:7778", "redis://127.0.0.1:7779" ]) }
-  let(:resource_key) { "foo" }
+  # It is recommended to have at least 3 servers in production
+  let(:lock_manager) { Redlock::Client.new }
+  let(:resource_key) { SecureRandom.hex(3)  }
   let(:ttl) { 1000 }
 
-  it 'locks' do
-    first_try_lock_info = lock_manager.lock(resource_key, ttl)
-    second_try_lock_info = lock_manager.lock(resource_key, ttl)
+  describe 'lock' do
+    context 'when lock is available' do
+      after(:each) { lock_manager.unlock(@lock_info) if @lock_info }
 
-    expect(first_try_lock_info[:resource]).to eq("foo")
-    expect(second_try_lock_info).to be_falsy
+      it 'locks' do
+        @lock_info = lock_manager.lock(resource_key, ttl)
 
-    lock_manager.unlock(first_try_lock_info)
+        expect(resource_key).to_not be_lockable(lock_manager, ttl)
+      end
+
+      it 'returns lock information' do
+        @lock_info = lock_manager.lock(resource_key, ttl)
+
+        expect(@lock_info).to be_lock_info_for(resource_key)
+      end
+    end
+
+    context 'when lock is not available' do
+      before { @another_lock_info = lock_manager.lock(resource_key, ttl) }
+      after { lock_manager.unlock(@another_lock_info) }
+
+      it 'returns false' do
+        lock_info = lock_manager.lock(resource_key, ttl)
+
+        expect(lock_info).to eql(false)
+      end
+    end
+
+    describe 'block syntax' do
+      context 'when lock is available' do
+        it 'locks' do
+          lock_manager.lock(resource_key, ttl) do |_|
+            expect(resource_key).to_not be_lockable(lock_manager, ttl)
+          end
+        end
+
+        it 'passes lock information as block argument' do
+          lock_manager.lock(resource_key, ttl) do |lock_info|
+            expect(lock_info).to be_lock_info_for(resource_key)
+          end
+        end
+
+        it 'returns true' do
+          rv = lock_manager.lock(resource_key, ttl) {}
+          expect(rv).to eql(true)
+        end
+
+        it 'automatically unlocks' do
+          lock_manager.lock(resource_key, ttl) {}
+          expect(resource_key).to be_lockable(lock_manager, ttl)
+        end
+
+        it 'automatically unlocks when block raises exception' do
+          lock_manager.lock(resource_key, ttl) { fail } rescue nil
+          expect(resource_key).to be_lockable(lock_manager, ttl)
+        end
+      end
+
+      context 'when lock is not available' do
+        before { @another_lock_info = lock_manager.lock(resource_key, ttl) }
+        after { lock_manager.unlock(@another_lock_info) }
+
+        it 'passes false as block argument' do
+          lock_manager.lock(resource_key, ttl) do |lock_info|
+            expect(lock_info).to eql(false)
+          end
+        end
+
+        it 'returns false' do
+          rv = lock_manager.lock(resource_key, ttl) {}
+          expect(rv).to eql(false)
+        end
+      end
+    end
   end
 
-  it 'unlocks' do
-    lock_info = lock_manager.lock(resource_key, ttl)
-    lock_manager.unlock(lock_info)
-    another_lock_info = lock_manager.lock(resource_key, ttl)
+  describe 'unlock' do
+    before { @lock_info = lock_manager.lock(resource_key, ttl) }
+
+    it 'unlocks' do
+      expect(resource_key).to_not be_lockable(lock_manager, ttl)
+
+      lock_manager.unlock(@lock_info)
 
-    expect(another_lock_info[:resource]).to eq("foo")
+      expect(resource_key).to be_lockable(lock_manager, ttl)
+    end
   end
 end

data/spec/spec_helper.rb

@@ -1,3 +1,44 @@
 # coding: utf-8
 # $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'coveralls'
+Coveralls.wear!
 require 'redlock'
+
+LOCK_INFO_KEYS = %i{validity resource value}
+
+RSpec::Matchers.define :be_lock_info_for do |resource|
+  def correct_type?(actual)
+    actual.is_a?(Hash)
+  end
+
+  def correct_layout?(actual)
+    ((LOCK_INFO_KEYS | actual.keys) - (LOCK_INFO_KEYS & actual.keys)).empty?
+  end
+
+  def correct_resource?(actual, resource)
+    actual[:resource] == resource
+  end
+
+  match do |actual|
+    correct_type?(actual) && correct_layout?(actual) && correct_resource?(actual, resource)
+  end
+
+  failure_message do |actual|
+    "expected that #{actual} would be lock information for #{expected}"
+  end
+end
+
+RSpec::Matchers.define :be_lockable do |lock_manager, ttl|
+  match do |resource_key|
+    begin
+      lock_info = lock_manager.lock(resource_key, ttl)
+      lock_info != false
+    ensure
+      lock_manager.unlock(lock_info) if lock_info
+    end
+  end
+
+  failure_message do |resource_key|
+    "expected that #{resource_key} would be lockable"
+  end
+end

metadata

@@ -1,55 +1,89 @@
 --- !ruby/object:Gem::Specification
 name: redlock
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Leandro Moreira
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-13 00:00:00.000000000 Z
+date: 2015-03-19 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.5
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '3.1'
 description: Distributed lock using Redis written in Ruby. Highly inspired by https://github.com/antirez/redlock-rb.
@@ -59,8 +93,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".rspec"
+- .gitignore
+- .rspec
+- .travis.yml
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -82,17 +117,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: Distributed lock using Redis written in Ruby.