foreman_remote_execution 0.1.2 → 0.2.1

data/app/controllers/job_invocations_controller.rb

@@ -4,14 +4,24 @@ class JobInvocationsController < ApplicationController
   before_filter :find_or_create_triggering, :only => [:create, :refresh]
 
   def new
-    @composer = JobInvocationComposer.from_ui_params(
+    ui_params = {
       :host_ids => params[:host_ids],
-      :job_invocation => {
-      },
       :targeting => {
         :targeting_type => Targeting::STATIC_TYPE,
         :bookmark_id => params[:bookmark_id]
-      })
+      }
+    }
+
+    if (template = JobTemplate.find_by_id(params[:template_id]))
+      ui_params[:job_invocation] = {
+        :job_category => template.job_category,
+        :providers => {
+          template.provider_type => {:job_template_id => template.id}
+        }
+      }
+    end
+
+    @composer = JobInvocationComposer.from_ui_params(ui_params)
   end
 
   def rerun
@@ -34,23 +44,25 @@ class JobInvocationsController < ApplicationController
       @composer.triggering.trigger(::Actions::RemoteExecution::RunHostsJob, job_invocation)
       redirect_to job_invocation_path(job_invocation)
     else
+      @composer.job_invocation.description_format = nil if params[:job_invocation].key?(:description_override)
       render :action => 'new'
     end
   end
 
   def show
-    @job_invocation = resource_base.find(params[:id])
+    @job_invocation = resource_base.includes(:template_invocations => :run_host_job_task).find(params[:id])
     @auto_refresh = @job_invocation.task.try(:pending?)
     hosts_base = @job_invocation.targeting.hosts.authorized(:view_hosts, Host)
     @hosts = hosts_base.search_for(params[:search], :order => params[:order] || 'name ASC').paginate(:page => params[:page])
   end
 
   def index
-    @job_invocations = resource_base.search_for(params[:search]).paginate(:page => params[:page]).with_task.order(params[:order] || 'job_invocations.id DESC')
+    @job_invocations = resource_base.search_for(params[:search], :order => params[:order]).paginate(:page => params[:page]).with_task.order('job_invocations.id DESC')
   end
 
   # refreshes the form
   def refresh
+    params[:job_invocation].delete :description_format if params[:job_invocation].key?(:description_override)
     @composer = JobInvocationComposer.from_ui_params(params)
   end
 

data/app/controllers/job_templates_controller.rb

@@ -6,11 +6,13 @@ class JobTemplatesController < ::TemplatesController
     @organizations    = @template.organizations
   end
 
-  def auto_complete_job_name
-    @job_names = resource_base.where(['job_name LIKE ?', "%#{params[:search]}%"]).pluck(:job_name).uniq
+  def auto_complete_job_category
+    @job_categories = resource_base.where(['job_category LIKE ?', "%#{params[:search]}%"]).pluck(:job_category).uniq
+    render :json => @job_categories.map { |name| { 'completed' => '', 'part' => name, 'label' => name, 'category' => '' } }.to_json
   end
 
   def preview
+    find_resource unless @template.present?
     base = Host.authorized(:view_hosts, Host)
     host = params[:preview_host_id].present? ? base.find(params[:preview_host_id]) : base.first
     @template.template = params[:template]
@@ -18,15 +20,23 @@ class JobTemplatesController < ::TemplatesController
     if (output = renderer.preview)
       render :text => output
     else
-      render :status => 406, :text => renderer.error_message
+      render :status => 406, :text => renderer.error_message + _(', note that you must save template input changes before you try to preview it.')
     end
   end
 
   private
 
+  def find_resource
+    if params[:id]
+      super
+    else
+      @template = resource_class.new(params[type_name_plural])
+    end
+  end
+
   def action_permission
     case params[:action]
-      when 'auto_complete_job_name'
+      when 'auto_complete_job_category'
         :view_job_templates
       else
         super

data/app/controllers/template_invocations_controller.rb

@@ -6,9 +6,11 @@ class TemplateInvocationsController < ApplicationController
   end
 
   def show
-    @template_invocation_task = ForemanTasks::Task.find(params[:id])
-    @template_invocation = @template_invocation_task.locks.where(:resource_type => 'TemplateInvocation').first.try(:resource)
-    @host = @template_invocation_task.locks.where(:resource_type => 'Host::Managed').first.try(:resource)
+    @template_invocation = TemplateInvocation.find(params[:id])
+    raise ActiveRecord::RecordNotFound unless User.current.can?(:view_job_invocations, @template_invocation.job_invocation)
+
+    @template_invocation_task = @template_invocation.run_host_job_task
+    @host = @template_invocation.host
     @auto_refresh = @template_invocation_task.pending?
     @since = params[:since].to_f if params[:since].present?
     @line_sets = @template_invocation_task.main_action.live_output

data/app/helpers/concerns/foreman_remote_execution/hosts_helper_extensions.rb

@@ -15,7 +15,7 @@ module ForemanRemoteExecution
     end
 
     def host_title_actions_with_run_button(*args)
-      title_actions(button_group(link_to(_("Run Job"), new_job_invocation_path(:host_ids => [args.first.id]), :id => :run_button)))
+      title_actions(button_group(link_to(_('Run Job'), new_job_invocation_path(:host_ids => [args.first.id]), :id => :run_button)))
       host_title_actions_without_run_button(*args)
     end
 

data/app/helpers/concerns/foreman_remote_execution/job_templates_extensions.rb

@@ -0,0 +1,19 @@
+module ForemanRemoteExecution
+  module JobTemplatesExtensions
+    extend ActiveSupport::Concern
+
+    included do
+      alias_method_chain :permitted_actions, :run_button
+    end
+
+    def permitted_actions_with_run_button(template)
+      original = permitted_actions_without_run_button(template)
+
+      if template.is_a?(JobTemplate) && !template.snippet
+        original.unshift(display_link_if_authorized(_('Run'), hash_for_new_job_invocation_path(:template_id => template.id)))
+      end
+
+      original
+    end
+  end
+end

data/app/helpers/remote_execution_helper.rb

@@ -30,15 +30,17 @@ module RemoteExecutionHelper
   end
 
   def job_invocation_status(invocation)
-    if invocation.task.blank?
-      _('Job not started yet 0%')
-    elsif invocation.task.state == 'scheduled'
-      _('Job set to execute at %s') % invocation.task.start_at
-    elsif invocation.task.state == 'stopped' && invocation.task.result == 'error'
-      invocation.task.execution_plan.errors.map(&:message).join("\n")
-    else
-      label = invocation.task.pending ? _('Running') : _('Finished')
-      label + ' ' + (invocation.task.progress * 100).to_i.to_s + '%'
+    case invocation.status
+      when HostStatus::ExecutionStatus::QUEUED
+        _('queued')
+      when HostStatus::ExecutionStatus::RUNNING
+        _('running %s%') % invocation.progress
+      when HostStatus::ExecutionStatus::OK
+        _('succeeded')
+      when HostStatus::ExecutionStatus::ERROR
+        _('failed')
+      else
+        _('unknown status')
     end
   end
 
@@ -77,43 +79,48 @@ module RemoteExecutionHelper
     end
   end
 
-  def template_invocation_actions(task, host)
-    if task.nil?
-      []
-    else
-      [display_link_if_authorized(_("Details"), hash_for_template_invocation_path(:id => task).merge(:auth_object => host, :permission => :view_hosts))]
-    end
+  def template_invocation_actions(task, host, job_invocation, template_invocation)
+    [
+      display_link_if_authorized(_('Host detail'), hash_for_host_path(host).merge(:auth_object => host, :permission => :view_hosts)),
+      display_link_if_authorized(_('Rerun on %s') % host.name, hash_for_rerun_job_invocation_path(:id => job_invocation, :host_ids => [ host.id ])),
+    ]
   end
 
-  def remote_execution_provider_for(task)
-    template_invocation = task.locks.where(:resource_type => 'TemplateInvocation').first.try(:resource) unless task.nil?
+  def remote_execution_provider_for(template_invocation)
     template_invocation.nil? ? _('N/A') : template_invocation.template.provider.humanized_name
   end
 
+  def job_invocations_buttons
+    [
+      documentation_button_rex('3.2ExecutingaJob'),
+      display_link_if_authorized(_('Run Job'), hash_for_new_job_invocation_path)
+    ]
+  end
+
   # rubocop:disable Metrics/AbcSize
   def job_invocation_task_buttons(task)
     job_invocation = task.task_groups.find { |group| group.class == JobInvocationTaskGroup }.job_invocation
     buttons = []
     buttons << link_to(_('Refresh'), {}, :class => 'btn btn-default', :title => _('Refresh this page'))
     if authorized_for(hash_for_new_job_invocation_path)
-      buttons << link_to(_("Rerun"), rerun_job_invocation_path(:id => job_invocation.id),
-                         :class => "btn btn-default",
+      buttons << link_to(_('Rerun'), rerun_job_invocation_path(:id => job_invocation.id),
+                         :class => 'btn btn-default',
                          :title => _('Rerun the job'))
     end
     if authorized_for(hash_for_new_job_invocation_path)
-      buttons << link_to(_("Rerun failed"), rerun_job_invocation_path(:id => job_invocation.id, :failed_only => 1),
-                         :class => "btn btn-default",
+      buttons << link_to(_('Rerun failed'), rerun_job_invocation_path(:id => job_invocation.id, :failed_only => 1),
+                         :class => 'btn btn-default',
                          :disabled => !task.sub_tasks.any? { |sub_task| task_failed?(sub_task) },
                          :title => _('Rerun on failed hosts'))
     end
     if authorized_for(:permission => :view_foreman_tasks, :auth_object => task)
-      buttons << link_to(_("Job Task"), foreman_tasks_task_path(task),
-                         :class => "btn btn-default",
+      buttons << link_to(_('Job Task'), foreman_tasks_task_path(task),
+                         :class => 'btn btn-default',
                          :title => _('See the last task details'))
     end
     if authorized_for(:permission => :edit_foreman_tasks, :auth_object => task)
-      buttons << link_to(_("Cancel Job"), cancel_foreman_tasks_task_path(task),
-                         :class => "btn btn-danger",
+      buttons << link_to(_('Cancel Job'), cancel_foreman_tasks_task_path(task),
+                         :class => 'btn btn-danger',
                          :title => _('Try to cancel the job'),
                          :disabled => !task.cancellable?,
                          :method => :post)
@@ -125,13 +132,13 @@ module RemoteExecutionHelper
   def template_invocation_task_buttons(task)
     buttons = []
     if authorized_for(:permission => :view_foreman_tasks, :auth_object => task)
-      buttons << link_to(_("Task Details"), foreman_tasks_task_path(task),
-                         :class => "btn btn-default",
+      buttons << link_to(_('Task Details'), foreman_tasks_task_path(task),
+                         :class => 'btn btn-default',
                          :title => _('See the task details'))
     end
     if authorized_for(:permission => :edit_foreman_tasks, :auth_object => task)
-      buttons << link_to(_("Cancel Job"), cancel_foreman_tasks_task_path(task),
-                         :class => "btn btn-danger",
+      buttons << link_to(_('Cancel Job'), cancel_foreman_tasks_task_path(task),
+                         :class => 'btn btn-danger',
                          :title => _('Try to cancel the job on a host'),
                          :disabled => !task.cancellable?,
                          :method => :post)
@@ -140,20 +147,20 @@ module RemoteExecutionHelper
   end
 
   def link_to_invocation_task_if_authorized(invocation)
-    if invocation.task.present? && invocation.task.state != 'scheduled'
+    if invocation.queued?
+      job_invocation_status(invocation)
+    else
       link_to_if_authorized job_invocation_status(invocation),
                             hash_for_foreman_tasks_task_path(invocation.task).merge(:auth_object => invocation.task, :permission => :view_foreman_tasks)
-    else
-      job_invocation_status(invocation)
     end
   end
 
   def invocation_count(invocation, options = {})
     options = { :unknown_string => 'N/A' }.merge(options)
-    if invocation.task.nil? || invocation.task.state != 'scheduled'
-      (invocation.task.try(:output) || {}).fetch(options[:output_key], options[:unknown_string])
-    else
+    if invocation.queued?
       options[:unknown_string]
+    else
+      (invocation.task.try(:output) || {}).fetch(options[:output_key], options[:unknown_string])
     end
   end
 
@@ -162,7 +169,7 @@ module RemoteExecutionHelper
     if (preview = renderer.preview)
       content_tag :pre, preview
     else
-      alert :class => "alert-block alert-danger base in fade has-error",
+      alert :class => 'alert-block alert-danger base in fade has-error',
             :text => renderer.error_message.html_safe
     end
   end
@@ -178,13 +185,55 @@ module RemoteExecutionHelper
     end
   end
 
-  def time_ago(time)
+  def time_in_words_span(time)
     if time.nil?
-      _('-')
+      _('N/A')
     else
-      content_tag :span, _("%s ago") % time_ago_in_words(time),
+      content_tag :span, (time > Time.now ? _('in %s') : _('%s ago')) % time_ago_in_words(time),
                   { :'data-original-title' => time.try(:in_time_zone), :rel => 'twipsy' }
     end
   end
 
+  def documentation_button_rex(section = '')
+    url = 'http://theforeman.org/plugins/foreman_remote_execution/' +
+      "#{ForemanRemoteExecution::VERSION.split('.').take(2).join('.')}/index.html#" +
+      section
+    link_to(
+      icon_text('help', _('Documentation'),
+                :class => 'icon-white', :kind => 'pficon'),
+      url,
+      :rel => 'external', :class => 'btn btn-info', :target => '_blank')
+  end
+
+  def template_input_header(f, template)
+    header = _('Template input')
+    header += ' ' + remove_child_link('x', f, {:rel => 'twipsy', :'data-title' => _('remove template input'), :'data-placement' => 'left',
+                                               :class => 'fr badge badge-danger'}) unless template.locked?
+    header.html_safe
+  end
+
+  def description_checkbox_f(f, job_template, disabled)
+    check_box_tag('description_format_override',
+                  job_template.generate_description_format,
+                  f.object.description_format.nil?,
+                  :class => 'description_format_override',
+                  :name => f.object_name + '[description_override]',
+                  :disabled => disabled,
+                  :onchange => 'description_override(this);') + ' ' + _('Use default description template')
+  end
+
+  def description_format_textarea_f(f, job_template, disabled)
+    textarea_f f, 'description_format',
+               :label => _('Description template'),
+               :value => f.object.description_format || job_template.generate_description_format,
+               :rows => 2,
+               :onchange => 'regenerate_description(this);',
+               :class => 'description_format',
+               :disabled => disabled,
+               :help_inline => popover(_('Explanation'),
+                                       _('This template is used to generate the description.
+                                          Input values can be used using the syntax %{package}.
+                                          You may also include the job category and template
+                                          name using %{job_category} and %{template_name}.'))
+  end
 end

data/app/lib/actions/remote_execution/run_host_job.rb

@@ -10,26 +10,29 @@ module Actions
       end
 
       def plan(job_invocation, host, template_invocation, proxy)
-        action_subject(host, :job_name => job_invocation.job_name, :description => job_invocation.description)
+        action_subject(host, :job_category => job_invocation.job_category, :description => job_invocation.description)
+
+        template_invocation.host_id = host.id
+        template_invocation.run_host_job_task_id = task.id
+        template_invocation.save!
 
-        template_invocation.update_attribute :host_id, host.id
         link!(job_invocation)
         link!(template_invocation)
 
         verify_permissions(host, template_invocation)
         hostname = find_ip_or_hostname(host)
 
-        raise _("Could not use any template used in the job invocation") if template_invocation.blank?
+        raise _('Could not use any template used in the job invocation') if template_invocation.blank?
 
         settings = { :global_proxy   => 'remote_execution_global_proxy',
                      :fallback_proxy => 'remote_execution_fallback_proxy' }
 
-        raise _("Could not use any proxy. Consider configuring %{global_proxy} " +
-                "or %{fallback_proxy} in settings") % settings if proxy.blank?
+        raise _('Could not use any proxy. Consider configuring %{global_proxy} ' +
+                'or %{fallback_proxy} in settings') % settings if proxy.blank?
 
         renderer = InputTemplateRenderer.new(template_invocation.template, host, template_invocation)
         script = renderer.render
-        raise _("Failed rendering template: %s") % renderer.error_message unless script
+        raise _('Failed rendering template: %s') % renderer.error_message unless script
 
         provider = template_invocation.template.provider
         plan_action(RunProxyCommand, proxy, hostname, script, provider.proxy_command_options(template_invocation, host))
@@ -57,9 +60,9 @@ module Actions
       end
 
       def humanized_name
-        _('%{description} on %{host}') % { :job_name => input[:job_name],
+        _('%{description} on %{host}') % { :job_category => input[:job_category],
                                            :host => input[:host][:name],
-                                           :description => input[:description].try(:capitalize) || input[:job_name] }
+                                           :description => input[:description].try(:capitalize) || input[:job_category] }
       end
 
       def find_ip_or_hostname(host)

data/app/lib/actions/remote_execution/run_hosts_job.rb

@@ -16,7 +16,7 @@ module Actions
         task.add_missing_task_groups(job_invocation.task_group) if job_invocation.task_group
         action_subject(job_invocation) unless locked
         job_invocation.targeting.resolve_hosts! if job_invocation.targeting.dynamic? || !locked
-        input.update(:job_name => job_invocation.job_name)
+        input.update(:job_category => job_invocation.job_category)
         plan_self(:job_invocation_id => job_invocation.id)
       end
 
@@ -24,8 +24,11 @@ module Actions
         job_invocation = JobInvocation.find(input[:job_invocation_id])
         load_balancer = ProxyLoadBalancer.new
 
+        # composer creates just "pattern" for template_invocations because target is evaluated
+        # during actual run (here) so we build template invocations from these patterns
         job_invocation.targeting.hosts.map do |host|
-          template_invocation = job_invocation.template_invocation_for_host(host)
+          template_invocation = job_invocation.pattern_template_invocation_for_host(host).deep_clone
+          template_invocation.host_id = host.id
           proxy = determine_proxy(template_invocation, host, load_balancer)
           trigger(RunHostJob, job_invocation, host, template_invocation, proxy)
         end

data/app/lib/actions/remote_execution/run_proxy_command.rb

@@ -21,7 +21,7 @@ module Actions
                                        .new(data[:metadata][:exception_message]))
         else
           super(data)
-          error! _("Script execution failed") if failed_run?
+          error! _('Script execution failed') if failed_run?
         end
       end
 
@@ -63,7 +63,7 @@ module Actions
         proxy_data.fetch('output', {}).fetch('result', [])
       rescue => e
         ::Foreman::Logging.exception("Failed to load data for task #{task.id} from proxy #{ input[:proxy_url] }", e)
-        [exception_to_output(_("Error loading data from proxy"), e)]
+        [exception_to_output(_('Error loading data from proxy'), e)]
       end
 
       def finalized_output
@@ -76,13 +76,18 @@ module Actions
         end
 
         if exit_status
-          records << format_output(_("Exit status: %s") % exit_status, 'stdout', task.ended_at)
+          records << format_output(_('Exit status: %s') % exit_status, 'stdout', final_timestamp(records))
         elsif run_step && run_step.error
-          records << format_output(_("Job finished with error") + ": #{run_step.error.exception_class} - #{run_step.error.message}", 'debug', task.ended_at)
+          records << format_output(_('Job finished with error') + ": #{run_step.error.exception_class} - #{run_step.error.message}", 'debug', final_timestamp(records))
         end
         return records
       end
 
+      def final_timestamp(records)
+        return task.ended_at if records.blank?
+        records.last.fetch('timestamp', task.ended_at) + 1
+      end
+
       def proxy_result
         self.output.fetch(:proxy_output, {}).fetch(:result, []) || []
       end