exekutor 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5bc7c7a8f6af32b1f764124d3905673240c167abd19b93e492016433414078a9
+  data.tar.gz: 37f8fb516c32a2a71595b2d608b2610ba78a5396e7f1b1e6bc7c2e90da8d770d
+SHA512:
+  metadata.gz: 8f36b7e5a5968009ba7f33657a0444053a72a5e7b91ebb8e5605c435d80a6861eec4a2d39af81c71ec6e88564a57f7d91fdaca43182ca9e5faf8c86cdd5ab7ff
+  data.tar.gz: ab262caf9827f3eccd5995309b8f0debc0da125af459b8a8321fbd43c6a25d9bcd42dc6fa65f5a98bbb341be07fca4251a8ab73860d01c2ce43efd388499a145

checksums.yaml.gz.sig

@@ -0,0 +1,3 @@
+e.o����+s�9�=S�����y��C����[6*�s���>��؁Wu ��._���
q���_��.�No�57Z�U�t�'kj}�V�l���9h�?���@ЋYݭJ�nW
+���a ��XF�B#�]6|���R�!�YҚ��Ʃ��0P��FG�"q��2�{<���b��W{��^��gAm034R/��q�f.r��"�:�I��h0�>�|y�ry�g1r�8�^�#ۆ�7�/�W����G�v�1+���F�q�<�����y%��7Ҁ��9�sc�jc�0�Z����Ϯ��LP��%�
+��;g\Rl��g���K_�1W�-J����YՃXz��js;���|����_���4{	B�WV�sڟ6	�7vʇ�b4�

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Roy
+
+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/exe/exekutor

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+require "exekutor/internal/cli/app"
+
+Process.setproctitle "Exekutor worker (Initializing…) [#{$PROGRAM_NAME}]"
+
+exit Exekutor::Internal::CLI::App.run(ARGV)

data/lib/active_job/queue_adapters/exekutor_adapter.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+require "active_job"
+require "active_job/queue_adapters"
+
+module ActiveJob
+  module QueueAdapters
+    # The active job queue adapter for Exekutor
+    class ExekutorAdapter < Exekutor::Queue
+      alias enqueue push
+      alias enqueue_all push
+      alias enqueue_at schedule_at
+    end
+  end
+end

data/lib/exekutor/asynchronous.rb

@@ -0,0 +1,188 @@
+module Exekutor
+  # Mixin to let methods be executed asynchronously by active job
+  #
+  # @example Mark methods as asynchronous
+  #    class MyClass
+  #      include Exekutor::Asynchronous
+  #
+  #      def instance_method
+  #        puts "This will be performed by an Exekutor worker"
+  #      end
+  #      perform_asynchronously :instance_method
+  #
+  #      def self.class_method(str)
+  #        puts "This will also be performed by an Exekutor worker: #{str}"
+  #      end
+  #      perform_asynchronously :class_method, class_method: true
+  #    end
+  module Asynchronous
+    extend ActiveSupport::Concern
+
+    included do
+      mattr_reader :__async_class_methods, instance_accessor: false, default: {}
+      mattr_reader :__async_instance_methods, instance_accessor: false, default: {}
+      private_class_method :perform_asynchronously
+    end
+
+    class_methods do
+      # Changes a method to be executed asynchronously.
+      # Be aware that you can no longer use the return value for
+      # asynchronous methods, because the actual method will be performed by a worker at a later time. The new
+      # implementation of the method will always return an instance of {AsyncMethodJob}.
+      # If the method takes parameters they must be serializable by active job, otherwise an
+      # +ActiveJob::SerializationError+ will be raised.
+      # @param method_name [Symbol] the method to be executed asynchronous
+      # @param alias_to [String] specifies the new name for the synchronous method
+      # @param class_method [Boolean] whether the method is a class method.
+      # @raise [Error] if the method could not be replaced with the asynchronous version
+      def perform_asynchronously(method_name, alias_to: "__immediately_#{method_name}", class_method: false)
+        raise ArgumentError, "method_name must be a Symbol (actual: #{method_name.class.name})" unless method_name.is_a? Symbol
+        raise ArgumentError, "alias_to must be present" unless alias_to.present?
+        if class_method
+          raise ArgumentError, "##{method_name} does not exist" unless respond_to? method_name, true
+
+          delegate = singleton_class
+          definitions = __async_class_methods
+        else
+          unless method_defined?(method_name, true) || private_method_defined?(method_name, true)
+            raise ArgumentError, "##{method_name} does not exist"
+          end
+
+          delegate = self
+          definitions = __async_instance_methods
+        end
+        if definitions.include? method_name
+          raise Error, "##{method_name} was already marked as asynchronous"
+        end
+
+        delegate.alias_method alias_to, method_name
+        delegate.define_method method_name do |*args, **kwargs|
+          error = Asynchronous.validate_args(self, alias_to, *args, **kwargs)
+          raise error if error
+          raise ArgumentError, "Cannot asynchronously execute with a block argument" if block_given?
+          AsyncMethodJob.perform_later self, method_name, [args, kwargs.presence]
+        end
+
+        definitions[method_name] = alias_to
+        if delegate.public_method_defined?(alias_to)
+          delegate.send :public, method_name
+        elsif delegate.protected_method_defined?(alias_to)
+          delegate.send :protected, method_name
+        else
+          delegate.send :private, method_name
+        end
+      end
+    end
+
+    private
+
+    # Validates whether the given arguments match the expected parameters for +method+
+    # @param delegate [Object] the object the +method+ will be called on
+    # @param method [Symbol] the method that will be called on +delegate+
+    # @param args [Array] the arguments that will be given to the method
+    # @param kwargs [Hash] the keyword arguments that will be given to the method
+    # @return [ArgumentError,nil] nil if the keywords are valid; an ArgumentError otherwise
+    def self.validate_args(delegate, method, *args, **kwargs)
+      obj_method = delegate.method(method)
+      min_arg_length = 0
+      max_arg_length = 0
+      accepts_keywords = false
+      missing_keywords = []
+      unknown_keywords = kwargs.keys
+      obj_method.parameters.each do |type, name|
+        if type == :req
+          min_arg_length += 1
+          max_arg_length += 1 if max_arg_length
+        elsif type == :opt
+          max_arg_length += 1 if max_arg_length
+        elsif type == :rest
+          max_arg_length = nil
+        elsif type == :keyreq
+          accepts_keywords = true
+          missing_keywords << name if kwargs.exclude?(name)
+          unknown_keywords.delete(name)
+        elsif type == :key
+          accepts_keywords = true
+          unknown_keywords.delete(name)
+        elsif type == :keyrest
+          accepts_keywords = true
+          unknown_keywords = []
+        end
+      end
+      if missing_keywords.present?
+        return ArgumentError.new "missing keyword#{"s" if missing_keywords.many?}: #{missing_keywords.map(&:inspect).join(", ")}"
+      end
+      if accepts_keywords
+        if unknown_keywords.present?
+          return ArgumentError.new "unknown keyword#{"s" if unknown_keywords.many?}: #{unknown_keywords.map(&:inspect).join(", ")}"
+        end
+      elsif kwargs.present?
+        args += [kwargs]
+      end
+
+      args_len = args.length
+      if min_arg_length > args_len || (max_arg_length.present? && max_arg_length < args_len)
+        expected = min_arg_length.to_s
+        if max_arg_length.nil?
+          expected += "+"
+        elsif max_arg_length > min_arg_length
+          expected += "..#{max_arg_length}"
+        end
+        return ArgumentError.new "wrong number of arguments (given #{args_len}, expected #{expected})"
+      end
+    end
+
+    # The internal job used for {Exekutor::Asynchronous}. Only works for methods that are marked as asynchronous to
+    # prevent remote code execution. Include the {Exekutor::Asynchronous} and call
+    # {Exekutor::Asynchronous#perform_asynchronously} to mark a method as asynchronous.
+    class AsyncMethodJob < ActiveJob::Base
+
+      # Calls the original, synchronous method
+      # @!visibility private
+      def perform(object, method, args)
+        check_object! object
+        method_alias = check_method! object, method
+        args, kwargs = args
+        if kwargs
+          object.__send__(method_alias, *args, **kwargs)
+        else
+          object.__send__(method_alias, *args)
+        end
+      end
+
+      private
+
+      def check_object!(object)
+        if object.nil?
+          raise Error, "Object cannot be nil"
+        elsif object.is_a? Class
+          unless object.included_modules.include? Asynchronous
+            raise Error, "Object has not included Exekutor::Asynchronous"
+          end
+        else
+          raise Error, "Object has not included Exekutor::Asynchronous" unless object.is_a? Asynchronous
+        end
+      end
+
+      def check_method!(object, method)
+        if object.is_a? Class
+          class_name = object.name
+          definitions = object.__async_class_methods
+        else
+          class_name = object.class.name
+          definitions = object.class.__async_instance_methods
+        end
+        unless object.respond_to? method, true
+          raise Error, "#{class_name} does not respond to #{method}"
+        end
+        unless definitions.include? method.to_sym
+          raise Error, "#{class_name}##{method} is not marked as asynchronous"
+        end
+        definitions[method.to_sym]
+      end
+    end
+
+    # Raised when an error occurs while configuring or executing asynchronous methods
+    class Error < Exekutor::DiscardJob; end
+  end
+end

data/lib/exekutor/cleanup.rb

@@ -0,0 +1,56 @@
+module Exekutor
+  # Helper class to clean up finished jobs and stale workers.
+  class Cleanup
+
+    # Purges all workers where the last heartbeat is over the +timeout+ ago.
+    # @param timeout [ActiveSupport::Duration,Numeric,Time] the timeout. Default: 4 hours
+    # @return [Array<Exekutor::Info::Worker>] the purged workers
+    def cleanup_workers(timeout: 4.hours)
+      destroy_before = case timeout
+                       when ActiveSupport::Duration
+                         timeout.ago
+                       when Numeric
+                         timeout.hours.ago
+                       when Date, Time
+                         timeout
+                       else
+                         raise ArgumentError, "Unsupported value for timeout: #{timeout.class}"
+                       end
+      # TODO PG-NOTIFY each worker with an EXIT command
+      Exekutor::Info::Worker.where(%{"last_heartbeat_at"<?}, destroy_before).destroy_all
+    end
+
+    # Purges all jobs where scheduled at is before +before+. Only purges jobs with the given status, if no status is
+    # given all jobs that are not pending are purged.
+    # @param before [ActiveSupport::Duration,Numeric,Time] the maximum scheduled at. Default: 48 hours ago
+    # @param status [Array<String,Symbol>,String,Symbol] the statuses to purge. Default: All except +:pending+
+    # @return [Integer] the number of purged jobs
+    def cleanup_jobs(before: 48.hours.ago, status: nil)
+      destroy_before = case before
+                       when ActiveSupport::Duration
+                         before.ago
+                       when Numeric
+                         before.hours.ago
+                       when Date, Time
+                         before
+                       else
+                         raise ArgumentError, "Unsupported value for before: #{before.class}"
+                       end
+      unless [Array, String, Symbol, NilClass].any?(&status.method(:is_a?))
+        raise ArgumentError, "Unsupported value for status: #{status.class}"
+      end
+
+      jobs = Exekutor::Job.all
+      unless before.nil?
+        jobs.where!(%{"scheduled_at"<?}, destroy_before)
+      end
+      if status
+        jobs.where! status: status
+      else
+        jobs = jobs.where.not(status: :p)
+      end
+      jobs.delete_all
+    end
+
+  end
+end

data/lib/exekutor/configuration.rb

@@ -0,0 +1,373 @@
+# frozen_string_literal: true
+
+require_relative "internal/configuration_builder"
+
+module Exekutor
+  # Configuration for the Exekutor library
+  class Configuration
+    include Internal::ConfigurationBuilder
+
+    # @private
+    DEFAULT_BASE_RECORD_CLASS = "ActiveRecord::Base"
+    private_constant "DEFAULT_BASE_RECORD_CLASS"
+
+    # @!macro
+    #   @!method $1
+    #     Gets the default queue priority. Is used when enqueueing jobs that don't have a priority set.
+    #     === Default value:
+    #     16,383
+    #     @return [Integer]
+    #   @!method $1=(value)
+    #     Sets the default queue priority. Is used when enqueueing jobs that don't have a priority set. Should be
+    #     between 1 and 32,767.
+    #     @raise [Error] When the priority is nil or invalid
+    #     @param value [Integer] the priority
+    #     @return [self]
+    define_option :default_queue_priority, default: 16_383, required: true, type: Integer,
+                  range: Exekutor::Queue::VALID_PRIORITIES
+
+    # @!macro
+    #   @!method $1
+    #     Gets the base class name for database records.
+    #     === Default value:
+    #     +"ActiveRecord::Base"+
+    #     @return [String]
+    #   @!method $1=(value)
+    #     Sets the base class name for database records. The validity of this value will not be checked immediately.
+    #     (Ie. When the specified class does not exist, an error will raised when a database record is used for the
+    #     first time.)
+    #     @raise [Error] When the name is blank
+    #     @param value [String] the class name
+    #     @return [self]
+    define_option :base_record_class_name, default: DEFAULT_BASE_RECORD_CLASS, required: true, type: String
+
+    # Gets the base class for database records. Is derived from the {#base_record_class_name} option.
+    # @raise [Error] when the class cannot be found
+    # @return [Class]
+    def base_record_class
+      const_get :base_record_class_name
+    rescue ::StandardError
+      # A nicer message for the default value
+      if base_record_class_name == DEFAULT_BASE_RECORD_CLASS
+        raise Error, "Cannot find ActiveRecord, did you install and load the gem?"
+      end
+
+      raise
+    end
+
+    # @!macro
+    #   @!method $1
+    #     Gets the unconverted JSON serializer value. This can be either a +String+, a +Symbol+, a +Proc+, or the
+    #     serializer.
+    #     === Default value:
+    #     +JSON+
+    #     @return [String,Symbol,Proc,Object]
+    #   @!method $1=(value)
+    #     Sets the JSON serializer. This can be either a +String+, a +Symbol+, a +Proc+, or the serializer. If a
+    #     +String+, +Symbol+, or +Proc+ is given, the serializer will be loaded when it is needed for the first time.
+    #     If the loaded class does not respond to +#dump+ and +#load+ an {Error} will be raised whenever the serializer
+    #     is loaded. If the value is neither a +String+, +Symbol+, nor a +Proc+ and it does not respond to +#dump+ and
+    #     +#load+, the error will be thrown immediately.
+    #     @raise [Error] When the value is neither a +String+, +Symbol+, nor a +Proc+ and it does not respond to +#dump+
+    #                    and +#load+
+    #     @param value [String,Symbol,Proc,Object] the serializer
+    #     @return [self]
+    define_option :json_serializer, default: "::JSON", required: true do |value|
+      unless value.is_a?(String) || value.is_a?(Symbol) || value.respond_to?(:call) ||
+        (value.respond_to?(:dump) && value.respond_to?(:load))
+        raise Error, "#json_serializer must either be a String, a Proc, or respond to #dump and #load"
+      end
+    end
+
+    # Gets the JSON serializer. Is derived from the {#json_serializer} option.
+    # @raise [Error] when the class cannot be found, or does not respond to +#dump+ and +#load+
+    # @return [Object]
+    def load_json_serializer
+      raw_value = self.json_serializer
+      if defined?(@json_serializer_instance) && @json_serializer_instance[0] == raw_value
+        return @json_serializer_instance[1]
+      end
+
+      serializer = const_get :json_serializer
+      unless serializer.respond_to?(:dump) && serializer.respond_to?(:load)
+        serializer = serializer.call if serializer.respond_to?(:call)
+        unless serializer.respond_to?(:dump) && serializer.respond_to?(:load)
+          serializer = serializer.new if serializer.respond_to?(:new)
+        end
+      end
+      unless serializer.respond_to?(:dump) && serializer.respond_to?(:load)
+        raise Error, <<~MSG.squish
+          The configured serializer (#{serializer.class}) does not respond to #dump and #load
+        MSG
+      end
+
+      @json_serializer_instance = [raw_value, serializer]
+      serializer
+    end
+
+    # @!macro
+    #   @!method $1
+    #     Gets the logger.
+    #     === Default value:
+    #       Rails.active_job.logger
+    #     @return [ActiveSupport::Logger]
+    #   @!method $1=(value)
+    #     Sets the logger.
+    #     @param value [ActiveSupport::Logger] the logger
+    #     @return [self]
+    define_option :logger, default: -> { Rails.active_job.logger }
+
+    # @!macro
+    #   @!method $1?
+    #     Whether the DB connection name should be set. Only affects the listener, unless started from the CLI.
+    #     === Default value:
+    #     false (true when started from the CLI)
+    #     @return [Boolean, nil]
+    #   @!method $1=(value)
+    #     Sets whether the DB connection name should be set
+    #     @param value [Boolean] whether to name should be set
+    #     @return [self]
+    define_option :set_db_connection_name, type: [TrueClass, FalseClass], required: true
+
+    def set_db_connection_name?
+      if set_db_connection_name.nil?
+        false
+      else
+        set_db_connection_name
+      end
+    end
+
+    # @!macro
+    #   @!method $1?
+    #     Whether the worker should use LISTEN/NOTIFY to listen for jobs.
+    #     === Default value:
+    #     true
+    #     @return [Boolean, nil]
+    #   @!method $1=(value)
+    #     Sets whether the worker should use LISTEN/NOTIFY to listen for jobs
+    #     @param value [Boolean] whether to enable the listener
+    #     @return [self]
+    define_option :enable_listener, reader: :enable_listener?, default: true, type: [TrueClass, FalseClass],
+                  required: true
+
+    # @!macro
+    #   @!method $1?
+    #     Whether the worker should delete jobs after completion.
+    #     === Default value:
+    #     false
+    #     @return [Boolean]
+    #   @!method $1=(value)
+    #     Sets whether the worker should delete jobs after completion
+    #     @param value [Boolean] whether to delete completed jobs
+    #     @return [self]
+    define_option :delete_completed_jobs, reader: :delete_completed_jobs?, required: true,
+                  type: [TrueClass, FalseClass], default: false
+
+    # @!macro
+    #   @!method $1?
+    #     Whether the worker should delete discarded jobs.
+    #     === Default value:
+    #     false
+    #     @return [Boolean]
+    #   @!method $1=(value)
+    #     Sets whether the worker should delete discarded jobs
+    #     @param value [Boolean] whether to delete discarded jobs
+    #     @return [self]
+    define_option :delete_discarded_jobs, reader: :delete_discarded_jobs?, required: true,
+                  type: [TrueClass, FalseClass], default: false
+
+    # @!macro
+    #   @!method $1?
+    #     Whether the worker should delete jobs after they failed to execute.
+    #     === Default value:
+    #     false
+    #     @return [Boolean]
+    #   @!method $1=(value)
+    #     Sets whether the worker should delete jobs after they failed to execute
+    #     @param value [Boolean] whether to delete failed jobs
+    #     @return [self]
+    define_option :delete_failed_jobs, reader: :delete_failed_jobs?, required: true,
+                  type: [TrueClass, FalseClass], default: false
+
+    # @!macro
+    #   @!method $1
+    #     The polling interval in seconds. When set, the worker will poll the database with this interval to check for
+    #     any pending jobs that a listener might have missed (if enabled).
+    #     === Default value:
+    #     60
+    #     @return [Integer]
+    #   @!method $1=(value)
+    #     Sets the polling interval in seconds. Set to +nil+ to disable polling. If the listener is disabled, this value
+    #     should be reasonably low so jobs don't have to wait in the queue too long; if it is enabled, this value can
+    #     be reasonably high.
+    #     @param value [Integer] the interval
+    #     @return [self]
+    define_option :polling_interval, default: 60, type: [Integer, nil], range: 1...(1.day.to_i)
+
+    # @!macro
+    #   @!method $1
+    #     The polling jitter, used to adjust the polling interval slightly so multiple workers will not query the
+    #     database at the same time.
+    #     === Default value:
+    #     0.1
+    #     @return [Float]
+    #   @!method $1=(value)
+    #     Sets the polling jitter, which is used to slightly adjust the polling interval. Should be between 0 and 0.5.
+    #     A value of 0.1 means the polling interval can vary by 10%. If the interval is set to 60 seconds and the jitter
+    #     is set to 0.1, the interval can range from 57 to 63 seconds. A value of 0 disables this feature.
+    #     @param value [Float] the jitter
+    #     @return [self]
+    define_option :polling_jitter, default: 0.1, type: [Float, Integer], range: 0..0.5
+
+    # @!macro
+    #   @!method $1
+    #     The minimum number of execution threads that should be active.
+    #     === Default value:
+    #     1
+    #     @return [Integer]
+    #   @!method $1=(value)
+    #     Sets the minimum number of execution threads that should be active
+    #     @param value [Integer] the number of threads
+    #     @return [self]
+    define_option :min_execution_threads, default: 1, type: Integer, range: 1...999
+
+    # @!macro
+    #   @!method $1
+    #     The maximum number of execution threads that may be active.
+    #     === Default value:
+    #     Active record pool size minus 1, with a minimum of 1
+    #     @return [Integer]
+    #   @!method $1=(value)
+    #     Sets the maximum number of execution threads that may be active. Be aware that if you set this to a value
+    #     greater than +connection_db_config.pool+, workers may have to wait for database connections to become
+    #     available because all connections are occupied by other threads. This may result in an
+    #     +ActiveRecord::ConnectionTimeoutError+ if the thread has to wait too long.
+    #     @param value [Integer] the number of threads
+    #     @return [self]
+    define_option :max_execution_threads,
+                  default: -> { (Internal::BaseRecord.connection_db_config.pool.to_i - 1).clamp(1, 999) },
+                  type: Integer, range: 1...999
+
+    # @!macro
+    #   @!method $1
+    #     The maximum number of seconds a thread may be idle before being stopped.
+    #     === Default value:
+    #     60
+    #     @return [Integer]
+    #   @!method $1=(value)
+    #     Sets the maximum number of seconds a thread may be idle before being stopped
+    #     @param value [Integer] the number of threads
+    #     @return [self]
+    define_option :max_execution_thread_idletime, default: 60, type: Integer, range: 1..(1.day.to_i)
+
+    # @!macro
+    #   @!method $1?
+    #     The rack handler for the status server
+    #     === Default value:
+    #     webrick
+    #     @return [String]
+    #   @!method $1=(value)
+    #     Sets the rack handler for the status server. The handler should respond to +#shutdown+ or +#stop+.
+    #     @param value [String] the name of the handler
+    #     @return [self]
+    define_option :status_server_handler, default: "webrick", type: String
+
+    # @!macro
+    #   @!method $1?
+    #     The heartbeat timeout for the `/live` endpoint of the status server, in minutes. If the heartbeat of a worker
+    #     is older than this timeout, the status server will respond with a 503 status indicating the service is
+    #     down.
+    #     === Default value:
+    #     30
+    #     @return [Integer]
+    #   @!method $1=(value)
+    #     Sets the heartbeat timeout for the `/live` endpoint of the status server, in minutes. Must be between 2
+    #     and 1440 (24 hours).
+    #     @param value [Integer] The timeout in minutes
+    #     @return [self]
+    define_option :healthcheck_timeout, default: 30, type: Integer, range: 2..1440
+
+    # @!macro
+    #   @!method $1?
+    #     Whether to suppress STDOUT messages
+    #     === Default value:
+    #     false
+    #     @return [Boolean]
+    #   @!method $1=(value)
+    #     Sets whether the STDOUT messages should be printed
+    #     @param value [Boolean] whether to suppress STDOUT messages
+    #     @return [self]
+    define_option :quiet, reader: :quiet?, type: [TrueClass, FalseClass], required: true, default: false
+
+    # Gets the options for a worker
+    # @return [Hash] the worker configuration
+    def worker_options
+      {
+        min_threads: min_execution_threads,
+        max_threads: max_execution_threads,
+        max_thread_idletime: max_execution_thread_idletime,
+      }.tap do |opts|
+        opts[:set_db_connection_name] = set_db_connection_name? unless set_db_connection_name.nil?
+        %i[enable_listener delete_completed_jobs delete_discarded_jobs delete_failed_jobs].each do |option|
+          opts[option] = send(:"#{option}?") ? true : false
+        end
+        %i[polling_interval polling_jitter status_server_handler healthcheck_timeout].each do |option|
+          opts[option] = send(option)
+        end
+      end
+    end
+
+    private
+
+    def const_get(option_name)
+      class_name = send(option_name)
+      case class_name
+      when String, Symbol
+        begin
+          class_name = if class_name.is_a? Symbol
+                         class_name.to_s.camelize.prepend("::")
+                       elsif class_name.start_with? "::"
+                         class_name
+                       else
+                         class_name.dup.prepend("::")
+                       end
+
+          Object.const_get class_name
+        rescue NameError, LoadError
+          raise Error, <<~MSG.squish
+            Cannot convert ##{option_name} (#{class_name.inspect}) to a constant. Have you made a typo?
+          MSG
+        end
+      else
+        class_name
+      end
+    end
+
+    # Raised when configuring an invalid option or value
+    class Error < Exekutor::Error; end
+
+    protected
+
+    def error_class
+      Error
+    end
+  end
+
+  def self.config
+    @config ||= Exekutor::Configuration.new
+  end
+
+  def self.configure(opts = nil, &block)
+    raise ArgumentError, "opts must be a Hash" unless opts.nil? || opts.is_a?(Hash)
+    raise ArgumentError, "Either opts or a block must be given" unless opts.present? || block_given?
+
+    config.set(**opts) if opts
+    return unless block_given?
+
+    if block.arity == 1
+      block.call config
+    else
+      instance_eval(&block)
+    end
+  end
+end