foreman-tasks 0.16.0 → 0.16.1

data/config/routes.rb

@@ -35,6 +35,9 @@ Foreman::Application.routes.draw do
       end
 
       resources :tasks, :only => [:show, :index] do
+        member do
+          get :details
+        end
         collection do
           post :bulk_search
           post :bulk_resume

data/lib/foreman_tasks/engine.rb

@@ -58,7 +58,7 @@ module ForemanTasks
         security_block :foreman_tasks do |_map|
           permission :view_foreman_tasks, { :'foreman_tasks/tasks' => [:auto_complete_search, :sub_tasks, :index, :summary, :show],
                                             :'foreman_tasks/react' => [:index],
-                                            :'foreman_tasks/api/tasks' => [:bulk_search, :show, :index, :summary] }, :resource_type => ForemanTasks::Task.name
+                                            :'foreman_tasks/api/tasks' => [:bulk_search, :show, :index, :summary, :details] }, :resource_type => ForemanTasks::Task.name
           permission :edit_foreman_tasks, { :'foreman_tasks/tasks' => [:resume, :unlock, :force_unlock, :cancel_step, :cancel, :abort],
                                             :'foreman_tasks/api/tasks' => [:bulk_resume] }, :resource_type => ForemanTasks::Task.name
 

data/lib/foreman_tasks/tasks/export_tasks.rake

@@ -211,7 +211,6 @@ namespace :foreman_tasks do
          'javascripts/application.js',
          'vendor/bootstrap/css/bootstrap.css',
          'stylesheets/application.css'].each do |file|
-
           filename = File.join(Gem::Specification.find_by_name('dynflow').gem_dir, 'web', 'assets', file) # rubocop:disable Rails/DynamicFindBy
           FileUtils.copy_file(filename, File.join(tmp_dir, File.basename(file)))
         end
@@ -244,6 +243,7 @@ namespace :foreman_tasks do
 
     tasks = ForemanTasks::Task.search_for(filter)
 
+    puts _("Exporting all tasks matching filter #{filter}")
     puts _("Gathering #{tasks.count} tasks.")
     if format == 'html'
       Dir.mktmpdir('task-export') do |tmp_dir|
@@ -255,7 +255,6 @@ namespace :foreman_tasks do
         tasks.each_with_index do |task, count|
           File.open(File.join(tmp_dir, "#{task.id}.html"), 'w') { |file| file.write(PageHelper.pagify(renderer.render_task(task))) }
           puts "#{count + 1}/#{total}"
-          count += 1
         end
 
         File.open(File.join(tmp_dir, 'index.html'), 'w') { |file| file.write(PageHelper.pagify(PageHelper.generate_index(tasks))) }

data/lib/foreman_tasks/version.rb

@@ -1,3 +1,3 @@
 module ForemanTasks
-  VERSION = '0.16.0'.freeze
+  VERSION = '0.16.1'.freeze
 end

data/package.json

@@ -21,17 +21,22 @@
   "bugs": {
     "url": "http://projects.theforeman.org/projects/foreman-tasks/issues"
   },
+  "dependencies": {
+    "@theforeman/vendor": "^0.1.1",
+    "humanize-duration": "^3.20.1",
+    "react-intl": "^2.8.0"
+  },
   "devDependencies": {
     "@storybook/addon-actions": "^5.0.1",
     "@storybook/addon-knobs": "^5.0.1",
     "@storybook/react": "^5.0.1",
+    "@theforeman/vendor-dev": "^0.1.1",
     "babel-cli": "^6.10.1",
     "babel-core": "^6.26.3",
     "babel-eslint": "^8.2.3",
     "babel-jest": "^23.6.0",
     "babel-loader": "^7.1.1",
     "babel-plugin-dynamic-import-node": "^2.0.0",
-    "babel-plugin-lodash": "^3.3.4",
     "babel-plugin-module-resolver": "^3.2.0",
     "babel-plugin-syntax-dynamic-import": "^6.18.0",
     "babel-plugin-transform-class-properties": "^6.24.1",
@@ -61,25 +66,6 @@
     "stylelint-config-standard": "^18.0.0",
     "surge": "^0.20.3"
   },
-  "dependencies": {
-    "babel-polyfill": "^6.26.0",
-    "classnames": "^2.2.5",
-    "lodash": "^4.17.11",
-    "patternfly-react": "^2.29.0",
-    "prop-types": "^15.6.0",
-    "react": "^16.8.1",
-    "react-dom": "^16.8.1",
-    "react-redux": "^5.0.6",
-    "react-router": "^4.3.1",
-    "react-router-bootstrap": "^0.24.4",
-    "react-router-dom": "^4.3.1",
-    "redux": "^3.6.0",
-    "redux-thunk": "^2.3.0",
-    "reselect": "^3.0.1",
-    "seamless-immutable": "^7.1.2",
-    "urijs": "^1.19.1",
-    "uuid": "^3.3.2"
-  },
   "jest": {
     "verbose": true,
     "testMatch": [

data/test/controllers/tasks_controller_test.rb

@@ -67,6 +67,17 @@ module ForemanTasks
                           session: set_session_user(User.current)
           assert_response :not_found
         end
+
+        it 'supports csv export' do
+          parent = FactoryBot.create(:some_task, :action => 'Some action')
+          child = FactoryBot.create(:some_task, :action => 'Child action')
+          child.parent_task_id = parent.id
+          child.save!
+          get(:sub_tasks, params: { id: parent.id, format: :csv }, session: set_session_user)
+          assert_response :success
+          assert_equal 2, response.body.lines.size
+          assert_include response.body.lines[1], 'Child action'
+        end
       end
 
       describe 'taxonomy scoping' do

data/test/helpers/foreman_tasks/foreman_tasks_helper_test.rb

@@ -0,0 +1,39 @@
+require 'foreman_tasks_test_helper'
+
+module ForemanTasks
+  class ForemanTasksHelperTest < ActionView::TestCase
+    describe 'breadcrumb items' do
+      before do
+        self.class.send(:include, ForemanTasks::TasksHelper)
+      end
+
+      it 'prepares items for index correctly' do
+        stubs(:action_name).returns('index')
+        items = breadcrumb_items
+        items.count.must_equal 1
+        items.first[:caption].must_equal 'Tasks'
+        items.first[:url].must_be_nil
+      end
+
+      it 'prepares items for show correctly' do
+        @task = FactoryBot.build(:dynflow_task, :user_create_task)
+        @task.action = 'A task'
+        stubs(:action_name).returns('show')
+        items = breadcrumb_items
+        items.map { |i| i[:caption] }.must_equal ['Tasks', 'A task']
+        items.last[:url].must_be_nil
+      end
+
+      it 'prepares items for sub tasks correctly' do
+        @task = FactoryBot.build(:dynflow_task, :user_create_task)
+        child = FactoryBot.build(:dynflow_task, :user_create_task)
+        @task.sub_tasks = [child]
+        @task.action = 'A task'
+        stubs(:action_name).returns('sub_tasks')
+        items = breadcrumb_items
+        items.map { |i| i[:caption] }.must_equal ['Tasks', 'A task', 'Sub tasks']
+        items.last[:url].must_be_nil
+      end
+    end
+  end
+end

data/test/unit/actions/bulk_action_test.rb

@@ -28,6 +28,7 @@ module ForemanTasks
       end
 
       specify 'it plans a task for each target' do
+        Target.expects(:unscoped).returns(Target)
         Target.expects(:where).with(:id => targets.map(&:id)).returns(targets)
 
         task.sub_tasks.count.must_equal targets.count
@@ -37,6 +38,7 @@ module ForemanTasks
       end
 
       specify 'it plans a task for each target even if target cannot be found' do
+        Target.expects(:unscoped).returns(Target)
         Target.expects(:where).with(:id => targets.map(&:id)).returns(targets.take(4))
 
         task.sub_tasks.count.must_equal targets.count

data/test/unit/task_test.rb

@@ -43,6 +43,10 @@ class TasksTest < ActiveSupport::TestCase
     test 'can search the tasks by array' do
       assert_equal [@task_one], ForemanTasks::Task.search_for("user ^ (this_user, #{@user_one.login}, that_user)")
     end
+
+    test 'properly returns username' do
+      assert_equal @task_one.username, @user_one.login
+    end
   end
 
   describe 'state_updated_at' do

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

@@ -0,0 +1,60 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { Alert } from 'patternfly-react';
+import { translate as __ } from 'foremanReact/common/I18n';
+
+const Errors = ({ ...props }) => {
+  const { failedSteps, executionPlan } = props;
+  if (!executionPlan)
+    return (
+      <Alert type="error">{__('Execution plan data not available ')}</Alert>
+    );
+  if (!failedSteps.length)
+    return <Alert type="success">{__('No errors')}</Alert>;
+  return (
+    <div>
+      {failedSteps.map((step, i) => (
+        <Alert type="error" key={i}>
+          <span>{__('Action')}:</span>
+          <span>
+            <pre>{step.action_class}</pre>
+          </span>
+          <span>{__('Input')}:</span>
+          <span>
+            <pre>{step.input}</pre>
+          </span>
+          <span>{__('Output')}:</span>
+          <span>
+            <pre>{step.output}</pre>
+          </span>
+          {step.error && (
+            <React.Fragment>
+              <span>{__('Exception')}:</span>
+              <span>
+                <pre>
+                  {step.error.exception_class}: {step.error.message}
+                </pre>
+              </span>
+              <span>{__('Backtrace')}:</span>
+              <span>
+                <pre>{step.error.backtrace.join('\n')}</pre>
+              </span>
+            </React.Fragment>
+          )}
+        </Alert>
+      ))}
+    </div>
+  );
+};
+
+Errors.propTypes = {
+  failedSteps: PropTypes.array,
+  executionPlan: PropTypes.shape({}),
+};
+
+Errors.defaultProps = {
+  failedSteps: [],
+  executionPlan: {},
+};
+
+export default Errors;

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

@@ -0,0 +1,46 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { Alert, Card, Row, Col } from 'patternfly-react';
+import { translate as __ } from 'foremanReact/common/I18n';
+
+const Locks = ({ locks }) => (
+  <div>
+    <Alert type="info">
+      {__(
+        'You can find resource locks on this page. Exclusive lock marked with locked icon means that no other task can use locked resource while this task is running. Non-exclusive lock marked with unlocked icon means other tasks can access the resource freely, it is only used to indicate the relation of this task with the resource'
+      )}
+    </Alert>
+    <Card.Grid>
+      <Row>
+        {locks.map((lock, key) => (
+          <Col xs={6} sm={4} md={4} key={key}>
+            <Card className="card-pf-aggregate-status" accented>
+              <Card.Title>
+                <span
+                  className={`fa ${
+                    lock.exclusive ? 'fa-lock' : 'fa-unlock-alt'
+                  }`}
+                />
+                {lock.name}
+              </Card.Title>
+              <Card.Body>
+                {`${lock.resource_type} id:${lock.resource_id}`}
+                <br />
+              </Card.Body>
+            </Card>
+          </Col>
+        ))}
+      </Row>
+    </Card.Grid>
+  </div>
+);
+
+Locks.propTypes = {
+  locks: PropTypes.array,
+};
+
+Locks.defaultProps = {
+  locks: [],
+};
+
+export default Locks;

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

@@ -0,0 +1,73 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { translate as __ } from 'foremanReact/common/I18n';
+
+import { durationInWords } from './TaskHelper';
+
+const Raw = ({ id, label, startedAt, endedAt, input, output, externalId }) => (
+  <div>
+    <div>
+      <span className="param-name list-group-item-heading">{__('Id')}:</span>
+      <span className="param-value">{id}</span>
+    </div>
+    <div>
+      <span className="param-name list-group-item-heading">{__('Label')}:</span>
+      <span className="param-value">{label}</span>
+    </div>
+    <div>
+      <span className="param-name list-group-item-heading">
+        {__('Duration')}:
+      </span>
+      <span
+        className="param-value"
+        title={durationInWords(startedAt, endedAt || new Date()).tooltip}
+      >
+        {durationInWords(startedAt, endedAt || new Date()).text}
+      </span>
+    </div>
+    <div>
+      <span className="param-name list-group-item-heading">
+        {__('Raw input')}:
+      </span>
+      <span className="param-value">
+        <pre>{JSON.stringify(input, null, '  ')}</pre>
+      </span>
+    </div>
+    <div>
+      <span className="param-name list-group-item-heading">
+        {__('Raw output')}:
+      </span>
+      <span className="param-value">
+        <pre>{JSON.stringify(output, null, '  ')}</pre>
+      </span>
+    </div>
+    <div>
+      <span className="param-name list-group-item-heading">
+        {__('External Id')}:
+      </span>
+      <span className="param-value">{externalId}</span>
+    </div>
+  </div>
+);
+
+Raw.propTypes = {
+  id: PropTypes.string,
+  label: PropTypes.string,
+  startedAt: PropTypes.string,
+  endedAt: PropTypes.string,
+  input: PropTypes.oneOfType([PropTypes.array, PropTypes.shape({})]),
+  output: PropTypes.shape({}),
+  externalId: PropTypes.string,
+};
+
+Raw.defaultProps = {
+  id: '',
+  label: '',
+  startedAt: '',
+  endedAt: '',
+  input: [],
+  output: {},
+  externalId: '',
+};
+
+export default Raw;

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

@@ -0,0 +1,55 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { Alert, Button } from 'patternfly-react';
+import { translate as __ } from 'foremanReact/common/I18n';
+
+const RunningSteps = ({ runningSteps }) => {
+  if (!runningSteps.length) return <span>{__('No running steps')}</span>;
+  return (
+    <div>
+      {runningSteps.map((step, i) => (
+        <Alert type="warning" key={i}>
+          {step.cancellable && (
+            <p>
+              <Button
+                bsSize="small"
+                data-method="post"
+                href={`/foreman_tasks/tasks/${step.id}/cancel_step`}
+              >
+                {__('Cancel')}
+              </Button>
+            </p>
+          )}
+
+          <p>
+            <span>{__('Action')}:</span>
+            <span />
+          </p>
+          <pre>{step.action_class}</pre>
+          <p>
+            <span>{__('State')}:</span>
+            <span>{step.state}</span>
+          </p>
+          <span>{__('Input')}:</span>
+          <span>
+            <pre>{step.input}</pre>
+          </span>
+          <span>{__('Output')}:</span>
+          <span>
+            <pre>{step.output}</pre>
+          </span>
+        </Alert>
+      ))}
+    </div>
+  );
+};
+
+RunningSteps.propTypes = {
+  runningSteps: PropTypes.array,
+};
+
+RunningSteps.defaultProps = {
+  runningSteps: [],
+};
+
+export default RunningSteps;

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

@@ -0,0 +1,202 @@
+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 TaskInfo from './TaskInfo';
+import { ClickConfirmation } from '../../common/ClickConfirmation';
+
+class Task extends Component {
+  taskProgressToggle = () => {
+    const {
+      timeoutId,
+      refetchTaskDetails,
+      id,
+      loading,
+      taskReloadStop,
+      taskReloadStart,
+    } = this.props;
+    if (timeoutId) {
+      taskReloadStop(timeoutId);
+    } else {
+      taskReloadStart(timeoutId, refetchTaskDetails, id, loading);
+    }
+  };
+
+  render() {
+    const {
+      taskReload,
+      externalId,
+      id,
+      state,
+      allowDangerousActions,
+      resumable,
+      cancellable,
+      hasSubTasks,
+      parentTask,
+      showUnlockModal,
+      showForceUnlockModal,
+      toggleUnlockModal,
+      toggleForceUnlockModal,
+    } = 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}`}
+              >
+                {__('Dynflow console')}
+              </Button>
+              <Button
+                bsSize="small"
+                bsStyle="primary"
+                data-method="post"
+                href={`/foreman_tasks/tasks/${id}/resume`}
+                disabled={!resumable}
+              >
+                {__('Resume')}
+              </Button>
+              <Button
+                bsSize="small"
+                data-method="post"
+                href={`/foreman_tasks/tasks/${id}/cancel`}
+                disabled={!cancellable}
+              >
+                {__('Cancel')}
+              </Button>
+
+              {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>
+    );
+  }
+}
+
+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,
+};
+
+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,
+};
+
+export default Task;