tasks_scheduler 0.2.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ffe5fd69eab67510ab378506158799d08b21d4577ed368ddbadf12cfb0a6957
-  data.tar.gz: e471eaeb074d10557c8c3bd55dff0d8bbd0a9e1b83723d28f6255b2b2907fe29
+  metadata.gz: 599df8db33d832f04a2ad1a0581c7775fbd17f345da397e6b2e6e14090dfe9d1
+  data.tar.gz: f20e6101384683f6d398ef55603f2a1d47d1e79dbf111237d68b2bfcc426292c
 SHA512:
-  metadata.gz: 435c0e3aa4e1c7a721933b6a47bd3b72f33ab51d5a5c67323cee7a179c2aef731bc6a39119763fa169c064670883a50728703c1ad37614c9d7996ba7b7993336
-  data.tar.gz: 9112b3ad93fd00dfc3d10d8487befc0c698461d046a8fdeead98611c86ecdd0d4f44dcb929864fa53e95fcf409fedd9eefcd85abe7ccf0817269f44d50b2b3df
+  metadata.gz: ca786519acd5d3925cc521ffed0f3d61471d409abefe94b70b32002951ce27d51cc63435567b2b820d7be7315265f7d7a847723ba721835246531fb391474539
+  data.tar.gz: 6e0e915ebd3b41d75499899b3155b33e71f34ad08fe80f03f30dc03dc75ead448acbd34dc71c6eb8ab38c8e9f49fd1c0f95c8922c4c76afb6ea9f3a30847368c

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 begin
   require 'bundler/setup'
 rescue LoadError
@@ -14,7 +16,7 @@ RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-APP_RAKEFILE = File.expand_path('../test/dummy/Rakefile', __FILE__)
+APP_RAKEFILE = File.expand_path('test/dummy/Rakefile', __dir__)
 load 'rails/tasks/engine.rake'
 
 load 'rails/tasks/statistics.rake'

data/app/assets/stylesheets/tasks_scheduler.scss

@@ -39,6 +39,10 @@
     td.status_disabled {
       color: lightgrey;
     }
+
+    td.status_task_not_found {
+      color: violet;
+    }
   }
 
   .last_run {

data/app/controllers/scheduled_tasks_controller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ScheduledTasksController < ApplicationController
   class << self
     private
@@ -8,7 +10,7 @@ class ScheduledTasksController < ApplicationController
   end
 
   active_scaffold :scheduled_task do |conf|
-    [:create, :update, :list].each do |action|
+    %i[create update list].each do |action|
       conf.send(action).columns.exclude(:next_run, :last_fail_status, :last_run_start,
                                         :last_run_successful_start, :last_run_unsuccessful_start,
                                         :last_run_successful_end, :last_run_unsuccessful_end,
@@ -26,8 +28,7 @@ class ScheduledTasksController < ApplicationController
     @log_file = record.log_file(params[:identifier])
   end
 
-  def status
-  end
+  def status; end
 
   def status_content
     @scheduled_tasks = ::ScheduledTask.order(task: :asc, scheduling: :asc)
@@ -36,7 +37,7 @@ class ScheduledTasksController < ApplicationController
 
   def run_now
     process_action_link_action do |record|
-      record.update_attributes!(next_run: Time.zone.now)
+      record.update!(next_run: Time.zone.now)
       record.reload
       flash[:info] = "Next run adjusted to #{record.next_run}"
     end

data/app/controllers/tasks_scheduler_daemon_controller.rb

@@ -1,6 +1,11 @@
+# frozen_string_literal: true
+
+require 'tasks_scheduler/checker'
+
 class TasksSchedulerDaemonController < ApplicationController
-  def index
-  end
+  require_relative 'tasks_scheduler_daemon_controller/_download_log'
+
+  def index; end
 
   def execute
     @result = ::TasksScheduler::Daemon.execute(params[:tasks_scheduler_execute_action])
@@ -9,26 +14,6 @@ class TasksSchedulerDaemonController < ApplicationController
 
   def status
     render json: { daemon_running: ::TasksScheduler::Daemon.running?,
-                   tasks_all_ok: !::ScheduledTask.all.any?(&:failed?) }
-  end
-
-  def download_log
-    if File.exist?(::TasksScheduler::Checker.instance.log_path)
-      send_log_file
-    else
-      redirect_to(tasks_scheduler_daemon_path,
-                  notice: "Arquivo \"#{::TasksScheduler::Checker.instance.log_path}\" não existe")
-    end
-  end
-
-  private
-
-  def send_log_file
-    send_file(
-      ::TasksScheduler::Checker.instance.log_path,
-      filename: "#{request.base_url.parameterize}_tasks-scheduler_checker-log_" \
-        "#{Time.zone.now.to_s.parameterize}.log",
-      type: 'text/plain'
-    )
+                   tasks_all_ok: ::ScheduledTask.all.none?(&:failed?) }
   end
 end

data/app/controllers/tasks_scheduler_daemon_controller/_download_log.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class TasksSchedulerDaemonController < ApplicationController
+  def download_log
+    return unless download_log_validate_log_key
+
+    log = ::TasksScheduler::Checker.instance.send("#{download_log_key}_log")
+    return unless download_log_validate_log_exist(log)
+
+    send_log_file(log)
+  end
+
+  private
+
+  def download_log_key
+    params[:log_key]
+  end
+
+  def download_log_validate_log_key
+    return true if ::TasksScheduler::Checker::LOGS_KEYS.include?(download_log_key)
+
+    redirect_to(tasks_scheduler_daemon_path,
+                notice: "Invalid log key: \"#{download_log_key}\"")
+    false
+  end
+
+  def download_log_validate_log_exist(log)
+    return true if log.exist?
+
+    redirect_to(tasks_scheduler_daemon_path, notice: "Log \"#{log.key}\" does not exist.")
+    false
+  end
+
+  def send_log_file(log)
+    send_file(
+      log.path,
+      filename: "#{request.base_url.parameterize}_tasks-scheduler_checker-log_" \
+        "#{Time.zone.now.to_s.parameterize}.log",
+      type: 'text/plain'
+    )
+  end
+end

data/app/helpers/scheduled_tasks_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ScheduledTasksHelper
   def scheduled_tasks_status_time(time)
     if time.present?

data/app/models/scheduled_task.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
 require 'rake'
 
 class ScheduledTask < ActiveRecord::Base
@@ -6,7 +9,7 @@ class ScheduledTask < ActiveRecord::Base
   include ::ScheduledTask::Runner
   include ::ScheduledTask::Status
 
-  DEFAULT_TIMEOUT_ENVVAR_NAME = 'TASKS_SCHEDULER_TIMEOUT'.freeze
+  DEFAULT_TIMEOUT_ENVVAR_NAME = 'TASKS_SCHEDULER_TIMEOUT'
   DEFAULT_TIMEOUT = 12.hours
 
   class << self
@@ -20,26 +23,25 @@ class ScheduledTask < ActiveRecord::Base
     def timeout
       @timeout ||= begin
         r = Integer(ENV[DEFAULT_TIMEOUT_ENVVAR_NAME])
-        r > 0 ? r.seconds : DEFAULT_TIMEOUT
-      rescue ArgumentError, TypeError
-        DEFAULT_TIMEOUT
+        r.positive? ? r.seconds : DEFAULT_TIMEOUT
+                   rescue ArgumentError, TypeError
+                     DEFAULT_TIMEOUT
       end
     end
   end
 
-  STATUS_RUNNING = 'running'
-  STATUS_FAILED = 'failed'
-  STATUS_WAITING = 'waiting'
-  STATUS_ABORTED = 'aborted'
-  STATUS_TIMEOUT = 'timeout'
-  STATUS_DISABLED = 'disabled'
+  enable_listable
+  lists.add_string :status, 'aborted', 'disabled', 'failed', 'running', 'task_not_found', 'timeout',
+                   'waiting'
 
-  LAST_FAIL_STATUSES = [STATUS_FAILED, STATUS_ABORTED, STATUS_TIMEOUT]
+  LAST_FAIL_STATUSES = [STATUS_FAILED, STATUS_ABORTED, STATUS_TASK_NOT_FOUND, STATUS_TIMEOUT].freeze
 
   validates :scheduling, presence: true, 'tasks_scheduler/cron_scheduling': true
-  validates :task, presence: true, inclusion: { in: rake_tasks }
+  validates :task, presence: true
   validates :last_fail_status, allow_blank: true, inclusion: { in: LAST_FAIL_STATUSES }
 
+  validate :validate_task
+
   LOG_RUNNING = 'running'
   LOG_SUCCESSFUL = 'successful'
   LOG_UNSUCCESSFUL = 'unsuccessful'
@@ -67,13 +69,26 @@ class ScheduledTask < ActiveRecord::Base
 
   def process_running?
     return false if pid.nil?
+
     Process.kill(0, pid)
-    return true
+    true
   rescue Errno::EPERM
     raise "No permission to query #{pid}!"
   rescue Errno::ESRCH
-    return false
-  rescue
+    false
+  rescue StandardError
     raise "Unable to determine status for #{pid}"
   end
+
+  def task_exist?
+    self.class.rake_tasks.include?(task)
+  end
+
+  def validate_task
+    return if task.blank?
+    return unless task_changed?
+    return if self.class.rake_tasks.include?(task)
+
+    errors.add(:task, "Task \"#{task}\" not found")
+  end
 end

data/app/models/scheduled_task/checker.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require 'rake'
+require 'eac_ruby_utils/ruby'
 
 class ScheduledTask < ActiveRecord::Base
   module Checker
@@ -34,6 +37,7 @@ class ScheduledTask < ActiveRecord::Base
 
     def check_on_pid_not_present
       return unless enabled?
+
       if next_run.present?
         check_task_with_next_run
       else
@@ -41,6 +45,12 @@ class ScheduledTask < ActiveRecord::Base
       end
     end
 
+    def check_on_task_not_exist
+      message = "Task does not exist: #{task}"
+      check_log(message)
+      on_end_running(::StandardError.new(message), STATUS_TASK_NOT_FOUND)
+    end
+
     def check_log(message, method = :info)
       Rails.logger.send(method, "TASK_CHECK(#{id}): #{message}")
     end
@@ -55,12 +65,14 @@ class ScheduledTask < ActiveRecord::Base
 
     def check_task_without_next_run
       check_log('Next run blank')
-      update_attributes!(next_run: calculate_next_run)
+      update!(next_run: calculate_next_run)
       check_log("Next run scheduled: #{next_run.in_time_zone}")
     end
 
     def check_task_with_next_run
-      if next_run < Time.zone.now
+      if !task_exist?
+        check_on_task_not_exist
+      elsif next_run < Time.zone.now
         check_log('Next run reached. Running...')
         spawn_task
       else
@@ -70,13 +82,15 @@ class ScheduledTask < ActiveRecord::Base
 
     def spawn_task
       params = ['bundle', 'exec', 'tasks_scheduler_run_task', id.to_s]
-      check_log("Spawn command: #{params}")
+      check_log("Spawn command: #{params} (Task: #{task})")
       spawn_pid = nil
-      Dir.chdir(Rails.root) do
-        spawn_pid = Process.spawn(*params)
+      ::EacRubyUtils::Ruby.on_clean_environment do
+        Dir.chdir(Rails.root) do
+          spawn_pid = ::Process.spawn(*params)
+        end
       end
       Process.detach(spawn_pid)
-      update_attributes!(pid: spawn_pid, last_fail_status: nil)
+      update!(pid: spawn_pid, last_fail_status: nil)
     end
 
     def timeout?

data/app/models/scheduled_task/log.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 class ScheduledTask < ActiveRecord::Base
   module Log
     def log_file(identifier)
       unless log_identifiers.include?(identifier)
-        fail "Log identifier unknown: \"#{identifier}\" (Valid: #{log_identifiers})"
+        raise "Log identifier unknown: \"#{identifier}\" (Valid: #{log_identifiers})"
       end
+
       Rails.root.join('log', 'tasks_scheduler', "#{id}_#{identifier}.log")
     end
 
@@ -23,9 +26,12 @@ class ScheduledTask < ActiveRecord::Base
     end
 
     def log_on_end(exception)
+      running_log = log_file(LOG_RUNNING)
+      return unless ::File.exist?(running_log)
+
       target_log = exception ? log_file(LOG_UNSUCCESSFUL) : log_file(LOG_SUCCESSFUL)
       File.unlink(target_log) if File.exist?(target_log)
-      File.rename(log_file(LOG_RUNNING), target_log)
+      File.rename(running_log, target_log)
     end
   end
 end

data/app/models/scheduled_task/runner.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 class ScheduledTask < ActiveRecord::Base
   module Runner
     def run
       log_on_start
       run_banner
       return if process_running? && pid != Process.pid
+
       status_on_start
       exception = invoke_task
       on_end_running(exception, STATUS_FAILED)
@@ -33,7 +36,7 @@ class ScheduledTask < ActiveRecord::Base
 
     def run_banner
       run_log("Task: #{self}")
-      run_log("PID: #{pid ? pid : '-'} (Current: #{Process.pid})")
+      run_log("PID: #{pid || '-'} (Current: #{Process.pid})")
       run_log("Process running? #{process_running? ? 'Yes' : 'No'}")
       run_log("Rails.env: #{Rails.env}")
     end
@@ -44,15 +47,16 @@ class ScheduledTask < ActiveRecord::Base
         Rake::Task.clear
         Rails.application.load_tasks
         Rake::Task[task].invoke(*invoke_args)
-      rescue StandardError => ex
-        run_log(ex, :fatal)
-        exception = ex
+      rescue StandardError => e
+        run_log(e, :fatal)
+        exception = e
       end
       exception
     end
 
     def invoke_args
-      return [] unless args.present?
+      return [] if args.blank?
+
       args.split('|')
     end
   end

data/app/models/scheduled_task/status.rb

@@ -1,10 +1,13 @@
+# frozen_string_literal: true
+
 class ScheduledTask < ActiveRecord::Base
   module Status
     def status
       return STATUS_DISABLED unless enabled?
       return STATUS_RUNNING if running?
       return STATUS_WAITING if waiting?
-      last_fail_status.present? ? last_fail_status : STATUS_FAILED
+
+      last_fail_status.presence || STATUS_FAILED
     end
 
     def failed?
@@ -17,6 +20,7 @@ class ScheduledTask < ActiveRecord::Base
 
     def waiting?
       return true if ended?(last_run_successful_end, last_run_unsuccessful_end)
+
       status_attributes.all? { |a| send(a).blank? }
     end
 
@@ -27,11 +31,11 @@ class ScheduledTask < ActiveRecord::Base
     end
 
     def status_on_start
-      update_attributes!(last_run_start: Time.zone.now)
+      update!(last_run_start: Time.zone.now)
     end
 
     def status_on_end(exception, last_fail_status)
-      update_attributes!(
+      update!(
         next_run: calculate_next_run,
         (exception ? :last_run_unsuccessful_start : :last_run_successful_start) => last_run_start,
         (exception ? :last_run_unsuccessful_end : :last_run_successful_end) => Time.zone.now,
@@ -42,7 +46,7 @@ class ScheduledTask < ActiveRecord::Base
     end
 
     def status_attributes
-      %w(start successful_start successful_end unsuccessful_start unsuccessful_end).map do |a|
+      %w[start successful_start successful_end unsuccessful_start unsuccessful_end].map do |a|
         "last_run_#{a}"
       end
     end

data/app/views/scheduled_tasks/status_content.html.erb

@@ -2,6 +2,7 @@
   <strong>Last update: </strong>
   <%= I18n.l(Time.zone.now, format: :short) %>
   <br/>
+  <strong>Daemon status: </strong>
   <%= render partial: '/tasks_scheduler_daemon/running_status' %>
 </p>
 <table>

data/app/views/tasks_scheduler_daemon/_daemon.html.erb

@@ -0,0 +1,11 @@
+<h3>Daemon</h3>
+<p>
+  <strong>Status: </strong>
+  <%= render partial: '/tasks_scheduler_daemon/running_status' %>
+  <br/>
+  <strong>Actions: </strong>
+  <%= safe_join(::TasksScheduler::Daemon::ACTIONS.map do |action|
+      link_to action, execute_tasks_scheduler_daemon_path(action), method: :post
+      end, ' | ') %>
+  <br/>
+</p>