foreman-tasks 0.7.6 → 0.7.7

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ZWM5N2ZhYzFhMzkxNDFhYTk2MGE4ZGRkNzNjNzRiZTlkNjJmNDdhNQ==
-  data.tar.gz: !binary |-
-    ODZiMDI1YmY1MDQ1ODBiMGZiZjE0NjMwNDhiNGUzMzY3YmIwM2FjMw==
+SHA1:
+  metadata.gz: 098fddc6fc2af891ed604780f543137d9e49e820
+  data.tar.gz: 9ae880cb667e08207995dd5e156c9960239f339e
 SHA512:
-  metadata.gz: !binary |-
-    MjIxYzA5NDE2YTlhMzVlZDdhYWFhOWY2ODg2MWNjNTI5ZjkyM2ZlMWU4MmY1
-    MzYzNGVjZTM4NDUyYTc2NDEwNWMxMjQyODdlYjU1YjM4ZjA5ZWRiYmExZjNj
-    NzI2OTkzMGIzZjA5MDI2YTFkMTUzZjdkNDdkY2RhMTM5MjkwZWY=
-  data.tar.gz: !binary |-
-    NDNkMGZlMDkzMTg1MjQ4YmUxZmRhNGFhZTQ5N2Y4YzUxMTBiM2EyZTIzMDIw
-    MGZlM2E0NDQyYzRiZTIwNDU2ZDBjNzQ5OGI1NmFlNTMyZGE2OWVmMGM2NzBl
-    YWMzNDUyMzViYWMxYmI4MjcwOWExNTFlYzI3NmM2MThmODRlZjk=
+  metadata.gz: 71a4d2529300e104363a53dac9c534e3a682cac5f14fe722076c7d29df48429ef0ae9f777633135b7575b68288b725b9176a449018c0276d159becd5fb0ee4fe
+  data.tar.gz: 39364230aa8cd621e922c377685f85cb570af75dec61ccb5105942e82793e52d71bdd061ba544200227d17215b890ad9312109c51a5f4246826e21f7823a05c2

data/app/assets/javascripts/trigger_form.js

@@ -0,0 +1,41 @@
+function trigger_form_selector_binds(form_name, form_object_name) {
+  var form = $('form#' +  form_name);
+  var trigger_mode_selector = form.find('input.trigger_mode_selector');
+  var input_type_selector = form.find('.form-control#input_type_selector');
+
+  trigger_mode_selector.on('click', function () {
+    ["future", "immediate", "recurring"].forEach(function(type) {
+      form.find('fieldset.trigger_mode_form#trigger_mode_' + type).hide();
+    });
+    form.find('fieldset.trigger_mode_form#trigger_mode_' + $(this).val()).show();
+  });
+
+  input_type_selector.on('change', function () {
+    var fieldset = form.find('fieldset.trigger_mode_form#trigger_mode_recurring');
+    ['cronline', 'monthly', 'weekly', 'hourly', 'daily'].forEach(function(type) {
+      fieldset.find('fieldset.input_type_form#input_type_' + type).hide();
+    })
+    fieldset.find('fieldset.input_type_form#input_type_' + $(this).val()).show();
+    var timepicker = fieldset.find('fieldset.input_type_form#time_picker');
+    if($(this).val() == 'cronline') {
+      timepicker.hide();
+    } else {
+      var hour_picker = timepicker.find('#s2id_triggering_time_time_4i');
+      if($(this).val() == 'hourly') {
+        hour_picker.hide();
+      } else {
+        hour_picker.show();
+      }
+      timepicker.show();
+    }
+  });
+
+  form.find('input.end_time_limit_selector').on('click', function() {
+    var o = form.find('fieldset#trigger_mode_recurring fieldset#end_time_limit_form');
+    if($(this).val() === 'true') {
+      o.show();
+    } else {
+      o.hide();
+    };
+  });
+};

data/app/controllers/foreman_tasks/recurring_logics_controller.rb

@@ -0,0 +1,33 @@
+module ForemanTasks
+  class RecurringLogicsController < ::ApplicationController
+
+    before_filter :find_recurring_logic, :only => [:show, :cancel]
+
+    def index
+      @recurring_logics = filter(resource_base)
+    end
+
+    def show
+    end
+
+    def cancel
+      @recurring_logic.cancel
+      redirect_to :action => :index
+    end
+
+    def controller_name
+      'foreman_tasks_recurring_logics'
+    end
+
+    private
+
+    def find_recurring_logic
+      @recurring_logic ||= ::ForemanTasks::RecurringLogic.find(params[:id])
+    end
+
+    def filter(scope)
+      scope.search_for(params[:search]).paginate(:page => params[:page])
+    end
+
+  end
+end

data/app/helpers/foreman_tasks/foreman_tasks_helper.rb

@@ -0,0 +1,144 @@
+module ForemanTasks
+  module ForemanTasksHelper
+
+    def recurring_logic_state(recurring_logic)
+      icon, status = case recurring_logic.state
+             when 'active'
+               'glyphicon-info-sign'
+             when 'finished'
+               ['glyphicon-ok-sign', 'status-ok']
+             when 'cancelled'
+               ['glyphicon-warning-sign', 'status-error']
+             else
+               'glyphicon-question-sign'
+             end
+      content_tag(:i, '&nbsp'.html_safe, :class => "glyphicon #{icon}") + content_tag(:span, recurring_logic.humanized_state, :class => status)
+    end
+
+    def recurring_logic_action_buttons(recurring_logic)
+      buttons = []
+      if authorized_for(:permission => :edit_recurring_logics, :auth_object => recurring_logic)
+        buttons << link_to(N_("Cancel"), cancel_foreman_tasks_recurring_logic_path(recurring_logic), :method => :post, :class => 'btn btn-danger') unless %w(cancelled finished).include? recurring_logic.state
+      end
+      button_group buttons
+    end
+
+    def recurring_logic_next_occurrence(recurring_logic)
+      if %w(finished cancelled).include? recurring_logic.state
+        N_('-')
+      else
+        recurring_logic.next_occurrence_time
+      end
+    end
+
+    def time_f(f, attr, field_options = {}, time_options = {}, html_options = {})
+      f.fields_for attr do |fields|
+        field(fields, attr, field_options) do
+          fields.time_select attr, time_options, html_options
+        end
+      end
+    end
+
+    def datetime_f(f, attr, field_options = {}, datetime_options = {}, html_options = {})
+      f.fields_for attr do |fields|
+        field(fields, attr, field_options) do
+          fields.datetime_select attr, datetime_options, html_options
+        end
+      end
+    end
+
+    def inline_checkboxes_f(f, attr, field_options = {}, checkboxes = {}, options = {})
+      field(f, attr, field_options) do
+        checkboxes.map do |key, name|
+          [f.check_box(key, options), " #{name} "]
+        end.flatten.join('')
+      end
+    end
+
+    def trigger_selector(f, triggering = Triggering.new, options = {})
+      render :partial => 'common/trigger_form', :locals => { :f => f, :triggering => triggering }
+    end
+
+    private
+
+    def future_mode_fieldset(f, triggering)
+      tags = []
+      tags << text_f(f, :start_at_raw, :label => _('Start at'), :placeholder => 'YYYY-mm-dd HH:MM')
+      tags << text_f(f, :start_before_raw, :label => _('Start before'), :placeholder => 'YYYY-mm-dd HH:MM')
+      content_tag(:fieldset, nil, :id => "trigger_mode_future", :class => "trigger_mode_form #{'hidden' unless triggering.future?}") do
+        tags.join.html_safe
+      end
+    end
+
+    def recurring_mode_fieldset(f, triggering)
+      tags = []
+      tags << selectable_f(f, :input_type, %w(cronline monthly weekly daily hourly), {}, :label => _("Repeats"), :id => 'input_type_selector')
+      tags += [
+        cronline_fieldset(f, triggering),
+        monthly_fieldset(f, triggering),
+        weekly_fieldset(f, triggering),
+        time_picker_fieldset(f, triggering)
+      ]
+
+      content_tag(:fieldset, nil, :id => 'trigger_mode_recurring', :class => "trigger_mode_form #{'hidden' unless triggering.recurring?}") do
+        tags.join.html_safe
+      end
+    end
+
+    def cronline_fieldset(f, triggering)
+      options = [
+        _('is minute (range: 0-59)'),
+        _('is hour (range: 0-23)'),
+        _('is day of month (range: 1-31)'),
+        _('is month (range: 1-12)'),
+        _('is day of week (range: 0-6)')
+      ].map { |opt| content_tag(:li, opt) }.join
+      help = content_tag(:span, nil, :class => 'help-inline') do
+        popover(_('Explanation'),
+                _("Cron line format 'a b c d e', where:<br><ol type=\"a\">#{options}</ol>"))
+      end
+      content_tag(:fieldset, nil, :class => "input_type_form #{'hidden' unless triggering.input_type == :cronline}", :id => "input_type_cronline") do
+        text_f f, :cronline, :label => _('Cron line'), :placeholder => '* * * * *', :help_inline => help
+      end
+    end
+
+    def monthly_fieldset(f, triggering)
+      content_tag(:fieldset, nil, :id => "input_type_monthly", :class => "input_type_form #{'hidden' unless triggering.input_type == :monthly}") do
+        text_f(f, :days, :label => _('Days'), :placeholder => '1,2...')
+      end
+    end
+
+    def weekly_fieldset(f, triggering)
+      content_tag(:fieldset, nil, :id => 'input_type_weekly', :class => "input_type_form #{'hidden' unless triggering.input_type == :weekly}") do
+        f.fields_for :days_of_week do |days_of_week|
+          inline_checkboxes_f(days_of_week,
+                              :weekday,
+                              { :label => _("Days of week") },
+                              { 1 => _("Mon"),
+                                2 => _("Tue"),
+                                3 => _("Wed"),
+                                4 => _("Thu"),
+                                5 => _("Fri"),
+                                6 => _("Sat"),
+                                7 => _("Sun") })
+        end
+      end
+    end
+
+    def time_picker_fieldset(f, triggering)
+      tags = []
+      tags << content_tag(:fieldset, nil, :id => 'time_picker', :class => "input_type_form #{'hidden' if triggering.input_type == :cronline}") do
+        time_f(f, :time, { :label => _("At"), :id => 'something' }, { :time_separator => '' })
+      end
+      tags << number_f(f, :max_iteration, :label => _('Repeat N times'), :min => 1, :placeholder => 'N')
+      tags << field(f, :end_time_limit_select, :label => _("Ends"), :control_group_id => "end_time_limit_select") do
+        radio_button_f(f, :end_time_limited, :value => false, :checked=> true, :text => _("Never"), :class => 'end_time_limit_selector') +
+        radio_button_f(f, :end_time_limited, :value => true, :text => _("On"), :class => 'end_time_limit_selector')
+      end
+      tags << content_tag(:fieldset, nil, :id => 'end_time_limit_form', :class => "input_type_form #{'hidden' unless triggering.end_time_limited}") do
+        datetime_f f, :end_time, { :label => _("Ends at") }, { :use_month_numbers => true, :use_two_digit_numbers => true, :time_separator => '' }
+      end
+      tags.join.html_safe
+    end
+  end
+end

data/app/helpers/foreman_tasks/tasks_helper.rb

@@ -12,5 +12,13 @@ module ForemanTasks
       end.join('; ')
       parts.join(" ")
     end
+
+    def format_recurring_logic_limit(thing)
+      if thing.nil?
+        content_tag(:i, N_('Unlimited'))
+      else
+        thing
+      end
+    end
   end
 end

data/app/lib/actions/base.rb

@@ -55,5 +55,9 @@ module Actions
       ForemanTasks::Task::DynflowTask.for_action(self.class).
         running.where('external_id != ?', execution_plan_id).any?
     end
+
+    def serializer_class
+      ::Actions::Serializers::ActiveRecordSerializer
+    end
   end
 end

data/app/lib/actions/entry_action.rb

@@ -57,7 +57,11 @@ module Actions
     end
 
     def delay(_schedule_options, *args)
-      Serializers::ActiveRecordSerializer.new args
+      self.serializer_class.new args
+    end
+
+    def self.serializer_class
+      Serializers::ActiveRecordSerializer
     end
 
   end

data/app/lib/actions/foreman/host/import_facts.rb

@@ -27,6 +27,10 @@ module Actions
           raise e unless e.code == 'ERF51-9911'
         end
 
+        def rescue_strategy
+          ::Dynflow::Action::Rescue::Skip
+        end
+
         def humanized_name
           _("Import facts")
         end

data/app/lib/actions/middleware/inherit_task_groups.rb

@@ -0,0 +1,39 @@
+module Actions
+  module Middleware
+    class InheritTaskGroups < Dynflow::Middleware
+
+      def delay(*args)
+        pass *args
+      end
+
+      def plan(*args)
+        inherit_task_groups
+        pass *args
+      end
+
+      def run(*args)
+        pass *args
+        collect_children_task_groups
+      end
+
+      def finalize
+        pass
+      end
+
+      private
+
+      def inherit_task_groups
+        task.add_missing_task_groups(task.parent_task.task_groups) if task.parent_task
+      end
+
+      def collect_children_task_groups
+        task.add_missing_task_groups task.sub_tasks.map(&:task_groups).flatten
+      end
+
+      def task
+        @task ||= action.task
+      end
+    end
+  end
+end
+

data/app/lib/actions/middleware/recurring_logic.rb

@@ -0,0 +1,42 @@
+module Actions
+  module Middleware
+    class RecurringLogic < ::Dynflow::Middleware
+
+      # ::Actions::Middleware::RecurringLogic
+      #
+      # A middleware designed to make action repeatable.
+      # After an action is delayed, it checks whether the delay_options
+      # hash contains an id of a recurring logic. If so, it adds the task
+      # to the recurring logic's task group, otherwise does nothing.
+      #
+      # After the action's plan phase the middleware checks if the task
+      # is associated with a task group of any recurring logic, in which case
+      # it triggers another repeat using the task group's recurring logic,
+      # otherwise does nothing.
+      def delay(delay_options, *args)
+        pass(delay_options, *args).tap do
+          if delay_options[:recurring_logic_id]
+            task.add_missing_task_groups(recurring_logic(delay_options).task_group)
+          end
+        end
+      end
+
+      def plan(*args)
+        pass(*args).tap do
+          task_group = task.task_groups.find { |tg| tg.is_a? ::ForemanTasks::TaskGroups::RecurringLogicTaskGroup }
+          task_group.recurring_logic.trigger_repeat(action.class, *args) if task_group
+        end
+      end
+
+      private
+
+      def recurring_logic(delay_options)
+        ForemanTasks::RecurringLogic.find(delay_options[:recurring_logic_id])
+      end
+
+      def task
+        @task ||= action.task
+      end
+    end
+  end
+end

data/app/models/foreman_tasks/recurring_logic.rb

@@ -0,0 +1,136 @@
+module ForemanTasks
+
+  require 'parse-cron'
+
+  class RecurringLogic < ActiveRecord::Base
+    include Authorizable
+
+    belongs_to :task_group
+    belongs_to :triggering
+
+    has_many :tasks, :through => :task_group
+    has_many :task_groups, :through => :tasks, :uniq => true
+
+    validates :cron_line, :presence => true
+
+    scoped_search :on => :id, :complete_value => false
+    scoped_search :on => :max_iteration, :complete_value => false, :rename => :iteration_limit
+    scoped_search :on => :iteration, :complete_value => false
+    scoped_search :on => :cron_line, :complete_value => true
+
+    before_create do
+      self.task_group.save
+    end
+
+    def self.allowed_states
+      %w(active finished cancelled failed)
+    end
+
+    def start(action_class, *args)
+      self.state = 'active'
+      save!
+      trigger_repeat(action_class, *args)
+    end
+
+    def trigger_repeat(action_class, *args)
+      unless can_continue?
+        self.state = 'finished'
+        save!
+        return
+      else
+        self.iteration += 1
+        save!
+        ::ForemanTasks.delay action_class,
+                             generate_delay_options,
+                             *args
+      end
+    end
+
+    def cancel
+      self.state = 'cancelled'
+      save!
+      tasks.active.each(&:cancel)
+    end
+
+    def next_occurrence_time(time = Time.now)
+      @parser ||= CronParser.new(cron_line)
+      @parser.next(time)
+    end
+
+    def generate_delay_options(time = Time.now, options = {})
+      {
+        :start_at => next_occurrence_time(time),
+        :start_before => options['start_before'],
+        :recurring_logic_id => self.id
+      }
+    end
+
+    def can_continue?(time = Time.now)
+      self.state == 'active' &&
+        (end_time.nil? || next_occurrence_time(time) < end_time) &&
+        (max_iteration.nil? || iteration < max_iteration)
+    end
+
+    def finished?
+      self.state == 'finished'
+    end
+
+    def humanized_state
+      case self.state
+      when 'active'
+        N_('Active')
+      when 'cancelled'
+        N_('Cancelled')
+      when 'finished'
+        N_('Finished')
+      else
+        N_('N/A')
+      end
+    end
+
+    def self.assemble_cronline(hash)
+      hash.values_at(*[:minutes, :hours, :days, :months, :days_of_week])
+          .map { |value| (value.nil? || value.blank?) ? '*' : value }
+          .join(' ')
+    end
+
+    def self.new_from_cronline(cronline)
+      self.new.tap do |logic|
+        logic.cron_line = cronline
+        logic.task_group = ::ForemanTasks::TaskGroups::RecurringLogicTaskGroup.new
+      end
+    end
+
+    def self.new_from_triggering(triggering)
+      cronline = if triggering.input_type == :cronline
+                   triggering.cronline
+                 else
+                   ::ForemanTasks::RecurringLogic.assemble_cronline(cronline_hash triggering.input_type, triggering.time, triggering.days_of_week)
+                 end
+      ::ForemanTasks::RecurringLogic.new_from_cronline(cronline).tap do |manager|
+        manager.end_time = Time.new(*recurring_options.end_time.values) if triggering.end_time_limited
+        manager.max_iteration = triggering.max_iteration unless triggering.max_iteration.blank?
+        manager.triggering = triggering
+      end
+    end
+
+    def self.cronline_hash(recurring_type, time_hash, days_of_week_hash)
+      hash = Hash[[:years, :months, :days, :hours, :minutes].zip(time_hash.values)]
+      
+      hash.update :days_of_week => days_of_week_hash
+                                  .select { |value, index| value == "1" }
+                                  .values.join(',')
+      allowed_keys = case recurring_type
+                     when :monthly
+                       [:minutes, :hours, :days]
+                     when :weekly
+                       [:minutes, :hours, :days_of_week]
+                     when :daily
+                       [:minutes, :hours]
+                     when :hourly
+                       [:minutes]
+                     end
+      hash.select { |key, _| allowed_keys.include? key }
+    end
+  end
+end