foreman_remote_execution 14.1.0 → 14.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0b4dd4f17f6d245a627cf09e014206e0392de844821d35cef065a9af835b399
-  data.tar.gz: 4b60be78f70b3791c02f57c08060cc771aeb33f5cfd985335f26f25f1db030c7
+  metadata.gz: 0c7d7e0afd2637caccf6c287144c92599fd6abb3acecdc27b4fdfa960bc12e8a
+  data.tar.gz: 85e3859a4e3c81e03cc0441222d79bec187156e942e1abd3f4aec17b67c1a044
 SHA512:
-  metadata.gz: 9f87b034acd048bf1a5fe968a418a3b03cd76880342e9aeec52303b19e8bfb097013f877c9a43a34ffc23cb8b5cc9614c30dba16188c8dbfa101fc0c94d18d52
-  data.tar.gz: a90d5d70bc9bf9a0480202699c62d48f7e78ad1f518d6421fbf478c866a29fe265a3a7a7a9ac9e4a9a15177212877ea3dbb2101696384faef7fc7eb9a0c27650
+  metadata.gz: e24ea3d8af7755d15f5ed7b72b606590835414521b5bd100b137fcffdf0496bb6a2f52d94140622f18ed7121bf07725ffed2be76d7ef4ca648664f6b47a9b385
+  data.tar.gz: b8ef21fe312ee53f7dd60e746c0fed2e8e60386c06202cddc6c3ad23da3beaccdbd0f01214517a4a80c17546d1c32fa74a80c4de4a0d783be1a78dda8703ddcd

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.1'.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