foreman-tasks 0.15.1 → 0.15.2

data/app/models/foreman_tasks/triggering.rb

@@ -18,8 +18,8 @@ module ForemanTasks
     ALLOWED_INPUT_TYPES = [:cronline, :monthly, :weekly, :daily, :hourly].freeze
 
     TIME_FORMAT = '%Y-%m-%d %H:%M'.freeze
-    TIME_REGEXP = /\A\d{4}-\d{2}-\d{2} \d{2}:\d{2}\Z/
-    DAYS_REGEXP = /\A(\s*\d{1,2}\s*)(,\s*\d{1,2}\s*)*\Z/
+    TIME_REGEXP = /\A\d{4}-\d{2}-\d{2} \d{2}:\d{2}\Z/.freeze
+    DAYS_REGEXP = /\A(\s*\d{1,2}\s*)(,\s*\d{1,2}\s*)*\Z/.freeze
 
     has_one :recurring_logic, :foreign_key => :triggering_id, :dependent => :nullify
 

data/app/models/setting/foreman_tasks.rb

@@ -3,6 +3,8 @@ class Setting::ForemanTasks < Setting
     # Check the table exists
     return unless super
 
+    Setting::BLANK_ATTRS.push('foreman_tasks_troubleshooting_url')
+
     transaction do
       [
         set('foreman_tasks_sync_task_timeout', N_('Number of seconds to wait for synchronous task to finish.'), 120),
@@ -12,7 +14,12 @@ class Setting::ForemanTasks < Setting
         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_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)
+        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'), 100),
+        set('foreman_tasks_troubleshooting_url',
+            N_('Url pointing to the task troubleshooting documentation. '\
+               'It should contain %{label} placeholder, that will be replaced with normalized task label '\
+               '(restricted to only alphanumeric characters)). %{version} placeholder is also available.'),
+            nil)
       ].each { |s| create! s.update(:category => 'Setting::ForemanTasks') }
     end
 

data/app/services/foreman_tasks/dashboard_table_filter.rb

@@ -0,0 +1,47 @@
+module ForemanTasks
+  # narrows the scope for the tasks table based on params coming from tasks dashboard
+  #
+  # Supported filters:
+  #
+  #  * :result
+  #  * :state
+  #  * :time_horizon - expected format of Hxy, where the xy is the time horizon in hours we're interested in
+  #      :time_mode can be set to 'recent' to filter the recent tasks, or 'older' (default) to filter earlier ones
+  class DashboardTableFilter
+    def initialize(scope, params)
+      @scope = scope
+      @params = params
+    end
+
+    def scope
+      @new_scope = @scope
+      scope_by(:result)
+      scope_by(:state)
+      scope_by_time
+      @new_scope
+    end
+
+    private
+
+    def scope_by(field)
+      @new_scope = @new_scope.where(field => @params[field]) if @params[field].present?
+    end
+
+    def scope_by_time
+      return if @params[:time_horizon].blank?
+      hours = @params[:time_horizon][/\AH(\d{1,2})$/i, 1]
+      unless hours
+        raise Foreman::Exception, 'Unexpected format of time: should be in form of "H24"'
+      end
+      timestamp = Time.now.utc - hours.to_i.hours
+      case @params[:time_mode]
+      when 'recent'
+        operator = '>'
+      else
+        operator = '<'
+        search_suffix = 'OR state_updated_at IS NULL'
+      end
+      @new_scope = @new_scope.where("state_updated_at #{operator} ? #{search_suffix}", timestamp)
+    end
+  end
+end

data/app/services/foreman_tasks/troubleshooting_help_generator.rb

@@ -0,0 +1,92 @@
+module ForemanTasks
+  class TroubleshootingHelpGenerator
+    class Link
+      attr_accessor :name, :title, :description, :href
+
+      def initialize(name:, title:, description:, href:)
+        @name = name
+        @title = title
+        @description = description
+        @href = href
+      end
+
+      def to_h(capitalize_title: false)
+        title = capitalize_title ? self.title.titlecase : self.title
+        { name: name, title: title, description: description, href: href, external: true }
+      end
+    end
+
+    class Info
+      attr_reader :links, :description_lines
+
+      def initialize
+        @description_lines = []
+        @links = []
+      end
+
+      def add_line(line)
+        @description_lines << line
+      end
+
+      def add_link(link)
+        @links << link
+      end
+    end
+
+    def initialize(action)
+      @action = action
+      @custom_info = action.troubleshooting_info if action.respond_to?(:troubleshooting_info)
+    end
+
+    def generate_html
+      # rubocop:disable Rails/OutputSafety
+      (description + link_descriptions_html).join('<br/>').html_safe
+      # rubocop:enable Rails/OutputSafety
+    end
+
+    def link_descriptions_html
+      links.map do |link|
+        link.description % { link: %(<a href="%{href}">%{title}</a>) % link.to_h }
+      end
+    end
+
+    def description
+      ret = generic_info.description_lines
+      ret += @custom_info.description_lines if @custom_info
+      ret
+    end
+
+    def links
+      links = generic_info.links
+      links += @custom_info.links if @custom_info
+      links
+    end
+
+    def generic_info
+      @generic_info ||= Info.new.tap do |i|
+        i.add_line _('A paused task represents a process that has not finished properly. '\
+                        'Any task in paused state can lead to potential inconsistency '\
+                        'and needs to be resolved.')
+        i.add_line _("The recommended approach is to investigate the error messages below and in 'errors' tab, "\
+                     'address the primary cause of the issue and resume the task.')
+        if (link = troubleshooting_link)
+          i.add_link(link)
+        end
+      end
+    end
+
+    def troubleshooting_link(generic_only: false)
+      url_template = Setting[:foreman_tasks_troubleshooting_url]
+      return if url_template.blank?
+      url = url_template % { label: generic_only ? '' : link_anchor, version: SETTINGS[:version].short }
+      Link.new(name: :troubleshooting,
+               title: _('troubleshooting documentation'),
+               description: _('See %{link} for more details on how to resolve the issue'),
+               href: url)
+    end
+
+    def link_anchor
+      @action.label.to_s
+    end
+  end
+end

data/app/services/ui_notifications/tasks.rb

@@ -0,0 +1,20 @@
+module UINotifications
+  module Tasks
+    class Base < ::UINotifications::Base
+      def initialize(task)
+        @subject = @task = task
+      end
+
+      def initiator
+        User.anonymous_admin
+      end
+
+      def troubleshooting_help_generator
+        return @troubleshooting_help_generator if defined? @troubleshooting_help_generator
+        @troubleshooting_help_generator = if @task.main_action
+                                            ForemanTasks::TroubleshootingHelpGenerator.new(@task.main_action)
+                                          end
+      end
+    end
+  end
+end

data/app/services/ui_notifications/tasks/task_paused_admin.rb

@@ -0,0 +1,43 @@
+module UINotifications
+  module Tasks
+    class TaskPausedAdmin < Tasks::Base
+      def deliver!
+        # delete previous notifications about paused tasks first
+        Notification.where(notification_blueprint_id: blueprint.id).each(&:destroy)
+        notification = ::Notification.new(
+          :audience => Notification::AUDIENCE_ADMIN,
+          :notification_blueprint => blueprint,
+          :initiator => initiator,
+          :subject => subject,
+          :message => message
+        )
+
+        notification.send(:set_custom_attributes) # to add links from blueprint
+        notification.actions['links'] ||= []
+        if troubleshooting_help_generator
+          troubleshooting_link = troubleshooting_help_generator.troubleshooting_link(generic_only: true)
+          notification.actions['links'] << troubleshooting_link.to_h(capitalize_title: true) if troubleshooting_link
+        end
+        notification.save!
+        notification
+      end
+
+      def initiator
+        User.anonymous_admin
+      end
+
+      def blueprint
+        @blueprint ||= NotificationBlueprint.unscoped.find_by(:name => 'tasks_paused_admin')
+      end
+
+      def message
+        return @message if @message
+
+        tasks_count = ForemanTasks::Task.where(state: 'paused').count
+        @message = n_('There is %{count} paused task in the system that need attention',
+                      'There are %{count} paused tasks in the system that need attention',
+                      tasks_count) % { count: tasks_count }
+      end
+    end
+  end
+end

data/app/services/ui_notifications/tasks/task_paused_owner.rb

@@ -0,0 +1,30 @@
+module UINotifications
+  module Tasks
+    class TaskPausedOwner < Tasks::Base
+      def deliver!
+        notification = ::Notification.new(
+          :audience => Notification::AUDIENCE_USER,
+          :notification_blueprint => blueprint,
+          :initiator => initiator,
+          :message => message,
+          :subject => subject
+        )
+        notification.send(:set_custom_attributes) # to add links from blueprint
+        notification.actions['links'] ||= []
+        if troubleshooting_help_generator
+          notification.actions['links'].concat(troubleshooting_help_generator.links.map { |l| l.to_h(capitalize_title: true) })
+        end
+        notification.save!
+        notification
+      end
+
+      def blueprint
+        @blueprint ||= NotificationBlueprint.unscoped.find_by(:name => 'tasks_paused_owner')
+      end
+
+      def message
+        StringParser.new(blueprint.message, subject: subject.action).to_s
+      end
+    end
+  end
+end

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

@@ -174,6 +174,8 @@
   </div>
 </div>
 
+<%= troubleshooting_info %>
+
 <% unless @task.humanized[:output].blank? %>
 <div>
   <span class="param-name list-group-item-heading"><%= _("Output") %>:</span>
@@ -184,10 +186,10 @@
 <% end %>
 
 <% unless @task.humanized[:errors].blank? %>
-<div>
-  <span class="param-name"><%= _("Errors") %>:</span>
+<p>
+  <span class="param-name"><b><%= _("Errors") %>:</b></span>
   <span class="param-value">
     <pre><%=Array(@task.humanized[:errors]).join("\n") %></pre>
   </span>
-</div>
+</p>
 <% end %>

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

@@ -1,3 +1,16 @@
+<% content_for(:javascripts) do %>
+    <%= webpacked_plugins_js_for :'foreman-tasks' %>
+<% end %>
+<% content_for(:stylesheets) do %>
+    <%= webpacked_plugins_css_for :'foreman-tasks' %>
+<% end %>
+<% content_for(:before_search_bar) do %>
+  <div id="tasks-dashboard"></div>
+  <%= mount_react_component('TasksDashboard', '#tasks-dashboard', {
+      yo: 'ya'
+  }.to_json) %>
+<% end %>
+
 <% title _("Tasks") %>
 <% title_actions csv_link, help_button %>
 <% stylesheet 'foreman_tasks/tasks' %>

data/config/routes.rb

@@ -11,6 +11,7 @@ Foreman::Application.routes.draw do
     resources :tasks, :only => [:index, :show] do
       collection do
         get 'auto_complete_search'
+        get '/summary/:recent_timeframe', action: 'summary'
       end
       member do
         get :sub_tasks

data/db/migrate/20190318153925_add_task_state_updated_at.foreman_tasks.rb

@@ -0,0 +1,5 @@
+class AddTaskStateUpdatedAt < ActiveRecord::Migration[5.2]
+  def change
+    add_column :foreman_tasks_tasks, :state_updated_at, :timestamp, index: true
+  end
+end

data/db/migrate/20190404132157_add_implicit_varchar_uuid_cast.rb

@@ -0,0 +1,25 @@
+class AddImplicitVarcharUuidCast < ActiveRecord::Migration[5.2]
+  def up
+    if on_postgresql?
+      ActiveRecord::Base.connection.execute <<~SQL
+        CREATE CAST (varchar AS uuid)
+        WITH INOUT
+        AS IMPLICIT
+      SQL
+    end
+  end
+
+  def down
+    if on_postgresql?
+      ActiveRecord::Base.connection.execute <<~SQL
+        DROP CAST (varchar AS uuid)
+      SQL
+    end
+  end
+
+  private
+
+  def on_postgresql?
+    ActiveRecord::Base.connection.adapter_name == 'PostgreSQL'
+  end
+end

data/db/seeds.d/30-notification_blueprints.rb

@@ -0,0 +1,33 @@
+blueprints = [
+  {
+    group: N_('Tasks'),
+    name: 'tasks_paused_admin',
+    message: "DYNAMIC",
+    level: 'warning',
+    actions:
+      {
+        links:
+          [
+            href: "/foreman_tasks/tasks?search=#{CGI.escape('state=paused')}",
+            title: N_('List of tasks')
+          ]
+      }
+  },
+
+  {
+    group: N_('Tasks'),
+    name: 'tasks_paused_owner',
+    message: "The task '%{subject}' got paused",
+    level: 'warning',
+    actions:
+      {
+        links:
+          [
+            path_method: :foreman_tasks_task_path,
+            title: N_('Task Details')
+          ]
+      }
+  }
+]
+
+blueprints.each { |blueprint| UINotifications::Seed.new(blueprint).configure }

data/foreman-tasks.gemspec

@@ -29,7 +29,7 @@ same resource. It also optionally provides Dynflow infrastructure for using it f
   s.extra_rdoc_files = Dir['README*', 'LICENSE']
 
   s.add_dependency "foreman-tasks-core"
-  s.add_dependency "dynflow", '>= 1.2.2'
+  s.add_dependency "dynflow", '>= 1.2.3'
   s.add_dependency "sinatra" # for Dynflow web console
   s.add_dependency "parse-cron", '~> 0.1.4'
   s.add_dependency "get_process_mem" # for memory polling

data/lib/foreman_tasks/cleaner.rb

@@ -193,15 +193,16 @@ module ForemanTasks
 
     def orphaned_dynflow_tasks
       db = ForemanTasks.dynflow.world.persistence.adapter.db
-      uuid_select = Sequel.lit(ForemanTasks::Task.select(:external_id).to_sql)
-      db[:dynflow_execution_plans].filter(:uuid => [uuid_select]).invert
+      db.fetch("select dynflow_execution_plans.uuid from dynflow_execution_plans left join "\
+               "foreman_tasks_tasks on (dynflow_execution_plans.uuid = foreman_tasks_tasks.external_id) "\
+               "where foreman_tasks_tasks.id IS NULL")
     end
 
     def prepare_filter
       filter_parts = [filter]
       filter_parts << %(started_at < "#{after.ago.to_s(:db)}") if after > 0
-      filter_parts << states.map { |s| "state = #{s}" }.join(' OR ') if states.any?
-      filter_parts.select(&:present?).join(' AND ')
+      filter_parts << "state ^ (#{states.join(',')})" if states.any?
+      filter_parts.select(&:present?).map { |segment| "(#{segment})" }.join(' AND ')
     end
 
     def start_tracking_progress(name, total = tasks.size)

data/lib/foreman_tasks/engine.rb

@@ -56,7 +56,7 @@ module ForemanTasks
              :last     => true
 
         security_block :foreman_tasks do |_map|
-          permission :view_foreman_tasks, { :'foreman_tasks/tasks' => [:auto_complete_search, :sub_tasks, :index, :show],
+          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
           permission :edit_foreman_tasks, { :'foreman_tasks/tasks' => [:resume, :unlock, :force_unlock, :cancel_step, :cancel, :abort],

data/lib/foreman_tasks/test_helpers.rb

@@ -1,9 +1,19 @@
 require 'dynflow/testing'
 module ForemanTasks
   module TestHelpers
+    def self.use_in_memory_sqlite!
+      raise 'the in thread world have already been initialized' if @test_in_thread_world
+      @use_in_memory_sqlite = true
+    end
+
     def self.test_in_thread_world
       return @test_in_thread_world if @test_in_thread_world
       world_config = ForemanTasks.dynflow.config.world_config
+      if @use_in_memory_sqlite
+        world_config.persistence_adapter = lambda do |*_args|
+          ::ForemanTasks::Dynflow::Persistence.new('adapter' => 'sqlite', 'database' => ':memory:')
+        end
+      end
       @test_in_thread_world = ::Dynflow::Testing::InThreadWorld.new(world_config)
     end