tasks_scheduler 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f9254c9d8a1935a5a50a998c497502693a00a062
+  data.tar.gz: f1161054c8feebbad1210375262e0ad6e925f56b
+SHA512:
+  metadata.gz: dd68161f972bc3632c370b1cd6ebdb18c4e825719156022324f3327fb743f4d9ce7e5de6bf3ffe991aa1143ffa46eb1c9dd696fd9f2561ccf991af7935138c8c
+  data.tar.gz: b05bd8fbcaab8d142be5798d0d47b5701368237d492eb5b4f108c6b3ffd9e0b8a726c9d40930b8210596890a53c46fd07f61ad5b014caee8ddd8e321ab155461

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Eduardo H. Bogoni
+
+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/README.rdoc

@@ -0,0 +1,3 @@
+= TasksScheduler
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,33 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'TasksScheduler'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path('../test/dummy/Rakefile', __FILE__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/app/assets/javascripts/tasks_scheduler.js

@@ -0,0 +1,59 @@
+//= require active_scaffold
+
+function TasksScheduler() {
+}
+
+TasksScheduler.Status = function () {
+}
+
+// Shortcut
+var _S = TasksScheduler.Status;
+
+_S.initialized = false;
+
+_S.init = function (url, interval_max) {
+  if (!_S.initialized) {
+    _S.initialized = true;
+    _S.url = url;
+    _S.interval_max = interval_max;
+    _S.update();
+  }
+};
+
+_S.content = function () {
+  return $('#TaskScheduler_Status_Content');
+};
+
+_S.status = function () {
+  return $('#TaskScheduler_Status_Status');
+};
+
+_S.update_status = function () {
+  _S.status().html(
+    "Updating in " + _S.interval + " seconds..."
+  );
+};
+
+_S.check = function () {
+  if (_S.interval <= 0) {
+    _S.update();
+  } else {
+    _S.interval--;
+    _S.update_status();
+    setTimeout(_S.check, 1000);
+  }
+};
+
+_S.update = function () {
+  $.ajax({
+    url: _S.url,
+    success: function (result) {
+      _S.content().html(result);
+    },
+    complete: function (result) {
+      _S.interval = _S.interval_max + 1;
+      _S.last_update = new Date();
+      _S.check();
+    }
+  });
+};

data/app/assets/stylesheets/tasks_scheduler.scss

@@ -0,0 +1,34 @@
+@import 'active_scaffold';
+
+#TaskScheduler_Status_Status {
+  font-size: small;
+  margin-bottom: 1.0em;
+}
+
+#TaskScheduler_Status_Content {
+  table {
+    border-collapse: collapse;
+
+    td, th {
+      border: thin solid black;
+      padding: 0.3em;
+      text-align: center;
+    }
+
+    td.status_running {
+      color: blue;
+    }
+
+    td.status_waiting {
+      color: darkgrey;
+    }
+
+    td.status_failed {
+      color: red;
+    }
+  }
+
+  .last_run {
+    font-weight: bold;
+  }
+}

data/app/controllers/scheduled_tasks_controller.rb

@@ -0,0 +1,45 @@
+class ScheduledTasksController < ApplicationController
+  active_scaffold :scheduled_task do |conf|
+    [:create, :update, :list].each do |action|
+      conf.send(action).columns.exclude(:next_run, :last_run_start,
+                                        :last_run_successful_start, :last_run_unsuccessful_start,
+                                        :last_run_successful_end, :last_run_unsuccessful_end,
+                                        :pid)
+    end
+    conf.columns[:task].form_ui = :select
+    conf.columns[:task].options ||= {}
+    conf.columns[:task].options[:options] = task_column_options
+    conf.action_links.add :status, label: I18n.t(:tasks_scheduler_status), position: true
+    conf.action_links.add :run_now, label: I18n.t(:run_now), type: :member,
+                                    crud_type: :update, method: :put, position: false
+  end
+
+  def log
+    record = find_if_allowed(params[:id], :read)
+    @log_file = record.log_file(params[:identifier])
+  end
+
+  def status
+  end
+
+  def status_content
+    @scheduled_tasks = ::ScheduledTask.order(task: :asc, scheduling: :asc)
+    render layout: false
+  end
+
+  def run_now
+    process_action_link_action do |record|
+      record.update_attributes!(next_run: Time.zone.now)
+      record.reload
+      flash[:info] = "Next run adjusted to #{record.next_run}"
+    end
+  end
+
+  class << self
+    private
+
+    def task_column_options
+      ::ScheduledTask.rake_tasks.map { |st| [st, st] }
+    end
+  end
+end

data/app/helpers/scheduled_tasks_helper.rb

@@ -0,0 +1,17 @@
+module ScheduledTasksHelper
+  def scheduled_tasks_status_time(time)
+    if time.present?
+      I18n.l(time, format: :short)
+    else
+      '-'
+    end
+  end
+
+  def scheduled_tasks_log(scheduled_task, log_identifier)
+    if File.exist?(scheduled_task.log_file(log_identifier))
+      link_to I18n.t(:log), log_scheduled_task_path(scheduled_task, identifier: log_identifier)
+    else
+      '-'
+    end
+  end
+end

data/app/models/scheduled_task.rb

@@ -0,0 +1,61 @@
+require 'rake'
+
+class ScheduledTask < ActiveRecord::Base
+  include ::ScheduledTask::Checker
+  include ::ScheduledTask::Log
+  include ::ScheduledTask::Runner
+  include ::ScheduledTask::Status
+
+  class << self
+    def rake_tasks
+      @rake_tasks ||= begin
+        Rails.application.load_tasks
+        Rake.application.tasks.map(&:name)
+      end
+    end
+  end
+
+  validates :scheduling, presence: true, 'tasks_scheduler/cron_scheduling': true
+  validates :task, presence: true, inclusion: { in: rake_tasks }
+
+  STATUS_RUNNING = 'running'
+  STATUS_FAILED = 'failed'
+  STATUS_WAITING = 'waiting'
+
+  LOG_RUNNING = 'running'
+  LOG_SUCCESSFUL = 'successful'
+  LOG_UNSUCCESSFUL = 'unsuccessful'
+
+  def cron_parser
+    @cron_parser ||= ::CronParser.new(scheduling)
+  end
+
+  def to_s
+    "S: #{scheduling}, T: #{task}, NR: #{next_run.present? ? next_run.in_time_zone : '-'}"
+  end
+
+  def calculate_next_run(time = nil)
+    if time.present?
+      cron_parser.next(time.utc)
+    else
+      cron_parser.next
+    end
+  end
+
+  def write_attribute(name, value)
+    @cron_parser = nil if name == 'scheduling'
+    super
+  end
+
+  def process_running?
+    return false if pid.nil?
+    Process.kill(0, pid)
+    return true
+  rescue Errno::EPERM
+    raise "No permission to query #{pid}!"
+  rescue Errno::ESRCH
+    return false
+  rescue
+    raise "Unable to determine status for #{pid}"
+  end
+end

data/app/models/scheduled_task/checker.rb

@@ -0,0 +1,54 @@
+require 'rake'
+
+class ScheduledTask < ActiveRecord::Base
+  module Checker
+    def check
+      check_banner
+      if process_running?
+        check_log("Already running (PID: #{pid})")
+        return
+      end
+      if next_run.present?
+        check_task_with_next_run
+      else
+        check_task_without_next_run
+      end
+    end
+
+    private
+
+    def check_log(message, method = :info)
+      Rails.logger.send(method, "TASK_CHECK(#{id}): #{message}")
+    end
+
+    def check_banner
+      check_log("Task: #{self}")
+    end
+
+    def check_task_without_next_run
+      check_log('Next run blank')
+      update_attributes!(next_run: calculate_next_run)
+      check_log("Next run @scheduled_taskored: #{next_run.in_time_zone}")
+    end
+
+    def check_task_with_next_run
+      if next_run < Time.zone.now
+        check_log('Next run reached. Running...')
+        spawn_task
+      else
+        check_log('Next run not reached')
+      end
+    end
+
+    def spawn_task
+      params = ['bundle', 'exec', 'tasks_scheduler_run_task', id.to_s]
+      check_log("Spawn command: #{params}")
+      spawn_pid = nil
+      Dir.chdir(Rails.root) do
+        spawn_pid = Process.spawn(*params)
+      end
+      Process.detach(spawn_pid)
+      update_attributes!(pid: spawn_pid)
+    end
+  end
+end

data/app/models/scheduled_task/log.rb

@@ -0,0 +1,28 @@
+class ScheduledTask < ActiveRecord::Base
+  module Log
+    def log_file(identifier)
+      unless log_identifiers.include?(identifier)
+        fail "Log identifier unknown: \"#{identifier}\" (Valid: #{log_identifiers})"
+      end
+      Rails.root.join('log', 'tasks_scheduler', "#{id}_#{identifier}.log")
+    end
+
+    private
+
+    def log_identifiers
+      [LOG_RUNNING, LOG_UNSUCCESSFUL, LOG_SUCCESSFUL]
+    end
+
+    def log_on_start
+      FileUtils.mkdir_p(File.dirname(log_file(LOG_RUNNING)))
+      File.unlink(log_file(LOG_RUNNING)) if File.exist?(log_file(LOG_RUNNING))
+      Rails.logger = ActiveSupport::Logger.new(log_file(LOG_RUNNING))
+    end
+
+    def log_on_end(exception)
+      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)
+    end
+  end
+end

data/app/models/scheduled_task/runner.rb

@@ -0,0 +1,50 @@
+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
+      run_log(exception, :fatal) if exception
+      status_on_end(exception)
+      log_on_end(exception)
+      run_log("Next run: #{next_run.in_time_zone}")
+    end
+
+    private
+
+    def run_log(message, method = :info)
+      if message.is_a?(Exception)
+        run_log("#{message.class}: #{message.message}")
+        run_log(message.backtrace.join("\n"))
+      else
+        Rails.logger.send(method, "TASK_RUN(#{id}): #{message}")
+      end
+    end
+
+    def run_banner
+      run_log("Task: #{self}")
+      run_log("PID: #{pid ? pid : '-'} (Current: #{Process.pid})")
+      run_log("Process running? #{process_running? ? 'Yes' : 'No'}")
+    end
+
+    def invoke_task
+      exception = nil
+      begin
+        Rake::Task.clear
+        Rails.application.load_tasks
+        Rake::Task[task].invoke(invoke_args)
+      rescue StandardError => ex
+        run_log(ex, :fatal)
+        exception = ex
+      end
+      exception
+    end
+
+    def invoke_args
+      return [] unless args.present?
+      args.split('|')
+    end
+  end
+end

data/app/models/scheduled_task/status.rb

@@ -0,0 +1,53 @@
+class ScheduledTask < ActiveRecord::Base
+  module Status
+    def status
+      return STATUS_RUNNING if running?
+      return STATUS_WAITING if waiting?
+      return STATUS_FAILED if failed?
+      fail "Unknown status (#{status_attributes_values})"
+    end
+
+    def running?
+      last_run_start.present?
+    end
+
+    def waiting?
+      return true if ended?(last_run_successful_end, last_run_unsuccessful_end)
+      status_attributes.all? { |a| send(a).blank? }
+    end
+
+    def failed?
+      ended?(last_run_unsuccessful_end, last_run_successful_end)
+    end
+
+    def ended?(time, oposite_time)
+      !running? && time.present? && (oposite_time.blank? || oposite_time < time)
+    end
+
+    private
+
+    def status_on_start
+      update_attributes!(last_run_start: Time.zone.now)
+    end
+
+    def status_on_end(exception)
+      update_attributes!(
+        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,
+        last_run_start: nil,
+        pid: nil
+      )
+    end
+
+    def status_attributes
+      %w(start successful_start successful_end unsuccessful_start unsuccessful_end).map do |a|
+        "last_run_#{a}"
+      end
+    end
+
+    def status_attributes_values
+      status_attributes.map { |a| "#{a}: #{send(a)}" }.join(', ')
+    end
+  end
+end