foreman-tasks 0.15.1 → 0.15.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9be0418b3db898832481c46ba3f3eae300e2562d7fa240d71cb96876ee825de
-  data.tar.gz: 61db2a1487d48b7312478c3ad65adffa2230c2fbe9f5a452d200cc4b56428962
+  metadata.gz: 9daa93c0112f4c796a124787624ad95f01e241bcc2f80912560eb548cabc080d
+  data.tar.gz: 0f2577e225a712c6e5041cb9c5006ac5707bf6f36cde9d9525f5118557037249
 SHA512:
-  metadata.gz: d303c00a15e97cbf2c5fe443559a5bd2260298e8b54e52e552040c93fb8885caba6130f7957ce097bfbddafee4a4b3b1bd1a8d41786471b88cd306876496f2f9
-  data.tar.gz: f4a036829b034d94577d0affce68fdb899bbcdeaf0bef74f8b2358d0cb165ac9e42b7afc8111060210d6eb90bc5289d3af5d49ca6fa88b4f05bd7464a5c94480
+  metadata.gz: 5aafc0509dedd3a27aeadbca202772220916f0e3ac20b35f28a8f25ece3190273b7c845f054d0be09ff1298a9cd244430cadf9294566a1cbfa570054a1a0de99
+  data.tar.gz: 25705ff172efabb0cbba2725c61571f113a017cc85c4a386825d151dac30799d3c7257b38640c7a5ee7f460bcd1baa3a6e2d7b221397c57debba3e62c2949a0f

data/.babelrc

@@ -18,7 +18,15 @@
   ],
   "env": {
     "test": {
-      "plugins": ["dynamic-import-node"]
+      "plugins": [
+        ["module-resolver", {
+          "alias": {
+            "root": ["./"],
+            "foremanReact": "./webpack/__mocks__/foremanReact"
+          }
+        }],
+        "dynamic-import-node"
+      ]
     }
   }
 }

data/.eslintrc

@@ -5,6 +5,12 @@
     "prettier/prettier": ["error", {
       "singleQuote": true,
       "trailingComma": "es5"
+    }],
+    "import/no-unresolved": ["error", {
+      "ignore": ['foremanReact/.*']
+    }],
+    "import/extensions": ["error", {
+      "ignore": ['foremanReact/.*']
     }]
   },
   "settings": {

data/.gitignore

@@ -16,3 +16,4 @@ locale/*/*.po.time_stamp
 node_modules
 package-lock.json
 coverage/
+.storybook-dist

data/.rubocop.yml

@@ -104,3 +104,9 @@ Style/FormatStringToken:
 
 Style/RegexpLiteral:
   Enabled: false
+
+Layout/AlignHash:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false

data/.storybook/webpack.config.js

@@ -1,66 +1,63 @@
 let path = require('path');
 
-// Use storybook's default configuration with our customizations
-module.exports = (baseConfig, env, defaultConfig) => {
-
-  // overwrite storybook's default import rules
-  defaultConfig.module.rules = [
-    {
-      test: /\.js$/,
-      exclude: /node_modules/,
-      loader: 'babel-loader',
-      options: {
-        presets: [
-          path.join(__dirname, '..', 'node_modules/babel-preset-react'),
-          path.join(__dirname, '..', 'node_modules/babel-preset-env')
-        ],
-        plugins: [
-          path.join(__dirname, '..', 'node_modules/babel-plugin-transform-class-properties'),
-          path.join(__dirname, '..', 'node_modules/babel-plugin-transform-object-rest-spread'),
-          path.join(__dirname, '..', 'node_modules/babel-plugin-transform-object-assign'),
-          path.join(__dirname, '..', 'node_modules/babel-plugin-syntax-dynamic-import')
-        ]
-      }
-    },
-    {
-      test: /(\.png|\.gif)$/,
-      loader: 'url-loader?limit=32767'
-    },
-    {
-      test: /\.css$/,
-      loaders: ['style-loader', 'css-loader']
-    },
-    {
-      test: /\.scss$/,
-      loaders: ['style-loader', 'css-loader', {
-        loader: 'sass-loader',
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.js$/,
+        exclude: /node_modules/,
+        loader: 'babel-loader',
         options: {
-          includePaths: [
-            // teach webpack to resolve patternfly dependencies
-            path.resolve(__dirname, '..', 'node_modules', 'patternfly', 'dist', 'sass'),
-            path.resolve(__dirname, '..', 'node_modules', 'bootstrap-sass', 'assets', 'stylesheets'),
-            path.resolve(__dirname, '..', 'node_modules', 'font-awesome-sass', 'assets', 'stylesheets')
+          presets: [
+            path.join(__dirname, '..', 'node_modules/babel-preset-react'),
+            path.join(__dirname, '..', 'node_modules/babel-preset-env')
+          ],
+          plugins: [
+            path.join(__dirname, '..', 'node_modules/babel-plugin-transform-class-properties'),
+            path.join(__dirname, '..', 'node_modules/babel-plugin-transform-object-rest-spread'),
+            path.join(__dirname, '..', 'node_modules/babel-plugin-transform-object-assign'),
+            path.join(__dirname, '..', 'node_modules/babel-plugin-syntax-dynamic-import')
           ]
         }
-      }]
-    },
-    {
-      test: /\.md$/,
-      loaders: ['raw-loader']
-    },
-    {
-      test: /(\.ttf|\.woff|\.woff2|\.eot|\.svg|\.jpg)$/,
-      loaders: ['url-loader']
-    },
-  ]
+      },
+      {
+        test: /(\.png|\.gif)$/,
+        loader: 'url-loader?limit=32767'
+      },
+      {
+        test: /\.css$/,
+        loaders: ['style-loader', 'css-loader'],
+      },
+      {
+        test: /\.scss$/,
+        loaders: ['style-loader', 'css-loader', {
+          loader: 'sass-loader',
+          options: {
+            includePaths: [
+              // teach webpack to resolve patternfly dependencies
+              path.resolve(__dirname, '..', 'node_modules', 'patternfly', 'dist', 'sass'),
+              path.resolve(__dirname, '..', 'node_modules', 'bootstrap-sass', 'assets', 'stylesheets'),
+              path.resolve(__dirname, '..', 'node_modules', 'font-awesome-sass', 'assets', 'stylesheets')
+            ]
+          }
+        }]
+      },
+      {
+        test: /\.md$/,
+        loaders: ['raw-loader']
+      },
+      {
+        test: /(\.ttf|\.woff|\.woff2|\.eot|\.svg|\.jpg)$/,
+        loaders: ['url-loader']
+      },
+    ],
+  },
 
-  defaultConfig.resolve = {
+  resolve: {
     modules: [
       path.join(__dirname, '..', 'webpack'),
       path.join(__dirname, '..', 'node_modules'),
       'node_modules/',
     ],
-  };
-
-  return defaultConfig;
+  },
 };

data/app/controllers/foreman_tasks/api/tasks_controller.rb

@@ -1,5 +1,4 @@
 module ForemanTasks
-  # rubocop:disable Metrics/ClassLength
   module Api
     class TasksController < ::Api::V2::BaseController
       include ::Foreman::Controller::SmartProxyAuth
@@ -285,5 +284,4 @@ module ForemanTasks
       end
     end
   end
-  # rubocop:enable Metrics/ClassLength
 end

data/app/controllers/foreman_tasks/tasks_controller.rb

@@ -24,6 +24,10 @@ module ForemanTasks
       end
     end
 
+    def summary
+      render json: Task::Summarizer.new(params[:recent_timeframe].to_i).summary
+    end
+
     def sub_tasks
       task   = Task.find(params[:id])
       @tasks = filter(task.sub_tasks)
@@ -109,7 +113,7 @@ module ForemanTasks
 
     def action_permission
       case params[:action]
-      when 'sub_tasks'
+      when 'sub_tasks', 'summary'
         :view
       when 'resume', 'unlock', 'force_unlock', 'cancel_step', 'cancel', 'abort'
         :edit
@@ -129,6 +133,7 @@ module ForemanTasks
     def filter(scope, paginate: true)
       search = current_taxonomy_search
       search = [search, params[:search]].select(&:present?).join(' AND ')
+      scope = DashboardTableFilter.new(scope, params).scope
       scope = scope.search_for(search, :order => params[:order])
       scope = scope.paginate(:page => params[:page], :per_page => params[:per_page]) if paginate
       scope.distinct

data/app/helpers/foreman_tasks/foreman_tasks_helper.rb

@@ -17,6 +17,14 @@ module ForemanTasks
       content_tag(:i, '&nbsp'.html_safe, :class => "glyphicon #{icon}") + content_tag(:span, recurring_logic.humanized_state, :class => status)
     end
 
+    def troubleshooting_info
+      return if @task.state != 'paused' || @task.main_action.nil?
+      helper = TroubleshootingHelpGenerator.new(@task.main_action)
+      ret = '<p><b>Troubleshooting</b></p>'
+      ret += '<p>%{help}</p>' % { help: helper.generate_html }
+      ret.html_safe
+    end
+
     def task_result_icon_class(task)
       return 'task-status pficon-help' if task.state != 'stopped'
 

data/app/lib/actions/base.rb

@@ -1,6 +1,9 @@
 module Actions
   class Base < Dynflow::Action
     middleware.use ::Actions::Middleware::RailsExecutorWrap
+    include Actions::Helpers::LifecycleLogging
+
+    execution_plan_hooks.use :notify_paused, :on => [:paused]
 
     def task
       @task ||= ::ForemanTasks::Task::DynflowTask.where(:external_id => execution_plan_id).first!
@@ -52,5 +55,9 @@ module Actions
     def serializer_class
       ::Actions::Serializers::ActiveRecordSerializer
     end
+
+    def notify_paused(*_args)
+      task.build_notifications.each(&:deliver!) if root_action?
+    end
   end
 end

data/app/lib/actions/helpers/lifecycle_logging.rb

@@ -0,0 +1,21 @@
+module Actions
+  module Helpers
+    module LifecycleLogging
+      def self.included(base)
+        base.execution_plan_hooks.use :log_task_state_change
+      end
+
+      def log_task_state_change(execution_plan)
+        return unless root_action?
+        logger = Rails.application.dynflow.world.action_logger
+        task_id = ForemanTasks::Task::DynflowTask.where(external_id: execution_plan.id).pluck(:id).first
+
+        task_id_parts = []
+        task_id_parts << "id: #{task_id}" if task_id
+        task_id_parts << "execution_plan_id: #{execution_plan.id}"
+        result_info = " result: #{execution_plan.result}" if [:stopped, :paused].include?(execution_plan.state)
+        logger.info("Task {label: #{execution_plan.label}, #{task_id_parts.join(', ')}} state changed: #{execution_plan.state} #{result_info}")
+      end
+    end
+  end
+end

data/app/lib/actions/proxy_action.rb

@@ -154,7 +154,9 @@ module Actions
       if output.key?(:proxy_output) || state == :error
         output.fetch(:proxy_output, {})
       elsif live && proxy_task_id
-        proxy_data = proxy.status_of_task(proxy_task_id)['actions'].detect { |action| action['class'] == proxy_action_name }
+        proxy_data = proxy.status_of_task(proxy_task_id)['actions'].detect do |action|
+          action['class'] == proxy_action_name || action.fetch('input', {})['proxy_operation_name'] == proxy_operation_name
+        end
         proxy_data.fetch('output', {})
       else
         {}
@@ -193,7 +195,7 @@ module Actions
     end
 
     def with_batch_triggering?(proxy_version)
-      (proxy_version[:major] == 1 && proxy_version[:minor] > 20) || proxy_version[:major] > 1 &&
+      ((proxy_version[:major] == 1 && proxy_version[:minor] > 20) || proxy_version[:major] > 1) &&
         input.fetch(:connection_options, {}).fetch(:proxy_batch_triggering, false)
     end
 

data/app/models/foreman_tasks/task.rb

@@ -15,6 +15,7 @@ module ForemanTasks
 
     self.primary_key = :id
     before_create :generate_id
+    before_save :update_state_updated_at
 
     belongs_to :parent_task, :class_name => 'ForemanTasks::Task'
     has_many :sub_tasks, :class_name => 'ForemanTasks::Task', :foreign_key => :parent_task_id, :dependent => :nullify
@@ -39,6 +40,7 @@ module ForemanTasks
     scoped_search :on => :state, :complete_value => true
     scoped_search :on => :result, :complete_value => true
     scoped_search :on => :started_at, :complete_value => false
+    scoped_search :on => :state_updated_at, :complete_value => false
     scoped_search :on => :start_at, :complete_value => false
     scoped_search :on => :ended_at, :complete_value => false
     scoped_search :on => :parent_task_id, :complete_value => true
@@ -146,6 +148,23 @@ module ForemanTasks
       end
     end
 
+    # used by Foreman notifications framework
+    def notification_recipients_ids
+      owner_ids
+    end
+
+    def build_notifications
+      notifications = []
+      if paused?
+        owner = self.owner
+        if owner && !owner.hidden?
+          notifications << UINotifications::Tasks::TaskPausedOwner.new(self)
+        end
+        notifications << UINotifications::Tasks::TaskPausedAdmin.new(self)
+      end
+      notifications
+    end
+
     def self.search_by_generic_resource(key, operator, value)
       key = 'resource_type' if key.blank?
       key_name = connection.quote_column_name(key.sub(/^.*\./, ''))
@@ -269,5 +288,9 @@ module ForemanTasks
     def generate_id
       self.id ||= SecureRandom.uuid
     end
+
+    def update_state_updated_at
+      self.state_updated_at = Time.now.utc if changes.key?(:state)
+    end
   end
 end

data/app/models/foreman_tasks/task/summarizer.rb

@@ -1,15 +1,105 @@
 module ForemanTasks
   class Task::Summarizer
-    def summarize_by_status(since = nil)
-      result = ::ForemanTasks::Task.where("result <> 'success'")
-                                   .select('count(state) AS count, state, result, max(started_at) AS started_at')
-                                   .group(:state, :result).order(:state)
-      result = result.where('started_at > ?', since) if since
-      result
+    ENSURED_STATE_KEYS = %w[running paused stopped scheduled].freeze
+    ENSURED_RESULT_KEYS = %w[success error warning].freeze
+
+    # number of recent/total tasks for specific classification (state/result)
+    class Record
+      def initialize
+        @data = { recent: 0, total: 0 }
+      end
+
+      def to_h
+        @data.dup
+      end
+
+      # updates `field` (one of [:recent, :total]) with counts from aggregated_scope
+      def update(field, counts)
+        raise ArgumentError, "Unexpected field #{field}" unless @data.key?(field)
+        @data[field] = counts.sum(&:count)
+      end
+    end
+
+    # number of recent/total tasks for specific state + distribution across different results
+    # in `by_result` attribute
+    class RecordWithResult < Record
+      attr_reader :by_result
+
+      def initialize
+        super
+        @by_result = Hash.new { |h, k| h[k] = Record.new }
+        ENSURED_RESULT_KEYS.each { |result_value| @by_result[result_value] = Record.new }
+      end
+
+      def to_h
+        by_result_hash = @by_result.each.with_object({}) do |(result, record), hash|
+          hash[result] = record.to_h
+        end
+        super.update(by_result: by_result_hash)
+      end
+
+      # Updates the `field` summary + grouping by result
+      def update(field, counts)
+        super(field, counts)
+        counts.group_by(&:result).each do |(result, result_counts)|
+          @by_result[result].update(field, result_counts)
+        end
+      end
+    end
+
+    def initialize(recent_timeframe = 24)
+      @recent_timeframe = recent_timeframe.hours
+    end
+
+    def summarize_by_status
+      aggregated_scope.where("result <> 'success'")
     end
 
     def latest_tasks_in_errors_warning(limit = 5)
       ::ForemanTasks::Task.where('result in (?)', %w[error warning]).order('started_at DESC').limit(limit)
     end
+
+    # Returns summary of tasks count, grouped by `state` and `result`, if form of:
+    #
+    #    { 'running'   => { recent: 3, total: 6 },
+    #      'paused'    => { recent: 1, total: 3 },
+    #      'stopped'   => { recent: 3, total: 7,
+    #                       by_result: {
+    #                         'success' => { recent: 2, total: 4 },
+    #                         'warning' => { recent: 1, total: 2 },
+    #                         'error'   => { recent: 0, total: 1 },
+    #                       }}
+    #      'scheduled' => { recent: 0, total: 3 }}
+    #
+    def summary
+      @summary = Hash.new { |h, state| h[state] = Record.new }
+      ENSURED_STATE_KEYS.each do |state|
+        @summary[state] = state == 'stopped' ? RecordWithResult.new : Record.new
+      end
+
+      add_to_summary(aggregated_scope, :total)
+      add_to_summary(aggregated_recent_scope, :recent)
+
+      @summary.each.with_object({}) do |(key, record), hash|
+        hash[key] = record.to_h
+      end
+    end
+
+    private
+
+    def add_to_summary(aggregated_scope, field)
+      aggregated_scope.group_by(&:state).each do |(state, state_counts)|
+        @summary[state].update(field, state_counts)
+      end
+    end
+
+    def aggregated_scope
+      ::ForemanTasks::Task.select('count(state) AS count, state, result, max(started_at) AS started_at')
+                          .group(:state, :result).order(:state)
+    end
+
+    def aggregated_recent_scope
+      aggregated_scope.where("state_updated_at > ?", Time.now.utc - @recent_timeframe)
+    end
   end
 end