activejob-uniqueness 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5fda42367a82ec4d28e8e9dd2aa4e4f1774b28133170aab20095a7cf1366ce6f
+  data.tar.gz: 4e29cd3caf6b85713a570fd95aa4272eec7df23f96a7fb44fb05574c83dc1d5d
+SHA512:
+  metadata.gz: 6ca9eb292b99425c77f3f5d3a2082ba3e15d045c683123203667328bb0e24033a3139a5b465fffd1da6b80fea6f3e963544cef1bbde5107ecb666d92d82396e6
+  data.tar.gz: 8deceb5728a0459ac983a9e0ec7501abf9ba050e9536c626770aa568504ba05737bf1664907abdff312c83cfe3c97d4ea61df572eaee56cfb54dd88245afa51d

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/Gemfile.lock
+/.ruby-gemset
+/.ruby-version
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,38 @@
+AllCops:
+  NewCops: enable
+
+Layout/LineLength:
+  Max: 120
+  Exclude:
+    - spec/**/*
+
+Layout/MultilineMethodCallIndentation:
+  Exclude:
+    - spec/**/*
+
+Lint/AmbiguousBlockAssociation:
+  Exclude:
+    - spec/**/*
+
+Metrics/AbcSize:
+  Exclude:
+    - spec/**/*
+
+Metrics/BlockLength:
+  Exclude:
+    - activejob-uniqueness.gemspec
+    - spec/**/*
+
+Metrics/MethodLength:
+  Exclude:
+    - spec/**/*
+
+Style/ClassAndModuleChildren:
+  Exclude:
+    - spec/**/*
+
+Style/Documentation:
+  Enabled: false
+
+Style/RescueModifier:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,21 @@
+---
+dist: xenial
+language: ruby
+services:
+  - redis-server
+cache: bundler
+rvm:
+  - 2.5.8
+  - 2.6.6
+  - 2.7.1
+env:
+  - ACTIVEJOB_VERSION="~> 4.2.11"
+  - ACTIVEJOB_VERSION="~> 5.2.4"
+  - ACTIVEJOB_VERSION="~> 6.0.3"
+jobs:
+  exclude:
+    - rvm: 2.7.1
+      env: ACTIVEJOB_VERSION="~> 4.2.11"
+
+before_install: gem install bundler -v 1.17.3
+bundler_args: --jobs 3 --retry 3

data/CHANGELOG.md

@@ -0,0 +1 @@
+## Original Release: 0.1.0

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in activejob-uniqueness.gemspec
+gemspec
+
+gem 'activejob', ENV.fetch('ACTIVEJOB_VERSION', '~> 4.2.11')

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Rustam Sharshenov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,102 @@
+# Job uniqueness for ActiveJob
+[![Build Status](https://travis-ci.com/veeqo/activejob-uniqueness.svg?branch=master)](https://travis-ci.com/veeqo/activejob-uniqueness) [![Gem Version](https://badge.fury.io/rb/activejob-uniqueness.svg)](https://badge.fury.io/rb/activejob-uniqueness)
+
+The gem allows to protect job uniqueness with next strategies:
+
+| Strategy | The job is locked | The job is unlocked |
+|-|-|-|
+| `until_executing` | when **pushed** to the queue | when **processing starts** |
+| `until_executed` | when **pushed** to the queue | when the job is **processed successfully** |
+| `until_expired` | when **pushed** to the queue | when the lock is **expired** |
+| `until_and_while_executing` | when **pushed** to the queue | when **processing starts**<br>a runtime lock is acquired to **prevent simultaneous jobs** |
+| `while_executing` | when **processing starts** | when the job is **processed**<br>with any result including an error |
+
+Inspired by [SidekiqUniqueJobs](https://github.com/mhenrixon/sidekiq-unique-jobs), uses [Redlock](https://github.com/leandromoreira/redlock-rb) under the hood, sponsored by [Veeqo](https://www.veeqo.com/).
+
+## Installation
+
+Add the "meta-tags" gem to your Gemfile.
+
+```ruby
+gem 'activejob-uniqueness'
+```
+
+And run `bundle install` command.
+
+## Configuration
+
+ActiveJob::Uniqueness is ready to work without any configuration. It will use `REDIS_URL` to connect to Redis instance.
+To override the defaults, create an initializer `config/initializers/active_job_uniqueness.rb` using the following command:
+
+```sh
+rails generate active_job:uniqueness:install
+```
+
+## Usage
+
+Define uniqueness strategy for your job via `unique` class method:
+
+```ruby
+class MyJob < ActiveJob::Base
+  unique :until_executed
+
+  # Custom expiration:
+  # unique :until_executed, lock_ttl: 3.hours
+
+  # Do not raise error on non unique jobs enqueuing:
+  # unique :until_executed, on_conflict: :log
+
+  # Handle conflict by custom Proc:
+  # unique :until_executed, on_conflict: ->(job) { job.logger.info 'Oops' }
+
+  # The :until_and_while_executing strategy supports extra attributes for a runtime lock:
+  # unique :until_and_while_executing runtime_lock_ttl: 10.minutes, on_runtime_conflict: :log
+end
+```
+
+ActiveJob::Uniqueness allows to manually unlock jobs:
+
+```ruby
+# Remove the lock for particular arguments:
+MyJob.unlock!(foo: 'bar')
+# or
+ActiveJob::Uniqueness.unlock!(job_class_name: 'MyJob', arguments: [{foo: 'bar'}])
+
+# Remove all locks of MyJob
+MyJob.unlock!
+# or
+ActiveJob::Uniqueness.unlock!(job_class_name: 'MyJob')
+
+# Remove all locks
+ActiveJob::Uniqueness.unlock!
+```
+
+## Test mode
+
+Most probably you don't want jobs to be locked in tests. Add this line to your test suite (`rails_helper.rb`):
+
+```ruby
+ActiveJob::Uniqueness.test_mode!
+```
+
+## Logging
+
+ActiveJob::Uniqueness instruments `ActiveSupport::Notifications` with next events:
+* `lock.active_job_uniqueness`
+* `runtime_lock.active_job_uniqueness`
+* `unlock.active_job_uniqueness`
+* `runtime_unlock.active_job_uniqueness`
+* `conflict.active_job_uniqueness`
+* `runtime_conflict.active_job_uniqueness`
+
+And then writes to `ActiveJob::Base.logger`.
+
+### ActiveJob prior to version `6.1` will always log `Enqueued MyJob (Job ID) ...` even if the callback chain was halted. [Details](https://github.com/rails/rails/pull/37830)
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/veeqo/activejob-uniqueness.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/activejob-uniqueness.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_job/uniqueness/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'activejob-uniqueness'
+  spec.version       = ActiveJob::Uniqueness::VERSION
+  spec.authors       = ['Rustam Sharshenov']
+  spec.email         = ['rustam@sharshenov.com']
+
+  spec.summary       = 'Ensure uniqueness of your ActiveJob jobs'
+  spec.description   = 'Ensure uniqueness of your ActiveJob jobs'
+  spec.homepage      = 'https://github.com/veeqo/activejob-uniqueness'
+  spec.license       = 'MIT'
+
+  if spec.respond_to?(:metadata)
+    spec.metadata['homepage_uri'] = spec.homepage
+    spec.metadata['source_code_uri'] = spec.homepage
+    spec.metadata['changelog_uri'] = 'https://github.com/veeqo/activejob-uniqueness/blob/master/CHANGELOG.md'
+  end
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(spec|\.rubocop.yml)/}) }
+  end
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activejob', '>= 4.2'
+  spec.add_dependency 'redlock', '>= 1.2', '< 2'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

data/lib/active_job/uniqueness.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/core_ext'
+require 'redlock'
+require 'openssl'
+require 'active_job/uniqueness/version'
+require 'active_job/uniqueness/errors'
+require 'active_job/uniqueness/log_subscriber'
+require 'active_job/uniqueness/patch'
+
+module ActiveJob
+  module Uniqueness
+    extend ActiveSupport::Autoload
+
+    autoload :Configuration
+    autoload :LockKey
+    autoload :Strategies
+    autoload :LockManager
+    autoload :TestLockManager
+
+    class << self
+      def configure
+        yield config
+      end
+
+      def config
+        @config ||= ActiveJob::Uniqueness::Configuration.new
+      end
+
+      def lock_manager
+        @lock_manager ||= ActiveJob::Uniqueness::LockManager.new(config.redlock_servers, config.redlock_options)
+      end
+
+      def unlock!(*args)
+        lock_manager.delete_locks(ActiveJob::Uniqueness::LockKey.new(*args).wildcard_key)
+      end
+
+      def test_mode!
+        @lock_manager = ActiveJob::Uniqueness::TestLockManager.new
+      end
+    end
+  end
+end

data/lib/active_job/uniqueness/configuration.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Uniqueness
+    # Use /config/initializer/activejob_uniqueness.rb to configure ActiveJob::Uniqueness
+    #
+    # ActiveJob::Uniqueness.configure do |c|
+    #   c.lock_ttl = 3.hours
+    # end
+    #
+    class Configuration
+      include ActiveSupport::Configurable
+
+      config_accessor(:lock_ttl) { 1.day }
+      config_accessor(:lock_prefix) { 'activejob_uniqueness' }
+      config_accessor(:on_conflict) { :raise }
+      config_accessor(:digest_method) { OpenSSL::Digest::MD5 }
+      config_accessor(:redlock_servers) { [ENV.fetch('REDIS_URL', 'redis://localhost:6379')] }
+      config_accessor(:redlock_options) { {} }
+      config_accessor(:lock_strategies) { {} }
+
+      def on_conflict=(action)
+        validate_on_conflict_action!(action)
+
+        config.on_conflict = action
+      end
+
+      def validate_on_conflict_action!(action)
+        return if action.nil? || %i[log raise].include?(action) || action.respond_to?(:call)
+
+        raise ActiveJob::Uniqueness::InvalidOnConflictAction, "Unexpected '#{action}' action on conflict"
+      end
+    end
+  end
+end

data/lib/active_job/uniqueness/errors.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Uniqueness
+    class Error < ::RuntimeError; end
+
+    # Raised when unknown strategy is referenced in the job class
+    #
+    # class MyJob < ActiveJob::Base
+    #   unique :invalid_strategy # exception raised
+    # end
+    #
+    class StrategyNotFound < Error; end
+
+    # Raised on attempt to enqueue a not unique job with :raise on_conflict.
+    # Also raised when the runtime lock is taken by some other job.
+    #
+    # class MyJob < ActiveJob::Base
+    #   unique :until_expired, on_conflict: :raise
+    # end
+    #
+    # MyJob.perform_later(1)
+    # MyJob.perform_later(1) # exception raised
+    #
+    class JobNotUnique < Error; end
+
+    # Raised when unsupported on_conflict action is used
+    #
+    # class MyJob < ActiveJob::Base
+    #   unique :until_expired, on_conflict: :die # exception raised
+    # end
+    #
+    class InvalidOnConflictAction < Error; end
+  end
+end

data/lib/active_job/uniqueness/lock_key.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'active_job/arguments'
+
+module ActiveJob
+  module Uniqueness
+    class LockKey
+      FALLBACK_ARGUMENTS_STRING = 'no_arguments'
+
+      delegate :lock_prefix, :digest_method, to: :'ActiveJob::Uniqueness.config'
+
+      attr_reader :job_class_name, :arguments
+
+      def initialize(job_class_name: nil, arguments: nil)
+        if arguments.present? && job_class_name.blank?
+          raise ArgumentError, 'job_class_name is required if arguments given'
+        end
+
+        @job_class_name = job_class_name
+        @arguments = arguments || []
+      end
+
+      def lock_key
+        [
+          lock_prefix,
+          normalized_job_class_name,
+          arguments_key_part
+        ].join(':')
+      end
+
+      def wildcard_key
+        [
+          lock_prefix,
+          normalized_job_class_name,
+          arguments.any? ? arguments_key_part + '*' : '*'
+        ].compact.join(':')
+      end
+
+      private
+
+      def arguments_key_part
+        arguments.any? ? arguments_digest : FALLBACK_ARGUMENTS_STRING
+      end
+
+      # ActiveJob::Arguments is used to reflect the way ActiveJob serializes arguments in order to
+      # serialize ActiveRecord models with GlobalID uuids instead of as_json which could give undesired artifacts
+      def serialized_arguments
+        ActiveSupport::JSON.encode(ActiveJob::Arguments.serialize(arguments))
+      end
+
+      def arguments_digest
+        digest_method.hexdigest(serialized_arguments)
+      end
+
+      def normalized_job_class_name
+        job_class_name&.underscore
+      end
+    end
+  end
+end

data/lib/active_job/uniqueness/lock_manager.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Uniqueness
+    # Redlock requires a value of the lock to release the resource by Redlock::Client#unlock method.
+    # LockManager introduces LockManager#delete_lock to unlock by resource key only.
+    # See https://github.com/leandromoreira/redlock-rb/issues/51 for more details.
+    class LockManager < ::Redlock::Client
+      # Unlocks a resource by resource only.
+      def delete_lock(resource)
+        @servers.each do |server|
+          server.instance_variable_get(:'@redis').with do |conn|
+            conn.del resource
+          end
+        end
+
+        true
+      end
+
+      # Unlocks multiple resources by key wildcard.
+      def delete_locks(wildcard)
+        @servers.each do |server|
+          server.instance_variable_get(:'@redis').with do |conn|
+            conn.scan_each(match: wildcard).each { |key| conn.del key }
+          end
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/active_job/uniqueness/log_subscriber.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'active_support/log_subscriber'
+
+module ActiveJob
+  class LogSubscriber < ActiveSupport::LogSubscriber #:nodoc:
+    def lock(event)
+      job = event.payload[:job]
+      resource = event.payload[:resource]
+
+      debug do
+        "Locked #{lock_info(job, resource)}" + args_info(job)
+      end
+    end
+
+    def runtime_lock(event)
+      job = event.payload[:job]
+      resource = event.payload[:resource]
+
+      debug do
+        "Locked runtime #{lock_info(job, resource)}" + args_info(job)
+      end
+    end
+
+    def unlock(event)
+      job = event.payload[:job]
+      resource = event.payload[:resource]
+
+      debug do
+        "Unlocked #{lock_info(job, resource)}"
+      end
+    end
+
+    def runtime_unlock(event)
+      job = event.payload[:job]
+      resource = event.payload[:resource]
+
+      debug do
+        "Unlocked runtime #{lock_info(job, resource)}"
+      end
+    end
+
+    def conflict(event)
+      job = event.payload[:job]
+      resource = event.payload[:resource]
+
+      info do
+        "Not unique #{lock_info(job, resource)}" + args_info(job)
+      end
+    end
+
+    def runtime_conflict(event)
+      job = event.payload[:job]
+      resource = event.payload[:resource]
+
+      info do
+        "Not unique runtime #{lock_info(job, resource)}" + args_info(job)
+      end
+    end
+
+    private
+
+    def lock_info(job, resource)
+      "#{job.class.name} (Job ID: #{job.job_id}) (Lock key: #{resource})"
+    end
+
+    def args_info(job)
+      if job.arguments.any? && log_arguments?(job)
+        ' with arguments: ' +
+          job.arguments.map { |arg| format(arg).inspect }.join(', ')
+      else
+        ''
+      end
+    end
+
+    def log_arguments?(job)
+      return true unless job.class.respond_to?(:log_arguments?)
+
+      job.class.log_arguments?
+    end
+
+    def format(arg)
+      case arg
+      when Hash
+        arg.transform_values { |value| format(value) }
+      when Array
+        arg.map { |value| format(value) }
+      when GlobalID::Identification
+        arg.to_global_id rescue arg
+      else
+        arg
+      end
+    end
+
+    def logger
+      ActiveJob::Base.logger
+    end
+  end
+end
+
+ActiveJob::LogSubscriber.attach_to :active_job_uniqueness

data/lib/active_job/uniqueness/patch.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Uniqueness
+    # Provides ability to make ActiveJob job unique.
+    #
+    # For example:
+    #
+    # class FooJob < ActiveJob::Base
+    #   queue_as :foo
+    #
+    #   unique :until_executed, lock_ttl: 3.hours
+    #
+    #   def perform(params)
+    #     #...
+    #   end
+    # end
+    #
+    module Patch
+      extend ActiveSupport::Concern
+
+      class_methods do
+        # Enables the uniqueness strategy for the job
+        # Params:
+        # +strategy+:: the uniqueness strategy.
+        # +options+:: uniqueness strategy options. For example: lock_ttl.
+        def unique(strategy, options = {})
+          validate_on_conflict_action!(options[:on_conflict])
+          validate_on_conflict_action!(options[:on_runtime_conflict])
+
+          self.lock_strategy_class = ActiveJob::Uniqueness::Strategies.lookup(strategy)
+          self.lock_options = options
+        end
+
+        # Unlocks all jobs of the job class if no arguments given
+        # Unlocks particular job if job arguments given
+        def unlock!(*arguments)
+          ActiveJob::Uniqueness.unlock!(job_class_name: name, arguments: arguments)
+        end
+
+        private
+
+        delegate :validate_on_conflict_action!, to: :'ActiveJob::Uniqueness.config'
+      end
+
+      included do
+        class_attribute :lock_strategy_class, instance_writer: false
+        class_attribute :lock_options, instance_writer: false
+
+        before_enqueue { |job| job.lock_strategy.before_enqueue if job.lock_strategy_class }
+        before_perform { |job| job.lock_strategy.before_perform if job.lock_strategy_class }
+        after_perform  { |job| job.lock_strategy.after_perform if job.lock_strategy_class }
+        around_enqueue { |job, block| job.lock_strategy_class ? job.lock_strategy.around_enqueue(block) : block.call }
+        around_perform { |job, block| job.lock_strategy_class ? job.lock_strategy.around_perform(block) : block.call }
+      end
+
+      def lock_strategy
+        @lock_strategy ||= lock_strategy_class.new(lock_options.merge(lock_key: lock_key, job: self))
+      end
+
+      # Override in your job class if you want to customize arguments set for a digest.
+      def lock_key_arguments
+        arguments
+      end
+
+      # Override lock_key method in your job class if you want to build completely custom lock key.
+      delegate :lock_key, to: :lock_key_generator
+
+      def lock_key_generator
+        ActiveJob::Uniqueness::LockKey.new job_class_name: self.class.name,
+                                           arguments: lock_key_arguments
+      end
+    end
+
+    if defined?(Rails)
+      class Railtie < Rails::Railtie
+        initializer 'active_job_uniqueness.patch_active_job' do
+          ActiveSupport.on_load(:active_job) do
+            ActiveJob::Base.include ActiveJob::Uniqueness::Patch
+          end
+        end
+      end
+    else
+      ActiveSupport.on_load(:active_job) do
+        ActiveJob::Base.include ActiveJob::Uniqueness::Patch
+      end
+    end
+  end
+end

data/lib/active_job/uniqueness/strategies.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Uniqueness
+    # See Configuration#lock_strategies if you want to define custom strategy
+    module Strategies
+      extend ActiveSupport::Autoload
+
+      autoload :Base
+      autoload :UntilExpired
+      autoload :UntilExecuted
+      autoload :UntilExecuting
+      autoload :UntilAndWhileExecuting
+      autoload :WhileExecuting
+
+      class << self
+        def lookup(strategy)
+          matching_strategy(strategy.to_s.camelize) ||
+            ActiveJob::Uniqueness.config.lock_strategies[strategy] ||
+            raise(StrategyNotFound, "Strategy '#{strategy}' is not found. Is it declared in the configuration?")
+        end
+
+        private
+
+        def matching_strategy(const)
+          const_get(const, false) if const_defined?(const, false)
+        end
+      end
+    end
+  end
+end

data/lib/active_job/uniqueness/strategies/base.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Uniqueness
+    module Strategies
+      # Base strategy is not supposed to actually be used as uniqueness strategy.
+      class Base
+        # https://github.com/rails/rails/pull/17227
+        # https://groups.google.com/g/rubyonrails-core/c/mhD4T90g0G4
+        ACTIVEJOB_SUPPORTS_THROW_ABORT = ActiveJob.gem_version >= Gem::Version.new('5.0')
+
+        delegate :lock_manager, :config, to: :'ActiveJob::Uniqueness'
+
+        attr_reader :lock_key, :lock_ttl, :on_conflict, :job
+
+        def initialize(lock_key:, lock_ttl: nil, on_conflict: nil, job: nil)
+          @lock_key = lock_key
+          @lock_ttl = (lock_ttl || config.lock_ttl).to_i * 1000 # ms
+          @on_conflict = on_conflict || config.on_conflict
+          @job = job
+        end
+
+        def lock(resource:, ttl:, event: :lock)
+          lock_manager.lock(resource, ttl).tap do |result|
+            instrument(event, resource: resource, ttl: ttl) if result
+          end
+        end
+
+        def unlock(resource:, event: :unlock)
+          lock_manager.delete_lock(resource).tap do
+            instrument(event, resource: resource)
+          end
+        end
+
+        def before_enqueue
+          # Expected to be overriden in the descendant strategy
+        end
+
+        def before_perform
+          # Expected to be overriden in the descendant strategy
+        end
+
+        def around_enqueue(block)
+          # Expected to be overriden in the descendant strategy
+          block.call
+        end
+
+        def around_perform(block)
+          # Expected to be overriden in the descendant strategy
+          block.call
+        end
+
+        def after_perform; end
+
+        module LockingOnEnqueue
+          def before_enqueue
+            return if lock(resource: lock_key, ttl: lock_ttl)
+
+            handle_conflict(resource: lock_key, on_conflict: on_conflict)
+            abort_job
+          end
+
+          def around_enqueue(block)
+            return if @job_aborted # ActiveJob 4.2 workaround
+
+            enqueued = false
+
+            block.call
+
+            enqueued = true
+          ensure
+            unlock(resource: lock_key) unless @job_aborted || enqueued
+          end
+        end
+
+        private
+
+        def handle_conflict(on_conflict:, resource:, event: :conflict)
+          case on_conflict
+          when :log then instrument(event, resource: resource)
+          when :raise then raise_not_unique_job_error(resource: resource, event: event)
+          else
+            on_conflict.call(job)
+          end
+        end
+
+        def abort_job
+          @job_aborted = true # ActiveJob 4.2 workaround
+
+          ACTIVEJOB_SUPPORTS_THROW_ABORT ? throw(:abort) : false
+        end
+
+        def instrument(action, payload = {})
+          ActiveSupport::Notifications.instrument "#{action}.active_job_uniqueness", payload.merge(job: job)
+        end
+
+        def raise_not_unique_job_error(resource:, event:)
+          message = [
+            job.class.name,
+            "(Job ID: #{job.job_id})",
+            "(Lock key: #{resource})",
+            job.arguments.inspect
+          ]
+
+          message.unshift(event == :runtime_conflict ? 'Not unique runtime' : 'Not unique')
+
+          raise JobNotUnique, message.join(' ')
+        end
+      end
+    end
+  end
+end

data/lib/active_job/uniqueness/strategies/until_and_while_executing.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Uniqueness
+    module Strategies
+      # Locks the job when it is pushed to the queue.
+      # Unlocks the job before the job is started.
+      # Then creates runtime lock to prevent simultaneous jobs from being executed.
+      class UntilAndWhileExecuting < Base
+        include LockingOnEnqueue
+
+        attr_reader :runtime_lock_ttl, :on_runtime_conflict
+
+        def initialize(runtime_lock_ttl: nil, on_runtime_conflict: nil, **params)
+          super(params)
+          @runtime_lock_ttl = runtime_lock_ttl.present? ? runtime_lock_ttl.to_i * 1000 : lock_ttl
+          @on_runtime_conflict = on_runtime_conflict || on_conflict
+        end
+
+        def before_perform
+          unlock(resource: lock_key)
+
+          return if lock(resource: runtime_lock_key, ttl: runtime_lock_ttl, event: :runtime_lock)
+
+          handle_conflict(on_conflict: on_runtime_conflict, resource: runtime_lock_key, event: :runtime_conflict)
+          abort_job
+        end
+
+        def around_perform(block)
+          return if @job_aborted # ActiveJob 4.2 workaround
+
+          block.call
+        ensure
+          unlock(resource: runtime_lock_key, event: :runtime_unlock) unless @job_aborted
+        end
+
+        def runtime_lock_key
+          [lock_key, 'runtime'].join(':')
+        end
+      end
+    end
+  end
+end

data/lib/active_job/uniqueness/strategies/until_executed.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Uniqueness
+    module Strategies
+      # Locks the job when it is pushed to the queue.
+      # Unlocks the job when the job is finished.
+      class UntilExecuted < Base
+        include LockingOnEnqueue
+
+        def after_perform
+          unlock(resource: lock_key)
+        end
+      end
+    end
+  end
+end

data/lib/active_job/uniqueness/strategies/until_executing.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Uniqueness
+    module Strategies
+      # Locks the job when it is pushed to the queue.
+      # Unlocks the job before the job is started.
+      class UntilExecuting < Base
+        include LockingOnEnqueue
+
+        def before_perform
+          unlock(resource: lock_key)
+        end
+      end
+    end
+  end
+end

data/lib/active_job/uniqueness/strategies/until_expired.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Uniqueness
+    module Strategies
+      # Locks the job when it is pushed to the queue.
+      # Does not allow new jobs enqueued until lock is expired.
+      class UntilExpired < Base
+        include LockingOnEnqueue
+      end
+    end
+  end
+end

data/lib/active_job/uniqueness/strategies/while_executing.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Uniqueness
+    module Strategies
+      # Locks the job when the job starts.
+      # Unlocks the job when the job is finished.
+      class WhileExecuting < Base
+        def before_perform
+          return if lock(resource: lock_key, ttl: lock_ttl, event: :runtime_lock)
+
+          handle_conflict(resource: lock_key, event: :runtime_conflict, on_conflict: on_conflict)
+          abort_job
+        end
+
+        def around_perform(block)
+          return if @job_aborted # ActiveJob 4.2 workaround
+
+          block.call
+        ensure
+          unlock(resource: lock_key, event: :runtime_unlock) unless @job_aborted
+        end
+      end
+    end
+  end
+end

data/lib/active_job/uniqueness/test_lock_manager.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Uniqueness
+    # Mocks ActiveJob::Uniqueness::LockManager methods.
+    # See ActiveJob::Uniqueness.test_mode!
+    class TestLockManager
+      def lock(*_args)
+        true
+      end
+
+      alias delete_lock lock
+      alias delete_locks lock
+    end
+  end
+end

data/lib/active_job/uniqueness/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Uniqueness
+    VERSION = '0.1.0'
+  end
+end

data/lib/activejob/uniqueness.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'active_job/uniqueness'

data/lib/generators/active_job/uniqueness/install_generator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Uniqueness
+    module Generators
+      class InstallGenerator < Rails::Generators::Base
+        desc 'Copy ActiveJob::Uniqueness default files'
+        source_root File.expand_path('templates', __dir__)
+
+        def copy_config
+          template 'config/initializers/active_job_uniqueness.rb'
+        end
+      end
+    end
+  end
+end

data/lib/generators/active_job/uniqueness/templates/config/initializers/active_job_uniqueness.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+ActiveJob::Uniqueness.configure do |config|
+  # Global default expiration for lock keys. Each job can define its own ttl via :lock_ttl option.
+  # Stategy :until_and_while_executing also accept :on_runtime_ttl option.
+  #
+  # config.lock_ttl = 1.day
+
+  # Prefix for lock keys. Can not be set per job.
+  #
+  # config.lock_prefix = 'activejob_uniqueness'
+
+  # Default action on lock conflict. Can be set per job.
+  # Stategy :until_and_while_executing also accept :on_runtime_conflict option.
+  # Allowed values are
+  #   :raise - raises ActiveJob::Uniqueness::JobNotUnique
+  #   :log - instruments ActiveSupport::Notifications and logs event to the ActiveJob::Logger
+  #   proc - custom Proc. For example, ->(job) { job.logger.info('Oops') }
+  #
+  # config.on_conflict = :raise
+
+  # Digest method for lock keys generating. Expected to have `hexdigest` class method.
+  #
+  # config.digest_method = OpenSSL::Digest::MD5
+
+  # Array of redis servers for Redlock quorum.
+  # Read more at https://github.com/leandromoreira/redlock-rb#redis-client-configuration
+  #
+  # config.redlock_servers = [ENV.fetch('REDIS_URL', 'redis://localhost:6379')]
+
+  # Custom options for Redlock.
+  # Read more at https://github.com/leandromoreira/redlock-rb#redlock-configuration
+  #
+  # config.redlock_options = {}
+
+  # Custom strategies.
+  # config.lock_strategies = { my_strategy: MyStrategy }
+  #
+  # config.lock_strategies = {}
+end

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification
+name: activejob-uniqueness
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Rustam Sharshenov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-07-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activejob
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: redlock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: pry-byebug
+  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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Ensure uniqueness of your ActiveJob jobs
+email:
+- rustam@sharshenov.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- activejob-uniqueness.gemspec
+- lib/active_job/uniqueness.rb
+- lib/active_job/uniqueness/configuration.rb
+- lib/active_job/uniqueness/errors.rb
+- lib/active_job/uniqueness/lock_key.rb
+- lib/active_job/uniqueness/lock_manager.rb
+- lib/active_job/uniqueness/log_subscriber.rb
+- lib/active_job/uniqueness/patch.rb
+- lib/active_job/uniqueness/strategies.rb
+- lib/active_job/uniqueness/strategies/base.rb
+- lib/active_job/uniqueness/strategies/until_and_while_executing.rb
+- lib/active_job/uniqueness/strategies/until_executed.rb
+- lib/active_job/uniqueness/strategies/until_executing.rb
+- lib/active_job/uniqueness/strategies/until_expired.rb
+- lib/active_job/uniqueness/strategies/while_executing.rb
+- lib/active_job/uniqueness/test_lock_manager.rb
+- lib/active_job/uniqueness/version.rb
+- lib/activejob/uniqueness.rb
+- lib/generators/active_job/uniqueness/install_generator.rb
+- lib/generators/active_job/uniqueness/templates/config/initializers/active_job_uniqueness.rb
+homepage: https://github.com/veeqo/activejob-uniqueness
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/veeqo/activejob-uniqueness
+  source_code_uri: https://github.com/veeqo/activejob-uniqueness
+  changelog_uri: https://github.com/veeqo/activejob-uniqueness/blob/master/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+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: []
+rubygems_version: 3.0.6
+signing_key: 
+specification_version: 4
+summary: Ensure uniqueness of your ActiveJob jobs
+test_files: []