foreman_remote_execution 0.1.2 → 0.2.1

data/app/models/concerns/foreman_remote_execution/errors_flattener.rb

@@ -1,7 +1,7 @@
 module ForemanRemoteExecution
   module ErrorsFlattener
     def flattened_validation_exception
-      ActiveRecord::RecordNotSaved.new(I18n.t("activerecord.errors.messages.record_invalid", :errors => flattened_errors.join(', ')))
+      ActiveRecord::RecordNotSaved.new(I18n.t('activerecord.errors.messages.record_invalid', :errors => flattened_errors.join(', ')))
     end
 
     def flattened_errors
@@ -25,7 +25,7 @@ module ForemanRemoteExecution
     def invalid_objects_for_attribute(attribute)
       if self.respond_to?(attribute)
         invalid_object = self.public_send(attribute)
-        if invalid_object.is_a? Enumerable
+        if invalid_object.respond_to? :each_with_index
           invalid_object.select { |o| o.respond_to?(:invalid?) && o.invalid? }
         else
           [invalid_object]

data/app/models/concerns/foreman_remote_execution/host_extensions.rb

@@ -9,7 +9,7 @@ module ForemanRemoteExecution
       alias_method_chain :params, :remote_execution
 
       has_many :targeting_hosts, :dependent => :destroy, :foreign_key => 'host_id'
-
+      has_many :template_invocations, :dependent => :destroy, :foreign_key => 'host_id'
       has_one :execution_status_object, :class_name => 'HostStatus::ExecutionStatus', :foreign_key => 'host_id'
 
       scoped_search :in => :execution_status_object, :on => :status, :rename => :'execution_status',
@@ -57,7 +57,7 @@ module ForemanRemoteExecution
     end
 
     def remote_execution_ssh_keys
-      remote_execution_proxies('Ssh').values.flatten.uniq.map { |proxy| proxy.pubkey }.compact.uniq
+      remote_execution_proxies('SSH').values.flatten.uniq.map { |proxy| proxy.pubkey }.compact.uniq
     end
 
     def drop_execution_interface_cache

data/app/models/concerns/foreman_remote_execution/smart_proxy_extensions.rb

@@ -11,7 +11,7 @@ module ForemanRemoteExecution
     end
 
     def update_pubkey
-      return unless has_feature?('Ssh')
+      return unless has_feature?('SSH')
       key = ::ProxyAPI::RemoteExecutionSSH.new(:url => url).pubkey
       self.update_attribute(:pubkey, key) if key
       key

data/app/models/concerns/foreman_remote_execution/template_extensions.rb

@@ -3,8 +3,16 @@ module ForemanRemoteExecution
     extend ActiveSupport::Concern
 
     included do
+      # autosave => true is required so the changes of inputs are saved even if template was not changed
+      has_many :template_inputs, :dependent => :destroy, :foreign_key => 'template_id', :autosave => true
+      has_many :foreign_input_sets, :dependent => :destroy, :foreign_key => 'template_id', :autosave => true
+
+      def template_inputs_with_foreign(templates_stack = [])
+        self.template_inputs.to_a + foreign_input_sets.map { |set| set.inputs(templates_stack) }.flatten
+      end
       accepts_nested_attributes_for :template_inputs, :allow_destroy => true
-      attr_accessible :template_inputs_attributes
+      accepts_nested_attributes_for :foreign_input_sets, :allow_destroy => true
+      attr_accessible :template_inputs_attributes, :foreign_input_sets_attributes
     end
 
     # create or overwrite instance methods...

data/app/models/foreign_input_set.rb

@@ -0,0 +1,49 @@
+class ForeignInputSet < ActiveRecord::Base
+  class CircularDependencyError < Foreman::Exception
+  end
+
+  attr_accessible :template_id, :target_template_id, :include_all, :include, :exclude
+
+  belongs_to :template
+  belongs_to :target_template, :class_name => 'Template'
+
+  scoped_search :on => :target_template_id, :complete_value => true
+
+  validates :target_template, :presence => true
+  validate :check_circular_dependency
+
+  def inputs(templates_stack = [])
+    return [] unless target_template
+    if templates_stack.include?(target_template)
+      raise CircularDependencyError.new(N_("Circular dependency detected in foreign input set '%{template}' -> '%{target_template}'. Templates stack: %{templates_stack}"),
+                                        :template => template.name, :target_template => target_template.name, :templates_stack => templates_stack.map(&:name).inspect)
+    end
+    inputs = target_template.template_inputs_with_foreign(templates_stack + [target_template])
+    unless self.include_all?
+      inputs = inputs.select { |input| included_names.include?(input.name) }
+    end
+    inputs = inputs.reject { |input| excluded_names.include?(input.name) }
+    return inputs
+  end
+
+  def included_names
+    comma_separated_names(self.include)
+  end
+
+  def excluded_names
+    comma_separated_names(self.exclude)
+  end
+
+  private
+
+  def comma_separated_names(value)
+    value.to_s.split(',').map(&:strip)
+  end
+
+  def check_circular_dependency
+    self.inputs
+    true
+  rescue CircularDependencyError => e
+    self.errors.add :base, e.message
+  end
+end

data/app/models/host_status/execution_status.rb

@@ -1,17 +1,21 @@
 class HostStatus::ExecutionStatus < HostStatus::Status
+  # execution finished successfully
   OK = 0
+  # execution finished with error
   ERROR = 1
+  # execution hasn't started yet, either scheduled to future or executor didn't create task yet
+  QUEUED = 2
+  # execution is in progress, dynflow task was created
+  RUNNING = 3
+  # mapping to string representation
+  STATUS_NAMES = { OK => 'succeeded', ERROR => 'failed', QUEUED => 'queued', RUNNING => 'running' }
 
   def relevant?
     execution_tasks.present?
   end
 
   def to_status(options = {})
-    if last_stopped_task.nil? || last_stopped_task.result == 'success'
-      OK
-    else
-      ERROR
-    end
+    ExecutionTaskStatusMapper.new(last_stopped_task).status
   end
 
   def to_global(options = {})
@@ -37,6 +41,47 @@ class HostStatus::ExecutionStatus < HostStatus::Status
     end
   end
 
+  class ExecutionTaskStatusMapper
+    attr_accessor :task
+
+    def self.sql_conditions_for(status)
+      status = STATUS_NAMES.key(status) if status.is_a?(String)
+
+      case status
+        when OK
+          [ "state = 'stopped' AND result = 'success'" ]
+        when ERROR
+          [ "state = 'stopped' AND (result = 'error' OR result = 'warning')" ]
+        when QUEUED
+          [ "state = 'scheduled' OR state IS NULL" ]
+        when RUNNING
+          [ "state <> 'stopped'" ]
+        else
+          [ '1 = 0' ]
+      end
+    end
+
+    def initialize(task)
+      self.task = task
+    end
+
+    def status
+      if task.nil? || task.state == 'scheduled'
+        QUEUED
+      elsif task.state == 'stopped' && 'success' == task.result
+        OK
+      elsif task.pending?
+        RUNNING
+      else
+        ERROR
+      end
+    end
+
+    def status_label
+      STATUS_NAMES[status]
+    end
+  end
+
   private
 
   def last_stopped_task

data/app/models/input_template_renderer.rb

@@ -4,19 +4,25 @@ class InputTemplateRenderer
 
   include UnattendedHelper
 
-  attr_accessor :template, :host, :invocation, :error_message
+  attr_accessor :template, :host, :invocation, :input_values, :error_message
 
   # takes template object that should be rendered
   # host and template invocation arguments are optional
   # so we can render values based on parameters, facts or user inputs
-  def initialize(template, host = nil, invocation = nil)
+  def initialize(template, host = nil, invocation = nil, input_values = nil, preview = false, templates_stack = [])
+    raise Foreman::Exception, N_('Recursive rendering of templates detected') if templates_stack.include?(template)
+
     @host = host
     @invocation = invocation
     @template = template
+    @input_values = input_values
+    @preview = preview
+    @templates_stack = templates_stack + [template]
   end
 
   def render
-    render_safe(@template.template, ::Foreman::Renderer::ALLOWED_HELPERS + [ :input ], :host => @host)
+    @template.validate_unique_inputs!
+    render_safe(@template.template, ::Foreman::Renderer::ALLOWED_HELPERS + [ :input, :render_template ], :host => @host)
   rescue => e
     self.error_message ||= _('error during rendering: %s') % e.message
     Rails.logger.debug e.to_s + "\n" + e.backtrace.join("\n")
@@ -24,14 +30,16 @@ class InputTemplateRenderer
   end
 
   def preview
+    old_preview = @preview
     @preview = true
-    output = render
-    @preview = false
-    output
+    render
+  ensure
+    @preview = old_preview
   end
 
   def input(name)
-    input = @template.template_inputs.where(:name => name.to_s).first || @template.template_inputs.detect { |i| i.name == name.to_s }
+    return @input_values[name.to_s] if @input_values
+    input = find_by_name(@template.template_inputs_with_foreign, name)
     if input
       @preview ? input.preview(self) : input.value(self)
     else
@@ -40,7 +48,44 @@ class InputTemplateRenderer
     end
   end
 
+  def render_template(template_name, input_values = {}, options = {})
+    options.assert_valid_keys(:with_foreign_input_set)
+    with_foreign_input_set = options.fetch(:with_foreign_input_set, true)
+    template = JobTemplate.authorized(:view_job_templates).where(:name => template_name).first
+    unless template
+      self.error_message = _('included template \'%s\' not found') % template_name
+      raise error_message
+    end
+    if with_foreign_input_set
+      input_values = foreign_input_set_values(template, input_values)
+    end
+    included_renderer = self.class.new(template, host, invocation, input_values.with_indifferent_access, @preview, @templates_stack)
+    out = included_renderer.render
+    if included_renderer.error_message
+      self.error_message = included_renderer.error_message
+      raise error_message
+    else
+      out
+    end
+  end
+
+  def foreign_input_set_values(target_template, overrides = {})
+    input_set = @template.foreign_input_sets.where(:target_template_id => target_template).first
+    return overrides if input_set.nil?
+
+    inputs_to_generate = input_set.inputs.map(&:name) - overrides.keys.map(&:to_s)
+    included_renderer = self.class.new(input_set.target_template, host, invocation, nil, @preview, @templates_stack)
+    input_values = inputs_to_generate.inject(HashWithIndifferentAccess.new) do |hash, input_name|
+      hash.merge(input_name => included_renderer.input(input_name))
+    end
+    input_values.merge(overrides)
+  end
+
   def logger
     Rails.logger
   end
+
+  def find_by_name(collection, name)
+    collection.detect { |i| i.name == name.to_s }
+  end
 end

data/app/models/job_invocation.rb

@@ -2,20 +2,28 @@ class JobInvocation < ActiveRecord::Base
   include Authorizable
 
   include ForemanRemoteExecution::ErrorsFlattener
-  FLATTENED_ERRORS_MAPPING = { :template_invocations => lambda do |template_invocation|
-                                                          _("template") + " #{template_invocation.template.name}"
-                                                        end }
+  FLATTENED_ERRORS_MAPPING = {
+    :pattern_template_invocations => lambda do |template_invocation|
+      _('template') + " #{template_invocation.template.name}"
+    end
+  }
 
   belongs_to :targeting, :dependent => :destroy
-  has_many :template_invocations, :inverse_of => :job_invocation, :dependent => :destroy
+  has_many :all_template_invocations, :inverse_of => :job_invocation, :dependent => :destroy, :class_name => 'TemplateInvocation'
+  if Rails::VERSION::MAJOR >= 4
+    has_many :template_invocations, -> { where('host_id IS NOT NULL') }, :inverse_of => :job_invocation
+    has_many :pattern_template_invocations, -> { where('host_id IS NULL') }, :inverse_of => :job_invocation, :class_name => 'TemplateInvocation'
+  else
+    has_many :template_invocations, :conditions => 'host_id IS NOT NULL', :inverse_of => :job_invocation
+    has_many :pattern_template_invocations, :conditions => 'host_id IS NULL', :inverse_of => :job_invocation, :class_name => 'TemplateInvocation'
+  end
 
   validates :targeting, :presence => true
-  validates :job_name, :presence => true
-  validates_associated :targeting, :template_invocations
+  validates :job_category, :presence => true
+  validates_associated :targeting, :all_template_invocations
 
-  scoped_search :on => :job_name
-
-  scoped_search :in => :recurring_logic, :on => 'id', :rename => 'recurring_logic.id', :auto_complete => true
+  scoped_search :on => :job_category, :complete_value => true
+  scoped_search :on => :description # FIXME No auto complete because of https://github.com/wvanbergen/scoped_search/issues/138
 
   delegate :bookmark, :resolved?, :to => :targeting, :allow_nil => true
 
@@ -27,55 +35,96 @@ class JobInvocation < ActiveRecord::Base
   belongs_to :task_group, :class_name => 'JobInvocationTaskGroup'
 
   has_many :tasks, :through => :task_group, :class_name => 'ForemanTasks::Task'
-
-  scoped_search :on => [:job_name], :complete_value => true
+  has_many :template_invocation_tasks, :through => :template_invocations,
+                                       :class_name => 'ForemanTasks::Task',
+                                       :source => 'run_host_job_task'
 
   scoped_search :in => :task, :on => :started_at, :rename => 'started_at', :complete_value => true
+  scoped_search :in => :task, :on => :start_at, :rename => 'start_at', :complete_value => true
   scoped_search :in => :task, :on => :ended_at, :rename => 'ended_at', :complete_value => true
+  scoped_search :in => :task, :on => :state, :rename => 'status', :ext_method => :search_by_status,
+                :only_explicit => true, :complete_value => Hash[HostStatus::ExecutionStatus::STATUS_NAMES.values.map { |v| [v, v] }]
 
   belongs_to :triggering, :class_name => 'ForemanTasks::Triggering'
   has_one :recurring_logic, :through => :triggering, :class_name => 'ForemanTasks::RecurringLogic'
 
-  scope :with_task, -> { joins('LEFT JOIN foreman_tasks_tasks ON foreman_tasks_tasks.id = job_invocations.task_id') }
+  if Rails::VERSION::MAJOR >= 4
+    scope :with_task, -> { references(:task) }
+  else
+    scope :with_task, -> { joins('LEFT JOIN foreman_tasks_tasks ON foreman_tasks_tasks.id = job_invocations.task_id') }
+  end
+
+  scoped_search :in => :recurring_logic, :on => 'id', :rename => 'recurring_logic.id', :auto_complete => true
+
+  scoped_search :in => :recurring_logic, :on => 'id', :rename => 'recurring',
+                :ext_method => :search_by_recurring_logic, :only_explicit => true,
+                :complete_value => { :true => true, :false => false }
 
   default_scope -> { order('job_invocations.id DESC') }
 
+  validates_lengths_from_database :only => [:description]
+
   attr_accessor :start_before, :description_format
   attr_writer :start_at
 
+  delegate :start_at, :to => :task, :allow_nil => true
+
+  def self.search_by_status(key, operator, value)
+    conditions = HostStatus::ExecutionStatus::ExecutionTaskStatusMapper.sql_conditions_for(value)
+    conditions[0] = "NOT (#{conditions[0]})" if operator == '<>'
+    { :conditions => sanitize_sql_for_conditions(conditions), :include => :task }
+  end
+
+  def self.search_by_recurring_logic(key, operator, value)
+    reucurring = value == 'true'
+    reucurring = !reucurring if operator == '<>'
+    not_operator = reucurring ? 'NOT' : ''
+
+    { :conditions => sanitize_sql_for_conditions(["foreman_tasks_recurring_logics.id IS #{not_operator} NULL"]), :joins => :recurring_logic }
+  end
+
+  def status
+    HostStatus::ExecutionStatus::ExecutionTaskStatusMapper.new(task).status
+  end
+
+  def status_label
+    HostStatus::ExecutionStatus::ExecutionTaskStatusMapper.new(task).status_label
+  end
+
+  # returns progress in percents
+  def progress
+    queued? ? 0 : (task.progress * 100).to_i
+  end
+
+  def queued?
+    status == HostStatus::ExecutionStatus::QUEUED
+  end
+
   def deep_clone
     JobInvocationComposer.from_job_invocation(self).job_invocation.tap do |invocation|
       invocation.task_group = JobInvocationTaskGroup.new.tap(&:save!)
       invocation.triggering = self.triggering
       invocation.description_format = self.description_format
       invocation.description = self.description
-      invocation.template_invocations = self.template_invocations.map(&:deep_clone)
+      invocation.pattern_template_invocations = self.pattern_template_invocations.map(&:deep_clone)
       invocation.save!
     end
   end
 
   def to_action_input
-    { :id => id, :name => job_name }
-  end
-
-  def template_invocation_tasks
-    sub_tasks.for_action_types('Actions::RemoteExecution::RunHostJob')
+    { :id => id, :name => job_category }
   end
 
   def failed_template_invocation_tasks
-    template_invocation_tasks.where(:result => 'warning')
+    template_invocation_tasks.where(:result => [ 'error', 'warning' ])
   end
 
   def failed_host_ids
-    locks_for_resource(failed_template_invocation_tasks, 'Host::Managed').map(&:resource_id)
+    failed_template_invocations.map(&:host_id)
   end
 
   def failed_hosts
-    locks_for_resource(failed_template_invocation_tasks, 'Host::Managed').map(&:resource)
-  end
-
-  def locks_for_resource(tasks, resource_type)
-    tasks.map { |task| task.locks.where(:resource_type => resource_type).first }.compact
+    failed_template_invocations.includes(:host).map(&:host)
   end
 
   def total_hosts_count
@@ -86,10 +135,10 @@ class JobInvocation < ActiveRecord::Base
     end
   end
 
-  def template_invocation_for_host(host)
+  def pattern_template_invocation_for_host(host)
     providers = available_providers(host)
     providers.each do |provider|
-      template_invocations.each do |template_invocation|
+      pattern_template_invocations.each do |template_invocation|
         if template_invocation.template.provider_type == provider
           return template_invocation
         end
@@ -103,7 +152,7 @@ class JobInvocation < ActiveRecord::Base
   end
 
   def sub_task_for_host(host)
-    sub_tasks.joins(:locks).where("#{ForemanTasks::Lock.table_name}.resource_type" => 'Host::Managed', "#{ForemanTasks::Lock.table_name}.resource_id" => host.id).first
+    template_invocations.where(:host => host.id).first.try(:run_host_job_task)
   end
 
   def output(host)
@@ -113,16 +162,24 @@ class JobInvocation < ActiveRecord::Base
 
   def generate_description!
     key_re = /%\{([^\}]+)\}/
-    template_invocation = template_invocations.first
-    input_names = template_invocation.template.template_input_names
+    template_invocation = pattern_template_invocations.first
+    input_names = template_invocation.template.template_inputs_with_foreign(&:name)
     hash_base = Hash.new { |hash, key| hash[key] = "%{#{key}}" }
     input_hash = hash_base.merge Hash[input_names.zip(template_invocation.input_values.pluck(:value))]
-    input_hash.update(:job_name => job_name)
+    input_hash.update(:job_category => job_category)
+    input_hash.update(:template_name => template_invocation.template.name)
     description_format.scan(key_re) { |key| input_hash[key.first] }
     self.description = description_format
     input_hash.each do |k, v|
-      self.description.gsub!(Regexp.new("%\{#{k}\}"), v)
+      self.description.gsub!(Regexp.new("%\{#{k}\}"), v || '')
     end
+    self.description = self.description[0..(JobInvocation.columns_hash['description'].limit - 1)]
     save!
   end
+
+  private
+
+  def failed_template_invocations
+    template_invocations.joins(:run_host_job_task).where("#{ForemanTasks::Task.table_name}.result" => ['error', 'warning'])
+  end
 end