katello 3.16.0.rc2.1 → 3.16.0.rc5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07abcc2d0e780bd3bfee4cd44b73ef4183e0a50daebe6a32cd056e162e3fde52
-  data.tar.gz: 6c95fe44a013f6e74d36098c3e96f8e669f5670925620a9dc26e6ed674cc2abb
+  metadata.gz: d0972a0ce2e400210de115168dd9b0119d5d738eacc73f4854406df2abf853e5
+  data.tar.gz: 102cafbfe169374c46933f8a11487ba06d36c029b08fb88cb2857bd9cc0faa59
 SHA512:
-  metadata.gz: 17dece7796e9c33d88970ed5eaba5d810db5b84c76ddc03d0767c8bf426013ac9c3e29f14a3bb3be6663e0233e8968551294f51000fb4161e348028add9ecb0b
-  data.tar.gz: c8b139917779fb48e642270141eb4418c4f668433307cb8097661b581985edc7163f67524328f13368c5cf80d7fc51ef2c856816eacb19ff9a720f40cef595d8
+  metadata.gz: 2ffe9b0201453156e10c992b0363feba8079d47b7be06e263b7f9fb9ae333569684532712a7eafe60ea0ae790ee7e512128a0b39051c6c07c5af11c3bb37ad3e
+  data.tar.gz: d30abd4cef90402f90122b412451c5dbdafc11da644363e176623f8f37d6f27e5774783c31cd1b6dd9791f208f8177913eae86fc3b4b087de725bb4501c8828f

data/app/controllers/katello/api/rhsm/candlepin_proxies_controller.rb

@@ -268,8 +268,8 @@ module Katello
     end
 
     def get_parent_host(headers)
-      hostnames = headers["HTTP_X_FORWARDED_SERVER"]
-      host = hostnames.split(",")[0] if hostnames
+      hostnames = headers["HTTP_X_FORWARDED_HOST"]
+      host = hostnames.split(/[\,,:]/)[0].strip if hostnames
       host || URI.parse(Setting[:foreman_url]).host
     end
 

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

@@ -5,6 +5,7 @@ module Katello
     include Api::V2::Rendering
     include Api::V2::ErrorHandling
     include ::Foreman::Controller::CsvResponder
+    include Concerns::Api::V2::AssociationsPermissionCheck
 
     # support for session (thread-local) variables must be the last filter in this class
     include Foreman::ThreadSession::Cleaner
@@ -211,10 +212,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/content_view_versions_controller.rb

@@ -143,6 +143,9 @@ module Katello
       end
     end
     def incremental_update
+      if params[:add_content].values.flatten.empty?
+        fail HttpErrors::BadRequest, _("Incremental update requires at least one content unit")
+      end
       any_environments = params[:content_view_version_environments].any? { |cvve| cvve[:environment_ids].try(:any?) }
       if params[:add_content]&.key?(:errata_ids) && params[:update_hosts] && any_environments
         hosts = calculate_hosts_for_incremental(params[:update_hosts], params[:propagate_to_composites])

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

@@ -22,6 +22,13 @@ module Katello
       param :solve_dependencies, :bool, :desc => N_("Solve RPM dependencies by default on Content View publish, defaults to false")
     end
 
+    def filtered_associations
+      {
+        :component_ids => Katello::ContentViewVersion,
+        :repository_ids => Katello::Repository
+      }
+    end
+
     api :GET, "/organizations/:organization_id/content_views", N_("List content views")
     api :GET, "/content_views", N_("List content views")
     param :organization_id, :number, :desc => N_("organization identifier")

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/api/v2/associations_permission_check.rb

@@ -0,0 +1,67 @@
+module Katello
+  module Concerns
+    module Api::V2::AssociationsPermissionCheck
+      extend ActiveSupport::Concern
+
+      # The purpose of this module is to protect a controller from a user creating or updating some association
+      # when they do not have permissions to view the associated items.  An example would be adding random repository ids to
+      # content view.
+      # To support this, within the controller define a method such as:
+      #     def filtered_associations
+      #       {
+      #         :component_ids => Katello::ContentViewVersion,
+      #         :repository_ids => Katello::Repository
+      #       }
+      #     end
+      # This assumes that the parameters are 'wrapped'.  So the above in the content_views_controller, actually looks at
+      #  a subhash of 'content_view'
+
+      included do
+        before_action :check_association_ids, :only => [:create, :update]
+      end
+
+      def check_association_ids
+        if filtered_associations
+          wrapped_params = params[self._wrapper_options.name]
+          find_param_arrays(wrapped_params).each do |key_path|
+            if (model_class = filtered_associations.with_indifferent_access.dig(*key_path))
+              param_ids = wrapped_params.dig(*key_path)
+              filtered_ids = model_class.readable.where(:id => param_ids).pluck(:id)
+              if (unfound_ids = param_ids_missing(param_ids, filtered_ids)).any?
+                fail HttpErrors::NotFound, _("One or more ids (%{ids}) were not found for %{assoc}.  You may not have permissions to see them.") %
+                    {ids: unfound_ids, assoc: key_path.last}
+              end
+            else
+              fail _("Unfiltered params array: %s.") % key_path
+            end
+          end
+        else
+          Rails.logger.warn("#{self.class.name} may has unprotected associations, see associations_permission_check.rb for details.") if ENV['RAILS_ENV'] == 'development'
+        end
+      end
+
+      def filtered_associations
+        #should return {} when supported by all controllers
+        nil
+      end
+
+      def param_ids_missing(param_ids, filtered_ids)
+        param_ids.map(&:to_i).uniq - filtered_ids.map(&:to_i).uniq
+      end
+
+      #returns an array of list of keys pointing to an array in a params hash i.e.:
+      # {"a"=> {"b" => [3]}}  =>  [["a", "b"]]
+      def find_param_arrays(hash = params)
+        list_of_paths = []
+        hash.each do |key, value|
+          if value.is_a?(ActionController::Parameters) || value.is_a?(Hash)
+            list_of_paths += find_param_arrays(value).compact.map { |inner_keys| [key] + inner_keys }
+          elsif value.is_a?(Array)
+            list_of_paths << [key]
+          end
+        end
+        list_of_paths.compact
+      end
+    end
+  end
+end

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/lib/actions/katello/capsule_content/refresh_repos.rb

@@ -10,6 +10,10 @@ module Actions
           fail NotImplementedError
         end
 
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip if self.state == 'error'
+        end
+
         def plan(smart_proxy, options = {})
           plan_self(:smart_proxy_id => smart_proxy.id,
                     :environment_id => options[:environment]&.id,

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

@@ -44,10 +44,6 @@ module Actions
             plan_action(SyncCapsule, smart_proxy, refresh_options)
           end
         end
-
-        def rescue_strategy
-          Dynflow::Action::Rescue::Skip
-        end
       end
     end
   end

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

@@ -11,19 +11,23 @@ module Actions
           skip_metadata_check = options.fetch(:skip_metadata_check, false)
 
           smart_proxy_helper = ::Katello::SmartProxyHelper.new(smart_proxy)
-          concurrence do
-            smart_proxy_helper.repos_available_to_capsule(environment, content_view, repository).each do |repo|
-              plan_pulp_action([Actions::Pulp::Orchestration::Repository::SmartProxySync,
-                                Actions::Pulp3::CapsuleContent::Sync],
-                                 repo, smart_proxy,
-                                 skip_metadata_check: skip_metadata_check)
+          sequence do
+            smart_proxy_helper.repos_available_to_capsule(environment, content_view, repository).in_groups_of(Setting[:foreman_proxy_content_batch_size], false) do |repos|
+              concurrence do
+                repos.each do |repo|
+                  plan_pulp_action([Actions::Pulp::Orchestration::Repository::SmartProxySync,
+                                    Actions::Pulp3::CapsuleContent::Sync],
+                                     repo, smart_proxy,
+                                     skip_metadata_check: skip_metadata_check)
 
-              if repo.is_a?(::Katello::Repository) &&
-                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)
+                  if repo.is_a?(::Katello::Repository) &&
+                    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)
+                  end
+                end
               end
             end
           end
@@ -32,10 +36,6 @@ module Actions
         def resource_locks
           :link
         end
-
-        def rescue_strategy
-          Dynflow::Action::Rescue::Skip
-        end
       end
     end
   end

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

@@ -80,6 +80,7 @@ module Actions
               added_units = version_output.try(:[], :output).try(:[], :added_units)
               if added_units
                 total_count[:errata_count] = added_units[:erratum].try(:count)
+                total_count[:modulemd_count] = added_units[:modulemd].try(:count)
                 total_count[:rpm_count] = added_units[:rpm].try(:count)
                 total_count[:puppet_module_count] = added_units[:puppet_module].try(:count)
               end
@@ -117,6 +118,10 @@ module Actions
             errata = _(" %{errata_count} Errata" % {:errata_count => total_count[:errata_count]})
             content << errata
           end
+          if total_count[:modulemd_count] && total_count[:modulemd_count] > 0
+            modulemd = _(" %{modulemd_count} Module Stream(s)" % {:modulemd_count => total_count[:modulemd_count]})
+            content << modulemd
+          end
           if total_count[:rpm_count] && total_count[:rpm_count] > 0
             rpm = _(" %{package_count} Package(s)" % {:package_count => total_count[:rpm_count]})
             content << rpm

data/app/lib/actions/katello/content_view/presenters/incremental_updates_presenter.rb

@@ -5,6 +5,7 @@ module Actions
         class IncrementalUpdatesPresenter < Helpers::Presenter::Base
           HUMANIZED_TYPES = {
             ::Katello::Erratum::CONTENT_TYPE => "Errata",
+            ::Katello::ModuleStream::CONTENT_TYPE => "Module Streams",
             ::Katello::Rpm::CONTENT_TYPE => "Packages",
             ::Katello::PuppetModule::CONTENT_TYPE => "Puppet Modules"
           }.freeze
@@ -25,7 +26,7 @@ module Actions
               if cvv
                 humanized_lines << "Content View: #{cvv.content_view.name} version #{cvv.version}"
                 humanized_lines << _("Added Content:")
-                [::Katello::Erratum, ::Katello::Rpm, ::Katello::PuppetModule].each do |content_type|
+                [::Katello::Erratum, ::Katello::ModuleStream, ::Katello::Rpm, ::Katello::PuppetModule].each do |content_type|
                   unless output[:added_units][content_type::CONTENT_TYPE].blank?
                     humanized_lines << "  #{HUMANIZED_TYPES[content_type::CONTENT_TYPE]}:"
                     humanized_lines += output[:added_units][content_type::CONTENT_TYPE].sort.map { |unit| "        #{unit}" }

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

@@ -51,11 +51,19 @@ module Actions
             end
 
             concurrence do
-              repos_to_clone.each do |source_repos|
-                copy_action_outputs += copy_repos(repository_mapping[source_repos],
-                                                  new_content_view_version,
-                                                  content,
-                                                  dep_solve)
+              if SmartProxy.pulp_master.pulp3_support?(repos_to_clone.first.first)
+                extended_repo_mapping = pulp3_repo_mapping(repository_mapping, old_version)
+                unit_map = pulp3_content_mapping(content)
+
+                copy_action_outputs << plan_action(Pulp3::Repository::MultiCopyUnits, extended_repo_mapping, unit_map,
+                                                   dependency_solving: true).output
+              else
+                repos_to_clone.each do |source_repos|
+                  copy_action_outputs += copy_repos(repository_mapping[source_repos],
+                                                    new_content_view_version,
+                                                    content,
+                                                    dep_solve)
+                end
               end
 
               sequence do
@@ -68,11 +76,37 @@ module Actions
             plan_self(:content_view_id => old_version.content_view.id,
                       :new_content_view_version_id => self.new_content_view_version.id,
                       :environment_ids => environments.map(&:id), :user_id => ::User.current.id,
-                      :history_id => history.id, :copy_action_outputs => copy_action_outputs)
+                      :history_id => history.id, :copy_action_outputs => copy_action_outputs,
+                      :old_version => old_version.id)
             promote(new_content_view_version, environments)
           end
         end
 
+        def pulp3_content_mapping(content)
+          units = ::Katello::Erratum.with_identifiers(content[:errata_ids]) +
+            ::Katello::Rpm.with_identifiers(content[:package_ids])
+          unit_map = { :errata => [], :rpms => [] }
+          units.each do |unit|
+            if unit.class.name == "Katello::Erratum"
+              unit_map[:errata] << unit.id
+            elsif unit.class.name == "Katello::Rpm"
+              unit_map[:rpms] << unit.id
+            end
+          end
+          unit_map
+        end
+
+        def pulp3_repo_mapping(repo_mapping, old_version)
+          pulp3_repo_mapping = {}
+          repo_mapping.each do |source_repo, dest_repo|
+            source_repo = source_repo.first.library_instance? ? source_repo : [source_repo.first.library_instance]
+            pulp3_repo_mapping[source_repo.first.id] = { dest_repo: dest_repo.id,
+                                                         base_version: pulp3_dest_base_version(
+                                                           ::Katello::ContentViewVersion.find(old_version.id), dest_repo) }
+          end
+          pulp3_repo_mapping
+        end
+
         def repos_to_copy(old_version, new_components)
           old_version.archived_repos.map do |source_repo|
             components_repo_instances(source_repo, new_components)
@@ -142,22 +176,46 @@ module Actions
                       ::Katello::PuppetModule::CONTENT_TYPE => []
                     }
 
-          input[:copy_action_outputs].each do |copy_output|
-            copy_output[:pulp_tasks].each do |pulp_task|
-              pulp_task[:result][:units_successful].each do |unit|
-                type = unit['type_id']
-                unit = unit['unit_key']
-                case type
-                when ::Katello::Erratum::CONTENT_TYPE
-                  content[::Katello::Erratum::CONTENT_TYPE] << unit['id']
-                when ::Katello::ModuleStream::CONTENT_TYPE
-                  content[::Katello::ModuleStream::CONTENT_TYPE] << "#{unit['name']}:#{unit['stream']}:#{unit['version']}"
-                when ::Katello::Rpm::CONTENT_TYPE
-                  content[::Katello::Rpm::CONTENT_TYPE] << ::Katello::Util::Package.build_nvra(unit)
-                when ::Katello::Deb::CONTENT_TYPE
-                  content[::Katello::Deb::CONTENT_TYPE] << "#{unit['name']}_#{unit['version']}_#{unit['architecture']}"
-                when ::Katello::PuppetModule::CONTENT_TYPE
-                  content[::Katello::PuppetModule::CONTENT_TYPE] << "#{unit['author']}-#{unit['name']}-#{unit['version']}"
+          base_repos = ::Katello::ContentViewVersion.find(input[:old_version]).repositories
+          new_repos = ::Katello::ContentViewVersion.find(input[:new_content_view_version_id]).repositories
+
+          if input[:copy_action_outputs].last[:pulp_tasks].last[:pulp_href]&.include?("/pulp/api/v3/")
+            new_repos.each do |new_repo|
+              matched_old_repo = base_repos.where(root_id: new_repo.root_id).first
+
+              new_errata = new_repo.errata - matched_old_repo.errata
+              new_module_streams = new_repo.module_streams - matched_old_repo.module_streams
+              new_rpms = new_repo.rpms - matched_old_repo.rpms
+
+              new_errata.each do |erratum|
+                content[::Katello::Erratum::CONTENT_TYPE] << erratum.errata_id
+              end
+              new_module_streams.each do |module_stream|
+                content[::Katello::ModuleStream::CONTENT_TYPE] <<
+                  "#{module_stream.name}:#{module_stream.stream}:#{module_stream.version}"
+              end
+              new_rpms.each do |rpm|
+                content[::Katello::Rpm::CONTENT_TYPE] << rpm.nvra
+              end
+            end
+          else
+            input[:copy_action_outputs].each do |copy_output|
+              copy_output[:pulp_tasks].each do |pulp_task|
+                pulp_task[:result][:units_successful].each do |unit|
+                  type = unit['type_id']
+                  unit = unit['unit_key']
+                  case type
+                  when ::Katello::Erratum::CONTENT_TYPE
+                    content[::Katello::Erratum::CONTENT_TYPE] << unit['id']
+                  when ::Katello::ModuleStream::CONTENT_TYPE
+                    content[::Katello::ModuleStream::CONTENT_TYPE] << "#{unit['name']}:#{unit['stream']}:#{unit['version']}"
+                  when ::Katello::Rpm::CONTENT_TYPE
+                    content[::Katello::Rpm::CONTENT_TYPE] << ::Katello::Util::Package.build_nvra(unit)
+                  when ::Katello::Deb::CONTENT_TYPE
+                    content[::Katello::Deb::CONTENT_TYPE] << "#{unit['name']}_#{unit['version']}_#{unit['architecture']}"
+                  when ::Katello::PuppetModule::CONTENT_TYPE
+                    content[::Katello::PuppetModule::CONTENT_TYPE] << "#{unit['author']}-#{unit['name']}-#{unit['version']}"
+                  end
                 end
               end
             end
@@ -174,10 +232,12 @@ module Actions
           history.status = ::Katello::ContentViewHistory::SUCCESSFUL
           history.save!
 
-          version.repositories.each do |repo|
-            SmartProxy.pulp_master.pulp_api.extensions.send(:module_default).
-              copy(repo.library_instance.pulp_id,
-              repo.pulp_id)
+          unless SmartProxy.pulp_master.pulp3_support?(version.repositories.first)
+            version.repositories.each do |repo|
+              SmartProxy.pulp_master.pulp_api.extensions.send(:module_default).
+                copy(repo.library_instance.pulp_id,
+                repo.pulp_id)
+            end
           end
         end
 
@@ -255,6 +315,10 @@ module Actions
           copy_outputs
         end
 
+        def pulp3_dest_base_version(old_cvv, new_repo)
+          old_cvv.repositories.archived.find_by(root_id: new_repo.root_id).version_href.split("/")[-1].to_i
+        end
+
         def copy_yum_content(new_repo, dep_solve, package_ids, errata_ids)
           copy_outputs = []
           if new_repo.content_type == ::Katello::Repository::YUM_TYPE