foreman_remote_execution 4.5.5 → 4.8.0

data/app/views/template_invocations/show.html.erb

@@ -18,7 +18,8 @@ end
 
 <div id="title_action">
   <div class="btn-toolbar pull-right">
-    <%= link_to(_('Back to Job'), job_invocation_path(@template_invocation.job_invocation), :class => 'btn btn-default') %>
+    <%= button_group(link_to(_('Back to Job'), job_invocation_path(@template_invocation.job_invocation), :class => 'btn btn-default'),
+                    (link_to(_('Rerun'), rerun_job_invocation_path(@template_invocation.job_invocation, :host_ids => [ @host.id ]), :class => 'btn btn-default') if authorized_for(:permission => :create_job_invocations))) %>
     <%= button_group(link_to_function(_('Toggle command'), '$("div.preview").toggle()', :class => 'btn btn-default'),
                      link_to_function(_('Toggle STDERR'), '$("div.line.stderr").toggle()', :class => 'btn btn-default'),
                      link_to_function(_('Toggle STDOUT'), '$("div.line.stdout").toggle()', :class => 'btn btn-default'),

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

@@ -146,12 +146,16 @@ 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
+
         extend_template_helpers ForemanRemoteExecution::RendererMethods
 
         extend_rabl_template 'api/v2/smart_proxies/main', 'api/v2/smart_proxies/pubkey'

data/lib/foreman_remote_execution/version.rb

@@ -1,3 +1,3 @@
 module ForemanRemoteExecution
-  VERSION = '4.5.5'.freeze
+  VERSION = '4.8.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.10.0",
+    "@theforeman/eslint-plugin-foreman": "^8.10.0",
+    "@theforeman/stories": "^8.10.0",
+    "@theforeman/test": "^8.10.0",
+    "@theforeman/vendor-dev": "^8.10.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.10.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,

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/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

data/test/unit/concerns/host_extensions_test.rb

@@ -131,23 +131,23 @@ class ForemanRemoteExecutionHostExtensionsTest < ActiveSupport::TestCase
     end
 
     context 'fallback strategy' do
-      let(:host) { FactoryBot.build(:host, :with_puppet) }
+      let(:host) { FactoryBot.build(:host, :with_tftp_subnet) }
 
       context 'enabled' do
         before do
           Setting[:remote_execution_fallback_proxy] = true
-          host.puppet_proxy.features << FactoryBot.create(:feature, :ssh)
+          host.subnet.tftp.features << FactoryBot.create(:feature, :ssh)
         end
 
         it 'returns a fallback proxy' do
-          host.remote_execution_proxies(provider)[:fallback].must_include host.puppet_proxy
+          host.remote_execution_proxies(provider)[:fallback].must_include host.subnet.tftp
         end
       end
 
       context 'disabled' do
         before do
           Setting[:remote_execution_fallback_proxy] = false
-          host.puppet_proxy.features << FactoryBot.create(:feature, :ssh)
+          host.subnet.tftp.features << FactoryBot.create(:feature, :ssh)
         end
 
         it 'returns no proxy' do

data/test/unit/input_template_renderer_test.rb

@@ -446,8 +446,7 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
           before { User.current = FactoryBot.build(:user, :admin) }
           after { User.current = nil }
 
-          let(:environment) { FactoryBot.create(:environment) }
-          before { renderer.host = FactoryBot.create(:host, :environment => environment) }
+          before { renderer.host = FactoryBot.create(:host) }
 
           describe 'rendering' do
             it 'can\'t render the content without host since we don\'t have variable value in classification' do
@@ -497,91 +496,4 @@ class InputTemplateRendererTest < ActiveSupport::TestCase
       end
     end
   end
-
-  context 'renderer for template with puppet parameter input used' do
-    let(:template) { FactoryBot.build(:job_template, :template => 'echo "This is WebServer with nginx <%= input("nginx_version") -%>" > /etc/motd') }
-    let(:renderer) { InputTemplateRenderer.new(template) }
-
-    context 'with matching input defined' do
-      before do
-        renderer.template.template_inputs<< FactoryBot.build(:template_input,
-          :name => 'nginx_version',
-          :input_type => 'puppet_parameter',
-          :puppet_parameter_name => 'version',
-          :puppet_class_name => 'nginx')
-      end
-      let(:result) { renderer.render }
-
-      describe 'rendering' do
-        it 'can\'t render the content without host since we don\'t have host so no classification' do
-          assert_not result
-        end
-
-        it 'registers an error' do
-          result # let is lazy
-          _(renderer.error_message).wont_be_nil
-          _(renderer.error_message).wont_be_empty
-        end
-
-        context 'with host specified' do
-          let(:environment) { FactoryBot.create(:environment) }
-          before { renderer.host = FactoryBot.create(:host, :environment => environment) }
-
-          describe 'rendering' do
-            it 'can\'t render the content without host since we don\'t have puppet parameter in classification' do
-              assert_not result
-            end
-
-            it 'registers an error' do
-              result # let is lazy
-              _(renderer.error_message).wont_be_nil
-              _(renderer.error_message).wont_be_empty
-            end
-          end
-
-          describe 'preview' do
-            it 'should render preview' do
-              _(renderer.preview).must_equal 'echo "This is WebServer with nginx $PUPPET_PARAMETER_INPUT[nginx_version]" > /etc/motd'
-            end
-          end
-
-          context 'with existing puppet parameter with matching override' do
-            let(:puppet_class) do
-              puppetclass = FactoryBot.create(:puppetclass, :environments => [environment], :name => 'nginx')
-              puppetclass.update_attribute(:hosts, [renderer.host])
-              puppetclass
-            end
-            let(:lookup_key) do
-              FactoryBot.create(:puppetclass_lookup_key, :as_smart_class_param,
-                :key => 'version',
-                :puppetclass => puppet_class,
-                :path => 'fqdn',
-                :override => true,
-                :overrides => {"fqdn=#{renderer.host.fqdn}" => '1.4.7'})
-            end
-
-            describe 'rendering' do
-              it 'renders the value from puppet parameter' do
-                lookup_key
-                _(result).must_equal 'echo "This is WebServer with nginx 1.4.7" > /etc/motd'
-              end
-            end
-
-            describe 'preview' do
-              it 'should render preview' do
-                lookup_key
-                _(renderer.preview).must_equal 'echo "This is WebServer with nginx 1.4.7" > /etc/motd'
-              end
-            end
-          end
-        end
-
-        describe 'preview' do
-          it 'should render preview' do
-            _(renderer.preview).must_equal 'echo "This is WebServer with nginx $PUPPET_PARAMETER_INPUT[nginx_version]" > /etc/motd'
-          end
-        end
-      end
-    end
-  end
 end