foreman_remote_execution 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f8d8e0e19bc92e9e21f80c8a6e3e92be602746bf
-  data.tar.gz: 0b1fec43cafcb5cf997572113a54b581f715e465
+  metadata.gz: f7b17c729ed77837816fc91f385aec89be98be24
+  data.tar.gz: 32d6a582df1ffb8e3d20163481176e651070127e
 SHA512:
-  metadata.gz: b10f8a9378e50fb25140a93a37141791f5080ee4f92027a005b1e68b8561fbc756d8780b90240f4bddd0cd50b38927f7ed849c94155ae59a3812341b0045dc2d
-  data.tar.gz: f0e678cf3bd185d40de34820c4d1e35cefc0d7429daedfff0d2440cb7744b49f97925259d74e1cf3743cb02492e7eedc916ca0e96d56543ae9d5055cf6d53f35
+  metadata.gz: 733f0235a691db6d71bc9ad72bcf1d3c45db6c95530ed9a57d39203d59401b92858ffb9954c2dccba622ae5a3819147fae35415a1073e1cb920fb138ef89ef46
+  data.tar.gz: 35cfdf9e050b3ebe132c955c0f21c41fbd97e33a3dee871f52e556b446a6d64625b66b0c558bd5d01a23465695b0a1cb233d2e39d5ac3f43c48e5aa6793e3d62

data/app/assets/javascripts/execution_interface.js

@@ -0,0 +1,6 @@
+$(document).on('click', '.interface_execution', function () {
+    confirm_flag_change(this, '.interface_execution', __("Another interface is already set as execution. Are you sure you want to use this one instead?"));
+
+    var modal_form = $('#interfaceModal').find('.modal-body').contents();
+    $('#interfaceForms .interface_execution:checked').attr("checked", false);
+});

data/app/assets/javascripts/template_invocation.js

@@ -31,6 +31,11 @@ function job_invocation_form_binds() {
     $('#job_template_' + $(this).val()).show();
   });
 
+  $('input.trigger_mode_selector').on('click', function () {
+     $("#trigger_mode_future").hide();
+     $('#trigger_mode_' + $(this).val()).show();
+   });
+
   $('select#job_invocation_job_name').on('change', refresh_execution_form);
 
   $('button#refresh_execution_form').on('click', refresh_execution_form);
@@ -39,3 +44,16 @@ function job_invocation_form_binds() {
 
   $('select#targeting_bookmark_id').on('change', refresh_search_query);
 }
+
+function delayed_refresh(url, data){
+  setTimeout(function () {
+    $.ajax(
+      {
+        url: url,
+        data: data,
+        dataType: "script",
+        error: function() { $("div.terminal div.printable").append(__('<div class="line error">There was an error while updating the status, try <a href="javascript:window.location.href=window.location.href">refreshing</a> the page</div>')) }
+      }
+    )
+  }, 1000);
+}

data/app/assets/stylesheets/template_invocation.css.scss

@@ -14,3 +14,56 @@ fieldset.provider_form {
     margin-left: 90px;
   }
 }
+
+div.terminal {
+  display: block;
+  padding: 9.5px;
+  margin: 0 0 10px;
+  font-size: 13px;
+  line-height: 1.428571429;
+  word-break: break-all;
+  word-wrap: break-word;
+  color: #B2B2B2;
+  background-color: #000000;
+  border: 1px solid #000000;
+  border-radius: 4px;
+  font-family: Menlo, Monaco, Consolas, "Courier New", monospace;
+
+  div.printable {
+    min-height: 50px;
+  }
+
+  div.line.error, div.line.debug {
+    color: #a9302a;
+  }
+
+  div.line.stderr {
+    background-color: rgba(205, 209, 207, 0.21);
+    color: #FFFFFF;
+  }
+
+  div.line span.counter {
+    float: left;
+    clear: left;
+  }
+
+  div.line div.content {
+    position: relative;
+    margin-left: 50px;
+  }
+
+  a {
+    color: #FFFFFF;
+  }
+
+  a.scroll-link-top {
+    position: relative;
+    bottom: 10px;
+  }
+
+  a.scroll-link-bottom {
+    position: relative;
+    z-index: 5;
+  }
+
+}

data/app/controllers/api/v2/job_invocations_controller.rb

@@ -0,0 +1,64 @@
+module Api
+  module V2
+    class JobInvocationsController < ::Api::V2::BaseController
+      include ::Api::Version2
+      include ::Api::TaxonomyScope
+      include ::Foreman::Renderer
+
+      before_filter :find_optional_nested_object
+      before_filter :find_resource, :only => %w{show update destroy clone}
+      before_filter :validate_templates, :only => :create
+
+      api :GET, "/job_invocations/", N_("List job invocations")
+      param_group :search_and_pagination, ::Api::V2::BaseController
+      def index
+        @job_invocations = resource_scope_for_index
+      end
+
+      api :GET, "/job_invocations/:id", N_("Show job invocation")
+      param :id, :identifier, :required => true
+      def show
+      end
+
+      def_param_group :job_invocation do
+        param :job_invocation, Hash, :required => true, :action_aware => true do
+          param :job_name, String, :required => true, :desc => N_("Job name")
+          param :template_id, String, :required => false, :desc => N_("If using a specific template, the id of that template.")
+          param :targeting_type, String, :required => true, :desc => N_("Invocation type, one of %s") % Targeting::TYPES
+          param :inputs, Array, :required => false, :desc => N_("Inputs to use") do
+            param :name, String, :required => true
+            param :value, String, :required => true
+          end
+          param :bookmark_id, Integer, :required => false
+          param :search_query, Integer, :required => false
+        end
+      end
+
+      api :POST, "/job_invocations/", N_("Create a job template")
+      param_group :job_invocation, :as => :create
+      def create
+        composer = JobInvocationApiComposer.new(JobInvocation.new, User.current, params[:job_invocation])
+        composer.save!
+        ForemanTasks.async_task(::Actions::RemoteExecution::RunHostsJob, composer.job_invocation)
+        @job_invocation = composer.job_invocation
+        process_response @job_invocation
+      end
+
+      private
+
+      def validate_templates
+        templates = []
+        if params[:job_invocation][:template_id]
+          templates << JobTemplate.find(params[:job_invocation][:template_id])
+        else
+          templates = JobTemplate.where(:job_name => params[:job_invocation][:job_name])
+          if templates.pluck(:provider_type).uniq.length != templates.length
+            raise Foreman::Exception, _("Duplicate remote execution providers found for specified Job, please specify a single template_id.")
+          end
+        end
+
+        raise Foreman::Exception, _("No templates associated with specified Job Name") if templates.empty?
+      end
+    end
+  end
+end

data/app/controllers/job_invocations_controller.rb

@@ -24,9 +24,17 @@ class JobInvocationsController < ApplicationController
 
   def create
     @composer = JobInvocationComposer.new.compose_from_params(params)
+    action = ::Actions::RemoteExecution::RunHostsJob
     if @composer.save
-      @task = ForemanTasks.async_task(::Actions::RemoteExecution::RunHostsJob, @composer.job_invocation)
-      redirect_to job_invocation_path(@composer.job_invocation)
+      job_invocation = @composer.job_invocation
+      if job_invocation.trigger_mode == :future
+        ForemanTasks.delay action,
+                           job_invocation.delay_options,
+                           job_invocation
+      else
+        ForemanTasks.async_task(action, job_invocation)
+      end
+      redirect_to job_invocation_path(job_invocation)
     else
       render :action => 'new'
     end
@@ -34,6 +42,7 @@ class JobInvocationsController < ApplicationController
 
   def show
     @job_invocation = resource_base.find(params[:id])
+    @auto_refresh = @job_invocation.last_task.try(:pending?)
   end
 
   def index

data/app/controllers/template_invocations_controller.rb

@@ -0,0 +1,16 @@
+class TemplateInvocationsController < ApplicationController
+  def controller_permission
+    'job_invocations'
+  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)
+    @auto_refresh = @template_invocation_task.pending?
+    @since = params[:since].to_f if params[:since].present?
+    @line_sets = @template_invocation_task.main_action.live_output
+    @line_sets = @line_sets.drop_while { |o| o['timestamp'].to_f <= @since } if @since
+    @line_counter = params[:line_counter].to_i
+  end
+end

data/app/helpers/remote_execution_helper.rb

@@ -11,14 +11,18 @@ module RemoteExecutionHelper
     options = { :class => 'statistics-pie small', :expandable => true, :border => 0, :show_title => true }
 
     if (bulk_task = invocation.last_task)
+      failed_tasks = bulk_task.sub_tasks.select { |sub_task| %w(warning error).include? sub_task.result }
+      cancelled_tasks, failed_tasks = failed_tasks.partition { |task| task_cancelled? task }
       success = bulk_task.output['success_count'] || 0
-      failed = bulk_task.output['failed_count'] || 0
-      pending = (bulk_task.output['pending_count'] || 0)
+      cancelled = cancelled_tasks.length
+      failed = failed_tasks.length
+      pending = (bulk_task.output['pending_count'] || bulk_task.sub_tasks.count)
 
       flot_pie_chart('status', job_invocation_status(invocation),
                      [{:label => _('Success'), :data => success, :color => '#5CB85C'},
                       {:label => _('Failed'), :data => failed, :color => '#D9534F'},
-                      {:label => _('Pending'), :data => pending, :color => '#DEDEDE'}],
+                      {:label => _('Pending'), :data => pending, :color => '#DEDEDE'},
+                      {:label => _('Cancelled'), :data => cancelled, :color => '#B7312D'}],
                      options)
     else
       content_tag(:h4, job_invocation_status(invocation))
@@ -28,11 +32,18 @@ module RemoteExecutionHelper
   def job_invocation_status(invocation)
     if invocation.last_task.blank?
       _('Job not started yet 0%')
+    elsif invocation.last_task.state == 'scheduled'
+      _('Job set to execute at %s') % invocation.last_task.start_at
+    elsif invocation.last_task.state == 'stopped' && invocation.last_task.result == 'error'
+      invocation.last_task.execution_plan.errors.map(&:message).join("\n")
     else
       label = invocation.last_task.pending ? _('Running') : _('Finished')
       label + ' ' + (invocation.last_task.progress * 100).to_i.to_s + '%'
     end
+  end
 
+  def task_cancelled?(task)
+    task.execution_plan.errors.map(&:exception).any? { |exception| exception.class == ::ForemanTasks::Task::TaskCancelledException }
   end
 
   def host_counter(label, count)
@@ -42,18 +53,39 @@ module RemoteExecutionHelper
   end
 
   def template_invocation_status(task)
-    case task.result
-      when 'warning', 'error'
-        content_tag(:i, '&nbsp'.html_safe, :class => 'glyphicon glyphicon-exclamation-sign') + content_tag(:span, _('failed'), :class => 'status-error')
-      when 'success'
-        content_tag(:i, '&nbsp'.html_safe, :class => 'glyphicon glyphicon-ok-sign') + content_tag(:span, _('success'), :class => 'status-ok')
-      when 'pending'
-        content_tag(:i, '&nbsp'.html_safe, :class => 'glyphicon glyphicon-question-sign') + content_tag(:span, _('pending'))
-      else
-        task.result
+    if task.nil?
+      content_tag(:i, '&nbsp'.html_safe, :class => 'glyphicon glyphicon-question-sign') + content_tag(:span, _('N/A'))
+    else
+      case task.result
+        when 'warning', 'error'
+          if task_cancelled?(task)
+            content_tag(:i, '&nbsp'.html_safe, :class => 'glyphicon glyphicon-warning-sign') + content_tag(:span, _('cancelled'), :class => 'status-error')
+          else
+            content_tag(:i, '&nbsp'.html_safe, :class => 'glyphicon glyphicon-exclamation-sign') + content_tag(:span, _('failed'), :class => 'status-error')
+          end
+        when 'success'
+          content_tag(:i, '&nbsp'.html_safe, :class => 'glyphicon glyphicon-ok-sign') + content_tag(:span, _('success'), :class => 'status-ok')
+        when 'pending'
+          content_tag(:i, '&nbsp'.html_safe, :class => 'glyphicon glyphicon-question-sign') + content_tag(:span, _('pending'))
+        else
+          task.result
+      end
     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_foreman_tasks))]
+    end
+  end
+
+  def remote_execution_provider_for(task)
+    template_invocation = task.locks.where(:resource_type => 'TemplateInvocation').first.try(:resource) unless task.nil?
+    template_invocation.nil? ? _('N/A') : _(RemoteExecutionProvider.provider_for(template_invocation.template.provider_type))
+  end
+
   def job_invocation_task_buttons(task)
     buttons = []
     buttons << link_to(_('Refresh'), {}, :class => 'btn btn-default', :title => _('Refresh this page'))
@@ -79,11 +111,28 @@ module RemoteExecutionHelper
                          :disabled => !task.cancellable?,
                          :method => :post)
     end
-    return button_group(*buttons)
+    return buttons
+  end
+
+  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",
+                         :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",
+                         :title => _('Try to cancel the job on a host'),
+                         :disabled => !task.cancellable?,
+                         :method => :post)
+    end
+    return buttons
   end
 
   def link_to_invocation_task_if_authorized(invocation)
-    if invocation.last_task.present?
+    if invocation.last_task.present? && invocation.last_task.state != 'scheduled'
       link_to_if_authorized job_invocation_status(invocation),
                             hash_for_foreman_tasks_task_path(invocation.last_task).merge(:auth_object => invocation.last_task, :permission => :view_foreman_tasks)
     else
@@ -93,6 +142,20 @@ module RemoteExecutionHelper
 
   def invocation_count(invocation, options = {})
     options = { :unknown_string => 'N/A' }.merge(options)
-    (invocation.last_task.try(:output) || {}).fetch(options[:output_key], options[:unknown_string])
+    if invocation.last_task.nil? || invocation.last_task.state != 'scheduled'
+      (invocation.last_task.try(:output) || {}).fetch(options[:output_key], options[:unknown_string])
+    else
+      options[:unknown_string]
+    end
+  end
+
+  def preview_box(template_invocation, target)
+    renderer = InputTemplateRenderer.new(template_invocation.template, target, template_invocation)
+    if (preview = renderer.preview)
+      content_tag :pre, preview
+    else
+      alert :class => "alert-block alert-danger base in fade has-error",
+            :text => renderer.error_message.html_safe
+    end
   end
 end

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

@@ -0,0 +1,29 @@
+module Actions
+  module Middleware
+
+    class BindJobInvocation < ::Dynflow::Middleware
+
+      def delay(*args)
+        _schedule_options, job_invocation = args
+        pass(*args).tap { bind(job_invocation) }
+      end
+
+      def plan(*args)
+        job_invocation = args.first
+        pass(*args).tap { bind(job_invocation) }
+      end
+
+      private
+
+      def task
+        @task ||= ForemanTasks::Task::DynflowTask.find_by_external_id!(action.execution_plan_id)
+      end
+
+      def bind(job_invocation)
+        job_invocation.update_attribute :last_task_id, task.id if job_invocation.last_task_id != task.id
+      end
+
+    end
+
+  end
+end

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

@@ -8,12 +8,17 @@ module Actions
 
       include ::Dynflow::Action::Cancellable
 
-      def plan(job_invocation, host)
+      def plan(job_invocation, host, template_invocation, proxy, connection_options = {})
         action_subject(host, :job_name => job_invocation.job_name)
-
-        template_invocation = find_template_invocation(job_invocation, host)
         hostname = find_ip_or_hostname(host)
-        proxy = find_proxy(template_invocation, host)
+
+        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?
 
         renderer = InputTemplateRenderer.new(template_invocation.template, host, template_invocation)
         script = renderer.render
@@ -22,71 +27,33 @@ module Actions
         link!(job_invocation)
         link!(template_invocation)
 
-        plan_action(RunProxyCommand, proxy, hostname, script)
+        plan_action(RunProxyCommand, proxy, hostname, script, { :connection_options => connection_options })
       end
 
       def humanized_output
-        host_run_action = planned_actions(RunProxyCommand).first
-        proxy_output = host_run_action && host_run_action.output[:proxy_output]
-        return unless proxy_output
-        output = []
-        if proxy_output[:result]
-          output << proxy_output[:result].map { |o| o[:output] }.join("")
-        end
-        output << "Exit status: #{host_run_action.exit_status}" if host_run_action.exit_status
-        return output.join("\n")
+        live_output.map { |line| line['output'].chomp }.join("\n")
+      end
+
+      def live_output
+        planned_actions(RunProxyCommand).first.live_output
       end
 
       def humanized_name
         _('Run %{job_name} on %{host}') % { :job_name => input[:job_name], :host => input[:host][:name] }
       end
 
-      def find_template_invocation(job_invocation, host)
-        providers = available_providers(job_invocation, host)
-        providers.each do |provider|
-          job_invocation.template_invocations.each do |template_invocation|
-            if template_invocation.template.provider_type == provider
-              return template_invocation
-            end
+      def find_ip_or_hostname(host)
+        %w(execution primary provision).each do |flag|
+          if host.send("#{flag}_interface") && host.send("#{flag}_interface").ip.present?
+            return host.execution_interface.ip
           end
         end
 
-        raise _("Could not use any template used in the job invocation")
-      end
-
-      def find_ip_or_hostname(host)
         host.interfaces.each do |interface|
           return interface.ip unless interface.ip.blank?
         end
-        return host.name
-      end
-
-      def available_providers(job_invocation, host)
-        # TODO: determine from the host and job_invocation details
-        return ['Ssh']
-      end
-
-      def find_proxy(template_invocation, host)
-        provider = template_invocation.template.provider_type.to_s
-        all_host_proxies(host).each do |proxies|
-          if proxy = proxies.joins(:features).where("features.name = ?", provider).first
-            return proxy
-          end
-        end
-        raise _("Could not use any proxy: assign a proxy with provider '%{provider}' to the host or set '%{global_proxy_setting}' in settings") %\
-            { :provider => provider, :global_proxy_setting => 'remote_execution_global_proxy' }
-      end
 
-      def all_host_proxies(host)
-        Enumerator.new do |e|
-          host.interfaces.each do |interface|
-            if interface.subnet
-              e << ::SmartProxy.where(:id => interface.subnet.proxies.map(&:id))
-            end
-          end
-          e << host.smart_proxies
-          e << ::SmartProxy.authorized if Setting[:remote_execution_global_proxy]
-        end
+        return host.fqdn
       end
     end
   end