activejob-locking 0.4.0 → 0.6.2

data/lib/activejob/locking/options.rb

@@ -1,57 +1,73 @@
-require 'ostruct'
-
-module ActiveJob
-  module Locking
-    class Options
-      attr_accessor :adapter
-      attr_accessor :hosts
-      attr_accessor :lock_time
-      attr_accessor :lock_acquire_time
-      attr_accessor :adapter_options
-
-      def initialize(options = {})
-        @adapter = options[:adapter]
-        @hosts = options[:hosts]
-        @lock_time = options[:lock_time]
-        @lock_acquire_time = options[:lock_acquire_time]
-        @adapter_options = options[:adapter_options]
-      end
-
-      def lock_time=(value)
-        case value
-          when NilClass
-            raise(ArgumentError, 'Lock time must be set')
-          when ActiveSupport::Duration
-            @lock_time = value.value
-          when 0
-            raise(ArgumentError, 'Lock time must be greater than zero')
-          else
-            @lock_time = value
-        end
-      end
-
-      def lock_acquire_time=(value)
-        case value
-          when NilClass
-            raise(ArgumentError, 'Lock acquire time must be set')
-          when ActiveSupport::Duration
-            @lock_acquire_time = value.value
-          when 0
-            raise(ArgumentError, 'Lock acquire time must be greater than zero')
-          else
-            @lock_acquire_time = value
-        end
-      end
-
-      def merge(other)
-        result = self.dup
-        result.adapter = other.adapter if other.adapter
-        result.hosts = other.hosts if other.hosts
-        result.lock_time = other.lock_time if other.lock_time
-        result.lock_acquire_time = other.lock_acquire_time if other.lock_acquire_time
-        result.adapter_options = other.adapter_options if other.adapter_options
-        result
-      end
-    end
-  end
+require 'ostruct'
+
+module ActiveJob
+  module Locking
+    class Options
+      attr_accessor :adapter
+      attr_accessor :hosts
+      attr_accessor :lock_time
+      attr_accessor :lock_acquire_time
+      attr_accessor :enqueue_time
+      attr_accessor :adapter_options
+
+      def initialize(options = {})
+        @adapter = options[:adapter]
+        @hosts = options[:hosts]
+        @enqueue_time = options[:enqueue_time]
+        @lock_time = options[:lock_time]
+        @lock_acquire_time = options[:lock_acquire_time]
+        @adapter_options = options[:adapter_options]
+      end
+
+      def enqueue_time=(value)
+        case value
+          when NilClass
+            raise(ArgumentError, 'Enqueue time must be set')
+          when ActiveSupport::Duration
+            @enqueue_time = value.value
+          when 0
+            raise(ArgumentError, 'Enqueue time must be greater than zero')
+          else
+            @enqueue_time = value
+        end
+      end
+
+      def lock_time=(value)
+        case value
+          when NilClass
+            raise(ArgumentError, 'Lock time must be set')
+          when ActiveSupport::Duration
+            @lock_time = value.value
+          when 0
+            raise(ArgumentError, 'Lock time must be greater than zero')
+          else
+            @lock_time = value
+        end
+      end
+
+      def lock_acquire_time=(value)
+        case value
+          when NilClass
+            raise(ArgumentError, 'Lock acquire time must be set')
+          when ActiveSupport::Duration
+            @lock_acquire_time = value.value
+          when 0
+            raise(ArgumentError, 'Lock acquire time must be greater than zero')
+          else
+            @lock_acquire_time = value
+        end
+      end
+
+      def merge(other)
+        result = self.dup
+        result.adapter = other.adapter if other.adapter
+        result.hosts = other.hosts if other.hosts
+        result.enqueue_time = other.enqueue_time if other.enqueue_time
+        result.lock_time = other.lock_time if other.lock_time
+        result.lock_acquire_time = other.lock_acquire_time if other.lock_acquire_time
+        result.adapter_options = other.adapter_options if other.adapter_options
+        result
+      end
+    end
+  end
 end

data/lib/activejob/locking/serialized.rb

@@ -1,23 +1,23 @@
-module ActiveJob
-  module Locking
-    module Serialized
-      extend ::ActiveSupport::Concern
-
-      included do
-        include ::ActiveJob::Locking::Base
-
-        around_perform do |job, block|
-          if job.adapter.lock
-            begin
-              block.call
-            ensure
-              job.adapter.unlock
-            end
-          else
-            job.class.set(wait: job.class.lock_acquire_time).perform_later(*job.arguments)
-          end
-        end
-      end
-    end
-  end
-end
+module ActiveJob
+  module Locking
+    module Serialized
+      extend ::ActiveSupport::Concern
+
+      included do
+        include ::ActiveJob::Locking::Base
+
+        around_perform do |job, block|
+          if job.adapter.lock
+            begin
+              block.call
+            ensure
+              job.adapter.unlock
+            end
+          else
+            job.class.set(wait: job.adapter.options.enqueue_time).perform_later(*job.arguments)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/activejob/locking/unique.rb

@@ -1,25 +1,25 @@
-module ActiveJob
-  module Locking
-    module Unique
-      extend ::ActiveSupport::Concern
-
-      included do
-        include ::ActiveJob::Locking::Base
-
-        before_enqueue do |job|
-          lock = job.adapter.lock
-          throw :abort unless lock
-        end
-
-        rescue_from(Exception) do |exception|
-          self.adapter.unlock
-          raise
-        end
-
-        after_perform do |job|
-          job.adapter.unlock
-        end
-      end
-    end
-  end
-end
+module ActiveJob
+  module Locking
+    module Unique
+      extend ::ActiveSupport::Concern
+
+      included do
+        include ::ActiveJob::Locking::Base
+
+        before_enqueue do |job|
+          lock = job.adapter.lock
+          throw :abort unless lock
+        end
+
+        rescue_from(Exception) do |exception|
+          self.adapter.unlock
+          raise
+        end
+
+        after_perform do |job|
+          job.adapter.unlock
+        end
+      end
+    end
+  end
+end

data/test/jobs/fail_job.rb

@@ -1,15 +1,15 @@
-class FailJob < ActiveJob::Base
-  include ActiveJob::Locking::Unique
-
-  self.lock_acquire_time = 2
-
-  # We want the job ids to be all the same for testing
-  def lock_key(index, sleep_time)
-    self.class.name
-  end
-
-  # Pass in index so we can distinguish different jobs
-  def perform(index, sleep_time)
-    raise(ArgumentError, 'Job failed')
-  end
+class FailJob < ActiveJob::Base
+  include ActiveJob::Locking::Unique
+
+  self.lock_acquire_time = 2
+
+  # We want the job ids to be all the same for testing
+  def lock_key(index, sleep_time)
+    self.class.name
+  end
+
+  # Pass in index so we can distinguish different jobs
+  def perform(index, sleep_time)
+    raise(ArgumentError, 'Job failed')
+  end
 end

data/test/jobs/serial_job.rb

@@ -1,15 +1,15 @@
-class SerialJob < ActiveJob::Base
-  include ActiveJob::Locking::Serialized
-
-  self.lock_acquire_time = 2
-
-  # We want the job ids to be all the same for testing
-  def lock_key(index, sleep_time)
-    self.class.name
-  end
-
-  # Pass in index so we can distinguish different jobs
-  def perform(index, sleep_time)
-    sleep(sleep_time)
-  end
+class SerialJob < ActiveJob::Base
+  include ActiveJob::Locking::Serialized
+
+  self.lock_acquire_time = 2
+
+  # We want the job ids to be all the same for testing
+  def lock_key(index, sleep_time)
+    self.class.name
+  end
+
+  # Pass in index so we can distinguish different jobs
+  def perform(index, sleep_time)
+    sleep(sleep_time)
+  end
 end

data/test/jobs/unique_job.rb

@@ -1,15 +1,15 @@
-class UniqueJob < ActiveJob::Base
-  include ActiveJob::Locking::Unique
-
-  self.lock_acquire_time = 2
-
-  # We want the job ids to be all the same for testing
-  def lock_key(index, sleep_time)
-    self.class.name
-  end
-
-  # Pass in index so we can distinguish different jobs
-  def perform(index, sleep_time)
-    sleep(sleep_time)
-  end
+class UniqueJob < ActiveJob::Base
+  include ActiveJob::Locking::Unique
+
+  self.lock_acquire_time = 2
+
+  # We want the job ids to be all the same for testing
+  def lock_key(index, sleep_time)
+    self.class.name
+  end
+
+  # Pass in index so we can distinguish different jobs
+  def perform(index, sleep_time)
+    sleep(sleep_time)
+  end
 end

data/test/serialized_tests.rb

@@ -1,63 +1,63 @@
-require File.expand_path('../test_helper', __FILE__)
-
-module SerializedTests
-  def test_one_completed
-    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
-    assert_equal(0, ActiveJob::Base.queue_adapter.performed_jobs.count)
-
-    start_time = Time.now
-    sleep_time = SerialJob.lock_acquire_time / 0.9
-    threads = 3.times.map do |i|
-      Thread.new do
-        SerialJob.perform_later(i, sleep_time)
-      end
-    end
-
-    # All the threads will complete after the sleep time has expired - since two jobs get requeued
-    threads.each {|thread| thread.join}
-    assert_equal(2, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
-    assert_equal(3, ActiveJob::Base.queue_adapter.performed_jobs.count)
-
-    assert(Time.now - start_time > (1 * sleep_time))
-  end
-
-  def test_some_completed
-    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
-    assert_equal(0, ActiveJob::Base.queue_adapter.performed_jobs.count)
-
-    start_time = Time.now
-    sleep_time = SerialJob.lock_acquire_time / 1.9
-    threads = 3.times.map do |i|
-      Thread.new do
-        SerialJob.perform_later(i, sleep_time)
-      end
-    end
-
-    # All the threads will complete after the sleep time has expired - since two jobs get requeued
-    threads.each {|thread| thread.join}
-    assert_equal(1, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
-    assert_equal(3, ActiveJob::Base.queue_adapter.performed_jobs.count)
-
-    assert(Time.now - start_time > (1 * sleep_time))
-  end
-
-  def test_all_completed
-    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
-    assert_equal(0, ActiveJob::Base.queue_adapter.performed_jobs.count)
-
-    start_time = Time.now
-    sleep_time = SerialJob.lock_acquire_time / 4
-    threads = 3.times.map do |i|
-      Thread.new do
-        SerialJob.perform_later(i, sleep_time)
-      end
-    end
-
-    # All the threads will complete after the sleep time has expired - since two jobs get requeued
-    threads.each {|thread| thread.join}
-    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
-    assert_equal(3, ActiveJob::Base.queue_adapter.performed_jobs.count)
-
-    assert(Time.now - start_time > (1 * sleep_time))
-  end
+require File.expand_path('../test_helper', __FILE__)
+
+module SerializedTests
+  def test_one_completed
+    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
+    assert_equal(0, ActiveJob::Base.queue_adapter.performed_jobs.count)
+
+    start_time = Time.now
+    sleep_time = SerialJob.lock_acquire_time / 0.9
+    threads = 3.times.map do |i|
+      Thread.new do
+        SerialJob.perform_later(i, sleep_time)
+      end
+    end
+
+    # All the threads will complete after the sleep time has expired - since two jobs get requeued
+    threads.each {|thread| thread.join}
+    assert_equal(2, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
+    assert_equal(3, ActiveJob::Base.queue_adapter.performed_jobs.count)
+
+    assert(Time.now - start_time > (1 * sleep_time))
+  end
+
+  def test_some_completed
+    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
+    assert_equal(0, ActiveJob::Base.queue_adapter.performed_jobs.count)
+
+    start_time = Time.now
+    sleep_time = SerialJob.lock_acquire_time / 1.9
+    threads = 3.times.map do |i|
+      Thread.new do
+        SerialJob.perform_later(i, sleep_time)
+      end
+    end
+
+    # All the threads will complete after the sleep time has expired - since two jobs get requeued
+    threads.each {|thread| thread.join}
+    assert_equal(1, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
+    assert_equal(3, ActiveJob::Base.queue_adapter.performed_jobs.count)
+
+    assert(Time.now - start_time > (1 * sleep_time))
+  end
+
+  def test_all_completed
+    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
+    assert_equal(0, ActiveJob::Base.queue_adapter.performed_jobs.count)
+
+    start_time = Time.now
+    sleep_time = SerialJob.lock_acquire_time / 4
+    threads = 3.times.map do |i|
+      Thread.new do
+        SerialJob.perform_later(i, sleep_time)
+      end
+    end
+
+    # All the threads will complete after the sleep time has expired - since two jobs get requeued
+    threads.each {|thread| thread.join}
+    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
+    assert_equal(3, ActiveJob::Base.queue_adapter.performed_jobs.count)
+
+    assert(Time.now - start_time > (1 * sleep_time))
+  end
 end

data/test/test_helper.rb

@@ -1,20 +1,20 @@
-require 'bundler'
-Bundler.require(:default, :test)
-
-require 'minitest/autorun'
-
-# To make debugging easier, test within this source tree versus an installed gem
-$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
-require 'activejob-locking'
-
-require 'activejob/locking/adapters/redis-semaphore'
-require 'activejob/locking/adapters/redlock'
-require 'activejob/locking/adapters/suo-redis'
-
-require_relative './jobs/unique_job'
-require_relative './jobs/fail_job'
-require_relative './jobs/serial_job'
-
-def redis_reset
-  Kernel.system('redis-cli FLUSHALL')
+require 'bundler'
+Bundler.require(:default, :test)
+
+require 'minitest/autorun'
+
+# To make debugging easier, test within this source tree versus an installed gem
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+require 'activejob-locking'
+
+require 'activejob/locking/adapters/redis-semaphore'
+require 'activejob/locking/adapters/redlock'
+require 'activejob/locking/adapters/suo-redis'
+
+require_relative './jobs/unique_job'
+require_relative './jobs/fail_job'
+require_relative './jobs/serial_job'
+
+def redis_reset
+  Kernel.system('redis-cli FLUSHALL')
 end