foreman-tasks 0.10.0 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: acd7b0adebf587957c53c75ff415ae872d5b5995
-  data.tar.gz: e682ae90a94614bae6d1cf7b1014e39bce5fa82e
+  metadata.gz: 7f1ef8e297d56025b9460e44ca7e96e753307d55
+  data.tar.gz: a26e87a7cd3abda09035c1b63747234a77c0562f
 SHA512:
-  metadata.gz: bd0a1edea81a4b634fea1f4e81ab7b2778a11d68cb5cc2d8c35974c60db2d9cc58ac12b85904fb0943ba22a1540b19d513504aefac6f285f1703cba8f4ce3217
-  data.tar.gz: 036bb166af540a7509a590fa8f5de2d056d93c8c77bf8311e92705d3e8936097365449b60b4f025fe6814df9ca8f6e5fc3e70d58fdc6a6ee74e9682a52351e13
+  metadata.gz: 0bf2da8785b5fb0504c110b4089b2a27fcb30173a6c060f0171295d77c4d3240192406822a38872edeb102beacfdd0f3fd462a03bcb5d2c9992de2a1b08b3fab
+  data.tar.gz: f95dcdf3437613f5c702df30248c6f962db176e88e2474edba21db0d97d362af4d554ccaecee5726fdef27686f2869eef2fb7853ce9fa26fb3458ade1f947a66

data/.rubocop_todo.yml

@@ -57,7 +57,6 @@ Metrics/PerceivedComplexity:
 Rails/Exit:
   Exclude:
     - 'lib/**/*.rake'
-    - 'lib/foreman_tasks/dynflow/daemon.rb'
 
 Rails/HttpPositionalArguments:
   Enabled: false
@@ -84,7 +83,6 @@ Style/ClassAndModuleChildren:
     - 'app/models/setting/foreman_tasks.rb'
     - 'lib/foreman_tasks/dynflow/configuration.rb'
     - 'lib/foreman_tasks/dynflow/console_authorizer.rb'
-    - 'lib/foreman_tasks/dynflow/daemon.rb'
     - 'lib/foreman_tasks/dynflow/persistence.rb'
     - 'test/controllers/api/recurring_logics_controller_test.rb'
     - 'test/controllers/api/tasks_controller_test.rb'

data/app/controllers/foreman_tasks/recurring_logics_controller.rb

@@ -17,6 +17,10 @@ module ForemanTasks
       'foreman_tasks_recurring_logics'
     end
 
+    def resource_class
+      ::ForemanTasks::RecurringLogic
+    end
+
     private
 
     def find_recurring_logic
@@ -24,7 +28,8 @@ module ForemanTasks
     end
 
     def filter(scope)
-      scope.search_for(params[:search]).paginate(:page => params[:page])
+      scope.search_for(params[:search])
+           .paginate(:page => params[:page], :per_page => params[:per_page])
     end
   end
 end

data/app/controllers/foreman_tasks/tasks_controller.rb

@@ -36,6 +36,16 @@ module ForemanTasks
       redirect_to :back
     end
 
+    def abort
+      task = find_dynflow_task
+      if task.abort
+        flash[:notice] = _('Trying to abort the task')
+      else
+        flash[:warning] = _('The task cannot be aborted at the moment.')
+      end
+      redirect_to :back
+    end
+
     def resume
       task = find_dynflow_task
       if task.resumable?
@@ -72,6 +82,10 @@ module ForemanTasks
       'foreman_tasks_tasks'
     end
 
+    def resource_class
+      ForemanTasks::Task
+    end
+
     private
 
     def restrict_dangerous_actions
@@ -86,7 +100,7 @@ module ForemanTasks
       case params[:action]
       when 'sub_tasks'
         :view
-      when 'resume', 'unlock', 'force_unlock', 'cancel_step', 'cancel'
+      when 'resume', 'unlock', 'force_unlock', 'cancel_step', 'cancel', 'abort'
         :edit
       else
         super
@@ -103,7 +117,7 @@ module ForemanTasks
 
     def filter(scope)
       scope.search_for(params[:search], :order => params[:order])
-           .paginate(:page => params[:page]).select('DISTINCT foreman_tasks_tasks.*')
+           .paginate(:page => params[:page], :per_page => params[:per_page]).distinct
     end
   end
 end

data/app/lib/actions/proxy_action.rb

@@ -31,6 +31,8 @@ module Actions
           # do nothing
         when ::Dynflow::Action::Cancellable::Cancel
           cancel_proxy_task
+        when ::Dynflow::Action::Cancellable::Abort
+          abort_proxy_task
         when CallbackData
           on_data(event.data)
         when ::Dynflow::Action::Timeouts::Timeout
@@ -78,6 +80,11 @@ module Actions
       end
     end
 
+    def abort_proxy_task
+      proxy.cancel_task(output[:proxy_task_id])
+      error! ForemanTasks::Task::TaskCancelledException.new(_('Task aborted: the task might be still running on the proxy'))
+    end
+
     def on_resume
       # TODO: add logic to load the data from the external action
       suspend

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

@@ -9,8 +9,8 @@ module ForemanTasks
       self.external_id    = data[:id]
       self.started_at     = utc_zone.parse(data[:started_at]) unless data[:started_at].nil?
       self.ended_at       = utc_zone.parse(data[:ended_at]) unless data[:ended_at].nil?
+      self.result         = map_result(data).to_s
       self.state          = data[:state].to_s
-      self.result         = map_result(data[:result])
       self.start_at       = utc_zone.parse(data[:start_at]) if data[:start_at]
       self.start_before   = utc_zone.parse(data[:start_before]) if data[:start_before]
       self.parent_task_id ||= begin
@@ -32,6 +32,10 @@ module ForemanTasks
       execution_plan!.cancel.any?
     end
 
+    def abort
+      execution_plan!.cancel(true).any?
+    end
+
     def resumable?
       execution_plan.try(:state) == :paused
     end
@@ -148,9 +152,20 @@ module ForemanTasks
 
     private
 
-    def map_result(result)
-      result = :cancelled if result == :error && cancelled?
-      result.to_s
+    def map_result(data)
+      if state_result_transitioned?(%w[planned pending], %w[stopped error], data) ||
+         (data[:result] == :error && cancelled?)
+        :cancelled
+      else
+        data[:result]
+      end
+    end
+
+    def state_result_transitioned?(from, to, data)
+      oldstate, oldresult = from
+      newstate, newresult = to
+      state == oldstate && data[:state].to_s == newstate &&
+        result == oldresult && data[:result].to_s == newresult
     end
 
     def cancelled?

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

@@ -1,7 +1,9 @@
 module ForemanTasks
   class Task::Summarizer
     def summarize_by_status(since = nil)
-      result = ::ForemanTasks::Task.select('count(state) AS count, state, result').group(:state, :result).order(:state)
+      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
     end

data/app/views/common/_trigger_form.html.erb

@@ -1,7 +1,7 @@
 <div class="form-group ">
   <label class="col-md-2 control-label"><%= _('Schedule') %></label>
   <div class="col-md-6">
-    <% javascript 'trigger_form' %>
+    <% javascript 'foreman_tasks/trigger_form' %>
     <% stylesheet 'foreman_tasks/trigger_form' %>
 
     <%= javascript_tag do %>

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

@@ -30,5 +30,4 @@
   <% end %>
 </table>
 
-<%= page_entries_info @recurring_logics %>
-<%= will_paginate @recurring_logics %>
+<%= will_paginate_with_info @recurring_logics %>

data/app/views/foreman_tasks/tasks/dashboard/_latest_tasks_in_error_warning.html.erb

@@ -11,7 +11,7 @@
       <td class="ellipsis"><%= link_to task.humanized[:action], defined?(main_app) ? main_app.foreman_tasks_task_path(task.id) : foreman_tasks_task_path(task.id) %></td>
       <td><%= task.state %></td>
       <td><%= task.result %></td>
-      <td><%= _('%s ago') % time_ago_in_words(task.started_at) %></td>
+      <td><%= task.started_at ? (_('%s ago') % time_ago_in_words(task.started_at)) : _('N/A') %></td>
     </tr>
   <% end %>
 </table>

data/app/views/foreman_tasks/tasks/dashboard/_tasks_status.html.erb

@@ -4,12 +4,14 @@
     <th><%= _("State") %></th>
     <th><%= _("Result") %></th>
     <th><%= _("No. of Tasks") %></th>
+    <th><%= _("Last start time") %></th>
   </tr>
   <% ForemanTasks::Task::Summarizer.new.summarize_by_status.each do |result| %>
     <tr class="<%= ForemanTasks::Task::StatusExplicator.new.is_erroneous(result) ? 'text-danger' : '' %>">
       <td><%= result.state %></td>
       <td><%= result.result %></td>
       <td><%= link_to result.count, main_app.foreman_tasks_tasks_path(:search => "state=#{result.state}&result=#{result.result}") %></td>
+      <td><%= result.started_at ? (_('%s ago') % time_ago_in_words(result.started_at)) : _('N/A') %></td>
     </tr>
   <% end %>
 </table>

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

@@ -38,5 +38,4 @@ $(document).on('click', ".table-two-pane td.two-pane-link", function(e) {
     </tr>
   <% end %>
 </table>
-<%= page_entries_info @tasks %>
-<%= will_paginate @tasks %>
+<%= will_paginate_with_info @tasks %>

data/config/routes.rb

@@ -12,6 +12,7 @@ Foreman::Application.routes.draw do
       end
       member do
         get :sub_tasks
+        post :abort
         post :cancel
         post :resume
         post :unlock

data/foreman-tasks.gemspec

@@ -29,10 +29,8 @@ 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", '~> 0.8.24'
-  s.add_dependency "sequel" # for Dynflow process persistence
+  s.add_dependency "dynflow", '~> 0.8.26'
   s.add_dependency "sinatra" # for Dynflow web console
-  s.add_dependency "daemons" # for running remote executor
   s.add_dependency "parse-cron", '~> 0.1.4'
   s.add_dependency "get_process_mem" # for memory polling
 end

data/lib/foreman_tasks.rb

@@ -2,6 +2,7 @@ require 'foreman_tasks/version'
 require 'foreman_tasks/task_error'
 require 'foreman_tasks/engine'
 require 'foreman_tasks/dynflow'
+require 'foreman_tasks/dynflow/configuration'
 require 'foreman_tasks/triggers'
 require 'foreman_tasks/authorizer_ext'
 require 'foreman_tasks/cleaner'
@@ -11,7 +12,7 @@ module ForemanTasks
   extend Algebrick::Matching
 
   def self.dynflow
-    @dynflow ||= ForemanTasks::Dynflow.new
+    @dynflow ||= ForemanTasks::Dynflow.new(nil, ForemanTasks::Dynflow::Configuration.new)
   end
 
   def self.trigger(action, *args, &block)

data/lib/foreman_tasks/dynflow.rb

@@ -3,92 +3,9 @@ require 'dynflow'
 
 module ForemanTasks
   # Class for configuring and preparing the Dynflow runtime environment.
-  class Dynflow
-    require 'foreman_tasks/dynflow/configuration'
-    require 'foreman_tasks/dynflow/persistence'
-    require 'foreman_tasks/dynflow/daemon'
+  class Dynflow < ::Dynflow::Rails
     require 'foreman_tasks/dynflow/console_authorizer'
 
-    def initialize(world_class = nil)
-      @required = false
-      @world_class = world_class
-    end
-
-    def config
-      @config ||= ForemanTasks::Dynflow::Configuration.new
-    end
-
-    # call this method if your engine uses Dynflow
-    def require!
-      @required = true
-    end
-
-    def required?
-      @required
-    end
-
-    def initialized?
-      !@world.nil?
-    end
-
-    def initialize!
-      return unless @required
-      return @world if @world
-
-      if config.lazy_initialization && defined?(PhusionPassenger)
-        config.dynflow_logger.warn('ForemanTasks: lazy loading with PhusionPassenger might lead to unexpected results')
-      end
-      init_world.tap do |world|
-        @world = world
-
-        unless config.remote?
-          # don't try to do any rescuing until the tables are properly migrated
-          if !Foreman.in_rake?('db:migrate') && (begin
-                                                   ForemanTasks::Task.table_exists?
-                                                 rescue
-                                                   (false)
-                                                 end)
-            config.run_on_init_hooks(world)
-            # leave this just for long-running executors
-            unless config.rake_task_with_executor?
-              world.auto_execute
-              ForemanTasks::Task::DynflowTask.consistency_check
-            end
-          end
-        end
-      end
-    end
-
-    # Mark that the process is executor. This prevents the remote setting from
-    # applying. Needs to be set up before the world is being initialized
-    def executor!
-      @executor = true
-    end
-
-    def executor?
-      @executor
-    end
-
-    def reinitialize!
-      @world = nil
-      initialize!
-    end
-
-    def world
-      return @world if @world
-
-      initialize! if config.lazy_initialization
-      unless @world
-        raise 'The Dynflow world was not initialized yet. '\
-              'If your plugin uses it, make sure to call ForemanTasks.dynflow.require! '\
-              'in some initializer'
-      end
-
-      @world
-    end
-
-    attr_writer :world
-
     def web_console
       ::Dynflow::Web.setup do
         before do
@@ -101,31 +18,8 @@ module ForemanTasks
         set(:custom_navigation) do
           { _('Back to tasks') => "/#{ForemanTasks::TasksController.controller_path}" }
         end
-        set(:world) { ForemanTasks.dynflow.world }
+        set(:world) { Rails.application.dynflow.world }
       end
     end
-
-    def eager_load_actions!
-      config.eager_load_paths.each do |load_path|
-        Dir.glob("#{load_path}/**/*.rb").sort.each do |file|
-          unless loaded_paths.include?(file)
-            require_dependency file
-            loaded_paths << file
-          end
-        end
-      end
-      @world.reload! if @world
-    end
-
-    def loaded_paths
-      @loaded_paths ||= Set.new
-    end
-
-    private
-
-    def init_world
-      return config.initialize_world(@world_class) if @world_class
-      config.initialize_world
-    end
   end
 end

data/lib/foreman_tasks/dynflow/configuration.rb

@@ -1,146 +1,11 @@
-module ForemanTasks
-  class Dynflow::Configuration
-    # the number of threads in the pool handling the execution
-    attr_accessor :pool_size
-
-    # the size of db connection pool
-    attr_accessor :db_pool_size
-
-    # set true if the executor runs externally (by default true in procution, othewise false)
-    attr_accessor :remote
-    alias remote? remote
-
-    # what transaction adapater should be used, by default, it uses the ActiveRecord
-    # based adapter, expecting ActiveRecord is used as ORM in the application
-    attr_accessor :transaction_adapter
-
-    attr_accessor :eager_load_paths
-
-    attr_accessor :lazy_initialization
-
-    # what rake tasks should run their own executor, not depending on the external one
-    attr_accessor :rake_tasks_with_executor
-
-    # if true, the ForemanTasks::Concerns::ActionTriggering will make
-    # no effect. Useful for testing, where we mignt not want to execute
-    # the orchestration tied to the models.
-    attr_accessor :disable_active_record_actions
-
-    def initialize
-      self.pool_size                = 5
-      self.db_pool_size             = pool_size + 5
-      self.remote                   = Rails.env.production?
-      self.transaction_adapter      = ::Dynflow::TransactionAdapters::ActiveRecord.new
-      self.eager_load_paths         = []
-      self.lazy_initialization      = !Rails.env.production?
-      self.rake_tasks_with_executor = %w[db:migrate db:seed]
-
-      @on_init = []
-    end
+# Require foreman's lib directory which contains foreman/dynflow/configuration
+lib_foreman = File.expand_path('lib/foreman', Rails.root)
+require lib_foreman if Dir.exist?(lib_foreman)
+require 'foreman_tasks/dynflow/persistence'
 
-    # for logging action related info (such as exceptions raised in side
-    # the actions' methods
-    def action_logger
-      Foreman::Logging.logger('foreman-tasks/action')
-    end
-
-    # for logging dynflow related info about the progress of the execution etc.
-    def dynflow_logger
-      Foreman::Logging.logger('foreman-tasks/dynflow')
-    end
-
-    def on_init(&block)
-      @on_init << block
-    end
-
-    def run_on_init_hooks(world)
-      @on_init.each { |init| init.call(world) }
-    end
-
-    def initialize_world(world_class = ::Dynflow::World)
-      world_class.new(world_config)
-    end
-
-    # No matter what config.remote says, when the process is marked as executor,
-    # it can't be remote
-    def remote?
-      !ForemanTasks.dynflow.executor? &&
-        !rake_task_with_executor? &&
-        @remote
-    end
-
-    def rake_task_with_executor?
-      return false unless defined?(Rake)
-
-      Rake.application.top_level_tasks.any? do |rake_task|
-        rake_tasks_with_executor.include?(rake_task)
-      end
-    end
-
-    def increase_db_pool_size?
-      ForemanTasks.dynflow.required? && !remote? && !Rails.env.test?
-    end
-
-    # To avoid pottential timeouts on db connection pool, make sure
-    # we have the pool bigger than the thread pool
-    def increase_db_pool_size
-      if increase_db_pool_size?
-        ActiveRecord::Base.connection_pool.disconnect!
-
-        config = ActiveRecord::Base.configurations[Rails.env]
-        config['pool'] = db_pool_size if config['pool'].to_i < db_pool_size
-        ActiveRecord::Base.establish_connection(config)
-      end
-    end
-
-    # generates the options hash consumable by the Dynflow's world
-    def world_config
-      ::Dynflow::Config.new.tap do |config|
-        config.auto_rescue         = true
-        config.logger_adapter      = ::Dynflow::LoggerAdapters::Delegator.new(action_logger, dynflow_logger)
-        config.pool_size           = 5
-        config.persistence_adapter = initialize_persistence
-        config.transaction_adapter = transaction_adapter
-        config.executor            = ->(world, _) { initialize_executor(world) }
-        config.connector           = ->(world, _) { initialize_connector(world) }
-
-        # we can't do any operation until the ForemanTasks.dynflow.world is set
-        config.auto_execute        = false
-      end
-    end
-
-    protected
-
-    def default_sequel_adapter_options
-      db_config            = ActiveRecord::Base.configurations[Rails.env].dup
-      db_config['adapter'] = 'postgres' if db_config['adapter'] == 'postgresql'
-      db_config['max_connections'] = db_pool_size if increase_db_pool_size?
-
-      if db_config['adapter'] == 'sqlite3'
-        db_config['adapter'] = 'sqlite'
-        database = db_config['database']
-        unless database == ':memory:'
-          # We need to create separate database for sqlite
-          # to avoid lock conflicts on the database
-          db_config['database'] = "#{File.dirname(database)}/dynflow-#{File.basename(database)}"
-        end
-      end
-      db_config
-    end
-
-    def initialize_executor(world)
-      if remote?
-        false
-      else
-        ::Dynflow::Executors::Parallel.new(world, pool_size)
-      end
-    end
-
-    def initialize_connector(world)
-      ::Dynflow::Connectors::Database.new(world)
-    end
-
-    # Sequel adapter based on Rails app database.yml configuration
+module ForemanTasks
+  # Import all Dynflow configuration from Foreman, and add our own for Tasks
+  class Dynflow::Configuration < ::Foreman::Dynflow::Configuration
     def initialize_persistence
       ForemanTasks::Dynflow::Persistence.new(default_sequel_adapter_options)
     end