katello 4.3.0 → 4.4.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5bebacc5b4b127cfadaeb424ce9f04aa6e2ba132a0d8d959d8456bd393418abf
-  data.tar.gz: 473b94c0aec5d6b73a174f334edf1f9079d42c53d16ef0ab60cc939af0e0e4b0
+  metadata.gz: 2cffead633d7427ab354f070ad520ef1436914690ae62a83707bd51f0ff94156
+  data.tar.gz: 759afa6d6768f23db062327899cd38db646b99c59d5068027dcf4bdc74f47896
 SHA512:
-  metadata.gz: 000e85ae93b95be282c88d10eec6f364526cfdb9e377de7b56d82a8df882e8390c40690b4d7b0740c24196fa10d20d166b48779f3422699e7a970bfb1722cdc2
-  data.tar.gz: 23a1e59f555ddbe334a98d6937aa64de3d46b1bc6b8fb33a61166e317792686fae9f30af480d0037226eebf6d341769a15acd1972d7bb05d20696ab6af1fb9dc
+  metadata.gz: f4d6669e6c29532fe48cb70fd014bc0fb0fd9e7ddfb29a3832e175134be2ecb40b2dbcedd458cef5303805680e28ec3d17a3ea9f250a3482403490c7dd22b3d1
+  data.tar.gz: 458b225423b94a7cfb95034ee9bbff4d0fceca0effcf2dfd2651bb98bf535cadc681791ccbbaca19175cd17446fffab9b1190140f07973e8b220c28239aaf398

data/app/assets/javascripts/katello/common/vendor.js

@@ -1,5 +1,4 @@
 //= require "jquery-ui/widgets/dialog"
-//= require "jquery-ui/widgets/sortable"
 //= require "jquery-ui/widgets/progressbar"
 //= require "jquery-ui/effect"
 //= require "jquery-ui/effect.all"

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

@@ -126,7 +126,7 @@ module Katello
       end
     rescue ScopedSearch::QueryNotSupported, ActiveRecord::StatementInvalid => error
       message = error.message
-      if error.class == ActiveRecord::StatementInvalid
+      if error.instance_of? ActiveRecord::StatementInvalid
         Rails.logger.error("Invalid search: #{error.message}")
         message = _('Your search query was invalid. Please revise it and try again. The full error has been sent to the application logs.')
       end
@@ -141,7 +141,7 @@ module Katello
     protected
 
     def scoped_search_query(query, group)
-      if group
+      if group && !query_has_group_by?(query)
         query.select(group).group(group)
       else
         query
@@ -149,7 +149,12 @@ module Katello
     end
 
     def scoped_search_total(query, group)
-      scoped_search_query(query, group).length
+      count_query = scoped_search_query(query, group)
+      if query_has_group_by?(count_query)
+        count_query.length
+      else
+        count_query.count
+      end
     end
 
     def scoped_search_total_selectable(query, group)
@@ -157,10 +162,14 @@ module Katello
       if self.respond_to?(:total_selectable, true)
         total_selectable(q)
       else
-        q.length
+        group ? q.length : q.count
       end
     end
 
+    def query_has_group_by?(query)
+      query.to_sql.include?('GROUP BY')
+    end
+
     def scoped_search_results(query:, subtotal: 0, total: 0, page: 0, per_page: 0, error: nil, selectable: nil)
       {
         :results => query,

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

@@ -163,6 +163,9 @@ module Katello
 
     def find_optional_readable_content_view
       @view = ContentView.readable.find_by(:id => params[:content_view_id])
+      if params[:content_view_id] && !@view
+        fail HttpErrors::NotFound, _("Couldn't find content view with id: '%s'") % params[:content_view_id]
+      end
     end
 
     def find_publishable_content_view

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

@@ -2,6 +2,7 @@ module Katello
   class Api::V2::ContentViewsController < Api::V2::ApiController
     include Concerns::Authorization::Api::V2::ContentViewsController
     include Katello::Concerns::FilteredAutoCompleteSearch
+    include Katello::Concerns::Api::V2::BulkExtensions
 
     before_action :find_authorized_katello_resource, :except => [:index, :create, :copy, :auto_complete_search]
     before_action :ensure_non_default, :except => [:index, :create, :copy, :auto_complete_search]
@@ -24,6 +25,18 @@ module Katello
       param :import_only, :bool, :desc => N_("Designate this Content View for importing from upstream servers only. Defaults to false")
     end
 
+    def_param_group :bulk_content_view_version_ids do
+      param :included, Hash, :desc => N_("Versions to exclusively include in the action"), :required => true, :action_aware => true do
+        param :search, String, :required => false, :desc => N_("Search string for versions to perform an action on")
+        param :ids, Array, :required => false, :desc => N_("List of versions to perform an action on")
+      end
+      param :excluded, Hash, :desc => N_("Versions to explicitly exclude in the action."\
+                                         " All other versions will be included in the action,"\
+                                         " unless an included parameter is passed as well."), :required => true, :action_aware => true do
+        param :ids, Array, :required => false, :desc => N_("List of versions to exclude and not run an action on")
+      end
+    end
+
     def filtered_associations
       {
         :component_ids => Katello::ContentViewVersion,
@@ -175,6 +188,39 @@ module Katello
       respond_for_async :resource => task
     end
 
+    api :PUT, "/content_views/:id/bulk_delete_versions", N_("Bulk remove versions from a content view and reassign systems and keys")
+    param_group :bulk_content_view_version_ids
+    param :id, :number, :desc => N_("content view numeric identifier"), :required => true
+    param :system_content_view_id, :number, :desc => N_("content view to reassign orphaned systems to")
+    param :system_environment_id, :number, :desc => N_("environment to reassign orphaned systems to")
+    param :key_content_view_id, :number, :desc => N_("content view to reassign orphaned activation keys to")
+    param :key_environment_id, :number, :desc => N_("environment to reassign orphaned activation keys to")
+    def bulk_delete_versions
+      params[:bulk_content_view_version_ids] ||= {}
+
+      versions = find_bulk_items(bulk_params: params[:bulk_content_view_version_ids],
+                                 model_scope: ::Katello::ContentViewVersion.where(content_view_id: @content_view.id),
+                                 key: :id)
+      cv_envs = ContentViewEnvironment.where(:content_view_version_id => versions.pluck(:id),
+                                             :content_view_id => @content_view.id
+      )
+
+      if !params[:destroy_content_view] && cv_envs.empty? && versions.empty?
+        fail _("There either were no environments nor versions specified or there were invalid environments/versions specified. "\
+               "Please check environment_ids and content_view_version_ids parameters.")
+      end
+
+      options = params.slice(:system_content_view_id,
+                             :system_environment_id,
+                             :key_content_view_id,
+                             :key_environment_id
+      ).reject { |_k, v| v.nil? }.to_unsafe_h
+      options[:content_view_versions] = versions
+      options[:content_view_environments] = cv_envs
+      task = async_task(::Actions::Katello::ContentView::Remove, @content_view, options)
+      respond_for_async :resource => task
+    end
+
     api :PUT, "/content_views/:id/remove_filters", N_("Delete multiple filters from a content view")
     param :id, :number, :desc => N_("content view numeric identifier"), :required => true
     param :filter_ids, Array, of: :number, :desc => N_("filter identifiers"), :required => true

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

@@ -2,6 +2,10 @@ module Katello
   class Api::V2::HostPackagesController < Api::V2::ApiController
     include Katello::Concerns::FilteredAutoCompleteSearch
 
+    UPGRADABLE = "upgradable".freeze
+    UP_TO_DATE = "up-to-date".freeze
+    VERSION_STATUSES = [UPGRADABLE, UP_TO_DATE].freeze
+
     before_action :require_packages_or_groups, :only => [:install, :remove]
     before_action :require_packages_only, :only => [:upgrade]
     before_action :find_editable_host_with_facet, :except => :index
@@ -21,9 +25,11 @@ module Katello
     api :GET, "/hosts/:host_id/packages", N_("List packages installed on the host")
     param :host_id, :number, :required => true, :desc => N_("ID of the host")
     param :include_latest_upgradable, :boolean, :desc => N_("Also include the latest upgradable package version for each host package")
+    param :status, String, :desc => N_("Return only packages of a particular status (upgradable or up-to-date)"), :required => false
     param_group :search, Api::V2::ApiController
     add_scoped_search_description_for(Katello::InstalledPackage)
     def index
+      validate_index_params!
       collection = scoped_search(index_relation, :name, :asc, :resource_class => ::Katello::InstalledPackage)
       collection[:results] = HostPackagePresenter.with_latest(collection[:results], @host) if ::Foreman::Cast.to_bool(params[:include_latest_upgradable])
       respond_for_index(:collection => collection)
@@ -84,7 +90,15 @@ module Katello
     end
 
     def index_relation
-      @host.installed_packages
+      packages = @host.installed_packages
+      upgradable_packages = ::Katello::Rpm.installable_for_hosts([@host]).select(:name)
+      if params[:status].present?
+        packages = case params[:status]
+                   when 'up-to-date' then packages.where.not(name: upgradable_packages)
+                   when 'upgradable' then packages.where(name: upgradable_packages)
+                   end
+      end
+      packages
     end
 
     def resource_class
@@ -137,5 +151,11 @@ module Katello
         group.gsub(/^@/, "")
       end
     end
+
+    def validate_index_params!
+      if params[:status].present?
+        fail _("Status must be one of: %s" % VERSION_STATUSES.join(', ')) unless VERSION_STATUSES.include?(params[:status])
+      end
+    end
   end
 end

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

@@ -3,11 +3,13 @@ module Katello
   class Api::V2::HostsBulkActionsController < Api::V2::ApiController
     include Concerns::Api::V2::BulkHostsExtensions
     include Katello::Concerns::Api::V2::ContentOverridesController
+    include Katello::ContentSourceHelper
+    include ::Foreman::Renderer::Scope::Macros::Base
 
     before_action :find_host_collections, only: [:bulk_add_host_collections, :bulk_remove_host_collections]
     before_action :find_environment, only: [:environment_content_view]
     before_action :find_content_view, only: [:environment_content_view]
-    before_action :find_editable_hosts, except: [:destroy_hosts, :resolve_traces]
+    before_action :find_editable_hosts, except: [:destroy_hosts, :resolve_traces, :change_content_source]
     before_action :find_deletable_hosts, only: [:destroy_hosts]
     before_action :find_readable_hosts, only: [:applicable_errata, :installable_errata, :available_incremental_updates]
     before_action :find_errata, only: [:available_incremental_updates]
@@ -305,6 +307,33 @@ module Katello
                         template: '../../../api/v2/module_streams/name_streams')
     end
 
+    api :PUT, "/hosts/bulk/change_content_source", N_("Update the content source for specified hosts and generate the reconfiguration script")
+    param :host_ids, Array, required: true, desc: N_("The ids of the hosts to alter. Hosts not managed by Katello are ignored")
+    param :environment_id, :number, required: true, desc: N_("The id of the lifecycle environment")
+    param :content_view_id, :number, required: true, desc: N_("The id of the content view")
+    param :content_source_id, :number, required: true, desc: N_("The id of the content source")
+    def change_content_source
+      hosts = ::Host.where(id: params[:host_ids])
+      throw_resource_not_found(name: 'host', id: params[:host_ids]) unless hosts.any?
+
+      lifecycle_environment = KTEnvironment.readable.find(params[:environment_id])
+      content_view = Katello::ContentView.readable.find(params[:content_view_id])
+      content_source = SmartProxy.authorized(:view_smart_proxies).find(params[:content_source_id])
+      template = prepare_ssl_cert(foreman_server_ca_cert) + configure_subman(content_source)
+
+      hosts.each do |host|
+        next unless host.content_facet
+
+        host.content_facet.lifecycle_environment = lifecycle_environment
+        host.content_facet.content_view = content_view
+        host.content_facet.content_source = content_source
+
+        host.update_candlepin_associations
+      end
+
+      render plain: template
+    end
+
     private
 
     def find_errata

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

@@ -134,13 +134,17 @@ module Katello
 
     api :PUT, "/organizations/:id/cdn_configuration", N_("Update the CDN configuration")
     param :id, String, :desc => N_("ID of the Organization"), :required => true
-    param :ssl_ca_credential_id, Integer, :desc => N_("Content Credential to use for SSL CA")
-    param :username, String, :desc => N_("Username for authentication")
-    param :password, String, :desc => N_("Password for authentication")
-    param :upstream_organization_label, String, :desc => N_("Upstream organization to sync CDN content from")
-    param :url, String, :desc => N_("Upstream server to sync CDN content from")
+    param :type, String, :desc => N_("CDN configuration type. One of %s.") % CdnConfiguration::TYPES, :required => true
+    param :url, String, :desc => N_("Upstream foreman server to sync CDN content from. Relevant only for 'upstream_server' type.")
+    param :username, String, :desc => N_("Username for authentication. Relevant only for 'upstream_server' type.")
+    param :password, String, :desc => N_("Password for authentication. Relevant only for 'upstream_server' type.")
+    param :upstream_organization_label, String, :desc => N_("Upstream organization to sync CDN content from. Relevant only for 'upstream_server' type.")
+    param :upstream_content_view_label, String, :desc => N_("Upstream Content View Label, default: Default_Organization_View. Relevant only for 'upstream_server' type.")
+    param :upstream_lifecycle_environment_label, String, :desc => N_("Upstream Lifecycle Environment, default: Library. Relevant only for 'upstream_server' type.")
+    param :ssl_ca_credential_id, Integer, :desc => N_("Content Credential to use for SSL CA. Relevant only for 'upstream_server' type.")
     def cdn_configuration
-      config_keys = [:url, :username, :password, :upstream_organization_label, :ssl_ca_credential_id]
+      config_keys = [:url, :username, :password, :upstream_organization_label, :ssl_ca_credential_id, :type,
+                     :upstream_lifecycle_environment_label, :upstream_content_view_label]
       config_params = params.slice(*config_keys).permit!.to_h
 
       task = sync_task(::Actions::Katello::CdnConfiguration::Update, @organization.cdn_configuration, config_params)

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

@@ -53,9 +53,13 @@ module Katello
     def custom_index_relation(collection)
       applicable = ::Foreman::Cast.to_bool(params[:packages_restrict_applicable]) || params[:host_id]
       upgradable = ::Foreman::Cast.to_bool(params[:packages_restrict_upgradable])
+      not_installed = ::Foreman::Cast.to_bool(params[:packages_restrict_not_installed])
 
       if upgradable
         collection = collection.installable_for_hosts(@hosts)
+      elsif not_installed && params[:host_id]
+        host = @hosts.first
+        collection = Katello::Rpm.yum_installable_for_host(host)
       elsif applicable
         collection = collection.applicable_to_hosts(@hosts)
       end

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

@@ -50,8 +50,10 @@ module Katello
       param :unprotected, :bool, :desc => N_("true if this repository can be published via HTTP")
       param :checksum_type, String, :desc => N_("Checksum of the repository, currently 'sha1' & 'sha256' are supported")
       param :docker_upstream_name, String, :desc => N_("Name of the upstream docker repository")
-      param :docker_tags_whitelist, Array, :desc => N_("Comma-separated list of tags to sync for Container Image repository")
-      param :download_policy, ["immediate", "on_demand"], :desc => N_("download policy for yum repos (either 'immediate' or 'on_demand')")
+      param :docker_tags_whitelist, Array, :desc => N_("Comma-separated list of tags to sync for Container Image repository (Deprecated)"), :deprecated => true
+      param :include_tags, Array, :desc => N_("Comma-separated list of tags to sync for a container image repository")
+      param :exclude_tags, Array, :desc => N_("Comma-separated list of tags to exclude when syncing a container image repository. Default: any tag ending in \"-source\"")
+      param :download_policy, ["immediate", "on_demand"], :desc => N_("download policy for yum, deb, and docker repos (either 'immediate' or 'on_demand')")
       param :download_concurrency, :number, :desc => N_("Used to determine download concurrency of the repository in pulp3. Use value less than 20. Defaults to 10")
       param :mirror_on_sync, :bool, :desc => N_("true if this repository when synced has to be mirrored from the source and stale rpms removed (Deprecated)")
       param :mirroring_policy, Katello::RootRepository::MIRRORING_POLICIES, :desc => N_("Policy to set for mirroring content.  Must be one of %s.") % RootRepository::MIRRORING_POLICIES
@@ -507,7 +509,7 @@ module Katello
               {:os_versions => []}, :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?
+      keys += [{:docker_tags_whitelist => []}, {:include_tags => []}, {:exclude_tags => []}, :docker_upstream_name] if params[:action] == 'create' || @repository&.docker?
       keys += [:ansible_collection_requirements, :ansible_collection_auth_url, :ansible_collection_auth_token] if params[:action] == 'create' || @repository&.ansible_collection?
       keys += [:label, :content_type] if params[:action] == "create"
 
@@ -540,13 +542,20 @@ module Katello
       credential_value
     end
 
-    # rubocop:disable Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/PerceivedComplexity,Metrics/MethodLength
     def construct_repo_from_params(repo_params) # rubocop:disable Metrics/AbcSize
       root = @product.add_repo(repo_params.slice(:label, :name, :description, :url, :content_type, :arch, :unprotected,
                                                             :gpg_key, :ssl_ca_cert, :ssl_client_cert, :ssl_client_key,
                                                             :checksum_type, :download_policy, :http_proxy_policy).to_h.with_indifferent_access)
       root.docker_upstream_name = repo_params[:docker_upstream_name] if repo_params[:docker_upstream_name]
-      root.docker_tags_whitelist = repo_params.fetch(:docker_tags_whitelist, []) if root.docker?
+      if root.docker?
+        if repo_params[:docker_tags_whitelist].present?
+          root.include_tags = repo_params.fetch(:docker_tags_whitelist, [])
+        else
+          root.include_tags = repo_params.fetch(:include_tags, [])
+        end
+      end
+      root.exclude_tags = repo_params.fetch(:exclude_tags, ['*-source']) if root.docker?
       root.verify_ssl_on_sync = ::Foreman::Cast.to_bool(repo_params[:verify_ssl_on_sync]) if repo_params.key?(:verify_ssl_on_sync)
       root.mirroring_policy = repo_params[:mirroring_policy] || Katello::RootRepository::MIRRORING_POLICY_CONTENT
       root.upstream_username = repo_params[:upstream_username] if repo_params.key?(:upstream_username)
@@ -577,7 +586,7 @@ module Katello
 
       root
     end
-    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/CyclomaticComplexity,Metrics/MethodLength
 
     def handle_mirror_on_sync(repo_params)
       if !repo_params.key?(:mirroring_policy) && repo_params.key?(:mirror_on_sync)
@@ -648,7 +657,8 @@ module Katello
 
     def generic_remote_options_hash(repo_params)
       generic_remote_options = {}
-      RepositoryTypeManager.generic_remote_options(content_type: repo_params[:content_type]).each do |option|
+      content_type = @repository&.content_type || repo_params[:content_type]
+      RepositoryTypeManager.generic_remote_options(content_type: content_type).each do |option|
         generic_remote_options[option.name] = repo_params[option.name]
       end
       generic_remote_options

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

@@ -13,6 +13,7 @@ module Katello
     before_action :find_authorized_host, :only => [:index, :auto_complete_search]
     before_action :find_organization
     before_action :find_product_content, :except => [:index, :auto_complete_search]
+    before_action :check_airgapped, :only => [:index]
 
     resource_description do
       api_version "v2"
@@ -209,5 +210,11 @@ module Katello
         params[:host_id] ||= params[:id]
       end
     end
+
+    def check_airgapped
+      if @organization.cdn_configuration.airgapped?
+        respond_for_index(:collection => { :error => _("Repositories are not available for enablement while CDN configuration is set to Air-gapped (disconnected).") }, :status => :forbidden)
+      end
+    end
   end
 end

data/app/controllers/katello/concerns/api/v2/repository_content_controller.rb

@@ -130,6 +130,9 @@ module Katello
       end
 
       def filter_by_content_view_version(version, collection)
+        if params[:content_type]
+          return collection.where(:id => version.send(controller_name, params[:content_type]))
+        end
         collection.where(:id => version.send(controller_name))
       end
 

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

@@ -9,6 +9,8 @@ module Katello
           case params[:action]
           when 'content_hosts'
             'view'
+          when 'change_content_source'
+            'edit'
           else
             super
           end
@@ -68,6 +70,36 @@ module Katello
             end
           end
         end
+
+        def change_content_source_data
+          hosts = ::Host.where(id: params[:host_ids])
+          content_hosts_ids = []
+          hosts_without_content = []
+
+          hosts.each do |host|
+            if host.content_facet
+              content_hosts_ids << host.id
+            else
+              hosts_without_content << host.name
+            end
+          end
+
+          environments = KTEnvironment.readable.where(organization: Organization.current).includes([:organization, :env_priors, :priors]).order(:name)
+          content_sources = SmartProxy.authorized(:view_smart_proxies).with_content.includes([:smart_proxy_features])
+
+          if Katello.with_remote_execution?
+            template_id = JobTemplate.find_by(name: 'Change content source')&.id
+            job_invocation_path = new_job_invocation_path(template_id: template_id, host_ids: content_hosts_ids) if template_id
+          end
+
+          render json: {
+            content_hosts_ids: content_hosts_ids,
+            hosts_without_content: hosts_without_content,
+            environments: environments,
+            content_sources: content_sources,
+            job_invocation_path: job_invocation_path
+          }
+        end
       end
     end
   end

data/app/controllers/katello/remote_execution_controller.rb

@@ -47,11 +47,12 @@ module Katello
       end
 
       def inputs
-        if feature_name == 'katello_errata_install'
-          { "Errata Search Query" => "errata_id ^ (#{errata_inputs.join(',')})" }
-        elsif feature_name == 'katello_service_restart'
+        case feature_name
+        when 'katello_errata_install'
+          { :errata => errata_inputs }
+        when 'katello_service_restart'
           { :helper => params[:name] }
-        elsif feature_name == 'katello_module_stream_action'
+        when 'katello_module_stream_action'
           fail HttpErrors::NotFound, _('module streams not found') if params[:module_spec].blank?
           fail HttpErrors::NotFound, _('actions not found') if params[:module_stream_action].blank?
           inputs = { :module_spec => params[:module_spec], :action => params[:module_stream_action] }

data/app/helpers/katello/content_source_helper.rb

@@ -0,0 +1,43 @@
+module Katello
+  module ContentSourceHelper
+    def missing_content_source(host)
+      <<~CMD
+        echo "Host [#{host.name}] doesn't have an assigned content source!"
+        exit 1
+      CMD
+    end
+
+    def prepare_ssl_cert(ca_cert)
+      <<~CMD
+        # Prepare SSL certificate
+
+        KATELLO_SERVER_CA_CERT=/etc/rhsm/ca/katello-server-ca.pem
+        SSL_CA_CERT=$(mktemp)
+        cat << EOF > $SSL_CA_CERT
+        #{ca_cert}
+        EOF
+
+        mkdir -p /etc/rhsm/ca
+        cp -f $SSL_CA_CERT $KATELLO_SERVER_CA_CERT
+        chmod 644 $KATELLO_SERVER_CA_CERT
+
+      CMD
+    end
+
+    def configure_subman(content_source)
+      <<~CMD
+        # Configure subscription-manager
+        RHSM_CFG=/etc/rhsm/rhsm.conf
+
+        test -f $RHSM_CFG.bak || cp $RHSM_CFG $RHSM_CFG.bak
+
+        subscription-manager config \
+          --server.hostname="#{content_source.rhsm_url.host}" \
+          --server.port="#{content_source.rhsm_url.port}" \
+          --server.prefix="#{content_source.rhsm_url.path}" \
+          --rhsm.repo_ca_cert="$KATELLO_SERVER_CA_CERT" \
+          --rhsm.baseurl="#{content_source.pulp_content_url}"
+      CMD
+    end
+  end
+end

data/app/helpers/katello/hosts_and_hostgroups_helper.rb

@@ -266,5 +266,9 @@ module Katello
         :priority => 900
       }]
     end
+
+    def hosts_change_content_source
+      [{ action: [_('Change Content Source'), '/change_host_content_source', false], priority: 100 }]
+    end
   end
 end

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

@@ -4,23 +4,21 @@ module Actions
       class Update < Actions::EntryAction
         def plan(cdn_configuration, options)
           cdn_configuration.update!(options)
+          return if cdn_configuration.airgapped?
 
-          if cdn_configuration.redhat?
-            cdn_configuration.ssl_cert = nil
-            cdn_configuration.ssl_key = nil
-          else
+          if cdn_configuration.upstream_server?
             resource = ::Katello::Resources::CDN::CdnResource.create(cdn_configuration: cdn_configuration)
             keypair = resource.debug_certificate
             cdn_configuration.ssl_cert = OpenSSL::X509::Certificate.new(keypair)
             cdn_configuration.ssl_key = OpenSSL::PKey::RSA.new(keypair)
-          end
 
-          cdn_configuration.save!
+            cdn_configuration.save!
+          end
 
           org = cdn_configuration.organization
           roots = ::Katello::RootRepository.redhat.in_organization(org)
           roots.each do |root|
-            full_path = if cdn_configuration.redhat?
+            full_path = if cdn_configuration.redhat_cdn?
                           root.product.repo_url(root.library_instance.generate_content_path)
                         else
                           resource.repository_url(content_label: root.content.label)

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

@@ -200,6 +200,11 @@ module Actions
                 plan_action(Katello::Repository::IndexContent, id: id, full_index: true)
               end
             end
+            concurrence do
+              version.importable_repositories.each do |repo|
+                plan_action(::Actions::Katello::Repository::MetadataGenerate, repo)
+              end
+            end
             plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::CopyVersionUnitsToLibrary, version)
           end
         end

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

@@ -72,6 +72,18 @@ module Actions
 
                 unless extended_repo_mapping.empty? || unit_map.values.flatten.empty?
                   sequence do
+                    # Pre-copy content if dest_repo is a soft copy of its library instance.
+                    # Don't use extended_repo_mapping because the source repositories are library instances.
+                    # We want the old CV snapshot repositories here so as to not pull in excess new content.
+                    separated_repo_map[:pulp3_yum_multicopy].each do |source_repos, dest_repo|
+                      if dest_repo.soft_copy_of_library?
+                        source_repos.each do |source_repo|
+                          # remove_all flag is set to cover the case of incrementally updating more than once with different content.
+                          # Without it, content from the previous incremental update will be copied as well due to how Pulp repo versions work.
+                          plan_action(Pulp3::Repository::CopyContent, source_repo, SmartProxy.pulp_primary, dest_repo, copy_all: true, remove_all: true)
+                        end
+                      end
+                    end
                     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|
@@ -125,10 +137,12 @@ module Actions
             source_library_repo = source_repos.first.library_instance? ? source_repos.first : source_repos.first.library_instance
 
             source_repos = [source_library_repo]
-            if old_version_repo.version_href
-              base_version = old_version_repo.version_href.split("/")[-1].to_i
-            else
+            if old_version_repo.version_href.nil?
               base_version = 0
+            elsif old_version_repo.soft_copy_of_library?
+              base_version = nil
+            else
+              base_version = old_version_repo.version_href.split("/")[-1].to_i
             end
 
             pulp3_repo_mapping[source_repos.map(&:id)] = { dest_repo: dest_repo.id, base_version: base_version }

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

@@ -33,7 +33,7 @@ module Actions
                 password = decrypt_field(input[:upstream_password])
                 repo_discovery = ::Katello::RepoDiscovery.new(input[:url], input[:content_type],
                                                               input[:upstream_username], password,
-                                                              input[:search], proxy,
+                                                              input[:search],
                                                               output[:crawled], output[:repo_urls], output[:to_follow])
 
                 repo_discovery.run(output[:to_follow].shift)
@@ -49,19 +49,6 @@ module Actions
         def task_output
           output[:repo_urls] || []
         end
-
-        def proxy
-          proxy_details = {}
-          if (proxy = ::HttpProxy.default_global_content_proxy)
-            uri = URI(proxy.url)
-            proxy_details[:proxy_host] = "#{uri.scheme}://#{uri.host}#{uri.path}"
-            proxy_details[:proxy_port] = uri.port
-            proxy_details[:proxy_user] = proxy.username
-            proxy_details[:proxy_password] = proxy.password
-          end
-
-          proxy_details
-        end
       end
     end
   end

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

@@ -24,7 +24,7 @@ module Actions
             ::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)
+              type.model_class.import_for_repository(repo, content_type: type.content_type)
             end
           elsif repo.deb?
             if input[:import_upload_task] && input[:import_upload_task][:content_unit_href]

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

@@ -19,6 +19,13 @@ module Actions
             metadata: input[:metadata]
           ).create_import(input[:importer_data][:pulp_href])
         end
+
+        def rescue_strategy_for_self
+          # There are various reasons the importing fails, not all of them are
+          # fatal: when fail on import, we continue with the task ending up
+          # in the warning state, but not locking further imports
+          Dynflow::Action::Rescue::Skip
+        end
       end
     end
   end