foreman_remote_execution 14.1.0 → 14.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0b4dd4f17f6d245a627cf09e014206e0392de844821d35cef065a9af835b399
-  data.tar.gz: 4b60be78f70b3791c02f57c08060cc771aeb33f5cfd985335f26f25f1db030c7
+  metadata.gz: 237cac074270280b4bab25b144716d3ddb515fe4d9159e3e86badfb2530dc667
+  data.tar.gz: bcb74259222068245df6df8af2ff6a0d7e7cd58516d4654e2b3a3635f09176b4
 SHA512:
-  metadata.gz: 9f87b034acd048bf1a5fe968a418a3b03cd76880342e9aeec52303b19e8bfb097013f877c9a43a34ffc23cb8b5cc9614c30dba16188c8dbfa101fc0c94d18d52
-  data.tar.gz: a90d5d70bc9bf9a0480202699c62d48f7e78ad1f518d6421fbf478c866a29fe265a3a7a7a9ac9e4a9a15177212877ea3dbb2101696384faef7fc7eb9a0c27650
+  metadata.gz: 4a68f13a3060ef118f1d44f262cb4c6d072acb1abe88cdd0ef6bbcd03dcca716e7468aaa0526c7697ce99729b0cdabe7bbfe1e3ac2b16f282b87d7316cf984ca
+  data.tar.gz: ce09bfa5f114f7cf0c43b4b880557b7394bff115e8d66750cea8bd5c861d8c89a06b0fa243a14ba57d899227bab655565a9b15c33fbcb4d21d6bcd7a02497b4e

data/app/models/job_template.rb

@@ -64,6 +64,7 @@ class JobTemplate < ::Template
     # will overwrite (sync) an existing template if options[:update] is true.
     def import_raw(contents, options = {})
       metadata = Template.parse_metadata(contents)
+      return unless SeedHelper.test_template_requirements(metadata['name'], metadata['require'] || [])
       import_parsed(metadata['name'], contents, metadata, options)
     end
 

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

@@ -9,7 +9,7 @@ var target = $("div.terminal div.printable");
   target.html(lines);
 <% end %>
 
-<%= render :partial => 'refresh.js' %>
+<%= render partial: 'refresh', formats: :js %>
 
 if (scrolledToBottom) {
   $("html, body").animate({ scrollTop: $(document).height() }, "slow");

data/db/migrate/20240312133027_extend_template_invocation_events.rb

@@ -6,6 +6,15 @@ class ExtendTemplateInvocationEvents < ActiveRecord::Migration[6.1]
 
     TemplateInvocationEvent.update_all("external_id = CASE WHEN event_type = 'exit' THEN 'exit' ELSE sequence_id::varchar END")
 
+    # For each template invocation return the lowest id of its exit event, if there is more than 1 exit event
+    scope = TemplateInvocationEvent.select("MIN(id) as id")
+                                   .where(external_id: 'exit')
+                                   .group(:template_invocation_id)
+                                   .having("count(*) > 1")
+
+    # Make sure there is at most one exit event per template invocation
+    TemplateInvocationEvent.where(:id => scope.limit(BATCH_SIZE)).delete_all while scope.any?
+
     remove_index :template_invocation_events, name: :unique_template_invocation_events_index
     remove_column :template_invocation_events, :sequence_id
 

data/lib/foreman_remote_execution/engine.rb

@@ -176,7 +176,7 @@ module ForemanRemoteExecution
             permission :create_job_invocations, { :job_invocations => [:new, :create, :legacy_create, :refresh, :rerun, :preview_hosts],
                                                   'api/v2/job_invocations' => [:create, :rerun] }, :resource_type => 'JobInvocation'
             permission :view_job_invocations, { :job_invocations => [:index, :chart, :show, :auto_complete_search, :preview_job_invocations_per_host], :template_invocations => [:show],
-                                                'api/v2/job_invocations' => [:index, :show, :output, :raw_output, :outputs] }, :resource_type => 'JobInvocation'
+                                                'api/v2/job_invocations' => [:index, :show, :output, :raw_output, :outputs, :hosts] }, :resource_type => 'JobInvocation'
             permission :view_template_invocations, { :template_invocations => [:show],
                                                     'api/v2/template_invocations' => [:template_invocations], :ui_job_wizard => [:job_invocation] }, :resource_type => 'TemplateInvocation'
             permission :create_template_invocations, {}, :resource_type => 'TemplateInvocation'

data/lib/foreman_remote_execution/version.rb

@@ -1,3 +1,3 @@
 module ForemanRemoteExecution
-  VERSION = '14.1.0'.freeze
+  VERSION = '14.1.2'.freeze
 end

data/lib/tasks/foreman_remote_execution_tasks.rake

@@ -17,6 +17,9 @@ namespace :test do
     t.pattern = "#{test_dir}/**/*_test.rb"
     t.verbose = true
     t.warning = false
+    t.test_files = [
+      Rails.root.join('test/unit/foreman/access_permissions_test.rb'),
+    ]
   end
 end
 

data/test/benchmark/run_hosts_job_benchmark.rb

@@ -0,0 +1,70 @@
+require 'benchmark/benchmark_helper'
+require 'dynflow/testing'
+
+# Add plugin to FactoryBot's paths
+FactoryBot.definition_file_paths << File.expand_path('../../factories', __FILE__)
+FactoryBot.definition_file_paths << "#{ForemanTasks::Engine.root}/test/factories"
+FactoryBot.reload
+
+module Actions
+  module RemoteExecution
+    class RunHostsJob < Actions::ActionWithSubPlans
+      # stub function that calls other actions.
+      def trigger(*args)
+        nil
+      end
+    end
+  end
+end
+
+module Support
+  class DummyDynflowAction < Dynflow::Action
+  end
+end
+
+def generate_hosts(total)
+  FactoryBot.create_list(:host, total, :comment => "benchmark-#{Foreman.uuid}")
+end
+
+Rails.logger.level = Logger::ERROR
+
+class ActionTester
+  include Dynflow::Testing::Factories
+
+  def initialize(task)
+    @task = task
+  end
+
+  def run_action(*args)
+    action = create_action(Actions::RemoteExecution::RunHostsJob)
+    @task.update(:external_id => action.execution_plan_id)
+    plan_action(action, *args)
+  end
+end
+
+puts 'generating admin user'
+admin = FactoryBot.build(:user, :admin)
+admin.save(:validate => false)
+User.current = admin
+targeting = FactoryBot.create(:targeting, :search_query => "comment = benchmark-#{Foreman.uuid}", :user => User.current)
+template_invocation = FactoryBot.build(:template_invocation, :job_invocation => nil)
+job_invocation = FactoryBot.build(:job_invocation, :targeting => targeting, :pattern_template_invocations => [template_invocation]).tap do |invocation|
+  invocation.targeting = targeting
+  invocation.save
+end
+
+task = FactoryBot.create(:dynflow_task, :external_id => '1')
+tester = ActionTester.new(task)
+
+puts 'generating hosts'
+generate_hosts(1000)
+puts 'starting benchmarking'
+foreman_benchmark do
+  Benchmark.ips do |x|
+    x.config(:time => 10, :warmup => 0)
+
+    x.report('rex-run-hosts-job') do
+      tester.run_action(job_invocation)
+    end
+  end
+end

data/test/benchmark/targeting_benchmark.rb

@@ -0,0 +1,31 @@
+require 'benchmark/benchmark_helper'
+require 'dynflow/testing'
+
+# Add plugin to FactoryBot's paths
+FactoryBot.definition_file_paths << File.expand_path('../../factories', __FILE__)
+FactoryBot.reload
+
+def generate_hosts(total)
+  FactoryBot.create_list(:host, total, :comment => "benchmark-#{Foreman.uuid}")
+end
+
+Rails.logger.level = Logger::ERROR
+
+puts 'generating hosts'
+generate_hosts(1000)
+puts 'generating admin user'
+admin = FactoryBot.build(:user, :admin)
+admin.save(:validate => false)
+User.current = admin
+
+puts 'starting benchmarking'
+foreman_benchmark do
+  Benchmark.ips do |x|
+    x.config(:time => 10, :warmup => 0)
+
+    x.report('rex-targeting-resolve-hosts') do
+      targeting = FactoryBot.create(:targeting, :search_query => "comment = benchmark-#{Foreman.uuid}", :user => User.current)
+      targeting.resolve_hosts!
+    end
+  end
+end

data/test/factories/foreman_remote_execution_factories.rb

@@ -0,0 +1,147 @@
+FactoryBot.define do
+  factory :job_template do
+    sequence(:name) { |n| "Job template #{n}" }
+    sequence(:job_category) { |n| "Job name #{n}" }
+    template { 'id' }
+    provider_type { 'SSH' }
+    organizations { [Organization.find_by(name: 'Organization 1')] }
+    locations { [Location.find_by(name: 'Location 1')] }
+
+    trait :with_input do
+      after(:build) do |template, evaluator|
+        template.template_inputs << FactoryBot.build(:template_input)
+      end
+    end
+
+    trait :with_description_format do
+      description_format { 'Factory-built %{job_category}' }
+    end
+
+    trait :with_feature do
+      remote_execution_feature
+    end
+  end
+
+  factory :foreign_input_set
+
+  factory :targeting do
+    search_query { 'name = foo' }
+    targeting_type { 'static_query' }
+    user
+
+    trait :with_randomized_ordering do
+      randomized_ordering { true }
+    end
+  end
+
+  factory :job_invocation do |f|
+    targeting
+    f.sequence(:job_category) { |n| "Job name #{n}" }
+    f.description_format { "%{job_category}" }
+    trait :with_template do
+      after(:build) do |invocation, evaluator|
+        invocation.pattern_template_invocations << FactoryBot.build(:template_invocation)
+      end
+    end
+
+    trait :with_failed_task do
+      after(:build) do |invocation, _evaluator|
+        invocation.template_invocations << FactoryBot.build(:template_invocation, :with_failed_task, :with_host)
+        invocation.task = FactoryBot.build(:some_task)
+      end
+    end
+
+    trait :with_task do
+      after(:build) do |invocation, _evaluator|
+        invocation.template_invocations << FactoryBot.build(:template_invocation, :with_task, :with_host)
+        invocation.task = FactoryBot.build(:some_task)
+      end
+    end
+
+    trait :with_unplanned_host do
+      after(:build) do |invocation, _evaluator|
+        invocation.targeting.hosts << FactoryBot.build(:host)
+      end
+    end
+  end
+
+  factory :remote_execution_provider do |f|
+    f.sequence(:name) { |n| "Provider #{n}" }
+  end
+
+  factory :template_invocation do
+    job_invocation
+    association :template, :factory => :job_template
+
+    trait :with_task do
+      after(:build) do |template, _evaluator|
+        template.run_host_job_task = FactoryBot.build(:some_task)
+      end
+    end
+
+    trait :with_failed_task do
+      after(:build) do |template, _evaluator|
+        template.run_host_job_task = FactoryBot.build(:some_task, :result => 'error')
+      end
+    end
+
+    trait :with_host do
+      after(:build) do |template, _evaluator|
+        template.host = FactoryBot.build(:host)
+      end
+    end
+  end
+
+  factory :template_invocation_input_value do |f|
+    f.sequence(:value) { |n| "Input Value #{n}" }
+  end
+
+  factory :remote_execution_feature do |f|
+    f.sequence(:label) { |n| "remote_execution_feature_#{n}" }
+    f.sequence(:name) { |n| "Remote Execution Feature #{n}" }
+  end
+end
+
+FactoryBot.modify do
+  factory :feature do
+    trait :ssh do
+      name { 'SSH' }
+    end
+  end
+
+  factory :smart_proxy do
+    trait :ssh do
+      features { [FactoryBot.create(:feature, :ssh)] }
+      pubkey { 'ssh-rsa AAAAB3N...' }
+    end
+  end
+
+  factory :subnet do
+    trait :execution do
+      remote_execution_proxies { [FactoryBot.build(:smart_proxy, :ssh)] }
+    end
+  end
+
+  factory :host do
+    trait :with_execution do
+      managed
+      domain
+      subnet do
+        overrides = {
+          :remote_execution_proxies => [FactoryBot.create(:smart_proxy, :ssh)],
+        }
+
+        overrides[:locations] = [location] unless location.nil?
+        overrides[:organizations] = [organization] unless organization.nil?
+
+        FactoryBot.create(
+          :subnet_ipv4,
+          overrides
+        )
+      end
+      interfaces do
+        [FactoryBot.build(:nic_primary_and_provision, :ip => subnet.network.sub(/0\Z/, '1'), :execution => true)]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+require 'test_plugin_helper'
+
+module Api
+  module V2
+    class ForeignInputSetsControllerTest < ActionController::TestCase
+      setup do
+        @template = FactoryBot.create(:job_template)
+        @foreign_template = FactoryBot.create(:job_template, :with_input)
+        @new_foreign_template = FactoryBot.create(:job_template, :with_input)
+        @input_set = @template.foreign_input_sets.create(:target_template_id => @foreign_template.id)
+      end
+
+      test 'should get index' do
+        get :index, params: { :template_id => @template.id }
+        input_sets = ActiveSupport::JSON.decode(@response.body)
+        assert_not input_sets.empty?, 'Should respond with input sets'
+        assert_response :success
+      end
+
+      test 'should get input set detail' do
+        get :show, params: { :template_id => @template.to_param, :id => @input_set.to_param }
+        assert_response :success
+        input_set = ActiveSupport::JSON.decode(@response.body)
+        assert_not input_set.empty?
+        assert_equal input_set['target_template_name'], @foreign_template.name
+      end
+
+      test 'should create valid' do
+        valid_attrs = { :target_template_id => @new_foreign_template.id }
+        post :create, params: { :foreign_input_set => valid_attrs, :template_id => @template.to_param }
+        input_set = ActiveSupport::JSON.decode(@response.body)
+        assert_equal input_set['target_template_name'], @new_foreign_template.name
+        assert_response :success
+      end
+
+      test 'should not create invalid' do
+        post :create, params: { :template_id => @template.to_param }
+        assert_response :unprocessable_entity
+      end
+
+      test 'should update valid' do
+        put :update, params: { :template_id => @template.to_param, :id => @input_set.to_param, :foreign_input_set => { :include_all => false } }
+        assert_response :ok
+      end
+
+      test 'should not update invalid' do
+        put :update, params: { :template_id => @template.to_param, :id => @input_set.to_param, :foreign_input_set => { :target_template_id => '' } }
+        assert_response :unprocessable_entity
+      end
+
+      test 'should destroy' do
+        delete :destroy, params: { :template_id => @template.to_param, :id => @input_set.to_param }
+        assert_response :ok
+        assert_not ForeignInputSet.exists?(@input_set.id)
+      end
+    end
+  end
+end