foreman_remote_execution 4.6.0 → 5.0.1

data/test/unit/job_invocation_test.rb

@@ -10,7 +10,7 @@ class JobInvocationTest < ActiveSupport::TestCase
     end
 
     it 'is able to perform search through job invocations' do
-      found_jobs = JobInvocation.search_for(%{job_category = "#{job_invocation.job_category}"}).paginate(:page => 1).with_task.order('job_invocations.id DESC')
+      found_jobs = JobInvocation.search_for(%{job_category = "#{job_invocation.job_category}"}).paginate(:page => 1).order('job_invocations.id DESC')
       _(found_jobs).must_equal [job_invocation]
     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

@@ -1,28 +1,96 @@
+/* eslint-disable camelcase */
 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(response => {
-    const responseJob = response.data;
-    setAdvancedValues({
-      effectiveUserValue: responseJob.effective_user?.value || '',
-      timeoutToKill: responseJob.job_template.execution_timeout_interval || '',
-    });
-  }, []);
+  const setDefaults = useCallback(
+    ({
+      data: {
+        template_inputs,
+        advanced_template_inputs,
+        effective_user,
+        job_template: { name, execution_timeout_interval, description_format },
+      },
+    }) => {
+      const advancedTemplateValues = {};
+      const defaultTemplateValues = {};
+      const inputs = template_inputs;
+      const advancedInputs = advanced_template_inputs;
+      if (inputs) {
+        setTemplateValues(() => {
+          inputs.forEach(input => {
+            defaultTemplateValues[input.name] = input?.default || '';
+          });
+          return defaultTemplateValues;
+        });
+      }
+      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,
+        };
+      });
+    },
+    []
+  );
   useEffect(() => {
     if (jobTemplateID) {
       dispatch(
@@ -35,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}
@@ -48,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}
@@ -65,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: <p>Schedule</p>,
-      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()}
@@ -89,6 +210,19 @@ export const JobWizard = () => {
       steps={steps}
       height="100%"
       className="job-wizard"
+      onSave={() => {
+        submit({
+          jobTemplateID,
+          templateValues,
+          advancedValues,
+          scheduleValue,
+          dispatch,
+          selectedTargets,
+          hostsSearchQuery,
+          location,
+          organization,
+        });
+      }}
     />
   );
 };

data/webpack/JobWizard/JobWizard.scss

@@ -1,14 +1,106 @@
 .job-wizard {
+  .wizard-title {
+    margin-bottom: 25px;
+  }
+
+  .pf-c-wizard__nav.pf-m-expanded {
+    z-index: calc(
+      var(--pf-c-wizard__footer--ZIndex) + 2
+    ); // So the small screen navigation can be shown above the select box
+  }
+
   .pf-c-wizard__main {
+    overflow: visible;
     z-index: calc(
       var(--pf-c-wizard__footer--ZIndex) + 1
     ); // So the select box can be shown above the wizard footer
   }
-
+  .pf-c-wizard__nav {
+    z-index: calc(
+      var(--pf-c-wizard__footer--ZIndex) + 2
+    ); // So the navigation box can be shown above the wizard body
+  }
   .pf-c-wizard__main-body {
     max-width: 500px;
     .advanced-fields-title {
       margin-bottom: 10px;
     }
+
+  }
+
+  .gray-text {
+    color: var(--pf-global--Color--dark-200);
+  }
+
+  .target-hosts-and-inputs {
+    .hosts-chip-group {
+      margin-top: 8px;
+      float: left;
+      clear: left;
+      display: block;
+    }
+    .clear-chips {
+      margin-top: 8px;
+    }
+    .pf-c-select__toggle-typeahead {
+      border: 0px;
+    }
+
+    .target-method-select {
+      .pf-c-select__toggle-wrapper {
+        flex-wrap: nowrap;
+      }
+    }
+  }
+  input[type='radio'],
+  input[type='checkbox'] {
+    margin: 0;
+  }
+  .schedule-tab {
+    .advanced-scheduling-button {
+      text-align: start;
+    }
+    #repeat-on-weekly {
+      display: grid;
+      grid-template-columns: repeat(7, 1fr);
+    }
+    .pf-l-grid {
+      gap: var(--pf-c-form--GridGap);
+    }
+    #repeat-on-hourly {
+      max-height: 300px;
+      overflow: scroll;
+    }
+  }
+
+  .pf-c-date-picker {
+    vertical-align: top;
+  }
+
+  .time-picker {
+    width: 150px;
+  }
+
+  input[type='radio'],
+  input[type='checkbox'] {
+    // overwriting bootstrap/_forms.scss margin: 4px 0 0;
+    margin: 0;
+  }
+  textarea {
+    min-height: 40px;
+    min-width: 100px;
+  }
+  #host-selection {
+    width: 500px;
+  }
+
+  .pf-c-modal-box {
+    width: auto;
+  }
+
+  .review-details {
+    .advanced-fields {
+      margin-left: 10px;
+    }
   }
 }

data/webpack/JobWizard/JobWizardConstants.js

@@ -1,6 +1,60 @@
+import { translate as __ } from 'foremanReact/common/I18n';
 import { foremanUrl } from 'foremanReact/common/helpers';
 
 export const JOB_TEMPLATES = 'JOB_TEMPLATES';
 export const JOB_CATEGORIES = 'JOB_CATEGORIES';
 export const JOB_TEMPLATE = 'JOB_TEMPLATE';
+export const JOB_INVOCATION = 'JOB_INVOCATION';
 export const templatesUrl = foremanUrl('/api/v2/job_templates');
+
+export const repeatTypes = {
+  noRepeat: __('Does not repeat'),
+  cronline: __('Cronline'),
+  monthly: __('Monthly'),
+  weekly: __('Weekly'),
+  daily: __('Daily'),
+  hourly: __('Hourly'),
+};
+
+export const WIZARD_TITLES = {
+  categoryAndTemplate: __('Category and Template'),
+  hostsAndInputs: __('Target hosts and inputs'),
+  advanced: __('Advanced Fields'),
+  schedule: __('Schedule'),
+  review: __('Review Details'),
+};
+
+export const initialScheduleState = {
+  repeatType: repeatTypes.noRepeat,
+  repeatAmount: '',
+  repeatData: {},
+  startsAt: '',
+  startsBefore: '',
+  ends: '',
+  isFuture: false,
+  isNeverEnds: false,
+  isTypeStatic: true,
+  purpose: '',
+};
+export const HOSTS_API = 'HOSTS_API';
+export const HOSTS = 'HOSTS';
+export const HOST_COLLECTIONS = 'HOST_COLLECTIONS';
+export const HOST_GROUPS = 'HOST_GROUPS';
+export const hostMethods = {
+  hosts: __('Hosts'),
+  hostCollections: __('Host collections'),
+  hostGroups: __('Host groups'),
+  searchQuery: __('Search query'),
+};
+
+export const hostQuerySearchID = 'searchBar'; // until https://projects.theforeman.org/issues/33737 is used
+export const hostsController = 'hosts';
+
+export const dataName = {
+  [HOSTS]: 'hosts',
+  [HOST_GROUPS]: 'hostgroups',
+};
+export const HOSTS_TO_PREVIEW_AMOUNT = 20;
+
+export const DEBOUNCE_HOST_COUNT = 700;
+export const HOST_IDS = 'HOST_IDS';

data/webpack/JobWizard/JobWizardSelectors.js

@@ -1,13 +1,18 @@
+import URI from 'urijs';
 import {
   selectAPIResponse,
   selectAPIStatus,
   selectAPIErrorMessage,
 } from 'foremanReact/redux/API/APISelectors';
+import { STATUS } from 'foremanReact/constants';
+import { selectRouterLocation } from 'foremanReact/routes/RouterSelector';
 
 import {
   JOB_TEMPLATES,
   JOB_CATEGORIES,
   JOB_TEMPLATE,
+  HOSTS_API,
+  JOB_INVOCATION,
 } from './JobWizardConstants';
 
 export const selectJobTemplatesStatus = state =>
@@ -22,6 +27,9 @@ export const selectJobTemplates = state =>
 export const selectJobCategories = state =>
   selectAPIResponse(state, JOB_CATEGORIES).job_categories || [];
 
+export const selectWithKatello = state =>
+  selectAPIResponse(state, JOB_CATEGORIES).with_katello || false;
+
 export const selectJobCategoriesStatus = state =>
   selectAPIStatus(state, JOB_CATEGORIES);
 
@@ -36,3 +44,36 @@ export const selectTemplateError = state =>
 
 export const selectJobTemplate = state =>
   selectAPIResponse(state, JOB_TEMPLATE);
+
+export const selectEffectiveUser = state =>
+  selectAPIResponse(state, JOB_TEMPLATE).effective_user;
+
+export const selectAdvancedTemplateInputs = state =>
+  selectAPIResponse(state, JOB_TEMPLATE).advanced_template_inputs || [];
+
+export const selectTemplateInputs = state =>
+  selectAPIResponse(state, JOB_TEMPLATE).template_inputs || [];
+
+export const selectHostCount = state =>
+  selectAPIResponse(state, HOSTS_API).subtotal || 0;
+
+export const selectHosts = state =>
+  (selectAPIResponse(state, HOSTS_API).results || []).map(host => host.name);
+
+export const selectIsLoadingHosts = state =>
+  !selectAPIStatus(state, HOSTS_API) ||
+  selectAPIStatus(state, HOSTS_API) === STATUS.PENDING;
+
+export const selectResponse = selectAPIResponse;
+
+export const selectIsLoading = (state, key) =>
+  selectAPIStatus(state, key) === STATUS.PENDING;
+
+export const selectIsSubmitting = state =>
+  selectAPIStatus(state, JOB_INVOCATION) === STATUS.PENDING ||
+  selectAPIStatus(state, JOB_INVOCATION) === STATUS.RESOLVED;
+
+export const selectRouterSearch = state => {
+  const { search } = selectRouterLocation(state);
+  return URI.parseQuery(search);
+};