katello 4.2.0.1.rc2 → 4.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 27a69c642aae16f1d0c623a4b236b981c1b09c0e78a304555d130a745983ebbc
-  data.tar.gz: aac4bfc71c9bbb798750fbbe27d545aa7a5b4586488598a4fc27fac1c513ddaa
+  metadata.gz: 3cdba19f418c59dd75998081c306267defc02548958e1c48b38db4db29f2c633
+  data.tar.gz: 96f3ff300309604144e935295d3d8f859f757a694cde91768f773a63dfde1106
 SHA512:
-  metadata.gz: 5427524abdae177c66bae610c182e1a58a116ef21198984d9f99b8b03d2615214d8820eca5a7a5cac6fbfea88afa7c8722110529aea86fc8f171f9423143eae2
-  data.tar.gz: 479223ec1f930a5f25adf8c6a97b423a47e6b09871a1cc75c5aaac418b0d6246cb7069d7c11df5ff428f78c2cfc75925d36625a716500bea4e2c7e7723f8f03b
+  metadata.gz: e793a484c717492274ee01345a14ccefb4ddad648a0db9b3615232a9b329f8681c1208ccabc21e382d7343bd5a812703db1a9840f59fe895bce42637a125c67f
+  data.tar.gz: f9a960acb16529071412b353e79c392cb0c79d8cb4f5f001d67b8ddc64056c80d8e9fd51ead49fce0d8f04918063ee95f31856608ddcef013eb22a70cb827f20

data/app/assets/javascripts/katello/hosts/host_and_hostgroup_edit.js

@@ -4,7 +4,7 @@ KT.hosts = {};
 $(document).on('ContentLoad', function(){
     KT.hosts.onKatelloHostEditLoad();
     window.tfm.hosts.registerPluginAttributes("os",
-         ['lifecycle_environment_id', 'content_view_id', 'environment_id', 'content_source_id', 'architecture_id']);
+         ['lifecycle_environment_id', 'content_view_id', 'environment_id', 'content_source_id', 'architecture_id', 'parent_id']);
 
     $("#hostgroup_lifecycle_environment_id").change(KT.hosts.environmentChanged);
     $("#host_lifecycle_environment_id").change(KT.hosts.environmentChanged);
@@ -27,13 +27,15 @@ KT.hosts.fetchContentViews = function () {
     var envId = KT.hosts.getSelectedEnvironment();
     var option;
     var previous_view = KT.hosts.getSelectedContentView();
-
+    var previousInheritViewText = select.find('option:first-child').text();
     select.find('option').remove();
     if (envId) {
         KT.hosts.signalContentViewFetch(true);
         var url = tfm.tools.foremanUrl('/katello/api/v2/content_views/');
         $.get(url, {environment_id: envId, full_result: true}, function (data) {
-            select.append($("<option />"));
+            if ($('#hostgroup_parent_id').length > 0) {
+                select.append($("<option />").text(previousInheritViewText).val(''));
+            }
             $.each(data.results, function(index, view) {
                 option = $("<option />").val(view.id).text(view.name);
                 if (view.id === parseInt(previous_view)) {
@@ -41,6 +43,7 @@ KT.hosts.fetchContentViews = function () {
                 }
                 select.append(option);
             });
+            select.trigger('change');
             KT.hosts.signalContentViewFetch(false);
         });
     }

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

@@ -15,9 +15,12 @@ module Katello
       fail Katello::Errors::InvalidRepositoryContent, _("Cannot upload Ansible collections.") if @repository.ansible_collection?
       content_type = params[:content_type] || ::Katello::RepositoryTypeManager.find(@repository.content_type)&.default_managed_content_type&.label
       RepositoryTypeManager.check_content_matches_repo_type!(@repository, content_type)
-
-      unit_type_id = SmartProxy.pulp_primary.content_service(content_type).content_type
-      render :json => @repository.backend_content_service(::SmartProxy.pulp_primary).create_upload(params[:size], params[:checksum], unit_type_id)
+      if ::Katello::RepositoryTypeManager.generic_content_type?(content_type)
+        unit_type_id = content_type
+      else
+        unit_type_id = SmartProxy.pulp_primary.content_service(content_type).content_type
+      end
+      render :json => @repository.backend_content_service(::SmartProxy.pulp_primary).create_upload(params[:size], params[:checksum], unit_type_id, @repository)
     end
 
     api :PUT, "/repositories/:repository_id/content_uploads/:id", N_("Upload a chunk of the file's content")

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

@@ -124,7 +124,8 @@ module Katello
       validate_content(params[:add_content])
       resolve_dependencies = params.fetch(:resolve_dependencies, true)
       task = async_task(::Actions::Katello::ContentView::IncrementalUpdates, @content_view_version_environments, @composite_version_environments,
-                        params[:add_content], resolve_dependencies, hosts, params[:description])
+                        params[:add_content], resolve_dependencies, hosts, params[:description],
+                        Setting[:remote_execution_by_default] && ::Katello.with_remote_execution?)
       respond_for_async :resource => task
     end
 

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

@@ -0,0 +1,26 @@
+module Katello
+  class Api::V2::GenericContentUnitsController < Api::V2::ApiController
+    Katello::RepositoryTypeManager.generic_content_types(enabled_only: false).each do |type|
+      apipie_concern_subst(:a_resource => N_(type), :resource_id => type.pluralize)
+      resource_description do
+        name type.pluralize.titleize
+      end
+    end
+
+    include Katello::Concerns::Api::V2::RepositoryContentController
+
+    def default_sort
+      %w(name asc)
+    end
+
+    def resource_class
+      ::Katello::GenericContentUnit.where(content_type: params[:content_type].singularize)
+    end
+
+    private
+
+    def repo_association
+      :repository_id
+    end
+  end
+end

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

@@ -56,6 +56,7 @@ module Katello
       param :verify_ssl_on_sync, :bool, :desc => N_("if true, Katello will verify the upstream url's SSL certifcates are signed by a trusted CA")
       param :upstream_username, String, :desc => N_("Username of the upstream repository user used for authentication")
       param :upstream_password, String, :desc => N_("Password of the upstream repository user used for authentication")
+      param :upstream_authentication_token, String, :desc => N_("Password of the upstream authentication token.")
       param :ostree_upstream_sync_policy, ::Katello::RootRepository::OSTREE_UPSTREAM_SYNC_POLICIES, :desc => N_("policies for syncing upstream ostree repositories")
       param :ostree_upstream_sync_depth, :number, :desc => N_("if a custom sync policy is chosen for ostree repositories then a 'depth' value must be provided")
       param :deb_releases, String, :desc => N_("whitespace-separated list of releases to be synced from deb-archive")
@@ -462,10 +463,11 @@ module Katello
 
     # rubocop:disable Metrics/CyclomaticComplexity
     def repository_params
-      keys = [:download_policy, :mirror_on_sync, :arch, :verify_ssl_on_sync, :upstream_password, :upstream_username, :download_concurrency,
+      keys = [:download_policy, :mirror_on_sync, :arch, :verify_ssl_on_sync, :upstream_password,
+              :upstream_username, :download_concurrency, :upstream_authentication_token,
               :ostree_upstream_sync_depth, :ostree_upstream_sync_policy, {:os_versions => []},
-              :deb_releases, :deb_components, :deb_architectures, :description, :http_proxy_policy, :http_proxy_id, :retain_package_versions_count,
-              {:ignorable_content => []}
+              :deb_releases, :deb_components, :deb_architectures, :description, :http_proxy_policy,
+              :http_proxy_id, :retain_package_versions_count, {:ignorable_content => []}
              ]
 
       keys += [{:docker_tags_whitelist => []}, :docker_upstream_name] if params[:action] == 'create' || @repository&.docker?
@@ -512,6 +514,7 @@ module Katello
       root.verify_ssl_on_sync = ::Foreman::Cast.to_bool(repo_params[:verify_ssl_on_sync]) if repo_params.key?(:verify_ssl_on_sync)
       root.upstream_username = repo_params[:upstream_username] if repo_params.key?(:upstream_username)
       root.upstream_password = repo_params[:upstream_password] if repo_params.key?(:upstream_password)
+      root.upstream_authentication_token = repo_params[:upstream_authentication_token] if repo_params.key?(:upstream_authentication_token)
       root.ignorable_content = repo_params[:ignorable_content] if root.yum? && repo_params.key?(:ignorable_content)
       root.http_proxy_policy = repo_params[:http_proxy_policy] if repo_params.key?(:http_proxy_policy)
       root.http_proxy_id = repo_params[:http_proxy_id] if repo_params.key?(:http_proxy_id)
@@ -563,12 +566,21 @@ module Katello
       content_type = params[:content_type]
 
       if content_type
+        RepositoryTypeManager.check_content_matches_repo_type!(@repository, params[:content_type]) if params[:content_type]
         @content = @repository.units_for_removal(params[:ids], content_type)
       else
         @content = @repository.units_for_removal(params[:ids])
       end
 
-      RepositoryTypeManager.check_content_matches_repo_type!(@repository, @content.first.class::CONTENT_TYPE)
+      if @repository.generic?
+        if content_type
+          RepositoryTypeManager.check_content_matches_repo_type!(@repository, @content.first.content_type)
+        else
+          RepositoryTypeManager.check_content_matches_repo_type!(@repository, @repository.repository_type.default_managed_content_type.label)
+        end
+      else
+        RepositoryTypeManager.check_content_matches_repo_type!(@repository, @content.first.class::CONTENT_TYPE)
+      end
     end
 
     def filter_by_content_view(query, content_view_id, environment_id, is_available_for)

data/app/helpers/katello/content_view_helper.rb

@@ -1,10 +1,10 @@
 module Katello
   module ContentViewHelper
-    def separated_repo_mapping(repo_mapping)
-      separated_mapping = { :pulp3_yum => {}, :other => {} }
+    def separated_repo_mapping(repo_mapping, use_multicopy_actions)
+      separated_mapping = { :pulp3_yum_multicopy => {}, :other => {} }
       repo_mapping.each do |source_repos, dest_repo|
-        if dest_repo.content_type == "yum" && SmartProxy.pulp_primary.pulp3_support?(dest_repo)
-          separated_mapping[:pulp3_yum][source_repos] = dest_repo
+        if dest_repo.content_type == "yum" && SmartProxy.pulp_primary.pulp3_support?(dest_repo) && use_multicopy_actions
+          separated_mapping[:pulp3_yum_multicopy][source_repos] = dest_repo
         else
           separated_mapping[:other][source_repos] = dest_repo
         end

data/app/helpers/katello/hosts_and_hostgroups_helper.rb

@@ -58,19 +58,19 @@ module Katello
     end
 
     def fetch_lifecycle_environment(host, options = {})
-      return host.lifecycle_environment if host.lifecycle_environment.present?
+      return host.lifecycle_environment if host.try(:lifecycle_environment_id)
       selected_host_group = options.fetch(:selected_host_group, nil)
       return selected_host_group.lifecycle_environment if selected_host_group.present?
     end
 
     def fetch_content_view(host, options = {})
-      return host.content_view if host.content_view.present?
+      return host.content_view if host.try(:content_view_id)
       selected_host_group = options.fetch(:selected_host_group, nil)
       return selected_host_group.content_view if selected_host_group.present?
     end
 
     def fetch_content_source(host, options = {})
-      return host.content_source if host.content_source.present?
+      return host.content_source if host.try(:content_source_id)
       selected_host_group = options.fetch(:selected_host_group, nil)
       return selected_host_group.content_source if selected_host_group.present?
     end
@@ -216,11 +216,15 @@ module Katello
         new_host.operatingsystem.kickstart_repos(new_host).map { |repo| OpenStruct.new(repo) }
       else
         # case 2
-        os_updated_kickstart_options(host)
+        os_updated_kickstart_options
       end
     end
 
-    def os_updated_kickstart_options(host)
+    def fetch_inherited_param(id, entity, parent_value)
+      id.blank? ? parent_value : entity.find(id)
+    end
+
+    def os_updated_kickstart_options(host = nil)
       # this method gets called in 1 place Once you chose a diff os/content source/arch/lifecycle env/cv
       # via the os_selected method.
       # In this case we want it play by the rules of "one of these params" and
@@ -228,19 +232,22 @@ module Katello
       os_selection_params = ["operatingsystem_id", 'content_view_id', 'lifecycle_environment_id',
                              'content_source_id', 'architecture_id']
       view_options = []
+
       host_params = params[:hostgroup] || params[:host]
-      if host_params && os_selection_params.all? { |key| host_params[key].present? }
+      parent = ::Hostgroup.find(host_params[:parent_id]) unless host_params.blank? || host_params[:parent_id].blank?
+      if host_params && (parent || os_selection_params.all? { |key| host_params[key].present? })
         if host.nil?
           host = ::Host.new
         end
-        host.operatingsystem = Operatingsystem.find(host_params[:operatingsystem_id])
-        host.architecture = Architecture.find(host_params[:architecture_id])
+        host.operatingsystem = fetch_inherited_param(host_params[:operatingsystem_id], ::Operatingsystem, parent&.os)
+        host.architecture = fetch_inherited_param(host_params[:architecture_id], ::Architecture, parent&.architecture)
+        lifecycle_env = fetch_inherited_param(host_params[:lifecycle_environment_id], ::Katello::KTEnvironment, parent&.lifecycle_environment)
+        content_view = fetch_inherited_param(host_params[:content_view_id], ::Katello::ContentView, parent&.content_view)
+        content_source = fetch_inherited_param(host_params[:content_source_id], ::SmartProxy, parent&.content_source)
 
-        lifecycle_env = Katello::KTEnvironment.find(host_params[:lifecycle_environment_id])
-        content_view = Katello::ContentView.find(host_params[:content_view_id])
         host.content_facet = Host::ContentFacet.new(:lifecycle_environment_id => lifecycle_env.id,
                                                     :content_view_id => content_view.id,
-                                                    :content_source => SmartProxy.find(host_params[:content_source_id]))
+                                                    :content_source => content_source)
         if host.operatingsystem.is_a?(Redhat)
           view_options = host.operatingsystem.kickstart_repos(host).map { |repo| OpenStruct.new(repo) }
         end

data/app/lib/actions/katello/activation_key/destroy.rb

@@ -6,7 +6,7 @@ module Actions
           skip_candlepin = options.fetch(:skip_candlepin, false)
           action_subject(activation_key)
 
-          plan_action(Candlepin::ActivationKey::Destroy, cp_id: activation_key.cp_id) unless skip_candlepin
+          plan_action(Candlepin::ActivationKey::Destroy, cp_id: activation_key.cp_id) if !skip_candlepin && activation_key.cp_id.present?
           plan_self
         end
 

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

@@ -40,7 +40,7 @@ module Actions
             pulp_repo = repo.backend_service(smart_proxy)
             if !current_repos_on_capsule_ids.include?(repo.id)
               pulp_repo.create_mirror_entities
-            elsif pulp_repo.mirror_needs_updates?
+            else
               tasks += pulp_repo.refresh_mirror_entities
             end
           end

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

@@ -4,6 +4,7 @@ module Actions
       class SyncCapsule < ::Actions::EntryAction
         include Actions::Katello::PulpSelector
         def plan(smart_proxy, options = {})
+          plan_self(:smart_proxy_id => smart_proxy.id)
           action_subject(smart_proxy)
           environment = options[:environment]
           content_view = options[:content_view]
@@ -11,6 +12,7 @@ module Actions
           skip_metadata_check = options.fetch(:skip_metadata_check, false)
           sequence do
             repos = repos_to_sync(smart_proxy, environment, content_view, repository, skip_metadata_check)
+            return nil if repos.empty?
 
             repos.in_groups_of(Setting[:foreman_proxy_content_batch_size], false) do |repo_batch|
               concurrence do
@@ -36,53 +38,6 @@ module Actions
               end
             end
           end
-          sync_container_gateway(smart_proxy)
-        end
-
-        def sync_container_gateway(smart_proxy)
-          if smart_proxy.has_feature?(::SmartProxy::CONTAINER_GATEWAY_FEATURE)
-            update_container_repo_list(smart_proxy)
-            users = smart_proxy.container_gateway_users
-            update_user_container_repo_mapping(smart_proxy, users) if users.any?
-          end
-        end
-
-        def unauthenticated_container_repositories
-          ::Katello::Repository.joins(:environment).where("#{::Katello::KTEnvironment.table_name}.registry_unauthenticated_pull" => true).select(:id).pluck(:id)
-        end
-
-        def update_container_repo_list(smart_proxy)
-          # [{ repository: "repoA", auth_required: false }]
-          repo_list = []
-          ::Katello::SmartProxyHelper.new(smart_proxy).combined_repos_available_to_capsule.each do |repo|
-            if repo.docker? && !repo.container_repository_name.nil?
-              repo_list << { repository: repo.container_repository_name,
-                             auth_required: !unauthenticated_container_repositories.include?(repo.id) }
-            end
-          end
-          smart_proxy.update_container_repo_list(repo_list)
-        end
-
-        def update_user_container_repo_mapping(smart_proxy, users)
-          # Example user-repo mapping:
-          # { users:
-          #   [
-          #     'user a' => [{ repository: 'repo 1', auth_required: true }]
-          #   ]
-          # }
-
-          user_repo_map = { users: [] }
-          users.each do |user|
-            inner_repo_list = []
-            repositories = ::Katello::Repository.readable_docker_catalog_as(user)
-            repositories.each do |repo|
-              next if repo.container_repository_name.nil?
-              inner_repo_list << { repository: repo.container_repository_name,
-                                   auth_required: !unauthenticated_container_repositories.include?(repo.id) }
-            end
-            user_repo_map[:users] << { user.login => inner_repo_list }
-          end
-          smart_proxy.update_user_container_repo_mapping(user_repo_map)
         end
 
         def repos_to_sync(smart_proxy, environment, content_view, repository, skip_metatadata_check = false)
@@ -108,6 +63,11 @@ module Actions
           :link
         end
 
+        def run
+          smart_proxy = ::SmartProxy.find(input[:smart_proxy_id])
+          smart_proxy.sync_container_gateway
+        end
+
         def rescue_strategy
           Dynflow::Action::Rescue::Skip
         end

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

@@ -4,7 +4,8 @@ module Actions
       class IncrementalUpdates < Actions::EntryAction
         include Helpers::Presenter
 
-        def plan(version_environments, composite_version_environments, content, dep_solve, hosts, description)
+        def plan(version_environments, composite_version_environments, content, dep_solve, hosts, description,
+                use_remote_execution = false)
           old_new_version_map = {}
           output_for_version_ids = []
 
@@ -28,12 +29,13 @@ module Actions
               handle_composites(old_new_version_map, composite_version_environments, output_for_version_ids, description)
             end
 
-            if hosts.any? && !content[:errata_ids].blank?
+            if hosts.any? && !content[:errata_ids].blank? && !use_remote_execution
               errata = ::Katello::Erratum.with_identifiers(content[:errata_ids])
               hosts = hosts.where(:id => ::Katello::Host::ContentFacet.with_applicable_errata(errata).pluck(:host_id))
               plan_action(::Actions::BulkAction, ::Actions::Katello::Host::Erratum::ApplicableErrataInstall, hosts, :errata_ids => content[:errata_ids])
             end
-            plan_self(:version_outputs => output_for_version_ids)
+            plan_self(:version_outputs => output_for_version_ids, :host_ids => hosts.pluck(:id),
+                      :errata_ids => content[:errata_ids], :use_remote_execution => use_remote_execution)
           end
         end
 
@@ -59,6 +61,14 @@ module Actions
         end
 
         def run
+          if input[:errata_ids].present? && input[:host_ids].present? && input[:use_remote_execution]
+            errata_ids = input[:errata_ids].join(',')
+            errata = ::Katello::Erratum.with_identifiers(input[:errata_ids])
+            hosts = ::Host.where(:id => input[:host_ids] &
+                                          ::Katello::Host::ContentFacet.with_applicable_errata(errata).pluck(:host_id))
+            JobInvocationComposer.for_feature('katello_errata_install', hosts, { :errata => errata_ids }).trigger
+          end
+
           output[:changed_content] = input[:version_outputs].map do |version_output|
             {
               :content_view_version => {:id => version_output[:version_id]},

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

@@ -45,17 +45,12 @@ module Actions
         end
 
         def finalize
-          # update errata applicability counts for all hosts in the CV & LE
-          ::Katello::Host::ContentFacet.where(:content_view_id => input[:content_view_id],
-                                              :lifecycle_environment_id => input[:environment_id]).each do |facet|
-            facet.update_applicability_counts
-            facet.update_errata_status
-          end
+          environment = ::Katello::KTEnvironment.find(input[:environment_id])
+          ::Katello::ContentView.find(input[:content_view_id]).update_host_statuses(environment)
 
           history = ::Katello::ContentViewHistory.find(input[:history_id])
           history.status = ::Katello::ContentViewHistory::SUCCESSFUL
           history.save!
-          environment = ::Katello::KTEnvironment.find(input[:environment_id])
 
           if !input[:incremental_update] && sync_proxies?(environment)
             ForemanTasks.async_task(ContentView::CapsuleSync,

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

@@ -49,13 +49,12 @@ module Actions
             plan_action(ContentView::AddToEnvironment, version, library) unless options[:skip_promotion]
             repository_mapping = plan_action(ContentViewVersion::CreateRepos, version, source_repositories).repository_mapping
             # Split Pulp 3 Yum repos out of the repository_mapping.  Only Pulp 3 RPM plugin has multi repo copy support.
-            separated_repo_map = separated_repo_mapping(repository_mapping)
+            separated_repo_map = separated_repo_mapping(repository_mapping, content_view.solve_dependencies)
 
             if options[:importing]
               handle_import(version, options.slice(:path, :metadata))
-            elsif 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)
+            elsif separated_repo_map[:pulp3_yum_multicopy].keys.flatten.present?
+              plan_action(Repository::MultiCloneToVersion, separated_repo_map[:pulp3_yum_multicopy], version)
             end
 
             concurrence do
@@ -194,12 +193,14 @@ module Actions
         def handle_import(version, path:, metadata:)
           sequence do
             plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::Import, version, path: path, metadata: metadata)
-            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)
+                # need to force full_indexing for these version repositories
+                # on import. This will then help us correctly copy version units to the library
+                plan_action(Katello::Repository::IndexContent, id: id, full_index: true)
               end
             end
+            plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::CopyVersionUnitsToLibrary, version)
           end
         end
 

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

@@ -55,7 +55,7 @@ module Actions
 
           sequence do
             repository_mapping = plan_action(ContentViewVersion::CreateRepos, new_content_view_version, repos_to_clone).repository_mapping
-            separated_repo_map = separated_repo_mapping(repository_mapping)
+            separated_repo_map = separated_repo_mapping(repository_mapping, true)
 
             repos_to_clone.each do |source_repos|
               plan_action(Repository::CloneToVersion,
@@ -66,8 +66,8 @@ module Actions
             end
 
             concurrence do
-              if separated_repo_map[:pulp3_yum].keys.flatten.present?
-                extended_repo_mapping = pulp3_repo_mapping(separated_repo_map[:pulp3_yum], old_version)
+              if separated_repo_map[:pulp3_yum_multicopy].keys.flatten.present?
+                extended_repo_mapping = pulp3_repo_mapping(separated_repo_map[:pulp3_yum_multicopy], old_version)
                 unit_map = pulp3_content_mapping(content)
 
                 unless extended_repo_mapping.empty? || unit_map.values.flatten.empty?
@@ -75,7 +75,7 @@ module Actions
                     copy_action_outputs << plan_action(Pulp3::Repository::MultiCopyUnits, extended_repo_mapping, unit_map,
                                                        dependency_solving: dep_solve).output
                     repos_to_clone.each do |source_repos|
-                      if separated_repo_map[:pulp3_yum].keys.include?(source_repos)
+                      if separated_repo_map[:pulp3_yum_multicopy].keys.include?(source_repos)
                         copy_repos(repository_mapping[source_repos])
                       end
                     end

data/app/lib/actions/katello/environment/publish_repositories.rb

@@ -16,6 +16,7 @@ module Actions
             repositories.each do |repository|
               sequence do
                 repository.set_container_repository_name
+                repository.clear_smart_proxy_sync_histories
                 plan_action(::Actions::Katello::Repository::InstanceUpdate, repository)
                 plan_action(::Actions::Katello::Repository::CapsuleSync, repository)
               end

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

@@ -13,6 +13,7 @@ module Actions
         # rubocop:disable Metrics/MethodLength
         # rubocop:disable Metrics/CyclomaticComplexity
         # rubocop:disable Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/AbcSize
         def run
           repo = ::Katello::Repository.find(input[:id])
           if repo.docker?
@@ -21,6 +22,10 @@ module Actions
             ::Katello::DockerManifestList.import_for_repository(repo)
           elsif repo.file?
             ::Katello::FileUnit.import_for_repository(repo)
+          elsif repo.generic?
+            repo.repository_type.content_types_to_index.each do |type|
+              type.model_class.import_for_repository(repo, generic_content_type: type.content_type)
+            end
           elsif repo.deb?
             if input[:import_upload_task] && input[:import_upload_task][:content_unit_href]
               unit_ids = [input[:import_upload_task][:content_unit_href]]

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

@@ -13,7 +13,7 @@ module Actions
             unit_type_id = SmartProxy.pulp_primary.content_service(content_type)::CONTENT_TYPE
           end
           generate_metadata = options.fetch(:generate_metadata, true)
-          plan_action(Katello::Repository::MetadataGenerate, repository, :dependency => import_upload_task) if generate_metadata
+          plan_action(Katello::Repository::MetadataGenerate, repository, :dependency => import_upload_task, :force_publication => true) if generate_metadata
 
           recent_range = 5.minutes.ago.utc.iso8601
           plan_action(Katello::Repository::FilteredIndexContent,

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

@@ -16,7 +16,11 @@ module Actions
           generate_applicability = options.fetch(:generate_applicability, repository.yum?)
 
           options[:content_type] ||= ::Katello::RepositoryTypeManager.find(repository.content_type).default_managed_content_type.label
-          unit_type_id = SmartProxy.pulp_primary.content_service(options[:content_type])::CONTENT_TYPE
+          if ::Katello::RepositoryTypeManager.generic_content_type?(options[:content_type])
+            unit_type_id = options[:content_type]
+          else
+            unit_type_id = SmartProxy.pulp_primary.content_service(options[:content_type])::CONTENT_TYPE
+          end
 
           sequence do
             upload_results = concurrence do
@@ -37,7 +41,7 @@ module Actions
                 import_upload.output
               end
             end
-            plan_action(Katello::Repository::MetadataGenerate, repository) if generate_metadata
+            plan_action(Katello::Repository::MetadataGenerate, repository, force_publication: true) if generate_metadata
             plan_action(Actions::Katello::Applicability::Repository::Regenerate, :repo_ids => [repository.id]) if generate_applicability
             plan_self(repository_id: repository.id, sync_capsule: sync_capsule, upload_results: upload_results)
           end

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

@@ -10,12 +10,13 @@ module Actions
           param :contents_changed
           param :matching_content
           param :source_repository_id
+          param :full_index
         end
 
         def run
           source_repository = ::Katello::Repository.find(input[:source_repository_id]) if input[:source_repository_id]
           repo = ::Katello::Repository.find(input[:id])
-          repo.index_content(source_repository: source_repository)
+          repo.index_content(source_repository: source_repository, full_index: input[:full_index].present?)
         end
       end
     end

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

@@ -7,7 +7,7 @@ module Actions
         def plan(repository)
           action_subject repository
           repository.save!
-          plan_action(::Actions::Pulp3::Orchestration::Repository::RefreshIfNeeded, repository)
+          plan_action(::Actions::Pulp3::Orchestration::Repository::RefreshIfNeeded, repository, SmartProxy.pulp_primary)
           plan_self(:repository_id => repository.id)
         end
 

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

@@ -7,9 +7,11 @@ module Actions
           source_repository ||= repository.target_repository if repository.link?
           smart_proxy = options.fetch(:smart_proxy, SmartProxy.pulp_primary)
           matching_content = options.fetch(:matching_content, false)
+          force_publication = options.fetch(:force_publication, false)
 
           plan_action(Pulp3::Orchestration::Repository::GenerateMetadata,
                         repository, smart_proxy,
+                        :force_publication => force_publication,
                         :source_repository => source_repository,
                         :matching_content => matching_content)
         end

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

@@ -9,7 +9,7 @@ module Actions
           sequence do
             plan_action(::Actions::Katello::Repository::MultiCloneContents, extended_repo_map,
                         copy_contents: true,
-                        solve_dependencies: content_view.solve_dependencies,
+                        solve_dependencies: true,
                         metadata_generate: !incremental)
           end
         end

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

@@ -16,7 +16,11 @@ module Actions
           action_subject(repository)
 
           content_unit_ids = content_units.map(&:id)
-          content_unit_type = options[:content_type] || content_units.first.class::CONTENT_TYPE
+          if repository.generic?
+            content_unit_type = options[:content_type] || content_units.first.content_type
+          else
+            content_unit_type = options[:content_type] || content_units.first.class::CONTENT_TYPE
+          end
           ::Katello::RepositoryTypeManager.check_content_matches_repo_type!(repository, content_unit_type)
 
           generate_applicability = options.fetch(:generate_applicability, repository.yum?)
@@ -38,7 +42,7 @@ module Actions
 
         def create_sub_plans
           trigger(Actions::Katello::Repository::MetadataGenerate,
-                  ::Katello::Repository.find(input[:repository][:id]))
+                  ::Katello::Repository.find(input[:repository][:id]), :force_publication => true)
         end
 
         def resource_locks

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

@@ -18,7 +18,6 @@ module Actions
         #   of Katello and we just need to finish the rest of the orchestration
         # rubocop:disable Metrics/MethodLength
         # rubocop:disable Metrics/CyclomaticComplexity
-        # rubocop:disable Metrics/PerceivedComplexity
         def plan(repo, options = {})
           action_subject(repo)
 
@@ -54,7 +53,6 @@ module Actions
               plan_action(Katello::Repository::FetchPxeFiles, :id => repo.id)
               plan_action(Katello::Repository::CorrectChecksum, repo)
               concurrence do
-                plan_action(Katello::Repository::MetadataGenerate, repo, :force => true) if skip_metadata_check && repo.yum?
                 plan_action(Katello::Repository::ErrataMail, repo, nil, contents_changed)
                 plan_action(Actions::Katello::Applicability::Repository::Regenerate, :repo_ids => [repo.id]) if generate_applicability
               end

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

@@ -15,7 +15,12 @@ module Actions
           content_type ||= ::Katello::RepositoryTypeManager.find(repository.content_type).default_managed_content_type.label
           ::Katello::RepositoryTypeManager.check_content_matches_repo_type!(repository, content_type)
 
-          unit_type_id = SmartProxy.pulp_primary.content_service(content_type)::CONTENT_TYPE
+          if ::Katello::RepositoryTypeManager.generic_content_type?(content_type)
+            unit_type_id = content_type
+          else
+            unit_type_id = SmartProxy.pulp_primary.content_service(content_type)::CONTENT_TYPE
+          end
+
           upload_actions = []
 
           generate_applicability = options.fetch(:generate_applicability, repository.yum?)