exekutor 0.1.0 → 0.1.2

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

data/lib/exekutor/internal/callbacks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Exekutor
   module Internal
     # Mixin to define callbacks on a class
@@ -49,41 +51,21 @@ module Exekutor
       # @param type [:on, :before, :around, :after] the type of the callback
       # @param action [Symbol] the name of the callback
       # @param args [Any] the callback args
-      def run_callbacks(type, action, *args)
+      def run_callbacks(type, action, *args, &block)
         callbacks = __callbacks && __callbacks[:"#{type}_#{action}"]
         unless callbacks
-          yield(*args) if block_given?
+          yield(*args) if block
           return
         end
         if type == :around
-          # Chain all callbacks together, ending with the original given block
-          callbacks.inject(-> { yield(*args) }) do |next_callback, (callback, extra_args)|
-            callback_args = if callback.arity.zero?
-                              []
-                            else
-                              args + extra_args
-                            end
-            lambda do
-              has_yielded = false
-              callback.call(*callback_args) { has_yielded = true; next_callback.call }
-              raise MissingYield, "Callback did not yield!" unless has_yielded
-            rescue StandardError => err
-              raise if err.is_a? MissingYield
-              Exekutor.on_fatal_error err, "[Executor] Callback error!"
-              next_callback.call
-            end
-          end.call
-          return
-        end
-        iterator = type == :after ? :each : :reverse_each
-        callbacks.send(iterator) do |(callback, extra_args)|
-          if callback.arity.zero?
-            callback.call
-          else
-            callback.call(*(args + extra_args))
+          chain_callbacks(callbacks, args, &block).call
+        else
+          # Invoke :before in reverse order (last registered first),
+          # invoke :after in original order (last registered last)
+          iterator = type == :after ? :each : :reverse_each
+          callbacks.send(iterator) do |(callback, extra_args)|
+            invoke_callback(callback, args, extra_args)
           end
-        rescue StandardError => err
-          Exekutor.on_fatal_error err, "[Executor] Callback error!"
         end
         nil
       end
@@ -98,6 +80,41 @@ module Exekutor
 
       private
 
+      # Chain all callbacks together, ending with the original given block
+      def chain_callbacks(callbacks, args)
+        callbacks.inject(-> { yield(*args) }) do |next_callback, (callback, extra_args)|
+          # collect args outside of the lambda
+          callback_args = if callback.arity.zero?
+                            []
+                          else
+                            args + extra_args
+                          end
+          lambda do
+            has_yielded = false
+            callback.call(*callback_args) do
+              has_yielded = true
+              next_callback.call
+            end
+            raise MissingYield, "Callback did not yield!" unless has_yielded
+          rescue StandardError => e
+            raise if e.is_a? MissingYield
+
+            Exekutor.on_fatal_error e, "[Executor] Callback error!"
+            next_callback.call
+          end
+        end
+      end
+
+      def invoke_callback(callback, args, extra_args)
+        if callback.arity.zero?
+          callback.call
+        else
+          callback.call(*(args + extra_args))
+        end
+      rescue StandardError => e
+        Exekutor.on_fatal_error e, "[Executor] Callback error!"
+      end
+
       def add_callback!(type, args, callback)
         @__callbacks ||= Concurrent::Hash.new
         __callbacks[type] ||= Concurrent::Array.new
@@ -105,12 +122,15 @@ module Exekutor
       end
 
       class_methods do
-        # Defines the specified callbacks on this class. Also defines a method with the given name to register the callback.
-        # @param callbacks [Symbol] the callback names to define. Must start with +on_+, +before_+, +after_+, or +around_+.
+        # Defines the specified callbacks on this class. Also defines a method with the given name to register the
+        # callback.
+        # @param callbacks [Symbol] the callback names to define. Must start with +on_+, +before_+, +after_+, or
+        #   +around_+.
         # @param freeze [Boolean] if true, freezes the callbacks so that no other callbacks can be defined
         # @raise [Error] if a callback name is invalid or if the callbacks are frozen
         def define_callbacks(*callbacks, freeze: true)
           raise Error, "Callbacks are frozen, no other callbacks may be defined" if __callback_names.frozen?
+
           callbacks.each do |name|
             unless /^(on_)|(before_)|(after_)|(around_)[a-z]+/.match? name.to_s
               raise Error, "Callback name must start with `on_`, `before_`, `after_`, or `around_`"
@@ -118,9 +138,9 @@ module Exekutor
 
             __callback_names << name
             module_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{name}(*args, &callback)
-                add_callback! :#{name}, args, callback
-              end
+              def #{name}(*args, &callback)             # def callback_method(*args, &callback
+                add_callback! :#{name}, args, callback  #   add_callback! :callback_method, args, callback
+              end                                       # end
             RUBY
           end
 
@@ -135,4 +155,4 @@ module Exekutor
       class MissingYield < Exekutor::Error; end
     end
   end
-end
+end

data/lib/exekutor/internal/cli/app.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "gli"
 require "rainbow"
 require_relative "cleanup"
@@ -29,24 +31,30 @@ module Exekutor
         switch %i[quiet], negatable: false, desc: "Enable less output"
 
         # Defines start command flags
-        def self.define_start_options(c)
-          c.flag %i[env environment], desc: "The Rails environment"
-          c.flag %i[q queue], default_value: Manager::DEFAULT_QUEUE, multiple: true,
-                 desc: "Queue to work from"
-          c.flag %i[t threads], type: String, default_value: Manager::DEFAULT_THREADS,
-                 desc: "The number of threads for executing jobs, specified as `min:max`"
-          c.flag %i[p poll_interval], type: Integer, default_value: DefaultOptionValue.new( value: 60),
-                 desc: "Interval between polls for available jobs (in seconds)"
-          c.flag %i[cfg configfile], type: String, default_value: Manager::DEFAULT_CONFIG_FILES, multiple: true,
-                 desc: "The YAML configuration file to load. If specifying multiple files, the last file takes precedence"
+        def self.define_start_options(cmd)
+          cmd.flag %i[env environment], desc: "The Rails environment"
+          cmd.flag %i[q queue], default_value: Manager::DEFAULT_QUEUE, multiple: true,
+                   desc: "Queue to work from"
+          cmd.flag %i[p priority], type: String, default_value: Manager::DEFAULT_PRIORITIES,
+                   desc: "The job priorities to execute, specified as `min` or `min:max`"
+          cmd.flag %i[t threads], type: String, default_value: Manager::DEFAULT_THREADS,
+                   desc: "The number of threads for executing jobs, specified as `min:max`"
+          cmd.flag %i[i poll_interval], type: Integer, default_value: DefaultOptionValue.new(value: 60),
+                   desc: "Interval between polls for available jobs (in seconds)"
+          cmd.flag %i[cfg configfile], type: String, default_value: Manager::DEFAULT_CONFIG_FILES, multiple: true,
+                   desc: "The YAML configuration file to load. If specifying multiple files, the last file takes " \
+                         "precedence"
         end
+
         private_class_method :define_start_options
 
         # Defines stop command flags
-        def self.define_stop_options(c)
-          c.flag %i[timeout shutdown_timeout], default_value: Manager::DEFAULT_FOREVER,
-                 desc: "Number of seconds to wait for jobs to finish when shutting down before killing the worker. (in seconds)"
+        def self.define_stop_options(cmd)
+          cmd.flag %i[timeout shutdown_timeout], default_value: Manager::DEFAULT_FOREVER,
+                   desc: "Number of seconds to wait for jobs to finish when shutting down before killing the worker. " \
+                         "(in seconds)"
         end
+
         private_class_method :define_stop_options
 
         desc "Starts a worker"
@@ -67,8 +75,8 @@ module Exekutor
 
         desc "Stops a daemonized worker"
         long_desc <<~TEXT
-          Stops a daemonized worker. This uses the PID file to send a shutdown command to a running worker. If the worker 
-          does not exit within the shutdown timeout it will kill the process.
+          Stops a daemonized worker. This uses the PID file to send a shutdown command to a running worker. If the
+          worker does not exit within the shutdown timeout it will kill the process.
         TEXT
         command :stop do |c|
           c.switch :all, negatable: false, desc: "Stops all workers with default pid files."
@@ -76,7 +84,9 @@ module Exekutor
 
           c.action do |global_options, options|
             if options[:all]
-              puts "The identifier option is ignored for --all" unless global_options[:identifier].nil? || global_options[:quiet]
+              unless global_options[:identifier].nil? || global_options[:quiet]
+                puts "The identifier option is ignored for --all"
+              end
               pidfile_pattern = if options[:pidfile].nil? || options[:pidfile] == Manager::DEFAULT_PIDFILE
                                   "tmp/pids/exekutor*.pid"
                                 else
@@ -98,8 +108,8 @@ module Exekutor
 
         desc "Restarts a daemonized worker"
         long_desc <<~TEXT
-          Restarts a daemonized worker. Will issue the stop command if a worker is running and wait for the active worker
-          to exit before starting a new worker. If no worker is currently running, a new worker will be started.
+          Restarts a daemonized worker. Will issue the stop command if a worker is running and wait for the active
+          worker to exit before starting a new worker. If no worker is currently running, a new worker will be started.
         TEXT
         command :restart do |c|
           define_stop_options c
@@ -107,7 +117,7 @@ module Exekutor
 
           c.action do |global_options, options|
             Manager.new(global_options).restart(options.slice(:shutdown_timeout),
-                                                options.reject { |k, _| k == :shutdown_timeout })
+                                                options.except(:shutdown_timeout))
           end
         end
 
@@ -127,14 +137,15 @@ module Exekutor
         long_desc <<~TEXT
           Cleans up the finished jobs and stale workers
         TEXT
-        command :cleanup do |c|
+        command :cleanup do |c| # rubocop:disable Metrics/BlockLength
           c.flag %i[env environment], desc: "The Rails environment."
 
           c.flag %i[t timeout],
                  desc: "The global timeout in hours. Workers and jobs before the timeout will be purged"
           c.flag %i[worker_timeout],
                  default_value: 4,
-                 desc: "The worker timeout in hours. Workers where the last heartbeat is before the timeout will be deleted."
+                 desc: "The worker timeout in hours. Workers where the last heartbeat is before the timeout will be " \
+                       "deleted."
           c.flag %i[job_timeout],
                  default_value: 48,
                  desc: "The job timeout in hours. Jobs where scheduled at is before the timeout will be purged."
@@ -167,7 +178,6 @@ module Exekutor
           end
         end
       end
-
     end
   end
-end
+end

data/lib/exekutor/internal/cli/application_loader.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Exekutor
   module Internal
     module CLI
@@ -12,6 +14,7 @@ module Exekutor
         # @param print_message [Boolean] whether to print a loading message to STDOUT
         def load_application(environment, path = "config/environment.rb", print_message: false)
           return if @application_loaded
+
           if print_message
             printf LOADING_MESSAGE
             @loading_message_printed = true
@@ -23,14 +26,22 @@ module Exekutor
 
         # Clears the loading message if it was printed
         def clear_application_loading_message
-          if @loading_message_printed
-            printf "\r#{" " * LOADING_MESSAGE.length}\r"
-            @loading_message_printed = false
-          end
+          return unless @loading_message_printed
+
+          printf "\r#{" " * LOADING_MESSAGE.length}\r"
+          @loading_message_printed = false
         end
 
+        # @return Whether the system time zone differs from the app time zone
+        def different_time_zone?
+          Time.zone.name != Time.new.zone
+        end
+
+        # Prints a message to STDOUT indicating in which time zone times are printed
+        def print_time_zone_warning
+          puts "(times are printed in the #{Time.zone.name} time zone)\n\n"
+        end
       end
     end
   end
-
-end
+end

data/lib/exekutor/internal/cli/cleanup.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "application_loader"
 require_relative "default_option_value"
 require "terminal-table"
@@ -21,26 +23,13 @@ module Exekutor
           load_application options[:environment], print_message: !quiet?
 
           ActiveSupport.on_load(:active_record, yield: true) do
-            # Use system time zone
-            Time.zone = Time.new.zone
+            clear_application_loading_message
+            print_time_zone_warning if different_time_zone? && !quiet?
 
-            clear_application_loading_message unless quiet?
-            timeout = options[:timeout] || options[:worker_timeout] || 4
+            timeout = worker_cleanup_timeout(options)
             workers = cleaner.cleanup_workers timeout: timeout.hours
-            return if quiet?
-
-            puts Rainbow("Workers").bright.blue if options[:print_header]
-            if workers.present?
-              puts "Purged #{workers.size} worker#{"s" if workers.many?}"
-              if verbose?
-                table = Terminal::Table.new
-                table.headings = ["id", "Last heartbeat"]
-                workers.each { |w| table << [w.id.split("-").first << "…", w.last_heartbeat_at] }
-                puts table
-              end
-            else
-              puts "Nothing purged"
-            end
+
+            print_worker_cleanup_result(options, workers) unless quiet?
           end
         end
 
@@ -50,30 +39,56 @@ module Exekutor
           load_application options[:environment], print_message: !quiet?
 
           ActiveSupport.on_load(:active_record, yield: true) do
-            # Use system time zone
-            Time.zone = Time.new.zone
-
-            clear_application_loading_message unless quiet?
-            timeout = options[:timeout] || options[:job_timeout] || 48
-            status = if options[:job_status].is_a? Array
-                       options[:job_status]
-                     elsif options[:job_status] && options[:job_status] != DEFAULT_STATUSES
-                       options[:job_status]
-                     end
-            purged_count = cleaner.cleanup_jobs before: timeout.hours.ago, status: status
-            return if quiet?
-
-            puts Rainbow("Jobs").bright.blue if options[:print_header]
-            if purged_count.zero?
-              puts "Nothing purged"
-            else
-              puts "Purged #{purged_count} job#{"s" if purged_count > 1}"
-            end
+            clear_application_loading_message
+            print_time_zone_warning if different_time_zone? && !quiet?
+
+            timeout = job_cleanup_timeout(options)
+            purged_count = cleaner.cleanup_jobs before: timeout.hours.ago, status: job_cleanup_statuses(options)
+
+            print_job_cleanup_result(options, purged_count) unless quiet?
           end
         end
 
         private
 
+        def job_cleanup_statuses(options)
+          options[:job_status] if options[:job_status] && options[:job_status] != DEFAULT_STATUSES
+        end
+
+        def job_cleanup_timeout(options)
+          options[:timeout] || options[:job_timeout] || 48
+        end
+
+        def print_job_cleanup_result(options, purged_count)
+          puts Rainbow("Jobs").bright.blue if options[:print_header]
+          if purged_count.zero?
+            puts "Nothing purged"
+          else
+            puts "Purged #{purged_count} job#{"s" if purged_count > 1}"
+          end
+        end
+
+        def worker_cleanup_timeout(options)
+          options[:timeout] || options[:worker_timeout] || 4
+        end
+
+        def print_worker_cleanup_result(options, workers)
+          puts Rainbow("Workers").bright.blue if options[:print_header]
+          if workers.present?
+            puts "Purged #{workers.size} worker#{"s" if workers.many?}"
+            print_worker_info(workers) if verbose?
+          else
+            puts "Nothing purged"
+          end
+        end
+
+        def print_worker_info(workers)
+          table = Terminal::Table.new
+          table.headings = ["id", "Last heartbeat"]
+          workers.each { |w| table << [w.id.split("-").first << "…", w.last_heartbeat_at] }
+          puts table
+        end
+
         # @return [Boolean] Whether quiet mode is enabled. Overrides verbose mode.
         def quiet?
           !!@global_options[:quiet]
@@ -85,12 +100,11 @@ module Exekutor
         end
 
         def cleaner
-          @delegate ||= ::Exekutor::Cleanup.new
+          @cleaner ||= ::Exekutor::Cleanup.new
         end
 
         DEFAULT_STATUSES = DefaultOptionValue.new("All except :pending").freeze
       end
     end
-
   end
-end
+end

data/lib/exekutor/internal/cli/daemon.rb

@@ -31,11 +31,9 @@ module Exekutor
           return nil unless ::File.exist? pidfile
 
           pid = ::File.read(pidfile)
-          if pid.to_i.positive?
-            pid.to_i
-          else
-            raise Error, "Corrupt PID-file. Check #{pidfile}"
-          end
+          raise Error, "Corrupt PID-file. Check #{pidfile}" unless pid.to_i.positive?
+
+          pid.to_i
         end
 
         # The process status for this daemon. Possible states are:
@@ -48,8 +46,8 @@ module Exekutor
           pid = self.pid
           return :not_running if pid.nil?
 
-          # If sig is 0, then no signal is sent, but error checking is still performed; this can be used to check for the
-          # existence of a process ID or process group ID.
+          # If sig is 0, then no signal is sent, but error checking is still performed; this can be used to check for
+          # the existence of a process ID or process group ID.
           ::Process.kill(0, pid)
           :running
         rescue Errno::ESRCH
@@ -63,14 +61,14 @@ module Exekutor
         # @return [Boolean] whether the status matches
         # @see #status
         def status?(*statuses)
-          statuses.include? self.status
+          statuses.include? status
         end
 
         # Raises an {Error} if a daemon is already running. Deletes the pidfile is the process is dead.
         # @return [void]
         # @raise [Error] when the daemon is running
         def validate!
-          case self.status
+          case status
           when :running, :not_owned
             raise Error, "A worker is already running. Check #{pidfile}"
           else
@@ -97,7 +95,7 @@ module Exekutor
         # @return [void]
         # @see #pidfile
         def delete_pid
-          File.delete(pidfile) if File.exist?(pidfile)
+          FileUtils.rm_f(pidfile)
         end
 
         # Raised when spawning a daemon process fails
@@ -105,4 +103,4 @@ module Exekutor
       end
     end
   end
-end
+end

data/lib/exekutor/internal/cli/default_option_value.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Exekutor
   # @private
   module Internal
@@ -26,4 +28,4 @@ module Exekutor
       end
     end
   end
-end
+end