foreman_remote_execution 4.7.0 → 5.0.2

data/test/unit/concerns/host_extensions_test.rb

@@ -1,9 +1,6 @@
 require 'test_plugin_helper'
 
 class ForemanRemoteExecutionHostExtensionsTest < ActiveSupport::TestCase
-  before do
-    Setting::RemoteExecution.load_defaults
-  end
   let(:provider) { 'SSH' }
 
   before { User.current = FactoryBot.build(:user, :admin) }
@@ -182,4 +179,40 @@ class ForemanRemoteExecutionHostExtensionsTest < ActiveSupport::TestCase
       end
     end
   end
+
+  describe '#execution_scope' do
+    let(:host) { FactoryBot.create(:host) }
+    let(:infra_host) { FactoryBot.create(:host, :with_infrastructure_facet) }
+
+    before do
+      host
+      infra_host
+    end
+
+    context 'without infrastructure host permission' do
+      it 'omits the infrastructure host' do
+        setup_user('view', 'hosts')
+
+        hosts = ::Host::Managed.execution_scope
+        hosts.must_include host
+        hosts.wont_include infra_host
+      end
+    end
+
+    context 'with infrastructure host permission' do
+      it 'finds the host as admin' do
+        assert User.current.admin?
+        hosts = ::Host::Managed.execution_scope
+        hosts.must_include host
+        hosts.must_include infra_host
+      end
+
+      it 'finds the host as user with needed permissions' do
+        setup_user('execute_jobs_on', 'infrastructure_hosts')
+        hosts = ::Host::Managed.execution_scope
+        hosts.must_include host
+        hosts.must_include infra_host
+      end
+    end
+  end
 end

data/test/unit/job_invocation_composer_test.rb

@@ -270,10 +270,6 @@ class JobInvocationComposerTest < ActiveSupport::TestCase
           composer.pattern_template_invocations.first
         end
 
-        before do
-          Setting::RemoteExecution.load_defaults
-        end
-
         context 'when overridable and provided' do
           let(:overridable) { true }
           let(:invocation_effective_user) { 'invocation user' }
@@ -370,8 +366,10 @@ class JobInvocationComposerTest < ActiveSupport::TestCase
         let(:host) { FactoryBot.create(:host) }
 
         it 'obeys authorization' do
+          fake_scope = mock
           composer.stubs(:displayed_search_query => "name = #{host.name}")
-          Host.expects(:authorized).with(:view_hosts, Host).returns(Host.where({}))
+          Host.expects(:execution_scope).returns(fake_scope)
+          fake_scope.expects(:authorized).with(:view_hosts, Host).returns(Host.where({}))
           composer.targeted_hosts_count
         end
 

data/test/unit/job_invocation_report_template_test.rb

@@ -19,7 +19,7 @@ class JobReportTemplateTest < ActiveSupport::TestCase
       it 'in settings includes only report templates with job_id input' do
         FactoryBot.create(:report_template, name: 'Template 1')
         job_invocation_template
-        templates = Setting::RemoteExecution.job_invocation_report_templates_select
+        templates = ForemanRemoteExecution.job_invocation_report_templates_select
 
         assert_include templates, 'Job Invocation Report Template'
       end
@@ -28,15 +28,16 @@ class JobReportTemplateTest < ActiveSupport::TestCase
     describe 'task reporting' do
       let(:fake_outputs) do
         [
-          { 'output_type' => 'stderr', 'output' => "error", 'timestamp' => Time.new(2020, 12, 1, 0, 0, 0).utc },
-          { 'output_type' => 'stdout', 'output' => "output", 'timestamp' => Time.new(2020, 12, 1, 0, 0, 0).utc },
-          { 'output_type' => 'stdebug', 'output' => "debug", 'timestamp' => Time.new(2020, 12, 1, 0, 0, 0).utc },
+          { 'output_type' => 'stderr', 'output' => "error" },
+          { 'output_type' => 'stdout', 'output' => "output" },
+          { 'output_type' => 'debug', 'output' => "debug" },
         ]
       end
-      let(:fake_task) { FakeTask.new(result: 'success', action_continuous_output: fake_outputs) }
+      let(:fake_task) { FakeTask.new(result: 'success', action_continuous_output: fake_outputs, :ended_at => Time.new(2020, 12, 1, 0, 0, 0).utc) }
+      let(:job_invocation) { FactoryBot.create(:job_invocation, :with_task) }
+      let(:host) { job_invocation.template_invocations.first.host }
 
       it 'should render task outputs' do
-        job_invocation = FactoryBot.create(:job_invocation, :with_task)
         JobInvocation.any_instance.expects(:sub_task_for_host).returns(fake_task)
 
         input = job_invocation_template.template_inputs.first
@@ -44,13 +45,15 @@ class JobReportTemplateTest < ActiveSupport::TestCase
         result = ReportComposer.new(composer_params).render
 
         # parsing the CSV result
-        CSV.parse(result.strip, headers: true).each_with_index do |row, i|
-          row_hash = row.to_h
-          assert_equal 'success', row_hash['result']
-          assert_equal fake_outputs[i]['output_type'], row_hash['type']
-          assert_equal fake_outputs[i]['output'], row_hash['message']
-          assert_kind_of Time, Time.zone.parse(row_hash['time']), 'Parsing of time column failed'
-        end
+        rows = CSV.parse(result.strip, headers: true)
+        assert_equal 1, rows.count
+        row = rows.first
+        assert_equal host.name, row['Host']
+        assert_equal 'success', row['Result']
+        assert_equal 'error', row['stderr']
+        assert_equal 'output', row['stdout']
+        assert_equal 'debug', row['debug']
+        assert_kind_of Time, Time.zone.parse(row['Finished']), 'Parsing of time column failed'
       end
     end
   end

data/test/unit/job_template_effective_user_test.rb

@@ -4,10 +4,6 @@ class JobTemplateEffectiveUserTest < ActiveSupport::TestCase
   let(:job_template) { FactoryBot.build(:job_template, :job_category => '') }
   let(:effective_user) { job_template.effective_user }
 
-  before do
-    Setting::RemoteExecution.load_defaults
-  end
-
   describe 'by default' do
     it 'is overridable' do
       assert effective_user.overridable?

data/test/unit/remote_execution_provider_test.rb

@@ -50,14 +50,22 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
     end
   end
 
+  describe '.host_setting' do
+    let(:host) { FactoryBot.create(:host) }
+
+    it 'honors falsey values set as a host parameter' do
+      key = 'remote_execution_connect_by_ip'
+      Setting[key] = true
+      host.parameters << HostParameter.new(name: key, value: false)
+
+      refute RemoteExecutionProvider.host_setting(host, key)
+    end
+  end
+
   describe SSHExecutionProvider do
     before { User.current = FactoryBot.build(:user, :admin) }
     after { User.current = nil }
 
-    before do
-      Setting::RemoteExecution.load_defaults
-    end
-
     let(:job_invocation) { FactoryBot.create(:job_invocation, :with_template) }
     let(:template_invocation) { job_invocation.pattern_template_invocations.first }
     let(:host) { FactoryBot.create(:host) }
@@ -200,6 +208,40 @@ class RemoteExecutionProviderTest < ActiveSupport::TestCase
         host.interfaces.each(&:save)
         host.reload
         SSHExecutionProvider.find_ip_or_hostname(host).must_equal execution_interface.ip
+
+        # there is an execution interface with both IPv6 and IPv4: IPv4 is being preferred over IPv6 by default
+        execution_interface = FactoryBot.build(:nic_managed,
+          flags.merge(:execution => true, :ip => '10.0.0.4', :ip6 => 'fd00::4'))
+        host.interfaces = [execution_interface]
+        host.interfaces.each(&:save)
+        host.reload
+        SSHExecutionProvider.find_ip_or_hostname(host).must_equal execution_interface.ip
+      end
+
+      it 'gets ipv6 from flagged interfaces with IPv6 preference' do
+        host.host_params['remote_execution_connect_by_ip_prefer_ipv6'] = true
+        host.host_params['remote_execution_connect_by_ip'] = true
+
+        # there is an execution interface with both IPv6 and IPv4: IPv6 is being preferred over IPv4 by host parameter configuration
+        execution_interface = FactoryBot.build(:nic_managed,
+          flags.merge(:execution => true, :ip => '10.0.0.4', :ip6 => 'fd00::4'))
+        host.interfaces = [execution_interface]
+        host.interfaces.each(&:save)
+        host.reload
+        SSHExecutionProvider.find_ip_or_hostname(host).must_equal execution_interface.ip6
+      end
+
+      it 'gets ipv6 from flagged interfaces with IPv4 preference but without IPv4 address' do
+        host.host_params['remote_execution_connect_by_ip_prefer_ipv6'] = false
+        host.host_params['remote_execution_connect_by_ip'] = true
+
+        # there is an execution interface with both IPv6 and IPv4: IPv6 is being preferred over IPv4 by host parameter configuration
+        execution_interface = FactoryBot.build(:nic_managed,
+          flags.merge(:execution => true, :ip => nil, :ip6 => 'fd00::4'))
+        host.interfaces = [execution_interface]
+        host.interfaces.each(&:save)
+        host.reload
+        SSHExecutionProvider.find_ip_or_hostname(host).must_equal execution_interface.ip6
       end
     end
   end

data/test/unit/targeting_test.rb

@@ -77,24 +77,73 @@ class TargetingTest < ActiveSupport::TestCase
     it { _(targeting.reload.hosts).must_be_empty }
   end
 
+  describe '#resolve_hosts!' do
+    let(:second_host) { FactoryBot.create(:host) }
+    let(:infra_host) { FactoryBot.create(:host, :with_infrastructure_facet) }
+    let(:targeting) { FactoryBot.build(:targeting) }
+
+    before do
+      host
+      second_host
+      infra_host
+    end
+
+    context 'with infrastructure host permission' do
+      before do
+        setup_user('view', 'hosts')
+        setup_user('execute_jobs_on', 'infrastructure_hosts')
+      end
+
+      it 'resolves all hosts' do
+        hosts = [host, second_host, infra_host]
+        targeting.search_query = "name ^ (#{hosts.map(&:name).join(',')})"
+        targeting.user = User.current
+        targeting.resolve_hosts!
+
+        targeting.hosts.must_include host
+        targeting.hosts.must_include second_host
+        targeting.hosts.must_include infra_host
+      end
+    end
+
+    context 'without infrastructure host permission' do
+      before { setup_user('view', 'hosts') }
+
+      it 'ignores infrastructure hosts' do
+        hosts = [host, second_host, infra_host]
+        targeting.search_query = "name ^ (#{hosts.map(&:name).join(',')})"
+        targeting.user = User.current
+        targeting.resolve_hosts!
+
+        targeting.hosts.must_include host
+        targeting.hosts.must_include second_host
+        targeting.hosts.wont_include infra_host
+      end
+    end
+  end
+
   describe '#build_query_from_hosts(ids)' do
     let(:second_host) { FactoryBot.create(:host) }
+    let(:infra_host) { FactoryBot.create(:host, :with_infrastructure_facet) }
 
     before do
       host
       second_host
+      infra_host
     end
 
     context 'for two hosts' do
-      let(:query) { Targeting.build_query_from_hosts([ host.id, second_host.id ]) }
+      let(:query) { Targeting.build_query_from_hosts([ host.id, second_host.id, infra_host.id ]) }
 
       it 'builds query using host names joining inside ^' do
         _(query).must_include host.name
         _(query).must_include second_host.name
+        _(query).must_include infra_host.name
         _(query).must_include 'name ^'
 
         Host.search_for(query).must_include host
         Host.search_for(query).must_include second_host
+        Host.search_for(query).must_include infra_host
       end
     end
 
@@ -105,6 +154,7 @@ class TargetingTest < ActiveSupport::TestCase
         _(query).must_equal "name ^ (#{host.name})"
         Host.search_for(query).must_include host
         Host.search_for(query).wont_include second_host
+        Host.search_for(query).wont_include infra_host
       end
     end
 
@@ -114,6 +164,23 @@ class TargetingTest < ActiveSupport::TestCase
       it 'builds query to find all hosts' do
         Host.search_for(query).must_include host
         Host.search_for(query).must_include second_host
+        Host.search_for(query).must_include infra_host
+      end
+    end
+
+    context 'without infrastructure host permission' do
+      before { User.current = nil }
+
+      it 'ignores the infrastructure host' do
+        query = Targeting.build_query_from_hosts([host.id, second_host.id, infra_host.id])
+        _(query).must_include host.name
+        _(query).must_include second_host.name
+        _(query).wont_include infra_host.name
+        _(query).must_include 'name ^'
+
+        Host.search_for(query).must_include host
+        Host.search_for(query).must_include second_host
+        Host.search_for(query).wont_include infra_host
       end
     end
   end

data/webpack/JobWizard/JobWizard.js

@@ -3,43 +3,91 @@ import React, { useState, useEffect, useCallback } from 'react';
 import { useDispatch, useSelector } from 'react-redux';
 import { Wizard } from '@patternfly/react-core';
 import { get } from 'foremanReact/redux/API';
-import { translate as __ } from 'foremanReact/common/I18n';
 import history from 'foremanReact/history';
+
+import {
+  useForemanOrganization,
+  useForemanLocation,
+} from 'foremanReact/Root/Context/ForemanContext';
 import CategoryAndTemplate from './steps/CategoryAndTemplate/';
 import { AdvancedFields } from './steps/AdvancedFields/AdvancedFields';
-import { JOB_TEMPLATE } from './JobWizardConstants';
-import { selectTemplateError } from './JobWizardSelectors';
+import {
+  JOB_TEMPLATE,
+  WIZARD_TITLES,
+  initialScheduleState,
+} from './JobWizardConstants';
+import {
+  selectTemplateError,
+  selectJobTemplate,
+  selectIsSubmitting,
+} from './JobWizardSelectors';
 import Schedule from './steps/Schedule/';
+import HostsAndInputs from './steps/HostsAndInputs/';
+import ReviewDetails from './steps/ReviewDetails/';
+import { useValidation } from './validation';
+import { useAutoFill } from './autofill';
+import { submit } from './submit';
 import './JobWizard.scss';
 
 export const JobWizard = () => {
   const [jobTemplateID, setJobTemplateID] = useState(null);
   const [category, setCategory] = useState('');
-  const [advancedValues, setAdvancedValues] = useState({});
+  const [advancedValues, setAdvancedValues] = useState({ templateValues: {} });
+  const [templateValues, setTemplateValues] = useState({}); // TODO use templateValues in advanced fields - description https://github.com/theforeman/foreman_remote_execution/pull/605
+  const [scheduleValue, setScheduleValue] = useState(initialScheduleState);
+  const [selectedTargets, setSelectedTargets] = useState({
+    hosts: [],
+    hostCollections: [],
+    hostGroups: [],
+  });
+  const [hostsSearchQuery, setHostsSearchQuery] = useState('');
   const dispatch = useDispatch();
 
   const setDefaults = useCallback(
     ({
       data: {
+        template_inputs,
         advanced_template_inputs,
         effective_user,
-        job_template: { executionTimeoutInterval, description_format },
+        job_template: { name, execution_timeout_interval, description_format },
       },
     }) => {
       const advancedTemplateValues = {};
+      const defaultTemplateValues = {};
+      const inputs = template_inputs;
       const advancedInputs = advanced_template_inputs;
-      if (advancedInputs) {
-        advancedInputs.forEach(input => {
-          advancedTemplateValues[input.name] = input?.default || '';
+      if (inputs) {
+        setTemplateValues(() => {
+          inputs.forEach(input => {
+            defaultTemplateValues[input.name] = input?.default || '';
+          });
+          return defaultTemplateValues;
         });
       }
-      setAdvancedValues(currentAdvancedValues => ({
-        ...currentAdvancedValues,
-        effectiveUserValue: effective_user?.value || '',
-        timeoutToKill: executionTimeoutInterval || '',
-        templateValues: advancedTemplateValues,
-        description: description_format || '',
-      }));
+      setAdvancedValues(currentAdvancedValues => {
+        if (advancedInputs) {
+          advancedInputs.forEach(input => {
+            advancedTemplateValues[input.name] = input?.default || '';
+          });
+        }
+        const generateDefaultDescription = () => {
+          if (description_format) return description_format;
+          const allInputs = [...advancedInputs, ...inputs];
+          if (!allInputs.length) return name;
+          const inputsString = allInputs
+            .map(({ name: inputname }) => `${inputname}="%{${inputname}}"`)
+            .join(' ');
+          return `${name} with inputs ${inputsString}`;
+        };
+        return {
+          ...currentAdvancedValues,
+          effectiveUserValue: effective_user?.value || '',
+          timeoutToKill: execution_timeout_interval || '',
+          templateValues: advancedTemplateValues,
+          description: generateDefaultDescription() || '',
+          isRandomizedOrdering: false,
+        };
+      });
     },
     []
   );
@@ -55,11 +103,23 @@ export const JobWizard = () => {
     }
   }, [jobTemplateID, setDefaults, dispatch]);
 
+  const [valid, setValid] = useValidation({
+    advancedValues,
+    templateValues,
+  });
+  useAutoFill({
+    setSelectedTargets,
+    setHostsSearchQuery,
+  });
   const templateError = !!useSelector(selectTemplateError);
-  const isTemplate = !templateError && !!jobTemplateID;
+  const templateResponse = useSelector(selectJobTemplate);
+  const isSubmitting = useSelector(selectIsSubmitting);
+  const isTemplate =
+    !templateError && !!jobTemplateID && templateResponse.job_template;
+
   const steps = [
     {
-      name: __('Category and Template'),
+      name: WIZARD_TITLES.categoryAndTemplate,
       component: (
         <CategoryAndTemplate
           jobTemplate={jobTemplateID}
@@ -68,14 +128,25 @@ export const JobWizard = () => {
           setCategory={setCategory}
         />
       ),
+      enableNext: isTemplate,
     },
     {
-      name: __('Target Hosts'),
-      component: <p>Target Hosts</p>,
+      name: WIZARD_TITLES.hostsAndInputs,
+      component: (
+        <HostsAndInputs
+          templateValues={templateValues}
+          setTemplateValues={setTemplateValues}
+          selected={selectedTargets}
+          setSelected={setSelectedTargets}
+          hostsSearchQuery={hostsSearchQuery}
+          setHostsSearchQuery={setHostsSearchQuery}
+        />
+      ),
       canJumpTo: isTemplate,
+      enableNext: isTemplate && valid.hostsAndInputs,
     },
     {
-      name: __('Advanced Fields'),
+      name: WIZARD_TITLES.advanced,
       component: (
         <AdvancedFields
           advancedValues={advancedValues}
@@ -85,23 +156,53 @@ export const JobWizard = () => {
               ...newValues,
             }));
           }}
-          jobTemplateID={jobTemplateID}
+          templateValues={templateValues}
         />
       ),
-      canJumpTo: isTemplate,
+      canJumpTo: isTemplate && valid.hostsAndInputs,
+      enableNext: isTemplate && valid.hostsAndInputs && valid.advanced,
     },
     {
-      name: __('Schedule'),
-      component: <Schedule />,
-      canJumpTo: isTemplate,
+      name: WIZARD_TITLES.schedule,
+      component: (
+        <Schedule
+          scheduleValue={scheduleValue}
+          setScheduleValue={setScheduleValue}
+          setValid={newValue => {
+            setValid(currentValid => ({ ...currentValid, schedule: newValue }));
+          }}
+        />
+      ),
+      canJumpTo: isTemplate && valid.hostsAndInputs && valid.advanced,
+      enableNext:
+        isTemplate && valid.hostsAndInputs && valid.advanced && valid.schedule,
     },
     {
-      name: __('Review Details'),
-      component: <p>Review Details</p>,
+      name: WIZARD_TITLES.review,
+      component: (
+        <ReviewDetails
+          jobCategory={category}
+          jobTemplateID={jobTemplateID}
+          advancedValues={advancedValues}
+          scheduleValue={scheduleValue}
+          templateValues={templateValues}
+          selectedTargets={selectedTargets}
+          hostsSearchQuery={hostsSearchQuery}
+        />
+      ),
       nextButtonText: 'Run',
-      canJumpTo: isTemplate,
+      canJumpTo:
+        isTemplate && valid.hostsAndInputs && valid.advanced && valid.schedule,
+      enableNext:
+        isTemplate &&
+        valid.hostsAndInputs &&
+        valid.advanced &&
+        valid.schedule &&
+        !isSubmitting,
     },
   ];
+  const location = useForemanLocation();
+  const organization = useForemanOrganization();
   return (
     <Wizard
       onClose={() => history.goBack()}
@@ -109,6 +210,19 @@ export const JobWizard = () => {
       steps={steps}
       height="100%"
       className="job-wizard"
+      onSave={() => {
+        submit({
+          jobTemplateID,
+          templateValues,
+          advancedValues,
+          scheduleValue,
+          dispatch,
+          selectedTargets,
+          hostsSearchQuery,
+          location,
+          organization,
+        });
+      }}
     />
   );
 };