foreman_remote_execution 4.5.6 → 5.0.0

data/db/migrate/20210816100932_rex_setting_category_to_dsl.rb

@@ -0,0 +1,5 @@
+class RexSettingCategoryToDsl < ActiveRecord::Migration[6.0]
+  def up
+    Setting.where(category: 'Setting::RemoteExecution').update_all(category: 'Setting')
+  end
+end

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

@@ -13,6 +13,20 @@ blueprints = [
       ],
     },
   },
+  {
+    group: N_('Jobs'),
+      name: 'rex_job_failed',
+      message: N_("A job '%{subject}' has failed"),
+      level: 'error',
+      actions:
+          {
+            links:
+                [
+                  path_method: :job_invocation_path,
+                    title: N_('Job Details'),
+                ],
+          },
+  },
 ]
 
 blueprints.each { |blueprint| UINotifications::Seed.new(blueprint).configure }

data/db/seeds.d/95-mail_notifications.rb

@@ -0,0 +1,24 @@
+N_('Remote execution job')
+
+notifications = [
+  {
+    :name               => 'remote_execution_job',
+    :description        => N_('A notification when a job finishes'),
+    :mailer             => 'RexJobMailer',
+    :method             => 'job_finished',
+    :subscription_type  => 'alert',
+  },
+]
+
+notifications.each do |notification|
+  if (mail = RexMailNotification.find_by(name: notification[:name]))
+    mail.attributes = notification
+    mail.save! if mail.changed?
+  else
+    created_notification = RexMailNotification.create(notification)
+    if created_notification.nil? || created_notification.errors.any?
+      raise ::Foreman::Exception.new(N_("Unable to create mail notification: %s"),
+        format_errors(created_notification))
+    end
+  end
+end

data/foreman_remote_execution.gemspec

@@ -16,8 +16,7 @@ Gem::Specification.new do |s|
                   'management functionality with remote management functionality.'
 
   s.files = `git ls-files`.split("\n").reject do |file|
-    file.start_with?('scripts', 'lib/foreman_remote_execution_core') ||
-      file == 'foreman_remote_execution_core.gemspec'
+    file.start_with?('scripts')
   end
 
   s.test_files =       `git ls-files test`.split("\n")
@@ -25,8 +24,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'deface'
   s.add_dependency 'dynflow', '>= 1.0.2', '< 2.0.0'
-  s.add_dependency 'foreman_remote_execution_core'
-  s.add_dependency 'foreman-tasks', '>= 4.1.0'
+  s.add_dependency 'foreman-tasks', '>= 5.1.0'
 
   s.add_development_dependency 'factory_bot_rails', '~> 4.8.0'
   s.add_development_dependency 'rdoc'

data/lib/foreman_remote_execution/engine.rb

@@ -19,10 +19,6 @@ module ForemanRemoteExecution
       end
     assets_to_precompile += %w(foreman_remote_execution/foreman_remote_execution.css)
 
-    initializer 'foreman_remote_execution.load_default_settings', :before => :load_config_initializers do
-      require_dependency File.expand_path('../../../app/models/setting/remote_execution.rb', __FILE__) if (Setting.table_exists? rescue(false))
-    end
-
     # Add any db migrations
     initializer 'foreman_remote_execution.load_app_instance_data' do |app|
       ForemanRemoteExecution::Engine.paths['db/migrate'].existent.each do |path|
@@ -51,7 +47,7 @@ module ForemanRemoteExecution
 
     initializer 'foreman_remote_execution.register_plugin', before: :finisher_hook do |_app|
       Foreman::Plugin.register :foreman_remote_execution do
-        requires_foreman '>= 2.2'
+        requires_foreman '>= 3.1'
         register_global_js_file 'global'
 
         apipie_documented_controllers ["#{ForemanRemoteExecution::Engine.root}/app/controllers/api/v2/*.rb"]
@@ -61,13 +57,114 @@ module ForemanRemoteExecution
         automatic_assets(false)
         precompile_assets(*assets_to_precompile)
 
+        # Add settings to a Remote Execution category
+        settings do
+          category :remote_execution, N_('Remote Execution') do
+            setting 'remote_execution_fallback_proxy',
+              type: :boolean,
+              description: N_('Search the host for any proxy with Remote Execution, useful when the host has no subnet or the subnet does not have an execution proxy'),
+              default: false,
+              full_name: N_('Fallback to Any Proxy')
+            setting 'remote_execution_global_proxy',
+              type: :boolean,
+              description: N_('Search for remote execution proxy outside of the proxies assigned to the host. The search will be limited to the host\'s organization and location.'),
+              default: true,
+              full_name: N_('Enable Global Proxy')
+            setting 'remote_execution_ssh_user',
+              type: :string,
+              description: N_('Default user to use for SSH.  You may override per host by setting a parameter called remote_execution_ssh_user.'),
+              default: 'root',
+              full_name: N_('SSH User')
+            setting 'remote_execution_effective_user',
+              type: :string,
+              description: N_('Default user to use for executing the script. If the user differs from the SSH user, su or sudo is used to switch the user.'),
+              default: 'root',
+              full_name: N_('Efffective User')
+            setting 'remote_execution_effective_user_method',
+              type: :string,
+              description: N_('What command should be used to switch to the effective user. One of %s') % SSHExecutionProvider::EFFECTIVE_USER_METHODS.inspect,
+              default: 'sudo',
+              full_name: N_('Effective User Method'),
+              collection: proc { Hash[SSHExecutionProvider::EFFECTIVE_USER_METHODS.map { |method| [method, method] }] }
+            setting 'remote_execution_effective_user_password',
+              type: :string,
+              description: N_('Effective user password'),
+              default: '',
+              full_name: N_('Effective user password'),
+              encrypted: true
+            setting 'remote_execution_sync_templates',
+              type: :boolean,
+              description: N_('Whether we should sync templates from disk when running db:seed.'),
+              default: true,
+              full_name: N_('Sync Job Templates')
+            setting 'remote_execution_ssh_port',
+              type: :integer,
+              description: N_('Port to use for SSH communication. Default port 22. You may override per host by setting a parameter called remote_execution_ssh_port.'),
+              default: 22,
+              full_name: N_('SSH Port')
+            setting 'remote_execution_connect_by_ip',
+              type: :boolean,
+              description: N_('Should the ip addresses on host interfaces be preferred over the fqdn? '\
+                              'It is useful when DNS not resolving the fqdns properly. You may override this per host by setting a parameter called remote_execution_connect_by_ip. '\
+                              'For dual-stacked hosts you should consider the remote_execution_connect_by_ip_prefer_ipv6 setting'),
+              default: false,
+              full_name: N_('Connect by IP')
+            setting 'remote_execution_connect_by_ip_prefer_ipv6',
+              type: :boolean,
+              description: N_('When connecting using ip address, should the IPv6 addresses be preferred? '\
+                              'If no IPv6 address is set, it falls back to IPv4 automatically. You may override this per host by setting a parameter called remote_execution_connect_by_ip_prefer_ipv6. '\
+                              'By default and for compatibility, IPv4 will be preferred over IPv6 by default'),
+              default: false,
+              full_name: N_('Prefer IPv6 over IPv4')
+            setting 'remote_execution_ssh_password',
+              type: :string,
+              description: N_('Default password to use for SSH. You may override per host by setting a parameter called remote_execution_ssh_password'),
+              default: nil,
+              full_name: N_('Default SSH password'),
+              encrypted: true
+            setting 'remote_execution_ssh_key_passphrase',
+              type: :string,
+              description: N_('Default key passphrase to use for SSH. You may override per host by setting a parameter called remote_execution_ssh_key_passphrase'),
+              default: nil,
+              full_name: N_('Default SSH key passphrase'),
+              encrypted: true
+            setting 'remote_execution_workers_pool_size',
+              type: :integer,
+              description: N_('Amount of workers in the pool to handle the execution of the remote execution jobs. Restart of the dynflowd/foreman-tasks service is required.'),
+              default: 5,
+              full_name: N_('Workers pool size')
+            setting 'remote_execution_cleanup_working_dirs',
+              type: :boolean,
+              description: N_('When enabled, working directories will be removed after task completion. You may override this per host by setting a parameter called remote_execution_cleanup_working_dirs.'),
+              default: true,
+              full_name: N_('Cleanup working directories')
+            setting 'remote_execution_cockpit_url',
+              type: :string,
+              description: N_('Where to find the Cockpit instance for the Web Console button.  By default, no button is shown.'),
+              default: nil,
+              full_name: N_('Cockpit URL')
+            setting 'remote_execution_form_job_template',
+              type: :string,
+              description: N_('Choose a job template that is pre-selected in job invocation form'),
+              default: 'Run Command - SSH Default',
+              full_name: N_('Form Job Template'),
+              collection: proc { Hash[JobTemplate.unscoped.map { |template| [template.name, template.name] }] }
+            setting 'remote_execution_job_invocation_report_template',
+              type: :string,
+              description: N_('Select a report template used for generating a report for a particular remote execution job'),
+              default: 'Jobs - Invocation report template',
+              full_name: N_('Job Invocation Report Template'),
+              collection: proc { ForemanRemoteExecution.job_invocation_report_templates_select }
+          end
+        end
+
         # Add permissions
         security_block :foreman_remote_execution do
           permission :view_job_templates, { :job_templates => [:index, :show, :revision, :auto_complete_search, :auto_complete_job_category, :preview, :export],
                                             :'api/v2/job_templates' => [:index, :show, :revision, :export],
                                             :'api/v2/template_inputs' => [:index, :show],
                                             :'api/v2/foreign_input_sets' => [:index, :show],
-                                            :ui_job_wizard => [:categories, :template]}, :resource_type => 'JobTemplate'
+                                            :ui_job_wizard => [:categories, :template, :resources]}, :resource_type => 'JobTemplate'
           permission :create_job_templates, { :job_templates => [:new, :create, :clone_template, :import],
                                               :'api/v2/job_templates' => [:create, :clone, :import] }, :resource_type => 'JobTemplate'
           permission :edit_job_templates, { :job_templates => [:edit, :update],
@@ -86,6 +183,7 @@ module ForemanRemoteExecution
           permission :view_template_invocations, { :template_invocations => [:show],
                                                    'api/v2/template_invocations' => [:template_invocations] }, :resource_type => 'TemplateInvocation'
           permission :create_template_invocations, {}, :resource_type => 'TemplateInvocation'
+          permission :execute_jobs_on_infrastructure_hosts, {}, :resource_type => 'JobInvocation'
           permission :cancel_job_invocations, { :job_invocations => [:cancel], 'api/v2/job_invocations' => [:cancel] }, :resource_type => 'JobInvocation'
           # this permissions grants user to get auto completion hints when setting up filters
           permission :filter_autocompletion_for_template_invocation, { :template_invocations => [ :auto_complete_search, :index ] },
@@ -146,12 +244,18 @@ module ForemanRemoteExecution
         register_custom_status HostStatus::ExecutionStatus
         # add dashboard widget
         # widget 'foreman_remote_execution_widget', name: N_('Foreman plugin template widget'), sizex: 4, sizey: 1
+        widget 'dashboard/latest-jobs', :name => N_('Latest Jobs'), :sizex => 6, :sizey => 1
 
         parameter_filter Subnet, :remote_execution_proxies, :remote_execution_proxy_ids => []
         parameter_filter Nic::Interface do |ctx|
           ctx.permit :execution
         end
 
+        register_graphql_query_field :job_invocations, '::Types::JobInvocation', :collection_field
+        register_graphql_query_field :job_invocation, '::Types::JobInvocation', :record_field
+
+        register_graphql_mutation_field :create_job_invocation, ::Mutations::JobInvocations::Create
+
         extend_template_helpers ForemanRemoteExecution::RendererMethods
 
         extend_rabl_template 'api/v2/smart_proxies/main', 'api/v2/smart_proxies/pubkey'
@@ -237,6 +341,10 @@ module ForemanRemoteExecution
     end
   end
 
+  def self.job_invocation_report_templates_select
+    Hash[ReportTemplate.unscoped.joins(:template_inputs).where(template_inputs: TemplateInput.where(name: 'job_id')).map { |template| [template.name, template.name] }]
+  end
+
   def self.register_rex_feature
     RemoteExecutionFeature.register(
       :puppet_run_host,

data/lib/foreman_remote_execution/version.rb

@@ -1,3 +1,3 @@
 module ForemanRemoteExecution
-  VERSION = '4.5.6'.freeze
+  VERSION = '5.0.0'.freeze
 end

data/package.json

@@ -21,11 +21,11 @@
   },
   "devDependencies": {
     "@babel/core": "^7.7.0",
-    "@theforeman/builder": "^4.14.0",
-    "@theforeman/eslint-plugin-foreman": "^4.14.0",
-    "@theforeman/stories": "^4.14.0",
-    "@theforeman/test": "^4.14.0",
-    "@theforeman/vendor-dev": "^4.14.0",
+    "@theforeman/builder": "^8.16.0",
+    "@theforeman/eslint-plugin-foreman": "^8.16.0",
+    "@theforeman/stories": "^8.16.0",
+    "@theforeman/test": "^8.16.0",
+    "@theforeman/vendor-dev": "^8.16.0",
     "babel-eslint": "^10.0.0",
     "eslint": "^6.8.0",
     "prettier": "^1.19.1",
@@ -33,6 +33,6 @@
     "redux-mock-store": "^1.2.2"
   },
   "peerDependencies": {
-    "@theforeman/vendor": "^8.3.0"
+    "@theforeman/vendor": "^8.16.0"
   }
 }

data/test/functional/api/v2/job_invocations_controller_test.rb

@@ -90,6 +90,16 @@ module Api
           assert_response :success
         end
 
+        test 'should create with a scheduled recurrence' do
+          @attrs[:scheduling] = { start_at: (Time.now + 1.hour) }
+          @attrs[:recurrence] = { cron_line: '5 * * * *' }
+          post :create, params: { job_invocation: @attrs }
+          invocation = ActiveSupport::JSON.decode(@response.body)
+          assert_equal 'recurring', invocation['mode']
+          assert invocation['start_at']
+          assert_response :success
+        end
+
         context 'with_feature' do
           setup do
             @feature = FactoryBot.create(:remote_execution_feature,
@@ -181,6 +191,11 @@ module Api
                                  host_id: FactoryBot.create(:host).id }
           assert_response :missing
         end
+
+        test 'should not break when taxonomy parameters are provided' do
+          get :output, params: { :job_invocation_id => @invocation.id, :host_id => host.id, :organization_id => host.organization_id, :location_id => host.location_id }
+          assert_response :success
+        end
       end
 
       describe '#outputs' do
@@ -233,6 +248,11 @@ module Api
           assert_response :success
         end
 
+        test 'should not break when taxonomy parameters are provided' do
+          get :raw_output, params: { :job_invocation_id => @invocation.id, :host_id => host.id, :organization_id => host.organization_id, :location_id => host.location_id }
+          assert_response :success
+        end
+
         test 'should provide raw output for delayed task' do
           start_time = Time.now
           JobInvocation.any_instance

data/test/functional/cockpit_controller_test.rb

@@ -2,7 +2,6 @@ require 'test_plugin_helper'
 
 class CockpitControllerTest < ActionController::TestCase
   def setup
-    Setting::RemoteExecution.load_defaults
     as_admin do
       @host = FactoryBot.create(:host)
     end

data/test/graphql/mutations/job_invocations/create.rb

@@ -0,0 +1,58 @@
+require 'test_plugin_helper'
+
+module Mutations
+  module JobInvocations
+    class CreateMutationTest < ActiveSupport::TestCase
+      let(:host) { FactoryBot.create(:host) }
+      let(:job_template) { FactoryBot.create(:job_template, :with_input) }
+      let(:cron_line) { '5 * * * *' }
+      let(:purpose) { 'test' }
+      let(:variables) do
+        {
+          jobInvocation: {
+            hostIds: [host.id],
+            jobTemplateId: job_template.id,
+            targetingType: 'static_query',
+            inputs: { job_template.template_inputs.first.name => "bar" },
+            recurrence: {
+              cronLine: cron_line,
+              purpose:  purpose,
+            },
+          },
+        }
+      end
+
+      let(:query) do
+        <<-GRAPHQL
+          mutation CreateJobInvocation($jobInvocation: JobInvocationInput!) {
+              createJobInvocation(input: { jobInvocation: $jobInvocation }) {
+                jobInvocation {
+                  id
+                  description
+                  recurringLogic {
+                    cronLine
+                    purpose
+                  }
+                }
+              }
+            }
+        GRAPHQL
+      end
+
+      context 'with admin user' do
+        let(:user) { FactoryBot.create(:user, :admin) }
+        let(:context) { { current_user: user } }
+
+        test 'create a job invocation' do
+          assert_difference('JobInvocation.count', +1) do
+            result = ForemanGraphqlSchema.execute(query, variables: variables, context: context)
+            assert_empty result['errors']
+            assert_empty result['data']['createJobInvocation']['jobInvocation']['errors']
+            assert_equal cron_line, result['data']['createJobInvocation']['jobInvocation']['recurringLogic']['cronLine']
+            assert_equal purpose, result['data']['createJobInvocation']['jobInvocation']['recurringLogic']['purpose']
+          end
+        end
+      end
+    end
+  end
+end

data/test/graphql/queries/job_invocation_query_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+module Queries
+  class JobInvocationQueryTest < GraphQLQueryTestCase
+    let(:query) do
+      <<-GRAPHQL
+      query (
+        $id: String!
+      ) {
+        jobInvocation(id: $id) {
+          id
+          jobCategory
+        }
+      }
+      GRAPHQL
+    end
+
+    let(:job_invocation) { FactoryBot.create(:job_invocation) }
+
+    let(:global_id) { Foreman::GlobalId.for(job_invocation) }
+    let(:variables) { { id: global_id } }
+    let(:data) { result['data']['jobInvocation'] }
+
+    test 'fetching job invocation attributes' do
+      assert_empty result['errors']
+
+      assert_equal global_id, data['id']
+      assert_equal job_invocation.job_category, data['jobCategory']
+    end
+  end
+end

data/test/graphql/queries/job_invocations_query_test.rb

@@ -0,0 +1,35 @@
+require 'test_plugin_helper'
+
+module Queries
+  class JobInvocationsQueryTest < GraphQLQueryTestCase
+    let(:query) do
+      <<-GRAPHQL
+      query {
+        jobInvocations {
+          totalCount
+          nodes {
+            id
+            jobCategory
+          }
+        }
+      }
+      GRAPHQL
+    end
+
+    let(:data) { result['data']['jobInvocations'] }
+
+    setup do
+      FactoryBot.create_list(:job_invocation, 2)
+    end
+
+    test 'should fetch job invocations' do
+      assert_empty result['errors']
+
+      expected_count = JobInvocation.count
+
+      assert_not_equal 0, expected_count
+      assert_equal expected_count, data['totalCount']
+      assert_equal expected_count, data['nodes'].count
+    end
+  end
+end

data/test/helpers/remote_execution_helper_test.rb

@@ -26,7 +26,6 @@ class RemoteExecutionHelperTest < ActionView::TestCase
 
   describe 'test correct setting' do
     it 'should found correct template from setting' do
-      Setting::RemoteExecution.load_defaults
       template_name = 'Job Invocation Report Template'
       setting_key = 'remote_execution_job_invocation_report_template'
       template = FactoryBot.create(:report_template, name: template_name)

data/test/unit/actions/run_host_job_test.rb

@@ -36,6 +36,27 @@ module ForemanRemoteExecution
       end
     end
 
+    describe '#verify_permission' do
+      let(:job_invocation) { FactoryBot.create(:job_invocation, :with_task) }
+      let(:template_invocation) { job_invocation.template_invocations.first }
+
+      before { job_invocation }
+
+      it 'raises an exception when run against an infrastructure host' do
+        template_invocation.host = FactoryBot.create(:host, :with_infrastructure_facet)
+
+        setup_user('view', 'hosts')
+        setup_user('view', 'job_templates')
+        setup_user('create', 'template_invocations')
+
+        action = Actions::RemoteExecution::RunHostJob.allocate
+        exception = assert_raises do
+          action.send(:verify_permissions, template_invocation.host, template_invocation)
+        end
+        _(exception.message).must_include "infrastructure host #{template_invocation.host.name}"
+      end
+    end
+
     describe '#finalize' do
       let(:host) { FactoryBot.create(:host, :with_execution) }
 

data/test/unit/actions/run_hosts_job_test.rb

@@ -5,6 +5,16 @@ module ForemanRemoteExecution
   class RunHostsJobTest < ActiveSupport::TestCase
     include Dynflow::Testing
 
+    # Adding run_step_id wich is needed in RunHostsJob as a quick fix
+    # it will be added to dynflow in the future see https://github.com/Dynflow/dynflow/pull/391
+    # rubocop:disable Style/ClassAndModuleChildren
+    class Dynflow::Testing::DummyPlannedAction
+      def run_step_id
+        Dynflow::Testing.get_id
+      end
+    end
+    # rubocop:enable Style/ClassAndModuleChildren
+
     let(:host) { FactoryBot.create(:host, :with_execution) }
     let(:proxy) { host.remote_execution_proxies('SSH')[:subnet].first }
     let(:targeting) { FactoryBot.create(:targeting, :search_query => "name = #{host.name}", :user => User.current) }
@@ -94,6 +104,22 @@ module ForemanRemoteExecution
       planned # To make the expectations happy
     end
 
+    describe '#proxy_batch_size' do
+      it 'defaults to Setting[foreman_tasks_proxy_batch_size]' do
+        Setting.expects(:[]).with('foreman_tasks_proxy_batch_size').returns(14)
+        planned
+        _(planned.proxy_batch_size).must_equal 14
+      end
+
+      it 'gets the provider value' do
+        provider = mock('provider')
+        provider.expects(:proxy_batch_size).returns(15)
+        JobTemplate.any_instance.expects(:provider).returns(provider)
+
+        _(planned.proxy_batch_size).must_equal 15
+      end
+    end
+
     describe 'concurrency control' do
       let(:level) { 5 }
       let(:span) { 60 }
@@ -127,10 +153,79 @@ module ForemanRemoteExecution
     end
 
     describe 'notifications' do
-      it 'creates notification on sucess run' do
-        FactoryBot.create(:notification_blueprint, :name => 'rex_job_succeeded')
-        assert_difference 'NotificationRecipient.where(:user_id => targeting.user.id).count' do
-          finalize_action planned
+      it 'creates drawer notification on succeess' do
+        blueprint = planned.job_invocation.build_notification
+        blueprint.expects(:deliver!)
+        planned.job_invocation.expects(:build_notification).returns(blueprint)
+        planned.notify_on_success(nil)
+      end
+
+      it 'creates drawer notification on failure' do
+        blueprint = planned.job_invocation.build_notification
+        blueprint.expects(:deliver!)
+        planned.job_invocation.expects(:build_notification).returns(blueprint)
+        planned.notify_on_failure(nil)
+      end
+
+      describe 'ignoring drawer notification' do
+        before do
+          blueprint = planned.job_invocation.build_notification
+          blueprint.expects(:deliver!)
+          planned.job_invocation.expects(:build_notification).returns(blueprint)
+        end
+
+        let(:mail) do
+          object = mock
+          object.stubs(:deliver_now)
+          object
+        end
+
+        describe 'for user subscribed to all' do
+          before do
+            planned.expects(:mail_notification_preference).returns(UserMailNotification.new(:interval => RexMailNotification::ALL_JOBS))
+          end
+
+          it 'sends the mail notification on success' do
+            RexJobMailer.expects(:job_finished).returns(mail)
+            planned.notify_on_success(nil)
+          end
+
+          it 'sends the mail notification on failure' do
+            RexJobMailer.expects(:job_finished).returns(mail)
+            planned.notify_on_failure(nil)
+          end
+        end
+
+        describe 'for user subscribed to failures' do
+          before do
+            planned.expects(:mail_notification_preference).returns(UserMailNotification.new(:interval => RexMailNotification::FAILED_JOBS))
+          end
+
+          it 'it does not send the mail notification on success' do
+            RexJobMailer.expects(:job_finished).never
+            planned.notify_on_success(nil)
+          end
+
+          it 'sends the mail notification on failure' do
+            RexJobMailer.expects(:job_finished).returns(mail)
+            planned.notify_on_failure(nil)
+          end
+        end
+
+        describe 'for user subscribed to successful jobs' do
+          before do
+            planned.expects(:mail_notification_preference).returns(UserMailNotification.new(:interval => RexMailNotification::SUCCEEDED_JOBS))
+          end
+
+          it 'sends the mail notification on success' do
+            RexJobMailer.expects(:job_finished).returns(mail)
+            planned.notify_on_success(nil)
+          end
+
+          it 'does not send the mail notification on failure' do
+            RexJobMailer.expects(:job_finished).never
+            planned.notify_on_failure(nil)
+          end
         end
       end
     end