foreman-tasks 0.8.6 → 0.9.0

data/app/models/foreman_tasks/concerns/host_action_subject.rb

@@ -5,7 +5,7 @@ module ForemanTasks
       include ForemanTasks::Concerns::ActionSubject
 
       def action_input_key
-        "host"
+        'host'
       end
 
       def available_locks
@@ -16,15 +16,15 @@ module ForemanTasks
         # TODO: This should get into the Foreman core, extracting the
         # +importHostAndFacts+ method into two
         def import_host(hostname, certname, facts, proxy_id = nil)
-          raise(::Foreman::Exception.new("Invalid Facts, must be a Hash")) unless facts.is_a?(Hash)
-          raise(::Foreman::Exception.new("Invalid Hostname, must be a String")) unless hostname.is_a?(String)
+          raise Foreman::Exception, 'Invalid Facts, must be a Hash' unless facts.is_a?(Hash)
+          raise Foreman::Exception, 'Invalid Hostname, must be a String' unless hostname.is_a?(String)
 
           # downcase everything
           hostname.try(:downcase!)
           certname.try(:downcase!)
 
-          host = certname.present? ? Host.find_by_certname(certname) : nil
-          host ||= Host.find_by_name hostname
+          host = certname.present? ? Host.find_by(certname: certname) : nil
+          host ||= Host.find_by name: hostname
           host ||= Host.new(:name => hostname, :certname => certname) if Setting[:create_new_host_when_facts_are_uploaded]
 
           return Host.new if host.nil?

data/app/models/foreman_tasks/lock.rb

@@ -1,32 +1,31 @@
 module ForemanTasks
   class Lock < ActiveRecord::Base
-
     LINK_LOCK_NAME  = :link_resource
     OWNER_LOCK_NAME = :task_owner
 
-    # not really intedet to be created in database, but it's used for
+    # not really intended to be created in database, but it's used for
     # explicitly stating that the all the locks for resource should be used
     ALL_LOCK_NAME   = :all
 
-    RESERVED_LOCK_NAMES = [LINK_LOCK_NAME, OWNER_LOCK_NAME, ALL_LOCK_NAME]
+    RESERVED_LOCK_NAMES = [LINK_LOCK_NAME, OWNER_LOCK_NAME, ALL_LOCK_NAME].freeze
 
     class LockConflict < StandardError
       attr_reader :required_lock, :conflicting_locks
       def initialize(required_lock, conflicting_locks)
-        header = _("Required lock is already taken by other running tasks.")
+        header = _('Required lock is already taken by other running tasks.')
         header << "\n"
-        header << _("Please inspect their state, fix their errors and resume them.")
+        header << _('Please inspect their state, fix their errors and resume them.')
         header << "\n\n"
-        header << _("Required lock: %s") % required_lock.name
+        header << _('Required lock: %s') % required_lock.name
         header << "\n"
-        header << _("Conflicts with tasks:")
+        header << _('Conflicts with tasks:')
         header << "\n"
         url_helpers       = Rails.application.routes.url_helpers
-        conflicting_tasks = conflicting_locks.
-            map(&:task).
-            uniq.
-            map { |task| "- #{Setting['foreman_url'] + url_helpers.foreman_tasks_task_path(task)}" }.
-            join("\n")
+        conflicting_tasks = conflicting_locks
+                            .map(&:task)
+                            .uniq
+                            .map { |task| "- #{Setting['foreman_url'] + url_helpers.foreman_tasks_task_path(task)}" }
+                            .join("\n")
 
         super header + conflicting_tasks
         @required_lock     = required_lock
@@ -38,21 +37,17 @@ module ForemanTasks
 
     belongs_to :resource, polymorphic: true
 
-    scope :active, -> do
-      joins(:task).where('foreman_tasks_tasks.state != ?', :stopped)
-    end
+    scope :active, -> { joins(:task).where('foreman_tasks_tasks.state != ?', :stopped) }
 
     validates :task_id, :name, :resource_id, :resource_type, presence: true
 
     validate do
-      unless available?
-        raise LockConflict.new(self, colliding_locks)
-      end
+      raise LockConflict.new(self, colliding_locks) unless available?
     end
 
     # returns true if it's possible to aquire this kind of lock
     def available?
-      not colliding_locks.exists?
+      !colliding_locks.exists?
     end
 
     # returns a scope of the locks colliding with this one
@@ -62,14 +57,13 @@ module ForemanTasks
       colliding_locks_scope = colliding_locks_scope.where(name:          name,
                                                           resource_id:   resource_id,
                                                           resource_type: resource_type)
-      unless self.exclusive?
+      unless exclusive?
         colliding_locks_scope = colliding_locks_scope.where(:exclusive => true)
       end
-      return colliding_locks_scope
+      colliding_locks_scope
     end
 
     class << self
-
       # Locks the resource so that no other task can lock it while running.
       # No other task related to the resource is not allowed (even not-locking ones)
       # A typical usecase is resource deletion, where it's good idea to make sure
@@ -82,7 +76,6 @@ module ForemanTasks
         build_exclusive_locks(resource).all?(&:available?)
       end
 
-
       # Locks the resource so that no other task can lock it while running.
       # Other not-locking tasks are tolerated.
       #
@@ -103,12 +96,12 @@ module ForemanTasks
       end
 
       def locked?(resource, uuid, *lock_names)
-        not lockable?(resource, uuid, *lock_names)
+        !lockable?(resource, uuid, *lock_names)
       end
 
       def colliding_locks(resource, uuid, *lock_names)
-        build_locks(resource, lock_names, uuid).
-            inject([]) { |collisions, lock| collisions.concat lock.colliding_locks.to_a }
+        build_locks(resource, lock_names, uuid)
+          .inject([]) { |collisions, lock| collisions.concat lock.colliding_locks.to_a }
       end
 
       # Assigns the resource to the task to easily track the task in context of
@@ -136,7 +129,7 @@ module ForemanTasks
       def all_lock_names(resource, include_links = false)
         lock_names = []
         if resource.class.respond_to?(:available_locks) &&
-            resource.class.available_locks.any?
+           resource.class.available_locks.any?
           lock_names.concat(resource.class.available_locks)
         else
           raise "The resource #{resource.class.name} doesn't define any available lock"
@@ -145,7 +138,7 @@ module ForemanTasks
           raise "Lock name #{lock_name} is reserved"
         end
         lock_names.concat([LINK_LOCK_NAME, OWNER_LOCK_NAME]) if include_links
-        return lock_names
+        lock_names
       end
 
       def build_exclusive_locks(resource, uuid = nil)
@@ -161,7 +154,7 @@ module ForemanTasks
           locks << build(uuid, resource, lock_name, true)
         end
         locks.concat(build_links(resource, uuid))
-        return locks
+        locks
       end
 
       def build_links(resource, uuid = nil)
@@ -179,23 +172,22 @@ module ForemanTasks
       end
 
       def build(uuid, resource, lock_name, exclusive)
-        self.new(task_id:       uuid,
-                 name:          lock_name,
-                 resource_type: resource.class.name,
-                 resource_id:   resource.id,
-                 exclusive:     !!exclusive)
+        new(task_id:       uuid,
+            name:          lock_name,
+            resource_type: resource.class.name,
+            resource_id:   resource.id,
+            exclusive:     !!exclusive)
       end
 
       # recursively search for related resources of the resource (using
       # the +related_resources+ method, avoiding the cycles
       def related_resources(resource)
         if resource.respond_to?(:all_related_resources)
-          return resource.all_related_resources
+          resource.all_related_resources
         else
-          return []
+          []
         end
       end
     end
-
   end
 end

data/app/models/foreman_tasks/recurring_logic.rb

@@ -1,5 +1,4 @@
 module ForemanTasks
-
   require 'parse-cron'
 
   class RecurringLogic < ActiveRecord::Base
@@ -15,13 +14,13 @@ module ForemanTasks
       has_many :task_groups, -> { uniq }, :through => :tasks
     end
 
-    scoped_search :on => :id, :complete_value => false
+    scoped_search :on => :id, :complete_value => false, :validator => ScopedSearch::Validators::INTEGER
     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
+      task_group.save
     end
 
     def self.allowed_states
@@ -35,16 +34,16 @@ module ForemanTasks
     end
 
     def trigger_repeat(action_class, *args)
-      unless can_continue?
-        self.state = 'finished'
-        save!
-        return
-      else
+      if can_continue?
         self.iteration += 1
         save!
         ::ForemanTasks.delay action_class,
                              generate_delay_options,
                              *args
+      else
+        self.state = 'finished'
+        save!
+        nil
       end
     end
 
@@ -54,21 +53,21 @@ module ForemanTasks
       tasks.active.each(&:cancel)
     end
 
-    def next_occurrence_time(time = Time.now)
-      @parser ||= CronParser.new(cron_line)
+    def next_occurrence_time(time = Time.zone.now)
+      @parser ||= CronParser.new(cron_line, Time.zone)
       @parser.next(time)
     end
 
-    def generate_delay_options(time = Time.now, options = {})
+    def generate_delay_options(time = Time.zone.now, options = {})
       {
         :start_at => next_occurrence_time(time),
         :start_before => options['start_before'],
-        :recurring_logic_id => self.id
+        :recurring_logic_id => id
       }
     end
 
     def valid?(*_)
-      cron_line.present? && valid_cronline? && !self.state.nil? || can_start?
+      cron_line.present? && valid_cronline? && !state.nil? || can_start?
     end
 
     def valid_cronline?
@@ -77,21 +76,21 @@ module ForemanTasks
       false
     end
 
-    def can_start?(time = Time.now)
+    def can_start?(time = Time.zone.now)
       (end_time.nil? || next_occurrence_time(time) < end_time) &&
         (max_iteration.nil? || iteration < max_iteration)
     end
 
-    def can_continue?(time = Time.now)
-      self.state == 'active' && can_start?(time)
+    def can_continue?(time = Time.zone.now)
+      state == 'active' && can_start?(time)
     end
 
     def finished?
-      self.state == 'finished'
+      state == 'finished'
     end
 
     def humanized_state
-      case self.state
+      case state
       when 'active'
         N_('Active')
       when 'cancelled'
@@ -104,13 +103,13 @@ module ForemanTasks
     end
 
     def self.assemble_cronline(hash)
-      hash.values_at(*[:minutes, :hours, :days, :months, :days_of_week])
-          .map { |value| (value.nil? || value.blank?) ? '*' : value }
+      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|
+      new.tap do |logic|
         logic.cron_line = cronline
         logic.task_group = ::ForemanTasks::TaskGroups::RecurringLogicTaskGroup.new
       end
@@ -120,7 +119,7 @@ module ForemanTasks
       cronline = if triggering.input_type == :cronline
                    triggering.cronline
                  else
-                   ::ForemanTasks::RecurringLogic.assemble_cronline(cronline_hash triggering.input_type, triggering.time, triggering.days_of_week)
+                   ::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 = triggering.end_time unless triggering.end_time_limited.blank?
@@ -132,8 +131,8 @@ module ForemanTasks
     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 { |key, value| value == "1" }
-                                  .keys.join(',')
+        .select { |_key, value| value == '1' }
+        .keys.join(',')
       allowed_keys = case recurring_type
                      when :monthly
                        [:minutes, :hours, :days]

data/app/models/foreman_tasks/task.rb

@@ -4,7 +4,7 @@ module ForemanTasks
   class Task < ActiveRecord::Base
     include Authorizable
 
-    # TODO missing validation of states
+    # TODO: missing validation of states
 
     self.primary_key = :id
     before_create :generate_id
@@ -18,17 +18,16 @@ module ForemanTasks
     if Rails::VERSION::MAJOR < 4
       has_many :recurring_logic_task_groups, :through => :task_group_members, :conditions => { :type => 'ForemanTasks::TaskGroups::RecurringLogicTaskGroup' }, :source => :task_group
       has_many :owners, :through => :locks, :source => :resource, :source_type => 'User',
-               :conditions => ["foreman_tasks_locks.name = ?", Lock::OWNER_LOCK_NAME]
+                        :conditions => ['foreman_tasks_locks.name = ?', Lock::OWNER_LOCK_NAME]
     else
       has_many :recurring_logic_task_groups, -> { where :type => 'ForemanTasks::TaskGroups::RecurringLogicTaskGroup' },
                :through => :task_group_members, :source => :task_group
       # in fact, the task has only one owner but Rails don't let you to
       # specify has_one relation though has_many relation
-      has_many :owners, lambda {where(["foreman_tasks_locks.name = ?", Lock::OWNER_LOCK_NAME])},
+      has_many :owners, -> { where(['foreman_tasks_locks.name = ?', Lock::OWNER_LOCK_NAME]) },
                :through => :locks, :source => :resource, :source_type => 'User'
     end
 
-
     scoped_search :on => :id, :complete_value => false
     scoped_search :on => :label, :complete_value => true
     scoped_search :on => :state, :complete_value => true
@@ -37,21 +36,26 @@ module ForemanTasks
     scoped_search :on => :start_at, :complete_value => false
     scoped_search :on => :ended_at, :complete_value => false
     scoped_search :on => :parent_task_id, :complete_value => true
-    scoped_search :in => :locks,  :on => :resource_type, :complete_value => true, :rename => "resource_type", :ext_method => :search_by_generic_resource
-    scoped_search :in => :locks,  :on => :resource_id, :complete_value => false, :rename => "resource_id", :ext_method => :search_by_generic_resource
-    scoped_search :in => :owners,  :on => :id, :complete_value => true, :rename => "owner.id", :ext_method => :search_by_owner
-    scoped_search :in => :owners,  :on => :login, :complete_value => true, :rename => "owner.login", :ext_method => :search_by_owner
-    scoped_search :in => :owners,  :on => :firstname, :complete_value => true, :rename => "owner.firstname", :ext_method => :search_by_owner
-    scoped_search :in => :task_groups, :on => :id, :complete_value => true, :rename => "task_group.id"
+    scoped_search :relation => :locks,  :on => :resource_type, :complete_value => true, :rename => 'resource_type', :ext_method => :search_by_generic_resource
+    scoped_search :relation => :locks,  :on => :resource_id, :complete_value => false, :rename => 'resource_id', :ext_method => :search_by_generic_resource
+    scoped_search :relation => :owners,  
+                  :on => :id, 
+                  :complete_value => true, 
+                  :rename => 'owner.id', 
+                  :ext_method => :search_by_owner,
+                  :validator => ->(value) { ScopedSearch::Validators::INTEGER.call(value) || value == 'current_user' }
+    scoped_search :relation => :owners,  :on => :login, :complete_value => true, :rename => 'owner.login', :ext_method => :search_by_owner
+    scoped_search :relation => :owners,  :on => :firstname, :complete_value => true, :rename => 'owner.firstname', :ext_method => :search_by_owner
+    scoped_search :relation => :task_groups, :on => :id, :complete_value => true, :rename => 'task_group.id', :validator => ScopedSearch::Validators::INTEGER
 
     scope :active, -> {  where('foreman_tasks_tasks.state != ?', :stopped) }
-    scope :running, -> {  where("foreman_tasks_tasks.state NOT IN ('stopped', 'paused')") }
+    scope :running, -> { where("foreman_tasks_tasks.state NOT IN ('stopped', 'paused')") }
     scope :for_resource,
-        (lambda do |resource|
-           joins(:locks).where(:"foreman_tasks_locks.resource_id" => resource.id,
-                               :"foreman_tasks_locks.resource_type" => resource.class.name)
-         end)
-    scope :for_action_types, (lambda { |action_types| where('foreman_tasks_tasks.label IN (?)', Array(action_types)) })
+          (lambda do |resource|
+             joins(:locks).where(:"foreman_tasks_locks.resource_id" => resource.id,
+                                 :"foreman_tasks_locks.resource_type" => resource.class.name)
+           end)
+    scope :for_action_types, (->(action_types) { where('foreman_tasks_tasks.label IN (?)', Array(action_types)) })
 
     def input
       {}
@@ -62,61 +66,67 @@ module ForemanTasks
     end
 
     def owner
-      self.owners.first
+      owners.first
     end
 
     def username
-      self.owner.try(:login)
+      owner.try(:login)
     end
 
     def execution_type
-      self.start_at.to_i == self.started_at.to_i ? N_('Immediate') : N_('Delayed')
+      delayed? ? N_('Delayed') : N_('Immediate')
     end
 
     def humanized
       { action: label,
-        input:  "",
-        output: "" }
+        input:  '',
+        output: '' }
     end
 
     def cli_example
-      ""
+      ''
     end
 
     # returns true if the task is running or waiting to be run
     def pending?
-      self.state != 'stopped'
+      state != 'stopped'
     end
-    alias_method :pending, :pending?
+    alias pending pending?
 
     def resumable?
       false
     end
 
     def paused?
-      self.state == 'paused'
+      state == 'paused'
+    end
+
+    def recurring?
+      !recurring_logic_task_group_ids.empty?
+    end
+
+    def delayed?
+      start_at.to_i != started_at.to_i
     end
 
     def self_and_parents
       [self].tap do |ret|
-        if parent_task
-          ret.concat(parent_task.self_and_parents)
-        end
+        ret.concat(parent_task.self_and_parents) if parent_task
       end
     end
 
     def self.search_by_generic_resource(key, operator, value)
-      key =  "resource_type" if key.blank?
-      key_name = self.connection.quote_column_name(key.sub(/^.*\./,''))
+      key = 'resource_type' if key.blank?
+      key_name = connection.quote_column_name(key.sub(/^.*\./, ''))
       condition = sanitize_sql_for_conditions(["foreman_tasks_locks.#{key_name} #{operator} ?", value])
 
-      return {:conditions => condition, :joins => :locks }
+      { :conditions => condition, :joins => :locks }
     end
 
     def self.search_by_owner(key, operator, value)
       return { :conditions => '0 = 1' } if value == 'current_user' && User.current.nil?
 
-      key_name = self.connection.quote_column_name(key.sub(/^.*\./,''))
+      key_name = connection.quote_column_name(key.sub(/^.*\./, ''))
       joins = <<-SQL
       INNER JOIN foreman_tasks_locks AS foreman_tasks_locks_owner
                  ON (foreman_tasks_locks_owner.task_id = foreman_tasks_tasks.id AND
@@ -132,21 +142,19 @@ module ForemanTasks
       condition = if key.blank?
                     sanitize_sql_for_conditions(["users.login #{operator} ? or users.firstname #{operator} ? ", value, value])
                   elsif key =~ /\.id\Z/
-                    if value == 'current_user'
-                      value = User.current.id
-                    end
+                    value = User.current.id if value == 'current_user'
                     sanitize_sql_for_conditions(["foreman_tasks_locks_owner.resource_id #{operator} ?", value])
                   else
                     sanitize_sql_for_conditions(["users.#{key_name} #{operator} ?", value])
                   end
-      return {:conditions => condition, :joins => joins }
+      { :conditions => condition, :joins => joins }
     end
 
     def progress
-      case self.state.to_s
-      when "running", "paused"
+      case state.to_s
+      when 'running', 'paused'
         0.5
-      when "stopped"
+      when 'stopped'
         1
       else
         0
@@ -163,6 +171,24 @@ module ForemanTasks
       (groups - task_groups).each { |group| task_groups << group }
     end
 
+    def sub_tasks_counts
+      result = %w(cancelled error pending success warning).zip([0].cycle).to_h
+      result.update sub_tasks.group(:result).count
+      sum = result.values.reduce(:+)
+      if respond_to?(:main_action) && main_action.respond_to?(:total_count)
+        result[:total] = main_action.total_count
+        # In case of batch planning there might be some plans still unplanned (not present in database).
+        # To get correct counts we need to add them to either:
+        #   cancelled when the parent is stopped
+        #   pending when the parent is still running.
+        key = state == 'stopped' ? 'cancelled' : 'pending'
+        result[key] += result[:total] - sum
+      else
+        result[:total] = sum
+      end
+      result.symbolize_keys
+    end
+
     protected
 
     def generate_id