background_job 0.0.1.rc1

data/lib/background_job/configuration/middleware_chain.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module BackgroundJob
+  # 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:
+  #
+  # BackgroundJob.config_for(:sidekiq) 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 Configuration::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/background_job/configuration/sidekiq.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module BackgroundJob
+  class Configuration::Sidekiq < Configuration::Base
+    attribute_accessor :redis, write: false
+    # It's recommended to not use the namespace option in Sidekiq.
+    # @see http://www.mikeperham.com/2015/09/24/storing-data-with-redis/#namespaces
+    attribute_accessor :namespace
+
+    def redis_pool
+      @redis_pool ||= if redis
+        BackgroundJob::RedisPool.new(redis)
+      else
+        BackgroundJob.config.redis_pool
+      end
+    end
+
+    def redis=(value)
+      @redis_pool = nil
+      @redis = value
+    end
+  end
+end

data/lib/background_job/configuration.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module BackgroundJob
+  class ConfigService < Set
+    def sidekiq?
+      include?(:sidekiq)
+    end
+
+    def faktory?
+      include?(:faktory)
+    end
+  end
+
+  class Configuration
+    attr_reader :redis
+
+    def redis=(value)
+      @redis_pool = nil
+      @redis = value
+    end
+
+    def redis_pool
+      @redis_pool ||= BackgroundJob::RedisPool.new(redis)
+    end
+
+    def services
+      @services ||= ConfigService.new
+    end
+
+    def faktory
+      @faktory ||= begin
+        services.add(:faktory)
+        require_relative 'jobs/faktory'
+        Configuration::Faktory.new
+      end
+      if block_given?
+        yield @faktory
+      else
+        @faktory
+      end
+    end
+
+    def sidekiq
+      @sidekiq ||= begin
+        services.add(:sidekiq)
+        require_relative 'jobs/sidekiq'
+        Configuration::Sidekiq.new
+      end
+      if block_given?
+        yield @sidekiq
+      else
+        @sidekiq
+      end
+    end
+  end
+end
+
+require_relative 'configuration/base'
+require_relative 'configuration/faktory'
+require_relative 'configuration/sidekiq'
+require_relative 'configuration/middleware_chain'

data/lib/background_job/errors.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module BackgroundJob
+  class Error < StandardError
+  end
+
+  class InvalidConfigError < Error
+  end
+  class NotDefinedJobError < Error
+    def initialize(job_class)
+      @job_class = job_class
+    end
+
+    def message
+      format(
+        "The %<job_class>p is not defined and the BackgroundJob is configured to work on strict mode.\n" +
+        "it's highly recommended to include this job class to the list of known jobs.\n" +
+        "Example: `BackgroundJob.config_for(:sidekiq) { |config| config.jobs = { %<job_class>p => {} } }`\n" +
+        'Another option is to set config.strict = false',
+        job_class: @job_class,
+      )
+    end
+  end
+end

data/lib/background_job/jobs/faktory.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative '../mixin/faktory'
+
+module BackgroundJob
+  module Jobs
+    class Faktory < Job
+      def initialize(job_class, **options)
+        super(
+          job_class,
+          **Mixin::Faktory.background_job_options(job_class, strict_check: true),
+          **options
+        )
+        @options.slice(:queue, :reserve_for).each do |key, value|
+          @payload[key.to_s] = value
+        end
+        @payload['jobtype'] = job_class.to_s
+        @payload['retry'] = parse_retry(@options[:retry])
+        @payload['created_at'] ||= Time.now.to_f
+      end
+
+      # Push job to Faktory
+      #   * If job has the 'at' key. Then schedule it
+      #   * Otherwise enqueue for immediate execution
+      #
+      # @raise [BackgroundJob::Error] raise and error when faktory dependency is not loaded
+      # @return [Hash] Payload that was sent to server
+      def push
+        unless Object.const_defined?(:Faktory)
+          raise BackgroundJob::Error, <<~ERR
+          Faktory client for ruby is not loaded. You must install and require https://github.com/contribsys/faktory_job_ruby.
+          ERR
+        end
+        normalize_before_push!
+        pool = Thread.current[:faktory_via_pool] || ::Faktory.server_pool
+        BackgroundJob.config.faktory.middleware.invoke(self, :faktory) do
+          ::Faktory.client_middleware.invoke(payload, pool) do
+            pool.with do |c|
+              c.push(payload)
+            end
+          end
+          payload
+        end
+      end
+
+      protected
+
+      def normalize_before_push!
+        with_job_jid # Generate a unique job id
+        payload['enqueued_at'] = Time.now.to_f
+        {'created_at' => false, 'enqueued_at' => false, 'at' => true}.each do |field, past_remove|
+          # Optimization to enqueue something now that is scheduled to go out now or in the past
+          if (time = payload.delete(field)) &&
+              (!past_remove || (past_remove && time > Time.now.to_f))
+            payload[field] = parse_time(time)
+          end
+        end
+      end
+
+      # Convert job retry value acording to the Go struct datatype.
+      #
+      # * 25 is the default.
+      # * 0 means the job is completely ephemeral. No matter if it fails or succeeds, it will be discarded.
+      # * -1 means the job will go straight to the Dead set if it fails, no retries.
+      def parse_retry(value)
+        case value
+        when Numeric then value.to_i
+        when false then -1
+        else
+          25
+        end
+      end
+
+      def parse_time(value)
+        case value
+        when Numeric then Time.at(value).to_datetime.rfc3339(9)
+        when Time then value.to_datetime.rfc3339(9)
+        when DateTime then value.rfc3339(9)
+        end
+      end
+
+      def to_json(value)
+        MultiJson.dump(value, mode: :compat)
+      end
+    end
+  end
+end

data/lib/background_job/jobs/job.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require_relative '../unique_job'
+
+# DSL used to create a job. It's generic so it can be used with any adapter.
+module BackgroundJob
+  class Jobs::Job
+    attr_reader :options, :payload, :job_class, :unique_job
+
+    def initialize(job_class, **options)
+      @job_class = job_class
+      @options = options
+      @payload = {}
+      unique(@options.delete(:uniq)) if @options.key?(:uniq)
+    end
+
+    # Push the job to the service backend
+    #
+    # @abstract
+    def push
+      raise NotImplementedError
+    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 || BackgroundJob.jid
+
+      self
+    end
+
+    def eql?(other)
+      return false unless other.is_a?(self.class)
+
+      job_class == other.job_class && \
+        payload == other.payload &&
+        options == other.options &&
+        unique_job == other.unique_job
+    end
+    alias == eql?
+
+    def unique_job?
+      unique_job.is_a?(UniqueJob)
+    end
+
+    def to_s
+      # format(
+      #   '#<%<c>s:0x%<o>x job_class=%<j>p, payload=%<p>p, options=%<o>p, unique_job=%<u>p>',
+      #   c: self.class, o: object_id, j: job_class, p: payload, o: options, u: unique_job
+      # )
+      str = format(
+        '#<%<c>s:0x%<o>x job_class=%<j>p',
+        c: self.class, o: object_id, j: job_class
+      )
+      if (args = payload['args'])
+        str += format(', args=%<p>p', p: args)
+      end
+      str += format(', options=%<o>p', o: options) unless options.empty?
+      str += format(', unique_job=%<u>p', u: unique_job) if unique_job
+      str += '>'
+      str
+    end
+
+    private
+
+    # Normalize payload before pushing to the service
+    # @abstract
+    def normalize_before_push!
+      # noop
+    end
+  end
+end

data/lib/background_job/jobs/sidekiq.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative '../mixin/sidekiq'
+
+
+module BackgroundJob
+  module Jobs
+    class Sidekiq < Job
+      OPTIONS_TO_PAYLOAD = %i[queue retry].freeze
+
+      def initialize(job_class, **options)
+        super(
+          job_class,
+          **Mixin::Sidekiq.background_job_options(job_class, strict_check: true),
+          **options,
+        )
+        @options.slice(*OPTIONS_TO_PAYLOAD).each do |key, value|
+          @payload[key.to_s] = value
+        end
+        @payload['class'] = job_class.to_s
+        @payload['created_at'] ||= Time.now.to_f
+      end
+
+      # Push sidekiq to the Sidekiq(Redis actually).
+      #   * If job has the 'at' key. Then schedule it
+      #   * Otherwise enqueue for immediate execution
+      #
+      # @return [Hash] Payload that was sent to redis
+      def push
+        normalize_before_push!
+
+        BackgroundJob.config.sidekiq.middleware.invoke(self, :sidekiq) do
+          # Optimization to enqueue something now that is scheduled to go out now or in the past
+          if (timestamp = payload.delete('at')) && (timestamp > Time.now.to_f)
+            redis_pool.with do |redis|
+              redis.zadd(scheduled_queue_name, timestamp.to_f.to_s, to_json(payload))
+            end
+          else
+            redis_pool.with do |redis|
+              redis.lpush(immediate_queue_name, to_json(payload))
+            end
+          end
+          payload
+        end
+      end
+
+      protected
+
+      def normalize_before_push!
+        with_job_jid # Generate a unique job id
+        payload['enqueued_at'] = Time.now.to_f
+      end
+
+      def redis_pool
+        BackgroundJob.config.sidekiq.redis_pool
+      end
+
+      def namespace
+        BackgroundJob.config.sidekiq.namespace
+      end
+
+      def scheduled_queue_name
+        [namespace, 'schedule'].compact.join(':')
+      end
+
+      def immediate_queue_name
+        [namespace, 'queue', payload.fetch('queue')].compact.join(':')
+      end
+
+      def to_json(value)
+        MultiJson.dump(value, mode: :compat)
+      end
+    end
+  end
+end

data/lib/background_job/jobs.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module BackgroundJob
+  module Jobs
+  end
+end
+
+require_relative 'jobs/job'

data/lib/background_job/lock.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module BackgroundJob
+  # Class Lock provides access to redis "sorted set" used to control unique jobs
+  class Lock
+    attr_reader :digest, :lock_id, :ttl
+
+    # @param :digest [String] It's the uniq string used to group similar jobs
+    # @param :lock_id [String] The uniq job id
+    # @param :ttl [Float] The timestamp related lifietime of the lock before being discarded.
+    def initialize(digest:, lock_id:, ttl:)
+      @digest = digest
+      @lock_id = lock_id
+      @ttl = ttl
+    end
+
+    # Initialize a Lock object from hash
+    #
+    # @param value [Hash] Hash with lock properties
+    # @return [BackgroundJob::Lock, nil]
+    def self.coerce(value)
+      return unless value.is_a?(Hash)
+
+      digest = value[:digest] || value['digest']
+      lock_id = value[:lock_id] || value['lock_id']
+      ttl = value[:ttl] || value['ttl']
+      return if [digest, lock_id, ttl].any?(&:nil?)
+
+      new(digest: digest, lock_id: lock_id, ttl: ttl)
+    end
+
+    # Remove expired locks from redis "sorted set"
+    #
+    # @param [String] digest It's the uniq string used to group similar jobs
+    def self.flush_expired_members(digest, redis: nil)
+      return unless digest
+
+      caller = ->(redis) { redis.zremrangebyscore(digest, '-inf', "(#{now}") }
+
+      if redis
+        caller.(redis)
+      else
+        BackgroundJob.config.redis_pool.with { |conn| caller.(conn) }
+      end
+    end
+
+    # Remove all locks from redis "sorted set"
+    #
+    # @param [String] digest It's the uniq string used to group similar jobs
+    def self.flush(digest, redis: nil)
+      return unless digest
+
+      caller = ->(conn) { conn.del(digest) }
+
+      if redis
+        caller.(redis)
+      else
+        BackgroundJob.config.redis_pool.with { |conn| caller.(conn) }
+      end
+    end
+
+    # Number of locks
+    #
+    # @param digest [String] It's the uniq string used to group similar jobs
+    # @option [Number] from The begin of set. Default to 0
+    # @option [Number] to The end of set. Default to the timestamp of 1 week from now
+    # @return Number the amount of entries that within digest
+    def self.count(digest, from: 0, to: nil, redis: nil)
+      to ||= Time.now.to_f + BackgroundJob::UniqueJob::VALID_OPTIONS[:timeout]
+      caller = ->(conn) { conn.zcount(digest, from, to) }
+
+      if redis
+        caller.(redis)
+      else
+        BackgroundJob.config.redis_pool.with { |conn| caller.(conn) }
+      end
+    end
+
+    def to_hash
+      {
+        'ttl' => ttl,
+        'digest' => (digest.to_s if digest),
+        'lock_id' => (lock_id.to_s if lock_id),
+      }
+    end
+
+    # @return [Float] A float timestamp of current time
+    def self.now
+      Time.now.to_f
+    end
+
+    # Remove lock_id lock from redis
+    # @return [Boolean] Returns true when it's locked or false when there is no lock
+    def unlock
+      redis_pool.with do |conn|
+        conn.zrem(digest, lock_id)
+      end
+    end
+
+    # Adds lock_id lock to redis
+    # @return [Boolean] Returns true when it's a fresh lock or false when lock already exists
+    def lock
+      redis_pool.with do |conn|
+        conn.zadd(digest, ttl, lock_id)
+      end
+    end
+
+    # Check if the lock_id lock exist
+    # @return [Boolean] true or false when lock exist or not
+    def locked?
+      locked = false
+
+      redis_pool.with do |conn|
+        timestamp = conn.zscore(digest, lock_id)
+        return false unless timestamp
+
+        locked = timestamp >= now
+        self.class.flush_expired_members(digest, redis: conn)
+      end
+
+      locked
+    end
+
+    def eql?(other)
+      return false unless other.is_a?(self.class)
+
+      [digest, lock_id, ttl] == [other.digest, other.lock_id, other.ttl]
+    end
+    alias == eql?
+
+    protected
+
+    def now
+      self.class.now
+    end
+
+    def redis_pool
+      BackgroundJob.config.redis_pool
+    end
+  end
+end

data/lib/background_job/lock_digest.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module BackgroundJob
+  # Class Lock generates the uniq digest acording to the uniq config
+  class LockDigest
+    NAMESPACE = 'bgjb'
+    BASE = 'uniq'.freeze
+    SEPARATOR = ':'.freeze
+
+    def initialize(*keys, across:)
+      @keys = keys.map { |k| k.to_s.strip.downcase }
+      @across = across.to_sym
+    end
+
+    def to_s
+      case @across
+      when :systemwide
+        build_name(*@keys.slice(0..-2))
+      when :queue
+        build_name(*@keys)
+      else
+        raise Error, format(
+          'Could not resolve the lock digest using across %<across>p. ' +
+          'Valid options are :systemwide and :queue',
+          across: @across,
+        )
+      end
+    end
+
+    private
+
+    def build_name(*segments)
+      [NAMESPACE, BASE, *segments].compact.join(SEPARATOR)
+    end
+  end
+end