katello 3.17.0.rc2 → 3.17.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c7f446fd8f4d3af288f0bbbf1f5b56bdac0f903d0c55fc332221d2cf2830384
-  data.tar.gz: 621fc49c5e82b6698a805c7a9b29143bad8b4b17690b94cd6cae3a65de1f33d9
+  metadata.gz: cd21c8de383c0f1eb036bb0591ecf77c27ffa30b8f9df1189b0a2da41abfdae4
+  data.tar.gz: bd0ec2cd3717b3b5237cc1af00c593a810493fb28866fa7e8344c49725563abc
 SHA512:
-  metadata.gz: e88e27186ae85ae6787743e2295b1076e9b6af862a531fc6aec29de59c18a378aa377725b0f7687594fcb8e9d891e6dc3d19e03f26aed3f1e9009eb03c03877d
-  data.tar.gz: 71d88ce6981546419a0f01f22a634727fdf36e11d164b69366aeabf00eb8ac1490935123c66e0733896ffc158b68b62d61817e4f03329f29cf6873fd1075da58
+  metadata.gz: fb2b4ce3ba4395eb68975bdb7d17ebd51fae70374742a0b06aab8c1e01e320a2c732bfd06e3ce0428c767604b864610a3e4480282725facb6e5451b0fbba86d2
+  data.tar.gz: 85a4321995088218ab2a92b05e015d8464529ccab3ca8e4ea3a704e28bb04682eede4cc7ea13b151364a7a254413269650af8e424515a476de8e1805e6accc52

data/app/controllers/katello/api/v2/api_controller.rb

@@ -39,8 +39,7 @@ module Katello
     end
 
     def deprecate_katello_agent
-      ::Foreman::Deprecation.api_deprecation_warning("Remote actions using katello-agent are deprecated and will be removed in Katello 4.0.  " \
-                                                         "You may consider switching to Remote Execution.")
+      ::Foreman::Deprecation.api_deprecation_warning("Katello-agent is deprecated and will be removed in a future release.")
     end
 
     def full_result_response(collection)

data/app/controllers/katello/api/v2/content_view_versions_controller.rb

@@ -99,7 +99,7 @@ module Katello
                         :template => '../../../api/v2/content_view_version_export_histories/index')
     end
 
-    api :POST, "/content_view_versions/:id/export", N_("Export a content view version"), :deprecated => true
+    api :POST, "/content_view_versions/:id/export", N_("Export a content view version")
     param :id, :number, :desc => N_("Content view version identifier"), :required => true
     param :destination_server, String, :desc => N_("Destination Server name, required for Pulp3")
     param :export_to_iso, :bool, :desc => N_("Export to ISO format. Relevant only for Pulp 2 repositories"), :required => false
@@ -143,6 +143,14 @@ module Katello
       respond_for_async :resource => task
     end
 
+    api :POST, "/content_view_versions/import", N_("Import a content view version")
+    param :content_view_id, :number, :desc => N_("Content view identifier"), :required => true
+    param :path, String, :desc => N_("Import path"), :required => true
+    def import
+      task = async_task(::Actions::Katello::ContentViewVersion::Import, @view, path: params[:path])
+      respond_for_async :resource => task
+    end
+
     api :DELETE, "/content_view_versions/:id", N_("Remove content view version")
     param :id, :number, :desc => N_("Content view version identifier"), :required => true
     def destroy

data/app/controllers/katello/api/v2/host_tracer_controller.rb

@@ -1,6 +1,11 @@
 module Katello
   class Api::V2::HostTracerController < Api::V2::ApiController
-    before_action :find_host, :only => :index
+    before_action :find_host
+
+    resource_description do
+      api_version 'v2'
+      api_base_url "/api"
+    end
 
     api :GET, "/hosts/:host_id/traces", N_("List services that need restarting on the host")
     param :host_id, :number, :required => true, :desc => N_("ID of the host")
@@ -9,43 +14,18 @@ module Katello
       respond_for_index(:collection => collection)
     end
 
-    api :PUT, "/traces/resolve", N_("Resolve Traces")
+    api :PUT, "/hosts/:host_id/traces/resolve", N_("Resolve Traces")
+    param :host_id, :number, :required => true, :desc => N_("ID of the host")
     param :trace_ids, Array, :required => true, :desc => N_("Array of Trace IDs")
     def resolve
-      traces = Katello::HostTracer.resolvable.where(id: params[:trace_ids])
-
-      traces.each do |trace|
-        if trace.reboot_required?
-          trace.helper = 'reboot'
-        end
-      end
-
-      traces_by_host_id = traces.group_by(&:host_id)
-      traces_by_helper = traces.group_by(&:helper)
-
-      composers = []
-
-      if traces_by_host_id.size < traces_by_helper.size
-        traces_by_host_id.each do |host_id, trace|
-          needed_traces = trace.map(&:helper).join(',')
-          joined_helpers = { :helper => needed_traces }
-          composers << JobInvocationComposer.for_feature(:katello_service_restart, [host_id], joined_helpers)
-        end
-      else
-        traces_by_helper.each do |helper, trace|
-          helpers = { :helper => helper }
-          composers << JobInvocationComposer.for_feature(:katello_service_restart, trace.map(&:host_id), helpers)
-        end
-      end
-
-      job_invocations = []
-
-      composers.each do |composer|
-        composer.trigger
-        job_invocations << composer.job_invocation
-      end
-
-      render json: job_invocations
+      traces = @host.host_traces.resolvable.where(id: params[:trace_ids])
+      fail HttpErrors::BadRequest, _("The requested traces were not found for this host") if traces.empty?
+
+      result = Katello::HostTraceManager.resolve_traces(traces)
+
+      task = ForemanTasks::Task.find(result.first.task_id)
+
+      respond_for_async(resource: task)
     end
 
     protected

data/app/controllers/katello/api/v2/hosts_bulk_actions_controller.rb

@@ -1,4 +1,5 @@
 module Katello
+  # rubocop:disable Metrics/ClassLength
   class Api::V2::HostsBulkActionsController < Api::V2::ApiController
     include Concerns::Api::V2::BulkHostsExtensions
     include Katello::Concerns::Api::V2::ContentOverridesController
@@ -6,7 +7,7 @@ module Katello
     before_action :find_host_collections, :only => [:bulk_add_host_collections, :bulk_remove_host_collections]
     before_action :find_environment, :only => [:environment_content_view]
     before_action :find_content_view, :only => [:environment_content_view]
-    before_action :find_editable_hosts, :except => [:destroy_hosts, :applicable_errata, :installable_errata]
+    before_action :find_editable_hosts, :except => [:destroy_hosts, :applicable_errata, :installable_errata, :resolve_traces]
     before_action :find_deletable_hosts, :only => [:destroy_hosts]
     before_action :find_readable_hosts, :only => [:applicable_errata, :installable_errata, :available_incremental_updates]
     before_action :find_errata, :only => [:available_incremental_updates]
@@ -236,6 +237,16 @@ module Katello
       respond_for_index(:collection => collection, :template => '../../../api/v2/host_tracer/index')
     end
 
+    api :PUT, "/hosts/bulk/resolve_traces", N_("Resolve traces for one or more hosts")
+    param_group :bulk_params
+    param :trace_ids, Array, :required => true, :desc => N_("Array of Trace IDs")
+    def resolve_traces
+      traces = Katello::HostTracer.resolvable.where(id: params[:trace_ids])
+      result = Katello::HostTraceManager.resolve_traces(traces)
+
+      render json: result
+    end
+
     api :POST, "/hosts/bulk/available_incremental_updates", N_("Given a set of hosts and errata, lists the content view versions" \
                                                                  " and environments that need updating.")
     param_group :bulk_params

data/app/controllers/katello/concerns/organizations_controller_extensions.rb

@@ -3,8 +3,14 @@ module Katello
     module OrganizationsControllerExtensions
       extend ActiveSupport::Concern
       include ForemanTasks::Triggers
+      include Foreman::Controller::Flash
 
       module Overrides
+        def edit
+          @can_toggle_sca = Katello::UpstreamConnectionChecker.new(@taxonomy).can_connect?
+          super
+        end
+
         def destroy
           if @taxonomy.is_a?(Organization)
             begin
@@ -42,6 +48,23 @@ module Katello
         end
       end
 
+      def update
+        super # we run super first here so that flash messages won't be in a confusing order
+        return if params[:simple_content_access].nil?
+        sca_param = ::Foreman::Cast.to_bool(params[:simple_content_access])
+        if sca_param && !@taxonomy.simple_content_access?
+          # user has requested SCA enable
+          task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Enable, params[:id])
+          info "Enabling Simple Content Access for organization #{@taxonomy.name}.",
+            link: { text: "View progress on the Tasks page", href: "/foreman_tasks/tasks/#{task&.id}" }
+        elsif !sca_param && @taxonomy.simple_content_access?
+          # user has requested SCA disable
+          task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Disable, params[:id])
+          info "Disabling Simple Content Access for organization #{@taxonomy.name}.",
+            link: { text: "View progress on the Tasks page", href: "/foreman_tasks/tasks/#{task&.id}" }
+        end
+      end
+
       included do
         prepend Overrides
       end

data/app/lib/actions/katello/applicability/hosts/bulk_generate.rb

@@ -9,8 +9,12 @@ module Actions
 
           def run
             input[:host_ids].each do |host_id|
-              content_facet = ::Host.find(host_id).content_facet
-              content_facet.calculate_and_import_applicability
+              content_facet = ::Katello::Host::ContentFacet.find_by_host_id(host_id)
+              if content_facet.present?
+                content_facet.calculate_and_import_applicability
+              else
+                Rails.logger.warn(_("Content Facet for host with id %s is non-existent. Skipping applicability calculation.") % host_id)
+              end
             end
           end
 

data/app/lib/actions/katello/capsule_content/sync_capsule.rb

@@ -20,10 +20,14 @@ module Actions
                                     Actions::Pulp3::CapsuleContent::Sync],
                                      repo, smart_proxy,
                                      skip_metadata_check: skip_metadata_check)
+                end
+              end
 
+              concurrence do
+                repo_batch.each do |repo|
                   if repo.is_a?(::Katello::Repository) &&
-                    repo.distribution_bootable? &&
-                    repo.download_policy == ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND
+                      repo.distribution_bootable? &&
+                      repo.download_policy == ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND
                     plan_action(Katello::Repository::FetchPxeFiles,
                                 id: repo.id,
                                 capsule_id: smart_proxy.id)

data/app/lib/actions/katello/content_view/promote.rb

@@ -2,7 +2,7 @@ module Actions
   module Katello
     module ContentView
       class Promote < Actions::EntryAction
-        def plan(version, environments, is_force = false, description = nil)
+        def plan(version, environments, is_force = false, description = nil, incremental_update = false)
           action_subject(version.content_view)
           version.check_ready_to_promote!(environments)
 
@@ -13,7 +13,7 @@ module Actions
           environments.each do |environment|
             sequence do
               plan_action(Katello::ContentViewVersion::BeforePromoteHook, :id => version.id)
-              plan_action(ContentView::PromoteToEnvironment, version, environment, description)
+              plan_action(ContentView::PromoteToEnvironment, version, environment, description, incremental_update)
               plan_action(Katello::ContentViewVersion::AfterPromoteHook, :id => version.id)
             end
           end

data/app/lib/actions/katello/content_view/promote_to_environment.rb

@@ -3,7 +3,7 @@ module Actions
   module Katello
     module ContentView
       class PromoteToEnvironment < Actions::EntryAction
-        def plan(version, environment, description)
+        def plan(version, environment, description, incremental_update = false)
           history = ::Katello::ContentViewHistory.create!(:content_view_version => version, :user => ::User.current.login,
                                                           :environment => environment, :task => self.task,
                                                           :status => ::Katello::ContentViewHistory::IN_PROGRESS,
@@ -29,8 +29,13 @@ module Actions
             plan_action(Candlepin::Environment::SetContent, version.content_view, environment, version.content_view.content_view_environment(environment))
             plan_action(Katello::Foreman::ContentUpdate, environment, version.content_view)
             plan_action(ContentView::ErrataMail, version.content_view, environment)
+
+            if incremental_update && sync_proxies?(environment)
+              plan_action(ContentView::CapsuleSync, version.content_view, environment)
+            end
+
             plan_self(history_id: history.id, environment_id: environment.id, user_id: ::User.current.id,
-                      environment_name: environment.name, content_view_id: version.content_view.id)
+                      environment_name: environment.name, content_view_id: version.content_view.id, incremental_update: incremental_update)
           end
         end
 
@@ -55,7 +60,7 @@ module Actions
           history.save!
           environment = ::Katello::KTEnvironment.find(input[:environment_id])
 
-          if ::SmartProxy.sync_needed?(environment) && Setting[:foreman_proxy_content_auto_sync]
+          if !input[:incremental_update] && sync_proxies?(environment)
             ForemanTasks.async_task(ContentView::CapsuleSync,
                                     ::Katello::ContentView.find(input[:content_view_id]),
                                     environment)
@@ -65,6 +70,10 @@ module Actions
 
         private
 
+        def sync_proxies?(environment)
+          Setting[:foreman_proxy_content_auto_sync] && ::SmartProxy.sync_needed?(environment)
+        end
+
         def repos_to_delete(version, environment)
           archived_library_instance_ids = version.archived_repos.collect { |archived| archived.library_instance_id }
           version.content_view.repos(environment).find_all do |repo|

data/app/lib/actions/katello/content_view/publish.rb

@@ -8,7 +8,9 @@ module Actions
         # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity
         def plan(content_view, description = "", options = {})
           action_subject(content_view)
-          content_view.check_ready_to_publish!
+          import_only = options.fetch(:import_only, false)
+          path = options[:path]
+          content_view.check_ready_to_publish! unless import_only
 
           if options[:repos_units].present?
             valid_labels_from_cv = content_view.repositories.map(&:label)
@@ -51,7 +53,11 @@ module Actions
 
             if separated_repo_map[:pulp3_yum].keys.flatten.present? &&
                 SmartProxy.pulp_primary.pulp3_support?(separated_repo_map[:pulp3_yum].keys.flatten.first)
-              plan_action(Repository::MultiCloneToVersion, separated_repo_map[:pulp3_yum], version)
+              if import_only
+                handle_import(version, path)
+              else
+                plan_action(Repository::MultiCloneToVersion, separated_repo_map[:pulp3_yum], version)
+              end
             end
 
             concurrence do
@@ -181,6 +187,16 @@ module Actions
             content_view.create_new_version
           end
         end
+
+        def handle_import(version, path)
+          plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::Import, version, path: path)
+          plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::CopyVersionUnitsToLibrary, version)
+          concurrence do
+            version.importable_repositories.pluck(:id).each do |id|
+              plan_action(Katello::Repository::IndexContent, id: id)
+            end
+          end
+        end
       end
     end
   end

data/app/lib/actions/katello/content_view_version/import.rb

@@ -0,0 +1,36 @@
+module Actions
+  module Katello
+    module ContentViewVersion
+      class Import < Actions::EntryAction
+        PULP_USER = 'pulp'.freeze
+
+        def plan(content_view, path:)
+          content_view.check_ready_to_import!
+          unless SmartProxy.pulp_primary.pulp3_repository_type_support?(::Katello::Repository::YUM_TYPE)
+            fail HttpErrors::BadRequest, _("This API endpoint is only valid for Pulp 3 repositories.")
+          end
+          ::Katello::Pulp3::ContentViewVersion::Import.check_permissions!(path)
+          metadata = ::Katello::Pulp3::ContentViewVersion::Import.metadata(path)
+          major = metadata[:content_view_version][:major]
+          minor = metadata[:content_view_version][:minor]
+
+          if ::Katello::ContentViewVersion.where(major: major, minor: minor, content_view: content_view).exists?
+            cvv_name = "#{content_view.name} #{major}.#{minor}"
+            fail _("Content View Version specified in the metadata - '%{name}' already exists. "\
+                    "If you wish to replace the existing version, delete %{name} and try again. " % { name: cvv_name })
+          end
+
+          plan_action(::Actions::Katello::ContentView::Publish, content_view, '',
+                        path: path,
+                        import_only: true,
+                        major: major,
+                        minor: minor)
+        end
+
+        def humanized_name
+          _("Import Content View Version")
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/katello/content_view_version/incremental_update.rb

@@ -266,8 +266,9 @@ module Actions
           history.status = ::Katello::ContentViewHistory::SUCCESSFUL
           history.save!
 
-          unless SmartProxy.pulp_primary.pulp3_support?(version.repositories.first)
-            version.repositories.each do |repo|
+          cvv_yum_repos = version.repositories.yum_type
+          unless cvv_yum_repos.empty? || SmartProxy.pulp_primary.pulp3_support?(cvv_yum_repos.first)
+            cvv_yum_repos.each do |repo|
               SmartProxy.pulp_primary.pulp_api.extensions.send(:module_default).
                 copy(repo.library_instance.pulp_id,
                 repo.pulp_id)
@@ -334,7 +335,7 @@ module Actions
         end
 
         def promote(new_version, environments)
-          plan_action(Katello::ContentView::Promote, new_version, environments, true)
+          plan_action(Katello::ContentView::Promote, new_version, environments, true, nil, true)
         end
 
         def copy_deb_content(new_repo, dep_solve, deb_ids)

data/app/lib/actions/katello/host/hypervisors_update.rb

@@ -13,6 +13,8 @@ module Actions
           @hypervisors = input[:hypervisors]
           return unless @hypervisors
 
+          @duplicate_uuid_hypervisors = {}
+
           User.as_anonymous_admin do
             ActiveRecord::Base.transaction do
               load_resources
@@ -30,8 +32,16 @@ module Actions
               update_facts(uuid, host)
             end
           end
+
+          @duplicate_uuid_hypervisors.each do |hypervisor, existing_host|
+            fail _("Host creation was skipped for %s because it shares a BIOS UUID with %s. " \
+                   "To report this hypervisor, override its dmi.system.uuid fact or set 'candlepin.use_system_uuid_for_matching' " \
+                   "to 'true' in the Candlepin configuration." % [hypervisor[:name], existing_host.name])
+          end
         end
 
+        private
+
         def load_hosts_guests
           @hosts.each do |uuid, host|
             host.subscription_facet ||= host.build_subscription_facet(uuid: uuid)
@@ -81,6 +91,14 @@ module Actions
           @hypervisors.each do |hypervisor|
             next if @hosts.key?(hypervisor[:uuid])
 
+            created_host = new_hypervisors[hypervisor[:uuid]]
+            if created_host
+              # we've already created a host record for this duplicate hypervisor
+              # track it so we can message later, and continue processing the remaining hypervisors
+              @duplicate_uuid_hypervisors[hypervisor] = created_host
+              next
+            end
+
             duplicate_name, org = duplicate_name(hypervisor, @candlepin_attributes[hypervisor[:uuid]])
             new_hypervisors[hypervisor[:uuid]] = create_host_for_hypervisor(duplicate_name, org)
           end

data/app/lib/actions/katello/organization/create.rb

@@ -17,7 +17,7 @@ module Actions
                                       label:  organization.label,
                                       name: organization.name)
             end
-            plan_action(Environment::LibraryCreate, organization.library)
+            plan_action(Katello::Environment::LibraryCreate, organization.library)
           end
           if cp_create
             action_subject organization, label: cp_create.output[:response][:key]

data/app/lib/actions/katello/organization/simple_content_access/disable.rb

@@ -10,6 +10,14 @@ module Actions
           def humanized_name
             N_("Disable Simple Content Access")
           end
+
+          def task_success_notification
+            ::Katello::UINotifications::Subscriptions::SCADisableSuccess
+          end
+
+          def task_error_notification
+            ::Katello::UINotifications::Subscriptions::SCADisableError
+          end
         end
       end
     end