foreman-tasks 0.7.3 → 0.7.4

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    Y2I3YzI4OGYwN2U1YWZmZGQ1MmE2MmVlYTBiNTBlZmUyMDhkMDJkYQ==
+    NzAzZDZlZGRhYjg2OWM2ZGU3NTdkMGMzMmZmMTg4ZDJhODU3NjU3NA==
   data.tar.gz: !binary |-
-    NDNlOGVkYjFjODE5ZmQ2NWNiMjYzOTFjMmI3NTQ3N2FjYmYzMmI2Mg==
+    NzQ1ZDRmODAwYzg3ODhhNThjMGVmNmQyZDQwNDA3NDliNjVkYjYxNQ==
 SHA512:
   metadata.gz: !binary |-
-    OTA1NDM0MjUyZDIzNGNmMjA3NTgwNWNkYzVmZDhmODg4ZDk3MGY0YjMzZGIx
-    ZjQyMTY4N2Y5NTgwNTQzMTEwNWU4ZmZlYThmNmEzZWVmMWE1ZGVmZDFlMWUz
-    N2IyZjkyMzc1YjIzOWZjZjY4M2E1NDc1NmI2NTI4ZTI4Y2RhOWE=
+    N2U4ZmQ0ZTE4MTZkNDlmMWRmYmEzYThhODJiYWQwZTEyOTQyY2Q3MWZjMzM1
+    NDJlNjQ1YWNjNWU5ODgzZmE3NjVmN2Q0Y2YzMGI4Y2NlZjZkN2RmODcyYzRk
+    ODc5Y2FlNWQ5ZDE3YjlmODYyMWYzYTI3YTljOWIxMTdmOWYwMzE=
   data.tar.gz: !binary |-
-    ZDRjZmVlN2I2NDgwMDc4YjVlODA2MjE1ZjY5MzRmZGJmMDlkOGM5OTI0YWMy
-    ZTJkNmIzMDk0MDZiYTZmOGEzMzFiZDZmOTdmNGYwNTQzYjg2NzBkNTUwN2Ew
-    YzQ2N2RlNWU1ZjdiNWRhOWY5NDE0ZmVjYWMxOTA4NmJkYTcwNjI=
+    YTU2ZjFlNTY2ZjI3MzA5ZmMxMWQ2YzQzMDQxMTZjMjY3NDExMjNmNjVlZjkz
+    ZjJhOGRlODk5OTgxOGIyZDI0NzE0YjY3ZmFhZDQxNmE4NGFlYWQ4Y2Q3ZWMw
+    MTY5MWMwNjMzNDVlOWJiMzE2YWZjMTgwZjc0NDZkZjYyNmE2MWY=

data/app/lib/actions/bulk_action.rb

@@ -54,10 +54,10 @@ module Actions
 
     def check_targets!(targets)
       if targets.empty?
-        fail _("Empty bulk action")
+        fail ::Foreman::Exception.new(N_("Empty bulk action"))
       end
       if targets.map(&:class).uniq.length > 1
-        fail _("The targets are of different types")
+        fail ::Foreman::Exception.new(N_("The targets are of different types"))
       end
     end
 

data/app/lib/actions/entry_action.rb

@@ -56,5 +56,9 @@ module Actions
       subclasses.map { |k| k.allocate.humanized_name }
     end
 
+    def delay(_schedule_options, *args)
+      Serializers::ActiveRecordSerializer.new args
+    end
+
   end
 end

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

@@ -15,8 +15,15 @@ module Actions
   module Middleware
 
     class KeepCurrentUser < Dynflow::Middleware
+
+      def delay(*args)
+        pass(*args).tap { store_current_user }
+      end
+
       def plan(*args)
-        pass(*args).tap { action.input[:current_user_id] = User.current.id }
+        with_current_user do
+          pass(*args).tap { store_current_user }
+        end
       end
 
       def run(*args)
@@ -29,6 +36,18 @@ module Actions
 
       private
 
+      def with_current_user
+        if User.current || action.input[:current_user_id].nil?
+          yield
+        else
+          restore_curent_user { yield }
+        end
+      end
+
+      def store_current_user
+        action.input[:current_user_id] = User.current.try(:id)
+      end
+
       def restore_curent_user
         User.current = User.find(action.input[:current_user_id])
         yield

data/app/lib/actions/proxy_action.rb

@@ -2,6 +2,7 @@ module Actions
   class ProxyAction < Base
 
     include ::Dynflow::Action::Cancellable
+    include ::Dynflow::Action::Timeouts
 
     class CallbackData
       attr_reader :data
@@ -12,39 +13,65 @@ module Actions
     end
 
     def plan(proxy, options)
+      options[:connection_options] ||= {}
+      default_connection_options.each { |key, value| options[:connection_options][key] ||= value }
       plan_self(options.merge(:proxy_url => proxy.url))
     end
 
     def run(event = nil)
-      case event
-      when nil
-        if output[:proxy_task_id]
-          on_resume
+      with_connection_error_handling(event) do |event|
+        case event
+        when nil
+          if output[:proxy_task_id]
+            on_resume
+          else
+            trigger_proxy_task
+          end
+          suspend
+        when ::Dynflow::Action::Skip
+          # do nothing
+        when ::Dynflow::Action::Cancellable::Cancel
+          cancel_proxy_task
+        when CallbackData
+          on_data(event.data)
+        when ::Dynflow::Action::Timeouts::Timeout
+          check_task_status
         else
-          trigger_proxy_task
+          raise "Unexpected event #{event.inspect}"
         end
-        suspend
-      when ::Dynflow::Action::Skip
-        # do nothing
-      when ::Dynflow::Action::Cancellable::Cancel
-        cancel_proxy_task
-      when CallbackData
-        on_data(event.data)
-      else
-        raise "Unexpected event #{event.inspect}"
       end
     end
 
     def trigger_proxy_task
-      response = proxy.trigger_task(proxy_action_name,
-                                    input.merge(:callback => { :task_id => task.id,
-                                                               :step_id => run_step_id }))
-      output[:proxy_task_id] = response["task_id"]
+      suspend do |_suspended_action|
+        set_timeout! unless timeout_set?
+        response = proxy.trigger_task(proxy_action_name,
+                                      input.merge(:callback => { :task_id => task.id,
+                                                                 :step_id => run_step_id }))
+        output[:proxy_task_id] = response["task_id"]
+      end
+    end
+
+    def check_task_status
+      if output[:proxy_task_id]
+        response = proxy.status_of_task(output[:proxy_task_id])
+        if response['state'] == 'stopped'
+          if response['result'] == 'error'
+            raise ::Foreman::Exception, _("The smart proxy task '#{output[:proxy_task_id]}' failed.")
+          else
+            on_data(response['actions'].find { |block_action| block_action['class'] == proxy_action_name }['output'])
+          end
+        else
+          cancel_proxy_task
+        end
+      else
+        process_timeout
+      end
     end
 
     def cancel_proxy_task
       if output[:cancel_sent]
-        error! _("Cancel enforced: the task might be still running on the proxy")
+        error! ForemanTasks::Task::TaskCancelledException.new(_("Cancel enforced: the task might be still running on the proxy"))
       else
         proxy.cancel_task(output[:proxy_task_id])
         output[:cancel_sent] = true
@@ -78,5 +105,65 @@ module Actions
     def proxy_output=(output)
       output[:proxy_output] = output
     end
+
+    def metadata
+      output[:metadata] ||= {}
+      output[:metadata]
+    end
+
+    def metadata=(thing)
+      output[:metadata] ||= {}
+      output[:metadata] = thing
+    end
+
+    def timeout_set?
+      !metadata[:timeout].nil?
+    end
+
+    def set_timeout!
+      time = Time.now + input[:connection_options][:timeout]
+      schedule_timeout(time)
+      metadata[:timeout] = time.to_s
+    end
+
+    def default_connection_options
+      # 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 => 15, :retry_count => 4, :timeout => 60 }
+    end
+
+    private
+
+    def with_connection_error_handling(event = nil)
+      yield event
+    rescue ::RestClient::Exception, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ETIMEDOUT => e
+      if event.class == CallbackData || event == ::Dynflow::Action::Timeouts::Timeout
+        raise e
+      else
+        handle_connection_exception(e, event)
+      end
+    end
+
+    def format_exception(exception)
+      { output[:proxy_task_id] =>
+            { :exception_class => exception.class.name,
+              :execption_message => exception.message } }
+    end
+
+    def handle_connection_exception(exception, event = nil)
+      metadata[:failed_proxy_tasks] ||= []
+      options = input[:connection_options]
+      metadata[:failed_proxy_tasks] << format_exception(exception)
+      output[:proxy_task_id] = nil
+      if metadata[:failed_proxy_tasks].count < options[:retry_count]
+        suspend do |suspended_action|
+          @world.clock.ping suspended_action,
+                            Time.now + options[:retry_interval],
+                            event
+        end
+      else
+        raise exception
+      end
+    end
   end
 end

data/app/lib/actions/serializers/active_record_serializer.rb

@@ -0,0 +1,26 @@
+module Actions
+  module Serializers
+
+    class ActiveRecordSerializer < ::Dynflow::Serializers::Noop
+      def serialize(arg)
+        if arg.is_a? ActiveRecord::Base
+          { :active_record_object => true,
+            :class_name => arg.class.name,
+            :id => arg.id }
+        else
+          super arg
+        end
+      end
+
+      def deserialize(arg)
+        if arg.is_a?(Hash) && arg[:active_record_object]
+          arg[:class_name].constantize.find(arg[:id])
+        else
+          super arg
+        end
+      end
+    end
+
+  end
+end
+

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

@@ -22,10 +22,14 @@ module ProxyAPI
         MultiJson.load(Task.new(@args).send(:post, payload))
       end
 
-      # Initiate the command
+      # Cancel the command
       def cancel_task(proxy_task_id)
         MultiJson.load(Task.new(@args).send(:post, "", "#{ proxy_task_id }/cancel"))
       end
+
+      def status_of_task(proxy_task_id)
+        MultiJson.load(Task.new(@args).send(:get, "#{ proxy_task_id }/status"))
+      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 => :ended_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
@@ -66,9 +67,10 @@ module ForemanTasks
     end
 
     # returns true if the task is running or waiting to be run
-    def pending
+    def pending?
       self.state != 'stopped'
     end
+    alias_method :pending, :pending?
 
     def resumable?
       false

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

@@ -11,6 +11,8 @@ module ForemanTasks
       self.ended_at       = data[:ended_at]
       self.state          = data[:state].to_s
       self.result         = data[:result].to_s
+      self.start_at       = data[:start_at] if data[:start_at]
+      self.start_before   = data[:start_before] if data[:start_before]
       self.parent_task_id ||= begin
                                 if main_action.caller_execution_plan_id
                                   DynflowTask.find_by_external_id!(main_action.caller_execution_plan_id).id
@@ -102,10 +104,16 @@ module ForemanTasks
             logger.warn("Task %s updated at consistency check: %s" % [task.id, changes.inspect])
           end
         rescue => e
-          Foreman::Logging.exception("Failed at consistency check for task #{task.id}", e, :logger => logger)
+          Foreman::Logging.exception("Failed at consistency check for task #{task.id}", e, :logger => 'foreman-tasks')
         end
       end
       return fixed_count
     end
+
+    def self.new_for_execution_plan(execution_plan_id, data)
+      self.new(:external_id => execution_plan_id,
+               :state => data[:state].to_s,
+               :result => data[:result].to_s)
+    end
   end
 end

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

@@ -1,8 +1,8 @@
 module ForemanTasks
   class Task::Summarizer
     def summarize_by_status(since=nil)
-      result = ::ForemanTasks::Task.select('count(state), state, result').group(:state, :result).order(:state)
-      result.where('started_at > ?', since) if since
+      result = ::ForemanTasks::Task.select('count(state) AS count, state, result').group(:state, :result).order(:state)
+      result = result.where('started_at > ?', since) if since
       result
     end
 

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

@@ -0,0 +1,7 @@
+module ForemanTasks
+  class Task::TaskCancelledException < ::Foreman::Exception
+    def backtrace
+      []
+    end
+  end
+end

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

@@ -95,13 +95,25 @@
   <span class="param-name"><%= _("Owner") %>:</span>
   <span class="param-value"><%= @task.username %></span>
 </div>
+<div>
+  <span class="param-name"><%= _("Execution type") %>:</span>
+  <span class="param-value"><%= @task.start_at.nil? ? _('Immediate') : _('Delayed') %></span>
+</div>
+<div>
+  <span class="param-name"><%= _("Start at") %>:</span>
+  <span class="param-value"><%= @task.start_at.nil? ? '-' : @task.start_at %></span>
+</div>
+<div>
+  <span class="param-name"><%= _("Start before") %>:</span>
+  <span class="param-value"><%= @task.start_before.nil? ? '-' : @task.start_before %></span>
+</div>
 <div>
   <span class="param-name"><%= _("Started at") %>:</span>
-  <span class="param-value"><%= @task.started_at %></span>
+  <span class="param-value"><%= @task.started_at.try(:in_time_zone) %></span>
 </div>
 <div>
   <span class="param-name"><%= _("Ended at") %>:</span>
-  <span class="param-value"><%= @task.ended_at %></span>
+  <span class="param-value"><%= @task.ended_at.try(:in_time_zone) %></span>
 </div>
 <div>
   <span class="param-name"><%= _("State") %>:</span>

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

@@ -32,6 +32,7 @@ $(document).on('click', ".table-two-pane td.two-pane-link", function(e) {
     <th><%= _("State") %></th>
     <th><%= _("Result") %></th>
     <th><%= sort :started_at, :as => _("Started at") %></th>
+    <th><%= sort :ended_at, :as => _("Ended at") %></th>
     <th><%= _("User") %></th>
   </tr>
   <% for task in @tasks %>
@@ -42,7 +43,8 @@ $(document).on('click', ".table-two-pane td.two-pane-link", function(e) {
       </td>
       <td><%= task.state %></td>
       <td><%= task.result %></td>
-      <td><%= task.started_at %></td>
+      <td><%= task.started_at.try(:in_time_zone) %></td>
+      <td><%= task.ended_at.try(:in_time_zone) %></td>
       <td><%= task.username %></td>
     </tr>
   <% end %>

data/db/migrate/20150817102538_add_delay_attributes.rb

@@ -0,0 +1,6 @@
+class AddDelayAttributes < ActiveRecord::Migration
+  def change
+    add_column :foreman_tasks_tasks, :start_at, :datetime, index: true, default: nil, null: true
+    add_column :foreman_tasks_tasks, :start_before, :datetime, index: true, default: nil, null: true
+  end
+end

data/db/seeds.d/61-foreman_tasks_bookmarks.rb

@@ -0,0 +1,12 @@
+Bookmark.without_auditing do
+  [
+    { :name => "running", :query => "state = running" },
+    { :name => "failed", :query => "state = paused or result = error or result = warning" }
+
+  ].each do |item|
+    next if Bookmark.find_by_name(item[:name])
+    next if audit_modified? Bookmark, item[:name]
+    b = Bookmark.create({:controller => "foreman_tasks_tasks", :public => true}.merge(item))
+    raise "Unable to create bookmark: #{format_errors b}" if b.nil? || b.errors.any?
+  end
+end

data/lib/foreman_tasks.rb

@@ -40,4 +40,9 @@ module ForemanTasks
       raise TaskError.new(task) if task.execution_plan.error?
     end
   end
+
+  def self.delay(action, delay_options, *args)
+    result = dynflow.world.delay action, delay_options, *args
+    ForemanTasks::Task::DynflowTask.find_by_external_id!(result.id)
+  end
 end

data/lib/foreman_tasks/dynflow/persistence.rb

@@ -13,7 +13,7 @@ module ForemanTasks
         begin
           on_execution_plan_save(execution_plan_id, value)
         rescue => e
-          Foreman::Logging.exception("Error on on_execution_plan_save event", e, :logger => Foreman::Logging.logger('foreman-tasks/dynflow'))
+          Foreman::Logging.exception("Error on on_execution_plan_save event", e, :logger => 'foreman-tasks/dynflow')
         end
       end
     ensure
@@ -23,11 +23,22 @@ module ForemanTasks
     def on_execution_plan_save(execution_plan_id, data)
       # We can load the data unless the execution plan was properly planned and saved
       # including its steps
-      if data[:state] == :planning
-        task = ::ForemanTasks::Task::DynflowTask.new
+      case data[:state]
+      when :pending
+        ForemanTasks::Task::DynflowTask.new_for_execution_plan(execution_plan_id, data).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?
+        # TODO: Rework this
+        delayed_plan = ::Dynflow::DelayedPlan.new_from_hash(ForemanTasks.dynflow.world, delayed_plan)
+        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))
+      when :planning
+        task = ::ForemanTasks::Task::DynflowTask.find_by_external_id(execution_plan_id)
         task.update_from_dynflow(data)
         Lock.owner!(::User.current, task.id) if ::User.current
-      elsif data[:state] != :pending
+      else
         if task = ::ForemanTasks::Task::DynflowTask.find_by_external_id(execution_plan_id)
           unless task.state.to_s == data[:state].to_s
             task.update_from_dynflow(data)

data/lib/foreman_tasks/triggers.rb

@@ -21,5 +21,9 @@ module ForemanTasks
     def sync_task(action, *args, &block)
       foreman_tasks.sync_task(action, *args, &block)
     end
+
+    def delay(action, delay_options, *args)
+      foreman_tasks.delay(action, delay_options, *args)
+    end
   end
 end

data/lib/foreman_tasks/version.rb

@@ -1,3 +1,3 @@
 module ForemanTasks
-  VERSION = "0.7.3"
+  VERSION = "0.7.4"
 end

data/test/controllers/api/tasks_controller_test.rb

@@ -40,8 +40,8 @@ module ForemanTasks
           task.reload
           task.state.must_equal 'stopped'
           task.result.must_equal 'success'
-          task.main_action.output.must_equal({ "proxy_task_id" => "123",
-                                               "proxy_output"  => { "result" => "success" }})
+          task.main_action.output['proxy_task_id'].must_equal "123"
+          task.main_action.output['proxy_output'].must_equal({ 'result' => 'success' })
         end
       end
     end

data/test/unit/actions/proxy_action_test.rb

@@ -17,6 +17,7 @@ module ForemanTasks
           proxy_call = Support::DummyProxyAction.proxy.log[:trigger_task].first
           proxy_call.must_equal(["Proxy::DummyAction",
                                  { "foo" => "bar",
+                                   "connection_options" => { "retry_interval" => 15, "retry_count" => 4, "timeout" => 60 },
                                    "proxy_url" => "proxy.example.com",
                                    "callback" => { "task_id" => "123", "step_id" => @action.run_step_id }}])
         end
@@ -61,6 +62,23 @@ module ForemanTasks
         action = run_action(@action, ::Actions::ProxyAction::CallbackData.new('result' => 'success'))
         action.output[:proxy_output].must_equal({'result' => 'success'})
       end
+
+      it 'handles connection errors' do
+        action = create_and_plan_action(Support::DummyProxyAction, Support::DummyProxyAction.proxy, { :foo => 'bar' })
+        run_stubbed_action = lambda do |lambda_action|
+          run_action lambda_action do |block_action|
+            block_action.expects(:trigger_proxy_task).raises(Errno::ECONNREFUSED.new('Connection refused'))
+          end
+        end
+        action = run_stubbed_action.call action
+        action.state.must_equal :suspended
+        action.world.clock.pending_pings.length.must_equal 1
+        action.output[:metadata][:failed_proxy_tasks].length.must_equal 1
+        2.times { action.output[:metadata][:failed_proxy_tasks] << {} }
+        proc { action = run_stubbed_action.call action }.must_raise(Errno::ECONNREFUSED)
+        action.state.must_equal :error
+      end
+
     end
 
   end

data/test/unit/cleaner_test.rb

@@ -14,7 +14,7 @@ class TasksTest < ActiveSupport::TestCase
                          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::Task.where(id: tasks_to_keep).order(:id).map(&:id).must_equal tasks_to_keep.map(&:id).sort
 
       ForemanTasks.dynflow.world.persistence.
           find_execution_plans(filters: {'uuid' => tasks_to_delete.map(&:external_id)}).size.must_equal 0

data/test/unit/task_test.rb

@@ -41,12 +41,13 @@ class TasksTest < ActiveSupport::TestCase
     let(:inconsistent_task) { FactoryGirl.create(:dynflow_task, :inconsistent_dynflow_task) }
 
     it 'ensures the tasks marked as running are really running in Dynflow' do
+      running_task_count = ForemanTasks::Task::DynflowTask.running.count
       consistent_task.state.must_equal 'planned'
       inconsistent_task.state.must_equal 'running'
 
       fixed_count = ForemanTasks::Task::DynflowTask.consistency_check
 
-      fixed_count.must_equal 1
+      fixed_count.must_equal running_task_count + 1
       consistent_task.reload.state.must_equal 'planned'
       inconsistent_task.reload.state.must_equal 'planned'
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: foreman-tasks
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.7.4
 platform: ruby
 authors:
 - Ivan Nečas
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-13 00:00:00.000000000 Z
+date: 2015-09-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dynflow
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.8.3
+        version: 0.8.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.8.3
+        version: 0.8.6
 - !ruby/object:Gem::Dependency
   name: sequel
   requirement: !ruby/object:Gem::Requirement
@@ -105,6 +105,7 @@ files:
 - app/lib/actions/helpers/lock.rb
 - app/lib/actions/middleware/keep_current_user.rb
 - app/lib/actions/proxy_action.rb
+- app/lib/actions/serializers/active_record_serializer.rb
 - app/lib/proxy_api/foreman_dynflow/dynflow_proxy.rb
 - app/models/foreman_tasks/concerns/action_subject.rb
 - app/models/foreman_tasks/concerns/action_triggering.rb
@@ -115,6 +116,7 @@ files:
 - app/models/foreman_tasks/task/dynflow_task.rb
 - app/models/foreman_tasks/task/status_explicator.rb
 - app/models/foreman_tasks/task/summarizer.rb
+- app/models/foreman_tasks/task/task_cancelled_exception.rb
 - app/models/setting/foreman_tasks.rb
 - app/views/foreman_tasks/api/tasks/show.json.rabl
 - app/views/foreman_tasks/tasks/_details.html.erb
@@ -134,8 +136,10 @@ files:
 - db/migrate/20131209122644_create_foreman_tasks_locks.rb
 - db/migrate/20140324104010_remove_foreman_tasks_progress.rb
 - db/migrate/20140813215942_add_parent_task_id.rb
+- db/migrate/20150817102538_add_delay_attributes.rb
 - db/seeds.d/20-foreman_tasks_permissions.rb
 - db/seeds.d/60-dynflow_proxy_feature.rb
+- db/seeds.d/61-foreman_tasks_bookmarks.rb
 - deploy/foreman-tasks.init
 - deploy/foreman-tasks.service
 - deploy/foreman-tasks.sysconfig