foreman-tasks 0.15.0 → 0.15.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e29d69e4d1a7ad804db75f4ce19d20004bdebced6e85e04d2648bcb5c571c2b1
-  data.tar.gz: 50e6b2708a35731579806eaef2a13c83dee4c92244db7a1a8f73c712e565891a
+  metadata.gz: d9be0418b3db898832481c46ba3f3eae300e2562d7fa240d71cb96876ee825de
+  data.tar.gz: 61db2a1487d48b7312478c3ad65adffa2230c2fbe9f5a452d200cc4b56428962
 SHA512:
-  metadata.gz: 311b48cc5a9cd2d8a502635f70a544b8e73fae9f7495148d67976f5e2ae0615c96ef7ca184b6992923e885abe942f0354e3f6ce0c76d0449f65099c1aede8077
-  data.tar.gz: f92ebcdad66e0f02ea0b3f27a954520792fe2e31a0057639fcec59e68658be686db75086c936aae6811b5ded4307cb9effccdec95e0554d7d7b047f6fb7d5762
+  metadata.gz: d303c00a15e97cbf2c5fe443559a5bd2260298e8b54e52e552040c93fb8885caba6130f7957ce097bfbddafee4a4b3b1bd1a8d41786471b88cd306876496f2f9
+  data.tar.gz: f4a036829b034d94577d0affce68fdb899bbcdeaf0bef74f8b2358d0cb165ac9e42b7afc8111060210d6eb90bc5289d3af5d49ca6fa88b4f05bd7464a5c94480

data/.babelrc

@@ -0,0 +1,24 @@
+{
+  "presets": [
+    "env",
+    "react"
+  ],
+  "plugins": [
+    ["module-resolver", {
+      "alias": {
+        "root": ["./"],
+        "foremanReact": "../foreman/webpack/assets/javascripts/react_app"
+      }
+    }],
+    "transform-class-properties",
+    "transform-object-rest-spread",
+    "transform-object-assign",
+    "lodash",
+    "syntax-dynamic-import"
+  ],
+  "env": {
+    "test": {
+      "plugins": ["dynamic-import-node"]
+    }
+  }
+}

data/.eslintrc

@@ -0,0 +1,27 @@
+{
+  "plugins": ["patternfly-react"],
+  "extends": ["plugin:patternfly-react/recommended"],
+  "rules": {
+    "prettier/prettier": ["error", {
+      "singleQuote": true,
+      "trailingComma": "es5"
+    }]
+  },
+  "settings": {
+    "import/resolver": {
+      "babel-module": {}
+    }
+  },
+  "globals": {
+    "document": false,
+    "escape": false,
+    "navigator": false,
+    "unescape": false,
+    "window": false,
+    "$": true,
+    "_": true,
+    "__": true,
+    "n__": true,
+    "d3": true
+  }
+}

data/.gitignore

@@ -13,3 +13,6 @@ locale/*.mo
 locale/*/*.pox
 locale/*/*.edit.po
 locale/*/*.po.time_stamp
+node_modules
+package-lock.json
+coverage/

data/.prettierrc

@@ -0,0 +1,4 @@
+{
+  "singleQuote": true,
+  "trailingComma": "es5"
+}

data/.rubocop.yml

@@ -59,7 +59,7 @@ Rails/ReversibleMigration:
 Metrics/BlockLength:
   Exclude:
     - config/routes.rb
-    - lib/foreman_remote_execution/engine.rb
+    - lib/foreman_tasks/engine.rb
     - test/**/*
     - lib/foreman_tasks/tasks/**/*
 

data/.storybook/addons.js

@@ -0,0 +1,2 @@
+import '@storybook/addon-actions/register';
+import '@storybook/addon-knobs/register';

data/.storybook/config.js

@@ -0,0 +1,7 @@
+import { configure } from '@storybook/react';
+
+function loadStories() {
+  require('../webpack/stories');
+}
+
+configure(loadStories, module);

data/.storybook/webpack.config.js

@@ -0,0 +1,66 @@
+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',
+        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 = {
+    modules: [
+      path.join(__dirname, '..', 'webpack'),
+      path.join(__dirname, '..', 'node_modules'),
+      'node_modules/',
+    ],
+  };
+
+  return defaultConfig;
+};

data/.stylelintrc

@@ -0,0 +1,5 @@
+{
+  "extends": [
+    "stylelint-config-standard",
+  ],
+}

data/.travis.yml

@@ -0,0 +1,5 @@
+language: node_js
+node_js:
+  - '8' # current LTS
+  - '10' # future LTS
+script: ./script/travis_run_js_tests.sh

data/.yo-rc.json

@@ -0,0 +1,5 @@
+{
+  "generator-react-domain": {
+    "depsInstalled": true
+  }
+}

data/README.md

@@ -22,6 +22,7 @@ happening/happened in your Foreman instance. A framework for asynchronous tasks
 | >= 1.17         | ~> 0.11.0      |
 | >= 1.18         | ~> 0.13.0      |
 | >= 1.20         | ~> 0.14.0      |
+| >= 1.22         | ~> 0.15.0      |
 
 Installation
 ------------

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

@@ -149,23 +149,41 @@ module ForemanTasks
         }
       end
 
-      api :POST, '/tasks/callback', N_('Send data to the task from external executor (such as smart_proxy_dynflow)')
-      param :callback, Hash do
-        param :task_id, :identifier, :desc => N_('UUID of the task')
-        param :step_id, String, :desc => N_('The ID of the step inside the execution plan to send the event to')
+      def_param_group :callback_target do
+        param :callback, Hash do
+          param :task_id, :identifier, :desc => N_('UUID of the task')
+          param :step_id, String, :desc => N_('The ID of the step inside the execution plan to send the event to')
+        end
       end
-      param :data, Hash, :desc => N_('Data to be sent to the action')
+
+      def_param_group :callback do
+        param_group :callback_target
+        param :data, Hash, :desc => N_('Data to be sent to the action')
+      end
+
+      api :POST, '/tasks/callback', N_('Send data to the task from external executor (such as smart_proxy_dynflow)')
+      param_group :callback
+      param :callbacks, Array, :of => param_group(:callback)
       def callback
-        task = ForemanTasks::Task::DynflowTask.find(params[:callback][:task_id])
-        ForemanTasks.dynflow.world.event(task.external_id,
-                                         params[:callback][:step_id].to_i,
-                                         # We need to call .to_unsafe_h to unwrap the hash from ActionController::Parameters
-                                         ::Actions::ProxyAction::CallbackData.new(params[:data].to_unsafe_h, :request_id => ::Logging.mdc['request']))
+        callbacks = params.key?(:callback) ? Array(params) : params[:callbacks]
+        ids = callbacks.map { |payload| payload[:callback][:task_id] }
+        external_map = Hash[*ForemanTasks::Task.where(:id => ids).pluck(:id, :external_id).flatten]
+        callbacks.each do |payload|
+          # We need to call .to_unsafe_h to unwrap the hash from ActionController::Parameters
+          callback = payload[:callback]
+          process_callback(external_map[callback[:task_id]], callback[:step_id].to_i, payload[:data].to_unsafe_h, :request_id => ::Logging.mdc['request'])
+        end
         render :json => { :message => 'processing' }.to_json
       end
 
       private
 
+      def process_callback(execution_plan_uuid, step_id, data, meta)
+        ForemanTasks.dynflow.world.event(execution_plan_uuid,
+                                         step_id,
+                                         ::Actions::ProxyAction::CallbackData.new(data, meta))
+      end
+
       def search_tasks(search_params)
         scope = resource_scope_for_index.select('DISTINCT foreman_tasks_tasks.*')
         scope = ordering_scope(scope, search_params)

data/app/controllers/foreman_tasks/react_controller.rb

@@ -0,0 +1,17 @@
+module ForemanTasks
+  class ReactController < ::ApplicationController
+    def index
+      render 'foreman_tasks/layouts/react', :layout => false
+    end
+
+    private
+
+    def controller_permission
+      :foreman_tasks
+    end
+
+    def action_permission
+      :view
+    end
+  end
+end

data/app/lib/actions/middleware/proxy_batch_triggering.rb

@@ -0,0 +1,36 @@
+module Actions
+  module Middleware
+    class ProxyBatchTriggering < ::Dynflow::Middleware
+      # If the event could result into sub tasks being planned, check if there are any RemoteTasks
+      # to trigger after the event is processed
+      #
+      # The ProxyAction needs to be planned with `:use_batch_triggering => true` to activate the feature
+      def run(event = nil)
+        pass event
+      ensure
+        trigger_remote_tasks if event.nil? || event.is_a?(Dynflow::Action::WithBulkSubPlans::PlanNextBatch)
+      end
+
+      def trigger_remote_tasks
+        # Find the tasks in batches, order them by proxy_url so we get all tasks
+        # to a certain proxy "close to each other"
+        remote_tasks.pending.order(:proxy_url, :id).find_in_batches(:batch_size => batch_size) do |batch|
+          # Group the tasks by operation, in theory there should be only one operation
+          batch.group_by(&:operation).each do |operation, group|
+            ForemanTasks::RemoteTask.batch_trigger(operation, group)
+          end
+        end
+      end
+
+      def remote_tasks
+        action.task.remote_sub_tasks
+      end
+
+      private
+
+      def batch_size
+        Setting['foreman_tasks_proxy_batch_size']
+      end
+    end
+  end
+end

data/app/lib/actions/middleware/watch_delegated_proxy_sub_tasks.rb

@@ -26,13 +26,11 @@ module Actions
       end
 
       def check_triggered
-        # Sort by proxy_url so there are less requests per proxy
-        source = remote_tasks.triggered.order(:proxy_url, :id)
-        source.find_in_batches(:batch_size => BATCH_SIZE) do |batch|
-          tasks = batch.group_by(&:proxy_url)
-                       .map { |(url, tasks)| poll_proxy_tasks(url, tasks) }
-                       .flatten
-          process_task_results tasks
+        in_remote_task_batches(remote_tasks.triggered) do |batch|
+          batch.group_by(&:proxy_url).each do |(url, tasks)|
+            tasks = poll_proxy_tasks(url, tasks).flatten
+            process_task_results tasks
+          end
         end
       end
 
@@ -68,6 +66,13 @@ module Actions
         action.action_logger.warn(_('Failed to check on tasks on proxy at %{url}: %{exception}') % { :url => url, :exception => e.message })
         []
       end
+
+      def in_remote_task_batches(scope)
+        # Sort by proxy_url so there are less requests per proxy
+        scope.order(:proxy_url, :id).find_in_batches(:batch_size => BATCH_SIZE) do |batch|
+          yield batch
+        end
+      end
     end
   end
 end

data/app/lib/actions/proxy_action.rb

@@ -26,8 +26,15 @@ module Actions
 
     def plan(proxy, klass, options)
       options[:connection_options] ||= {}
-      default_connection_options.each { |key, value| options[:connection_options][key] ||= value }
-      plan_self(options.merge(:proxy_url => proxy.url, :proxy_action_name => klass.to_s))
+      default_connection_options.each do |key, value|
+        options[:connection_options][key] = value unless options[:connection_options].key?(key)
+      end
+      plan_self(options.merge(:proxy_url => proxy.url, :proxy_action_name => klass.to_s, :proxy_version => proxy_version(proxy)))
+      # Just saving the RemoteTask is enough when using batch triggering
+      # It will be picked up by the ProxyBatchTriggering middleware
+      if input[:use_batch_triggering] && with_batch_triggering?(input[:proxy_version])
+        prepare_remote_task.save!
+      end
     end
 
     def run(event = nil)
@@ -64,20 +71,22 @@ module Actions
 
     def trigger_proxy_task
       suspend do |_suspended_action|
-        response = proxy.trigger_task(proxy_action_name,
-                                      input.merge(:callback => { :task_id => task.id,
-                                                                 :step_id => run_step_id }))
-        ::ForemanTasks::RemoteTask.new(:remote_task_id => response['task_id'], :execution_plan_id => execution_plan_id,
-                                       :state => 'triggered', :proxy_url => input[:proxy_url], :step_id => run_step_id).save!
-        output[:proxy_task_id] = response['task_id']
+        remote_task = prepare_remote_task
+        remote_task.trigger(proxy_action_name, proxy_input)
+        output[:proxy_task_id] = remote_task.remote_task_id
       end
     end
 
+    def proxy_input(task_id = task.id)
+      input.merge(:callback => { :task_id => task_id,
+                                 :step_id => run_step_id })
+    end
+
     def check_task_status
-      response = proxy.status_of_task(output[:proxy_task_id])
+      response = proxy.status_of_task(proxy_task_id)
       if %w[stopped paused].include? response['state']
         if response['result'] == 'error'
-          raise ::Foreman::Exception, _('The smart proxy task %s failed.') % output[:proxy_task_id]
+          raise ::Foreman::Exception, _('The smart proxy task %s failed.') % proxy_task_id
         else
           on_data(response['actions'].find { |block_action| block_action['class'] == proxy_action_name }['output'])
         end
@@ -90,14 +99,14 @@ module Actions
       if output[:cancel_sent]
         error! ForemanTasks::Task::TaskCancelledException.new(_('Cancel enforced: the task might be still running on the proxy'))
       else
-        proxy.cancel_task(output[:proxy_task_id])
+        proxy.cancel_task(proxy_task_id)
         output[:cancel_sent] = true
         suspend
       end
     end
 
     def abort_proxy_task
-      proxy.cancel_task(output[:proxy_task_id])
+      proxy.cancel_task(proxy_task_id)
       error! ForemanTasks::Task::TaskCancelledException.new(_('Task aborted: the task might be still running on the proxy'))
     end
 
@@ -132,6 +141,11 @@ module Actions
       input[:proxy_action_name]
     end
 
+    # @override String name of a operation to be triggered on server
+    def proxy_operation_name
+      input[:proxy_operation_name]
+    end
+
     def proxy
       ProxyAPI::ForemanDynflow::DynflowProxy.new(:url => input[:proxy_url])
     end
@@ -139,8 +153,8 @@ module Actions
     def proxy_output(live = false)
       if output.key?(:proxy_output) || state == :error
         output.fetch(:proxy_output, {})
-      elsif live && output[:proxy_task_id]
-        proxy_data = proxy.status_of_task(output[:proxy_task_id])['actions'].detect { |action| action['class'] == proxy_action_name }
+      elsif live && proxy_task_id
+        proxy_data = proxy.status_of_task(proxy_task_id)['actions'].detect { |action| action['class'] == proxy_action_name }
         proxy_data.fetch('output', {})
       else
         {}
@@ -174,7 +188,13 @@ module Actions
       # Fails if the plan is not finished within 60 seconds from the first task trigger attempt on the smart proxy
       # If the triggering fails, it retries 3 more times with 15 second delays
       { :retry_interval => Setting['foreman_tasks_proxy_action_retry_interval'] || 15,
-        :retry_count    => Setting['foreman_tasks_proxy_action_retry_count'] || 4 }
+        :retry_count    => Setting['foreman_tasks_proxy_action_retry_count'] || 4,
+        :proxy_batch_triggering => Setting['foreman_tasks_proxy_batch_trigger'] || false }
+    end
+
+    def with_batch_triggering?(proxy_version)
+      (proxy_version[:major] == 1 && proxy_version[:minor] > 20) || proxy_version[:major] > 1 &&
+        input.fetch(:connection_options, {}).fetch(:proxy_batch_triggering, false)
     end
 
     def clean_remote_task(*_args)
@@ -183,6 +203,11 @@ module Actions
 
     private
 
+    def proxy_version(proxy)
+      match = proxy.statuses[:version].version['version'].match(/(\d+)\.(\d+)\.(\d+)/)
+      { :major => match[1].to_i, :minor => match[2].to_i, :patch => match[3].to_i }
+    end
+
     def failed_proxy_tasks
       metadata[:failed_proxy_tasks] ||= []
     end
@@ -198,7 +223,7 @@ module Actions
     end
 
     def format_exception(exception)
-      { :proxy_task_id => output[:proxy_task_id],
+      { :proxy_task_id => proxy_task_id,
         :exception_class => exception.class.name,
         :exception_message => exception.message,
         :timestamp => Time.now.to_f }
@@ -218,5 +243,16 @@ module Actions
         raise exception
       end
     end
+
+    def prepare_remote_task
+      ::ForemanTasks::RemoteTask.new(:execution_plan_id => execution_plan_id,
+                                     :proxy_url => input[:proxy_url],
+                                     :step_id => run_step_id,
+                                     :operation => proxy_operation_name)
+    end
+
+    def proxy_task_id
+      output[:proxy_task_id] ||= remote_task.try(:remote_task_id)
+    end
   end
 end

data/app/lib/proxy_api/foreman_dynflow/dynflow_proxy.rb

@@ -39,6 +39,18 @@ module ProxyAPI
         payload = MultiJson.dump(:task_ids => ids)
         MultiJson.load(Task.new(@args).send(:post, payload, 'status'))
       end
+
+      def operations
+        MultiJson.load(Task.new(@args).send(:get, 'operations'))
+      end
+
+      def launch_tasks(operation, input, options = {})
+        data = { :input => input,
+                 :operation => operation,
+                 :options => options }
+        payload = MultiJson.dump(data)
+        MultiJson.load(Task.new(@args).send(:post, payload, 'launch'))
+      end
     end
   end
 end

data/app/models/foreman_tasks/remote_task.rb

@@ -8,5 +8,79 @@ module ForemanTasks
                       :inverse_of  => :remote_tasks
 
     scope :triggered, -> { where(:state => 'triggered') }
+    scope :pending,   -> { where(:state => 'new') }
+
+    delegate :proxy_action_name, :to => :action
+
+    # Triggers a task on the proxy "the old way"
+    def trigger(proxy_action_name, input)
+      response = begin
+                   proxy.trigger_task(proxy_action_name, input).merge('result' => 'success')
+                 rescue RestClient::Exception => e
+                   logger.warn "Could not trigger task on the smart proxy: #{e.message}"
+                   {}
+                 end
+      update_from_batch_trigger(response)
+      save!
+    end
+
+    def self.batch_trigger(operation, remote_tasks)
+      remote_tasks.group_by(&:proxy_url).values.map do |group|
+        input_hash = group.reduce({}) do |acc, remote_task|
+          acc.merge(remote_task.execution_plan_id => { :action_input => remote_task.proxy_input,
+                                                       :action_class => remote_task.proxy_action_name })
+        end
+        safe_batch_trigger(operation, group, input_hash)
+      end
+      remote_tasks
+    end
+
+    # Attempt to trigger the tasks using the new API and fall back to the old one
+    # if it fails
+    def self.safe_batch_trigger(operation, remote_tasks, input_hash)
+      results = remote_tasks.first.proxy.launch_tasks(operation, input_hash)
+      remote_tasks.each { |remote_task| remote_task.update_from_batch_trigger results[remote_task.execution_plan_id] }
+    rescue RestClient::NotFound
+      fallback_batch_trigger remote_tasks, input_hash
+    end
+
+    # Trigger the tasks one-by-one using the old API
+    def self.fallback_batch_trigger(remote_tasks, input_hash)
+      remote_tasks.each do |remote_task|
+        task_data = input_hash[remote_task.execution_plan_id]
+        remote_task.trigger(task_data[:action_class], task_data[:action_input])
+      end
+    end
+
+    def update_from_batch_trigger(data)
+      if data['result'] == 'success'
+        self.remote_task_id = data['task_id']
+        self.state = 'triggered'
+      else
+        # Tell the action the task on the smart proxy stopped
+        ForemanTasks.dynflow.world.event execution_plan_id,
+                                         step_id,
+                                         ::Actions::ProxyAction::ProxyActionStopped.new
+      end
+      save!
+    end
+
+    def proxy_input
+      action.proxy_input(task.id)
+    end
+
+    def proxy
+      @proxy ||= ::ProxyAPI::ForemanDynflow::DynflowProxy.new(:url => proxy_url)
+    end
+
+    private
+
+    def action
+      @action ||= ForemanTasks.dynflow.world.persistence.load_action(step)
+    end
+
+    def step
+      @step ||= task.execution_plan.steps[step_id]
+    end
   end
 end

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

@@ -83,7 +83,7 @@ module ForemanTasks
     end
 
     def input
-      return execution_plan_action.input['job_arguments'] if active_job?
+      return active_job_data['arguments'] if active_job?
       main_action.task_input if main_action.respond_to?(:task_input)
     end
 
@@ -113,12 +113,8 @@ module ForemanTasks
     def main_action
       return @main_action if defined?(@main_action)
       if active_job?
-        args = if execution_plan.delay_record
-                 execution_plan.delay_record.args.first
-               else
-                 execution_plan_action.input
-               end
-        @main_action = active_job_action(args['job_class'], args['job_arguments'])
+        job_data = active_job_data
+        @main_action = active_job_action(job_data['job_class'], job_data['arguments'])
       else
         @main_action = execution_plan && execution_plan.root_plan_step.try(:action, execution_plan)
       end
@@ -140,6 +136,17 @@ module ForemanTasks
       execution_plan_action.class == ::Dynflow::ActiveJob::QueueAdapters::JobWrapper
     end
 
+    def active_job_data
+      args = if execution_plan.delay_record
+               execution_plan.delay_record.args.first
+             else
+               execution_plan_action.input
+             end
+      return args['job_data'] if args.key?('job_data')
+      # For dynflow <= 1.2.1
+      { 'job_class' => args['job_class'], 'arguments' => args['job_arguments'] }
+    end
+
     def execution_plan_action
       execution_plan.root_plan_step.action(execution_plan)
     end

data/app/models/setting/foreman_tasks.rb

@@ -10,7 +10,9 @@ class Setting::ForemanTasks < Setting
         set('dynflow_enable_console', N_('Enable the dynflow console (/foreman_tasks/dynflow) for debugging'), true),
         set('dynflow_console_require_auth', N_('Require user to be authenticated as user with admin rights when accessing dynflow console'), true),
         set('foreman_tasks_proxy_action_retry_count', N_('Number of attempts to start a task on the smart proxy before failing'), 4),
-        set('foreman_tasks_proxy_action_retry_interval', N_('Time in seconds between retries'), 15)
+        set('foreman_tasks_proxy_action_retry_interval', N_('Time in seconds between retries'), 15),
+        set('foreman_tasks_proxy_batch_trigger', N_('Allow triggering tasks on the smart proxy in batches'), true),
+        set('foreman_tasks_proxy_batch_size', N_('Number of tasks which should be sent to the smart proxy in one request, if foreman_tasks_proxy_batch_trigger is enabled'), 1000)
       ].each { |s| create! s.update(:category => 'Setting::ForemanTasks') }
     end
 

data/app/views/foreman_tasks/layouts/react.html.erb

@@ -0,0 +1,12 @@
+<% content_for(:javascripts) do %>
+  <%= webpacked_plugins_js_for :'foreman-tasks' %>
+<% end %>
+
+<% content_for(:content) do %>
+  <%= notifications %>
+  <div id="organization-id" data-id="<%= Organization.current.id if Organization.current %>" ></div>
+  <div id="user-id" data-id="<%= User.current.id if User.current %>" ></div>
+  <div id="foremanTasksReactRoot"></div>
+<% end %>
+<%= render file: "layouts/base" %>
+<%= mount_react_component('ForemanTasks', '#foremanTasksReactRoot') %>

data/app/views/foreman_tasks/tasks/show.html.erb

@@ -7,7 +7,7 @@
       url: url_for(foreman_tasks_tasks_path)
     },
     {
-      caption: truncate(format_task_input(@task), :length => 50)
+      caption: format_task_input(@task)
     }
   ],
   name_field: 'action',