katello 3.16.0.rc1.1 → 3.16.0.rc4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49e88fab5fb43375d053afea798096a12e7141395144dfab26d48323e304fbac
-  data.tar.gz: ee2095edb5cb2ce6f48966c9f7a7f73ee893f2d5c08e31930d080e8b07895321
+  metadata.gz: 590a33ff3016ad29aaeca6e8d5a0c967b9053a01cf3dbf8f28fcb68b63d056bd
+  data.tar.gz: e8c30ca9e88f472f3aabf89b7f2cc3c6122750706e9bdfbb9d1cfa8aa957d4a5
 SHA512:
-  metadata.gz: 27d9a1ab44ddd37d5ec67ebdcb918be9a0f86cf179a02c5e93b1188cf461fcd31c3205cd4748c893aa24f940dfd0f599b8649abef5291161b02fbdaf9a99778e
-  data.tar.gz: 9ecb92e8ff4000c0564762fc4eb2355a0c265e34f97e2ebe47c6e6636afc17d320519dfc0d73fe83d7e44ee7dd1d8a23f96e3e5a1fdcab8f0c1a9f62cabc4d83
+  metadata.gz: 2fbba71f828db21edacf4100aac226a638fa7c6dd59871f6d0f029846af27ff54914c803798fd6054463ae4f44bbfc29d9466fca8a19867e63c10486668ce30c
+  data.tar.gz: 17347500daf6bb1b2dd1ff7126b97e84f2120e1c12e23066036d2f30402cdb9018dc5c6cb1f74ceff441f069a2733dceb4e3a4958032237034eaff5783915b49

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

@@ -211,10 +211,14 @@ module Katello
       fail HttpErrors::BadRequest, _("Host has not been registered with subscription-manager") if @host.subscription_facet.nil?
     end
 
-    def check_disconnected
-      msg = "You are currently operating in disconnected mode where access to Red Hat Subcription Management " \
-            "is prohibited. If you would like to change this, please update the content setting 'Disconnected mode'."
-      fail HttpErrors::BadRequest, _(msg) if Setting[:content_disconnected]
+    def check_upstream_connection
+      checker = Katello::UpstreamConnectionChecker.new(@organization)
+
+      begin
+        checker.assert_connection
+      rescue => e
+        raise HttpErrors::BadRequest, e.message
+      end
     end
   end
 end

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

@@ -7,7 +7,7 @@ module Katello
     before_action :find_optional_organization, :only => [:index, :available, :show]
     before_action :find_organization, :only => [:upload, :delete_manifest,
                                                 :refresh_manifest, :manifest_history]
-    before_action :check_disconnected, only: [:refresh_manifest]
+    before_action :check_upstream_connection, only: [:refresh_manifest]
     before_action :find_provider
 
     skip_before_action :check_content_type, :only => [:upload]

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

@@ -1,6 +1,7 @@
 module Katello
   class Api::V2::UpstreamSubscriptionsController < Api::V2::ApiController
-    before_action :check_disconnected
+    before_action :find_organization
+    before_action :check_upstream_connection
 
     resource_description do
       description "Red Hat subscriptions management platform."
@@ -65,6 +66,17 @@ module Katello
       respond_for_async resource: task
     end
 
+    api :GET, "/organizations/:organization_id/upstream_subscriptions/ping",
+      N_("Check if a connection can be made to Red Hat Subscription Management.")
+    def ping
+      # This API raises an error if:
+      # - Katello is in disconnected mode
+      # - There is no manifest imported
+      # - The local manifest identity certs have expired
+      # - The manifest has been deleted upstream
+      render json: { status: 'OK' }
+    end
+
     private
 
     def update_params

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

@@ -18,6 +18,17 @@ module Katello
       included do
         prepend Overrides
 
+        def update_multiple_taxonomies(type)
+          registered_host = @hosts.detect { |host| host.subscription_facet }
+          unless registered_host.nil?
+            error _("Unregister host %s before assigning an organization") % registered_host.name
+            redirect_back_or_to hosts_path
+            return
+          end
+
+          super
+        end
+
         def destroy
           if Katello::RegistrationManager.unregister_host(@host, :unregistering => false)
             process_success redirection_url_on_host_deletion

data/app/controllers/katello/remote_execution_controller.rb

@@ -43,7 +43,7 @@ module Katello
       end
 
       def errata_inputs
-        if params[:install_all]
+        if ::Foreman::Cast.to_bool(params[:install_all])
           Erratum.installable_for_hosts(hosts).pluck(:errata_id).join(',')
         else
           params[:name]

data/app/lib/actions/katello/applicability/hosts/{generate.rb → bulk_generate.rb}

@@ -2,17 +2,26 @@ module Actions
   module Katello
     module Applicability
       module Hosts
-        class Generate < Actions::EntryAction
+        class BulkGenerate < Actions::EntryAction
           input_format do
             param :host_ids, Array
           end
 
           def run
             input[:host_ids].each do |host_id|
-              ::Katello::EventQueue.push_event(::Katello::Events::GenerateHostApplicability::EVENT_TYPE, host_id)
+              content_facet = ::Host.find(host_id).content_facet
+              content_facet.calculate_and_import_applicability
             end
           end
 
+          def queue
+            ::Katello::HOST_TASKS_QUEUE
+          end
+
+          def resource_locks
+            :link
+          end
+
           def humanized_name
             _("Bulk generate applicability for hosts")
           end

data/app/lib/actions/katello/applicability/repository/regenerate.rb

@@ -11,9 +11,14 @@ module Actions
           end
 
           def run
-            ::Katello::Repository.find(input[:repo_id]).content_facets.each do |facet|
-              ::Katello::EventQueue.push_event(::Katello::Events::GenerateHostApplicability::EVENT_TYPE, facet.host.id)
+            host_ids = ::Katello::Repository.find(input[:repo_id]).hosts_with_applicability.pluck(:id)
+            return if host_ids.empty?
+
+            host_ids.each do |host_id|
+              ::Katello::ApplicableHostQueue.push_host(host_id)
             end
+
+            ::Katello::EventQueue.push_event(::Katello::Events::GenerateHostApplicability::EVENT_TYPE, 0)
           end
 
           def humanized_name

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

@@ -8,7 +8,7 @@ module Actions
 
         def plan(hosts, use_queue = true)
           if SETTINGS[:katello][:katello_applicability]
-            plan_action(::Actions::Katello::Applicability::Hosts::Generate, host_ids: hosts.pluck(:id))
+            plan_self(:host_ids => hosts.map(&:id))
           else
             uuids = hosts.map { |host| host.content_facet.try(:uuid) }.compact
             unless uuids.empty?
@@ -19,7 +19,12 @@ module Actions
         end
 
         def finalize
-          unless SETTINGS[:katello][:katello_applicability]
+          if SETTINGS[:katello][:katello_applicability]
+            input[:host_ids].each do |host_id|
+              ::Katello::ApplicableHostQueue.push_host(host_id)
+            end
+            ::Katello::EventQueue.push_event(::Katello::Events::GenerateHostApplicability::EVENT_TYPE, 0)
+          else
             input[:host_ids].each do |host_id|
               if input[:use_queue]
                 ::Katello::EventQueue.push_event(::Katello::Events::ImportHostApplicability::EVENT_TYPE, host_id)

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

@@ -38,15 +38,18 @@ module Actions
             ::Katello::ModuleStream.where(profile.slice(:name, :stream))
           end
 
-          query_name_streams = query_name_streams.inject(&:or)
+          updated_profiles = []
+          unless query_name_streams.empty?
+            query_name_streams = query_name_streams.inject(&:or)
 
-          bound_library_instances = host.content_facet.bound_repositories.map(&:library_instance_or_self)
-          query = ::Katello::ModuleStream.in_repositories(bound_library_instances).
-                                          select(:name, :stream, :version, :context, :arch).
-                                            merge(query_name_streams)
+            bound_library_instances = host.content_facet.bound_repositories.map(&:library_instance_or_self)
+            query = ::Katello::ModuleStream.in_repositories(bound_library_instances).
+                                            select(:name, :stream, :version, :context, :arch).
+                                              merge(query_name_streams)
 
-          updated_profiles = query.map do |module_stream|
-            module_stream.slice(:name, :stream, :version, :context, :arch)
+            updated_profiles = query.map do |module_stream|
+              module_stream.slice(:name, :stream, :version, :context, :arch)
+            end
           end
 
           # We also need to pass module streams that are not found in the ModuleStream table
@@ -55,10 +58,16 @@ module Actions
             updated_profiles.none? { |p| p[:name] == profile[:name] && p[:stream] == profile[:stream] }
           end
 
-          ::Katello::Pulp::Consumer.new(host.content_facet.uuid).
-              upload_module_stream_profile(updated_profiles + unassociated_profiles)
-        rescue RestClient::ResourceNotFound
-          Rails.logger.warn("Host with ID %s was not known to Pulp, continuing" % host.id)
+          module_stream_profile = updated_profiles + unassociated_profiles
+
+          unless module_stream_profile.empty?
+            begin
+              ::Katello::Pulp::Consumer.new(host.content_facet.uuid).
+                upload_module_stream_profile(module_stream_profile)
+            rescue RestClient::ResourceNotFound
+              Rails.logger.warn("Host with ID %s was not known to Pulp, continuing" % host.id)
+            end
+          end
         end
 
         def import_module_streams(payload, host)

data/app/lib/actions/katello/repository/sync.rb

@@ -26,8 +26,7 @@ module Actions
           incremental = options.fetch(:incremental, false)
           validate_contents = options.fetch(:validate_contents, false)
           skip_metadata_check = options.fetch(:skip_metadata_check, false) || (validate_contents && repo.yum?)
-          # TODO: Remove the check for Pulp 3 once Pulp 3 errata is working fully
-          generate_applicability = repo.yum? && !SmartProxy.pulp_master.pulp3_support?(repo)
+          generate_applicability = repo.yum?
 
           fail ::Katello::Errors::InvalidActionOptionError, _("Unable to sync repo. This repository does not have a feed url.") if repo.url.blank? && source_url.blank?
           fail ::Katello::Errors::InvalidActionOptionError, _("Cannot validate contents on non-yum/deb repositories.") if validate_contents && !repo.yum? && !repo.deb?

data/app/lib/actions/katello/repository/update.rb

@@ -10,6 +10,8 @@ module Actions
           action_subject root.library_instance
 
           repo_params[:url] = nil if repo_params[:url] == ''
+          update_cv_cert_protected = (repo_params[:unprotected] != repository.unprotected)
+
           root.update!(repo_params)
 
           if root.download_policy == ::Runcible::Models::YumImporter::DOWNLOAD_BACKGROUND
@@ -44,15 +46,24 @@ module Actions
                               ::Actions::Pulp3::Orchestration::Repository::Update],
                              repository,
                              SmartProxy.pulp_master)
-            plan_self(:repository_id => root.library_instance.id)
+            plan_self(:repository_id => root.library_instance.id, :update_cv_cert_protected => update_cv_cert_protected)
           end
         end
 
         def run
           repository = ::Katello::Repository.find(input[:repository_id])
+          output[:repository_id] = input[:repository_id]
+          output[:update_cv_cert_protected] = input[:update_cv_cert_protected]
           ForemanTasks.async_task(Katello::Repository::MetadataGenerate, repository)
         end
 
+        def finalize
+          repository = ::Katello::Repository.find(output[:repository_id])
+          if output[:update_cv_cert_protected]
+            ForemanTasks.async_task(::Actions::Katello::Repository::UpdateCVRepoCertGuard, repository, SmartProxy.pulp_master)
+          end
+        end
+
         private
 
         def update_content?(repository)

data/app/lib/actions/katello/repository/update_cv_repo_cert_guard.rb

@@ -0,0 +1,17 @@
+module Actions
+  module Katello
+    module Repository
+      class UpdateCVRepoCertGuard < Actions::Base
+        include Actions::Katello::PulpSelector
+
+        def plan(repository, smart_proxy)
+          plan_optional_pulp_action([::Actions::Pulp3::Repository::UpdateCVRepositoryCertGuard], repository, smart_proxy)
+        end
+
+        def humanized_name
+          _("Updating repository authentication configuration")
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/ContentGuard/refresh.rb

@@ -0,0 +1,19 @@
+module Actions
+  module Pulp3
+    module ContentGuard
+      class Refresh < Pulp3::Abstract
+        def plan(smart_proxy, options = {})
+          return if (::Katello::Pulp3::ContentGuard.count > 0 || options.try(:[], :update))
+          content_guard_api = ::Katello::Pulp3::Api::ContentGuard.new(smart_proxy)
+          if options.try(:[], :update)
+            content_guard_href = ::Katello::Pulp3::ContentGuard.first.href
+            content_guard_api.partial_update content_guard_href
+          else
+            content_guard_api.create
+            ::Katello::Pulp3::ContentGuard.import(smart_proxy)
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/orchestration/repository/copy_all_units.rb

@@ -13,25 +13,23 @@ module Actions
             if filter_ids.present? || rpm_filenames.present? || source_repositories.length > 1
               sequence do
                 if filter_ids.present? || rpm_filenames.present?
-                  copy_action = plan_action(Actions::Pulp3::Repository::CopyContent,
-                                            source_repositories.first, smart_proxy, target_repo,
+                  copy_action = plan_action(Actions::Pulp3::Repository::CopyContent, source_repositories.first, smart_proxy, target_repo,
                                             filter_ids: filter_ids, solve_dependencies: solve_dependencies,
                                             rpm_filenames: rpm_filenames)
-
-                  plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo, tasks: copy_action.output[:pulp_tasks])
+                  plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo,
+                              repository_details: { latest_version_href: copy_action.output[:latest_version_href] }, tasks: copy_action.output[:pulp_tasks])
                 else
                   #if we are not filtering, copy the version to the cv repository, and the units for each additional repo
                   action = plan_action(Actions::Pulp3::Repository::CopyVersion, source_repositories.first, smart_proxy, target_repo)
-                  plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo, tasks: action.output[:pulp_tasks])
+                  plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo,
+                              repository_details: { latest_version_href: action.output[:latest_version_output] }, tasks: action.output[:pulp_tasks])
                   copy_actions = []
                   #since we're creating a new version from the first repo, start copying at the 2nd
                   source_repositories[1..-1].each do |source_repo|
-                    copy_actions << plan_action(Actions::Pulp3::Repository::CopyContent,
-                                                source_repo, smart_proxy, target_repo,
+                    copy_actions << plan_action(Actions::Pulp3::Repository::CopyContent, source_repo, smart_proxy, target_repo,
                                                 filter_ids: filter_ids, solve_dependencies: solve_dependencies,
                                                 rpm_filenames: rpm_filenames)
                   end
-
                   plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo, tasks: copy_actions.last.output[:pulp_tasks])
                 end
               end

data/app/lib/actions/pulp3/orchestration/repository/generate_metadata.rb

@@ -12,7 +12,7 @@ module Actions
               elsif publication_content_type
                 plan_action(Actions::Pulp3::Repository::CreatePublication, repository, smart_proxy, options)
               end
-
+              plan_action(Actions::Pulp3::ContentGuard::Refresh, smart_proxy) unless repository.unprotected
               plan_action(Actions::Pulp3::Repository::RefreshDistribution, repository, smart_proxy, :contents_changed => options[:contents_changed]) if repository.environment
             end
           end

data/app/lib/actions/pulp3/repository/copy_content.rb

@@ -11,6 +11,7 @@ module Actions
         def invoke_external_task
           source = ::Katello::Repository.find(input[:source_repository_id])
           target = ::Katello::Repository.find(input[:target_repository_id] || input[:target_repository])
+          output[:latest_version_href] = target.backend_service(smart_proxy).read.latest_version_href
           output[:pulp_tasks] = target.backend_service(smart_proxy).copy_content_for_source(source, input)
         end
       end

data/app/lib/actions/pulp3/repository/refresh_distribution.rb

@@ -9,6 +9,7 @@ module Actions
           sequence do
             options = {:repository_id => repository.id, :smart_proxy_id => smart_proxy.id}
             options[:contents_changed] if options.key?(:contents_changed)
+            plan_action(::Actions::Pulp3::ContentGuard::Refresh, smart_proxy) unless repository.unprotected
             action = plan_self(options)
             plan_action(SaveDistributionReferences, repository, smart_proxy,
                         action.output, :contents_changed => options[:contents_changed])

data/app/lib/actions/pulp3/repository/save_distribution_references.rb

@@ -12,9 +12,11 @@ module Actions
           if input[:tasks] && input[:tasks][:pulp_tasks] && input[:tasks][:pulp_tasks].first
             distribution_hrefs = input[:tasks][:pulp_tasks].map { |task| task[:created_resources].first }
             distribution_hrefs.compact!
+            repo = ::Katello::Repository.find(input[:repository_id])
             if distribution_hrefs.any?
-              repo = ::Katello::Repository.find(input[:repository_id])
               repo.backend_service(smart_proxy).save_distribution_references(distribution_hrefs)
+            else
+              repo.backend_service(smart_proxy).update_distribution
             end
           end
         end

data/app/lib/actions/pulp3/repository/save_version.rb

@@ -11,7 +11,9 @@ module Actions
 
           if input[:tasks]
             version_href = input[:tasks].last[:created_resources].first
-          elsif input[:repository_details]
+          end
+
+          if !version_href && input[:repository_details]
             version_href = input[:repository_details][:latest_version_href]
           end
 

data/app/lib/actions/pulp3/repository/update_cv_repository_cert_guard.rb

@@ -0,0 +1,15 @@
+module Actions
+  module Pulp3
+    module Repository
+      class UpdateCVRepositoryCertGuard < Pulp3::Abstract
+        def plan(repository, _smart_proxy)
+          root = repository.root
+          cv_repositories = root.repositories - [root.library_instance]
+          cv_repositories.each do |repo|
+            plan_action(::Actions::Pulp3::Repository::RefreshDistribution, repo, SmartProxy.pulp_master)
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/katello/concerns/base_template_scope_extensions.rb

@@ -9,7 +9,7 @@ module Katello
                    :host_latest_applicable_rpm_version, :load_pools, :load_errata_applications, :host_content_facet,
                    :host_sla, :host_products, :sub_name, :sub_sku, :registered_through, :last_checkin, :host_collections,
                    :host_subscriptions_names, :host_subscriptions, :host_products_names, :host_collections_names,
-                   :host_redhat_subscription_names]
+                   :host_redhat_subscription_names, :registered_at]
         end
       end
 
@@ -76,6 +76,10 @@ module Katello
         host_subscription_facet(host)&.registered_through
       end
 
+      def registered_at(host)
+        host_subscription_facet(host)&.registered_at
+      end
+
       def host_applicable_errata_ids(host)
         host.applicable_errata.map(&:errata_id)
       end

data/app/lib/katello/errors.rb

@@ -39,6 +39,12 @@ module Katello
       end
     end
 
+    class HostRegisteredException < StandardError
+      def message
+        _("Content host must be unregistered before performing this action.")
+      end
+    end
+
     class EmptyBulkActionException < StandardError
       def message
         _("No hosts registered with subscription-manager found in selection.")
@@ -154,5 +160,24 @@ module Katello
         _("No URL found for a container registry. Please check the configuration.")
       end
     end
+
+    class DisconnectedMode < StandardError
+      def message
+        _("You are currently operating in disconnected mode where access to Red Hat Subcription Management " \
+        "is prohibited. If you would like to change this, please update the content setting 'Disconnected mode'.")
+      end
+    end
+
+    class NoManifestImported < StandardError
+      def message
+        _("Current organization has no manifest imported.")
+      end
+    end
+
+    class ManifestExpired < StandardError
+      def message
+        _("This Organization's subscription manifest has expired. Please import a new manifest.")
+      end
+    end
   end
 end