exekutor 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5bc7c7a8f6af32b1f764124d3905673240c167abd19b93e492016433414078a9
-  data.tar.gz: 37f8fb516c32a2a71595b2d608b2610ba78a5396e7f1b1e6bc7c2e90da8d770d
+  metadata.gz: d5b178052eb277168916a76f663ba53882204481f740a7c30bc309d243de79cf
+  data.tar.gz: bfb648002d86bf278b41b5f7ca6fde0f1d3cb39954c445eec0e268bf72120efe
 SHA512:
-  metadata.gz: 8f36b7e5a5968009ba7f33657a0444053a72a5e7b91ebb8e5605c435d80a6861eec4a2d39af81c71ec6e88564a57f7d91fdaca43182ca9e5faf8c86cdd5ab7ff
-  data.tar.gz: ab262caf9827f3eccd5995309b8f0debc0da125af459b8a8321fbd43c6a25d9bcd42dc6fa65f5a98bbb341be07fca4251a8ab73860d01c2ce43efd388499a145
+  metadata.gz: e2d7a7787f83dc362aeca814d511d0584e5e3e2af24209f1bfc00bd1efbae47d9226bc91e5615a0c7b38b5a515ad64146ec43d74e6cb3b757f3144fcc100d05e
+  data.tar.gz: 651ee14b261990adfe498e017afd6ea0e3e382e12f7bf4a352d01dd4d203938f62f2223159e7930bd517ee5fd68f191b2d0ad9189c13670158064e8381278b5b

checksums.yaml.gz.sig

@@ -1,3 +1,2 @@
-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�
+��<����}g�w
�2���ȝ�T���L�7!��wc��]<o���6���
f{o���&�9���H@��<Zy7���-"׈'}5Hbu^�҄���W����I̒�k$턍��)2-�*�߷���ci
+��#�s)�������b`gư�H� (H�����U�u��&v9(��H��*t()��`{3��<g�mf(��?M�,$������r`3“�'��WkةyH��;'���^��0�d�)0>��(��!�9����@KI�<������������a6��������V�\
!�k���|��q�V��X%�&�u��IK�˛�H+�>���l�nY�3D6�-���"1�Y�����a�7�ے�x��X

data/exe/exekutor

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

data/lib/active_job/queue_adapters/exekutor_adapter.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "active_job"
 require "active_job/queue_adapters"
 
@@ -11,4 +12,4 @@ module ActiveJob
       alias enqueue_at schedule_at
     end
   end
-end
+end

data/lib/exekutor/asynchronous.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Exekutor
   # Mixin to let methods be executed asynchronously by active job
   #
@@ -21,10 +23,10 @@ module Exekutor
     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
+      private_class_method :perform_asynchronously, :async_delegate_and_definitions, :redefine_method
     end
 
-    class_methods do
+    class_methods do # rubocop:disable Metrics/BlockLength
       # 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
@@ -36,46 +38,62 @@ module Exekutor
       # @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?
+        unless method_name.is_a? Symbol
+          raise ArgumentError, "method_name must be a Symbol (actual: #{method_name.class.name})"
+        end
+        raise ArgumentError, "alias_to must be present" if alias_to.blank?
+
+        delegate, definitions = async_delegate_and_definitions(method_name, class_method: class_method)
+        raise Error, "##{method_name} was already marked as asynchronous" if definitions.include? method_name
+
+        redefine_method_as_async(delegate, method_name, alias_to)
+        definitions[method_name] = alias_to
+        nil
+      end
+
+      # Gets the object to define aliased method on, and the definitions that are already defined
+      # @return [Array(Any, Hash<Symbol=>Symbol>)] The delegate and the existing definitions
+      def async_delegate_and_definitions(method_name, class_method:)
         if class_method
           raise ArgumentError, "##{method_name} does not exist" unless respond_to? method_name, true
 
-          delegate = singleton_class
-          definitions = __async_class_methods
+          [singleton_class, __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"
+          [self, __async_instance_methods]
         end
+      end
+
+      # Aliases the indicated method and redefines the method to call the original method asynchronously.
+      # @param delegate [Any] the delegate to redefine the method on
+      # @param method_name [Symbol] the name of the method to redefine
+      # @param alias_to [String] the name to alias the original method to
+      # @return [Void]
+      def redefine_method_as_async(delegate, method_name, alias_to)
+        visibility = if delegate.private_method_defined?(method_name)
+                       :private
+                     elsif delegate.protected_method_defined?(method_name)
+                       :protected
+                     else
+                       :public
+                     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
+        delegate.send(visibility, method_name)
       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+
@@ -83,60 +101,16 @@ module Exekutor
     # @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
+      error = ArgumentValidator.new(delegate, method).validate(args, kwargs)
+      return nil unless error
 
-      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
+      ArgumentError.new(error)
     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
-
+    # +perform_asynchronously+ to mark a method as asynchronous.
+    class AsyncMethodJob < ActiveJob::Base # rubocop:disable Rails/ApplicationJob
       # Calls the original, synchronous method
       # @!visibility private
       def perform(object, method, args)
@@ -172,16 +146,110 @@ module Exekutor
           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}"
+        raise Error, "#{class_name} does not respond to #{method}" unless object.respond_to? method, true
+        raise Error, "#{class_name}##{method} is not marked as asynchronous" unless definitions.include? method.to_sym
+
+        definitions[method.to_sym]
+      end
+    end
+
+    # Validates whether a set of arguments is valid for a particular method
+    class ArgumentValidator
+      def initialize(delegate, method)
+        @required_keywords = []
+        @optional_keywords = []
+        @accepts_keyrest = false
+        parse_method_params delegate.method(method)
+      end
+
+      def parse_method_params(method)
+        arguments = ArgumentCounter.new
+        method.parameters.each do |type, name|
+          case type
+          when :req, :opt
+            arguments.increment(type)
+          when :rest
+            arguments.clear_max
+          when :keyreq
+            @required_keywords << name
+          when :key
+            @optional_keywords << name
+          when :keyrest
+            @accepts_keyrest = true
+          else
+            Exekutor.say "Unsupported parameter type: #{type.inspect}"
+          end
+        end
+        @arg_length = arguments.to_range
+      end
+
+      def accepts_keywords?
+        @accepts_keyrest || @required_keywords.present? || @optional_keywords.present?
+      end
+
+      def fixed_keywords?
+        !@accepts_keyrest && (@required_keywords.present? || @optional_keywords.present?)
+      end
+
+      def validate(args, kwargs)
+        args += [kwargs] unless kwargs.empty? || accepts_keywords?
+
+        return argument_length_error(args.length) unless @arg_length.cover? args.length
+
+        missing_keywords = @required_keywords - kwargs.keys
+        return missing_keywords_error(missing_keywords) if missing_keywords.present?
+
+        unknown_keywords = (kwargs.keys - @required_keywords - @optional_keywords if fixed_keywords?)
+        return unknown_keywords_error(unknown_keywords) if unknown_keywords.present?
+
+        nil
+      end
+
+      private
+
+      def unknown_keywords_error(unknown_keywords)
+        "unknown keyword#{"s" if unknown_keywords.many?}: #{
+          unknown_keywords.map(&:inspect).join(", ")}"
+      end
+
+      def missing_keywords_error(missing_keywords)
+        "missing keyword#{"s" if missing_keywords.many?}: #{
+          missing_keywords.map(&:inspect).join(", ")}"
+      end
+
+      def argument_length_error(given_length)
+        expected = @arg_length.begin.to_s
+        if @arg_length.end.nil?
+          expected += "+"
+        elsif @arg_length.end > @arg_length.begin
+          expected += "..#{@arg_length.end}"
         end
-        unless definitions.include? method.to_sym
-          raise Error, "#{class_name}##{method} is not marked as asynchronous"
+        "wrong number of arguments (given #{given_length}, expected #{expected})"
+      end
+
+      # Keeps track of the minimum and maximum number of allowed arguments
+      class ArgumentCounter
+        def initialize
+          @min = @max = 0
+        end
+
+        def increment(type)
+          @min += 1 if type == :req
+          @max += 1 if @max
+        end
+
+        def clear_max
+          @max = nil
+        end
+
+        def to_range
+          @min..@max
         end
-        definitions[method.to_sym]
       end
     end
 
+    private_constant :ArgumentValidator
+
     # Raised when an error occurs while configuring or executing asynchronous methods
     class Error < Exekutor::DiscardJob; end
   end

data/lib/exekutor/cleanup.rb

@@ -1,23 +1,15 @@
+# frozen_string_literal: true
+
 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
+      destroy_before = parse_timeout_arg :timeout, timeout
+      # 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
@@ -26,24 +18,13 @@ module Exekutor
     # @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?))
+      destroy_before = parse_timeout_arg :before, before
+      unless [Array, String, Symbol, NilClass].any? { |c| status.is_a? c }
         raise ArgumentError, "Unsupported value for status: #{status.class}"
       end
 
       jobs = Exekutor::Job.all
-      unless before.nil?
-        jobs.where!(%{"scheduled_at"<?}, destroy_before)
-      end
+      jobs.where!(%("scheduled_at"<?), destroy_before) unless before.nil?
       if status
         jobs.where! status: status
       else
@@ -52,5 +33,23 @@ module Exekutor
       jobs.delete_all
     end
 
+    private
+
+    # Converts timout argument to a Time
+    # @param name [Symbol,String] the name of the argument
+    # @param value [ActiveSupport::Duration,Numeric,Date,Time] the argument to parse
+    # @return [Date,Time] The point in time
+    def parse_timeout_arg(name, value)
+      case value
+      when ActiveSupport::Duration
+        value.ago
+      when Numeric
+        value.hours.ago
+      when Date, Time
+        value
+      else
+        raise ArgumentError, "Unsupported value for #{name}: #{value.class}"
+      end
+    end
   end
-end
+end

data/lib/exekutor/configuration.rb

@@ -2,6 +2,7 @@
 
 require_relative "internal/configuration_builder"
 
+# The Exekutor namespace
 module Exekutor
   # Configuration for the Exekutor library
   class Configuration
@@ -9,7 +10,7 @@ module Exekutor
 
     # @private
     DEFAULT_BASE_RECORD_CLASS = "ActiveRecord::Base"
-    private_constant "DEFAULT_BASE_RECORD_CLASS"
+    private_constant :DEFAULT_BASE_RECORD_CLASS
 
     # @!macro
     #   @!method $1
@@ -73,8 +74,7 @@ module Exekutor
     #     @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))
+      unless value.is_a?(String) || value.is_a?(Symbol) || value.respond_to?(:call) || SerializerValidator.valid?(value)
         raise Error, "#json_serializer must either be a String, a Proc, or respond to #dump and #load"
       end
     end
@@ -83,24 +83,13 @@ module Exekutor
     # @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
+      raw_value = 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
-
+      serializer = SerializerValidator.convert! serializer unless SerializerValidator.valid? serializer
       @json_serializer_instance = [raw_value, serializer]
       serializer
     end
@@ -191,18 +180,19 @@ module Exekutor
 
     # @!macro
     #   @!method $1
-    #     The polling interval in seconds. When set, the worker will poll the database with this interval to check for
+    #     The polling interval. 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]
+    #     60 seconds
+    #     @return [ActiveSupport::Duration]
     #   @!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
+    #     Sets the polling interval. 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 the listener is enabled, this
+    #     value can be reasonably high.
+    #     @param value [ActiveSupport::Duration] the interval
     #     @return [self]
-    define_option :polling_interval, default: 60, type: [Integer, nil], range: 1...(1.day.to_i)
+    define_option :polling_interval, default: 1.minute, type: [ActiveSupport::Duration, nil],
+                  range: (1.second)...(1.day)
 
     # @!macro
     #   @!method $1
@@ -250,21 +240,22 @@ module Exekutor
 
     # @!macro
     #   @!method $1
-    #     The maximum number of seconds a thread may be idle before being stopped.
+    #     The maximum duration a thread may be idle before being stopped.
     #     === Default value:
-    #     60
-    #     @return [Integer]
+    #     60 seconds
+    #     @return [ActiveSupport::Duration]
     #   @!method $1=(value)
-    #     Sets the maximum number of seconds a thread may be idle before being stopped
-    #     @param value [Integer] the number of threads
+    #     Sets the maximum duration a thread may be idle before being stopped
+    #     @param value [ActiveSupport::Duration] the number of threads
     #     @return [self]
-    define_option :max_execution_thread_idletime, default: 60, type: Integer, range: 1..(1.day.to_i)
+    define_option :max_execution_thread_idletime, default: 1.minute, type: ActiveSupport::Duration,
+                  range: (1.second)..(1.day)
 
     # @!macro
     #   @!method $1?
     #     The rack handler for the status server
     #     === Default value:
-    #     webrick
+    #     +"webrick"+
     #     @return [String]
     #   @!method $1=(value)
     #     Sets the rack handler for the status server. The handler should respond to +#shutdown+ or +#stop+.
@@ -274,18 +265,46 @@ module Exekutor
 
     # @!macro
     #   @!method $1?
-    #     The heartbeat timeout for the `/live` endpoint of the status server, in minutes. If the heartbeat of a worker
+    #     The port number for the status server
+    #     === Default value:
+    #     +nil+ (ie. the status server is disabled)
+    #     @return [Integer]
+    #   @!method $1=(value)
+    #     Sets the port number for the status server.
+    #     @param value [Integer] the port number
+    #     @return [self]
+    define_option :status_server_port, default: nil, type: Integer
+
+    # @!macro
+    #   @!method $1?
+    #     The heartbeat timeout for the `/live` endpoint of the status server. 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]
+    #     30 minutes
+    #     @return [ActiveSupport::Duration]
     #   @!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
+    #     Sets the heartbeat timeout for the `/live` endpoint of the status server. Must be between 1 minute
+    #     and 24 hours.
+    #     @param value [ActiveSupport::Duration] The timeout in minutes
     #     @return [self]
-    define_option :healthcheck_timeout, default: 30, type: Integer, range: 2..1440
+    define_option :healthcheck_timeout, default: 30.minutes, type: ActiveSupport::Duration,
+                  range: (1.minute)..(1.day)
+
+    # @!macro
+    #   @!method $1?
+    #     Whether the priority should be inverted. If true, the job with the highest value as the priority is the most
+    #     important. If false, the job with the lowest value as the priority is the most important.
+    #     === Default value:
+    #     false
+    #     @return [Boolean]
+    #   @!method $1=(value)
+    #     Sets whether the the priority should be inverted. When true, the job with the highest value as the priority is
+    #     the most important; when false, the job with the lowest value as the priority is the most important.
+    #     @param value [Boolean] whether the job with the highest priority value is the most important.
+    #     @return [self]
+    define_option :inverse_priority, reader: :inverse_priority?, type: [TrueClass, FalseClass], required: true,
+                  default: false
 
     # @!macro
     #   @!method $1?
@@ -305,13 +324,14 @@ module Exekutor
       {
         min_threads: min_execution_threads,
         max_threads: max_execution_threads,
-        max_thread_idletime: max_execution_thread_idletime,
+        max_thread_idletime: max_execution_thread_idletime.to_f
       }.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|
+        %i[polling_interval polling_jitter status_server_handler status_server_port healthcheck_timeout]
+          .each do |option|
           opts[option] = send(option)
         end
       end
@@ -351,6 +371,36 @@ module Exekutor
     def error_class
       Error
     end
+
+    # Validates the value for a serializer, which must implement dump & load
+    class SerializerValidator
+      # @param serializer [Any] the value to validate
+      # @return [Boolean] whether the serializer has implemented dump & load
+      def self.valid?(serializer)
+        serializer.respond_to?(:dump) && serializer.respond_to?(:load)
+      end
+
+      # Tries to convert the specified value to a serializer, raises an error if the conversion fails.
+      # @param serializer [Any] the value to convert
+      # @return [#dump&#load]
+      # @raise [Error] if the serializer has not implemented dump & load
+      def self.convert!(serializer)
+        return serializer if SerializerValidator.valid? serializer
+
+        if serializer.respond_to?(:call)
+          serializer = serializer.call
+          return serializer if SerializerValidator.valid? serializer
+        end
+        if serializer.respond_to?(:new)
+          serializer = serializer.new
+          return serializer if SerializerValidator.valid? serializer
+        end
+
+        raise Error, <<~MSG.squish
+          The configured serializer (#{serializer.class}) does not respond to #dump and #load
+        MSG
+      end
+    end
   end
 
   def self.config
@@ -358,16 +408,20 @@ module Exekutor
   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?
+    raise ArgumentError, "either opts or a block must be given" unless opts || block
 
-    config.set(**opts) if opts
-    return unless block_given?
+    if opts
+      raise ArgumentError, "opts must be a Hash" unless opts.is_a?(Hash)
 
-    if block.arity == 1
-      block.call config
-    else
-      instance_eval(&block)
+      config.set(**opts)
+    end
+    if block
+      if block.arity.zero?
+        instance_eval(&block)
+      else
+        yield config
+      end
     end
+    self
   end
 end