foreman-tasks 0.8.6 → 0.9.0

data/lib/foreman_tasks.rb

@@ -22,10 +22,10 @@ module ForemanTasks
     Match! async, true, false
 
     match trigger(action, *args, &block),
-          (on ::Dynflow::World::PlaningFailed.(error: ~any) do |error|
+          (on ::Dynflow::World::PlaningFailed.call(error: ~any) do |error|
             raise error
           end),
-          (on ::Dynflow::World::Triggered.(execution_plan_id: ~any, future: ~any) do |id, finished|
+          (on ::Dynflow::World::Triggered.call(execution_plan_id: ~any, future: ~any) do |id, finished|
             finished.wait if async == false
             ForemanTasks::Task::DynflowTask.where(:external_id => id).first!
           end)
@@ -37,7 +37,7 @@ module ForemanTasks
 
   def self.sync_task(action, *args, &block)
     trigger_task(false, action, *args, &block).tap do |task|
-      raise TaskError.new(task) if task.execution_plan.error? || task.execution_plan.result == :warning
+      raise TaskError, task if task.execution_plan.error? || task.execution_plan.result == :warning
     end
   end
 

data/lib/foreman_tasks/authorizer_ext.rb

@@ -10,7 +10,7 @@ module ForemanTasks
 
     def resource_name_with_authorized_resource_name(klass)
       if klass.respond_to?(:authorized_resource_name)
-        return klass.authorized_resource_name
+        klass.authorized_resource_name
       else
         resource_name_without_authorized_resource_name(klass)
       end

data/lib/foreman_tasks/cleaner.rb

@@ -1,10 +1,9 @@
 module ForemanTasks
   # Represents the cleanup mechanism for tasks
   class Cleaner
-
     def self.run(options)
       if options.key?(:filter)
-        self.new(options).delete
+        new(options).delete
       else
         [:after, :states].each do |invalid_option|
           if options.key?(invalid_option)
@@ -12,10 +11,10 @@ module ForemanTasks
           end
         end
         if cleanup_settings[:after]
-          self.new(options.merge(:filter => "", :after  => cleanup_settings[:after])).delete
+          new(options.merge(:filter => '', :after => cleanup_settings[:after])).delete
         end
         actions_with_default_cleanup.each do |action_class, period|
-          self.new(options.merge(:filter => "label = #{action_class.name}", :after  => period)).delete
+          new(options.merge(:filter => "label = #{action_class.name}", :after => period)).delete
         end
       end
     end
@@ -37,7 +36,7 @@ module ForemanTasks
           actions_with_periods[action_class] = action_class.cleanup_after
         end
       end
-      return actions_with_periods
+      actions_with_periods
     end
 
     def self.cleanup_settings
@@ -45,7 +44,7 @@ module ForemanTasks
       @cleanup_settings = SETTINGS[:'foreman-tasks'] && SETTINGS[:'foreman-tasks'][:cleanup] || {}
     end
 
-    attr_reader :filter, :after , :states, :verbose, :batch_size, :noop, :full_filter
+    attr_reader :filter, :after, :states, :verbose, :batch_size, :noop, :full_filter
 
     # @param filter [String] scoped search matching the tasks to be deleted
     # @param after [String|nil] delete the tasks after they are older
@@ -57,7 +56,7 @@ module ForemanTasks
                           :verbose      => false,
                           :batch_size   => 1000,
                           :noop         => false,
-                          :states       => ["stopped"] }
+                          :states       => ['stopped'] }
       options         = default_options.merge(options)
 
       @filter         = options[:filter]
@@ -69,7 +68,7 @@ module ForemanTasks
 
       raise ArgumentError, 'filter not speficied' if @filter.nil?
 
-      @full_filter    = prepare_filter
+      @full_filter = prepare_filter
     end
 
     # Delete the filtered tasks, including the dynflow execution plans
@@ -102,14 +101,15 @@ module ForemanTasks
 
     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 << %(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 ')
     end
 
     def start_tracking_progress
       if verbose
-        @current, @total = 0, tasks.size
+        @current = 0
+        @total = tasks.size
         say "#{@current}/#{@total}", false
       end
     end
@@ -123,13 +123,11 @@ module ForemanTasks
 
     def say(message, log = true)
       puts message
-      if log
-        Foreman::Logging.logger('foreman-tasks').info(message)
-      end
+      Foreman::Logging.logger('foreman-tasks').info(message) if log
     end
 
     def parse_time_interval(string)
-      matched_string = string.gsub(' ','').match(/\A(\d+)(\w)\Z/)
+      matched_string = string.delete(' ').match(/\A(\d+)(\w)\Z/)
       unless matched_string
         raise ArgumentError, "String #{string} isn't an expected specification of time in format of \"{number}{time_unit}\""
       end
@@ -146,7 +144,7 @@ module ForemanTasks
               else
                 raise ArgumentError, "Unexpected time unit in #{string}, expected one of [s,h,d,y]"
               end
-      return value
+      value
     end
   end
 end

data/lib/foreman_tasks/dynflow.rb

@@ -35,14 +35,18 @@ module ForemanTasks
       return @world if @world
 
       if config.lazy_initialization && defined?(PhusionPassenger)
-        config.dynflow_logger.warn("ForemanTasks: lazy loading with PhusionPassenger might lead to unexpected results")
+        config.dynflow_logger.warn('ForemanTasks: lazy loading with PhusionPassenger might lead to unexpected results')
       end
       config.initialize_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') && (ForemanTasks::Task.table_exists? rescue(false))
+          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?
@@ -66,7 +70,7 @@ module ForemanTasks
 
     def reinitialize!
       @world = nil
-      self.initialize!
+      initialize!
     end
 
     def world
@@ -79,24 +83,22 @@ module ForemanTasks
               'in some initializer'
       end
 
-      return @world
+      @world
     end
 
-    def world=(world)
-      @world = world
-    end
+    attr_writer :world
 
     def web_console
       ::Dynflow::Web.setup do
         before do
           if !Setting[:dynflow_enable_console] ||
-                (Setting[:dynflow_console_require_auth] && !ConsoleAuthorizer.new(env).allow?)
+             (Setting[:dynflow_console_require_auth] && !ConsoleAuthorizer.new(env).allow?)
             halt 403, 'Access forbidden'
           end
         end
 
         set(:custom_navigation) do
-          { _("Back to tasks") => "/#{ForemanTasks::TasksController.controller_path}" }
+          { _('Back to tasks') => "/#{ForemanTasks::TasksController.controller_path}" }
         end
         set(:world) { ForemanTasks.dynflow.world }
       end

data/lib/foreman_tasks/dynflow/configuration.rb

@@ -1,6 +1,5 @@
 module ForemanTasks
   class Dynflow::Configuration
-
     # the number of threads in the pool handling the execution
     attr_accessor :pool_size
 
@@ -9,7 +8,7 @@ module ForemanTasks
 
     # set true if the executor runs externally (by default true in procution, othewise false)
     attr_accessor :remote
-    alias_method :remote?, :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
@@ -34,7 +33,7 @@ module ForemanTasks
       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]
+      self.rake_tasks_with_executor = %w(db:migrate db:seed)
 
       @on_init = []
     end
@@ -66,8 +65,8 @@ module ForemanTasks
     # it can't be remote
     def remote?
       !ForemanTasks.dynflow.executor? &&
-          !rake_task_with_executor? &&
-          @remote
+        !rake_task_with_executor? &&
+        @remote
     end
 
     def rake_task_with_executor?
@@ -79,7 +78,7 @@ module ForemanTasks
     end
 
     def increase_db_pool_size?
-       ForemanTasks.dynflow.required? && !remote? && !Rails.env.test?
+      ForemanTasks.dynflow.required? && !remote? && !Rails.env.test?
     end
 
     # To avoid pottential timeouts on db connection pool, make sure
@@ -126,14 +125,14 @@ module ForemanTasks
           db_config['database'] = "#{File.dirname(database)}/dynflow-#{File.basename(database)}"
         end
       end
-      return db_config
+      db_config
     end
 
     def initialize_executor(world)
-      if self.remote?
+      if remote?
         false
       else
-        ::Dynflow::Executors::Parallel.new(world, self.pool_size)
+        ::Dynflow::Executors::Parallel.new(world, pool_size)
       end
     end
 
@@ -145,6 +144,5 @@ module ForemanTasks
     def initialize_persistence
       ForemanTasks::Dynflow::Persistence.new(default_sequel_adapter_options)
     end
-
   end
 end

data/lib/foreman_tasks/dynflow/console_authorizer.rb

@@ -21,7 +21,7 @@ module ForemanTasks
     def unlimited_edit?
       return true if @user.admin?
       # users with unlimited edit_foreman_tasks can operate with the
-      # console no matter what task it is…
+      # console no matter what task it is...
       edit_permission = Permission.where(:name => :edit_foreman_tasks, :resource_type => ForemanTasks::Task.name).first
       if @user.filters.joins(:filterings).unlimited.where('filterings.permission_id' => edit_permission).first
         return true
@@ -29,7 +29,7 @@ module ForemanTasks
     end
 
     def authorized_for_task?
-      if task = extract_task
+      if (task = extract_task)
         begin
           original_user = User.current
           User.current = @user
@@ -38,16 +38,15 @@ module ForemanTasks
           User.current = original_user
         end
       else
-        return false
+        false
       end
     end
 
     def extract_task
-      dynflow_id = @rack_request.path_info[/^\/([\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12})/,1]
+      dynflow_id = @rack_request.path_info[/^\/([\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12})/, 1]
       unless dynflow_id.empty?
         ForemanTasks::Task::DynflowTask.where(:external_id => dynflow_id).first
       end
     end
-
   end
 end

data/lib/foreman_tasks/dynflow/daemon.rb

@@ -2,25 +2,24 @@ require 'fileutils'
 
 module ForemanTasks
   class Dynflow::Daemon
-
     # load the Rails environment and initialize the executor
     # in this thread.
     def run(foreman_root = Dir.pwd)
-      STDERR.puts("Starting Rails environment")
-      foreman_env_file = File.expand_path("./config/environment.rb", foreman_root)
-      unless File.exists?(foreman_env_file)
+      STDERR.puts('Starting Rails environment')
+      foreman_env_file = File.expand_path('./config/environment.rb', foreman_root)
+      unless File.exist?(foreman_env_file)
         raise "#{foreman_root} doesn't seem to be a foreman root directory"
       end
       ForemanTasks.dynflow.executor!
       require foreman_env_file
-      STDERR.puts("Everything ready")
+      STDERR.puts('Everything ready')
       sleep
     ensure
-      STDERR.puts("Exiting")
+      STDERR.puts('Exiting')
     end
 
     # run the executor as a daemon
-    def run_background(command = "start", options = {})
+    def run_background(command = 'start', options = {})
       default_options = { foreman_root: Dir.pwd,
                           process_name: 'dynflow_executor',
                           pid_dir: "#{Rails.root}/tmp/pids",
@@ -36,7 +35,7 @@ module ForemanTasks
         raise "You need to add gem 'daemons' to your Gemfile if you wish to use it."
       end
 
-      unless %w[start stop restart run].include?(command)
+      unless %w(start stop restart run).include?(command)
         raise "Command exptected to be 'start', 'stop', 'restart', 'run', was #{command.inspect}"
       end
 
@@ -44,19 +43,20 @@ module ForemanTasks
 
       options[:executors_count].times do
         Daemons.run_proc(options[:process_name],
-                       :multiple => true,
-                       :dir => options[:pid_dir],
-                       :log_dir => options[:log_dir],
-                       :dir_mode => :normal,
-                       :monitor => true,
-                       :log_output => true,
-                       :ARGV => [command]) do |*args|
+                         :multiple => true,
+                         :dir => options[:pid_dir],
+                         :log_dir => options[:log_dir],
+                         :dir_mode => :normal,
+                         :monitor => true,
+                         :log_output => true,
+                         :log_output_syslog => true,
+                         :ARGV => [command]) do |*_args|
           begin
             ::Logging.reopen
             run(options[:foreman_root])
           rescue => e
             STDERR.puts e.message
-            Foreman::Logging.exception("Failed running foreman-tasks daemon", e)
+            Foreman::Logging.exception('Failed running foreman-tasks daemon', e)
             exit 1
           end
         end
@@ -66,9 +66,7 @@ module ForemanTasks
     protected
 
     def world
-       ForemanTasks.dynflow.world
+      ForemanTasks.dynflow.world
     end
-
-
   end
 end

data/lib/foreman_tasks/dynflow/persistence.rb

@@ -1,19 +1,17 @@
 module ForemanTasks
-
   # wrap the dynflow persistence to reflect the changes to execution plan
   # in the Task model. This is probably a temporary solution and
   # Dynflow will probably get more events-based API but it should be enought
   # for start, until the requiements on the API are clear enough.
   class Dynflow::Persistence < ::Dynflow::PersistenceAdapters::Sequel
-
     def save_execution_plan(execution_plan_id, value)
       # clear connection only if not running in some active record transaction already
-      clear_connections = ActiveRecord::Base.connection.open_transactions == 0
+      clear_connections = ActiveRecord::Base.connection.open_transactions.zero?
       super.tap do
         begin
           on_execution_plan_save(execution_plan_id, value)
         rescue => e
-          Foreman::Logging.exception("Error on on_execution_plan_save event", e, :logger => 'foreman-tasks/dynflow')
+          Foreman::Logging.exception('Error on on_execution_plan_save event', e, :logger => 'foreman-tasks/dynflow')
         end
       end
     ensure
@@ -26,11 +24,11 @@ module ForemanTasks
       case data[:state]
       when :pending
         task = ForemanTasks::Task::DynflowTask.new_for_execution_plan(execution_plan_id, data)
-        task.start_at ||= Time.now
+        task.start_at ||= Time.zone.now
         task.save!
       when :scheduled
         delayed_plan = load_delayed_plan(execution_plan_id)
-        raise Foreman::Exception.new('Plan is delayed but the delay record is missing') if delayed_plan.nil?
+        raise Foreman::Exception, 'Plan is delayed but the delay record is missing' if delayed_plan.nil?
         task = ::ForemanTasks::Task::DynflowTask.find_by!(:external_id => execution_plan_id)
         task.update_from_dynflow(data.merge(:start_at => delayed_plan[:start_at],
                                             :start_before => delayed_plan[:start_before]))
@@ -39,13 +37,12 @@ module ForemanTasks
         task.update_from_dynflow(data)
         Lock.owner!(::User.current, task.id) if ::User.current
       else
-        if task = ::ForemanTasks::Task::DynflowTask.where(:external_id => execution_plan_id).first
+        if (task = ::ForemanTasks::Task::DynflowTask.where(:external_id => execution_plan_id).first)
           unless task.state.to_s == data[:state].to_s
             task.update_from_dynflow(data)
           end
         end
       end
     end
-
   end
 end

data/lib/foreman_tasks/engine.rb

@@ -4,10 +4,14 @@ require 'gettext_i18n_rails'
 
 module ForemanTasks
   class Engine < ::Rails::Engine
-    engine_name "foreman_tasks"
+    engine_name 'foreman_tasks'
 
     initializer 'foreman_tasks.load_default_settings', :before => :load_config_initializers do
-      require_dependency File.expand_path('../../../app/models/setting/foreman_tasks.rb', __FILE__) if (Setting.table_exists? rescue(false))
+      require_dependency File.expand_path('../../../app/models/setting/foreman_tasks.rb', __FILE__) if begin
+                                                                                                          Setting.table_exists?
+                                                                                                        rescue
+                                                                                                          (false)
+                                                                                                        end
     end
 
     # Precompile any JS or CSS files under app/assets/
@@ -35,9 +39,9 @@ module ForemanTasks
       Foreman::Gettext::Support.add_text_domain locale_domain, locale_dir
     end
 
-    initializer 'foreman_tasks.register_plugin', :before => :finisher_hook do |app|
+    initializer 'foreman_tasks.register_plugin', :before => :finisher_hook do |_app|
       Foreman::Plugin.register :"foreman-tasks" do
-        requires_foreman '>= 1.9.0'
+        requires_foreman '>= 1.15.0'
         divider :top_menu, :parent => :monitor_menu, :last => true
         menu :top_menu, :tasks,
              :url_hash => { :controller => 'foreman_tasks/tasks', :action => :index },
@@ -51,64 +55,63 @@ module ForemanTasks
              :parent   => :monitor_menu,
              :last     => true
 
-        security_block :foreman_tasks do |map|
-          permission :view_foreman_tasks, {:'foreman_tasks/tasks' => [:auto_complete_search, :sub_tasks, :index, :show],
-                                           :'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],
-                                           :'foreman_tasks/api/tasks' => [:bulk_resume]}, :resource_type => ForemanTasks::Task.name
+        security_block :foreman_tasks do |_map|
+          permission :view_foreman_tasks, { :'foreman_tasks/tasks' => [:auto_complete_search, :sub_tasks, :index, :show],
+                                            :'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],
+                                            :'foreman_tasks/api/tasks' => [:bulk_resume] }, :resource_type => ForemanTasks::Task.name
 
-          permission :create_recurring_logics, { }, :resource_type => ForemanTasks::RecurringLogic.name
+          permission :create_recurring_logics, {}, :resource_type => ForemanTasks::RecurringLogic.name
 
           permission :view_recurring_logics, { :'foreman_tasks/recurring_logics' => [:index, :show],
                                                :'foreman_tasks/api/recurring_logics' => [:index, :show] }, :resource_type => ForemanTasks::RecurringLogic.name
 
           permission :edit_recurring_logics, { :'foreman_tasks/recurring_logics' => [:cancel],
                                                :'foreman_tasks/api/recurring_logics' => [:cancel] }, :resource_type => ForemanTasks::RecurringLogic.name
-
         end
 
         logger :dynflow, :enabled => true
         logger :action, :enabled => true
 
-        role "Tasks Manager", [:view_foreman_tasks, :edit_foreman_tasks]
-        role "Tasks Reader", [:view_foreman_tasks]
+        role 'Tasks Manager', [:view_foreman_tasks, :edit_foreman_tasks]
+        role 'Tasks Reader', [:view_foreman_tasks]
 
-        widget 'foreman_tasks/tasks/dashboard/tasks_status', :sizex=>6, :sizey=>1, :name=> N_('Task Status')
-        widget 'foreman_tasks/tasks/dashboard/latest_tasks_in_error_warning', :sizex=>6, :sizey=>1,:name=> N_('Latest Warning/Error Tasks')
+        widget 'foreman_tasks/tasks/dashboard/tasks_status', :sizex => 6, :sizey => 1, :name => N_('Task Status')
+        widget 'foreman_tasks/tasks/dashboard/latest_tasks_in_error_warning', :sizex => 6, :sizey => 1, :name => N_('Latest Warning/Error Tasks')
       end
     end
 
-    initializer 'foreman_tasks.ignore_dynflow_tables' do |app|
+    initializer 'foreman_tasks.ignore_dynflow_tables' do |_app|
       # Ignore Dynflow tables when schema-dumping. Dynflow tables are handled automatically by Dynflow.
       ActiveRecord::SchemaDumper.ignore_tables << /^dynflow_.*$/
     end
 
-    initializer "foreman_tasks.apipie" do
+    initializer 'foreman_tasks.apipie' do
       # this condition is here for compatibility reason to work with Foreman 1.4.x
       if Apipie.configuration.api_controllers_matcher.is_a?(Array) &&
-            Apipie.configuration.respond_to?(:checksum_path)
+         Apipie.configuration.respond_to?(:checksum_path)
         Apipie.configuration.api_controllers_matcher << "#{ForemanTasks::Engine.root}/app/controllers/foreman_tasks/api/*.rb"
         Apipie.configuration.checksum_path += ['/foreman_tasks/api/']
       end
     end
 
-    initializer "foreman_tasks.register_paths" do |app|
-      ForemanTasks.dynflow.config.eager_load_paths.concat(%W[#{ForemanTasks::Engine.root}/app/lib/actions])
+    initializer 'foreman_tasks.register_paths' do |_app|
+      ForemanTasks.dynflow.config.eager_load_paths.concat(%W(#{ForemanTasks::Engine.root}/app/lib/actions))
     end
 
-    initializer "foreman_tasks.test_exceptions" do |app|
+    initializer 'foreman_tasks.test_exceptions' do |_app|
       if defined? ActiveSupport::TestCase
         require 'foreman_tasks/test_extensions'
       end
     end
 
-    initializer "foreman_tasks.load_app_instance_data" do |app|
+    initializer 'foreman_tasks.load_app_instance_data' do |app|
       ForemanTasks::Engine.paths['db/migrate'].existent.each do |path|
         app.config.paths['db/migrate'] << path
       end
     end
 
-    initializer "foreman_tasks.require_dynflow", :before => "foreman_tasks.initialize_dynflow" do |app|
+    initializer 'foreman_tasks.require_dynflow', :before => 'foreman_tasks.initialize_dynflow' do |_app|
       ForemanTasks.dynflow.require!
       ::ForemanTasks.dynflow.config.on_init do |world|
         ForemanTasksCore.dynflow_setup(world)
@@ -128,8 +131,6 @@ module ForemanTasks
     if ENV['FOREMAN_TASKS_MONKEYS'] == 'true'
       config.to_prepare do
         ::Api::V2::HostsController.send :include, ForemanTasks::Concerns::HostsControllerExtension
-        ::PuppetclassesController.send :include, ForemanTasks::Concerns::EnvironmentsExtension
-        ::EnvironmentsController.send :include, ForemanTasks::Concerns::EnvironmentsExtension
         ::Host::Base.send :include, ForemanTasks::Concerns::HostActionSubject
       end
     end
@@ -147,9 +148,7 @@ module ForemanTasks
       unless ForemanTasks.dynflow.config.lazy_initialization
         if defined?(PhusionPassenger)
           PhusionPassenger.on_event(:starting_worker_process) do |forked|
-            if forked
-              ForemanTasks.dynflow.initialize!
-            end
+            ForemanTasks.dynflow.initialize! if forked
           end
         else
           ForemanTasks.dynflow.initialize!
@@ -158,15 +157,15 @@ module ForemanTasks
     end
 
     rake_tasks do
-      %w[dynflow.rake test.rake export_tasks.rake cleanup.rake].each do |rake_file|
+      %w(dynflow.rake test.rake export_tasks.rake cleanup.rake).each do |rake_file|
         full_path = File.expand_path("../tasks/#{rake_file}", __FILE__)
-        load full_path if File.exists?(full_path)
+        load full_path if File.exist?(full_path)
       end
     end
   end
 
   def self.table_name_prefix
-    "foreman_tasks_"
+    'foreman_tasks_'
   end
 
   def use_relative_model_naming