foreman-tasks 1.1.3 → 3.0.0

data/webpack/ForemanTasks/Components/TaskActions/UnlockModals.test.js

@@ -0,0 +1,14 @@
+import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
+
+import { UnlockModal, ForceUnlockModal } from './UnlockModals';
+
+const fixtures = {
+  render: { taskID: 'some-id', onClick: jest.fn() },
+};
+
+describe('UnlockModal', () => {
+  testComponentSnapshotsWithFixtures(UnlockModal, fixtures);
+});
+describe('ForceUnlockModal', () => {
+  testComponentSnapshotsWithFixtures(ForceUnlockModal, fixtures);
+});

data/webpack/ForemanTasks/Components/TaskActions/__snapshots__/TaskAction.test.js.snap

@@ -0,0 +1,233 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Tasks actions should cancelTaskRequest and fail 1`] = `
+Array [
+  Array [
+    Object {
+      "payload": Object {
+        "message": Object {
+          "message": "Trying to cancel some-name task",
+          "type": "info",
+        },
+      },
+      "type": "TOASTS_ADD",
+    },
+  ],
+  Array [
+    Object {
+      "type": "TASKS_CANCEL_REQUEST",
+    },
+  ],
+  Array [
+    Object {
+      "payload": [Error: Network Error],
+      "type": "TASKS_CANCEL_FAILURE",
+    },
+  ],
+  Array [
+    Object {
+      "payload": Object {
+        "message": Object {
+          "message": "some-name Task execution task has to be cancellable",
+          "type": "warning",
+        },
+      },
+      "type": "TOASTS_ADD",
+    },
+  ],
+]
+`;
+
+exports[`Tasks actions should cancelTaskRequest and succeed 1`] = `
+Array [
+  Array [
+    Object {
+      "payload": Object {
+        "message": Object {
+          "message": "Trying to cancel some-name task",
+          "type": "info",
+        },
+      },
+      "type": "TOASTS_ADD",
+    },
+  ],
+  Array [
+    Object {
+      "type": "TASKS_CANCEL_REQUEST",
+    },
+  ],
+  Array [
+    Object {
+      "type": "TASKS_CANCEL_SUCCESS",
+    },
+  ],
+  Array [
+    Object {
+      "payload": Object {
+        "message": Object {
+          "message": "some-name Task execution was cancelled",
+          "type": "success",
+        },
+      },
+      "type": "TOASTS_ADD",
+    },
+  ],
+]
+`;
+
+exports[`Tasks actions should forceCancelTaskRequest and fail 1`] = `
+Array [
+  Array [
+    Object {
+      "type": "TASKS_FORCE_CANCEL_REQUEST",
+    },
+  ],
+  Array [
+    Object {
+      "type": "TASKS_FORCE_CANCEL_FAILURE",
+    },
+  ],
+  Array [
+    Object {
+      "payload": Object {
+        "message": Object {
+          "message": "some-name Task execution cannot be cancelled with force at the moment.",
+          "type": "warning",
+        },
+      },
+      "type": "TOASTS_ADD",
+    },
+  ],
+]
+`;
+
+exports[`Tasks actions should forceCancelTaskRequest and succeed 1`] = `
+Array [
+  Array [
+    Object {
+      "type": "TASKS_FORCE_CANCEL_REQUEST",
+    },
+  ],
+  Array [
+    Object {
+      "type": "TASKS_FORCE_CANCEL_SUCCESS",
+    },
+  ],
+  Array [
+    Object {
+      "payload": Object {
+        "message": Object {
+          "message": "some-name Task execution resources were unlocked with force.",
+          "type": "success",
+        },
+      },
+      "type": "TOASTS_ADD",
+    },
+  ],
+]
+`;
+
+exports[`Tasks actions should resumeTaskRequest and fail 1`] = `
+Array [
+  Array [
+    Object {
+      "type": "TASKS_RESUME_REQUEST",
+    },
+  ],
+  Array [
+    Object {
+      "payload": [Error: Network Error],
+      "type": "TASKS_RESUME_FAILURE",
+    },
+  ],
+  Array [
+    Object {
+      "payload": Object {
+        "message": Object {
+          "message": "some-name Task execution could not be resumed",
+          "type": "error",
+        },
+      },
+      "type": "TOASTS_ADD",
+    },
+  ],
+]
+`;
+
+exports[`Tasks actions should resumeTaskRequest and succeed 1`] = `
+Array [
+  Array [
+    Object {
+      "type": "TASKS_RESUME_REQUEST",
+    },
+  ],
+  Array [
+    Object {
+      "type": "TASKS_RESUME_SUCCESS",
+    },
+  ],
+  Array [
+    Object {
+      "payload": Object {
+        "message": Object {
+          "message": "some-name Task execution was resumed",
+          "type": "success",
+        },
+      },
+      "type": "TOASTS_ADD",
+    },
+  ],
+]
+`;
+
+exports[`Tasks actions should unlockTaskRequest and fail 1`] = `
+Array [
+  Array [
+    Object {
+      "type": "TASKS_FORCE_CANCEL_REQUEST",
+    },
+  ],
+  Array [
+    Object {
+      "type": "TASKS_FORCE_CANCEL_FAILURE",
+    },
+  ],
+  Array [
+    Object {
+      "payload": Object {
+        "message": Object {
+          "message": "some-name Task execution cannot be cancelled with force at the moment.",
+          "type": "warning",
+        },
+      },
+      "type": "TOASTS_ADD",
+    },
+  ],
+]
+`;
+
+exports[`Tasks actions should unlockTaskRequest and succeed 1`] = `
+Array [
+  Array [
+    Object {
+      "type": "TASKS_UNLOCK_REQUEST",
+    },
+  ],
+  Array [
+    Object {
+      "type": "TASKS_UNLOCK_SUCCESS",
+    },
+  ],
+  Array [
+    Object {
+      "payload": Object {
+        "message": Object {
+          "message": "some-name Task execution resources were unlocked ",
+          "type": "success",
+        },
+      },
+      "type": "TOASTS_ADD",
+    },
+  ],
+]
+`;

data/webpack/ForemanTasks/Components/TaskActions/__snapshots__/UnlockModals.test.js.snap

@@ -0,0 +1,25 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`ForceUnlockModal render 1`] = `
+<ClickConfirmation
+  body="Resources for 1 task(s) will be unlocked and will not prevent other tasks from being run. As the task(s) might be still running, it should be avoided to use this unless you are really sure the task(s) got stuck."
+  confirmAction="Force Unlock"
+  confirmType="danger"
+  confirmationMessage="I understand that this may cause harm and have working database backups of all backend services."
+  id="forceUnlockModal"
+  onClick={[MockFunction]}
+  title="Force Unlock"
+/>
+`;
+
+exports[`UnlockModal render 1`] = `
+<ClickConfirmation
+  body="This will unlock the resources that the task is running against. Please note that this might lead to inconsistent state and should be used with caution, after making sure that the task can't be resumed."
+  confirmAction="Unlock"
+  confirmType="warning"
+  confirmationMessage="I understand that this may cause harm and have working database backups of all backend services."
+  id="unlockModal"
+  onClick={[MockFunction]}
+  title="Unlock"
+/>
+`;

data/webpack/ForemanTasks/Components/TaskActions/index.js

@@ -0,0 +1,115 @@
+import { sprintf } from 'foremanReact/common/I18n';
+import { API } from 'foremanReact/redux/API';
+import { addToast } from 'foremanReact/redux/actions/toasts';
+import {
+  TASKS_RESUME_REQUEST,
+  TASKS_RESUME_SUCCESS,
+  TASKS_RESUME_FAILURE,
+  TASKS_CANCEL_REQUEST,
+  TASKS_CANCEL_SUCCESS,
+  TASKS_CANCEL_FAILURE,
+  TASKS_FORCE_CANCEL_REQUEST,
+  TASKS_FORCE_CANCEL_SUCCESS,
+  TASKS_FORCE_CANCEL_FAILURE,
+  TASKS_UNLOCK_REQUEST,
+  TASKS_UNLOCK_SUCCESS,
+  TASKS_UNLOCK_FAILURE,
+} from './TaskActionsConstants';
+import { infoToastData } from '../common/ToastsHelpers/';
+import {
+  resumeToastInfo,
+  cancelToastInfo,
+  forceCancelToastInfo,
+  unlockToastInfo,
+  toastDispatch,
+} from './TaskActionHelpers';
+
+export const cancelTaskRequest = (id, name) => async dispatch => {
+  dispatch(addToast(infoToastData(sprintf('Trying to cancel %s task', name))));
+  dispatch({ type: TASKS_CANCEL_REQUEST });
+  try {
+    await API.post(`/foreman_tasks/tasks/${id}/cancel`);
+    dispatch({ type: TASKS_CANCEL_SUCCESS });
+    toastDispatch({
+      type: 'cancelled',
+      name,
+      toastInfo: cancelToastInfo,
+      dispatch,
+    });
+  } catch (error) {
+    dispatch({ type: TASKS_CANCEL_FAILURE, payload: error });
+    toastDispatch({
+      type: 'skipped',
+      name,
+      toastInfo: cancelToastInfo,
+      dispatch,
+    });
+  }
+};
+
+export const resumeTaskRequest = (id, name) => async dispatch => {
+  dispatch({ type: TASKS_RESUME_REQUEST });
+  try {
+    await API.post(`/foreman_tasks/tasks/${id}/resume`);
+
+    dispatch({ type: TASKS_RESUME_SUCCESS });
+    toastDispatch({
+      type: 'resumed',
+      name,
+      toastInfo: resumeToastInfo,
+      dispatch,
+    });
+  } catch (error) {
+    dispatch({ type: TASKS_RESUME_FAILURE, payload: error });
+    toastDispatch({
+      type: 'failed',
+      name,
+      toastInfo: resumeToastInfo,
+      dispatch,
+    });
+  }
+};
+
+export const forceCancelTaskRequest = (id, name) => async dispatch => {
+  dispatch({ type: TASKS_FORCE_CANCEL_REQUEST });
+  try {
+    await API.post(`/foreman_tasks/tasks/${id}/force_unlock`);
+    dispatch({ type: TASKS_FORCE_CANCEL_SUCCESS });
+    toastDispatch({
+      type: 'forceCancelled',
+      name,
+      toastInfo: forceCancelToastInfo,
+      dispatch,
+    });
+  } catch ({ response }) {
+    dispatch({ type: TASKS_FORCE_CANCEL_FAILURE });
+    toastDispatch({
+      type: 'failed',
+      name,
+      toastInfo: forceCancelToastInfo,
+      dispatch,
+    });
+  }
+};
+
+export const unlockTaskRequest = (id, name) => async dispatch => {
+  dispatch({ type: TASKS_UNLOCK_REQUEST });
+  try {
+    await API.post(`/foreman_tasks/tasks/${id}/unlock`);
+    dispatch({ type: TASKS_UNLOCK_SUCCESS });
+    toastDispatch({
+      type: 'unlocked',
+      name,
+      toastInfo: unlockToastInfo,
+      dispatch,
+    });
+  } catch ({ response }) {
+    dispatch({ type: TASKS_UNLOCK_FAILURE });
+    toastDispatch({
+      type: 'failed',
+      name,
+      toastInfo: unlockToastInfo,
+      dispatch,
+    });
+  }
+};

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

@@ -3,7 +3,13 @@ import PropTypes from 'prop-types';
 import { Alert, Button } from 'patternfly-react';
 import { translate as __ } from 'foremanReact/common/I18n';
 
-const RunningSteps = ({ runningSteps }) => {
+const RunningSteps = ({
+  runningSteps,
+  id,
+  cancelStep,
+  taskReload,
+  taskReloadStart,
+}) => {
   if (!runningSteps.length) return <span>{__('No running steps')}</span>;
   return (
     <div>
@@ -13,8 +19,12 @@ const RunningSteps = ({ runningSteps }) => {
             <p>
               <Button
                 bsSize="small"
-                data-method="post"
-                href={`/foreman_tasks/tasks/${step.id}/cancel_step`}
+                onClick={() => {
+                  if (!taskReload) {
+                    taskReloadStart(id);
+                  }
+                  cancelStep(id, step.id);
+                }}
               >
                 {__('Cancel')}
               </Button>
@@ -46,6 +56,10 @@ const RunningSteps = ({ runningSteps }) => {
 
 RunningSteps.propTypes = {
   runningSteps: PropTypes.array,
+  id: PropTypes.string.isRequired,
+  cancelStep: PropTypes.func.isRequired,
+  taskReload: PropTypes.bool.isRequired,
+  taskReloadStart: PropTypes.func.isRequired,
 };
 
 RunningSteps.defaultProps = {

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

@@ -1,219 +1,52 @@
-import React, { Component } from 'react';
-import PropTypes from 'prop-types';
-import { Grid, Row, Col, Button } from 'patternfly-react';
-import { translate as __ } from 'foremanReact/common/I18n';
+import React from 'react';
+import { Grid, Row } from 'patternfly-react';
 import TaskInfo from './TaskInfo';
-import { ClickConfirmation } from '../../common/ClickConfirmation';
-import { ResumeButton } from '../../common/ActionButtons/ResumeButton';
-import { CancelButton } from '../../common/ActionButtons/CancelButton';
+import { ForceUnlockModal, UnlockModal } from '../../TaskActions/UnlockModals';
+import { TaskButtons } from './TaskButtons';
 
-class Task extends Component {
-  taskProgressToggle = () => {
-    const {
-      timeoutId,
-      refetchTaskDetails,
-      id,
-      loading,
-      taskReloadStop,
-      taskReloadStart,
-    } = this.props;
-    if (timeoutId) {
-      taskReloadStop(timeoutId);
-    } else {
-      taskReloadStart(timeoutId, refetchTaskDetails, id, loading);
+const Task = props => {
+  const {
+    taskReload,
+    id,
+    forceCancelTaskRequest,
+    unlockTaskRequest,
+    action,
+    taskReloadStart,
+  } = props;
+  const forceUnlock = () => {
+    if (!taskReload) {
+      taskReloadStart(id);
     }
+    forceCancelTaskRequest(id, action);
   };
-
-  render() {
-    const {
-      taskReload,
-      externalId,
-      id,
-      state,
-      allowDangerousActions,
-      resumable,
-      cancellable,
-      hasSubTasks,
-      parentTask,
-      showUnlockModal,
-      showForceUnlockModal,
-      toggleUnlockModal,
-      toggleForceUnlockModal,
-      cancelTaskRequest,
-      resumeTaskRequest,
-      action,
-      dynflowEnableConsole,
-    } = this.props;
-    const modalUnlock = (
-      <ClickConfirmation
-        showModal={showUnlockModal}
-        title={__('Unlock')}
-        body={__(
-          "This will unlock the resources that the task is running against. Please note that this might lead to inconsistent state and should be used with caution, after making sure that the task can't be resumed."
-        )}
-        confirmationMessage={__(
-          'I understand that this may cause harm and have working database backups of all backend services.'
-        )}
-        confirmAction={__('Unlock')}
-        path={`/foreman_tasks/tasks/${id}/unlock`}
-        confirmType="warning"
-        closeModal={toggleUnlockModal}
-      />
-    );
-
-    const modalForceUnlock = (
-      <ClickConfirmation
-        showModal={showForceUnlockModal}
-        title={__('Force Unlock')}
-        body={__(
-          'Resources will be unlocked and will not prevent other tasks from being run. As the task might be still running, it should be avoided to use this unless you are really sure the task got stuck'
-        )}
-        confirmationMessage={__(
-          'I understand that this may cause harm and have working database backups of all backend services.'
-        )}
-        confirmAction={__('Force Unlock')}
-        path={`/foreman_tasks/tasks/${id}/force_unlock`}
-        confirmType="danger"
-        closeModal={toggleForceUnlockModal}
-      />
-    );
-    return (
-      <React.Fragment>
-        {modalUnlock}
-        {modalForceUnlock}
-        <Grid>
-          <Row>
-            <Col xs={12}>
-              <Button
-                hidden={!allowDangerousActions}
-                className="reload-button"
-                bsSize="small"
-                onClick={this.taskProgressToggle}
-              >
-                <span
-                  className={`glyphicon glyphicon-refresh ${
-                    taskReload ? 'spin' : ''
-                  }`}
-                />
-                {__(`${taskReload ? 'Stop' : 'Start'}  auto-reloading`)}
-              </Button>
-              <Button
-                bsSize="small"
-                href={`/foreman_tasks/dynflow/${externalId}`}
-                disabled={!dynflowEnableConsole}
-              >
-                {__('Dynflow console')}
-              </Button>
-              <ResumeButton
-                id={id}
-                onClick={() => {
-                  if (!taskReload) {
-                    this.taskProgressToggle();
-                  }
-                  resumeTaskRequest(id, action);
-                }}
-                name={action}
-                disabled={!resumable}
-              />
-              <CancelButton
-                id={id}
-                name={action}
-                disabled={!cancellable}
-                onClick={() => {
-                  if (!taskReload) {
-                    this.taskProgressToggle();
-                  }
-                  cancelTaskRequest(id, action);
-                }}
-              />
-              {parentTask && (
-                <Button
-                  bsSize="small"
-                  href={`/foreman_tasks/tasks/${parentTask}`}
-                >
-                  {__('Parent task')}
-                </Button>
-              )}
-              {hasSubTasks && (
-                <Button
-                  bsSize="small"
-                  href={`/foreman_tasks/tasks/${id}/sub_tasks`}
-                >
-                  {__('Sub tasks')}
-                </Button>
-              )}
-              {allowDangerousActions && (
-                <Button
-                  bsSize="small"
-                  disabled={state !== 'paused'}
-                  onClick={toggleUnlockModal}
-                >
-                  {__('Unlock')}
-                </Button>
-              )}
-              {allowDangerousActions && (
-                <Button
-                  bsSize="small"
-                  disabled={state === 'stopped'}
-                  onClick={toggleForceUnlockModal}
-                >
-                  {__('Force Unlock')}
-                </Button>
-              )}
-            </Col>
-          </Row>
-          <TaskInfo {...this.props} />
-        </Grid>
-      </React.Fragment>
-    );
-  }
-}
+  const unlock = () => {
+    if (!taskReload) {
+      taskReloadStart(id);
+    }
+    unlockTaskRequest(id, action);
+  };
+  return (
+    <React.Fragment>
+      <UnlockModal onClick={unlock} />
+      <ForceUnlockModal onClick={forceUnlock} />
+      <Grid>
+        <Row>
+          <TaskButtons taskReloadStart={taskReloadStart} {...props} />
+        </Row>
+        <TaskInfo {...props} />
+      </Grid>
+    </React.Fragment>
+  );
+};
 
 Task.propTypes = {
   ...TaskInfo.PropTypes,
-  state: PropTypes.string,
-  allowDangerousActions: PropTypes.bool,
-  resumable: PropTypes.bool,
-  cancellable: PropTypes.bool,
-  refetchTaskDetails: PropTypes.func,
-  hasSubTasks: PropTypes.bool,
-  parentTask: PropTypes.string,
-  taskReload: PropTypes.bool,
-  taskReloadStop: PropTypes.func,
-  taskReloadStart: PropTypes.func,
-  timeoutId: PropTypes.number,
-  externalId: PropTypes.string,
-  id: PropTypes.string.isRequired,
-  showUnlockModal: PropTypes.bool,
-  showForceUnlockModal: PropTypes.bool,
-  toggleUnlockModal: PropTypes.func,
-  toggleForceUnlockModal: PropTypes.func,
-  cancelTaskRequest: PropTypes.func,
-  resumeTaskRequest: PropTypes.func,
-  dynflowEnableConsole: PropTypes.bool,
+  ...TaskButtons.PropTypes,
 };
 
 Task.defaultProps = {
   ...TaskInfo.defaultProps,
-  state: '',
-  allowDangerousActions: false,
-  resumable: false,
-  cancellable: false,
-  refetchTaskDetails: () => null,
-  hasSubTasks: false,
-  parentTask: '',
-  taskReload: false,
-  taskReloadStop: () => null,
-  taskReloadStart: () => null,
-  timeoutId: null,
-  externalId: '',
-  showUnlockModal: false,
-  showForceUnlockModal: false,
-  toggleUnlockModal: () => null,
-  toggleForceUnlockModal: () => null,
-  cancelTaskRequest: () => null,
-  resumeTaskRequest: () => null,
-  dynflowEnableConsole: false,
+  ...TaskButtons.defaultProps,
 };
 
 export default Task;