foreman-tasks 0.7.1 → 0.7.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NDU0Mzk4MWU2NDIzMmY3ZDVhMTEyZDdhN2RiNDcyNGVjZGVjMGQ1Mg==
+    MDE1OGU2NTc0M2VkNTdhYjUwODE4YTM1YTNiMTVmYWQwNTUyNjIxZQ==
   data.tar.gz: !binary |-
-    MTcyNGQ0ZDdhN2JkZWY0NzNiM2Q1MzBkNWUzZDU5Y2I0MjMxNjliZQ==
+    YmU0NzM5ZjNhZTMxODdjZjVkYTFkYTkwYWY5YjhiZDljMjUxNGZkZA==
 SHA512:
   metadata.gz: !binary |-
-    Yjg3Yjk4OTJlMmY5MDk0OWUyZWI0MDRmOTIyYjFmMDY2NDE2ZjU0YTNmODgz
-    ODI1YWY1NTBjNDk3NTgwOWFmZjgyZDhiMzcxNzVlNDg1ZTM3ODNjZjNhOWEw
-    NDcxZWY4MDEyNTJkZDk0M2RkNDQ0YTNlOWMxZDNkOTIzZDdkN2M=
+    Yzc2NTgwODNhODY2MTM5MWFjNmU3NzBkODZlZmNhYjZjZTJlZTIxMzVlZjll
+    MDQ1OTk0ZmE4MTk5ZDRiMmUyMzViNzQxYTdjZDViNmMyNTcyZjQwNmIyODI0
+    MzRiZjM4ZjA0YWJlNTRkZGY1ZjVjODNiNWJjMmZkYjAxYWU5OWM=
   data.tar.gz: !binary |-
-    OGQzOWFmNTgyZjJlMTIyNDRiNmY4Nzk4OTdlYTEyZmMzNmFlMmY4MzE3YmM5
-    M2YxMmVlOWRiMDZiODI1ZjZiMWQ4ZDhkMDMzNDIwZGY1MGY4NzEyODRhNmFj
-    ZTNhOWZiY2YwYjE2MDFlMTE2YjBjNjhkYTY3NjYxYTE0MmRjZjQ=
+    Y2VjMzU0Y2UxNjg0YjJlNGY1NDMwMWVjMzQ3NGMwNGVmMzI1ZjhkMmM2YWRl
+    NTU1NGJmZDVhMWFiODkyYjQzMzJlMmExYTI3YmJmNjY4MGU1Yzg2ZGIwNGY1
+    Njc1NzE3YTRmZmYxOTVjN2IyMGVhYmFiMDkyNmY1ZjM1ZTcyNmM=

data/README.md

@@ -93,6 +93,7 @@ it would be:
 ```ruby
 initializer "your_engine.require_dynflow", :before => "foreman_tasks.initialize_dynflow" do |app|
   ForemanTasks.dynflow.require!
+  ForemanTasks.dynflow.config.eager_load_paths << File.join(YourEngine::Engine.root, 'app/lib/actions')
 end
 ```
 
@@ -128,13 +129,73 @@ The executor process needs to be executed before the web server. You
 can run it by:
 
 ```
-RAILS_ENV=production bundle exec rake foreman_tasks:dynflow:executor
+foreman-rake foreman_tasks:dynflow:executor
 ```
 
 Also, there is a possibility to run the executor in daemonized mode
 using the `dynflow-executor`. It expects to be executed from Foreman
 rails root directory. See `-h` for more details and options
 
+Tasks cleanup
+-------------
+
+Although, the history of tasks has an auditing value, some kinds of
+tasks can grow up in number quite soon. Therefore there is a mechanism
+how to clean the tasks, using a rake command. When running without
+any arguments, the tasks are deleted based on the default parameters
+defined in the code.
+
+```
+foreman-rake foreman_tasks:cleanup
+```
+
+To see what tasks would be deleted, without actually deleting the records, you can run
+
+```
+foreman-rake foreman_tasks:cleanup NOOP=true
+```
+
+By default, only the actions explicitly defined with expiration time
+in the code, will get cleaned. One can configure new actions, or
+override the default configuration inside the configuration
+`config/settings.plugins.d/foreman_tasks.yaml`, such as:
+
+
+```
+:foreman-tasks:
+  :cleanup:
+# the period after witch to delete all the tasks (by default all tasks are not being deleted after some period)
+    :after: 365d
+# per action settings to override the default defined in the actions (cleanup_after method)
+    :actions:
+      - :name: Actions::Foreman::Host::ImportFacts
+        :after: 10d
+
+```
+
+The `foreman_tasks:cleanup` script also accepts additional parameters
+to specify the search criteria for the cleanup manually:
+
+* `FILTER`: scoped search filter (example: 'label = "Actions::Foreman::Host::ImportFacts"')
+* `AFTER`: delete tasks created after `AFTER` period. Expected format
+  is a number followed by the time unit (`s`, `h`, `m`, `y`), such as
+  `10d` for 10 days (applicable only when the `FILTER` option is specified)
+* `STATES`: comma separated list of task states to touch with the
+  cleanup, by default only stopped tasks are affected
+  (applicable only when the `FILTER` option is specified)
+* `NOOP`: set to "true" if the task should not actuall perform the
+  deletion, only report the actions the script would perform
+* `VERBOSE`: set to "true" for more verbose output
+* `BATCH_SIZE`: the size of batches the tasks get processed in (1000 by default)
+
+To see the current configuration (what actions get cleaned
+automatically and what is their `after` period), this script can be
+used:
+
+```
+foreman-rake foreman_tasks:cleanup:config
+```
+
 Issues
 ------
 

data/app/controllers/foreman_tasks/tasks_controller.rb

@@ -93,7 +93,7 @@ module ForemanTasks
 
     def filter(scope)
       scope.search_for(params[:search], :order => params[:order]).
-          paginate(:page => params[:page])
+          paginate(:page => params[:page]).select('DISTINCT foreman_tasks_tasks.*')
     end
 
   end

data/app/lib/actions/foreman/host/import_facts.rb

@@ -35,6 +35,11 @@ module Actions
           input[:host] && input[:host][:name]
         end
 
+        # default value for cleaning up the tasks, it can be overriden by settings
+        def self.cleanup_after
+          '30d'
+        end
+
       end
     end
   end

data/app/models/foreman_tasks/task.rb

@@ -23,6 +23,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 => :parent_task_id, :complete_value => true
     scoped_search :in => :locks,  :on => :resource_type, :complete_value => true, :rename => "resource_type", :ext_method => :search_by_generic_resource
     scoped_search :in => :locks,  :on => :resource_id, :complete_value => false, :rename => "resource_id", :ext_method => :search_by_generic_resource
     scoped_search :in => :owners,  :on => :id, :complete_value => true, :rename => "owner.id", :ext_method => :search_by_owner

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

@@ -85,15 +85,16 @@ module ForemanTasks
 
     def self.consistency_check
       fixed_count = 0
+      logger = Foreman::Logging.logger('foreman-tasks')
       self.running.each do |task|
         begin
           changes = task.update_from_dynflow(task.execution_plan.to_hash)
           unless changes.empty?
             fixed_count += 1
-            Rails.logger.warn("Task %s updated at consistency check: %s" % [task.id, changes.inspect])
+            logger.warn("Task %s updated at consistency check: %s" % [task.id, changes.inspect])
           end
         rescue => e
-          Rails.logger.warn("Failed at consistency check for task %s: %s\n %s" % [task.id, e.message, e.backtrace.join("\n")])
+          Foreman::Logging.exception("Failed at consistency check for task #{task.id}", e, :logger => logger)
         end
       end
       return fixed_count

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

@@ -14,11 +14,14 @@
 </style>
 
 <script>
+
+var currentTwoPaneTask;
+
 $(document).on('click', ".table-two-pane td.two-pane-link", function(e) {
-  var item = $(this).find("a");
-  if(item.length){
+  currentTwoPaneTask = $(this).find("a");
+  if(currentTwoPaneTask.length){
     e.preventDefault();
-    two_pane_open(item);
+    two_pane_open(currentTwoPaneTask);
   }
 });
 

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

@@ -1,44 +1,45 @@
 <script>
-  var taskProgressReloader = {
-    timeoutId: null,
-    reload: function () {
-      $.ajax({
-        url: "",
-        context: document.body,
-        success: function (s, x) {
-          $(this).html(s);
-          taskProgressReloader.start();
+  if (typeof taskProgressReloader === 'undefined') {
+    var taskProgressReloader = {
+      timeoutId: null,
+      reload: function () {
+        // we need different reload mechanism for two-pane and non-two-pane
+        if (typeof currentTwoPaneTask !== 'undefined') {
+          taskProgressReloader.timeoutId = null;
+          two_pane_open(currentTwoPaneTask);
+        } else {
+          document.location.reload();
         }
-      });
-    },
+      },
 
-    start: function () {
-      if (!this.timeoutId) {
-        this.timeoutId = setTimeout(this.reload, 5000);
-      }
-     var button = $('.reload-button');
-     button.html('<span class="glyphicon glyphicon-refresh spin"></span> <%= _('Stop auto-reloading') %>');
-     button.show();
-    },
+      start: function () {
+        if (!taskProgressReloader.timeoutId) {
+          taskProgressReloader.timeoutId = setTimeout(this.reload, 5000);
+        }
+        var button = $('.reload-button');
+        button.html('<span class="glyphicon glyphicon-refresh spin"></span> <%= _('Stop auto-reloading') %>');
+        button.show();
+      },
 
-    stop: function () {
-      if (this.timeoutId) {
-        clearTimeout(this.timeoutId);
-      }
-      this.timeoutId = null;
-      var button = $('.reload-button');
-      button.html('<span class="glyphicon glyphicon-refresh"></span> <%= _('Start auto-reloading') %>');
-      button.show();
-    },
+      stop: function () {
+        if (taskProgressReloader.timeoutId) {
+          clearTimeout(taskProgressReloader.timeoutId);
+        }
+        taskProgressReloader.timeoutId = null;
+        var button = $('.reload-button');
+        button.html('<span class="glyphicon glyphicon-refresh"></span> <%= _('Start auto-reloading') %>');
+        button.show();
+      },
 
-    toggle: function () {
-      if (this.timeoutId) {
-        this.stop();
-      } else {
-        this.start();
+      toggle: function () {
+        if (taskProgressReloader.timeoutId) {
+          this.stop();
+        } else {
+          this.start();
+        }
       }
-    }
-  };
+    };
+  }
 
   $(document).ready(function () {
     $('.modal-submit').click(function(e){

data/config/foreman-tasks.yaml.example

@@ -0,0 +1,26 @@
+:foreman-tasks:
+#
+# Logging configuration can be changed by uncommenting the loggers
+# section and the logger configuration desired.
+#
+#   :loggers:
+#     :dynflow:
+#       :enabled: true
+#     :action:
+#       :enabled: true
+
+
+# Cleaning configuration: how long should the actions be kept before deleted
+# by `rake foreman_tasks:clean` task
+#
+#  :cleanup:
+#
+# the period after which to delete all the tasks (by default all tasks are not being deleted after some period)
+#
+#    :after: 365d
+#
+# per action settings to override the default defined in the actions (self.cleanup_after method)
+#
+#    :actions:
+#      - :name: Actions::Foreman::Host::ImportFacts
+#        :after: 10d

data/lib/foreman_tasks.rb

@@ -4,6 +4,7 @@ require 'foreman_tasks/engine'
 require 'foreman_tasks/dynflow'
 require 'foreman_tasks/triggers'
 require 'foreman_tasks/authorizer_ext'
+require 'foreman_tasks/cleaner'
 
 module ForemanTasks
   extend Algebrick::TypeCheck

data/lib/foreman_tasks/cleaner.rb

@@ -0,0 +1,152 @@
+module ForemanTasks
+  # Represents the cleanup mechanism for tasks
+  class Cleaner
+
+    def self.run(options)
+      if options.key?(:filter)
+        self.new(options).delete
+      else
+        [:after, :states].each do |invalid_option|
+          if options.key?(invalid_option)
+            raise "The option #{invalid_option} is not valid unless the filter specified"
+          end
+        end
+        if cleanup_settings[:after]
+          self.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
+        end
+      end
+    end
+
+    def self.actions_with_default_cleanup
+      actions_with_periods = {}
+      if cleanup_settings[:actions]
+        cleanup_settings[:actions].each do |action|
+          begin
+            action_class = action[:name].constantize
+            actions_with_periods[action_class] = action[:after]
+          rescue => e
+            Foreman::Logging.exception("Error handling #{action} cleanup settings", e)
+          end
+        end
+      end
+      (ForemanTasks.dynflow.world.action_classes - actions_with_periods.keys).each do |action_class|
+        if action_class.respond_to?(:cleanup_after)
+          actions_with_periods[action_class] = action_class.cleanup_after
+        end
+      end
+      return actions_with_periods
+    end
+
+    def self.cleanup_settings
+      return @cleanup_settings if @cleanup_settings
+      @cleanup_settings = SETTINGS[:'foreman-tasks'] && SETTINGS[:'foreman-tasks'][:cleanup] || {}
+    end
+
+    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
+    #                           than the value: the number in string is expected
+    #                           to be followed by time unit specification one of s,h,d,y for
+    #        seconds ago. If not specified, no implicit filtering on the date.
+    def initialize(options = {})
+      default_options = { :after        => '0s',
+                          :verbose      => false,
+                          :batch_size   => 1000,
+                          :noop         => false,
+                          :states       => ["stopped"] }
+      options         = default_options.merge(options)
+
+      @filter         = options[:filter]
+      @after          = parse_time_interval(options[:after])
+      @states         = options[:states]
+      @verbose        = options[:verbose]
+      @batch_size     = options[:batch_size]
+      @noop           = options[:noop]
+
+      raise ArgumentError, 'filter not speficied' if @filter.nil?
+
+      @full_filter    = prepare_filter
+    end
+
+    # Delete the filtered tasks, including the dynflow execution plans
+    def delete
+      if noop
+        say "[noop] deleting all tasks matching filter #{full_filter}"
+        say "[noop] #{ForemanTasks::Task.search_for(full_filter).size} tasks would be deleted"
+      else
+        start_tracking_progress
+        while (chunk = ForemanTasks::Task.search_for(full_filter).limit(batch_size)).any?
+          delete_tasks(chunk)
+          delete_dynflow_plans(chunk)
+          report_progress(chunk)
+        end
+      end
+    end
+
+    def tasks
+      ForemanTasks::Task.search_for(full_filter).select('DISTINCT foreman_tasks_tasks.id, foreman_tasks_tasks.type, foreman_tasks_tasks.external_id')
+    end
+
+    def delete_tasks(chunk)
+      ForemanTasks::Task.where(:id => chunk.map(&:id)).delete_all
+    end
+
+    def delete_dynflow_plans(chunk)
+      dynflow_ids = chunk.find_all { |task| task.is_a? Task::DynflowTask }.map(&:external_id)
+      ForemanTasks.dynflow.world.persistence.delete_execution_plans({ 'uuid' => dynflow_ids }, batch_size)
+    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 ')
+    end
+
+    def start_tracking_progress
+      if verbose
+        @current, @total = 0, tasks.size
+        say "#{@current}/#{@total}", false
+      end
+    end
+
+    def report_progress(chunk)
+      if verbose
+        @current += chunk.size
+        say "#{@current}/#{@total}", false
+      end
+    end
+
+    def say(message, log = true)
+      puts message
+      if log
+        Foreman::Logging.logger('foreman-tasks').info(message)
+      end
+    end
+
+    def parse_time_interval(string)
+      matched_string = string.gsub(' ','').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
+      number = matched_string[1].to_i
+      value = case matched_string[2]
+              when 's'
+                number.seconds
+              when 'h'
+                number.hours
+              when 'd'
+                number.days
+              when 'y'
+                number.years
+              else
+                raise ArgumentError, "Unexpected time unit in #{string}, expected one of [s,h,d,y]"
+              end
+      return value
+    end
+  end
+end

data/lib/foreman_tasks/dynflow/configuration.rb

@@ -1,13 +1,6 @@
 module ForemanTasks
   class Dynflow::Configuration
 
-    # for logging action related info (such as exceptions raised in side
-    # the actions' methods
-    attr_accessor :action_logger
-
-    # for logging dynflow related info about the progress of the execution etc.
-    attr_accessor :dynflow_logger
-
     # the number of threads in the pool handling the execution
     attr_accessor :pool_size
 
@@ -35,8 +28,6 @@ module ForemanTasks
     attr_accessor :disable_active_record_actions
 
     def initialize
-      self.action_logger            = Rails.logger
-      self.dynflow_logger           = Rails.logger
       self.pool_size                = 5
       self.db_pool_size             = pool_size + 5
       self.remote                   = Rails.env.production?
@@ -48,6 +39,17 @@ module ForemanTasks
       @on_init = []
     end
 
+    # 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

data/lib/foreman_tasks/dynflow/daemon.rb

@@ -24,6 +24,7 @@ module ForemanTasks
       default_options = { foreman_root: Dir.pwd,
                           process_name: 'dynflow_executor',
                           pid_dir: "#{Rails.root}/tmp/pids",
+                          log_dir: File.join(Rails.root, 'log'),
                           wait_attempts: 300,
                           wait_sleep: 1 }
       options = default_options.merge(options)
@@ -42,15 +43,17 @@ module ForemanTasks
 
       Daemons.run_proc(options[:process_name],
                        :dir => options[:pid_dir],
+                       :log_dir => options[:log_dir],
                        :dir_mode => :normal,
                        :monitor => true,
                        :log_output => true,
                        :ARGV => [command]) do |*args|
         begin
+          ::Logging.reopen
           run(options[:foreman_root])
         rescue => e
           STDERR.puts e.message
-          Rails.logger.fatal e
+          Foreman::Logging.exception("Failed running foreman-tasks daemon", e)
           exit 1
         end
       end

data/lib/foreman_tasks/dynflow/persistence.rb

@@ -13,9 +13,7 @@ module ForemanTasks
         begin
           on_execution_plan_save(execution_plan_id, value)
         rescue => e
-          ForemanTasks.dynflow.world.logger.error('Error on on_execution_plan_save event')
-          ForemanTasks.dynflow.world.logger.error(e.message)
-          ForemanTasks.dynflow.world.logger.error(e.backtrace.join("\n"))
+          Foreman::Logging.exception("Error on on_execution_plan_save event", e, :logger => Foreman::Logging.logger('foreman-tasks/dynflow'))
         end
       end
     ensure

data/lib/foreman_tasks/engine.rb

@@ -8,7 +8,7 @@ module ForemanTasks
 
     initializer 'foreman_tasks.register_plugin', :after => :finisher_hook do |app|
       Foreman::Plugin.register :"foreman-tasks" do
-        requires_foreman '>= 1.6'
+        requires_foreman '>= 1.9.0'
         divider :top_menu, :parent => :monitor_menu, :after => :audits
         menu :top_menu, :tasks,
              :url_hash => { :controller => 'foreman_tasks/tasks', :action => :index },
@@ -22,6 +22,9 @@ module ForemanTasks
                                            :'foreman_tasks/api/tasks' => [:bulk_resume]}, :resource_type => ForemanTasks::Task.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]
 
@@ -91,7 +94,7 @@ module ForemanTasks
 
 
     rake_tasks do
-      %w[dynflow.rake test.rake export_tasks.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)
       end

data/lib/foreman_tasks/tasks/cleanup.rake

@@ -0,0 +1,67 @@
+namespace :foreman_tasks do
+  namespace :cleanup do
+    desc <<DESC
+Clean tasks based on filter and age. ENV variables:
+
+  * FILTER     : scoped search filter (example: 'label = "Actions::Foreman::Host::ImportFacts"')
+  * AFTER      : delete tasks created after *AFTER* period. Expected format is a number followed by the time unit (s,h,m,y), such as '10d' for 10 days
+  * STATES     : comma separated list of task states to touch with the cleanup, by default only stopped tasks are covered
+  * NOOP       : set to "true" if the task should not actuall perform the deletion
+  * VERBOSE    : set to "true" for more verbose output
+  * BATCH_SIZE : the size of batches the tasks get processed in (1000 by default)
+
+If none of FILTER, BEFORE, STATES is specified, the tasks will be cleaned based
+configuration in settings
+DESC
+    task :run => 'environment' do
+      options = {}
+
+      if ENV['FILTER']
+        options[:filter] = ENV['FILTER']
+      end
+
+      if ENV['AFTER']
+        options[:after] = ENV['AFTER']
+      end
+
+      if ENV['STATES']
+        options[:states] = ENV['STATES'].to_s.split(',')
+      end
+
+      if ENV['NOOP']
+        options[:noop] = true
+      end
+
+      if ENV['VERBOSE']
+        options[:verbose] = true
+      end
+
+      if ENV['BATCH_SIZE']
+        options[:batch_size] = ENV['BATCH_SIZE'].to_i
+      end
+
+      ForemanTasks::Cleaner.run(options)
+    end
+
+    desc 'Show the current configuration for auto-cleanup'
+    task :config => 'environment' do
+      if ForemanTasks::Cleaner.cleanup_settings[:after]
+        puts _('The tasks will be deleted after %{after}') % ForemanTasks::Cleaner.cleanup_settings[:after]
+      else
+        puts _('Global period for cleaning up tasks is not set')
+      end
+
+      if ForemanTasks::Cleaner.actions_with_default_cleanup.empty?
+        puts _('No actions are configured to be cleaned automatically')
+      else
+        puts _('The following actions are configured to be deleted automatically after some time:')
+        printf("%-50s %s\n", _('name'), _('delete after'))
+        ForemanTasks::Cleaner.actions_with_default_cleanup.each do |action, after|
+          printf("%-50s %s\n", action.name, after)
+        end
+      end
+    end
+  end
+
+  task :cleanup => 'cleanup:run'
+end

data/lib/foreman_tasks/version.rb

@@ -1,3 +1,3 @@
 module ForemanTasks
-  VERSION = "0.7.1"
+  VERSION = "0.7.2"
 end

data/test/factories/task_factory.rb

@@ -22,11 +22,18 @@ FactoryGirl.define do
       result "success"
       parent_task_id nil
 
-      after(:build) do |task|
+      transient do
+        sync_with_dynflow false
+      end
+
+      after(:build) do |task, evaluator|
         execution_plan = ForemanTasks.dynflow.world.plan(Support::DummyDynflowAction)
         # remove the task created automatically by the persistence
         ForemanTasks::Task.where(:external_id => execution_plan.id).delete_all
-        task.update_from_dynflow(execution_plan.to_hash)
+        task.update_attributes!(:external_id => execution_plan.id)
+        if evaluator.sync_with_dynflow
+          task.update_from_dynflow(execution_plan.to_hash)
+        end
       end
 
       trait :user_create_task do

data/test/unit/cleaner_test.rb

@@ -0,0 +1,74 @@
+require 'foreman_tasks_test_helper'
+
+class TasksTest < ActiveSupport::TestCase
+  describe ForemanTasks::Cleaner do
+    it 'is able to delete tasks (including the dynflow plans) based on filter' do
+      cleaner = ForemanTasks::Cleaner.new(:filter => 'label = "Actions::User::Create"', :after => '10d')
+
+      tasks_to_delete = [FactoryGirl.create(:dynflow_task, :user_create_task),
+                         FactoryGirl.create(:dynflow_task, :user_create_task)]
+      tasks_to_keep   = [FactoryGirl.create(:dynflow_task, :user_create_task) do |task|
+                           task.started_at = task.ended_at = Time.now
+                           task.save
+                         end,
+                         FactoryGirl.create(:dynflow_task, :product_create_task)]
+      cleaner.delete
+      ForemanTasks::Task.where(id: tasks_to_delete).must_be_empty
+      ForemanTasks::Task.where(id: tasks_to_keep).must_equal tasks_to_keep
+
+      ForemanTasks.dynflow.world.persistence.
+          find_execution_plans(filters: {'uuid' => tasks_to_delete.map(&:external_id)}).size.must_equal 0
+
+      ForemanTasks.dynflow.world.persistence.
+          find_execution_plans(filters: {'uuid' => tasks_to_keep.map(&:external_id)}).size.must_equal tasks_to_keep.size
+    end
+
+    it 'deletes all tasks matching the filter when the time limit is not specified' do
+      cleaner = ForemanTasks::Cleaner.new(:filter => 'label = "Actions::User::Create"')
+      tasks_to_delete = [FactoryGirl.create(:dynflow_task, :user_create_task),
+                         FactoryGirl.create(:dynflow_task, :user_create_task) do |task|
+                           task.started_at = task.ended_at = Time.now
+                           task.save
+                         end]
+
+      tasks_to_keep   = [FactoryGirl.create(:dynflow_task, :product_create_task)]
+      cleaner.delete
+      ForemanTasks::Task.where(id: tasks_to_delete).must_be_empty
+      ForemanTasks::Task.where(id: tasks_to_keep).must_equal tasks_to_keep
+    end
+
+    it 'supports passing empty filter (just delete all)' do
+      cleaner = ForemanTasks::Cleaner.new(:filter => '', :after => '10d')
+      tasks_to_delete = [FactoryGirl.create(:dynflow_task, :user_create_task),
+                         FactoryGirl.create(:dynflow_task, :product_create_task)]
+
+      tasks_to_keep   = [FactoryGirl.create(:dynflow_task, :user_create_task) do |task|
+                           task.started_at = task.ended_at = Time.now
+                           task.save
+                         end]
+      cleaner.delete
+      ForemanTasks::Task.where(id: tasks_to_delete).must_be_empty
+      ForemanTasks::Task.where(id: tasks_to_keep).must_equal tasks_to_keep
+    end
+
+    class ActionWithCleanup < Actions::Base
+      def self.cleanup_after
+        '15d'
+      end
+    end
+
+    describe "default behaviour" do
+      it "searches for the actions that have the cleanup_after defined" do
+        ForemanTasks::Cleaner.stubs(:cleanup_settings => {})
+        ForemanTasks::Cleaner.actions_with_default_cleanup[ActionWithCleanup].must_equal '15d'
+      end
+
+      it "searches for the actions that have the cleanup_after defined" do
+        ForemanTasks::Cleaner.stubs(:cleanup_settings =>
+                                     { :actions => [{:name => ActionWithCleanup.name, :after => '5d'}]})
+        ForemanTasks::Cleaner.actions_with_default_cleanup[ActionWithCleanup].must_equal '5d'
+      end
+
+    end
+  end
+end

data/test/unit/task_test.rb

@@ -37,7 +37,7 @@ class TasksTest < ActiveSupport::TestCase
 
   describe 'consistency check' do
 
-    let(:consistent_task) { FactoryGirl.create(:dynflow_task) }
+    let(:consistent_task) { FactoryGirl.create(:dynflow_task, :sync_with_dynflow => true) }
     let(:inconsistent_task) { FactoryGirl.create(:dynflow_task, :inconsistent_dynflow_task) }
 
     it 'ensures the tasks marked as running are really running in Dynflow' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: foreman-tasks
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.2
 platform: ruby
 authors:
 - Ivan Nečas
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-03 00:00:00.000000000 Z
+date: 2015-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dynflow
@@ -126,6 +126,7 @@ files:
 - app/views/foreman_tasks/tasks/show.html.erb
 - bin/dynflow-executor
 - bin/foreman-tasks
+- config/foreman-tasks.yaml.example
 - config/routes.rb
 - db/migrate/20131205204140_create_foreman_tasks.rb
 - db/migrate/20131209122644_create_foreman_tasks_locks.rb
@@ -138,6 +139,7 @@ files:
 - lib/foreman-tasks.rb
 - lib/foreman_tasks.rb
 - lib/foreman_tasks/authorizer_ext.rb
+- lib/foreman_tasks/cleaner.rb
 - lib/foreman_tasks/dynflow.rb
 - lib/foreman_tasks/dynflow/configuration.rb
 - lib/foreman_tasks/dynflow/console_authorizer.rb
@@ -145,6 +147,7 @@ files:
 - lib/foreman_tasks/dynflow/persistence.rb
 - lib/foreman_tasks/engine.rb
 - lib/foreman_tasks/task_error.rb
+- lib/foreman_tasks/tasks/cleanup.rake
 - lib/foreman_tasks/tasks/dynflow.rake
 - lib/foreman_tasks/tasks/export_tasks.rake
 - lib/foreman_tasks/triggers.rb
@@ -156,6 +159,7 @@ files:
 - test/helpers/foreman_tasks/tasks_helper_test.rb
 - test/support/dummy_dynflow_action.rb
 - test/unit/actions/action_with_sub_plans_test.rb
+- test/unit/cleaner_test.rb
 - test/unit/dynflow_console_authorizer_test.rb
 - test/unit/task_test.rb
 homepage: https://github.com/theforeman/foreman-tasks
@@ -187,6 +191,7 @@ test_files:
 - test/foreman_tasks_test_helper.rb
 - test/controllers/api/tasks_controller_test.rb
 - test/factories/task_factory.rb
+- test/unit/cleaner_test.rb
 - test/unit/dynflow_console_authorizer_test.rb
 - test/unit/actions/action_with_sub_plans_test.rb
 - test/unit/task_test.rb