exekutor 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5bc7c7a8f6af32b1f764124d3905673240c167abd19b93e492016433414078a9
-  data.tar.gz: 37f8fb516c32a2a71595b2d608b2610ba78a5396e7f1b1e6bc7c2e90da8d770d
+  metadata.gz: 94b3158b3e0df0ca892836df74beb23ccfd8bddf5a1377a46b5ebd881cb5bee8
+  data.tar.gz: a24e415df40ba9bf69d6972da2fb6461f60c655976d81f87ff36f2e365da42a6
 SHA512:
-  metadata.gz: 8f36b7e5a5968009ba7f33657a0444053a72a5e7b91ebb8e5605c435d80a6861eec4a2d39af81c71ec6e88564a57f7d91fdaca43182ca9e5faf8c86cdd5ab7ff
-  data.tar.gz: ab262caf9827f3eccd5995309b8f0debc0da125af459b8a8321fbd43c6a25d9bcd42dc6fa65f5a98bbb341be07fca4251a8ab73860d01c2ce43efd388499a145
+  metadata.gz: 8de1e356a03b80f1e7dd82802956902531f76111cbea7210ee61eeeb34dbccc22120e5127f24ec9112328bfcb0f175f593f7ab4a9e6f347165b168503c4dbf49
+  data.tar.gz: 33c945b0e29d611d2e25d98985e75df68494bb3463d014efda5a60c7402acb711541a465b6e4db10afcbb8f2db4b86d9d2c2fd3d6b23a140bf324eefbeb8cf51

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
@@ -305,7 +294,7 @@ 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
       }.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|
@@ -351,6 +340,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 +377,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

data/lib/exekutor/hook.rb

@@ -27,12 +27,12 @@ module Exekutor
       before_enqueue around_enqueue after_enqueue before_job_execution around_job_execution after_job_execution
       on_job_failure on_fatal_error before_startup after_startup before_shutdown after_shutdown
     ].freeze
-    private_constant "CALLBACK_NAMES"
+    private_constant :CALLBACK_NAMES
 
     included do
       class_attribute :__callbacks, default: Hash.new { |h, k| h[k] = [] }
 
-      private_class_method :add_callback!
+      private_class_method :_add_callback
     end
 
     # Gets the registered callbacks
@@ -53,7 +53,6 @@ module Exekutor
     end
 
     class_methods do
-
       # @!method before_enqueue
       #   Registers a callback to be called before a job is enqueued.
       #   @param methods [Symbol] the method(s) to call
@@ -141,9 +140,9 @@ module Exekutor
 
       CALLBACK_NAMES.each do |name|
         module_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{name}(*methods, &callback)
-            add_callback! :#{name}, methods, callback
-          end
+          def #{name}(*methods, &callback)            # def callback_name(*methods, &callback
+            _add_callback :#{name}, methods, callback #   _add_callback :callback_name, methods, callback
+          end                                         # end
         RUBY
       end
 
@@ -156,16 +155,21 @@ module Exekutor
           raise Error, "Invalid callback type: #{type} (Expected one of: #{CALLBACK_NAMES.map(&:inspect).join(", ")}"
         end
 
-        add_callback! type, methods, callback
+        _add_callback type, methods, callback
         true
       end
 
-      def add_callback!(type, methods, callback)
-        raise Error, "No method or callback block supplied" if methods.blank? && callback.nil?
+      # @!visibility private
+      def _add_callback(type, methods, callback)
         raise Error, "Either a method or a callback block must be supplied" if methods.present? && callback.present?
 
-        methods&.each { |method| __callbacks[type] << [method, nil] }
-        __callbacks[type] << [nil, callback] if callback.present?
+        if methods.present?
+          methods.each { |method| __callbacks[type] << [method, nil] }
+        elsif callback.present?
+          __callbacks[type] << [nil, callback]
+        else
+          raise Error, "No method or callback block supplied"
+        end
       end
     end
   end

data/lib/exekutor/info/worker.rb

@@ -12,9 +12,9 @@ module Exekutor
 
       # Registers a heartbeat for this worker, if necessary
       def heartbeat!
-        now = Time.now.change(sec: 0)
-        touch :last_heartbeat_at, time: now if self.last_heartbeat_at.nil? || now >= self.last_heartbeat_at + 1.minute
+        now = Time.current.change(sec: 0)
+        touch :last_heartbeat_at, time: now if last_heartbeat_at.nil? || now >= last_heartbeat_at + 1.minute
       end
     end
   end
-end
+end

data/lib/exekutor/internal/base_record.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Exekutor
   # @private
   module Internal
@@ -8,4 +9,4 @@ module Exekutor
       self.table_name_prefix = "exekutor_"
     end
   end
-end
+end