foreman_remote_execution 0.0.6 → 0.0.7

data/config/routes.rb

@@ -23,8 +23,12 @@ Rails.application.routes.draw do
     end
   end
 
+  resources :template_invocations, :only => [:show]
+
   namespace :api, :defaults => {:format => 'json'} do
     scope "(:apiv)", :module => :v2, :defaults => {:apiv => 'v2'}, :apiv => /v1|v2/, :constraints => ApiConstraints.new(:version => 2, :default => true) do
+      resources :job_invocations, :except => [:new, :edit, :update, :destroy]
+
       resources :job_templates, :except => [:new, :edit] do
         (resources :locations, :only => [:index, :show]) if SETTINGS[:locations_enabled]
         (resources :organizations, :only => [:index, :show]) if SETTINGS[:organizations_enabled]

data/db/migrate/20150826191632_create_target_remote_execution_proxies.rb

@@ -0,0 +1,14 @@
+class CreateTargetRemoteExecutionProxies < ActiveRecord::Migration
+  def change
+    create_table :target_remote_execution_proxies do |t|
+      t.integer :remote_execution_proxy_id
+      t.integer :target_id
+      t.string :target_type
+
+      t.timestamps
+    end
+
+    add_index :target_remote_execution_proxies, :remote_execution_proxy_id, :name => 'target_remote_execution_proxies_proxy_id'
+    add_index :target_remote_execution_proxies, [:target_id, :target_type], :name => 'target_remote_execution_proxies_target_id_target_type'
+  end
+end

data/db/migrate/20150903192731_add_execution_to_interface.rb

@@ -0,0 +1,22 @@
+class FakeNic < ActiveRecord::Base
+  self.table_name = 'nics'
+
+  def type
+    Nic::Managed
+  end
+end
+
+class AddExecutionToInterface < ActiveRecord::Migration
+  def up
+    add_column :nics, :execution, :boolean, :default => false
+
+    FakeNic.reset_column_information
+    FakeNic.all.each do |nic|
+      nic.update_column(:execution, true) if nic.primary
+    end
+  end
+
+  def down
+    remove_column :nics, :execution
+  end
+end

data/doc/source/design/index.md

@@ -1315,3 +1315,8 @@ package "Developer API" {
 }
 
 {% endplantuml %}
+
+Wireframes
+===========
+
+Here are [wireframes PDF](/foreman_remote_execution/design/wireframes.pdf) from 2015-08-14 which we follow where underlaying backends allow us.

data/lib/foreman_remote_execution.rb

@@ -1,5 +1,5 @@
+require 'deface'
 require 'foreman-tasks'
-
 require 'foreman_remote_execution/engine'
 
 module ForemanRemoteExecution

data/lib/foreman_remote_execution/engine.rb

@@ -42,10 +42,10 @@ module ForemanRemoteExecution
           permission :destroy_job_templates, { :job_templates => [:destroy],
                                                :'api/v2/job_templates' => [:destroy] }, :resource_type => 'JobTemplate'
           permission :lock_job_templates, { :job_templates => [:lock, :unlock] }, :resource_type => 'JobTemplate'
-
-          permission :view_job_invocations, { :job_invocations => [:index, :show, :auto_complete_search] }, :resource_type => 'JobInvocation'
-
-          permission :create_job_invocations, { :job_invocations => [:new, :create, :refresh, :rerun] }, :resource_type => 'JobInvocation'
+          permission :create_job_invocations, { :job_invocations => [:new, :create, :refresh, :rerun],
+                                                'api/v2/job_invocations' => [:create] }, :resource_type => 'JobInvocation'
+          permission :view_job_invocations, { :job_invocations => [:index, :show, :auto_complete_search], :template_invocations => [:show],
+                                              'api/v2/job_invocations' => [:index, :show] }, :resource_type => 'JobInvocation'
         end
 
         # Add a new role called 'ForemanRemoteExecution' if it doesn't exist
@@ -100,14 +100,23 @@ module ForemanRemoteExecution
       # similarly, attr_accessible :template_inputs_attributes does not work with STI
       (Template.descendants + [Template]).each { |klass| klass.send(:include, ForemanRemoteExecution::TemplateExtensions) }
 
+      (Taxonomy.descendants + [Taxonomy]).each { |klass| klass.send(:include, ForemanRemoteExecution::TaxonomyExtensions) }
+
       User.send(:include, ForemanRemoteExecution::UserExtensions)
       (Host::Base.descendants + [Host::Base]).each do |klass|
         klass.send(:include, ForemanRemoteExecution::HostExtensions)
         klass.send(:include, ForemanTasks::Concerns::HostActionSubject)
       end
+
+      (Nic::Base.descendants + [Nic::Base]).each do |klass|
+        klass.send(:include, ForemanRemoteExecution::NicExtensions)
+      end
+
       Bookmark.send(:include, ForemanRemoteExecution::BookmarkExtensions)
       HostsHelper.send(:include, ForemanRemoteExecution::HostsHelperExtensions)
 
+      Subnet.send(:include, ForemanRemoteExecution::SubnetExtensions)
+
       # We need to explicitly force to load the Task model due to Rails loader
       # having issues with resolving it to Rake::Task otherwise
       require_dependency 'foreman_tasks/task'

data/lib/foreman_remote_execution/version.rb

@@ -1,3 +1,3 @@
 module ForemanRemoteExecution
-  VERSION = '0.0.6'
+  VERSION = '0.0.7'
 end

data/test/factories/foreman_remote_execution_factories.rb

@@ -1,6 +1,8 @@
 FactoryGirl.define do
+
   factory :job_template do |f|
     f.sequence(:name) { |n| "Job template #{n}" }
+    sequence(:job_name) { |n| "job name #{n}" }
     f.template 'id'
     f.provider_type 'Ssh'
 
@@ -13,7 +15,7 @@ FactoryGirl.define do
 
   factory :template_input do |f|
     f.sequence(:name) { |n| "Template input #{n}" }
-    f.input_type TemplateInput::TYPES.keys.first
+    f.input_type 'user'
   end
 
   factory :targeting do |f|
@@ -46,3 +48,46 @@ FactoryGirl.define do
     f.sequence(:value) { |n| "Input Value #{n}" }
   end
 end
+
+FactoryGirl.modify do
+  factory :feature do
+    trait :ssh do
+      name 'Ssh'
+    end
+  end
+
+  factory :smart_proxy do
+    trait :ssh do
+      features { [FactoryGirl.build(:feature, :ssh)] }
+    end
+  end
+
+  factory :subnet do
+    trait :execution do
+      remote_execution_proxies { [FactoryGirl.build(:smart_proxy, :ssh)] }
+    end
+  end
+
+  factory :host do
+    trait :with_execution do
+      managed
+      domain
+      subnet do
+        overrides = {
+          :remote_execution_proxies => [FactoryGirl.create(:smart_proxy, :ssh)]
+        }
+
+        overrides[:locations] = [location] unless location.nil?
+        overrides[:organizations] = [organization] unless organization.nil?
+
+        FactoryGirl.create(
+          :subnet,
+          overrides
+        )
+      end
+      interfaces do
+        [FactoryGirl.build(:nic_primary_and_provision, :ip => subnet.network.sub(/0\Z/, '1'), :execution => true)]
+      end
+    end
+  end
+end

data/test/functional/api/v2/job_invocations_controller_test.rb

@@ -0,0 +1,45 @@
+require 'test_plugin_helper'
+
+module Api
+  module V2
+    class JobInvocationsControllerTest < ActionController::TestCase
+      setup do
+        @invocation = FactoryGirl.create(:job_invocation, :with_template)
+        @template = FactoryGirl.create(:job_template, :with_input)
+      end
+
+      test "should get index" do
+        get :index
+        invocations = ActiveSupport::JSON.decode(@response.body)
+        refute_empty invocations, "Should response with invocation"
+        assert_response :success
+      end
+
+      test "should get invocation detail" do
+        get :show,  :id => @invocation.id
+        assert_response :success
+        template = ActiveSupport::JSON.decode(@response.body)
+        refute_empty template
+        assert_equal template["job_name"], @invocation.job_name
+      end
+
+      test "should create valid without template_id" do
+        attrs = { :job_name => @template.job_name, :name => 'RandomName', :targeting_type => 'static_query', :search_query => "foobar"}
+        post :create,  :job_invocation => attrs
+
+        invocation = ActiveSupport::JSON.decode(@response.body)
+        assert_equal attrs[:job_name], invocation['job_name']
+        assert_response 200
+      end
+
+      test "should create valid with template_id" do
+        attrs = { :job_name => @template.job_name, :name => 'RandomName', :template_id => @template.id,:targeting_type => 'static_query', :search_query => "foobar"}
+        post :create,  :job_invocation => attrs
+
+        invocation = ActiveSupport::JSON.decode(@response.body)
+        assert_equal attrs[:job_name], invocation['job_name']
+        assert_response 200
+      end
+    end
+  end
+end

data/test/test_plugin_helper.rb

@@ -6,3 +6,21 @@ require 'dynflow/testing'
 # Add plugin to FactoryGirl's paths
 FactoryGirl.definition_file_paths << File.join(File.dirname(__FILE__), 'factories')
 FactoryGirl.reload
+
+# Foreman's setup doesn't handle cleaning up for Minitest::Spec
+DatabaseCleaner.strategy = :transaction
+
+class Minitest::Spec
+  class << self
+    alias_method :context, :describe
+  end
+
+  before :each do
+    DatabaseCleaner.start
+    Setting::RemoteExecution.load_defaults
+  end
+
+  after :each do
+    DatabaseCleaner.clean
+  end
+end

data/test/unit/actions/run_hosts_job_test.rb

@@ -2,28 +2,27 @@
 require "test_plugin_helper"
 
 module ForemanRemoteExecution
-  class RunHostsJobTest <  ActiveSupport::TestCase
+  class RunHostsJobTest < ActiveSupport::TestCase
     include Dynflow::Testing
 
-    let(:proxy) { FactoryGirl.build(:smart_proxy) }
-    let(:hostname) { 'myhost.example.com' }
-    let(:script) { 'ping -c 5 redhat.com' }
+    let(:host) { FactoryGirl.create(:host, :with_execution) }
+    let(:proxy) { host.remote_execution_proxies('Ssh')[:subnet].first }
     let(:targeting) { FactoryGirl.create(:targeting, :search_query => "name = #{host.name}", :user => User.current) }
     let(:job_invocation) do
-      FactoryGirl.build(:job_invocation).tap do |invocation|
+      FactoryGirl.build(:job_invocation, :with_template).tap do |invocation|
         invocation.targeting = targeting
         invocation.save
       end
     end
-    let(:host) { FactoryGirl.create(:host) }
     let(:action) do
       action = create_action(Actions::RemoteExecution::RunHostsJob)
       action.expects(:action_subject).with(job_invocation)
-      action.expects(:task).returns(OpenStruct.new(:id => '123'))
+      ForemanTasks::Task::DynflowTask.stubs(:find_by_external_id!).returns(OpenStruct.new(:id => '123'))
       plan_action(action, job_invocation)
     end
 
     before do
+      ProxyAPI::ForemanDynflow::DynflowProxy.any_instance.stubs(:tasks_count).returns(0)
       User.current = users :admin
       action
     end
@@ -33,8 +32,14 @@ module ForemanRemoteExecution
     end
 
     it 'triggers the RunHostJob actions on the resolved hosts in run phase' do
-      action.expects(:trigger).with(Actions::RemoteExecution::RunHostJob, job_invocation, host)
+      template_invocation = job_invocation.template_invocation_for_host(host)
+      action.expects(:trigger).with(Actions::RemoteExecution::RunHostJob, job_invocation, host, template_invocation, proxy, {})
       action.create_sub_plans
     end
+
+    it 'uses the BindJobInvocation middleware' do
+      action
+      job_invocation.last_task_id.must_equal '123'
+    end
   end
 end

data/test/unit/actions/run_proxy_command_test.rb

@@ -1,21 +1,25 @@
 require "test_plugin_helper"
 
 module ForemanRemoteExecution
-  class RunProxyCommandTest <  ActiveSupport::TestCase
+  class RunProxyCommandTest < ActiveSupport::TestCase
     include Dynflow::Testing
 
-    let(:proxy) { FactoryGirl.build(:smart_proxy) }
+    let(:host) { FactoryGirl.build(:host, :with_execution) }
+    let(:proxy) { host.remote_execution_proxies('Ssh')[:subnet].first }
     let(:hostname) { 'myhost.example.com' }
     let(:script) { 'ping -c 5 redhat.com' }
+    let(:connection_options) { { 'retry_interval' => 15, 'retry_count' => 4, 'timeout' => 60 } }
     let(:action) do
-      create_and_plan_action(Actions::RemoteExecution::RunProxyCommand, proxy, hostname, script)
+      create_and_plan_action(Actions::RemoteExecution::RunProxyCommand, proxy, host.name, script)
     end
+    let(:timestamp) { 1_443_194_805.9192207 }
 
     it 'plans for running the command action on server' do
-      assert_run_phase action, { :hostname       => hostname,
+      assert_run_phase action, { :hostname       => host.name,
                                  :script         => script,
                                  :proxy_url      => proxy.url,
-                                 :effective_user => nil }
+                                 :effective_user => nil,
+                                 :connection_options => connection_options }
     end
 
     it 'sends to command to ssh provider' do
@@ -26,5 +30,105 @@ module ForemanRemoteExecution
       action.rescue_strategy.must_equal ::Dynflow::Action::Rescue::Skip
     end
 
+    describe '#live_output' do
+      let(:task) { ForemanTasks::Task.new }
+
+      let(:action) do
+        planned_action = create_and_plan_action(Actions::RemoteExecution::RunProxyCommand, proxy, hostname, script)
+        create_action_presentation(Actions::RemoteExecution::RunProxyCommand).tap do |action|
+          action.stubs(:task).returns(task)
+          action.stubs(:proxy).returns(ProxyAPI::ForemanDynflow::DynflowProxy.new(:url => proxy.url))
+          action.instance_variable_set('@input', planned_action.input)
+          action.output.merge!(:proxy_task_id => '123')
+        end
+      end
+
+      let(:live_output) do
+        action.live_output
+      end
+
+      describe 'when the task is finished' do
+        before do
+          task.state = 'stopped'
+          task.ended_at = timestamp + 1
+        end
+
+        describe 'the task finished sucessfully' do
+          before do
+            action.output.merge!(:proxy_output => { :result => [{ 'output_type' => 'stdout', 'output' => 'Hello', 'timestamp' => timestamp}],
+                                                    :exit_status => 0 })
+          end
+
+          it "doesn't fetch data from proxy anymore" do
+            action.proxy.expects(:status_of_task).never
+            live_output.size.must_equal 2
+            live_output[0]['output_type'].must_equal 'stdout'
+            live_output[0]['output'].must_equal 'Hello'
+            live_output[0]['timestamp'].must_be_kind_of Float
+            live_output[1]['output_type'].must_equal 'stdout'
+            live_output[1]['output'].must_equal 'Exit status: 0'
+            live_output[1]['timestamp'].must_be_kind_of Float
+          end
+        end
+
+        describe 'there was not output data from proxy' do
+          before do
+            action.output.merge!(:proxy_output => {})
+          end
+
+          it "doesn't fetch data from proxy anymore" do
+            action.proxy.expects(:status_of_task).never
+            live_output.size.must_equal 1
+            live_output[0]['output_type'].must_equal 'debug'
+            live_output[0]['output'].must_equal 'No output'
+            live_output[0]['timestamp'].must_be_kind_of Float
+          end
+        end
+      end
+
+      describe 'when something went wrong while fetching the data' do
+        before do
+          action.proxy.expects(:status_of_task).raises("Something went wrong")
+        end
+
+        it "reports the failure as part of the live output" do
+          live_output.size.must_equal 1
+          live_output.first['output_type'].must_equal 'debug'
+          live_output.first['output'].must_equal 'Error loading data from proxy: RuntimeError - Something went wrong'
+          live_output.first['timestamp'].must_be_kind_of Float
+        end
+      end
+
+      describe 'when there was some connection error while running the command' do
+        before do
+          action.output.merge!(:proxy_task_id => nil,
+                               :metadata => { :failed_proxy_tasks => [action.send(:format_exception, RuntimeError.new('Connection error'))]})
+        end
+
+        it "reports the failure as part of the live output" do
+          live_output.size.must_equal 1
+          live_output.first['output_type'].must_equal 'debug'
+          live_output.first['output'].must_equal 'Initialization error: RuntimeError - Connection error'
+          live_output.first['timestamp'].must_be_kind_of Float
+        end
+      end
+
+      describe 'when proxy returns valid data' do
+        before do
+          action.proxy.expects(:status_of_task).returns('actions' =>
+                                                        [{ 'class' => 'Proxy::RemoteExecution::Ssh::CommandAction',
+                                                           'output' => { 'result' => [ { 'output_type' => 'stdout',
+                                                                                         'output' => 'Hello',
+                                                                                         'timestamp' => timestamp }]}}])
+        end
+
+        it "reports the failure as part of the live output" do
+          live_output.size.must_equal 1
+          live_output.first['output_type'].must_equal 'stdout'
+          live_output.first['output'].must_equal 'Hello'
+          live_output.first['timestamp'].must_be_kind_of Float
+        end
+      end
+    end
   end
 end

data/test/unit/concerns/host_extensions_test.rb

@@ -0,0 +1,90 @@
+require 'test_plugin_helper'
+
+describe ForemanRemoteExecution::HostExtensions do
+  let(:provider) { 'Ssh' }
+
+  before do
+    User.current = FactoryGirl.build(:user, :admin)
+  end
+
+  after { User.current = nil }
+
+  context 'host has multiple nics' do
+    let(:host) { FactoryGirl.build(:host, :with_execution) }
+
+    it 'should only have one execution interface' do
+      host.interfaces << FactoryGirl.build(:nic_managed)
+      host.interfaces.each { |interface| interface.execution = true }
+      host.wont_be :valid?
+    end
+
+    it 'returns the execution interface' do
+      host.execution_interface.must_be_kind_of Nic::Managed
+    end
+  end
+
+  describe 'proxy determination strategies' do
+    context 'subnet strategy' do
+      let(:host) { FactoryGirl.build(:host, :with_execution) }
+      it { host.remote_execution_proxies(provider)[:subnet].must_include host.subnet.remote_execution_proxies.first }
+    end
+
+    context 'fallback strategy' do
+      let(:host) { FactoryGirl.build(:host, :with_puppet) }
+
+      context 'enabled' do
+        before do
+          Setting[:remote_execution_fallback_proxy] = true
+          host.puppet_proxy.features << FactoryGirl.create(:feature, :ssh)
+        end
+
+        it 'returns a fallback proxy' do
+          host.remote_execution_proxies(provider)[:fallback].must_include host.puppet_proxy
+        end
+      end
+
+      context 'disabled' do
+        before do
+          Setting[:remote_execution_fallback_proxy] = false
+          host.puppet_proxy.features << FactoryGirl.create(:feature, :ssh)
+        end
+
+        it 'returns no proxy' do
+          host.remote_execution_proxies(provider)[:fallback].must_be_empty
+        end
+      end
+    end
+
+    context 'global strategy' do
+      let(:organization) { FactoryGirl.build(:organization) }
+      let(:location) { FactoryGirl.build(:location) }
+      let(:host) { FactoryGirl.build(:host, :organization => organization, :location => location) }
+      let(:proxy_in_taxonomies) { FactoryGirl.create(:smart_proxy, :ssh, :organizations => [organization], :locations => [location]) }
+      let(:proxy_no_taxonomies) { FactoryGirl.create(:smart_proxy, :ssh) }
+
+      context 'enabled' do
+        before { Setting[:remote_execution_global_proxy] = true }
+
+        it 'returns correct proxies confined by taxonomies' do
+          proxy_in_taxonomies
+          proxy_no_taxonomies
+          host.remote_execution_proxies(provider)[:global].must_include proxy_in_taxonomies
+          host.remote_execution_proxies(provider)[:global].wont_include proxy_no_taxonomies
+        end
+
+        it 'returns all proxies when there\'s no taxonomies' do
+          Taxonomy.stubs(:enabled_taxonomies).returns([])
+          host.remote_execution_proxies(provider)[:global].must_include proxy_in_taxonomies
+          host.remote_execution_proxies(provider)[:global].must_include proxy_no_taxonomies
+        end
+      end
+
+      context 'disabled' do
+        before { Setting[:remote_execution_global_proxy] = false }
+        it 'returns no proxy' do
+          host.remote_execution_proxies(provider)[:global].must_be_empty
+        end
+      end
+    end
+  end
+end