foreman_remote_execution 16.0.4 → 16.1.0

data/lib/foreman_remote_execution/plugin.rb

@@ -0,0 +1,240 @@
+Foreman::Plugin.register :foreman_remote_execution do
+  requires_foreman '>= 3.15'
+  register_global_js_file 'global'
+  register_gettext
+
+  apipie_documented_controllers ["#{ForemanRemoteExecution::Engine.root}/app/controllers/api/v2/*.rb"]
+  ApipieDSL.configuration.dsl_classes_matchers += [
+    "#{ForemanRemoteExecution::Engine.root}/app/lib/foreman_remote_execution/renderer/**/*.rb",
+  ]
+  automatic_assets(false)
+  precompile_assets(ForemanRemoteExecution::Engine.assets_to_precompile)
+
+  # Add settings to a Remote Execution category
+  settings do
+    category :remote_execution, N_('Remote Execution') do
+      setting 'remote_execution_fallback_proxy',
+        type: :boolean,
+        description: N_('Search the host for any proxy with Remote Execution, useful when the host has no subnet or the subnet does not have an execution proxy'),
+        default: false,
+        full_name: N_('Fallback to Any Proxy')
+      setting 'remote_execution_global_proxy',
+        type: :boolean,
+        description: N_('Search for remote execution proxy outside of the proxies assigned to the host. The search will be limited to the host\'s organization and location.'),
+        default: true,
+        full_name: N_('Enable Global Proxy')
+      setting 'remote_execution_ssh_user',
+        type: :string,
+        description: N_('Default user to use for SSH.  You may override per host by setting a parameter called remote_execution_ssh_user.'),
+        default: 'root',
+        full_name: N_('SSH User')
+      setting 'remote_execution_effective_user',
+        type: :string,
+        description: N_('Default user to use for executing the script. If the user differs from the SSH user, su or sudo is used to switch the user.'),
+        default: 'root',
+        full_name: N_('Effective User')
+      setting 'remote_execution_effective_user_method',
+        type: :string,
+        description: N_('What command should be used to switch to the effective user. One of %s') % ::ScriptExecutionProvider::EFFECTIVE_USER_METHODS.inspect,
+        default: 'sudo',
+        full_name: N_('Effective User Method'),
+        collection: proc { Hash[::ScriptExecutionProvider::EFFECTIVE_USER_METHODS.map { |method| [method, method] }] }
+      setting 'remote_execution_effective_user_password',
+        type: :string,
+        description: N_('Effective user password'),
+        default: '',
+        full_name: N_('Effective user password'),
+        encrypted: true
+      setting 'remote_execution_sync_templates',
+        type: :boolean,
+        description: N_('Whether we should sync templates from disk when running db:seed.'),
+        default: true,
+        full_name: N_('Sync Job Templates')
+      setting 'remote_execution_ssh_port',
+        type: :integer,
+        description: N_('Port to use for SSH communication. Default port 22. You may override per host by setting a parameter called remote_execution_ssh_port.'),
+        default: 22,
+        full_name: N_('SSH Port')
+      setting 'remote_execution_connect_by_ip',
+        type: :boolean,
+        description: N_('Should the ip addresses on host interfaces be preferred over the fqdn? '\
+                        'It is useful when DNS not resolving the fqdns properly. You may override this per host by setting a parameter called remote_execution_connect_by_ip. '\
+                        'For dual-stacked hosts you should consider the remote_execution_connect_by_ip_prefer_ipv6 setting'),
+        default: false,
+        full_name: N_('Connect by IP')
+      setting 'remote_execution_connect_by_ip_prefer_ipv6',
+        type: :boolean,
+        description: N_('When connecting using ip address, should the IPv6 addresses be preferred? '\
+                        'If no IPv6 address is set, it falls back to IPv4 automatically. You may override this per host by setting a parameter called remote_execution_connect_by_ip_prefer_ipv6. '\
+                        'By default and for compatibility, IPv4 will be preferred over IPv6 by default'),
+        default: false,
+        full_name: N_('Prefer IPv6 over IPv4')
+      setting 'remote_execution_ssh_password',
+        type: :string,
+        description: N_('Default password to use for SSH. You may override per host by setting a parameter called remote_execution_ssh_password'),
+        default: nil,
+        full_name: N_('Default SSH password'),
+        encrypted: true
+      setting 'remote_execution_ssh_key_passphrase',
+        type: :string,
+        description: N_('Default key passphrase to use for SSH. You may override per host by setting a parameter called remote_execution_ssh_key_passphrase'),
+        default: nil,
+        full_name: N_('Default SSH key passphrase'),
+        encrypted: true
+      setting 'remote_execution_cleanup_working_dirs',
+        type: :boolean,
+        description: N_('When enabled, working directories will be removed after task completion. You may override this per host by setting a parameter called remote_execution_cleanup_working_dirs.'),
+        default: true,
+        full_name: N_('Cleanup working directories')
+      setting 'remote_execution_cockpit_url',
+        type: :string,
+        description: N_('Where to find the Cockpit instance for the Web Console button.  By default, no button is shown.'),
+        default: nil,
+        full_name: N_('Cockpit URL')
+      setting 'remote_execution_form_job_template',
+        type: :string,
+        description: N_('Choose a job template that is pre-selected in job invocation form'),
+        default: 'Run Command - Script Default',
+        full_name: N_('Form Job Template'),
+        collection: proc { Hash[JobTemplate.unscoped.map { |template| [template.name, template.name] }] }
+      setting 'remote_execution_job_invocation_report_template',
+        type: :string,
+        description: N_('Select a report template used for generating a report for a particular remote execution job'),
+        default: 'Job - Invocation Report',
+        full_name: N_('Job Invocation Report Template'),
+        collection: proc { ForemanRemoteExecution.job_invocation_report_templates_select }
+      setting 'remote_execution_time_to_pickup',
+        type: :integer,
+        description: N_('Time in seconds within which the host has to pick up a job. If the job is not picked up within this limit, the job will be cancelled. Defaults to 1 day. Applies only to pull-mqtt based jobs.'),
+        default: 24 * 60 * 60,
+        full_name: N_('Time to pickup')
+    end
+  end
+
+  # Add permissions
+  security_block :foreman_remote_execution do
+    permission :view_job_templates, { :job_templates => [:index, :show, :revision, :auto_complete_search, :auto_complete_job_category, :preview, :export],
+                                      :'api/v2/job_templates' => [:index, :show, :revision, :export],
+                                      :'api/v2/template_inputs' => [:index, :show],
+                                      :'api/v2/foreign_input_sets' => [:index, :show],
+                                      :ui_job_wizard => [:categories, :template, :resources, :job_invocation]}, :resource_type => 'JobTemplate'
+    permission :create_job_templates, { :job_templates => [:new, :create, :clone_template, :import],
+                                        :'api/v2/job_templates' => [:create, :clone, :import] }, :resource_type => 'JobTemplate'
+    permission :edit_job_templates, { :job_templates => [:edit, :update],
+                                      :'api/v2/job_templates' => [:update],
+                                      :'api/v2/template_inputs' => [:create, :update, :destroy],
+                                      :'api/v2/foreign_input_sets' => [:create, :update, :destroy]}, :resource_type => 'JobTemplate'
+    permission :view_remote_execution_features, { :remote_execution_features => [:index, :show],
+                                                  :'api/v2/remote_execution_features' => [:index, :show, :available_remote_execution_features]},
+      :resource_type => 'RemoteExecutionFeature'
+    permission :edit_remote_execution_features, { :remote_execution_features => [:update],
+                                                  :'api/v2/remote_execution_features' => [:update]}, :resource_type => 'RemoteExecutionFeature'
+    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 :create_job_invocations, { :job_invocations => [:new, :create, :legacy_create, :refresh, :rerun, :preview_hosts],
+                                          'api/v2/job_invocations' => [:create, :rerun] }, :resource_type => 'JobInvocation'
+    permission :view_job_invocations, { :job_invocations => [:index, :chart, :show, :auto_complete_search, :preview_job_invocations_per_host, :list_jobs_hosts], :template_invocations => [:show, :show_template_invocation_by_host],
+                                        'api/v2/job_invocations' => [:index, :show, :output, :raw_output, :outputs, :hosts] }, :resource_type => 'JobInvocation'
+    permission :view_template_invocations, { :template_invocations => [:show, :template_invocation_preview, :show_template_invocation_by_host], :job_invocations => [:list_jobs_hosts],
+                                            'api/v2/template_invocations' => [:template_invocations], :ui_job_wizard => [:job_invocation] }, :resource_type => 'TemplateInvocation'
+    permission :create_template_invocations, {}, :resource_type => 'TemplateInvocation'
+    permission :execute_jobs_on_infrastructure_hosts, {}, :resource_type => 'JobInvocation'
+    permission :cancel_job_invocations, { :job_invocations => [:cancel], 'api/v2/job_invocations' => [:cancel] }, :resource_type => 'JobInvocation'
+    # this permissions grants user to get auto completion hints when setting up filters
+    permission :filter_autocompletion_for_template_invocation, { :template_invocations => [:auto_complete_search, :index] },
+      :resource_type => 'TemplateInvocation'
+    permission :cockpit_hosts, { 'cockpit' => [:redirect, :host_ssh_params] }, :resource_type => 'Host'
+  end
+
+  user_permissions = [
+    :view_job_templates,
+    :view_job_invocations,
+    :create_job_invocations,
+    :create_template_invocations,
+    :view_hosts,
+    :view_smart_proxies,
+    :view_remote_execution_features,
+  ].freeze
+  manager_permissions = user_permissions + [
+    :cancel_job_invocations,
+    :destroy_job_templates,
+    :edit_job_templates,
+    :create_job_templates,
+    :lock_job_templates,
+    :view_audit_logs,
+    :filter_autocompletion_for_template_invocation,
+    :edit_remote_execution_features,
+  ]
+
+  # Add a new role called 'Remote Execution User ' if it doesn't exist
+  role 'Remote Execution User', user_permissions, 'Role with permissions to run remote execution jobs against hosts'
+  role 'Remote Execution Manager', manager_permissions, 'Role with permissions to manage job templates, remote execution features, cancel jobs and view audit logs'
+
+  add_all_permissions_to_default_roles(except: [:execute_jobs_on_infrastructure_hosts])
+  add_permissions_to_default_roles({
+    Role::MANAGER => [:execute_jobs_on_infrastructure_hosts],
+    Role::SITE_MANAGER => user_permissions + [:execute_jobs_on_infrastructure_hosts],
+  })
+
+  # add menu entry
+  menu :top_menu, :job_templates,
+    url_hash: { controller: :job_templates, action: :index },
+    caption: N_('Job Templates'),
+    parent: :hosts_menu,
+    after: :provisioning_templates
+  menu :admin_menu, :remote_execution_features,
+    url_hash: { controller: :remote_execution_features, action: :index },
+    caption: N_('Remote Execution Features'),
+    parent: :administer_menu,
+    after: :bookmarks
+
+  menu :top_menu, :job_invocations,
+    url_hash: { controller: :job_invocations, action: :index },
+    caption: N_('Jobs'),
+    parent: :monitor_menu,
+    after: :audits
+
+  register_custom_status HostStatus::ExecutionStatus
+  # add dashboard widget
+  # widget 'foreman_remote_execution_widget', name: N_('Foreman plugin template widget'), sizex: 4, sizey: 1
+  widget 'dashboard/latest-jobs', :name => N_('Latest Jobs'), :sizex => 6, :sizey => 1
+
+  parameter_filter Subnet, :remote_execution_proxies, :remote_execution_proxy_ids => []
+  parameter_filter Nic::Interface do |ctx|
+    ctx.permit :execution
+  end
+
+  register_graphql_query_field :job_invocations, '::Types::JobInvocation', :collection_field
+  register_graphql_query_field :job_invocation, '::Types::JobInvocation', :record_field
+
+  register_graphql_mutation_field :create_job_invocation, ::Mutations::JobInvocations::Create
+
+  extend_template_helpers ForemanRemoteExecution::RendererMethods
+
+  extend_rabl_template 'api/v2/smart_proxies/main', 'api/v2/smart_proxies/pubkey'
+  extend_rabl_template 'api/v2/interfaces/main', 'api/v2/interfaces/execution_flag'
+  extend_rabl_template 'api/v2/subnets/show', 'api/v2/subnets/remote_execution_proxies'
+  extend_rabl_template 'api/v2/hosts/main', 'api/v2/host/main'
+  parameter_filter ::Subnet, :remote_execution_proxy_ids
+
+  describe_host do
+    multiple_actions_provider :rex_hosts_multiple_actions
+    overview_buttons_provider :rex_host_overview_buttons
+  end
+
+  # Extend Registration module
+  extend_allowed_registration_vars :remote_execution_interface
+  extend_allowed_registration_vars :setup_remote_execution_pull
+  ForemanTasks.dynflow.eager_load_actions!
+  extend_observable_events(
+    ::Dynflow::Action.descendants.select do |klass|
+      klass <= ::Actions::ObservableAction
+    end.map(&:namespaced_event_names) +
+    RemoteExecutionFeature.all.pluck(:label).flat_map do |label|
+      [::Actions::RemoteExecution::RunHostJob, ::Actions::RemoteExecution::RunHostsJob].map do |klass|
+        klass.feature_job_event_names(label)
+      end
+    end
+  )
+end

data/lib/foreman_remote_execution/version.rb

@@ -1,3 +1,3 @@
 module ForemanRemoteExecution
-  VERSION = '16.0.4'.freeze
+  VERSION = '16.1.0'.freeze
 end

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

@@ -91,7 +91,7 @@ module Api
         end
 
         test 'should create with schedule' do
-          @attrs[:scheduling] = { start_at: Time.now.to_s }
+          @attrs[:scheduling] = { start_at: (Time.now + 1.hour).to_s }
           post :create, params: { job_invocation: @attrs }
           invocation = ActiveSupport::JSON.decode(@response.body)
           assert_equal invocation['mode'], 'future'

data/test/unit/job_invocation_report_template_test.rb

@@ -28,9 +28,9 @@ class JobReportTemplateTest < ActiveSupport::TestCase
     describe 'task reporting' do
       let(:fake_outputs) do
         [
-          { 'output_type' => 'stderr', 'output' => "error" },
-          { 'output_type' => 'stdout', 'output' => "output" },
-          { 'output_type' => 'debug', 'output' => "debug" },
+          { 'output_type' => 'stderr', 'output' => "error\n" },
+          { 'output_type' => 'stdout', 'output' => "output\n" },
+          { 'output_type' => 'debug', 'output' => "debug\n" },
         ]
       end
       let(:fake_task) { FakeTask.new(result: 'success', action_continuous_output: fake_outputs, :ended_at => Time.new(2020, 12, 1, 0, 0, 0).utc) }
@@ -50,9 +50,9 @@ class JobReportTemplateTest < ActiveSupport::TestCase
         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_equal "error\n", row['stderr']
+        assert_equal "output\n", row['stdout']
+        assert_equal "debug\n", row['debug']
         assert_kind_of Time, Time.zone.parse(row['Finished']), 'Parsing of time column failed'
       end
     end

data/webpack/JobInvocationDetail/CheckboxesActions.js

@@ -0,0 +1,327 @@
+/* eslint-disable max-lines */
+import {
+  Button,
+  Divider,
+  Dropdown,
+  DropdownItem,
+  DropdownList,
+  MenuToggle,
+  Tooltip,
+} from '@patternfly/react-core';
+import {
+  EllipsisVIcon,
+  OutlinedWindowRestoreIcon,
+} from '@patternfly/react-icons';
+import axios from 'axios';
+import { foremanUrl } from 'foremanReact/common/helpers';
+import { useAPI } from 'foremanReact/common/hooks/API/APIHooks';
+import { translate as __, sprintf } from 'foremanReact/common/I18n';
+import { addToast } from 'foremanReact/components/ToastsList';
+import PropTypes from 'prop-types';
+import React, { useState } from 'react';
+import { useDispatch, useSelector } from 'react-redux';
+
+import {
+  DIRECT_OPEN_HOST_LIMIT,
+  MAX_HOSTS_API_SIZE,
+  templateInvocationPageUrl,
+} from './JobInvocationConstants';
+import {
+  selectHasPermission,
+  selectItems,
+  selectTaskCancelable,
+} from './JobInvocationSelectors';
+import OpenAllInvocationsModal, { PopupAlert } from './OpenAllInvocationsModal';
+
+/* eslint-disable camelcase */
+const ActionsKebab = ({
+  selectedIds,
+  failedCount,
+  isTaskCancelable,
+  hasCancelPermission,
+  handleTaskAction,
+  handleOpenHosts,
+  isDropdownOpen,
+  setIsDropdownOpen,
+}) => {
+  const dropdownItems = [
+    <DropdownItem
+      ouiaId="cancel-host-dropdown-item"
+      onClick={() => handleTaskAction('cancel')}
+      key="cancel"
+      component="button"
+      isDisabled={
+        selectedIds.length === 0 || !isTaskCancelable || !hasCancelPermission
+      }
+    >
+      {__('Cancel selected')}
+    </DropdownItem>,
+    <DropdownItem
+      ouiaId="abort-host-dropdown-item"
+      onClick={() => handleTaskAction('abort')}
+      key="abort"
+      component="button"
+      isDisabled={
+        selectedIds.length === 0 || !isTaskCancelable || !hasCancelPermission
+      }
+    >
+      {__('Abort selected')}
+    </DropdownItem>,
+    <Divider component="li" key="separator" />,
+    <DropdownItem
+      ouiaId="open-failed-dropdown-item"
+      key="open-failed"
+      onClick={() => handleOpenHosts('failed')}
+      isDisabled={failedCount === 0}
+    >
+      {sprintf(__('Open all failed runs (%s)'), failedCount)}
+    </DropdownItem>,
+  ];
+
+  return (
+    <Dropdown
+      isOpen={isDropdownOpen}
+      onOpenChange={setIsDropdownOpen}
+      onSelect={() => setIsDropdownOpen(false)}
+      ouiaId="actions-kebab"
+      shouldFocusToggleOnSelect
+      toggle={toggleRef => (
+        <MenuToggle
+          aria-label="actions dropdown toggle"
+          id="toggle-kebab"
+          isExpanded={isDropdownOpen}
+          onClick={() => setIsDropdownOpen(prev => !prev)}
+          ref={toggleRef}
+          variant="plain"
+        >
+          <EllipsisVIcon />
+        </MenuToggle>
+      )}
+    >
+      <DropdownList>{dropdownItems}</DropdownList>
+    </Dropdown>
+  );
+};
+
+export const CheckboxesActions = ({
+  selectedIds,
+  failedCount,
+  jobID,
+  filter,
+  bulkParams,
+}) => {
+  const [isModalOpen, setIsModalOpen] = useState(false);
+  const [showAlert, setShowAlert] = useState(false);
+  const [isOpenFailed, setIsOpenFailed] = useState(false);
+  const [isDropdownOpen, setIsDropdownOpen] = useState(false);
+  const isTaskCancelable = useSelector(selectTaskCancelable);
+  const dispatch = useDispatch();
+
+  const hasCreatePermission = useSelector(
+    selectHasPermission('create_job_invocations')
+  );
+  const hasCancelPermission = useSelector(
+    selectHasPermission('cancel_job_invocations')
+  );
+  const jobSearchQuery = useSelector(selectItems)?.targeting?.search_query;
+  const filterQuery =
+    filter && filter !== 'all_statuses'
+      ? ` and job_invocation.result = ${filter}`
+      : '';
+  const combinedQuery = `${bulkParams}${filterQuery}`;
+
+  const { response: failedHostsData } = useAPI(
+    'get',
+    foremanUrl(`/api/job_invocations/${jobID}/hosts`),
+    {
+      params: {
+        per_page: MAX_HOSTS_API_SIZE,
+        search: `job_invocation.result = failed`,
+      },
+      skip: failedCount === 0,
+    }
+  );
+
+  const failedHosts = failedHostsData?.results || [];
+
+  const openLink = url => {
+    const newWin = window.open(url);
+
+    if (!newWin || newWin.closed || typeof newWin.closed === 'undefined') {
+      setShowAlert(true);
+    }
+  };
+
+  const handleOpenHosts = async (type = 'all') => {
+    if (type === 'failed') {
+      if (failedCount <= DIRECT_OPEN_HOST_LIMIT) {
+        failedHosts.forEach(host =>
+          openLink(templateInvocationPageUrl(host.id, jobID))
+        );
+        return;
+      }
+      setIsOpenFailed(true);
+      setIsModalOpen(true);
+      return;
+    }
+
+    if (selectedIds.length <= DIRECT_OPEN_HOST_LIMIT) {
+      selectedIds.forEach(id => openLink(templateInvocationPageUrl(id, jobID)));
+      return;
+    }
+
+    setIsOpenFailed(false);
+    setIsModalOpen(true);
+  };
+
+  const cancelJobTasks = (search, action) => async () => {
+    dispatch(
+      addToast({
+        key: `cancel-job-info`,
+        type: 'info',
+        message: sprintf(__('Trying to %s the task'), action),
+      })
+    );
+
+    try {
+      const response = await axios.post(
+        `/api/v2/job_invocations/${jobID}/cancel`,
+        {
+          search,
+          force: action !== 'cancel',
+        }
+      );
+
+      const cancelledTasks = response.data?.cancelled;
+      const pastTenseAction =
+        action === 'cancel' ? __('cancelled') : __('aborted');
+
+      if (cancelledTasks && cancelledTasks.length > 0) {
+        const idList = cancelledTasks.join(', ');
+        dispatch(
+          addToast({
+            key: `success-tasks-cancelled`,
+            type: 'success',
+            message: sprintf(
+              __('%s task(s) successfully %s: %s'),
+              cancelledTasks.length,
+              pastTenseAction,
+              idList
+            ),
+          })
+        );
+      } else {
+        dispatch(
+          addToast({
+            key: `warn-no-tasks-cancelled-${Date.now()}`,
+            type: 'warning',
+            message: sprintf(__('Task(s) were not %s'), pastTenseAction),
+          })
+        );
+      }
+    } catch (error) {
+      dispatch(
+        addToast({
+          key: `error-cancelling-tasks`,
+          type: 'danger',
+          message: error.response?.data?.error || __('An error occurred.'),
+        })
+      );
+    }
+  };
+
+  const handleTaskAction = action => {
+    dispatch(cancelJobTasks(combinedQuery, action));
+  };
+
+  const OpenAllButton = () => (
+    <Button
+      aria-label="open all template invocations in new tab"
+      className="open-all-button"
+      isDisabled={selectedIds.length === 0}
+      isInline
+      onClick={() => handleOpenHosts('all')}
+      ouiaId="template-invocation-new-tab-button"
+      variant="link"
+    >
+      <Tooltip content={__('Open selected in new tab')}>
+        <OutlinedWindowRestoreIcon />
+      </Tooltip>
+    </Button>
+  );
+
+  const RerunSelectedButton = () => (
+    <Button
+      aria-label="rerun selected template invocations"
+      className="rerun-selected-button"
+      component="a"
+      href={foremanUrl(
+        `/job_invocations/${jobID}/rerun?search=(${jobSearchQuery}) AND (${combinedQuery})`
+      )}
+      // eslint-disable-next-line camelcase
+      isDisabled={selectedIds.length === 0 || !hasCreatePermission}
+      isInline
+      ouiaId="template-invocation-rerun-selected-button"
+      variant="secondary"
+    >
+      {__('Rerun')}
+    </Button>
+  );
+
+  return (
+    <>
+      <OpenAllButton />
+      <RerunSelectedButton />
+      <ActionsKebab
+        selectedIds={selectedIds}
+        failedCount={failedCount}
+        isTaskCancelable={isTaskCancelable}
+        hasCancelPermission={hasCancelPermission}
+        handleTaskAction={handleTaskAction}
+        handleOpenHosts={handleOpenHosts}
+        isDropdownOpen={isDropdownOpen}
+        setIsDropdownOpen={setIsDropdownOpen}
+      />
+      {showAlert && <PopupAlert setShowAlert={setShowAlert} />}
+      <OpenAllInvocationsModal
+        isOpen={isModalOpen}
+        onClose={() => setIsModalOpen(false)}
+        failedCount={failedCount}
+        failedHosts={failedHosts}
+        jobID={jobID}
+        isOpenFailed={isOpenFailed}
+        setShowAlert={setShowAlert}
+        selectedIds={selectedIds}
+      />
+    </>
+  );
+};
+
+ActionsKebab.propTypes = {
+  selectedIds: PropTypes.array.isRequired,
+  failedCount: PropTypes.number.isRequired,
+  isTaskCancelable: PropTypes.bool,
+  hasCancelPermission: PropTypes.bool,
+  handleTaskAction: PropTypes.func.isRequired,
+  handleOpenHosts: PropTypes.func.isRequired,
+  isDropdownOpen: PropTypes.bool.isRequired,
+  setIsDropdownOpen: PropTypes.func.isRequired,
+};
+
+ActionsKebab.defaultProps = {
+  isTaskCancelable: false,
+  hasCancelPermission: false,
+};
+
+CheckboxesActions.propTypes = {
+  selectedIds: PropTypes.array.isRequired,
+  failedCount: PropTypes.number.isRequired,
+  jobID: PropTypes.string.isRequired,
+  bulkParams: PropTypes.string,
+  filter: PropTypes.string,
+};
+
+CheckboxesActions.defaultProps = {
+  bulkParams: '',
+  filter: '',
+};

data/webpack/JobInvocationDetail/{JobInvocationHostTableToolbar.js → DropdownFilter.js}

@@ -10,10 +10,7 @@ import {
 } from '@patternfly/react-core';
 import { STATUS_TITLES } from './JobInvocationConstants';
 
-const JobInvocationHostTableToolbar = ({
-  dropdownFilter,
-  setDropdownFilter,
-}) => {
+const DropdownFilter = ({ dropdownFilter, setDropdownFilter }) => {
   const [isOpen, setIsOpen] = React.useState(false);
   const onSelect = (_event, itemId) => {
     setDropdownFilter(itemId);
@@ -60,9 +57,9 @@ const JobInvocationHostTableToolbar = ({
   );
 };
 
-JobInvocationHostTableToolbar.propTypes = {
+DropdownFilter.propTypes = {
   dropdownFilter: PropTypes.string.isRequired,
   setDropdownFilter: PropTypes.func.isRequired,
 };
 
-export default JobInvocationHostTableToolbar;
+export default DropdownFilter;

data/webpack/JobInvocationDetail/JobInvocationConstants.js

@@ -1,7 +1,7 @@
 /* eslint-disable camelcase */
 import React from 'react';
-import { foremanUrl } from 'foremanReact/common/helpers';
 import { translate as __ } from 'foremanReact/common/I18n';
+import { foremanUrl } from 'foremanReact/common/helpers';
 import { useForemanHostDetailsPageUrl } from 'foremanReact/Root/Context/ForemanContext';
 import JobStatusIcon from '../react_app/components/RecentJobsCard/JobStatusIcon';
 
@@ -16,18 +16,22 @@ export const CANCEL_RECURRING_LOGIC = 'CANCEL_RECURRING_LOGIC';
 export const GET_REPORT_TEMPLATES = 'GET_REPORT_TEMPLATES';
 export const GET_REPORT_TEMPLATE_INPUTS = 'GET_REPORT_TEMPLATE_INPUTS';
 export const JOB_INVOCATION_HOSTS = 'JOB_INVOCATION_HOSTS';
+export const GET_TEMPLATE_INVOCATION = 'GET_TEMPLATE_INVOCATION';
+export const MAX_HOSTS_API_SIZE = 100;
+export const DIRECT_OPEN_HOST_LIMIT = 3;
+export const ALL_JOB_HOSTS = 'ALL_JOB_HOSTS';
 export const currentPermissionsUrl = foremanUrl(
   '/api/v2/permissions/current_permissions'
 );
-export const GET_TEMPLATE_INVOCATION = 'GET_TEMPLATE_INVOCATION';
+
 export const showTemplateInvocationUrl = (hostID, jobID) =>
   `/show_template_invocation_by_host/${hostID}/job_invocation/${jobID}`;
+export const LIST_TEMPLATE_INVOCATIONS = 'LIST_TEMPLATE_INVOCATIONS';
 
 export const templateInvocationPageUrl = (hostID, jobID) =>
   `/job_invocations_detail/${jobID}/host_invocation/${hostID}`;
 
-export const jobInvocationDetailsUrl = id =>
-  `/experimental/job_invocations_detail/${id}`;
+export const jobInvocationDetailsUrl = id => `/job_invocations/${id}`;
 
 export const STATUS = {
   PENDING: 'pending',
@@ -135,11 +139,6 @@ const Columns = () => {
       },
       weight: 5,
     },
-    actions: {
-      title: ' ',
-      weight: 6,
-      wrapper: () => null,
-    },
   };
 };