foreman_remote_execution 0.0.1

data/README.md

@@ -0,0 +1,54 @@
+# Foreman Remote Execution
+
+A plugin bringing remote execution to the Foreman, completing the config 
+management functionality with remote management functionality.
+
+## Installation
+
+See [How_to_Install_a_Plugin](http://projects.theforeman.org/projects/foreman/wiki/How_to_Install_a_Plugin)
+for how to install Foreman plugins
+
+## Usage
+
+*Usage here*
+
+## Generating the docs
+
+0. ``cd doc``
+
+0. ``mkdir .bin`` # only first time
+
+1. ``bundle install``
+
+2. ``bundle exec rake plantuml_install`` to install prerequisites
+
+3. ``bundle exec jekyll serve`` to see the rendered changes locally
+
+4. ``bundle exec rake publish`` to publish the changes to Github pages
+
+## Links
+
+* [the project page](http://theforeman.github.io/foreman_remote_execution/)
+* [the issue tracker](http://projects.theforeman.org/projects/foreman_remote_execution)
+
+## Contributing
+
+Fork and send a Pull Request. Thanks!
+
+## Copyright
+
+Copyright (c) 2015 The Foreman developers
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+

data/Rakefile

@@ -0,0 +1,47 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ForemanRemoteExecution'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path('../test/dummy/Rakefile', __FILE__)
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test
+
+begin
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
+rescue => _
+  puts 'Rubocop not loaded.'
+end
+
+task :default do
+  Rake::Task['rubocop'].execute
+end

data/app/assets/javascripts/template_input.js

@@ -0,0 +1,9 @@
+$(document).on('change', 'select.input_type_selector', function () {
+  update_visibility_after_input_type_change($(this));
+});
+
+function update_visibility_after_input_type_change(select){
+  fieldset = select.closest('fieldset');
+  fieldset.find('div.custom_input_type_fields').hide();
+  fieldset.find('div.' + select.val() + '_input_type').show();
+}

data/app/assets/javascripts/template_invocation.js

@@ -0,0 +1,32 @@
+$(function() { job_invocation_form_binds() });
+
+function refresh_execution_form() {
+  var form = $('form#job_invocation_form');
+  var data = form.serializeArray();
+
+  request = $.ajax({
+    data: data,
+    type: 'POST',
+    url: form.attr('data-refresh-url'),
+    dataType: 'script'
+  });
+
+  request.done(function () {
+    password_caps_lock_hint();
+    form.find('a[rel="popover-modal"]').popover({html: true});
+    form.find('select').select2({allowClear: true});
+    job_invocation_form_binds();
+  });
+}
+
+function job_invocation_form_binds() {
+  $('input.job_template_selector').on('click', function () {
+    parent_fieldset = $(this).closest('fieldset');
+    $(parent_fieldset).find('fieldset.job_template_form').hide();
+    $('#job_template_' + $(this).val()).show();
+  });
+
+  $('select#job_invocation_job_name').on('change', refresh_execution_form);
+
+  $('button#refresh_execution_form').on('click', refresh_execution_form);
+}

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

@@ -0,0 +1,35 @@
+div#status_chart {
+  float: right;
+}
+
+div.infoblock {
+  margin-bottom: 20px;
+  line-height: 2;
+
+  pre {
+    margin-top: 5px;
+  }
+
+  div.host_counter {
+    float: left;
+    min-width: 100px;
+    text-align: center;
+
+    .count {
+      font-size: 20px;
+    }
+  }
+}
+
+// chances are that these will be present in Foreman 1.10
+.status-ok {
+  color: #5CB85C;
+}
+
+.status-error {
+  color: #D9534F
+}
+
+.status-warn, .status-question {
+  color: #DB843D;
+}

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

@@ -0,0 +1,16 @@
+fieldset.provider_form {
+  margin-bottom: 10px;
+
+  legend {
+    margin-bottom: 0px;
+    font-size: 14px;
+    font-weight: bold;
+    margin-left: 80px;
+    width: 80%
+  }
+
+  label.radio-inline {
+    display: block;
+    margin-left: 90px;
+  }
+}

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

@@ -0,0 +1,108 @@
+module Api
+  module V2
+    class JobTemplatesController < ::Api::V2::BaseController
+      include ::Api::Version2
+      include ::Api::TaxonomyScope
+      include ::Foreman::Renderer
+      include ::Foreman::Controller::ProvisioningTemplates
+
+      before_filter :find_optional_nested_object
+      before_filter :find_resource, :only => %w{show update destroy clone}
+
+      before_filter :handle_template_upload, :only => [:create, :update]
+
+      api :GET, "/job_templates/", N_("List job templates")
+      api :GET, "/locations/:location_id/job_templates/", N_("List job templates per location")
+      api :GET, "/organizations/:organization_id/job_templates/", N_("List job templates per organization")
+      param_group :taxonomy_scope, ::Api::V2::BaseController
+      param_group :search_and_pagination, ::Api::V2::BaseController
+      def index
+        @job_templates = resource_scope_for_index
+      end
+
+      api :GET, "/job_templates/:id", N_("Show job template details")
+      param :id, :identifier, :required => true
+      def show
+      end
+
+      def_param_group :job_template do
+        param :job_template, Hash, :required => true, :action_aware => true do
+          param :name, String, :required => true, :desc => N_("Template name")
+          param :job_name, String, :required => true, :desc => N_("Job name")
+          param :template, String, :required => true
+          param :provider_type, String, :required => true, :desc => N_("Provider type")
+          param :snippet, :bool, :allow_nil => true
+          param :audit_comment, String, :allow_nil => true
+          param :locked, :bool, :desc => N_("Whether or not the template is locked for editing")
+          param_group :taxonomies, ::Api::V2::BaseController
+        end
+      end
+
+      api :POST, "/job_templates/", N_("Create a job template")
+      param_group :job_template, :as => :create
+      def create
+        @job_template = JobTemplate.new(params[:job_template])
+        process_response @job_template.save
+      end
+
+      api :PUT, "/job_templates/:id", N_("Update a job template")
+      param :id, :identifier, :required => true
+      param_group :job_template
+      def update
+        process_response @job_template.update_attributes(params[:job_template])
+      end
+
+      api :GET, "/job_templates/revision"
+      param :version, String, :desc => N_("Template version")
+      def revision
+        audit = Audit.authorized(:view_audit_logs).find(params[:version])
+        render :json => audit.revision.template
+      end
+
+      api :DELETE, "/job_templates/:id", N_("Delete a job template")
+      param :id, :identifier, :required => true
+      def destroy
+        process_response @job_template.destroy
+      end
+
+      def_param_group :job_template_clone do
+        param :job_template, Hash, :required => true, :action_aware => true do
+          param :name, String, :required => true, :desc => N_("Template name")
+        end
+      end
+
+      api :POST, "/job_templates/:id/clone", N_("Clone a provision template")
+      param :id, :identifier, :required => true
+      param_group :job_template_clone, :as => :create
+      def clone
+        @job_template = @job_template.clone
+        load_vars_from_template
+        @job_template.name = params[:job_template][:name]
+        process_response @job_template.save
+      end
+
+      def resource_name
+        'job_template'
+      end
+
+      private
+
+      def action_permission
+        case params[:action]
+        when 'clone'
+          :create
+        else
+          super
+        end
+      end
+
+      def resource_class
+        JobTemplate
+      end
+
+      def allowed_nested_id
+        %w(location_id organization_id)
+      end
+    end
+  end
+end

data/app/controllers/job_invocations_controller.rb

@@ -0,0 +1,35 @@
+class JobInvocationsController < ApplicationController
+  include Foreman::Controller::AutoCompleteSearch
+
+  def new
+    @composer = JobInvocationComposer.new(JobInvocation.new,
+                                          :host_ids => params[:host_ids],
+                                          :targeting => {
+                                            :targeting_type => Targeting::STATIC_TYPE,
+                                            :bookmark_id => params[:bookmark_id]
+                                          })
+  end
+
+  def create
+    @composer = JobInvocationComposer.new(JobInvocation.new, params)
+    if @composer.save
+      @task = ForemanTasks.async_task(::Actions::RemoteExecution::RunHostsJob, @composer.job_invocation)
+      redirect_to job_invocation_path(@composer.job_invocation)
+    else
+      render :action => 'new'
+    end
+  end
+
+  def show
+    @job_invocation = resource_base.find(params[:id])
+  end
+
+  def index
+    @job_invocations = resource_base.search_for(params[:search]).paginate(:page => params[:page]).order('id DESC')
+  end
+
+  # refreshes the form
+  def refresh
+    @composer = JobInvocationComposer.new(JobInvocation.new, params)
+  end
+end

data/app/controllers/job_templates_controller.rb

@@ -0,0 +1,35 @@
+class JobTemplatesController < ::TemplatesController
+  def load_vars_from_template
+    return unless @template
+
+    @locations        = @template.locations
+    @organizations    = @template.organizations
+  end
+
+  def auto_complete_job_name
+    @job_names = resource_base.where(['job_name LIKE ?', "%#{params[:search]}%"]).pluck(:job_name).uniq
+  end
+
+  def preview
+    base = Host.authorized(:view_hosts)
+    host = params[:preview_host_id].present? ? base.find(params[:preview_host_id]) : base.first
+    @template.template = params[:template]
+    renderer = InputTemplateRenderer.new(@template, host)
+    if (output = renderer.preview)
+      render :text => output
+    else
+      render :status => 406, :text => renderer.error_message
+    end
+  end
+
+  private
+
+  def action_permission
+    case params[:action]
+      when 'auto_complete_job_name'
+        :view_job_templates
+      else
+        super
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module ForemanRemoteExecution
+  module HostsHelperExtensions
+    extend ActiveSupport::Concern
+
+    included do
+      alias_method_chain(:host_title_actions, :run_button)
+      alias_method_chain :multiple_actions, :remote_execution
+      alias_method_chain :multiple_actions_select, :remote_execution
+    end
+
+    def multiple_actions_with_remote_execution
+      # The modal window loads empty page, we hook the custom function
+      # to the link later. The ?run_job=true is there just to be able to identify the link
+      multiple_actions_without_remote_execution + [[_('Run Job'), 'blank.html?run_job=true']]
+    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)))
+      host_title_actions_without_run_button(*args)
+    end
+
+    def multiple_actions_select_with_remote_execution(*args)
+      # TODO: awful hack to open the job invocation form as a new
+      # page rather than using the AJAX inside a modal window.
+      # Since we want for this plugin to be compatible with 1.9, we
+      # need to monkey patch/js hack for now, but it should be removed
+      # after we fix and release http://projects.theforeman.org/issues/11309
+      multiple_actions_select_without_remote_execution(*args) +
+          <<-JAVASCRIPT.html_safe
+      <script>
+      $(function () {
+        $("#submit_multiple a[onclick*='blank.html?run_job=true']").click(function (e) {
+          document.location = "#{new_job_invocation_path}?" + $.param({host_ids: $.foremanSelectedHosts});
+        })
+      })
+      </script>
+      JAVASCRIPT
+    end
+  end
+end

data/app/helpers/remote_execution_helper.rb

@@ -0,0 +1,88 @@
+module RemoteExecutionHelper
+  def providers_options
+    RemoteExecutionProvider.providers.map { |key, provider| [ key, _(provider) ] }
+  end
+
+  def template_input_types_options
+    TemplateInput::TYPES.map { |key, name| [ _(name), key ] }
+  end
+
+  def job_invocation_chart(invocation)
+    options = { :class => 'statistics-pie small', :expandable => true, :border => 0, :show_title => true }
+
+    if (bulk_task = invocation.last_task)
+      success = bulk_task.output['success_count'] || 0
+      failed = bulk_task.output['failed_count'] || 0
+      pending = (bulk_task.output['pending_count'] || 0)
+
+      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'}],
+                     options)
+    else
+      content_tag(:h4, job_invocation_status(invocation))
+    end
+  end
+
+  def job_invocation_status(invocation)
+    if invocation.last_task.blank?
+      _('Job not started yet 0%')
+    else
+      label = invocation.last_task.pending ? _('Running') : _('Finished')
+      label + ' ' + (invocation.last_task.progress * 100).to_i.to_s + '%'
+    end
+
+  end
+
+  def host_counter(label, count)
+    content_tag(:div, :class => 'host_counter') do
+      content_tag(:div, label, :class => 'header') + content_tag(:div, count.to_s, :class => 'count')
+    end
+  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
+    end
+  end
+
+  def job_invocation_task_buttons(task)
+    buttons = []
+    buttons << link_to(_('Refresh'), {}, :class => 'btn btn-default', :title => _('Refresh this page'))
+    if authorized_for(:permission => :view_foreman_tasks, :auth_object => task)
+      buttons << link_to(_("Last 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",
+                         :title => _('Try to cancel the job'),
+                         :disabled => !task.cancellable?,
+                         :method => :post)
+    end
+    return button_group(*buttons)
+  end
+
+  def link_to_invocation_task_if_authorized(invocation)
+    if invocation.last_task.present?
+      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
+      job_invocation_status(invocation)
+    end
+  end
+
+  def invocation_count(invocation, options = {})
+    options = { :unknown_string => 'N/A' }.merge(options)
+    (invocation.last_task.try(:output) || {}).fetch(options[:output_key], options[:unknown_string])
+  end
+end

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

@@ -0,0 +1,93 @@
+module Actions
+  module RemoteExecution
+    class RunHostJob < Actions::EntryAction
+
+      def resource_locks
+        :link
+      end
+
+      include ::Dynflow::Action::Cancellable
+
+      def plan(job_invocation, host)
+        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)
+
+        renderer = InputTemplateRenderer.new(template_invocation.template, host, template_invocation)
+        script = renderer.render
+        raise _("Failed rendering template: %s") % renderer.error_message unless script
+
+        link!(job_invocation)
+        link!(template_invocation)
+
+        plan_action(RunProxyCommand, proxy, hostname, script)
+      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")
+      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
+          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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Actions
+  module RemoteExecution
+    class RunHostsJob < Actions::ActionWithSubPlans
+      def plan(job_invocation)
+        action_subject(job_invocation)
+
+        job_invocation.targeting.resolve_hosts!
+        job_invocation.update_attribute :last_task_id, task.id
+        input.update(:job_name => job_invocation.job_name)
+        plan_self(job_invocation_id: job_invocation.id)
+      end
+
+      def create_sub_plans
+        job_invocation = JobInvocation.find(input[:job_invocation_id])
+        job_invocation.targeting.hosts.map do |host|
+          trigger(RunHostJob, job_invocation, host)
+        end
+      end
+
+      def rescue_strategy
+        ::Dynflow::Action::Rescue::Skip
+      end
+
+      def run(event = nil)
+        super unless event == Dynflow::Action::Skip
+      end
+
+      def output
+        result = super
+        result[:pending_count] = (result[:total_count] || 0) - (result[:failed_count] || 0) - (result[:success_count] || 0)
+        result
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Actions
+  module RemoteExecution
+    class RunProxyCommand < Actions::ProxyAction
+
+      include ::Dynflow::Action::Cancellable
+
+      def plan(proxy, hostname, script, options = {})
+        options = { :effective_user => nil }.merge(options)
+        super(proxy, options.merge(:hostname => hostname, :script => script))
+      end
+
+      def proxy_action_name
+        'Proxy::RemoteExecution::Ssh::CommandAction'
+      end
+
+      def on_data(data)
+        super(data)
+        error! _("Script execution failed") if failed_run?
+      end
+
+      def rescue_strategy
+        ::Dynflow::Action::Rescue::Skip
+      end
+
+      def failed_run?
+        exit_status && proxy_output[:exit_status] != 0
+      end
+
+      def exit_status
+        proxy_output && proxy_output[:exit_status]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module ForemanRemoteExecution
+  module BookmarkExtensions
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :targetings, :dependent => :nullify
+    end
+  end
+end