katello 3.16.0.rc4 → 3.16.0.rc4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 590a33ff3016ad29aaeca6e8d5a0c967b9053a01cf3dbf8f28fcb68b63d056bd
-  data.tar.gz: e8c30ca9e88f472f3aabf89b7f2cc3c6122750706e9bdfbb9d1cfa8aa957d4a5
+  metadata.gz: 3206fcf99b7e7aa7a1fcbb9b6231173193f89ba0099c5e46f6226b5fc044bc8b
+  data.tar.gz: c5ffbe4836c0958563e1448657a5fbc7d8a684ed2a647b19f933728e2436fe5f
 SHA512:
-  metadata.gz: 2fbba71f828db21edacf4100aac226a638fa7c6dd59871f6d0f029846af27ff54914c803798fd6054463ae4f44bbfc29d9466fca8a19867e63c10486668ce30c
-  data.tar.gz: 17347500daf6bb1b2dd1ff7126b97e84f2120e1c12e23066036d2f30402cdb9018dc5c6cb1f74ceff441f069a2733dceb4e3a4958032237034eaff5783915b49
+  metadata.gz: c01c07349a208003082823e8a0b50e5d0920506a6b72db57c811c8c13d934cba35ec92f3c3b7088770e6e8f21efca6cd22560380c8838900d7c2fdf99501ebcd
+  data.tar.gz: fc2bbb3bab3ac2e163bea0b97941e0fac8d48831d276af542a059ba03cae395c396010ec8a65e3e0a5150bb6032a9d0e1458c848c17a9e74dbd8a4d429f95729

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

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/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/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

data/app/lib/actions/pulp/abstract_async_task.rb

@@ -74,6 +74,7 @@ module Actions
       end
 
       def cancel!
+        output[:cancelled] = true
         cancel
         self.external_task = poll_external_task
         # We suspend the action and the polling will take care of finding

data/app/lib/actions/pulp/consumer/sync_capsule.rb

@@ -26,6 +26,14 @@ module Actions
           self.done? ? 1 : 0.1
         end
 
+        def rescue_strategy_for_self
+          if output[:cancelled]
+            Dynflow::Action::Rescue::Fail
+          else
+            Dynflow::Action::Rescue::Skip
+          end
+        end
+
         def run_progress_weight
           100
         end

data/app/lib/actions/pulp/repository/presenters/deb_presenter.rb

@@ -54,11 +54,11 @@ module Actions
           end
 
           def items_done
-            task_details&.inject(0) { |sum, details| sum + details[:num_success].to_i }
+            task_details&.inject(0) { |sum, details| sum + details[:num_success].to_i } || 0
           end
 
           def items_total
-            task_details&.inject(0) { |sum, details| sum + details[:items_total].to_i }
+            task_details&.inject(0) { |sum, details| sum + details[:items_total].to_i } || 0
           end
 
           def size_done

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

@@ -0,0 +1,48 @@
+module Actions
+  module Pulp3
+    module Repository
+      class MultiCopyUnits < Pulp3::AbstractAsyncTask
+        # repo_map example: {
+        #   <source_repo_id>: {
+        #     dest_repo: <dest_repo_id>,
+        #     base_version: <base_version>
+        #   }
+        # }
+        def plan(repo_map, unit_map, options = {})
+          if unit_map.values.flatten.any?
+            action_output = plan_self(repo_map: repo_map,
+                      unit_map: unit_map,
+                      dependency_solving: options[:dependency_solving],
+                      incremental_update: options[:incremental_update],
+                      smart_proxy_id: SmartProxy.pulp_master.id).output
+            plan_action(Pulp3::Repository::SaveVersions, repo_map.values.pluck(:dest_repo),
+                        tasks: action_output[:pulp_tasks]).output
+          end
+        end
+
+        def invoke_external_task
+          unit_hrefs = []
+          repo_map = input[:repo_map]
+
+          if input[:unit_map][:errata].any?
+            unit_hrefs << ::Katello::RepositoryErratum.
+              joins("inner join katello_errata on katello_repository_errata.erratum_id = katello_errata.id").
+              where("katello_repository_errata.repository_id in (#{repo_map.keys.join(',')}) and
+                    katello_errata.id in (#{input[:unit_map][:errata].join(",")})").map(&:erratum_pulp3_href)
+          end
+
+          if input[:unit_map][:rpms].any?
+            unit_hrefs << ::Katello::Rpm.where(:id => input[:unit_map][:rpms]).map(&:pulp_id)
+          end
+
+          # TODO: Fix this workaround by refactoring copy_units after general content view dep solving is refactored
+          source_repo = ::Katello::Repository.find(repo_map.keys.first)
+          target_repo = ::Katello::Repository.find(repo_map.values.first[:dest_repo])
+          dest_base_version = repo_map.values.first[:base_version]
+          repo_map.delete(repo_map.keys.first)
+          output[:pulp_tasks] = target_repo.backend_service(SmartProxy.pulp_master).copy_units(source_repo, unit_hrefs.flatten, input[:dependency_solving], dest_base_version, repo_map)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Actions
+  module Pulp3
+    module Repository
+      class SaveVersions < Pulp3::Abstract
+        def plan(repository_ids, options)
+          plan_self(:repository_ids => repository_ids, :tasks => options[:tasks])
+        end
+
+        def run
+          version_hrefs = input[:tasks].last[:created_resources]
+          repositories = input[:repository_ids].collect do |repo_id|
+            ::Katello::Repository.find(repo_id)
+          end
+
+          output[:contents_changed] = false
+          output[:updated_repositories] = []
+          repositories.each do |repo|
+            # Chop off the version number to compare base repo strings
+            unversioned_href = repo.version_href[0..-2].rpartition('/').first
+            new_version_href = version_hrefs.detect do |version_href|
+              unversioned_href == version_href[0..-2].rpartition('/').first
+            end
+            # Successive incremental updates won't generate a new repo version, so fetch the latest Pulp 3 repo version
+            new_version_href ||= ::Katello::Pulp3::Api::Yum.new(SmartProxy.pulp_master!).
+              repositories_api.read(repo.backend_service(SmartProxy.pulp_master).
+              repository_reference.repository_href).latest_version_href
+
+            unless new_version_href == repo.version_href
+              repo.update(version_href: new_version_href)
+              repo.index_content
+              output[:contents_changed] = true
+              output[:updated_repositories] << repo.id
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,20 +3,6 @@ module Katello
     module BaseTemplateScopeExtensions
       extend ActiveSupport::Concern
 
-      module Overrides
-        def allowed_helpers
-          super + [:errata, :host_subscriptions, :host_applicable_errata_ids, :host_applicable_errata_filtered,
-                   :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, :registered_at]
-        end
-      end
-
-      included do
-        prepend Overrides
-      end
-
       def errata(id)
         Katello::Erratum.in_repositories(Katello::Repository.readable).with_identifiers(id).map(&:attributes).first.slice!('created_at', 'updated_at')
       end

data/app/models/katello/glue/pulp/repo.rb

@@ -90,6 +90,7 @@ module Katello
       def pulp_counts_differ?
         pulp_counts = pulp_repo_facts[:content_unit_counts]
         rpms.count != pulp_counts['rpm'].to_i ||
+          srpms.count != pulp_counts['srpm'].to_i ||
           errata.count != pulp_counts['erratum'].to_i ||
           package_groups.count != pulp_counts['package_group'].to_i ||
           puppet_modules.count != pulp_counts['puppet_module'].to_i ||

data/app/models/katello/host/content_facet.rb

@@ -47,11 +47,13 @@ module Katello
         bindable_paths = bindable_types
         relative_paths = []
 
-        paths.each do |path|
+        # paths == ["/pulp/repos/Default_Organization/Library/custom/Test_product/test2",
+        # "/pulp/repos/Default_Organization/Library/custom/Test_product/My_repo"]
+        paths.each do |absolute_path|
           bindable_paths.each do |supported|
-            relative_path = path.gsub(supported[:matcher], '')
-            relative_paths << relative_path
-            if path.starts_with?(supported[:matcher])
+            relative_path = absolute_path.gsub(supported[:matcher], '') # remove e.g. '/pulp/repos/' from beginning of string
+            relative_paths << relative_path unless relative_path == absolute_path
+            if absolute_path.starts_with?(supported[:matcher])
               supported[:paths] << relative_path
               break
             end
@@ -60,10 +62,12 @@ module Katello
 
         repos = bindable_paths.flat_map do |supported|
           repos = Repository.joins(:root).where(RootRepository.table_name => {content_type: supported[:type]}, relative_path: supported[:paths])
-          relative_paths -= repos.pluck(:relative_path)
+          relative_paths -= repos.pluck(:relative_path) # remove relative paths that match our repos
           repos
         end
 
+        # Any leftover relative paths do not match the repos we've just retrieved from the db,
+        # so we should log warnings about them.
         relative_paths.each do |repo_path|
           Rails.logger.warn("System #{self.host.name} (#{self.host.id}) requested binding to unknown repo #{repo_path}")
         end
@@ -121,6 +125,7 @@ module Katello
         ::Katello::Applicability::ApplicableContentHelper.new(self, ::Katello::Rpm, bound_repos).calculate_and_import
         ::Katello::Applicability::ApplicableContentHelper.new(self, ::Katello::Erratum, bound_repos).calculate_and_import
         ::Katello::Applicability::ApplicableContentHelper.new(self, ::Katello::ModuleStream, bound_repos).calculate_and_import
+        update_applicability_counts
       end
 
       def import_applicability(partial = false)

data/app/models/setting/content.rb

@@ -2,7 +2,7 @@ class Setting::Content < Setting
   #rubocop:disable Metrics/MethodLength
   #rubocop:disable Metrics/AbcSize
 
-  validate :content_default_http_proxy, if: proc { |s| s.name == 'content_default_http_proxy' }
+  validate :content_default_http_proxy, if: proc { |s| s.name == 'content_default_http_proxy' && HttpProxy.table_exists? }
 
   after_save :add_organizations_and_locations_if_global_http_proxy
 
@@ -91,6 +91,8 @@ class Setting::Content < Setting
                false, N_('Restrict Composite Content View promotion')),
       self.set('check_services_before_actions', N_("Whether or not to check the status of backend services such as pulp and candlepin prior to performing some actions."),
                true, N_('Check services before actions')),
+      self.set('foreman_proxy_content_batch_size', N_("How many repositories should be synced concurrently on the capsule.  A smaller number may lead to longer sync times.  A larger number will increase dynflow load."),
+               25, N_('Batch size to sync repositories in.')),
       self.set('foreman_proxy_content_auto_sync', N_("Whether or not to auto sync the Smart Proxies after a Content View promotion."),
                true, N_('Sync Smart Proxies after Content View promotion')),
       self.set('default_download_policy', N_("Default download policy for custom repositories (either 'immediate', 'on_demand', or 'background')"), "immediate",

data/app/services/katello/pulp3/repository/yum.rb

@@ -70,28 +70,54 @@ module Katello
           "/pulp/repos/#{repo.relative_path}/".sub('//', '/')
         end
 
-        def copy_units(source_repository_version_href, content_unit_hrefs, dependency_solving)
+        def copy_units(source_repository, content_unit_hrefs, dependency_solving, dest_base_version = 0,
+                       additional_repo_map = {})
           tasks = []
 
+          content_unit_hrefs.sort!
           if content_unit_hrefs.any?
             data = PulpRpmClient::Copy.new
-            data.config = [
-              source_repo_version: source_repository_version_href,
+            data.config = [{
+              source_repo_version: source_repository.version_href,
               dest_repo: repository_reference.repository_href,
-              dest_base_version: 0,
-              content: content_unit_hrefs.sort
-            ]
+              dest_base_version: dest_base_version,
+              content: content_unit_hrefs
+            }]
             data.dependency_solving = dependency_solving
+            if dependency_solving
+              # repo_map example: {
+              #   <source_repo_id>: {
+              #     dest_repo: <dest_repo_id>,
+              #     base_version: <base_version>
+              #   }
+              # }
+              additional_repo_map.each do |source_repo, dest_repo_map|
+                source_repo_version = ::Katello::Repository.find(source_repo).version_href
+
+                dest_repo = ::Katello::Repository.find(dest_repo_map[:dest_repo])
+                dest_repo_href = ::Katello::Pulp3::Repository::Yum.new(dest_repo, SmartProxy.pulp_master).repository_reference.repository_href
+                data.config << {
+                  source_repo_version: source_repo_version,
+                  dest_repo: dest_repo_href,
+                  dest_base_version: dest_repo_map[:base_version],
+                  content: content_unit_hrefs
+                }
+              end
+            end
             tasks << api.copy_api.copy_content(data)
           else
-            data = PulpRpmClient::RepositoryAddRemoveContent.new(
-              remove_content_units: ['*'])
-            tasks << api.repositories_api.modify(repository_reference.repository_href, data)
+            tasks << remove_all_content
           end
 
           tasks
         end
 
+        def remove_all_content
+          data = PulpRpmClient::RepositoryAddRemoveContent.new(
+            remove_content_units: ['*'])
+          api.repositories_api.modify(repository_reference.repository_href, data)
+        end
+
         def packageenvironments(options = {})
           api.content_package_environments_api.list(options)
         end
@@ -133,7 +159,7 @@ module Katello
           content_unit_hrefs += source_repository.srpms.pluck(:pulp_id)
 
           dependency_solving = options[:solve_dependencies] || false
-          copy_units(source_repository.version_href, content_unit_hrefs.uniq, dependency_solving)
+          copy_units(source_repository, content_unit_hrefs.uniq, dependency_solving)
         end
 
         def additional_content_hrefs(source_repository, content_unit_hrefs)
@@ -158,11 +184,6 @@ module Katello
             repo_service.distributiontrees(options).results, content_unit_hrefs)
           content_unit_hrefs + distribution_tree_hrefs_to_include
         end
-
-        def regenerate_applicability
-          # TODO
-          fail NotImplementedError
-        end
       end
     end
   end

data/engines/bastion_katello/app/assets/javascripts/bastion_katello/errata/errata.routes.js

@@ -9,7 +9,7 @@
  */
 angular.module('Bastion.errata').config(['$stateProvider', function ($stateProvider) {
     $stateProvider.state('errata', {
-        url: '/errata',
+        url: '/errata?repositoryId',
         permission: ['view_products', 'view_content_views'],
         views: {
           '@': {

data/engines/bastion_katello/app/assets/stylesheets/bastion_katello/bastion_katello.scss

@@ -67,4 +67,8 @@
 
 .popover-large {
   max-width: 100%;
+}
+
+.uib-increment, .uib-decrement {
+  text-align: center;
 }

data/lib/katello/engine.rb

@@ -154,7 +154,6 @@ module Katello
 
       # Lib Extensions
       ::Foreman::Renderer::Scope::Variables::Base.include Katello::Concerns::RendererExtensions
-      ::Foreman::Renderer::Scope::Base.include Katello::Concerns::BaseTemplateScopeExtensions
 
       # Model extensions
       ::Environment.include Katello::Concerns::EnvironmentExtensions

data/lib/katello/plugin.rb

@@ -220,6 +220,8 @@ Foreman::Plugin.register :katello do
 
   allowed_template_helpers :subscription_manager_configuration_url, :repository_url
   extend_template_helpers Katello::KatelloUrlsHelper
+  extend_template_helpers Katello::Concerns::BaseTemplateScopeExtensions
+
   register_global_js_file 'fills'
 
   search_path_override("Katello") do |resource|

data/lib/katello/version.rb

@@ -1,3 +1,3 @@
 module Katello
-  VERSION = "3.16.0.rc4".freeze
+  VERSION = "3.16.0.rc4.1".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: katello
 version: !ruby/object:Gem::Version
-  version: 3.16.0.rc4
+  version: 3.16.0.rc4.1
 platform: ruby
 authors:
 - N/A
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-01 00:00:00.000000000 Z
+date: 2020-07-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -699,6 +699,7 @@ files:
 - app/controllers/katello/application_controller.rb
 - app/controllers/katello/auto_complete_search_controller.rb
 - app/controllers/katello/concerns/api/api_controller.rb
+- app/controllers/katello/concerns/api/v2/associations_permission_check.rb
 - app/controllers/katello/concerns/api/v2/bulk_hosts_extensions.rb
 - app/controllers/katello/concerns/api/v2/content_overrides_controller.rb
 - app/controllers/katello/concerns/api/v2/hostgroups_controller_extensions.rb
@@ -1014,6 +1015,7 @@ files:
 - app/lib/actions/pulp3/repository/delete_remote.rb
 - app/lib/actions/pulp3/repository/delete_version.rb
 - app/lib/actions/pulp3/repository/import_upload.rb
+- app/lib/actions/pulp3/repository/multi_copy_units.rb
 - app/lib/actions/pulp3/repository/presenters/abstract_sync_presenter.rb
 - app/lib/actions/pulp3/repository/presenters/content_unit_presenter.rb
 - app/lib/actions/pulp3/repository/refresh_distribution.rb
@@ -1022,6 +1024,7 @@ files:
 - app/lib/actions/pulp3/repository/save_distribution_references.rb
 - app/lib/actions/pulp3/repository/save_publication.rb
 - app/lib/actions/pulp3/repository/save_version.rb
+- app/lib/actions/pulp3/repository/save_versions.rb
 - app/lib/actions/pulp3/repository/sync.rb
 - app/lib/actions/pulp3/repository/update_cv_repository_cert_guard.rb
 - app/lib/actions/pulp3/repository/update_distributions.rb