katello 3.18.5 → 4.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 625ecabd197fcf1e9562afe5ab95076a78aad73960543c9804d0510f36bfc398
-  data.tar.gz: 0a6c82ff085f980e9d028a9734f3d071fa5324e6354b0c45b49406bf4400783c
+  metadata.gz: 3942a71eb36eb3e5c9e6adcf139e30a2443a038eea11c417e55c6b590580465f
+  data.tar.gz: f59fa795ac9c2298450020e4c8f90409691374acc1f09e1c49a88e661d06cdd6
 SHA512:
-  metadata.gz: ff6a670562b076e29b4112e22b8575ae0fbc8a1864377ea538e642207a9b78e574e1bcffb9c611f61691303fb9f5b8a56e80dda96b6391d96ab836b8cfc5ab7c
-  data.tar.gz: f8b4a6bb32933ef5a12ebc1dab3e1e06b023c39834b9fd58dad920912ce84f25ac6974cad9611ae6d6cd87b4b2bbd45d38d71604bf42d5ebb8be72f5b93f3293
+  metadata.gz: ff801d6c4540553020d70162d030def3a7782771f58fe8e85a81def49dd1abdb4abeab3b039ce56a2741636e745bba0887e0713ae534809e952ab0fc0482ba23
+  data.tar.gz: 4920f4ab7232331cc2d79a56f05625811a71f334e8909bab61a7d74cbbb8fbf345a9394a888bf44ca94dac9ae17dd4f53a069f6a7fd822926377dd8b9dc1c6ed

data/app/assets/stylesheets/katello/katello.scss

@@ -163,6 +163,78 @@ input:focus {
   @extend .status_exclamation_icon;
 }
 
+/* BUTTONS */
+input[type='submit'], button, .button {
+  font-size: 10px;
+  display: inline-block;
+  vertical-align: bottom;
+  background: -moz-linear-gradient(top, #f9f9f9, #f0f0f0, #e5e5e5, #e9e9e9);
+  background: -webkit-gradient(linear, left top, left bottom, from(#f9f9f9), color-stop(0.9, #e5e5e5), to(#e9e9e9));
+  box-shadow: none;
+  border: 1px solid darken($stroke_color, 20%);
+  color: #221e1f;
+  cursor: pointer;
+  padding: 4px 8px;
+  border-radius: 5px;
+  text-shadow: 0 1px 0 rgba($white_color, 1);
+  min-height: 14px;
+  .nomargin {
+    margin: 0;
+  }
+  &:hover {
+    background: -moz-linear-gradient(top, $white_color, $white_color, #cfcfcf);
+    background: -webkit-gradient(linear, left top, left bottom, from($white_color), color-stop(0.6, $white_color), to(#cfcfcf));
+    box-shadow: 0 1px 2px rgba(0,0,0,0.5);
+    text-decoration: none;
+    color: black;
+  }
+  &:active {
+    background: -moz-linear-gradient(top, #c2c3c0, #e4e5e4);
+    background: -webkit-gradient(linear, left top, left bottom, from(#c2c3c0), to(#e4e5e4));
+    box-shadow: none;
+    text-decoration: none;
+  }
+  &:focus {
+    text-decoration: none;
+    color: #000;
+    border-width: 2px;
+  }
+  &.dialogbutton {
+    float: right;
+    margin-left: 3px;
+    margin: 40px 4px 4px;
+  }
+  &.formbutton {
+    display: inline-block;
+    margin-left: 3px;
+    margin: 40px 4px 4px;
+  }
+  &.actionlink {
+    margin: 40px 0 0;
+  }
+  &.disabled, &[disabled] {
+    cursor: default;
+    background: transparent;
+    opacity: 0.4;
+
+    &:hover {
+      background: transparent;
+      box-shadow: none;
+    }
+  }
+  &.iconbutton {
+    display: inline-block;
+  }
+  &.tiny {
+    padding: 4px;
+    margin: 0;
+    &:active, &:focus {
+      margin: 0;
+      padding: 3px;
+    }
+  }
+}
+
 table {
   border-collapse: collapse;
   border: 1px solid $stroke_color;

data/app/controllers/katello/api/registry/registry_proxies_controller.rb

@@ -167,9 +167,11 @@ module Katello
       end
 
       if (manifest_response = redirect_client { Resources::Registry::Proxy.get(@_request.fullpath, headers) })
-        #for some requests, we get a redirect, but for others we get the actual manifest in response
+        #when pulp 2 is removed, this should no longer be needed, and all clients should be redirected
+        logger.debug filter_sensitive_data(manifest_response)
         results = JSON.parse(manifest_response)
-        response.header['Docker-Content-Digest'] = manifest_response.headers[:docker_content_digest]
+
+        response.header['Docker-Content-Digest'] = "sha256:#{Digest::SHA256.hexdigest(manifest_response)}"
         # https://docs.docker.com/registry/spec/manifest-v2-2/
         # If its v2 schema 2 only the mediaType attribute will be present in the manifest
         media_type = results['mediaType']
@@ -182,8 +184,8 @@ module Katello
                          'application/vnd.docker.distribution.manifest.v1+prettyjws'
                        end
         end
-        response.headers['Content-Type'] = media_type
-        render json: manifest_response
+
+        render json: manifest_response, content_type: media_type
       end
     end
 

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

@@ -4,8 +4,6 @@ module Katello
     include ForemanTasks::Triggers
     include AbstractController::Callbacks
 
-    before_action :deprecated, only: :deb_package_profile
-
     skip_before_action :authorize, :only => [:upload_package_profile, :upload_profiles, :deb_package_profile]
     before_action :find_host, :only => [:upload_package_profile, :upload_profiles, :deb_package_profile]
     before_action :authorize_client_or_user, :only => [:upload_package_profile, :upload_profiles, :deb_package_profile]
@@ -31,19 +29,6 @@ module Katello
       render :json => Resources::Candlepin::Consumer.get(@host.subscription_facet.uuid)
     end
 
-    api :PUT, "/systems/:id/deb_package_profile", N_("Update installed deb packages")
-    param :deb_package_profile, Hash, :required => true do
-      param :deb_packages, Array, :required => true do
-        param :name, String, :required => true
-        param :architecture, String, :required => true
-        param :version, String, :required => true
-      end
-    end
-    param :id, String, :desc => N_("UUID of the system"), :required => true
-    def deb_package_profile
-      upload_profiles
-    end
-
     def find_host(uuid = nil)
       params = request.path_parameters
       uuid ||= params[:id]
@@ -65,9 +50,5 @@ module Katello
       authorized = (User.current.uuid == @host.subscription_facet.uuid) if @host && User.consumer?
       authorized
     end
-
-    def deprecated
-      ::Foreman::Deprecation.api_deprecation_warning("it will be removed in Katello 4.0. Please use /consumers/:id/profiles instead.")
-    end
   end
 end

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

@@ -41,8 +41,6 @@ module Katello
             body_json['displayMessage'] = body_json['message']
           end
           response.body = body_json.to_s
-
-        # rubocop:disable Lint/SuppressedException
         rescue JSON::ParserError
           # Not a json response, leave as-is
         end
@@ -370,7 +368,7 @@ module Katello
 
       if (ak_names = params[:activation_keys])
         fail HttpErrors::NotFound, _("Organization not found") if organization.nil?
-        ak_names        = ak_names.split(",")
+        ak_names        = ak_names.split(",").uniq.compact
         activation_keys = ak_names.map do |ak_name|
           activation_key = organization.activation_keys.find_by(:name => ak_name)
           fail HttpErrors::NotFound, _("Couldn't find activation key '%s'") % ak_name unless activation_key

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

@@ -10,9 +10,9 @@ module Katello
     end
 
     def_param_group :content_credential do
-      param :name, :identifier, :action_aware => true, :required => true, :desc => N_("identifier of the content credential")
-      param :content_type, String, :action_aware => true, :required => true, :desc => N_("type of content")
-      param :content, String, :action_aware => true, :required => true, :desc => N_("public key block in DER encoding or certificate content")
+      param :name, :identifier, :action_aware => true, :required => true, :desc => N_('Name of the Content Credential')
+      param :content_type, String, :action_aware => true, :required => true, :desc => N_('Type of content: "cert", "gpg_key"')
+      param :content, String, :action_aware => true, :required => true, :desc => N_('Public key block in DER encoding or certificate content')
     end
 
     resource_description do
@@ -22,13 +22,13 @@ module Katello
         Content Credentials are used to store credentials like GPG Keys and Certificates for the authentication
         to Products / Repositories.
       DESC
-      api_version "v2"
+      api_version 'v2'
     end
 
-    api :GET, "/content_credentials", N_("List content credentials")
-    param :organization_id, :number, :desc => N_("organization identifier"), :required => true
-    param :name, String, :desc => N_("name of the Content Credential"), :required => false
-    param :content_type, String, :desc => N_("type of content"), :required => false
+    api :GET, "/content_credentials", N_('List Content Credentials')
+    param :organization_id, :number, :desc => N_('Organization identifier'), :required => true
+    param :name, String, :desc => N_('Name of the Content Credential'), :required => false
+    param :content_type, String, :desc => N_('Type of content'), :required => false
     param_group :search, Api::V2::ApiController
     def index
       respond(:collection => scoped_search(index_relation.distinct, :name, :asc))
@@ -41,15 +41,15 @@ module Katello
       query
     end
 
-    api :POST, "/content_credentials", N_("Create a content credential")
-    param :organization_id, :number, :desc => N_("organization identifier"), :required => true
+    api :POST, "/content_credentials", N_('Create a Content Credential')
+    param :organization_id, :number, :desc => N_('Organization identifier'), :required => true
     param_group :content_credential, :as => :create
     def create
       filepath = params.try(:[], :file_path).try(:path)
 
       content = nil
       if filepath
-        content = File.open(filepath, "rb") { |file| file.read }
+        content = File.open(filepath, 'rb') { |file| file.read }
       else
         content = params[:content]
       end
@@ -58,45 +58,45 @@ module Katello
       respond_for_create(:resource => content_credential)
     end
 
-    api :GET, "/content_credentials/:id", N_("Show a content credential")
-    param :id, :number, :desc => N_("content credential numeric identifier"), :required => true
+    api :GET, "/content_credentials/:id", N_('Show a Content Credential')
+    param :id, :number, :desc => N_('Content Credential numeric identifier'), :required => true
     def show
       respond_for_show(:resource => @content_credential)
     end
 
-    api :PUT, "/content_credentials/:id", N_("Update a content credential")
-    param :id, :number, :desc => N_("content credential numeric identifier"), :required => true
+    api :PUT, "/content_credentials/:id", N_('Update a Content Credential')
+    param :id, :number, :desc => N_('Content Credential ID'), :required => true
     param_group :content_credential
     def update
       sync_task(::Actions::Katello::GpgKey::Update, @content_credential, content_credential_params.to_h)
       respond_for_show(:resource => @content_credential)
     end
 
-    api :DELETE, "/content_credentials/:id", N_("Destroy a content credential")
-    param :id, :number, :desc => N_("content credential numeric identifier"), :required => true
+    api :DELETE, "/content_credentials/:id", N_('Destroy a Content Credential')
+    param :id, :number, :desc => N_('Content Credential ID'), :required => true
     def destroy
       @content_credential.destroy
       respond_for_destroy
     end
 
-    api :GET, "/content_credentials/:id/content", N_("Return the content of a content credential, used directly by yum")
+    api :GET, "/content_credentials/:id/content", N_('Return the content of a Content Credential, used directly by yum')
     param :id, :number, :required => true
     def content
       render(:plain => @content_credential.content, :layout => false)
     end
 
-    api :POST, "/content_credentials/:id/content", N_("Upload content credential contents")
-    param :id, :number, :desc => N_("content credential numeric identifier"), :required => true
-    param :content, File, :desc => N_("file contents"), :required => true
+    api :POST, "/content_credentials/:id/content", N_('Upload Content Credential contents')
+    param :id, :number, :desc => N_('Content Credential ID'), :required => true
+    param :content, File, :desc => N_('File contents'), :required => true
     def set_content
       filepath = params.try(:[], :content).try(:path)
 
       if filepath
-        content = File.open(filepath, "rb") { |file| file.read }
+        content = File.open(filepath, 'rb') { |file| file.read }
         @content_credential.update!(:content => content)
-        render :json => {:status => "success"}
+        render :json => {:status => 'success'}
       else
-        fail HttpErrors::BadRequest, _("No file uploaded")
+        fail HttpErrors::BadRequest, _('No file uploaded')
       end
     end
 

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

@@ -58,7 +58,7 @@ module Katello
                                                                 organization: @organization,
                                                                 create_by_default: false)
       if @view.blank?
-        msg = _("Unable to incrementally export. Do a Full Export the library content "\
+        msg = _("Unable to incrementally export. Do a Full Export on the library content "\
                 "before updating from the latest increment.")
         fail HttpErrors::BadRequest, msg
       end

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

@@ -10,6 +10,9 @@ module Katello
     param :destination_server, String, :desc => N_("Destination Server name"), :required => false
     param :organization_id, :number, :desc => N_("Organization identifier"), :required => false
     param :id, :number, :desc => N_("Content view version export history identifier"), :required => false
+    param :type, ::Katello::ContentViewVersionExportHistory::EXPORT_TYPES,
+                                  :desc => N_("Export Types"),
+                                  :required => false
     param_group :search, Api::V2::ApiController
     add_scoped_search_description_for(ContentViewVersionExportHistory)
     def index
@@ -17,6 +20,7 @@ module Katello
       history = history.where(:id => params[:id]) unless params[:id].blank?
       history = history.where(:content_view_version_id => params[:content_view_version_id]) unless params[:content_view_version_id].blank?
       history = history.where(:destination_server => params[:destination_server]) unless params[:destination_server].blank?
+      history = history.where(:export_type => params[:type]) unless params[:type].blank?
       history = history.with_organization_id(params[:organization_id]) unless params[:organization_id].blank?
       history = history.with_content_view_id(params[:content_view_id]) unless params[:content_view_id].blank?
       respond_with_template_collection("index", 'content_view_version_export_histories',

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

@@ -190,8 +190,8 @@ module Katello
 
     api :PUT, "/content_views/:id/remove", N_("Remove versions and/or environments from a content view and reassign systems and keys")
     param :id, :number, :desc => N_("content view numeric identifier"), :required => true
-    param :environment_ids, :number, :desc => N_("environment numeric identifiers to be removed")
-    param :content_view_version_ids, :number, :desc => N_("content view version identifiers to be deleted")
+    param :environment_ids, Array, of: :number, :desc => N_("environment numeric identifiers to be removed")
+    param :content_view_version_ids, Array, of: :number, :desc => N_("content view version identifiers to be deleted")
     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")

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

@@ -42,9 +42,8 @@ module Katello
     def index_response(reload_host = false)
       # Host needs to be reloaded because of lazy accessor
       @host.reload if reload_host
-      entitlements = @host.subscription_facet.candlepin_consumer.entitlements
-      subscriptions = entitlements.map { |entitlement| ::Katello::HostSubscriptionPresenter.new(entitlement) }
-      full_result_response(subscriptions)
+      presenter = ::Katello::HostSubscriptionsPresenter.new(@host)
+      full_result_response(presenter.subscriptions)
     end
 
     api :PUT, "/hosts/:host_id/subscriptions/auto_attach", N_("Trigger an auto-attach of subscriptions")

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

@@ -25,7 +25,6 @@ module Katello
     before_action(:only => [:create, :update]) { find_content_credential CONTENT_CREDENTIAL_SSL_CA_CERT_TYPE }
     before_action(:only => [:create, :update]) { find_content_credential CONTENT_CREDENTIAL_SSL_CLIENT_CERT_TYPE }
     before_action(:only => [:create, :update]) { find_content_credential CONTENT_CREDENTIAL_SSL_CLIENT_KEY_TYPE }
-    before_action :check_ignore_global_proxy, :only => [ :update, :create ]
     skip_before_action :authorize, :only => [:gpg_key_content]
     skip_before_action :check_media_type, :only => [:upload_content]
 
@@ -45,7 +44,7 @@ module Katello
       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", "background"], :desc => N_("download policy for yum repos (either 'immediate', 'on_demand', or 'background (deprecated)')")
+      param :download_policy, ["immediate", "on_demand"], :desc => N_("download policy for yum 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")
       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")
@@ -56,11 +55,11 @@ module Katello
       param :deb_releases, String, :desc => N_("comma-separated list of releases to be synced from deb-archive")
       param :deb_components, String, :desc => N_("comma-separated list of repo components to be synced from deb-archive")
       param :deb_architectures, String, :desc => N_("comma-separated list of architectures to be synced from deb-archive")
-      param :ignore_global_proxy, :bool, :desc => N_("if true, will ignore the globally configured proxy when syncing"), :deprecated => true
       param :ignorable_content, Array, :desc => N_("List of content units to ignore while syncing a yum repository. Must be subset of %s") % RootRepository::IGNORABLE_CONTENT_UNIT_TYPES.join(",")
       param :ansible_collection_requirements, String, :desc => N_("Contents of requirement yaml file to sync from URL")
       param :http_proxy_policy, ::Katello::RootRepository::HTTP_PROXY_POLICIES, :desc => N_("policies for HTTP proxy for content sync")
       param :http_proxy_id, :number, :desc => N_("ID of a HTTP Proxy")
+      param :arch, String, :desc => N_("Architecture of content in the repository")
     end
 
     def_param_group :repo_create do
@@ -226,10 +225,6 @@ module Katello
         fail HttpErrors::UnprocessableEntity, msg
       end
 
-      if repo_params['content_type'] == "puppet" || repo_params['content_type'] == "ostree"
-        ::Foreman::Deprecation.api_deprecation_warning("Puppet and OSTree will no longer be supported in Katello 4.0")
-      end
-
       gpg_key = get_content_credential(repo_params, CONTENT_CREDENTIAL_GPG_KEY_TYPE)
       ssl_ca_cert = get_content_credential(repo_params, CONTENT_CREDENTIAL_SSL_CA_CERT_TYPE)
       ssl_client_cert = get_content_credential(repo_params, CONTENT_CREDENTIAL_SSL_CLIENT_CERT_TYPE)
@@ -495,17 +490,6 @@ module Katello
       params.require(:repository).permit(*keys).to_h.with_indifferent_access
     end
 
-    def check_ignore_global_proxy
-      if params.key?(:ignore_global_proxy)
-        ::Foreman::Deprecation.api_deprecation_warning("The parameter ignore_global_proxy will be removed in a future Katello release. Please update to use the http_proxy_policy parameter.")
-        if ::Foreman::Cast.to_bool(params[:ignore_global_proxy])
-          params[:repository][:http_proxy_policy] = RootRepository::NO_DEFAULT_HTTP_PROXY
-        else
-          params[:repository][:http_proxy_policy] = RootRepository::GLOBAL_DEFAULT_HTTP_PROXY
-        end
-      end
-    end
-
     def get_content_credential(repo_params, content_type)
       credential_value = @product.send(content_type)
 
@@ -517,7 +501,7 @@ module Katello
     end
 
     # rubocop:disable Metrics/CyclomaticComplexity
-    def construct_repo_from_params(repo_params)
+    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)

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

@@ -0,0 +1,34 @@
+module Katello
+  class Api::V2::SimpleContentAccessController < Api::V2::ApiController
+    before_action :find_organization
+    before_action :check_upstream_connection
+
+    resource_description do
+      description "Red Hat subscriptions management platform."
+      api_version 'v2'
+    end
+
+    api :GET, "/organizations/:organization_id/simple_content_access/eligible",
+      N_("Check if the specified organization is eligible for Simple Content Access")
+    def eligible
+      eligible = @organization.upstream_consumer.simple_content_access_eligible?
+      render json: { simple_content_access_eligible: eligible }
+    end
+
+    api :PUT, "/organizations/:organization_id/simple_content_access/enable",
+      N_("Enable simple content access for a manifest")
+    param :organization_id, :number, :desc => N_("Organization ID"), :required => true
+    def enable
+      task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Enable, params[:organization_id])
+      respond_for_async :resource => task
+    end
+
+    api :PUT, "/organizations/:organization_id/simple_content_access/disable",
+      N_("Disable simple content access for a manifest")
+    param :organization_id, :number, :desc => N_("Organization ID"), :required => true
+    def disable
+      task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Disable, params[:organization_id])
+      respond_for_async :resource => task
+    end
+  end
+end

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

@@ -41,7 +41,7 @@ module Katello
                         :start_date, :end_date, :available, :quantity, :account_number, :contract_number,
                         :support_level, :ram, :stacking_id, :multi_entitlement, :type, :product_id,
                         :unmapped_guest, :virt_only, :virt_who, :upstream?],
-                       ['Pool Id', 'Subscription Id', 'Name', 'Candlepin Id', 'Organization Id',
+                       ['Pool Id Number', 'Subscription Id', 'Name', 'Pool Id', 'Organization Id',
                         'Sockets', 'Cores', 'Start Date', 'End Date', 'Available', 'Quantity', 'Account Number',
                         'Contract Number', 'Support Level', 'RAM', 'Stacking Id', 'Multi Entitlement', 'Type',
                         'Product Id', 'Unmapped Guest', 'Virt Only', 'Requires Virt Who', 'Upstream'])

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

@@ -2,7 +2,7 @@ module Katello
   class Api::V2::UpstreamSubscriptionsController < Api::V2::ApiController
     before_action :find_organization
     before_action :check_upstream_connection
-
+    before_action :deprecated, only: [:simple_content_access_eligible, :enable_simple_content_access, :disable_simple_content_access]
     resource_description do
       description "Red Hat subscriptions management platform."
       api_version 'v2'
@@ -78,14 +78,14 @@ module Katello
     end
 
     api :GET, "/organizations/:organization_id/upstream_subscriptions/simple_content_access/eligible",
-      N_("Check if the specified organization is eligible for Simple Content Access")
+      N_("Check if the specified organization is eligible for Simple Content Access"), :deprecated => true
     def simple_content_access_eligible
       eligible = @organization.upstream_consumer.simple_content_access_eligible?
       render json: { simple_content_access_eligible: eligible }
     end
 
     api :PUT, "/organizations/:organization_id/upstream_subscriptions/simple_content_access/enable",
-      N_("Enable simple content access for a manifest")
+      N_("Enable simple content access for a manifest"), :deprecated => true
     param :organization_id, :number, :desc => N_("Organization ID"), :required => true
     def enable_simple_content_access
       task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Enable, params[:organization_id])
@@ -93,7 +93,7 @@ module Katello
     end
 
     api :PUT, "/organizations/:organization_id/upstream_subscriptions/simple_content_access/disable",
-      N_("Disable simple content access for a manifest")
+      N_("Disable simple content access for a manifest"), :deprecated => true
     param :organization_id, :number, :desc => N_("Organization ID"), :required => true
     def disable_simple_content_access
       task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Disable, params[:organization_id])
@@ -124,5 +124,9 @@ module Katello
         { "pool" => pool[:id], "quantity" => pool[:quantity] } if pool
       end
     end
+
+    def deprecated
+      ::Foreman::Deprecation.api_deprecation_warning("it will be removed in Katello 4.0, Please see /api/v2/simple_content_access")
+    end
   end
 end

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

@@ -39,20 +39,7 @@ module Katello
       end
 
       def throw_resource_not_found(name: resource_name, id: params[:id])
-        perms_message = "Potential missing permissions: " +
-          missing_permissions.map(&:name).join(', ')
-        fail HttpErrors::NotFound, _("Could not find %{name} resource with id %{id}. %{perms_message}") % {id: id, name: name, perms_message: perms_message}
-      end
-
-      def missing_permissions
-        missing_perms = ::Foreman::AccessControl.permissions_for_controller_action(path_to_authenticate)
-
-        # promote_or_remove_content_views_to_environments has a special relationship to promote_or_remove_content_views
-        if path_to_authenticate["controller"] == "katello/api/v2/content_view_versions" &&
-            path_to_authenticate["action"].in?(["promote", "remove_from_environment", "remove", "republish_repositories"])
-          missing_perms << ::Permission.find_by(name: "promote_or_remove_content_views_to_environments")
-        end
-        missing_perms
+        fail HttpErrors::NotFound, _("Could not find %{name} resource with id %{id}") % {id: id, name: name}
       end
 
       def throw_resources_not_found(name:, expected_ids: [])

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

@@ -107,7 +107,7 @@ module Katello
       true
     end
 
-    def authorize_remove_environments(view, options)
+    def authorize_remove_environments(view, options) # rubocop:disable Metrics/CyclomaticComplexity
       env_ids = options[:environment_ids]
 
       return true if env_ids.blank?

data/app/helpers/katello/sync_management_helper.rb

@@ -35,8 +35,6 @@ module Katello
     module RepoMethods
       # returns all repos in hash representation with minors and arch children included
       def collect_repos(products, env, include_feedless = true)
-        Glue::Pulp::Repos.prepopulate! products, env, []
-
         products.map do |prod|
           minor_repos, repos_without_minor = collect_minor(prod.repos(env, nil, include_feedless))
           { :name => prod.name, :object => prod, :id => prod.id, :type => "product", :repos => repos_without_minor,

data/app/lib/actions/candlepin/environment/create.rb

@@ -13,7 +13,7 @@ module Actions
           ::Katello::Resources::Candlepin::Environment.create(input['organization_label'],
                                                    input['cp_id'],
                                                    input['name'],
-                                                   input['description'])
+                                                   input['description'].try(:truncate, 255))
         end
       end
     end

data/app/lib/actions/candlepin/environment/set_content.rb

@@ -9,7 +9,7 @@ module Actions
                     :new_content_id => new_content_id)
         end
 
-        def finalize
+        def finalize # rubocop:disable Metrics/AbcSize
           content_view = ::Katello::ContentView.find(input[:content_view_id])
           environment = ::Katello::KTEnvironment.find(input[:environment_id])
           content_ids = content_view.repos(environment).map(&:content_id).uniq.compact

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

@@ -4,17 +4,15 @@ module Actions
       class Create < Actions::EntryAction
         def plan(activation_key, params = {})
           activation_key.save!
-          if ::SETTINGS[:katello][:use_cp]
-            cp_create = plan_action(Candlepin::ActivationKey::Create,
-                                    organization_label: activation_key.organization.label,
-                                    auto_attach: activation_key.auto_attach,
-                                    service_level: params[:service_level],
-                                    release_version: activation_key.release_version,
-                                    purpose_role: activation_key.purpose_role,
-                                    purpose_usage: activation_key.purpose_usage,
-                                    purpose_addons: activation_key.purpose_addons.pluck(:name))
-            cp_id = cp_create.output[:response][:id]
-          end
+          cp_create = plan_action(Candlepin::ActivationKey::Create,
+                                  organization_label: activation_key.organization.label,
+                                  auto_attach: activation_key.auto_attach,
+                                  service_level: params[:service_level],
+                                  release_version: activation_key.release_version,
+                                  purpose_role: activation_key.purpose_role,
+                                  purpose_usage: activation_key.purpose_usage,
+                                  purpose_addons: activation_key.purpose_addons.pluck(:name))
+          cp_id = cp_create.output[:response][:id]
           action_subject(activation_key, :cp_id => cp_id)
           plan_self
         end

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

@@ -30,18 +30,18 @@ module Actions
 
           fail _("Action not allowed for the default smart proxy.") if smart_proxy.pulp_primary?
 
-          smart_proxy_helper = ::Katello::SmartProxyHelper.new(smart_proxy)
-          repositories = smart_proxy_helper.combined_repos_available_to_capsule(environment, content_view, repository)
-
-          smart_proxy.ping_pulp if repositories.any? { |repo| !smart_proxy.pulp3_support?(repo) }
-
           refresh_options = options.merge(content_view: content_view,
                                              environment:  environment,
                                              repository: repository)
           sequence do
-            plan_action(Actions::Pulp::Orchestration::Repository::RefreshRepos, smart_proxy, refresh_options) if smart_proxy.has_feature?(SmartProxy::PULP_NODE_FEATURE)
-            plan_action(Actions::Pulp3::CapsuleContent::RefreshContentGuard, smart_proxy) if repositories.any? { |repo| smart_proxy.pulp3_support?(repo) }
-            plan_action(Actions::Pulp3::Orchestration::Repository::RefreshRepos, smart_proxy, refresh_options) if smart_proxy.pulp3_enabled?
+            if smart_proxy.has_feature?(SmartProxy::PULP_NODE_FEATURE)
+              plan_action(Actions::Pulp::Orchestration::Repository::RefreshRepos, smart_proxy, refresh_options)
+            end
+
+            if smart_proxy.has_feature?(SmartProxy::PULP3_FEATURE)
+              plan_action(Actions::Pulp3::CapsuleContent::RefreshContentGuard, smart_proxy)
+              plan_action(Actions::Pulp3::Orchestration::Repository::RefreshRepos, smart_proxy, refresh_options)
+            end
             plan_action(SyncCapsule, smart_proxy, refresh_options)
           end
         end

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

@@ -35,6 +35,15 @@ module Actions
               end
             end
           end
+          update_unauthenticated_repo_list(smart_proxy) if smart_proxy.has_feature?("Container_Gateway")
+        end
+
+        def update_unauthenticated_repo_list(smart_proxy)
+          unauthenticated_repo_list =
+            ::Katello::SmartProxyHelper.new(smart_proxy).combined_repos_available_to_capsule.select do |repo|
+              repo.docker? && repo.environment.registry_unauthenticated_pull
+            end
+          smart_proxy.update_unauthenticated_repo_list(unauthenticated_repo_list.map(&:container_repository_name))
         end
 
         def repos_to_sync(smart_proxy, environment, content_view, repository, skip_metatadata_check = false)