multi-background-job 0.1.0

data/lib/multi_background_job/middleware/unique_job/faktory.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# Server midleware for Faktory
+#
+# @see https://github.com/contribsys/faktory_worker_ruby/wiki/Middleware
+module MultiBackgroundJob
+  module Middleware
+    class UniqueJob
+      module Faktory
+        def self.bootstrap
+          if defined?(::Faktory)
+            ::Faktory.configure_worker do |config|
+              config.worker_middleware do |chain|
+                chain.add Worker
+              end
+            end
+          end
+        end
+
+        # Worker middleware runs around the execution of a job
+        class Worker
+          def call(_jobinst, payload)
+            if payload.is_a?(Hash) && (unique_lock = unique_job_lock(payload))
+              unique_lock.unlock
+            end
+            yield
+          end
+
+          protected
+
+          def unique_job_lock(payload)
+            return unless payload['uniq'].is_a?(Hash)
+
+            unique_job = ::MultiBackgroundJob::UniqueJob.coerce(payload['uniq'])
+            unique_job&.lock
+          end
+        end
+      end
+    end
+  end
+end

data/lib/multi_background_job/middleware/unique_job/sidekiq.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+
+# Provides the Sidekiq middleware that make the unique job control work
+#
+# @see https://github.com/contribsys/faktory_worker_ruby/wiki/Middleware
+module MultiBackgroundJob
+  module Middleware
+    class UniqueJob
+      module Sidekiq
+        def self.bootstrap
+          if defined?(::Sidekiq)
+            ::Sidekiq.configure_worker do |config|
+              config.worker_middleware do |chain|
+                chain.add Worker
+              end
+            end
+          end
+        end
+
+        # Worker middleware runs around the execution of a job
+        class Worker
+          # @param worker [Object] the worker instance
+          # @param job [Hash] the full job payload
+          #   * @see https://github.com/mperham/sidekiq/wiki/Job-Format
+          # @param queue [String] the name of the queue the job was pulled from
+          # @yield the next middleware in the chain or worker `perform` method
+          # @return [Void]
+          def call(_worker, job, _queue)
+            if job.is_a?(Hash) && (unique_lock = unique_job_lock(job))
+              unique_lock.unlock
+            end
+            yield
+          end
+
+          protected
+
+          def unique_job_lock(job)
+            return unless job['uniq'].is_a?(Hash)
+
+            unique_job = ::MultiBackgroundJob::UniqueJob.coerce(job['uniq'])
+            unique_job&.lock
+          end
+        end
+      end
+    end
+  end
+end

data/lib/multi_background_job/middleware_chain.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module MultiBackgroundJob
+  # Middleware is code configured to run before/after push a new job.
+  # It is patterned after Rack middleware for some modification before push the job to the server
+  #
+  # To add a middleware:
+  #
+  # MultiBackgroundJob.configure do |config|
+  #   config.middleware do |chain|
+  #     chain.add MyMiddleware
+  #   end
+  # end
+  #
+  # This is an example of a minimal middleware, note the method must return the result
+  # or the job will not push the server.
+  #
+  # class MyMiddleware
+  #   def call(job, conn_pool)
+  #     puts "Before push"
+  #     result = yield
+  #     puts "After push"
+  #     result
+  #   end
+  # end
+  #
+  class MiddlewareChain
+    include Enumerable
+    attr_reader :entries
+
+    def initialize_copy(copy)
+      copy.instance_variable_set(:@entries, entries.dup)
+    end
+
+    def each(&block)
+      entries.each(&block)
+    end
+
+    def initialize
+      @entries = []
+      yield self if block_given?
+    end
+
+    def remove(klass)
+      entries.delete_if { |entry| entry.klass == klass }
+    end
+
+    def add(klass, *args)
+      remove(klass) if exists?(klass)
+      entries << Entry.new(klass, *args)
+    end
+
+    def prepend(klass, *args)
+      remove(klass) if exists?(klass)
+      entries.insert(0, Entry.new(klass, *args))
+    end
+
+    def insert_before(oldklass, newklass, *args)
+      i = entries.index { |entry| entry.klass == newklass }
+      new_entry = i.nil? ? Entry.new(newklass, *args) : entries.delete_at(i)
+      i = entries.index { |entry| entry.klass == oldklass } || 0
+      entries.insert(i, new_entry)
+    end
+
+    def insert_after(oldklass, newklass, *args)
+      i = entries.index { |entry| entry.klass == newklass }
+      new_entry = i.nil? ? Entry.new(newklass, *args) : entries.delete_at(i)
+      i = entries.index { |entry| entry.klass == oldklass } || entries.count - 1
+      entries.insert(i+1, new_entry)
+    end
+
+    def exists?(klass)
+      any? { |entry| entry.klass == klass }
+    end
+
+    def retrieve
+      map(&:make_new)
+    end
+
+    def clear
+      entries.clear
+    end
+
+    def invoke(*args)
+      chain = retrieve.dup
+      traverse_chain = lambda do
+        if chain.empty?
+          yield
+        else
+          chain.pop.call(*args, &traverse_chain)
+        end
+      end
+      traverse_chain.call
+    end
+
+    class Entry
+      attr_reader :klass, :args
+
+      def initialize(klass, *args)
+        @klass = klass
+        @args  = args
+      end
+
+      def make_new
+        @klass.new(*@args)
+      end
+    end
+  end
+end

data/lib/multi_background_job/unique_job.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative './lock'
+
+module MultiBackgroundJob
+  class UniqueJob
+    VALID_OPTIONS = {
+      across: %i[queue systemwide],
+      timeout: 604800, # 1 week
+      unlock_policy: %i[success start],
+    }.freeze
+
+    attr_reader :across, :timeout, :unlock_policy, :lock
+
+    # @options [Hash] Unique definitions
+    # @option [Symbol] :across Valid options are :queue and :systemwide. If jobs should not to be duplicated on
+    #   current queue or the entire system
+    # @option [Integer] :timeout Amount of times in seconds. Timeout decides how long to wait for acquiring the lock.
+    #   A default timeout is defined to 1 week so unique locks won't last forever.
+    # @option [Symbol] :unlock_policy Control when the unique lock is removed. The default value is `success`.
+    #   The job will not unlock until it executes successfully, it will remain locked even if it raises an error and
+    #   goes into the retry queue. The alternative value is `start` the job will unlock right before it starts executing
+    def initialize(across: :queue, timeout: nil, unlock_policy: :success, lock: nil)
+      unless VALID_OPTIONS[:across].include?(across.to_sym)
+        raise Error, format('Invalid `across: %<given>p` option. Only %<expected>p are allowed.',
+          given: across,
+          expected: VALID_OPTIONS[:across])
+      end
+      unless VALID_OPTIONS[:unlock_policy].include?(unlock_policy.to_sym)
+        raise Error, format('Invalid `unlock_policy: %<given>p` option. Only %<expected>p are allowed.',
+          given: unlock_policy,
+          expected: VALID_OPTIONS[:unlock_policy])
+      end
+      timeout = VALID_OPTIONS[:timeout] if timeout.to_i <= 0
+
+      @across = across.to_sym
+      @timeout = timeout.to_i
+      @unlock_policy = unlock_policy.to_sym
+      @lock = lock if lock.is_a?(MultiBackgroundJob::Lock)
+    end
+
+    def self.coerce(value)
+      return unless value.is_a?(Hash)
+
+      new(
+        across: (value['across'] || value[:across] || :queue).to_sym,
+        timeout: (value['timeout'] || value[:timeout] || nil),
+        unlock_policy: (value['unlock_policy'] || value[:unlock_policy] || :success).to_sym,
+      ).tap do |instance|
+        instance.lock = value['lock'] || value[:lock]
+      end
+    end
+
+    def ttl
+      Time.now.to_f + timeout
+    end
+
+    def to_hash
+      {
+        'across' => (across.to_s if across),
+        'timeout' => timeout,
+        'unlock_policy' => (unlock_policy.to_s if unlock_policy),
+      }.tap do |hash|
+        hash['lock'] = lock.to_hash if lock
+      end
+    end
+
+    def eql?(other)
+      return false unless other.is_a?(self.class)
+
+      [across, timeout, unlock_policy] == [other.across, other.timeout, other.unlock_policy]
+    end
+    alias == eql?
+
+    def lock=(value)
+      @lock = case value
+      when MultiBackgroundJob::Lock then value
+      when Hash then MultiBackgroundJob::Lock.coerce(value)
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/multi_background_job/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MultiBackgroundJob
+  VERSION = '0.1.0'
+end

data/lib/multi_background_job/worker.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative './unique_job'
+
+module MultiBackgroundJob
+  class Worker
+    attr_reader :options, :payload, :worker_class, :unique_job
+
+    attr_reader :arguments
+
+    def initialize(worker_class, **options)
+      @worker_class = worker_class
+      @options = options
+      @payload = {}
+      unique(@options.delete(:uniq)) if @options.key?(:uniq)
+    end
+
+    def self.coerce(service:, payload:, **opts)
+      SERVICES.fetch(service).coerce_to_worker(payload, **opts)
+    end
+
+    %i[created_at enqueued_at].each do |method_name|
+      define_method method_name do |value|
+        @payload[method_name.to_s] = \
+          case value
+          when Numeric then value.to_f
+          when String then Time.parse(value).to_f
+          when Time, DateTime then value.to_f
+          else
+            raise ArgumentError, format('The %<v>p is not a valid value for %<m>s.', v: value, m: method_name)
+          end
+
+        self
+      end
+    end
+
+    # Adds arguments to the job
+    # @return self
+    def with_args(*args)
+      @payload['args'] = args
+
+      self
+    end
+
+    # Schedule the time when a job will be executed. Jobs which are scheduled in the past are enqueued for immediate execution.
+    # @param timestamp [Numeric] timestamp, numeric or something that acts numeric.
+    # @return self
+    def in(timestamp)
+      now = Time.now.to_f
+      timestamp = Time.parse(timestamp) if timestamp.is_a?(String)
+      int = timestamp.respond_to?(:strftime) ? timestamp.to_f : now + timestamp.to_f
+      return self if int <= now
+
+      @payload['at'] = int
+      @payload['created_at'] = now
+
+      self
+    end
+    alias_method :at, :in
+
+    # Wrap uniq options
+    #
+    # @param value [Hash] Unique configurations with `across`, `timeout` and `unlock_policy`
+    # @return self
+    def unique(value)
+      value = {} if value == true
+      @unique_job = \
+        case value
+        when Hash then UniqueJob.coerce(value)
+        when UniqueJob then value
+        else
+          nil
+        end
+
+      self
+    end
+
+    def with_job_jid(jid = nil)
+      @payload['jid'] ||= jid || MultiBackgroundJob.jid
+
+      self
+    end
+
+    # @param :to [Symbol] Adapter key
+    # @return Response of service
+    # @see MultiBackgroundJob::Adapters::** for more details
+    def push(to: nil)
+      to ||= options[:service]
+      unless SERVICES.include?(to)
+        raise Error, format('Service %<to>p is not implemented. Please use one of %<list>p', to: to, list: SERVICES.keys)
+      end
+
+      @payload['created_at'] ||= Time.now.to_f
+      worker_to_push = with_job_jid
+      MultiBackgroundJob.config.middleware.invoke(worker_to_push, to) do
+        SERVICES[to].push(worker_to_push)
+      end
+    end
+
+    def eql?(other)
+      return false unless other.is_a?(self.class)
+
+      worker_class == other.worker_class && \
+        payload == other.payload &&
+        options == other.options &&
+        unique_job == other.unique_job
+    end
+    alias == eql?
+
+    def unique_job?
+      unique_job.is_a?(UniqueJob)
+    end
+  end
+end

data/lib/multi_background_job/workers/faktory.rb

@@ -0,0 +1,28 @@
+# frizen_string_literal: true
+
+require_relative './shared_class_methods'
+
+module MultiBackgroundJob
+  module Workers
+    module Faktory
+      def self.extended(base)
+        base.include(::Faktory::Job) if defined?(::Faktory)
+        base.extend SharedClassMethods
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        def service_worker_options
+          default_queue = MultiBackgroundJob.config.workers.dig(self.name, :queue)
+          default_retry = MultiBackgroundJob.config.workers.dig(self.name, :retry)
+          default_queue ||= ::Faktory.default_job_options['queue'] if defined?(::Faktory)
+          default_retry ||= ::Faktory.default_job_options['retry'] if defined?(::Faktory)
+          {
+            queue: (default_queue || 'default'),
+            retry: (default_retry || 25),
+          }
+        end
+      end
+    end
+  end
+end

data/lib/multi_background_job/workers/shared_class_methods.rb

@@ -0,0 +1,26 @@
+# frizen_string_literal: true
+
+module MultiBackgroundJob
+  module Workers
+    module SharedClassMethods
+      def perform_async(*args)
+        build_worker.with_args(*args).push
+      end
+
+      def perform_in(interval, *args)
+        build_worker.with_args(*args).at(interval).push
+      end
+      alias_method :perform_at, :perform_in
+
+      protected
+
+      def service_worker_options
+        {}
+      end
+
+      def build_worker
+        MultiBackgroundJob[self.name, **service_worker_options.merge(bg_worker_options)]
+      end
+    end
+  end
+end