with_process_lock 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0af2c6f49c7b058970c7fc98be0949625b6f005d
-  data.tar.gz: '005991b9d6d6355c7c98e9ed0aa9241c3e2b147d'
+  metadata.gz: aa3c649e6d7f28c49dc515e0f1fc851921500bc0
+  data.tar.gz: b24366c20a4ee898d385af92aeda3cc26b5b8075
 SHA512:
-  metadata.gz: 7c34ceac06e7d7e8ffdb256a968a9e8464161fc742065cc3679ab5acdc19c810099c30f084f59940a746d913285509db1bc679426101d0296bc4e3ad6bd05eda
-  data.tar.gz: 6a700c32cff253497e62aa6e668b95b692ce359dbff3d5e5786154dd00687585ab2e89ea290a2df4164cf7bb23388c0adf73cda47693c3087117502ef25fa9c2
+  metadata.gz: e4e1a90d66242b191695f42f26ffd548c8a3d3ef46d7c753cfbddc622d4fda065758b83ff5dfbcc095095b9e1f2a902aa0291739de4aeb1a5c91cadf223754e5
+  data.tar.gz: b4bdd542ced26842e933f99ee754f0fc1b74ad95cabadf7200044d25367d0c39a5807047381566c04fd18039a0461afe4abab2d2c19aef264dcaaa1f971dcdd0

data/README.md

@@ -29,13 +29,59 @@ Or install it yourself as:
 
 ## Usage
 
+You can attempt to run a process once with `execute_once`. It will execute the
+block if the process is not locked, otherwise it will raise an exception.
+
+```
+  ProcessLock::WithProcessLock.execute_once('unique_key_for_your_process') do
+    # The code to run in the process
+    do_stuff
+  end
+```
+
+You can run a process with a retry:
+
+```
+  ProcessLock::WithProcessLock.execute_with_retry(
+    'unique_key_for_your_process'
+  ) do
+    # The code to run in the process
+    do_stuff
+  end
 ```
-  ProcessLock::WithProcessLock.execute('unique_key_for_your_process') do
+
+This will retry running the block every 1 second until the process is unblocked.
+The current thread will be blocked until the block successfully executes.
+You can override the default retry wait by providing the `retry_wait` parameter
+in seconds.
+
+```
+  ProcessLock::WithProcessLock.execute_with_retry(
+    'unique_key_for_your_process',
+    retry_wait: 2
+  ) do
+    # The code to run in the process
+    do_stuff
+  end
+```
+
+If you don't want the retry to run forever, you can specify a timeout by
+providing the `timeout` parameter in seconds:
+
+
+```
+  ProcessLock::WithProcessLock.execute_with_retry(
+    'unique_key_for_your_process',
+    retry_wait: 2,
+    timeout: 10
+  ) do
     # The code to run in the process
     do_stuff
   end
 ```
 
+This will retry until the timeout time is expired, then raise an error.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/process_lock.rb

@@ -1,6 +1,9 @@
 require 'redis'
 require "process_lock/version"
+require "process_lock/execute_once"
+require "process_lock/execute_with_retry"
 require "process_lock/with_process_lock"
+require "process_lock/process_lock_error"
 module ProcessLock
 
 end

data/lib/process_lock/execute_once.rb

@@ -0,0 +1,15 @@
+module ProcessLock
+  module ExecuteOnce
+    # Tries to run the given block and raises an exception if the process is
+    # locked
+    # @param key [String] The unique key to determine if the process is locked
+    def execute_once(key, &blk)
+      if can_execute?(key)
+        execute(key, &blk)
+      else
+        redis.quit
+        raise ProcessLockError, key: key
+      end
+    end
+  end
+end

data/lib/process_lock/execute_with_retry.rb

@@ -0,0 +1,37 @@
+module ProcessLock
+  module ExecuteWithRetry
+    # Tries to run the given block and retries every retry_wait seconds until
+    #   the process in unblocked
+    # @param key [String] The unique key to determine if the process is locked
+    # @param retry_wait [Number] The number of seconds to wait in between
+    #   retry attempts, defaulting to 1
+    # @param timeout [Number] The number of seconds until an exception should
+    #   be raised instead of retrying, defaulting to nil (no timeout)
+    def execute_with_retry(
+      key,
+      retry_wait: 1,
+      timeout: nil,
+      &blk
+    )
+      if can_execute?(key)
+        execute(key, &blk)
+      else
+        # If there is time left before timeout or there is no timeout,
+        # wait retry_wait seconds and then recurse
+        if timeout.nil? || timeout >= retry_wait
+          sleep(retry_wait)
+          execute_with_retry(
+            key,
+            retry_wait: retry_wait,
+            timeout: timeout.nil? ? nil : timeout - retry_wait,
+            &blk
+          )
+        else
+          # If the timeout was reached, give up
+          redis.quit
+          raise ProcessLockError, key: key
+        end
+      end
+    end
+  end
+end

data/lib/process_lock/process_lock_error.rb

@@ -0,0 +1,7 @@
+module ProcessLock
+  class ProcessLockError < StandardError
+    def initialize(key:)
+      super("Can not run process because #{key} taken.")
+    end
+  end
+end

data/lib/process_lock/version.rb

@@ -1,3 +1,3 @@
 module ProcessLock
-  VERSION = "0.1.1"
+  VERSION = "1.0.0"
 end

data/lib/process_lock/with_process_lock.rb

@@ -1,28 +1,27 @@
 module ProcessLock
   class WithProcessLock
+    class << self
+      include ExecuteOnce
+      include ExecuteWithRetry
 
-    def self.execute(key, &blk)
-      if can_execute?(key)
+      private
+
+      def execute(key, &blk)
         redis.set(key, true)
-        begin
-          yield blk
-        ensure
-          # Delete the key and quit redis even if the block raises an exception
-          redis.del(key)
-          redis.quit
-        end
-      else
+        yield blk
+      ensure
+        # Delete the key and quit redis even if the block raises an exception
+        redis.del(key)
         redis.quit
-        raise StandardError, "Can not run process because #{key} taken."
       end
-    end
 
-    def self.can_execute?(key)
-      !redis.exists(key)
-    end
+      def can_execute?(key)
+        !redis.exists(key)
+      end
 
-    def self.redis
-      @_redis ||= Redis.new
+      def redis
+        @_redis ||= Redis.new
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: with_process_lock
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0
 platform: ruby
 authors:
 - James Friedman
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-05-01 00:00:00.000000000 Z
+date: 2017-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -141,6 +141,9 @@ files:
 - bin/console
 - bin/setup
 - lib/process_lock.rb
+- lib/process_lock/execute_once.rb
+- lib/process_lock/execute_with_retry.rb
+- lib/process_lock/process_lock_error.rb
 - lib/process_lock/version.rb
 - lib/process_lock/with_process_lock.rb
 - process_lock.gemspec