katello 4.5.1 → 4.6.0.rc1

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

@@ -5,11 +5,10 @@ module Actions
         def plan(acs)
           action_subject(acs)
           sequence do
-            acs.smart_proxies.each do |smart_proxy|
-              plan_action(Pulp3::Orchestration::AlternateContentSource::Delete,
-                          acs, smart_proxy)
+            acs.smart_proxy_alternate_content_sources.each do |smart_proxy_acs|
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Delete, smart_proxy_acs)
             end
-            plan_self(:acs_id => acs.id)
+            plan_self(acs_id: acs.id)
           end
         end
 

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

@@ -5,17 +5,15 @@ module Actions
         def plan(acs)
           action_subject(acs)
           concurrence do
-            acs.smart_proxies.each do |smart_proxy|
-              plan_action(Pulp3::Orchestration::AlternateContentSource::Refresh,
-                          acs, smart_proxy)
+            acs.smart_proxy_alternate_content_sources.each do |smart_proxy_acs|
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Refresh, smart_proxy_acs)
             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)
+          ::Katello::AlternateContentSource.find_by(id: input[:acs_id])&.audit_refresh
         end
 
         def humanized_name

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

@@ -2,32 +2,76 @@ module Actions
   module Katello
     module AlternateContentSource
       class Update < Actions::EntryAction
+        include Actions::Katello::AlternateContentSource::AlternateContentSourceCommon
         # smart_proxies ALWAYS represents the smart proxies to remain associated
         # after the action runs.  If smart_proxies == [], there will be none afterwards.
-        def plan(acs, smart_proxies, acs_params)
+        # The same rule applies to products.
+        def plan(acs, smart_proxies, products, acs_params)
           action_subject(acs)
           acs.update!(acs_params)
 
           smart_proxies = smart_proxies.uniq
-          smart_proxies_to_add = smart_proxies - acs.smart_proxies
-          smart_proxies_to_delete = acs.smart_proxies - smart_proxies
+          smart_proxies_to_associate = smart_proxies - acs.smart_proxies
+          smart_proxies_to_disassociate = acs.smart_proxies - smart_proxies
           smart_proxies_to_update = smart_proxies & acs.smart_proxies
 
+          products ||= []
+          products_to_associate = []
+          products_to_disassociate = []
+
+          if acs.simplified?
+            products = products.uniq
+            products_to_associate = products - acs.products
+            products_to_disassociate = acs.products - products
+            old_product_ids = acs.products.pluck(:id)
+            acs.products = products
+            acs.audit_updated_products(old_product_ids) unless products_to_associate.empty? && products_to_disassociate.empty?
+          end
+
           concurrence do
-            smart_proxies_to_add&.each do |smart_proxy|
-              ::Katello::SmartProxyAlternateContentSource.create(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id)
-              plan_action(Pulp3::Orchestration::AlternateContentSource::Create,
-                          acs, smart_proxy)
+            create_acss(acs, smart_proxies_to_associate)
+            delete_acss(acs, smart_proxies_to_disassociate)
+            update_acss(acs, smart_proxies_to_update, products_to_associate, products_to_disassociate)
+          end
+        end
+
+        def create_acss(acs, smart_proxies_to_associate)
+          smart_proxies_to_associate&.each do |smart_proxy|
+            if acs.custom?
+              smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.create(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id)
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Create, smart_proxy_acs)
+            elsif acs.simplified?
+              create_simplified_acs(acs, smart_proxy)
             end
+          end
+        end
 
-            smart_proxies_to_delete&.each do |smart_proxy|
-              plan_action(Pulp3::Orchestration::AlternateContentSource::Delete,
-                          acs, smart_proxy)
+        def delete_acss(acs, smart_proxies_to_disassociate)
+          smart_proxies_to_disassociate&.each do |smart_proxy|
+            acs.smart_proxy_alternate_content_sources.where(smart_proxy_id: smart_proxy.id).each do |smart_proxy_acs|
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Delete, smart_proxy_acs)
             end
+          end
+        end
 
-            smart_proxies_to_update&.each do |smart_proxy|
-              plan_action(Pulp3::Orchestration::AlternateContentSource::Update,
-                          acs, smart_proxy)
+        def update_acss(acs, smart_proxies_to_update, products_to_associate, products_to_disassociate)
+          smart_proxies_to_update&.each do |smart_proxy|
+            if acs.custom?
+              smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find_by(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id, repository_id: nil)
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Update, smart_proxy_acs)
+            elsif acs.simplified?
+              products_to_associate.each do |product|
+                product.repositories.library.with_type(acs.content_type).each do |repo|
+                  smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.create(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id, repository_id: repo.id)
+                  plan_action(Pulp3::Orchestration::AlternateContentSource::Create, smart_proxy_acs)
+                end
+              end
+              products_to_disassociate.each do |product|
+                product.repositories.library.with_type(acs.content_type).each do |repo|
+                  smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find_by(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id, repository_id: repo.id)
+                  plan_action(Pulp3::Orchestration::AlternateContentSource::Delete, smart_proxy_acs)
+                end
+              end
             end
           end
         end

data/app/lib/actions/katello/applicability/hosts/bulk_generate.rb

@@ -32,8 +32,8 @@ module Actions
           end
 
           def humanized_name
-            if input[:host_ids]&.length == 1
-              _("Bulk generate applicability for host %s" % hostname(input[:host_ids].first))
+            if input && input[:host_ids]&.length == 1
+              _("Bulk generate applicability for host %s" % hostname(input[:host_ids]&.first))
             else
               _("Bulk generate applicability for hosts")
             end

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

@@ -44,10 +44,14 @@ module Actions
 
         def plan_refresh_repos(import_products_action, org)
           repositories = ::Katello::Repository.in_default_view.in_product(::Katello::Product.redhat.in_org(org))
-          repositories.each do |repo|
-            plan_action(Katello::Repository::RefreshRepository,
-              repo,
-              :dependency => import_products_action.output)
+          repositories.in_groups_of(Setting[:foreman_proxy_content_batch_size], false) do |repo_batch|
+            concurrence do
+              repo_batch.each do |repo|
+                plan_action(Katello::Repository::RefreshRepository,
+                  repo,
+                  :dependency => import_products_action.output)
+              end
+            end
           end
         end
 

data/app/lib/actions/katello/organization/simple_content_access/toggle.rb

@@ -14,15 +14,7 @@ module Actions
           def plan(organization_id)
             @organization = ::Organization.find(organization_id)
             action_subject organization
-            ::Katello::Resources::Candlepin::UpstreamConsumer.update(
-              "#{consumer['apiUrl']}#{consumer['uuid']}",
-              consumer['idCert']['cert'],
-              consumer['idCert']['key'],
-              nil,
-              {contentAccessMode: content_access_mode_value}
-            )
-
-            plan_action(::Actions::Katello::Organization::ManifestRefresh, organization)
+            ::Katello::Resources::Candlepin::Owner.update(@organization.label, contentAccessMode: content_access_mode_value)
           end
 
           def failure_notification(plan)

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

@@ -2,6 +2,7 @@ module Actions
   module Katello
     module Repository
       class Create < Actions::EntryAction
+        # rubocop:disable Metrics/MethodLength
         def plan(repository, args = {})
           clone = args[:clone] || false
           force_repo_create = args[:force_repo_create] || false
@@ -33,6 +34,14 @@ module Actions
 
             concurrence do
               plan_self(:repository_id => repository.id, :clone => clone)
+              if repository.url.present?
+                repository.product.alternate_content_sources.with_type(repository.content_type).each do |acs|
+                  acs.smart_proxies.each do |smart_proxy|
+                    smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.create(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id, repository_id: repository.id)
+                    plan_action(Pulp3::Orchestration::AlternateContentSource::Create, smart_proxy_acs)
+                  end
+                end
+              end
             end
           end
         end

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

@@ -25,6 +25,8 @@ module Actions
 
           remove_versions(repository, repository.content_views.generated_for_none, affected_cvv_ids) if remove_from_content_view_versions
 
+          handle_alternate_content_sources(repository)
+
           plan_self(:user_id => ::User.current.id, :affected_cvv_ids => affected_cvv_ids)
           sequence do
             if repository.redhat?
@@ -52,6 +54,25 @@ module Actions
           end
         end
 
+        def handle_alternate_content_sources(repository)
+          product = repository.product
+          content_type = repository.content_type
+          repository.smart_proxy_alternate_content_sources.each do |smart_proxy_acs|
+            plan_action(Pulp3::Orchestration::AlternateContentSource::Delete, smart_proxy_acs)
+          end
+
+          # Remove the product from the ACS if it's empty.
+          # An ACS with only an empty product will not function correctly
+          ## because there will be no smart_proxy_alternate_content_sources.
+          if product.repositories.with_type(content_type).count == 1
+            ::Katello::AlternateContentSource.with_products(product).each do |acs|
+              acs.products = acs.products - [product]
+              Rails.logger.info _('Removing product %{prod_name} with ID %{prod_id} from ACS %{acs_name} with ID %{acs_id}') %
+                { prod_name: product.name, prod_id: product.id, acs_name: acs.name, acs_id: acs.id }
+            end
+          end
+        end
+
         def handle_custom_content(repository, remove_from_content_view_versions)
           #if this is the last instance of a custom repo, destroy the content
           if remove_from_content_view_versions || repository.root.repositories.where.not(id: repository.id).empty?

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

@@ -5,15 +5,15 @@ module Actions
         middleware.use Actions::Middleware::ExecuteIfContentsChanged
 
         def plan(repo, contents_changed = nil)
-          plan_self(:repo => repo.id, :contents_changed => contents_changed)
+          last_updated = repo.repository_errata.order('updated_at ASC').last.try(:updated_at) || Time.now
+          plan_self(:repo => repo.id, :contents_changed => contents_changed, :last_updated => last_updated.to_s)
         end
 
         def run
           ::User.current = ::User.anonymous_admin
           repo = ::Katello::Repository.find(input[:repo])
-          last_updated = repo.repository_errata.order('updated_at ASC').last.try(:updated_at) || Time.now
           users = ::User.select { |user| user.receives?(:sync_errata) && user.organization_ids.include?(repo.organization.id) && user.can?(:view_products, repo.product) }.compact
-          errata = ::Katello::Erratum.where(:id => repo.repository_errata.where('katello_repository_errata.updated_at > ?', last_updated).pluck(:erratum_id))
+          errata = ::Katello::Erratum.where(:id => repo.repository_errata.where('katello_repository_errata.updated_at > ?', input['last_updated'].to_datetime).pluck(:erratum_id))
 
           begin
             MailNotification[:sync_errata].deliver(:users => users, :repo => repo, :errata => errata) unless (users.blank? || errata.blank?)

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

@@ -7,6 +7,9 @@ module Actions
             repo = ::Katello::Repository.find(repo.id)
             plan_action(Actions::Pulp3::Orchestration::Repository::RefreshIfNeeded,
                              repo, SmartProxy.default_capsule!, :dependency => options[:dependency])
+            repo.smart_proxy_alternate_content_sources.each do |smart_proxy_acs|
+              plan_action(::Actions::Pulp3::Orchestration::AlternateContentSource::RefreshRemote, smart_proxy_acs)
+            end
             plan_self(:name => repo.name, :dependency => options[:dependency])
           end
         end

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

@@ -10,7 +10,11 @@ module Actions
 
           repo_params[:url] = nil if repo_params[:url] == ''
           update_cv_cert_protected = repo_params.key?(:unprotected) && (repo_params[:unprotected] != repository.unprotected)
+          create_acs = create_acs?(repository.url, repo_params[:url])
+          delete_acs = delete_acs?(repository.url, repo_params[:url])
 
+          # Keep the old URL for RPM vs ULN remote cleanup
+          old_url = root.url
           root.update!(repo_params)
 
           if update_content?(repository)
@@ -43,6 +47,8 @@ module Actions
               if update_cv_cert_protected
                 plan_optional_pulp_action([::Actions::Pulp3::Orchestration::Repository::TriggerUpdateRepoCertGuard], repository, ::SmartProxy.pulp_primary)
               end
+
+              handle_alternate_content_sources(repository, create_acs, delete_acs, old_url)
             end
           end
         end
@@ -55,9 +61,36 @@ module Actions
 
         private
 
+        def handle_alternate_content_sources(repository, create_acs, delete_acs, old_url)
+          if create_acs
+            repository.product.alternate_content_sources.each do |acs|
+              acs.smart_proxies.each do |smart_proxy|
+                smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.create(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id, repository_id: repository.id)
+                plan_action(Pulp3::Orchestration::AlternateContentSource::Create, smart_proxy_acs)
+              end
+            end
+          elsif delete_acs
+            repository.smart_proxy_alternate_content_sources.each do |smart_proxy_acs|
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Delete, smart_proxy_acs, old_url: old_url)
+            end
+          else
+            repository.smart_proxy_alternate_content_sources.each do |smart_proxy_acs|
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Update, smart_proxy_acs)
+            end
+          end
+        end
+
         def update_content?(repository)
           repository.library_instance? && !repository.product.redhat?
         end
+
+        def create_acs?(old_url, new_url)
+          old_url.nil? && new_url.present?
+        end
+
+        def delete_acs?(old_url, new_url)
+          old_url.present? && new_url.nil?
+        end
       end
     end
   end

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

@@ -6,7 +6,7 @@ module Actions
           action_subject repo
           repo.root.update!(:url => upstream_url(repo)) if repo.library_instance?
           repo.update!(relative_path: relative_path(repo))
-          plan_action(::Actions::Pulp3::Orchestration::Repository::RefreshIfNeeded, repo)
+          plan_action(::Actions::Katello::Repository::RefreshRepository, repo)
           plan_self(:repository_id => repo.id)
         end
 

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

@@ -2,13 +2,14 @@ module Actions
   module Pulp3
     module AlternateContentSource
       class Create < Pulp3::Abstract
-        def plan(acs, smart_proxy)
-          plan_self(:acs_id => acs.id, :smart_proxy_id => smart_proxy.id)
+        def plan(smart_proxy_acs)
+          plan_self(smart_proxy_id: smart_proxy_acs.smart_proxy_id, smart_proxy_acs_id: smart_proxy_acs.id)
         end
 
         def run
-          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
-          output[:response] = acs.backend_service(smart_proxy).create
+          smart_proxy_acs_id = input[:smart_proxy_acs_id]
+          smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find(smart_proxy_acs_id)
+          output[:response] = smart_proxy_acs.backend_service.create
         end
 
         def rescue_strategy

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

@@ -2,13 +2,14 @@ module Actions
   module Pulp3
     module AlternateContentSource
       class CreateRemote < Pulp3::Abstract
-        def plan(acs, smart_proxy)
-          plan_self(:acs_id => acs.id, :smart_proxy_id => smart_proxy.id)
+        def plan(smart_proxy_acs)
+          plan_self(smart_proxy_id: smart_proxy_acs.smart_proxy_id, smart_proxy_acs_id: smart_proxy_acs.id)
         end
 
         def run
-          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
-          output[:response] = acs.backend_service(smart_proxy).create_remote
+          smart_proxy_acs_id = input[:smart_proxy_acs_id]
+          smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find(smart_proxy_acs_id)
+          output[:response] = smart_proxy_acs.backend_service.create_remote
         end
 
         def rescue_strategy

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

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

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

@@ -2,13 +2,13 @@ module Actions
   module Pulp3
     module AlternateContentSource
       class DeleteRemote < Pulp3::AbstractAsyncTask
-        def plan(acs, smart_proxy)
-          plan_self(:acs_id => acs.id, :smart_proxy_id => smart_proxy.id)
+        def plan(smart_proxy_acs, options = {})
+          plan_self(smart_proxy_id: smart_proxy_acs.smart_proxy_id, smart_proxy_acs_id: smart_proxy_acs.id, old_url: options[:old_url])
         end
 
         def invoke_external_task
-          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
-          output[:response] = acs.backend_service(smart_proxy).delete_remote
+          smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find(input[:smart_proxy_acs_id])
+          output[:response] = smart_proxy_acs.backend_service.delete_remote(old_url: input[:old_url])
         end
       end
     end

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

@@ -2,13 +2,13 @@ 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)
+        def plan(smart_proxy_acs)
+          plan_self(smart_proxy_id: smart_proxy_acs.smart_proxy_id, smart_proxy_acs_id: smart_proxy_acs.id)
         end
 
         def invoke_external_task
-          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
-          output[:response] = acs.backend_service(smart_proxy).refresh
+          smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find(input[:smart_proxy_acs_id])
+          output[:response] = smart_proxy_acs.backend_service.refresh
         end
 
         def rescue_strategy_for_self

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

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

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

@@ -2,14 +2,14 @@ module Actions
   module Pulp3
     module AlternateContentSource
       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)
+        def plan(smart_proxy_acs)
+          smart_proxy_acs.backend_service.create_test_remote
+          plan_self(smart_proxy_acs_id: smart_proxy_acs.id, smart_proxy_id: smart_proxy_acs.smart_proxy_id)
         end
 
         def invoke_external_task
-          acs = ::Katello::AlternateContentSource.find(input[:acs_id])
-          output[:response] = acs.backend_service(smart_proxy).update_remote
+          smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find(input[:smart_proxy_acs_id])
+          output[:response] = smart_proxy_acs.backend_service.update_remote
         end
       end
     end

data/app/lib/actions/pulp3/capsule_content/reclaim_space.rb

@@ -12,6 +12,7 @@ module Actions
             end
             repository_hrefs = ::Katello::Pulp3::Api::Core.new(smart_proxy).core_repositories_list_all(fields: 'pulp_href').map(&:pulp_href)
           end
+          fail _('There is no downloaded content to clean.') if repository_hrefs.empty?
           plan_self(repository_hrefs: repository_hrefs, smart_proxy_id: smart_proxy.id)
         end
 

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

@@ -3,10 +3,10 @@ module Actions
     module Orchestration
       module AlternateContentSource
         class Create < Pulp3::Abstract
-          def plan(acs, smart_proxy)
+          def plan(smart_proxy_acs)
             sequence do
-              plan_action(Actions::Pulp3::AlternateContentSource::CreateRemote, acs, smart_proxy)
-              plan_action(Actions::Pulp3::AlternateContentSource::Create, acs, smart_proxy)
+              plan_action(Actions::Pulp3::AlternateContentSource::CreateRemote, smart_proxy_acs)
+              plan_action(Actions::Pulp3::AlternateContentSource::Create, smart_proxy_acs)
             end
           end
         end

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

@@ -3,18 +3,17 @@ module Actions
     module Orchestration
       module AlternateContentSource
         class Delete < Pulp3::Abstract
-          def plan(acs, smart_proxy)
+          def plan(smart_proxy_acs, options = {})
             sequence do
-              plan_action(Actions::Pulp3::AlternateContentSource::Delete, acs, smart_proxy)
-              plan_action(Actions::Pulp3::AlternateContentSource::DeleteRemote, acs, smart_proxy)
-              plan_self(acs_id: acs.id, smart_proxy_id: smart_proxy.id)
+              plan_action(Actions::Pulp3::AlternateContentSource::Delete, smart_proxy_acs)
+              plan_action(Actions::Pulp3::AlternateContentSource::DeleteRemote, smart_proxy_acs, options)
+              plan_self(smart_proxy_id: smart_proxy_acs.smart_proxy_id, smart_proxy_acs_id: smart_proxy_acs.id)
             end
           end
 
           def finalize
-            acs_id = input[:acs_id]
-            smart_proxy_id = input[:smart_proxy_id]
-            ::Katello::SmartProxyAlternateContentSource.find_by(alternate_content_source_id: acs_id, smart_proxy_id: smart_proxy_id).destroy
+            smart_proxy_acs_id = input[:smart_proxy_acs_id]
+            ::Katello::SmartProxyAlternateContentSource.find_by(id: smart_proxy_acs_id).destroy
           end
         end
       end

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

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

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

@@ -0,0 +1,18 @@
+module Actions
+  module Pulp3
+    module Orchestration
+      module AlternateContentSource
+        class RefreshRemote < Pulp3::AbstractAsyncTask
+          def plan(smart_proxy_acs)
+            plan_self(smart_proxy_acs_id: smart_proxy_acs.id, smart_proxy_id: smart_proxy_acs.smart_proxy_id)
+          end
+
+          def invoke_external_task
+            smart_proxy_acs = ::Katello::SmartProxyAlternateContentSource.find(input[:smart_proxy_acs_id])
+            smart_proxy_acs.backend_service.update_remote
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,10 +3,10 @@ module Actions
     module Orchestration
       module AlternateContentSource
         class Update < Pulp3::Abstract
-          def plan(acs, smart_proxy)
+          def plan(smart_proxy_acs)
             sequence do
-              plan_action(Actions::Pulp3::AlternateContentSource::UpdateRemote, acs, smart_proxy)
-              plan_action(Actions::Pulp3::AlternateContentSource::Update, acs, smart_proxy)
+              plan_action(Actions::Pulp3::AlternateContentSource::UpdateRemote, smart_proxy_acs)
+              plan_action(Actions::Pulp3::AlternateContentSource::Update, smart_proxy_acs)
             end
           end
         end

data/app/lib/actions/pulp3/orchestration/repository/generate_metadata.rb

@@ -16,7 +16,7 @@ module Actions
                 plan_action(Actions::Pulp3::Repository::CreatePublication, repository, smart_proxy, options)
               end
               plan_action(Actions::Pulp3::ContentGuard::Refresh, smart_proxy) unless repository.unprotected
-              plan_action(Actions::Pulp3::Repository::RefreshDistribution, repository, smart_proxy, :contents_changed => options[:contents_changed]) if repository.environment
+              plan_action(Actions::Pulp3::Repository::RefreshDistribution, repository, smart_proxy, :contents_changed => options[:contents_changed]) if Setting[:distribute_archived_cvv] || repository.environment
             end
           end
 

data/app/lib/katello/concerns/base_template_scope_extensions.rb

@@ -161,7 +161,7 @@ module Katello
         returns String, desc: 'Package version'
       end
       def host_latest_applicable_rpm_version(host, package)
-        host.applicable_rpms.where(name: package).order(:version_sortable).limit(1).pluck(:nvra).first
+        ::Katello::Rpm.latest(host.applicable_rpms.where(name: package)).first.nvra
       end
 
       apipie :method, 'Loads Pool objects' do

data/app/lib/katello/errors.rb

@@ -154,7 +154,7 @@ module Katello
 
     class NoManifestImported < StandardError
       def message
-        _("Current organization has no manifest imported.")
+        _("Current organization does not have a manifest imported.")
       end
     end
 

data/app/lib/katello/resources/candlepin/owner.rb

@@ -12,8 +12,14 @@ module Katello
 
           # Set the contentPrefix at creation time so that the client will get
           # content only for the org it has been subscribed to
-          def create(key, description)
-            attrs = {:key => key, :displayName => description, :contentPrefix => "/#{key}/$env"}
+          def create(key, description, content_access_mode: 'org_environment')
+            attrs = {
+              :key => key,
+              :displayName => description,
+              :contentPrefix => "/#{key}/$env",
+              :contentAccessMode => content_access_mode,
+              :contentAccessModeList => ['entitlement', 'org_environment'].join(',')
+            }
             owner_json = self.post(path, attrs.to_json, self.default_headers).body
             JSON.parse(owner_json).with_indifferent_access
           end
@@ -36,6 +42,7 @@ module Katello
           def update(key, attrs)
             owner = find(key)
             owner.merge!(attrs)
+            owner.merge!(:contentAccessModeList => ['entitlement', 'org_environment'].join(','))
             self.put(path(key), JSON.generate(owner), self.default_headers).body
           end