foreman-tasks 0.8.6 → 0.9.0

data/app/models/foreman_tasks/task/dynflow_task.rb

@@ -1,8 +1,8 @@
 module ForemanTasks
   class Task::DynflowTask < ForemanTasks::Task
-
     include Algebrick::TypeCheck
 
+    delegate :cancellable?, :progress, to: :execution_plan
     scope :for_action, ->(action_class) { where(label: action_class.name) }
 
     def update_from_dynflow(data)
@@ -11,7 +11,7 @@ module ForemanTasks
       self.started_at     = utc_zone.parse(data[:started_at]) unless data[:started_at].nil?
       self.ended_at       = utc_zone.parse(data[:ended_at]) unless data[:ended_at].nil?
       self.state          = data[:state].to_s
-      self.result         = data[:result].to_s
+      self.result         = map_result(data[:result])
       self.start_at       = utc_zone.parse(data[:start_at]) if data[:start_at]
       self.start_before   = utc_zone.parse(data[:start_before]) if data[:start_before]
       self.parent_task_id ||= begin
@@ -20,13 +20,9 @@ module ForemanTasks
                                 end
                               end
       self.label          ||= main_action.class.name
-      changes             = self.changes
-      self.save!
-      return changes
-    end
-
-    def cancellable?
-      execution_plan.cancellable?
+      changes = self.changes
+      save!
+      changes
     end
 
     def cancel
@@ -41,10 +37,6 @@ module ForemanTasks
       action.is_a?(::Dynflow::Action::Cancellable)
     end
 
-    def progress
-      execution_plan.progress
-    end
-
     def execution_plan
       @execution_plan ||= ForemanTasks.dynflow.world.persistence.load_execution_plan(external_id)
     end
@@ -73,9 +65,7 @@ module ForemanTasks
     end
 
     def cli_example
-      if main_action.respond_to?(:cli_example)
-        main_action.cli_example
-      end
+      main_action.cli_example if main_action.respond_to?(:cli_example)
     end
 
     def main_action
@@ -104,30 +94,39 @@ module ForemanTasks
     def self.consistency_check
       fixed_count = 0
       logger = Foreman::Logging.logger('foreman-tasks')
-      self.running.each do |task|
+      running.each do |task|
         begin
           changes = task.update_from_dynflow(task.execution_plan.to_hash)
           unless changes.empty?
             fixed_count += 1
-            logger.warn("Task %s updated at consistency check: %s" % [task.id, changes.inspect])
+            logger.warn('Task %s updated at consistency check: %s' % [task.id, changes.inspect])
           end
         rescue => e
           Foreman::Logging.exception("Failed at consistency check for task #{task.id}", e, :logger => 'foreman-tasks')
         end
       end
-      return fixed_count
+      fixed_count
     end
 
     def self.new_for_execution_plan(execution_plan_id, data)
-      self.new(:external_id => execution_plan_id,
-               :state => data[:state].to_s,
-               :result => data[:result].to_s)
+      new(:external_id => execution_plan_id,
+          :state => data[:state].to_s,
+          :result => data[:result].to_s)
     end
 
-    private
-
     def self.model_name
       superclass.model_name
     end
+
+    private
+
+    def map_result(result)
+      result = :cancelled if result == :error && cancelled?
+      result.to_s
+    end
+
+    def cancelled?
+      execution_plan.errors.map(&:exception).any? { |exception| exception.class == ::ForemanTasks::Task::TaskCancelledException }
+    end
   end
 end

data/app/models/foreman_tasks/task/status_explicator.rb

@@ -3,9 +3,9 @@ module ForemanTasks
     ANY = 1
     ERRONEOUS_STATUSES = [
       { :state => 'paused', :result => ANY },
-      { :state => ANY, :result => 'error'},
-      { :state => ANY, :result => 'warning'}
-    ]
+      { :state => ANY, :result => 'error' },
+      { :state => ANY, :result => 'warning' }
+    ].freeze
     def is_erroneous(task)
       remainder = ERRONEOUS_STATUSES.select do |status|
         (status[:state] == ANY || status[:state] == task.state) &&

data/app/models/foreman_tasks/task/summarizer.rb

@@ -1,13 +1,13 @@
 module ForemanTasks
   class Task::Summarizer
-    def summarize_by_status(since=nil)
+    def summarize_by_status(since = nil)
       result = ::ForemanTasks::Task.select('count(state) AS count, state, result').group(:state, :result).order(:state)
       result = result.where('started_at > ?', since) if since
       result
     end
 
-    def latest_tasks_in_errors_warning(limit=5)
-      ::ForemanTasks::Task.where('result in (?)', ['error', 'warning']).order('started_at DESC').limit(limit)
+    def latest_tasks_in_errors_warning(limit = 5)
+      ::ForemanTasks::Task.where('result in (?)', %w(error warning)).order('started_at DESC').limit(limit)
     end
   end
 end

data/app/models/foreman_tasks/task_group.rb

@@ -1,6 +1,5 @@
 module ForemanTasks
   class TaskGroup < ActiveRecord::Base
-
     has_many :task_group_members
     has_many :tasks, :through => :task_group_members
 
@@ -11,6 +10,5 @@ module ForemanTasks
     def resource
       raise NotImplementedError
     end
-
   end
 end

data/app/models/foreman_tasks/task_group_member.rb

@@ -1,8 +1,6 @@
 module ForemanTasks
   class TaskGroupMember < ActiveRecord::Base
-
     belongs_to :task_group
     belongs_to :task
-    
   end
 end

data/app/models/foreman_tasks/task_groups/recurring_logic_task_group.rb

@@ -1,16 +1,13 @@
 module ForemanTasks
   module TaskGroups
     class RecurringLogicTaskGroup < ::ForemanTasks::TaskGroup
-
       has_one :recurring_logic, :foreign_key => :task_group_id
 
-      alias_method :resource, :recurring_logic
+      alias resource recurring_logic
 
       def resource_name
         N_('Recurring logic')
       end
-
     end
   end
 end
-

data/app/models/foreman_tasks/triggering.rb

@@ -2,8 +2,8 @@ module ForemanTasks
   class Triggering < ActiveRecord::Base
     PARAMS = [:start_at_raw, :start_before_raw, :max_iteration, :input_type,
               :cronline, :days, :days_of_week, :time, :end_time_limited,
-              :end_time]
-    attr_accessor *PARAMS
+              :end_time].freeze
+    attr_accessor(*PARAMS)
 
     before_save do
       if future?
@@ -14,34 +14,34 @@ module ForemanTasks
       end
     end
 
-    ALLOWED_MODES = [:immediate, :future, :recurring]
-    ALLOWED_INPUT_TYPES = [:cronline, :monthly, :weekly, :daily, :hourly]
+    ALLOWED_MODES = [:immediate, :future, :recurring].freeze
+    ALLOWED_INPUT_TYPES = [:cronline, :monthly, :weekly, :daily, :hourly].freeze
 
-    TIME_FORMAT = "%Y-%m-%d %H:%M"
+    TIME_FORMAT = '%Y-%m-%d %H:%M'.freeze
     TIME_REGEXP = /\A\d{4}-\d{2}-\d{2} \d{2}:\d{2}\Z/
     DAYS_REGEXP = /\A(\s*\d{1,2}\s*)(,\s*\d{1,2}\s*)*\Z/
 
     has_one :recurring_logic, :foreign_key => :triggering_id
 
     validates :mode, :inclusion => { :in => ALLOWED_MODES,
-                                     :message => _("%{value} is not allowed triggering mode")  }
+                                     :message => _('%{value} is not allowed triggering mode') }
     validates :input_type, :if => :recurring?,
-              :inclusion => { :in => ALLOWED_INPUT_TYPES,
-                              :message => _("%{value} is not allowed input type") }
-    validates_format_of :start_at_raw, :with => TIME_REGEXP, :if => :future?,
-                        :message => _("%{value} is wrong format")
-    validates_format_of :start_before_raw, :with => TIME_REGEXP, :if => :future?,
-                        :message => _("%{value} is wrong format"), :allow_blank => true
-    validates_format_of :days, :with => DAYS_REGEXP,
-                        :if => Proc.new { |t| t.recurring? && t.input_type == :monthly }
+                           :inclusion => { :in => ALLOWED_INPUT_TYPES,
+                                           :message => _('%{value} is not allowed input type') }
+    validates :start_at_raw, format: { :with => TIME_REGEXP, :if => :future?,
+                                       :message => _('%{value} is wrong format') }
+    validates :start_before_raw, format: { :with => TIME_REGEXP, :if => :future?,
+                                           :message => _('%{value} is wrong format'), :allow_blank => true }
+    validates :days, format: { :with => DAYS_REGEXP,
+                               :if => proc { |t| t.recurring? && t.input_type == :monthly } }
     validate :can_start_recurring, :if => :recurring?
     validate :can_start_future, :if => :future?
 
     def self.new_from_params(params = {})
-      self.new(params.except(:mode, :start_at, :start_before)).tap do |triggering|
+      new(params.except(:mode, :start_at, :start_before)).tap do |triggering|
         triggering.mode = params.fetch(:mode, :immediate).to_sym
         triggering.input_type = params.fetch(:input_type, :daily).to_sym
-        triggering.end_time_limited = params[:end_time_limited] == "true"
+        triggering.end_time_limited = params[:end_time_limited] == 'true'
         triggering.start_at_raw ||= Time.zone.now.strftime(TIME_FORMAT)
         triggering.recurring_logic = ::ForemanTasks::RecurringLogic.new_from_triggering(triggering) if triggering.recurring?
       end
@@ -102,14 +102,14 @@ module ForemanTasks
     private
 
     def can_start_recurring
-      self.errors.add(:input_type, _('No task could be started')) unless recurring_logic.valid?
-      self.errors.add(:cronline, _('%s is not valid format of cron line') % (cronline)) unless recurring_logic.valid_cronline?
+      errors.add(:input_type, _('No task could be started')) unless recurring_logic.valid?
+      errors.add(:cronline, _('%s is not valid format of cron line') % cronline) unless recurring_logic.valid_cronline?
     end
 
     def can_start_future
       parse_start_before!
       parse_start_at!
-      self.errors.add(:start_before_raw, _('The task could not be started')) if !start_before.nil? && start_before < start_at
+      errors.add(:start_before_raw, _('The task could not be started')) if !start_before.nil? && start_before < start_at
     end
   end
 end

data/app/models/setting/foreman_tasks.rb

@@ -1,22 +1,19 @@
 class Setting::ForemanTasks < Setting
-
   def self.load_defaults
     # Check the table exists
     return unless super
 
-    self.transaction do
+    transaction do
       [
-          self.set('dynflow_allow_dangerous_actions', N_("Allow unlocking actions which can have dangerous consequences."), false),
-          self.set('dynflow_enable_console', N_("Enable the dynflow console (/foreman_tasks/dynflow) for debugging"), true),
-          self.set('dynflow_console_require_auth', N_("Require user to be authenticated as user with admin rights when accessing dynflow console"), true),
-          self.set('foreman_tasks_proxy_action_retry_count', N_("Number of attempts to start a task on the smart proxy before failing"), 4),
-          self.set('foreman_tasks_proxy_action_retry_interval', N_("Time in seconds between retries"), 15),
-          self.set('foreman_tasks_proxy_action_start_timeout', N_("Time in second during which a task has to be started on the proxy"), 60)
-      ].each { |s| self.create! s.update(:category => "Setting::ForemanTasks")}
+        set('dynflow_allow_dangerous_actions', N_('Allow unlocking actions which can have dangerous consequences.'), false),
+        set('dynflow_enable_console', N_('Enable the dynflow console (/foreman_tasks/dynflow) for debugging'), true),
+        set('dynflow_console_require_auth', N_('Require user to be authenticated as user with admin rights when accessing dynflow console'), true),
+        set('foreman_tasks_proxy_action_retry_count', N_('Number of attempts to start a task on the smart proxy before failing'), 4),
+        set('foreman_tasks_proxy_action_retry_interval', N_('Time in seconds between retries'), 15),
+        set('foreman_tasks_proxy_action_start_timeout', N_('Time in second during which a task has to be started on the proxy'), 60)
+      ].each { |s| create! s.update(:category => 'Setting::ForemanTasks') }
     end
 
     true
-
   end
-
 end

data/app/services/foreman_tasks/proxy_selector.rb

@@ -1,6 +1,5 @@
 module ForemanTasks
   class ProxySelector
-
     attr_reader :offline
 
     def initialize
@@ -12,7 +11,7 @@ module ForemanTasks
       [:subnet, :fallback, :global]
     end
 
-    def available_proxies(*args)
+    def available_proxies(*_args)
       raise NotImplementedError
     end
 
@@ -34,8 +33,8 @@ module ForemanTasks
     def select_by_jobs_count(proxies)
       exclude = @tasks.keys + @offline
       @tasks.merge!(get_counts(proxies - exclude))
-      next_proxy = @tasks.select { |proxy, _| proxies.include?(proxy) }.
-          min_by { |_, job_count| job_count }.try(:first)
+      next_proxy = @tasks.select { |proxy, _| proxies.include?(proxy) }
+                         .min_by { |_, job_count| job_count }.try(:first)
       @tasks[next_proxy] += 1 if next_proxy.present?
       next_proxy
     end
@@ -43,7 +42,7 @@ module ForemanTasks
     private
 
     def get_counts(proxies)
-      proxies.inject({}) do |result, proxy|
+      proxies.each_with_object({}) do |proxy, result|
         begin
           proxy_api = ProxyAPI::ForemanDynflow::DynflowProxy.new(:url => proxy.url)
           result[proxy] = proxy_api.tasks_count('running')

data/app/views/foreman_tasks/tasks/_details.html.erb

@@ -168,7 +168,7 @@
            aria-valuemin="0"
            aria-valuemax="100"
            style="width: <%= progress %>%;">
-        <span><%= progress %>% Complete</span>
+        <span><%= progress.round %>% Complete</span>
       </div>
     </div>
   </div>

data/bin/dynflow-executor

@@ -8,7 +8,7 @@ opts = OptionParser.new do |opts|
   opts.banner = <<BANNER
 Run Dynflow executor for Foreman tasks.
 
-Usage: #{File.basename($0)} [options] ACTION"
+Usage: #{File.basename($PROGRAM_NAME)} [options] ACTION"
 
 ACTION can be one of:
 

data/bin/foreman-tasks

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
 
-foreman_root = "/usr/share/foreman"
+foreman_root = '/usr/share/foreman'
 require File.expand_path('./config/application', foreman_root)
 ForemanTasks::Dynflow::Daemon.new.run_background(ARGV.last, :foreman_root => foreman_root)

data/config/routes.rb

@@ -39,7 +39,7 @@ Foreman::Application.routes.draw do
 
     if ForemanTasks.dynflow.required?
       require 'dynflow/web'
-      mount ForemanTasks.dynflow.web_console => "/dynflow"
+      mount ForemanTasks.dynflow.web_console => '/dynflow'
     end
   end
 end

data/db/migrate/20150814204140_add_task_type_value_index.rb

@@ -1,5 +1,5 @@
 class AddTaskTypeValueIndex < ActiveRecord::Migration
   def change
-     add_index :foreman_tasks_tasks, [:type, :label]
+    add_index :foreman_tasks_tasks, [:type, :label]
   end
 end

data/db/migrate/20160924213030_change_tasks_widget_names.rb

@@ -1,15 +1,15 @@
 class ChangeTasksWidgetNames < ActiveRecord::Migration
   def up
-    Widget.where(:name => 'Tasks Status table').\
-      update_all(:name => 'Task Status')
-    Widget.where(:name => 'Tasks in Error/Warning').\
-      update_all(:name => 'Latest Warning/Error Tasks')
+    Widget.where(:name => 'Tasks Status table')\
+          .update_all(:name => 'Task Status')
+    Widget.where(:name => 'Tasks in Error/Warning')\
+          .update_all(:name => 'Latest Warning/Error Tasks')
   end
 
   def down
-    Widget.where(:name => 'Task Status').\
-      update_all(:name => 'Tasks Status table')
-    Widget.where(:name => 'Latest Warning/Error Tasks').\
-      update_all(:name => 'Tasks in Error/Warning')
+    Widget.where(:name => 'Task Status')\
+          .update_all(:name => 'Tasks Status table')
+    Widget.where(:name => 'Latest Warning/Error Tasks')\
+          .update_all(:name => 'Tasks in Error/Warning')
   end
 end

data/db/seeds.d/61-foreman_tasks_bookmarks.rb

@@ -1,12 +1,12 @@
 Bookmark.without_auditing do
   [
-    { :name => "running", :query => "state = running" },
-    { :name => "failed", :query => "state = paused or result = error or result = warning" }
+    { :name => 'running', :query => 'state = running' },
+    { :name => 'failed', :query => 'state = paused or result = error or result = warning' }
 
   ].each do |item|
     next if Bookmark.where(:name => item[:name]).first
     next if audit_modified? Bookmark, item[:name]
-    b = Bookmark.create({:controller => "foreman_tasks_tasks", :public => true}.merge(item))
+    b = Bookmark.create({ :controller => 'foreman_tasks_tasks', :public => true }.merge(item))
     raise "Unable to create bookmark: #{format_errors b}" if b.nil? || b.errors.any?
   end
 end

data/deploy/foreman-tasks.sysconfig

@@ -6,3 +6,9 @@ FOREMAN_LOGGING=warn
 FOREMAN_LOGGING_SQL=warn
 FOREMAN_TASK_PARAMS="-p foreman"
 FOREMAN_LOG_DIR=/var/log/foreman
+
+RUBY_GC_MALLOC_LIMIT=4000100
+RUBY_GC_MALLOC_LIMIT_MAX=16000100
+RUBY_GC_MALLOC_LIMIT_GROWTH_FACTOR=1.1
+RUBY_GC_OLDMALLOC_LIMIT=16000100
+RUBY_GC_OLDMALLOC_LIMIT_MAX=16000100

data/extra/dynflow-debug.sh

@@ -3,5 +3,17 @@
 # This file provides additional debug information for foreman-debug tool and is
 # symlinked as /usr/share/foreman/script/foreman-debug.d/60-dynflow_debug
 
+export_csv() {
+  echo "COPY ($1) TO STDOUT WITH CSV;" | su - postgres -c '/usr/bin/psql -d foreman' > $2
+}
+
 add_files /var/log/foreman/dynflow_executor*.log*
 add_files /var/log/foreman/dynflow_executor*.output*
+
+# Foreman Tasks fast export (for HTML version use foreman-rake foreman_tasks:export_tasks)
+export_csv "select dynflow_execution_plans.* from foreman_tasks_tasks join dynflow_execution_plans on (foreman_tasks_tasks.external_id = dynflow_execution_plans.uuid) where foreman_tasks_tasks.started_at > 'now'::timestamp - '${DYNFLOW_EXPORT_MONTHS:-6} months'::interval" "$DIR/dynflow_execution_plans.csv"
+export_csv "select dynflow_actions.* from foreman_tasks_tasks join dynflow_actions on (foreman_tasks_tasks.external_id = dynflow_actions.execution_plan_uuid) where foreman_tasks_tasks.started_at > 'now'::timestamp - '${DYNFLOW_EXPORT_MONTHS:-6} months'::interval" "$DIR/dynflow_actions.csv"
+export_csv "select dynflow_steps.* from foreman_tasks_tasks join dynflow_steps on (foreman_tasks_tasks.external_id = dynflow_steps.execution_plan_uuid) where foreman_tasks_tasks.started_at > 'now'::timestamp - '${DYNFLOW_EXPORT_MONTHS:-6} months'::interval" "$DIR/dynflow_steps.csv"
+export_csv "select * from dynflow_schema_info" "$DIR/dynflow_schema_info.csv"
+export_csv "select * from foreman_tasks_tasks" "$DIR/foreman_tasks_tasks.csv"
+

data/foreman-tasks.gemspec

@@ -29,7 +29,7 @@ DESC
   s.extra_rdoc_files = Dir['README*', 'LICENSE']
 
   s.add_dependency "foreman-tasks-core"
-  s.add_dependency "dynflow", '~> 0.8.17'
+  s.add_dependency "dynflow", '~> 0.8.22'
   s.add_dependency "sequel" # for Dynflow process persistence
   s.add_dependency "sinatra" # for Dynflow web console
   s.add_dependency "daemons" # for running remote executor