redis_lock 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: be7ac8c0aec7de8f0d4d6a86b4a1455a6f9aef61
-  data.tar.gz: 9861b4a0a873da471fac752e00ff426821f03715
+  metadata.gz: 03eb17313451ab7a8dfa1cffa18f79f7e87df368
+  data.tar.gz: 36611216461166a026bc525452720ccbc30be78c
 SHA512:
-  metadata.gz: 499d274f428e55d2db225f5cd92caab91b79533aaf090217b38dbc5d4dd515ff254fc9227ee6bef79ecb366e37758d476c685d41040c52e14970559418c3aa68
-  data.tar.gz: 6c239f00a424665dc5e075779685f3206faf9cf0b199dcd025e9c6ec3a76df22c42cd1cc66fdb5430fabeaff581eef3a593e090acab61c8a2d19daccfc9f1c2f
+  metadata.gz: b48fc19c007834779835bffab3abfa4cba58573f6963f87ae70affcef14b350f8a5ef06fb81e59360f04a4bf47ed56516cd28fa3b0291389c0248524543aabe5
+  data.tar.gz: 6b17f6e912c9f445a3243a1c4dff1b862a0371442a360ca68e3d9875d349529c120ca34e7b7c0e4ad6aeeabcbb6fe6fd6fa7ef3867266468e324a544fa0c7427

data/README.md

@@ -101,6 +101,25 @@ out #=> :hello
 RedisLock.new('my_key').locked? #=> false
 ```
 
+Very useful when you are changing multiple objects and want to protect them
+in a distributed system
+
+```ruby
+lock_1 = RedisLock.new('my_key')
+lock_2 = RedisLock.new('another_key')
+
+out = RedisLock.multi_semaphore('my_key', 'another_key') do |multi_lock|
+        multi_lock.locked? #=> true
+        lock_1.locked? #=> true
+        lock_2.locked? #=> true
+        sleep 3 # Do something
+        :hello
+      end
+out #=> :hello
+lock_1.locked? #=> false
+lock_2.locked? #=> false
+```
+
 __if_open:__
 
 **Use case:**

data/lib/redis_lock.rb

@@ -1,6 +1,5 @@
 require 'redis'
 require "redis_lock/version"
-require "redis_lock/configuration"
 
 class RedisLock
   attr_reader :key
@@ -13,16 +12,19 @@ class RedisLock
     yield config
   end
 
-  def self.semaphore(key, args = {}, &block)
-    setup_instance(key, args).semaphore(args, &block)
+  def self.semaphore(*args, &block)
+    opts = extract_options!(args)
+    Semaphore.new(MultiLock.new(*args, opts), opts).call(&block)
   end
 
-  def self.if_open(key, args = {}, &block)
-    setup_instance(key, args).if_open(args, &block)
+  def self.if_open(*args, &block)
+    opts = extract_options!(args)
+    IfOpen.new(MultiLock.new(*args, opts), opts).call(&block)
   end
 
-  def self.if_locked(key, args = {}, &block)
-    setup_instance(key, args).if_locked(args, &block)
+  def self.if_locked(*args, &block)
+    opts = extract_options!(args)
+    IfLocked.new(MultiLock.new(*args, opts), opts).call(&block)
   end
 
   def config; self.class.config; end
@@ -51,25 +53,17 @@ class RedisLock
     redis.set(key, value, args.merge(opts)) == "OK" ? true : false
   end
 
-  def semaphore(args = {}, &block)
-    ttl = args[:ttl] || config.default_ttl
-    set_opts = args[:set_opts] || {}
-    while locked?
-      sleep (args[:wait] || 3)
-    end
-    set(ttl, set_opts)
-    _semaphore_perform(&block)
+  def semaphore(opts = {}, &block)
+    Semaphore.new(self, opts).call(&block)
   end
 
-  def if_open(args = {}, &block)
-    return if locked?
-    _perform(&block)
+  def if_open(opts = {}, &block)
+    IfOpen.new(self, opts).call(&block)
   end
   alias_method :perform, :if_open
 
-  def if_locked(args = {}, &block)
-    return if open?
-    _perform(&block)
+  def if_locked(opts = {}, &block)
+    IfLocked.new(self, opts).call(&block)
   end
 
   def locked?
@@ -98,28 +92,13 @@ class RedisLock
     redis.get(key)
   end
 
-  private
-
-  def self.setup_instance(key, args)
-    inst_opts = { redis: args.delete(:redis) }.reject{ |_, v| v.nil? }
-    new(key, inst_opts)
-  end
-
-  def _semaphore_perform(&block)
-    yield self
-  rescue => e
-    config.logger.error "[#{self.class}] key: `#{key}` error:"
-    config.logger.error e
-    raise e
-  ensure
-    unlock!
-  end
-
-  def _perform(&block)
-    yield self
-  rescue => e
-    config.logger.error "[#{self.class}] key: `#{key}` error:"
-    config.logger.error e
-    raise e
+  def self.extract_options!(args)
+    args.last.is_a?(::Hash) ? args.pop : {}
   end
 end
+
+require "redis_lock/configuration"
+require "redis_lock/semaphore"
+require "redis_lock/if_open"
+require "redis_lock/if_locked"
+require "redis_lock/multi_lock"

data/lib/redis_lock/if_locked.rb

@@ -0,0 +1,8 @@
+class RedisLock
+  class IfLocked < Semaphore
+    def call(&block)
+      return :open if lock.open?
+      _perform(&block)
+    end
+  end
+end

data/lib/redis_lock/if_open.rb

@@ -0,0 +1,8 @@
+class RedisLock
+  class IfOpen < Semaphore
+    def call(&block)
+      return :locked if lock.locked?
+      _perform(&block)
+    end
+  end
+end

data/lib/redis_lock/multi_lock.rb

@@ -0,0 +1,45 @@
+class RedisLock
+  class MultiLock
+    extend Forwardable
+    attr_reader :keys, :locks, :opts
+    def_delegators :locks, :any?, :all?, :each, :map
+
+    def initialize(*args)
+      @opts = extract_options!(args)
+      @keys = args
+      @locks = @keys.map do |k|
+                 RedisLock.new(k, @opts)
+               end
+    end
+
+    def extract_options!(args)
+      args.last.is_a?(::Hash) ? args.pop : {}
+    end
+
+    def set(ttl, opts = {})
+      map { |l| l.set(ttl, opts) }.all?{ |e| e === true }
+    end
+
+    def config
+      RedisLock.config
+    end
+
+    def delete
+      map(&:delete).all?{ |e| e === true }
+    end
+    alias_method :unlock!, :delete
+    alias_method :open!, :delete
+    alias_method :remove, :delete
+
+    def open?
+      all?(&:open?)
+    end
+    alias_method :unlocked?, :open?
+
+    def locked?
+      any?(&:locked?)
+    end
+    alias_method :exists?, :locked?
+    alias_method :in_use?, :locked?
+  end
+end

data/lib/redis_lock/semaphore.rb

@@ -0,0 +1,32 @@
+class RedisLock
+  class Semaphore
+    attr_reader :lock, :args
+
+    def initialize(lock, args = {})
+      @lock = lock
+      @args = args
+    end
+
+    def call(&block)
+      ttl = args[:ttl] || lock.config.default_ttl
+      set_opts = args[:set_opts] || {}
+      while lock.locked?
+        sleep (args[:wait] || 1)
+      end
+      lock.set(ttl, set_opts)
+      out = _perform(&block)
+      lock.unlock!
+      out
+    end
+
+    private
+
+    def _perform(&block)
+      yield lock
+    rescue => e
+      config.logger.error "[#{self.class}] key: `#{key}` error:"
+      config.logger.error e
+      raise e
+    end
+  end
+end

data/lib/redis_lock/version.rb

@@ -1,3 +1,3 @@
 class RedisLock
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis_lock
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Artur Pañach
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-05-25 00:00:00.000000000 Z
+date: 2018-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -96,6 +96,10 @@ files:
 - bin/setup
 - lib/redis_lock.rb
 - lib/redis_lock/configuration.rb
+- lib/redis_lock/if_locked.rb
+- lib/redis_lock/if_open.rb
+- lib/redis_lock/multi_lock.rb
+- lib/redis_lock/semaphore.rb
 - lib/redis_lock/version.rb
 - redis_lock.gemspec
 homepage: https://github.com/arturictus/redis_lock.git