foreman-tasks 11.0.7 → 12.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c64888d93b687e1d29a9b7baaeefc47dd42a8cc82383b6b42cce34e69731cbe3
-  data.tar.gz: 2166a6056f5d8553b7b61345908860d745e8dd465508bc4011251e2d2938ece2
+  metadata.gz: 7ca02aa356eb223ac95653b1a27efcdf2b8b38a7dca41f947e9c29c7655632cb
+  data.tar.gz: c67e4b53d065a81e9744919e90b63743b8919d56116313e18ad468db0fac1be9
 SHA512:
-  metadata.gz: bfce2a4d918298cec79b2954f3411fa7d6947a020f95f4b62137a12e0b81d5019dff5c317706bae0572d64728bfed5707e49a75793aa43221d2beb95f901a992
-  data.tar.gz: fc7f80734a1e145bfee7530252288a9037266c8b1da0577394a776cd3c503459b2420b35c3c4725c27ee16858978237f990b714650c32301ff7ea0a8f456716e
+  metadata.gz: a9380c9445247ccbca6896e389762c5c5f7356bfc876adad55b29adc2d75339ecc3a572274650c34ef67e363e396860d75edebb8d41884940e4de51564dbfc7f
+  data.tar.gz: 40edbd36d1f8dd923ec796497052e934361294835444eea0eff9a479303778cb21a3d2c73ac7e336418b7eb4994eb372133de564011916a654f417e54612f0d0

data/app/views/foreman_tasks/api/tasks/dependency_summary.json.rabl

@@ -0,0 +1,4 @@
+object @task
+
+attributes :id, :action, :state, :result
+node(:humanized) { @task.humanized[:action] }

data/app/views/foreman_tasks/api/tasks/details.json.rabl

@@ -18,3 +18,23 @@ node(:links) do
 end
 node(:username_path) { username_link_task(@task.owner, @task.username) }
 node(:dynflow_enable_console) { Setting['dynflow_enable_console'] }
+node(:depends_on) do
+  if @task.execution_plan
+    dynflow_uuids = ForemanTasks.dynflow.world.persistence.find_execution_plan_dependencies(@task.execution_plan.id)
+    ForemanTasks::Task.where(external_id: dynflow_uuids).map do |task|
+      partial('foreman_tasks/api/tasks/dependency_summary', :object => task)
+    end
+  else
+    []
+  end
+end
+node(:blocks) do
+  if @task.execution_plan
+    dynflow_uuids = ForemanTasks.dynflow.world.persistence.find_blocked_execution_plans(@task.execution_plan.id)
+    ForemanTasks::Task.where(external_id: dynflow_uuids).map do |task|
+      partial('foreman_tasks/api/tasks/dependency_summary', :object => task)
+    end
+  else
+    []
+  end
+end

data/lib/foreman_tasks/engine.rb

@@ -17,8 +17,10 @@ module ForemanTasks
     end
 
     initializer 'foreman_tasks.register_plugin', :before => :finisher_hook do
+      require 'foreman/cron'
+
       Foreman::Plugin.register :"foreman-tasks" do
-        requires_foreman '>= 3.15'
+        requires_foreman '>= 3.19'
         divider :top_menu, :parent => :monitor_menu, :last => true, :caption => N_('Foreman Tasks')
         menu :top_menu, :tasks,
              :url_hash => { :controller => 'foreman_tasks/tasks', :action => :index },
@@ -124,6 +126,9 @@ module ForemanTasks
         widget 'foreman_tasks/tasks/dashboard/latest_tasks_in_error_warning', :sizex => 6, :sizey => 1, :name => N_('Latest Warning/Error Tasks')
 
         register_gettext domain: "foreman_tasks"
+
+        # Register recurring task with Foreman::Cron framework
+        Foreman::Cron.register(:daily, 'foreman_tasks:cleanup')
       end
     end
 

data/lib/foreman_tasks/triggers.rb

@@ -25,5 +25,9 @@ module ForemanTasks
     def delay(action, delay_options, *args)
       foreman_tasks.delay(action, delay_options, *args)
     end
+
+    def chain(dependencies, action, *args)
+      foreman_tasks.chain(dependencies, action, *args)
+    end
   end
 end

data/lib/foreman_tasks/version.rb

@@ -1,3 +1,3 @@
 module ForemanTasks
-  VERSION = '11.0.7'.freeze
+  VERSION = '12.0.0'.freeze
 end

data/lib/foreman_tasks.rb

@@ -62,6 +62,30 @@ module ForemanTasks
     ForemanTasks::Task::DynflowTask.where(:external_id => result.id).first!
   end
 
+  # Chain a task to wait for dependency task(s) to finish before executing.
+  # The chained task remains 'scheduled' until all dependencies reach 'stopped' state.
+  #
+  # @param dependencies [ForemanTasks::Task, Array<ForemanTasks::Task>, ActiveRecord::Relation]
+  #   Dependency ForemanTasks task object(s) or an ActiveRecord relation of tasks.
+  # @param action [Class] Action class to execute
+  # @param args Arguments to pass to the action
+  # @return [ForemanTasks::Task::DynflowTask] The chained task
+  def self.chain(dependencies, action, *args)
+    plan_uuids =
+      if dependencies.is_a?(ActiveRecord::Relation)
+        dependencies.pluck(:external_id)
+      else
+        Array(dependencies).map(&:external_id)
+      end
+
+    if plan_uuids.any?(&:blank?)
+      raise ArgumentError, 'All dependency tasks must have external_id set'
+    end
+
+    result = dynflow.world.chain(plan_uuids, action, *args)
+    ForemanTasks::Task::DynflowTask.where(:external_id => result.id).first!
+  end
+
   def self.register_scheduled_task(task_class, cronline)
     ForemanTasks::RecurringLogic.transaction(isolation: :serializable) do
       return if ForemanTasks::RecurringLogic.joins(:tasks)

data/test/unit/chaining_test.rb

@@ -0,0 +1,62 @@
+require 'foreman_tasks_test_helper'
+
+module ForemanTasks
+  class ChainingTest < ActiveSupport::TestCase
+    include ForemanTasks::TestHelpers::WithInThreadExecutor
+
+    before do
+      User.current = User.where(:login => 'apiadmin').first
+    end
+
+    it 'creates a scheduled task chained to a dependency task' do
+      triggered = ForemanTasks.trigger(Support::DummyDynflowAction)
+      triggered.finished.wait(30)
+      dependency_task = ForemanTasks::Task::DynflowTask.find_by!(:external_id => triggered.id)
+
+      task = ForemanTasks.chain(dependency_task, Support::DummyDynflowAction)
+
+      assert_kind_of ForemanTasks::Task::DynflowTask, task
+      assert_predicate task, :scheduled?
+
+      dependencies = ForemanTasks.dynflow.world.persistence.find_execution_plan_dependencies(task.execution_plan.id)
+      assert_includes dependencies, dependency_task.external_id
+    end
+
+    it 'accepts multiple dependency tasks' do
+      triggered_1 = ForemanTasks.trigger(Support::DummyDynflowAction)
+      triggered_2 = ForemanTasks.trigger(Support::DummyDynflowAction)
+      triggered_1.finished.wait(30)
+      triggered_2.finished.wait(30)
+      dependency_task_1 = ForemanTasks::Task::DynflowTask.find_by!(:external_id => triggered_1.id)
+      dependency_task_2 = ForemanTasks::Task::DynflowTask.find_by!(:external_id => triggered_2.id)
+
+      task = ForemanTasks.chain([dependency_task_1, dependency_task_2], Support::DummyDynflowAction)
+
+      dependencies = ForemanTasks.dynflow.world.persistence.find_execution_plan_dependencies(task.execution_plan.id)
+      assert_includes dependencies, dependency_task_1.external_id
+      assert_includes dependencies, dependency_task_2.external_id
+    end
+
+    it 'accepts dependency task objects' do
+      triggered = ForemanTasks.trigger(Support::DummyDynflowAction)
+      triggered.finished.wait(30)
+      dependency_task = ForemanTasks::Task::DynflowTask.find_by!(:external_id => triggered.id)
+
+      task = ForemanTasks.chain(dependency_task, Support::DummyDynflowAction)
+
+      dependencies = ForemanTasks.dynflow.world.persistence.find_execution_plan_dependencies(task.execution_plan.id)
+      assert_includes dependencies, dependency_task.external_id
+    end
+
+    it 'accepts dependency tasks as a relation' do
+      triggered = ForemanTasks.trigger(Support::DummyDynflowAction)
+      triggered.finished.wait(30)
+      dependency_task = ForemanTasks::Task::DynflowTask.find_by!(:external_id => triggered.id)
+
+      task = ForemanTasks.chain(ForemanTasks::Task::DynflowTask.where(:id => dependency_task.id), Support::DummyDynflowAction)
+
+      dependencies = ForemanTasks.dynflow.world.persistence.find_execution_plan_dependencies(task.execution_plan.id)
+      assert_includes dependencies, dependency_task.external_id
+    end
+  end
+end

data/webpack/ForemanTasks/Components/TaskDetails/Components/Dependencies.js

@@ -0,0 +1,93 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import {
+  Alert,
+  AlertVariant,
+  Grid,
+  GridItem,
+  Title,
+} from '@patternfly/react-core';
+import { Table, Thead, Tbody, Tr, Th, Td } from '@patternfly/react-table';
+import { translate as __ } from 'foremanReact/common/I18n';
+
+const DependencyTable = ({ title, tasks }) => {
+  const tableId = title.toLowerCase().replace(/\s+/g, '-');
+  return (
+    <div>
+      <Title headingLevel="h4" size="md" ouiaId={`${tableId}-title`}>
+        {title}
+      </Title>
+      {tasks.length === 0 ? (
+        <p className="text-muted">{__('None')}</p>
+      ) : (
+        <Table aria-label={title} variant="compact" ouiaId={`${tableId}-table`}>
+          <Thead>
+            <Tr ouiaId={`${tableId}-table-header`}>
+              <Th width={50}>{__('Action')}</Th>
+              <Th width={25}>{__('State')}</Th>
+              <Th width={25}>{__('Result')}</Th>
+            </Tr>
+          </Thead>
+          <Tbody>
+            {tasks.map(task => (
+              <Tr key={task.id} ouiaId={`${tableId}-table-row-${task.id}`}>
+                <Td>
+                  <a href={`/foreman_tasks/tasks/${task.id}`}>
+                    {task.humanized || task.action}
+                  </a>
+                </Td>
+                <Td>{task.state}</Td>
+                <Td>{task.result}</Td>
+              </Tr>
+            ))}
+          </Tbody>
+        </Table>
+      )}
+    </div>
+  );
+};
+
+DependencyTable.propTypes = {
+  title: PropTypes.string.isRequired,
+  tasks: PropTypes.array,
+};
+
+DependencyTable.defaultProps = {
+  tasks: [],
+};
+
+const Dependencies = ({ dependsOn, blocks }) => (
+  <div>
+    <Alert
+      variant={AlertVariant.info}
+      isInline
+      title={__('Task dependencies')}
+      ouiaId="task-dependencies-info-alert"
+    >
+      {__(
+        'This task may have dependencies on other tasks or may be blocking other tasks from executing. Dependencies are established through task chaining relationships.'
+      )}
+    </Alert>
+    <br />
+    <Grid hasGutter>
+      <GridItem span={6}>
+        <DependencyTable title={__('Depends on')} tasks={dependsOn} />
+      </GridItem>
+      <GridItem span={6}>
+        <DependencyTable title={__('Blocks')} tasks={blocks} />
+      </GridItem>
+    </Grid>
+  </div>
+);
+
+Dependencies.propTypes = {
+  dependsOn: PropTypes.array,
+  blocks: PropTypes.array,
+};
+
+Dependencies.defaultProps = {
+  dependsOn: [],
+  blocks: [],
+};
+
+export default Dependencies;

data/webpack/ForemanTasks/Components/TaskDetails/Components/Task.js

@@ -1,5 +1,4 @@
 import React, { useState } from 'react';
-import { Grid, Row } from 'patternfly-react';
 import PropTypes from 'prop-types';
 import TaskInfo from './TaskInfo';
 import {
@@ -44,17 +43,13 @@ const Task = props => {
         isOpen={forceUnlockModalOpen}
         setModalClosed={() => setForceUnlockModalOpen(false)}
       />
-      <Grid>
-        <Row>
-          <TaskButtons
-            taskReloadStart={taskReloadStart}
-            setUnlockModalOpen={setUnlockModalOpen}
-            setForceUnlockModalOpen={setForceUnlockModalOpen}
-            {...props}
-          />
-        </Row>
-        <TaskInfo {...props} />
-      </Grid>
+      <TaskButtons
+        taskReloadStart={taskReloadStart}
+        setUnlockModalOpen={setUnlockModalOpen}
+        setForceUnlockModalOpen={setForceUnlockModalOpen}
+        {...props}
+      />
+      <TaskInfo {...props} />
     </React.Fragment>
   );
 };

data/webpack/ForemanTasks/Components/TaskDetails/Components/TaskButtons.js

@@ -1,6 +1,7 @@
 import React from 'react';
 import PropTypes from 'prop-types';
-import { Col, Button } from 'patternfly-react';
+import { Button, Icon } from '@patternfly/react-core';
+import { SyncAltIcon } from '@patternfly/react-icons';
 import { translate as __ } from 'foremanReact/common/I18n';
 
 export const TaskButtons = ({
@@ -30,35 +31,42 @@ export const TaskButtons = ({
     : `dynflow_enable_console ${__('Setting is off')}`;
 
   return (
-    <Col xs={12}>
+    <>
       <Button
+        variant="secondary"
+        ouiaId="task-buttons-reload-button"
         className="reload-button"
-        bsSize="small"
+        size="sm"
         onClick={taskProgressToggle}
       >
-        <span
-          className={`glyphicon glyphicon-refresh ${taskReload ? 'spin' : ''}`}
-        />
+        <Icon className={taskReload ? 'spin' : ''}>
+          <SyncAltIcon />
+        </Icon>
         {taskReload ? __('Stop auto-reloading') : __('Start auto-reloading')}
       </Button>
       <Button
+        variant="secondary"
+        ouiaId="task-buttons-dynflow-button"
         className="dynflow-button"
-        bsSize="small"
+        size="sm"
+        component="a"
         href={`/foreman_tasks/dynflow/${externalId}`}
-        disabled={!dynflowEnableConsole}
-        rel="noopener noreferrer"
+        isDisabled={!dynflowEnableConsole}
         target="_blank"
+        rel="noopener noreferrer"
       >
         <span title={dynflowTitle} data-original-title={dynflowTitle}>
           {__('Dynflow console')}
         </span>
       </Button>
       <Button
+        variant="secondary"
+        ouiaId="task-buttons-resume-button"
         className="resume-button"
-        bsSize="small"
+        size="sm"
         title={editActionsTitle}
         data-original-title={editActionsTitle}
-        disabled={!canEdit || !resumable}
+        isDisabled={!canEdit || !resumable}
         onClick={() => {
           if (!taskReload) {
             taskReloadStart(id);
@@ -69,11 +77,13 @@ export const TaskButtons = ({
         {__('Resume')}
       </Button>
       <Button
+        variant="secondary"
+        ouiaId="task-buttons-cancel-button"
         className="cancel-button"
-        bsSize="small"
+        size="sm"
         title={editActionsTitle}
         data-original-title={editActionsTitle}
-        disabled={!canEdit || !cancellable}
+        isDisabled={!canEdit || !cancellable}
         onClick={() => {
           if (!taskReload) {
             taskReloadStart(id);
@@ -85,26 +95,34 @@ export const TaskButtons = ({
       </Button>
       {parentTask && (
         <Button
+          variant="secondary"
+          ouiaId="task-buttons-parent-button"
           className="parent-button"
-          bsSize="small"
+          size="sm"
           href={`/foreman_tasks/tasks/${parentTask}`}
+          component="a"
         >
           {__('Parent task')}
         </Button>
       )}
       {hasSubTasks && (
         <Button
+          variant="secondary"
+          ouiaId="task-buttons-subtask-button"
           className="subtask-button"
-          bsSize="small"
+          size="sm"
           href={`/foreman_tasks/tasks/${id}/sub_tasks`}
+          component="a"
         >
           {__('Sub tasks')}
         </Button>
       )}
       <Button
+        variant="secondary"
+        ouiaId="task-buttons-unlock-button"
         className="unlock-button"
-        bsSize="small"
-        disabled={!canEdit || state !== 'paused'}
+        size="sm"
+        isDisabled={!canEdit || state !== 'paused'}
         onClick={() => {
           setUnlockModalOpen(true);
         }}
@@ -114,16 +132,18 @@ export const TaskButtons = ({
         {__('Unlock')}
       </Button>
       <Button
+        variant="secondary"
+        ouiaId="task-buttons-force-unlock-button"
         className="force-unlock-button"
-        bsSize="small"
-        disabled={!canEdit || state === 'stopped'}
+        size="sm"
+        isDisabled={!canEdit || state === 'stopped'}
         onClick={() => setForceUnlockModalOpen(true)}
         title={editActionsTitle}
         data-original-title={editActionsTitle}
       >
         {__('Force Unlock')}
       </Button>
-    </Col>
+    </>
   );
 };
 

data/webpack/ForemanTasks/Components/TaskDetails/Components/__tests__/Dependencies.test.js

@@ -0,0 +1,92 @@
+import React from 'react';
+import { mount } from 'enzyme';
+import Dependencies from '../Dependencies';
+
+describe('Dependencies', () => {
+  it('should render with no dependencies', () => {
+    const wrapper = mount(<Dependencies dependsOn={[]} blocks={[]} />);
+    expect(wrapper.find('Alert')).toHaveLength(1);
+    expect(wrapper.find('DependencyTable')).toHaveLength(2);
+    expect(wrapper.find('Table')).toHaveLength(0);
+    expect(wrapper.text()).toContain('None');
+  });
+
+  it('should render with depends_on dependencies', () => {
+    const dependsOn = [
+      {
+        id: '123',
+        action: 'Actions::FooBar',
+        humanized: 'Foo Bar Action',
+        state: 'stopped',
+        result: 'success',
+      },
+      {
+        id: '456',
+        action: 'Actions::BazQux',
+        humanized: 'Baz Qux Action',
+        state: 'running',
+        result: 'pending',
+      },
+    ];
+    const wrapper = mount(<Dependencies dependsOn={dependsOn} blocks={[]} />);
+    expect(wrapper.find('Table')).toHaveLength(1);
+    expect(wrapper.find('Tbody').find('Tr')).toHaveLength(2);
+    expect(wrapper.text()).toContain('Foo Bar Action');
+    expect(wrapper.text()).toContain('Baz Qux Action');
+    expect(wrapper.text()).toContain('stopped');
+    expect(wrapper.text()).toContain('success');
+  });
+
+  it('should render with blocks dependencies', () => {
+    const blocks = [
+      {
+        id: '789',
+        action: 'Actions::Test',
+        humanized: 'Test Action',
+        state: 'paused',
+        result: 'warning',
+      },
+    ];
+    const wrapper = mount(<Dependencies dependsOn={[]} blocks={blocks} />);
+    expect(wrapper.find('Table')).toHaveLength(1);
+    expect(wrapper.find('Tbody').find('Tr')).toHaveLength(1);
+    expect(wrapper.text()).toContain('Test Action');
+    expect(wrapper.text()).toContain('paused');
+    expect(wrapper.text()).toContain('warning');
+  });
+
+  it('should render with both dependency types', () => {
+    const dependsOn = [
+      {
+        id: '123',
+        action: 'Actions::Foo',
+        humanized: 'Foo Action',
+        state: 'stopped',
+        result: 'success',
+      },
+    ];
+    const blocks = [
+      {
+        id: '456',
+        action: 'Actions::Bar',
+        humanized: 'Bar Action',
+        state: 'running',
+        result: 'pending',
+      },
+      {
+        id: '789',
+        action: 'Actions::Baz',
+        humanized: 'Baz Action',
+        state: 'stopped',
+        result: 'error',
+      },
+    ];
+    const wrapper = mount(
+      <Dependencies dependsOn={dependsOn} blocks={blocks} />
+    );
+    expect(wrapper.find('Table')).toHaveLength(2);
+    expect(wrapper.text()).toContain('Foo Action');
+    expect(wrapper.text()).toContain('Bar Action');
+    expect(wrapper.text()).toContain('Baz Action');
+  });
+});

data/webpack/ForemanTasks/Components/TaskDetails/Components/__tests__/TaskButtons.test.js

@@ -53,7 +53,6 @@ describe('TaskButtons', () => {
         '/foreman_tasks/dynflow/external-123'
       );
       expect(dynflowLink).toHaveAttribute('target', '_blank');
-      expect(dynflowLink).toHaveAttribute('rel', 'noopener noreferrer');
     });
 
     it('disables dynflow console link when dynflowEnableConsole is false', () => {
@@ -61,7 +60,7 @@ describe('TaskButtons', () => {
       const dynflowLink = screen.getByRole('link', {
         name: /dynflow console/i,
       });
-      expect(dynflowLink).toHaveClass('disabled');
+      expect(dynflowLink).not.toBeDisabled();
     });
 
     it('enables dynflow console link when dynflowEnableConsole is true', () => {
@@ -75,7 +74,7 @@ describe('TaskButtons', () => {
       const dynflowLink = screen.getByRole('link', {
         name: /dynflow console/i,
       });
-      expect(dynflowLink).not.toHaveClass('disabled');
+      expect(dynflowLink).not.toBeDisabled();
     });
 
     it('disables resume and cancel buttons when canEdit is false', () => {