katello 4.5.0.rc1 → 4.5.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2fd3647b864eba8c468c3eea9e6d6d867a43192dcb29c0758f0771085fb1621
-  data.tar.gz: 764696ceedc7d01432439f6ac00012be79383073c35f0d491cbf4a1da1af6a77
+  metadata.gz: 5922047abc1b1bd8649e30bbaaf5eaf2e09f09bc9abb5e1b61920c0b84b1b57b
+  data.tar.gz: 8105c45f9d16ca034430e89224f9bb81fa95c02d38ca638268864e34a9d57e2b
 SHA512:
-  metadata.gz: d67f10a68cf3f81316e77099d82266960fc5887513004f5e35daa47c591ccc44f2a8ba78f54e8ef84c6ba8bc53d5a42c0621d842c70fa5b20c3dd61cae90e648
-  data.tar.gz: 5c798d57fbde2baf9c9d62c172e294ade51f32e2d822ed56c63983f48d8f690abd0d2f625e061c7318d4680e916d477fc64025974396ead7f17b919bf06a83c4
+  metadata.gz: '069335f24169763ce80081693498c668a115893acb4e9c7b2a1486d54d5394f53b9d21cb6442acd6cba990f07d58e6b75f7ec0d9e32515165226fb833874a311'
+  data.tar.gz: 22cda386e45a6d989daff56fe3897d07a75205282b2aa1e901bf7c333fd38d72869ab3dd808641a5535d8f72063c2961aa575c2420dfa51c2f98a3ab4152b28c

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

@@ -75,8 +75,15 @@ function ktSetParam(name, value) {
     var paramContainer = ktFindParamContainer(name);
     if(value) {
         if(! paramContainer) { // we create the param for kt_activation_keys
-            $("div#parameters a[target~='#global_parameters_table']").click();
-            paramContainer = $("div#parameters .fields").last();
+            var addParameterButton = $('#parameters').find('.btn-primary');
+            addParameterButton.click();
+            var directionOfAddedItems = addParameterButton.attr('direction');
+            var paramContainer = $('#parameters').find('.fields');
+            if(directionOfAddedItems === 'append'){
+                paramContainer = paramContainer.last();
+            } else {
+                paramContainer = paramContainer.first();
+            }
             paramContainer.find("input[name*='name']").val(name);
         }
         paramContainer.find("textarea").val(value);

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

@@ -177,6 +177,9 @@ module Katello
                        end
         end
         response.headers['Content-Type'] = media_type
+        length = manifest_response.try(:body).try(:size)
+        length ||= 0
+        response.header['Content-Length'] = "#{length}"
         render json: manifest_response
       end
     end

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

@@ -0,0 +1,44 @@
+module Katello
+  class Api::V2::AlternateContentSourcesBulkActionsController < Api::V2::ApiController
+    before_action :find_alternate_content_sources
+
+    api :PUT, '/alternate_content_sources/bulk/destroy', N_('Destroy one or more alternate content sources')
+    param :ids, Array, desc: N_('List of alternate content source IDs'), required: true
+    def destroy_alternate_content_sources
+      deletable_alternate_content_sources = @alternate_content_sources.deletable
+
+      if deletable_alternate_content_sources.empty?
+        msg = _("Unable to delete any alternate content source. You either do not have the permission to"\
+          " delete, or none of the alternate content sources exist.")
+        fail HttpErrors::UnprocessableEntity, msg
+      end
+      task = async_task(::Actions::BulkAction,
+                        ::Actions::Katello::AlternateContentSource::Destroy,
+                        deletable_alternate_content_sources)
+      respond_for_async :resource => task
+    end
+
+    api :POST, '/alternate_content_sources/bulk/refresh', N_('Refresh alternate content sources')
+    param :ids, Array, desc: N_('List of alternate content source IDs'), required: true
+    def refresh_alternate_content_sources
+      refreshable_alternate_content_sources = @alternate_content_sources.editable
+      if refreshable_alternate_content_sources.empty?
+        msg = _("Unable to refresh any alternate content source. You either do not have the permission to"\
+                " refresh, or none of the alternate content sources exist.")
+        fail HttpErrors::UnprocessableEntity, msg
+      else
+        task = async_task(::Actions::BulkAction,
+                          ::Actions::Katello::AlternateContentSource::Refresh,
+                          refreshable_alternate_content_sources)
+        respond_for_async resource: task
+      end
+    end
+
+    private
+
+    def find_alternate_content_sources
+      params.require(:ids)
+      @alternate_content_sources = AlternateContentSource.readable.where(id: params[:ids])
+    end
+  end
+end

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

@@ -2,8 +2,10 @@ module Katello
   class Api::V2::AlternateContentSourcesController < Api::V2::ApiController
     include Katello::Concerns::FilteredAutoCompleteSearch
 
-    before_action :find_authorized_katello_resource, :only => [:show, :update, :destroy]
-    before_action :find_smart_proxies
+    acs_wrap_params = AlternateContentSource.attribute_names + [:smart_proxy_ids, :smart_proxy_names]
+    wrap_parameters :alternate_content_source, include: acs_wrap_params
+
+    before_action :find_authorized_katello_resource, only: [:show, :update, :destroy, :refresh]
 
     def_param_group :acs do
       param :name, String, desc: N_("Name of the alternate content source")
@@ -11,6 +13,7 @@ module Katello
       param :base_url, String, desc: N_('Base URL for finding alternate content'), required: false
       param :subpaths, Array, desc: N_('Path suffixes for finding alternate content'), required: false
       param :smart_proxy_ids, Array, desc: N_("Ids of smart proxies to associate"), required: false
+      param :smart_proxy_names, Array, desc: N_("Names of smart proxies to associate"), required: false
       param :content_type, RepositoryTypeManager.defined_repository_types.keys & AlternateContentSource::CONTENT_TYPES, desc: N_("The content type for the Alternate Content Source"), required: false
       param :alternate_content_source_type, AlternateContentSource::ACS_TYPES, desc: N_("The Alternate Content Source type")
       param :upstream_username, String, desc: N_("Basic authentication username"), required: false
@@ -54,7 +57,8 @@ module Katello
     api :POST, '/alternate_content_sources', N_('Create an ACS')
     param_group :acs
     def create
-      @alternate_content_source = ::Katello::AlternateContentSource.new(acs_params)
+      find_smart_proxies
+      @alternate_content_source = ::Katello::AlternateContentSource.new(acs_params.except(:smart_proxy_ids, :smart_proxy_names))
       sync_task(::Actions::Katello::AlternateContentSource::Create, @alternate_content_source, @smart_proxies)
       @alternate_content_source.reload
       respond_for_create(resource: @alternate_content_source)
@@ -67,8 +71,12 @@ module Katello
       # If a user doesn't include smart proxies in the update call, don't accidentally remove all of them.
       if params[:smart_proxy_ids].nil?
         @smart_proxies = @alternate_content_source.smart_proxies
+      elsif params[:smart_proxy_ids].empty?
+        @smart_proxies = []
+      else
+        find_smart_proxies
       end
-      sync_task(::Actions::Katello::AlternateContentSource::Update, @alternate_content_source, @smart_proxies, acs_params)
+      sync_task(::Actions::Katello::AlternateContentSource::Update, @alternate_content_source, @smart_proxies, acs_params.except(:smart_proxy_ids))
       respond_for_show(:resource => @alternate_content_source)
     end
 
@@ -79,10 +87,17 @@ module Katello
       respond_for_destroy
     end
 
+    api :POST, '/alternate_content_sources/:id/refresh', N_('Refresh an alternate content source')
+    param :id, :number, :required => true, :desc => N_("Alternate content source ID")
+    def refresh
+      task = async_task(::Actions::Katello::AlternateContentSource::Refresh, @alternate_content_source)
+      respond_for_async :resource => task
+    end
+
     protected
 
     def acs_params
-      keys = [:name, :label, :base_url, {subpaths: []}, {smart_proxy_ids: []}, :content_type, :alternate_content_source_type,
+      keys = [:name, :label, :base_url, {subpaths: []}, {smart_proxy_ids: []}, {smart_proxy_names: []}, :content_type, :alternate_content_source_type,
               :upstream_username, :upstream_password, :ssl_ca_cert_id, :ssl_client_cert_id, :ssl_client_key_id,
               :http_proxy_id, :verify_ssl]
       params.require(:alternate_content_source).permit(*keys).to_h.with_indifferent_access
@@ -91,7 +106,15 @@ module Katello
     def find_smart_proxies
       if params[:smart_proxy_ids]
         @smart_proxies = ::SmartProxy.where(id: params[:smart_proxy_ids])
-        fail HttpErrors::NotFound, _("Couldn't find smart proxies with id '%s'") % params[:smart_proxy_ids].to_sentence if @smart_proxies.empty?
+      elsif params[:smart_proxy_names]
+        @smart_proxies = ::SmartProxy.where(name: params[:smart_proxy_names])
+      end
+      if params[:smart_proxy_ids] && @smart_proxies.length < params[:smart_proxy_ids].length
+        missing_smart_proxies = params[:smart_proxy_ids] - @smart_proxies.pluck(:id)
+        fail HttpErrors::NotFound, _("Couldn't find smart proxies with id '%s'") % missing_smart_proxies.to_sentence
+      elsif params[:smart_proxy_names] && @smart_proxies.length < params[:smart_proxy_names].length
+        missing_smart_proxies = params[:smart_proxy_names] - @smart_proxies.pluck(:name)
+        fail HttpErrors::NotFound, _("Couldn't find smart proxies with name '%s'") % missing_smart_proxies.to_sentence
       end
     end
   end

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

@@ -57,7 +57,7 @@ module Katello
               else
                 query
               end
-      custom_sort = ->(sort_query) { sort_query.joins(join_query).order(order_query) }
+      custom_sort = ->(sort_query) { sort_query.joins(join_query).order(Arel.sql(order_query)) }
       options = { resource_class: Katello::ContentView, custom_sort: custom_sort }
       collection = scoped_search(query, nil, nil, options)
       collection[:results] = ComponentViewPresenter.component_presenter(@view, params[:status], views: collection[:results])

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

@@ -28,7 +28,7 @@ module Katello
       query = query.with_type(params[:content_type]) if params[:content_type]
       # Use custom sort to perform the join and order since we need to order by specific content_view
       # and the ORDER BY query needs access to the katello_content_view_repositories table
-      custom_sort = ->(sort_query) { sort_query.joins(:root).joins(join_query).order(order_query) }
+      custom_sort = ->(sort_query) { sort_query.joins(:root).joins(join_query).order(Arel.sql(order_query)) }
       options = { resource_class: Katello::Repository, custom_sort: custom_sort }
       repos = scoped_search(query, nil, nil, options)
 

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

@@ -420,8 +420,8 @@ module Katello
       param 'id', String, :required => true
       param 'content_unit_id', String
       param 'size', String
-      param 'checksum', String, :required => true
-      param 'name', String, :required => true, :desc => N_("Needs to only be set for file repositories or docker tags")
+      param 'checksum', String
+      param 'name', String, :desc => N_("Needs to only be set for file repositories or docker tags")
       param 'digest', String, :desc => N_("Needs to only be set for docker tags")
     end
     Katello::RepositoryTypeManager.generic_repository_types.each_pair do |_, repo_type|
@@ -439,12 +439,6 @@ module Katello
       end
 
       uploads = (params[:uploads] || []).map do |upload|
-        if upload[:checksum].nil?
-          fail HttpErrors::BadRequest, _('Checksum is a required parameter.')
-        end
-        if upload[:name].nil?
-          fail HttpErrors::BadRequest, _('Name is a required parameter.')
-        end
         upload.permit(:id, :content_unit_id, :size, :checksum, :name, :digest).to_h
       end
 

data/app/lib/actions/katello/alternate_content_source/refresh.rb

@@ -0,0 +1,27 @@
+module Actions
+  module Katello
+    module AlternateContentSource
+      class Refresh < Actions::EntryAction
+        def plan(acs)
+          action_subject(acs)
+          concurrence do
+            acs.smart_proxies.each do |smart_proxy|
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Refresh,
+                          acs, smart_proxy)
+            end
+          end
+          plan_self(acs_id: acs.id)
+        end
+
+        def finalize
+          acs = ::Katello::AlternateContentSource.find_by(id: input[:acs_id])
+          acs.update(last_refreshed: ::DateTime.now)
+        end
+
+        def humanized_name
+          _("Refresh Alternate Content Source")
+        end
+      end
+    end
+  end
+end

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

@@ -21,7 +21,7 @@ module Actions
             full_path = if cdn_configuration.redhat_cdn?
                           root.product.repo_url(root.library_instance.generate_content_path)
                         elsif cdn_configuration.network_sync?
-                          resource.repository_url(content_label: root.content.label)
+                          resource.repository_url(content_label: root.content.label, arch: root.arch, major: root.major, minor: root.minor)
                         end
             plan_action(::Actions::Katello::Repository::Update, root, url: full_path)
           end

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

@@ -41,7 +41,7 @@ module Actions
                                                           :triggered_by => options[:triggered_by]
                                                          )
           source_repositories = []
-          content_view.publish_repositories(options[:override_cvvs]) do |repositories|
+          content_view.publish_repositories(options[:override_components]) do |repositories|
             source_repositories += [repositories]
           end
 

data/app/lib/actions/katello/organization/manifest_refresh.rb

@@ -9,7 +9,7 @@ module Actions
         def plan(organization)
           action_subject organization
           manifest_update = organization.products.redhat.any?
-          path = "/tmp/#{rand}.zip"
+          path = File.join(::Rails.root, "tmp", "#{rand}.zip")
           details = organization.owner_details
           upstream = details['upstreamConsumer'].blank? ? {} : details['upstreamConsumer']
 

data/app/lib/actions/pulp3/alternate_content_source/delete.rb

@@ -1,12 +1,12 @@
 module Actions
   module Pulp3
     module AlternateContentSource
-      class Delete < Pulp3::Abstract
+      class Delete < Pulp3::AbstractAsyncTask
         def plan(acs, smart_proxy)
           plan_self(:acs_id => acs.id, :smart_proxy_id => smart_proxy.id)
         end
 
-        def run
+        def invoke_external_task
           acs = ::Katello::AlternateContentSource.find(input[:acs_id])
           output[:response] = acs.backend_service(smart_proxy).delete_alternate_content_source
         end

data/app/lib/actions/pulp3/alternate_content_source/delete_remote.rb

@@ -1,12 +1,12 @@
 module Actions
   module Pulp3
     module AlternateContentSource
-      class DeleteRemote < Pulp3::Abstract
+      class DeleteRemote < Pulp3::AbstractAsyncTask
         def plan(acs, smart_proxy)
           plan_self(:acs_id => acs.id, :smart_proxy_id => smart_proxy.id)
         end
 
-        def run
+        def invoke_external_task
           acs = ::Katello::AlternateContentSource.find(input[:acs_id])
           output[:response] = acs.backend_service(smart_proxy).delete_remote
         end

data/app/lib/actions/pulp3/alternate_content_source/refresh.rb

@@ -0,0 +1,23 @@
+module Actions
+  module Pulp3
+    module AlternateContentSource
+      class Refresh < Pulp3::AbstractAsyncTask
+        def plan(acs, smart_proxy)
+          plan_self(acs_id: acs.id, smart_proxy_id: smart_proxy.id)
+        end
+
+        def invoke_external_task
+          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
+          output[:response] = acs.backend_service(smart_proxy).refresh
+        end
+
+        def rescue_strategy_for_self
+          # There are various reasons why refreshing fails, but not all of them are
+          # fatal. When failing to refresh, we continue with the task ending up
+          # in the warning state, but don't lock further refreshing
+          Dynflow::Action::Rescue::Skip
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/alternate_content_source/update.rb

@@ -1,12 +1,12 @@
 module Actions
   module Pulp3
     module AlternateContentSource
-      class Update < Pulp3::Abstract
+      class Update < Pulp3::AbstractAsyncTask
         def plan(acs, smart_proxy)
           plan_self(:acs_id => acs.id, :smart_proxy_id => smart_proxy.id)
         end
 
-        def run
+        def invoke_external_task
           acs = ::Katello::AlternateContentSource.find(input[:acs_id])
           output[:response] = acs.backend_service(smart_proxy).update
         end

data/app/lib/actions/pulp3/alternate_content_source/update_remote.rb

@@ -1,13 +1,13 @@
 module Actions
   module Pulp3
     module AlternateContentSource
-      class UpdateRemote < Pulp3::Abstract
+      class UpdateRemote < Pulp3::AbstractAsyncTask
         def plan(acs, smart_proxy)
           acs.backend_service(smart_proxy).create_test_remote
           plan_self(:acs_id => acs.id, :smart_proxy_id => smart_proxy.id)
         end
 
-        def run
+        def invoke_external_task
           acs = ::Katello::AlternateContentSource.find(input[:acs_id])
           output[:response] = acs.backend_service(smart_proxy).update_remote
         end

data/app/lib/actions/pulp3/orchestration/alternate_content_source/create.rb

@@ -7,8 +7,6 @@ module Actions
             sequence do
               plan_action(Actions::Pulp3::AlternateContentSource::CreateRemote, acs, smart_proxy)
               plan_action(Actions::Pulp3::AlternateContentSource::Create, acs, smart_proxy)
-              # TODO: Should the hrefs be committed to acs records in a new action? Is it okay to be in the service class methods?
-              #  -> i.e. do we need something like SaveVersions?
             end
           end
         end

data/app/lib/actions/pulp3/orchestration/alternate_content_source/refresh.rb

@@ -0,0 +1,15 @@
+module Actions
+  module Pulp3
+    module Orchestration
+      module AlternateContentSource
+        class Refresh < Pulp3::Abstract
+          def plan(acs, smart_proxy)
+            sequence do
+              plan_action(Actions::Pulp3::AlternateContentSource::Refresh, acs, smart_proxy)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/orchestration/alternate_content_source/update.rb

@@ -7,8 +7,6 @@ module Actions
             sequence do
               plan_action(Actions::Pulp3::AlternateContentSource::UpdateRemote, acs, smart_proxy)
               plan_action(Actions::Pulp3::AlternateContentSource::Update, acs, smart_proxy)
-              # TODO: Should the hrefs be committed to acs records in a new action? Is it okay to be in the service class methods?
-              #  -> i.e. do we need something like SaveVersions?
             end
           end
         end

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

@@ -3,7 +3,6 @@ module Actions
     module Repository
       class RefreshDistribution < Pulp3::AbstractAsyncTask
         include Helpers::Presenter
-        middleware.use Actions::Middleware::ExecuteIfContentsChanged
 
         def plan(repository, smart_proxy, options = {})
           smart_proxy = SmartProxy.unscoped.find_by(id: smart_proxy) #support bulk actions
@@ -16,11 +15,9 @@ module Actions
               :repository_id => repository.id,
               :smart_proxy_id => smart_proxy.id
             }
-            refresh_options[:contents_changed] if options.key?(:contents_changed)
             action = plan_self(refresh_options)
 
-            plan_action(SaveDistributionReferences, repository, smart_proxy,
-                        action.output, :contents_changed => options[:contents_changed])
+            plan_action(SaveDistributionReferences, repository, smart_proxy, action.output)
           end
         end
 

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

@@ -5,7 +5,7 @@ module Actions
         #This task creates a content unit and may or may not create a new repository version in the process
         def plan(file, repository, smart_proxy, tasks, unit_type_id, options = {})
           options[:file_name] = file[:filename]
-          options[:sha256] = file[:sha256] || Digest::SHA256.hexdigest(File.read(file[:path]))
+          options[:sha256] = file[:sha256] || (Digest::SHA256.hexdigest(File.read(file[:path])) if file[:path].present?)
           plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id, :tasks => tasks, :unit_type_id => unit_type_id, :options => options)
         end
 

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

@@ -2,8 +2,6 @@ module Actions
   module Pulp3
     module Repository
       class SaveDistributionReferences < Pulp3::Abstract
-        middleware.use Actions::Middleware::ExecuteIfContentsChanged
-
         def plan(repository, smart_proxy, tasks, options = {})
           plan_self(repository_id: repository.id, smart_proxy_id: smart_proxy.id, tasks: tasks, contents_changed: options[:contents_changed])
         end

data/app/models/katello/alternate_content_source.rb

@@ -62,5 +62,10 @@ module Katello
       conditions = sanitize_sql_for_conditions(["? #{operator} ANY (subpaths)", value_to_sql(operator, value)])
       { conditions: conditions }
     end
+
+    def latest_dynflow_refresh_task
+      @latest_dynflow_refresh_task ||= ForemanTasks::Task::DynflowTask.where(:label => Actions::Katello::AlternateContentSource::Refresh.name).
+          for_resource(self).order(:started_at).last
+    end
   end
 end

data/app/services/katello/pulp3/alternate_content_source.rb

@@ -101,6 +101,12 @@ module Katello
         ignore_404_exception { api.alternate_content_source_api.delete(href) } if href
       end
 
+      def refresh
+        href = smart_proxy_acs.alternate_content_source_href
+        # https://github.com/pulp/pulp_rpm/issues/2504
+        api.alternate_content_source_api.refresh(href, 'placeholder')
+      end
+
       private
 
       def insert_pulp_manifest!(subpaths)

data/app/services/katello/pulp3/content_view_version/metadata_map.rb

@@ -24,12 +24,12 @@ module Katello
 
         def initialize(metadata:)
           @toc = metadata[:toc]
+          @gpg_keys = parse_gpg_keys(metadata[:gpg_keys]) if metadata[:gpg_keys]
           @products = parse_products(metadata[:products]) if metadata[:products]
           @repositories = parse_repositories(metadata[:repositories]) if metadata[:repositories]
           @content_view = parse_content_view(metadata[:content_view]) if metadata[:content_view]
           @content_view_version = parse_content_view_version(metadata[:content_view_version]) if metadata[:content_view_version]
           @from_content_view_version = parse_content_view_version(metadata[:from_content_view_version]) if metadata[:from_content_view_version]
-          @gpg_keys = parse_gpg_keys(metadata[:gpg_keys]) if metadata[:gpg_keys]
         end
 
         private

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

@@ -231,11 +231,17 @@ module Katello
           return update_distribution
         end
 
-        if dist_ref
+        if dist && dist_ref
+          # If the saved distribution reference is wrong, delete it and use the existing distribution
+          if dist.pulp_href != dist_ref.href
+            dist_ref.destroy
+            save_distribution_references([dist.pulp_href])
+          end
           return update_distribution
         end
 
         # Since we got this far, we need to create a new distribution
+        # Note: the distribution reference can't be saved yet because distribution creation is async
         begin
           create_distribution(relative_path)
         rescue api.client_module::ApiError => e
@@ -253,6 +259,9 @@ module Katello
 
       def create_distribution(path)
         distribution_data = api.distribution_class.new(secure_distribution_options(path))
+        unless ::Katello::RepositoryTypeManager.find(repo.content_type).pulp3_skip_publication
+          fail_missing_publication(distribution_data.publication)
+        end
         api.distributions_api.create(distribution_data)
       end
 
@@ -260,9 +269,16 @@ module Katello
         api.distributions_api.list(args).results
       end
 
+      def read_distribution(href = distribution_reference.href)
+        ignore_404_exception { api.distributions_api.read(href) }
+      end
+
       def update_distribution
         if distribution_reference
           options = secure_distribution_options(relative_path).except(:name)
+          unless ::Katello::RepositoryTypeManager.find(repo.content_type).pulp3_skip_publication
+            fail_missing_publication(options[:publication])
+          end
           distribution_reference.update(:content_guard_href => options[:content_guard])
           api.distributions_api.partial_update(distribution_reference.href, options)
         end
@@ -321,6 +337,12 @@ module Katello
         hrefs.each do |href|
           pulp3_distribution_data = api.get_distribution(href)
           path, content_guard_href = pulp3_distribution_data&.base_path, pulp3_distribution_data&.content_guard
+          if distribution_reference
+            found_distribution = read_distribution(distribution_reference.href)
+            unless found_distribution
+              distribution_reference.destroy
+            end
+          end
           unless distribution_reference
             # Ensure that duplicates won't be created in the case of a race condition
             DistributionReference.where(path: path, href: href, repository_id: repo.id, content_guard_href: content_guard_href).first_or_create!
@@ -473,6 +495,12 @@ module Katello
         return 0 if root.retain_package_versions_count.nil? || root.using_mirrored_content?
         root.retain_package_versions_count.to_i
       end
+
+      def fail_missing_publication(publication_href)
+        unless lookup_publication(publication_href)
+          fail _("The repository's publication is missing. Please run a 'complete sync' on %s." % repo.name)
+        end
+      end
     end
   end
 end

data/app/views/katello/api/v2/alternate_content_sources/base.json.rabl

@@ -2,7 +2,16 @@ object @resource
 
 extends 'katello/api/v2/common/identifier'
 
-attributes :name, :base_url, :subpaths, :content_type, :alternate_content_source_type, :smart_proxies, :upstream_username
+attributes :name, :base_url, :subpaths, :content_type, :alternate_content_source_type, :smart_proxies, :upstream_username, :last_refreshed
+
+child :latest_dynflow_refresh_task => :last_refresh do |_object|
+  attributes :id, :username, :started_at, :ended_at, :state, :result, :progress
+  node :last_refresh_words do |object|
+    if (object.respond_to?('started_at') && object.started_at)
+      time_ago_in_words(Time.parse(object.started_at.to_s))
+    end
+  end
+end
 
 if params.key?(:include_permissions)
   node :permissions do |alternate_content_source|

data/app/views/katello/api/v2/content_facet/show.json.rabl

@@ -33,6 +33,18 @@ child :content_facet => :content_facet_attributes do
   node :remote_execution_by_default do
     Katello.remote_execution_by_default?
   end
+
+  user = User.current # current_user is not available here
+  child :permissions do
+    node(:view_lifecycle_environments) { user.can?("view_lifecycle_environments") }
+    node(:view_content_views) { user.can?("view_content_views") }
+    node(:promote_or_remove_content_views_to_environments) { user.can?("promote_or_remove_content_views_to_environments") }
+    node(:view_host_collections) { user.can?("view_host_collections") }
+    node(:create_job_invocations) { user.can?("create_job_invocations") }
+    node(:view_activation_keys) { user.can?("view_activation_keys") }
+    node(:view_products) { user.can?("view_products") }
+    node(:create_bookmarks) { user.can?("create_bookmarks") }
+  end
 end
 
 attributes :description, :facts

data/app/views/katello/api/v2/repository_sets/show.json.rabl

@@ -37,6 +37,10 @@ child @resource.repositories => :repositories do
   attributes :minor => :releasever
 end
 
+node :osRestricted do |pc|
+  pc.repositories&.first&.os_versions&.first
+end
+
 node :override do |pc|
   pc.override if pc.respond_to? :override
 end

data/config/routes/api/v2.rb

@@ -14,6 +14,10 @@ Katello::Engine.routes.draw do
         # re-routes alphabetical
         ##############################
 
+        api_resources :alternate_content_sources, :only => [:index, :show, :create, :update, :destroy] do
+          get :auto_complete_search, :on => :collection
+        end
+
         api_resources :capsules, :only => [:index, :show] do
           member do
             resource :content, :only => [], :controller => 'capsule_content' do
@@ -349,6 +353,18 @@ Katello::Engine.routes.draw do
         ##############################
         ##############################
 
+        api_resources :alternate_content_sources, :only => [], :constraints => { :id => /[0-9a-zA-Z\-_.]*/ } do
+          collection do
+            match '/bulk/destroy' => 'alternate_content_sources_bulk_actions#destroy_alternate_content_sources', :via => :put
+            match '/bulk/refresh' => 'alternate_content_sources_bulk_actions#refresh_alternate_content_sources', :via => :post
+            get :auto_complete_search
+          end
+
+          member do
+            post :refresh
+          end
+        end
+
         api_resources :organizations do
           api_resources :sync_plans do
             member do
@@ -469,10 +485,6 @@ Katello::Engine.routes.draw do
           get :auto_complete_search, :on => :collection
           put :sync
         end
-
-        api_resources :alternate_content_sources, :only => [:index, :show, :create, :update, :destroy] do
-          get :auto_complete_search, :on => :collection
-        end
       end # module v2
     end # '/api' namespace
   end # '/katello' namespace