katello 4.3.1 → 4.4.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1a33ac3431921424a7d17bcd6f90afbb0f0ed372e6c7873ea1b2afa35cde5d2
-  data.tar.gz: 864c45929eea0df21199da1bafc4598f504887578c8c7fa860e3d03729fcf0aa
+  metadata.gz: 2cffead633d7427ab354f070ad520ef1436914690ae62a83707bd51f0ff94156
+  data.tar.gz: 759afa6d6768f23db062327899cd38db646b99c59d5068027dcf4bdc74f47896
 SHA512:
-  metadata.gz: 938cb19362f4c5add3bd334c4889a95462a2c3f071a2d3764a43c59bfeac6bef1bb036f99b0d168dbf10953664e7fc5f8623f6b4a0a09021be7e9f1931b8be64
-  data.tar.gz: bb12015598a2ac15cfbd0aad5f9a18d7c86142c8157e73cf134a22b93470d0da64c977c59fb74fb2819ad5e2c15b8f77f0b1283d0b9a674205bd1e0f6ac9dc89
+  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)

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/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/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/katello/concerns/base_template_scope_extensions.rb

@@ -288,6 +288,17 @@ module Katello
         Katello.with_katello_agent?
       end
 
+      include Katello::ContentSourceHelper
+
+      apipie :method, "Generate script to change a host's content source" do
+        returns String
+      end
+      def change_content_source(host, ca_cert)
+        return missing_content_source(host) unless host.content_source
+
+        prepare_ssl_cert(ca_cert) + configure_subman(host.content_source)
+      end
+
       private
 
       def host_subscription_facet(host)

data/app/lib/katello/errors.rb

@@ -145,10 +145,10 @@ module Katello
       end
     end
 
-    class DisconnectedMode < StandardError
+    class SubscriptionConnectionNotEnabled < StandardError
       def message
-        _("You are currently operating in disconnected mode where access to Red Hat Subcription Management " \
-        "is prohibited. If you would like to change this, please update the content setting 'Disconnected mode'.")
+        _("Access to Red Hat Subscription Management " \
+        "is prohibited. If you would like to change this, please update the content setting 'Subscription connection enabled'.")
       end
     end
 

data/app/lib/katello/logging.rb

@@ -19,9 +19,9 @@ module Katello
     class Timer
       def initialize(key = "default")
         @key = key
-        @start_time = Time.now
         Thread.current[:timers] ||= {}
         Thread.current[:timers][key] = self
+        self.start
       end
 
       def start
@@ -38,6 +38,11 @@ module Katello
         Rails.logger.info "Timer #{@key} stopping at #{Time.now}: #{duration} sec"
       end
 
+      def log(msg = nil)
+        duration = (Time.now - @start_time).truncate(2)
+        Rails.logger.info ["Timer #{@key} running at #{Time.now}", msg, "#{duration} sec"].compact.join(': ')
+      end
+
       def self.find_by_key(key)
         if Thread.current&.[](:timers)&.[](key)
           Thread.current[:timers][key]