katello 3.16.0.rc5.1 → 3.16.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c713303404ad8912ded54dd3d110d6ef3f8e1ed9500f55abf1f31f2180d08a2
-  data.tar.gz: 07eb7edbe97e87b35d0ebd26eb90c0da64a8eddb69d4435333a546eaa82d298b
+  metadata.gz: 7e3320c3167ac19ebd8119f1d4e58f0dcc141a4a18e4bccc98f1a4965e09262d
+  data.tar.gz: a9d5092691dca107610bfae636df54566cc07bf9fdf724d4c2e96312c3fdca9b
 SHA512:
-  metadata.gz: 67508f99358a420af1f1fbdb332e427bec5ee59092c69f05790029be0d14b624f6306dc351c550f02671819add178da8ae92938aeb2f66a262bebbd287cbad66
-  data.tar.gz: 5267fc924abe8504b4688481792f964adab5b530f2110e3bb8954717fef6a6d691635f0c64d9f2a56b7bf311620df1b5cde767e9e9d2894ad454d134552f9425
+  metadata.gz: 263362175e3deffd8bb979fd7464447b66524ccf5156a2a9836ae92b8ccd615b443202e3072309cc8d2d870ff899ddb4256887a5385c0fe860eb903b4b6a7066
+  data.tar.gz: af6e7d83da1cb8ac22dd279156e076cc42e605fb4f5b968d9e027f19903c3a819ebec6c8149f4a2f16ef43a9b3d5d34bb7ed4359c9b6b86e041ce0180c486a6a

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

@@ -6,8 +6,8 @@ module Katello
     before_action :confirm_push_settings, only: [:start_upload_blob, :upload_blob, :finish_upload_blob,
                                                  :chunk_upload_blob, :push_manifest]
     skip_before_action :authorize
-    before_action :optional_authorize, only: [:token]
-    before_action :registry_authorize, except: [:token, :v1_search]
+    before_action :optional_authorize, only: [:token, :catalog]
+    before_action :registry_authorize, except: [:token, :v1_search, :catalog]
     before_action :authorize_repository_read, only: [:pull_manifest, :tags_list]
     before_action :authorize_repository_write, only: [:push_manifest]
     skip_before_action :check_content_type, only: [:start_upload_blob, :upload_blob, :finish_upload_blob,
@@ -39,20 +39,7 @@ module Katello
                                              "scope=\"repository:registry:pull,push\""
     end
 
-    def optional_authorize
-      @repository = find_scope_repository
-      if @repository && (@repository.environment.registry_unauthenticated_pull || ssl_client_authorized?(@repository.organization.label))
-        true
-      else
-        authorize
-      end
-    end
-
-    def registry_authorize
-      @repository = find_readable_repository
-      return true if ['GET', 'HEAD'].include?(request.method) && @repository && !require_user_authorization?
-
-      token = request.headers['Authorization']
+    def set_user_by_token(token, redirect_on_failure = true)
       if token
         token_type, token = token.split
         if token_type == 'Bearer' && token
@@ -63,10 +50,34 @@ module Katello
           end
         elsif token_type == 'Basic' && token
           return true if authorize
-          redirect_authorization_headers
+          redirect_authorization_headers if redirect_on_failure
           return false
         end
       end
+      false
+    end
+
+    def optional_authorize
+      @repository = find_scope_repository
+      if @repository && (@repository.environment.registry_unauthenticated_pull || ssl_client_authorized?(@repository.organization.label))
+        true
+      elsif params['action'] == 'catalog'
+        set_user_by_token(request.headers['Authorization'], false)
+      elsif (params['action'] == 'token' && params['scope'].blank? && params['account'].blank?)
+        true
+      else
+        authorize
+      end
+    end
+
+    def registry_authorize
+      @repository = find_readable_repository
+      return true if ['GET', 'HEAD'].include?(request.method) && @repository && !require_user_authorization?
+
+      is_user_set = set_user_by_token(request.headers['Authorization'])
+
+      return true if is_user_set
+
       redirect_authorization_headers
       render_error('unauthorized', :status => :unauthorized)
       return false
@@ -87,12 +98,8 @@ module Katello
     # Also include repositories in lifecycle environments with registry_unauthenticated_pull=true
     def readable_repositories
       table_name = Repository.table_name
-      in_products = Repository.in_product(Katello::Product.authorized(:view_products)).select(:id)
-      in_environments = Repository.where(:environment_id => Katello::KTEnvironment.authorized(:view_lifecycle_environments)).select(:id)
       in_unauth_environments = Repository.joins(:environment).where("#{Katello::KTEnvironment.table_name}.registry_unauthenticated_pull" => true).select(:id)
-      in_content_views = Repository.joins(:content_view_repositories).where("#{ContentViewRepository.table_name}.content_view_id" => Katello::ContentView.readable).select(:id)
-      in_versions = Repository.joins(:content_view_version).where("#{Katello::ContentViewVersion.table_name}.content_view_id" => Katello::ContentView.readable).select(:id)
-      Repository.where("#{table_name}.id in (?) or #{table_name}.id in (?) or #{table_name}.id in (?) or #{table_name}.id in (?) or #{table_name}.id in (?)", in_products, in_content_views, in_versions, in_environments, in_unauth_environments)
+      Repository.readable.or(Repository.joins(:root).where("#{table_name}.id in (?)", in_unauth_environments))
     end
 
     def find_readable_repository
@@ -105,7 +112,8 @@ module Katello
     end
 
     def require_user_authorization?(repository = @repository)
-      !repository || (!repository.environment.registry_unauthenticated_pull && !ssl_client_authorized?(repository.organization.label))
+      !(params['action'] == 'token' && params['scope'].blank? && params['account'].blank?) &&
+        (!repository || (!repository.environment.registry_unauthenticated_pull && !ssl_client_authorized?(repository.organization.label)))
     end
 
     def ssl_client_authorized?(org_label)
@@ -293,6 +301,14 @@ module Katello
     end
 
     def v1_search
+      # Checks for podman client and issues a 404 in that case. Podman
+      # examines the response from a /v1_search request. If the result
+      # is a 4XX, it will then proceed with a request to /_catalog
+      if request.headers['HTTP_USER_AGENT'].downcase.include?('libpod')
+        render json: {}, status: :not_found
+        return
+      end
+
       authenticate # to set current_user, not to enforce
       options = {
         resource_class: Katello::Repository

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

@@ -480,7 +480,7 @@ module Katello
         else
           User.consumer? || ::User.current.can?(:view_organizations, self)
         end
-      when "rhsm_proxy_owner_servicelevels_path"
+      when "rhsm_proxy_owner_servicelevels_path", "rhsm_proxy_owner_system_purpose_path"
         (User.consumer? || ::User.current.can?(:view_organizations, self))
       when "rhsm_proxy_consumer_accessible_content_path", "rhsm_proxy_consumer_certificates_path",
            "rhsm_proxy_consumer_releases_path", "rhsm_proxy_certificate_serials_path",

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

@@ -1,6 +1,6 @@
 module Katello
   class Api::V2::HostTracerController < Api::V2::ApiController
-    before_action :find_host, :only => :index
+    before_action :find_host
 
     resource_description do
       api_version 'v2'
@@ -14,43 +14,18 @@ module Katello
       respond_for_index(:collection => collection)
     end
 
-    api :PUT, "/traces/resolve", N_("Resolve Traces")
+    api :PUT, "/hosts/:host_id/traces/resolve", N_("Resolve Traces")
+    param :host_id, :number, :required => true, :desc => N_("ID of the host")
     param :trace_ids, Array, :required => true, :desc => N_("Array of Trace IDs")
     def resolve
-      traces = Katello::HostTracer.resolvable.where(id: params[:trace_ids])
-
-      traces.each do |trace|
-        if trace.reboot_required?
-          trace.helper = 'reboot'
-        end
-      end
-
-      traces_by_host_id = traces.group_by(&:host_id)
-      traces_by_helper = traces.group_by(&:helper)
-
-      composers = []
-
-      if traces_by_host_id.size < traces_by_helper.size
-        traces_by_host_id.each do |host_id, trace|
-          needed_traces = trace.map(&:helper).join(',')
-          joined_helpers = { :helper => needed_traces }
-          composers << JobInvocationComposer.for_feature(:katello_service_restart, [host_id], joined_helpers)
-        end
-      else
-        traces_by_helper.each do |helper, trace|
-          helpers = { :helper => helper }
-          composers << JobInvocationComposer.for_feature(:katello_service_restart, trace.map(&:host_id), helpers)
-        end
-      end
+      traces = @host.host_traces.resolvable.where(id: params[:trace_ids])
+      fail HttpErrors::BadRequest, _("The requested traces were not found for this host") if traces.empty?
 
-      job_invocations = []
+      result = Katello::HostTraceManager.resolve_traces(traces)
 
-      composers.each do |composer|
-        composer.trigger
-        job_invocations << composer.job_invocation
-      end
+      task = ForemanTasks::Task.find(result.first.task_id)
 
-      render json: job_invocations
+      respond_for_async(resource: task)
     end
 
     protected

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

@@ -6,7 +6,7 @@ module Katello
     before_action :find_host_collections, :only => [:bulk_add_host_collections, :bulk_remove_host_collections]
     before_action :find_environment, :only => [:environment_content_view]
     before_action :find_content_view, :only => [:environment_content_view]
-    before_action :find_editable_hosts, :except => [:destroy_hosts, :applicable_errata, :installable_errata]
+    before_action :find_editable_hosts, :except => [:destroy_hosts, :applicable_errata, :installable_errata, :resolve_traces]
     before_action :find_deletable_hosts, :only => [:destroy_hosts]
     before_action :find_readable_hosts, :only => [:applicable_errata, :installable_errata, :available_incremental_updates]
     before_action :find_errata, :only => [:available_incremental_updates]
@@ -230,6 +230,16 @@ module Katello
       respond_for_index(:collection => collection, :template => '../../../api/v2/host_tracer/index')
     end
 
+    api :PUT, "/hosts/bulk/resolve_traces", N_("Resolve traces for one or more hosts")
+    param_group :bulk_params
+    param :trace_ids, Array, :required => true, :desc => N_("Array of Trace IDs")
+    def resolve_traces
+      traces = Katello::HostTracer.resolvable.where(id: params[:trace_ids])
+      result = Katello::HostTraceManager.resolve_traces(traces)
+
+      render json: result
+    end
+
     api :POST, "/hosts/bulk/available_incremental_updates", N_("Given a set of hosts and errata, lists the content view versions" \
                                                                  " and environments that need updating.")
     param_group :bulk_params

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

@@ -50,6 +50,21 @@ module Katello
       respond_for_async :resource => task
     end
 
+    api :PUT, "/products/bulk/verify_checksum", N_("Verify checksum for one or more products")
+    param :ids, Array, :desc => N_("List of product ids"), :required => true
+    def verify_checksum_products
+      repairable_products = @products.syncable
+      repairable_roots = RootRepository.where(:product_id => repairable_products).
+        where(:content_type => ::Katello::Repository::YUM_TYPE).has_url.select { |r| r.library_instance }.uniq
+
+      repairable_repositories = Katello::Repository.where(:root_id => repairable_roots)
+      task = async_task(::Actions::BulkAction,
+                        ::Actions::Katello::Repository::VerifyChecksum,
+                        repairable_repositories)
+
+      respond_for_async :resource => task
+    end
+
     api :PUT, "/products/bulk/http_proxy", N_("Update the HTTP proxy configuration on the repositories of one or more products.")
     param :ids, Array, :desc => N_("List of product ids"), :required => true
     param :http_proxy_policy, ::Katello::RootRepository::HTTP_PROXY_POLICIES, :desc => N_("policy for HTTP proxy for content sync")

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

@@ -15,7 +15,7 @@ module Katello
     before_action :find_organization_from_product, :only => [:create]
     before_action :find_repository, :only => [:show, :update, :destroy, :sync, :export,
                                               :remove_content, :upload_content, :republish,
-                                              :import_uploads, :gpg_key_content]
+                                              :import_uploads, :gpg_key_content, :verify_checksum]
     before_action :find_content, :only => :remove_content
     before_action :find_organization_from_repo, :only => [:update]
     before_action :error_on_rh_product, :only => [:create]
@@ -294,6 +294,15 @@ module Katello
       raise HttpErrors::BadRequest, e.message
     end
 
+    api :POST, "/repositories/:id/verify_checksum", N_("Verify checksum of repository contents")
+    param :id, :number, :required => true, :desc => N_("repository ID")
+    def verify_checksum
+      task = async_task(::Actions::Katello::Repository::VerifyChecksum, @repository)
+      respond_for_async :resource => task
+    rescue Errors::InvalidActionOptionError => e
+      raise HttpErrors::BadRequest, e.message
+    end
+
     api :POST, "/repositories/:id/export", N_("Export a repository")
     param :id, :number, :desc => N_("Repository identifier"), :required => true
     param :export_to_iso, :bool, :desc => N_("Export to ISO format"), :required => false

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

@@ -19,11 +19,17 @@ module Katello
         prepend Overrides
 
         def update_multiple_taxonomies(type)
-          registered_host = @hosts.detect { |host| host.subscription_facet }
-          unless registered_host.nil?
-            error _("Unregister host %s before assigning an organization") % registered_host.name
-            redirect_back_or_to hosts_path
-            return
+          if type == :organization
+            new_org_id = params.dig(type, 'id')
+
+            if new_org_id
+              registered_host = @hosts.where.not(organization_id: new_org_id).joins(:subscription_facet).first
+              if registered_host
+                error _("Unregister host %s before assigning an organization") % registered_host.name
+                redirect_back_or_to hosts_path
+                return
+              end
+            end
           end
 
           super

data/app/helpers/katello/content_view_helper.rb

@@ -0,0 +1,15 @@
+module Katello
+  module ContentViewHelper
+    def separated_repo_mapping(repo_mapping)
+      separated_mapping = { :pulp3_yum => {}, :other => {} }
+      repo_mapping.each do |source_repos, dest_repo|
+        if dest_repo.content_type == "yum" && SmartProxy.pulp_master.pulp3_support?(dest_repo)
+          separated_mapping[:pulp3_yum][source_repos] = dest_repo
+        else
+          separated_mapping[:other][source_repos] = dest_repo
+        end
+      end
+      separated_mapping
+    end
+  end
+end

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

@@ -9,8 +9,12 @@ module Actions
 
           def run
             input[:host_ids].each do |host_id|
-              content_facet = ::Host.find(host_id).content_facet
-              content_facet.calculate_and_import_applicability
+              content_facet = ::Katello::Host::ContentFacet.find_by_host_id(host_id)
+              if content_facet.present?
+                content_facet.calculate_and_import_applicability
+              else
+                Rails.logger.warn(_("Content Facet for host with id %s is non-existent. Skipping applicability calculation.") % host_id)
+              end
             end
           end
 

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

@@ -37,7 +37,7 @@ module Actions
           current_repos_on_capsule = smart_proxy_service.current_repositories(environment, content_view)
           current_repos_on_capsule_ids = current_repos_on_capsule.pluck(:id)
 
-          list_of_repos_to_sync = smart_proxy_helper.repos_available_to_capsule(environment, content_view, repository)
+          list_of_repos_to_sync = smart_proxy_helper.combined_repos_available_to_capsule(environment, content_view, repository)
           list_of_repos_to_sync.each do |repo|
             if repo.is_a?(Katello::ContentViewPuppetEnvironment)
               repo = repo.nonpersisted_repository

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

@@ -31,8 +31,8 @@ module Actions
           fail _("Action not allowed for the default smart proxy.") if smart_proxy.pulp_master?
 
           smart_proxy_helper = ::Katello::SmartProxyHelper.new(smart_proxy)
-          repositories = smart_proxy_helper.repos_available_to_capsule(environment, content_view, repository)
-          smart_proxy.ping_pulp3 if repositories.any? { |repo| smart_proxy.pulp3_support?(repo) }
+          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,
@@ -40,6 +40,7 @@ module Actions
                                              repository: repository)
           sequence do
             plan_action(Actions::Pulp::Orchestration::Repository::RefreshRepos, smart_proxy, refresh_options)
+            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?
             plan_action(SyncCapsule, smart_proxy, refresh_options)
           end

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

@@ -10,11 +10,12 @@ module Actions
           repository = options[:repository]
           skip_metadata_check = options.fetch(:skip_metadata_check, false)
 
-          smart_proxy_helper = ::Katello::SmartProxyHelper.new(smart_proxy)
           sequence do
-            smart_proxy_helper.repos_available_to_capsule(environment, content_view, repository).in_groups_of(Setting[:foreman_proxy_content_batch_size], false) do |repos|
+            repos = repos_to_sync(smart_proxy, environment, content_view, repository)
+
+            repos.in_groups_of(Setting[:foreman_proxy_content_batch_size], false) do |repo_batch|
               concurrence do
-                repos.each do |repo|
+                repo_batch.each do |repo|
                   plan_pulp_action([Actions::Pulp::Orchestration::Repository::SmartProxySync,
                                     Actions::Pulp3::CapsuleContent::Sync],
                                      repo, smart_proxy,
@@ -33,6 +34,19 @@ module Actions
           end
         end
 
+        def repos_to_sync(smart_proxy, environment, content_view, repository)
+          smart_proxy_helper = ::Katello::SmartProxyHelper.new(smart_proxy)
+          smart_proxy_helper.lifecycle_environment_check(environment, repository)
+
+          if repository
+            [repository]
+          else
+            repositories = smart_proxy_helper.repositories_available_to_capsule(environment, content_view).by_rpm_count
+            puppet_envs = smart_proxy_helper.puppet_environments_available_to_capsule(environment, content_view)
+            repositories + puppet_envs
+          end
+        end
+
         def resource_locks
           :link
         end

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

@@ -52,7 +52,9 @@ module Actions
               action = plan_action(ContentViewVersion::IncrementalUpdate, composite_version, environments,
                                    :new_components => new_components, :description => description,
                                                            :content => {:puppet_module_ids => puppet_module_ids})
-              output_for_version_ids << {:version_id => action.new_content_view_version.id, :output => action.output}
+              unless SmartProxy.pulp_master.pulp3_repository_type_support?("yum")
+                output_for_version_ids << {:version_id => action.new_content_view_version.id, :output => action.output}
+              end
             end
           end
         end

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

@@ -3,6 +3,8 @@ module Actions
   module Katello
     module ContentView
       class Publish < Actions::EntryAction
+        include ::Katello::ContentViewHelper
+        attr_accessor :version
         # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
         def plan(content_view, description = "", options = {})
           action_subject(content_view)
@@ -21,7 +23,11 @@ module Actions
             end
           end
 
+          # Add non-override components back in
+          options[:override_components] = include_other_components(options[:override_components], content_view)
+
           version = version_for_publish(content_view, options)
+          self.version = version
           library = content_view.organization.library
           history = ::Katello::ContentViewHistory.create!(:content_view_version => version,
                                                           :user => ::User.current.login,
@@ -32,20 +38,30 @@ module Actions
                                                           :triggered_by => options[:triggered_by]
                                                          )
           source_repositories = []
-          content_view.publish_repositories do |repositories|
+          content_view.publish_repositories(options[:override_cvvs]) do |repositories|
             source_repositories += [repositories]
           end
 
           sequence do
-            plan_action(ContentView::AddToEnvironment, version, library)
+            plan_action(ContentView::AddToEnvironment, version, library) unless options[:skip_promotion]
             repository_mapping = plan_action(ContentViewVersion::CreateRepos, version, source_repositories).repository_mapping
 
+            # Split Pulp 3 Yum repos out of the repository_mapping.  Only Pulp 3 RPM plugin has multi repo copy support.
+            separated_repo_map = separated_repo_mapping(repository_mapping)
+
+            if separated_repo_map[:pulp3_yum].keys.flatten.present? &&
+                SmartProxy.pulp_master.pulp3_support?(separated_repo_map[:pulp3_yum].keys.flatten.first)
+              plan_action(Repository::MultiCloneToVersion, separated_repo_map[:pulp3_yum], version)
+            end
+
             concurrence do
               source_repositories.each do |repositories|
                 sequence do
-                  plan_action(Repository::CloneToVersion, repositories, version, repository_mapping[repositories],
-                                                 :repos_units => options[:repos_units])
-                  plan_action(Repository::CloneToEnvironment, repository_mapping[repositories], library)
+                  if repositories.present? && separated_repo_map[:other].keys.include?(repositories)
+                    plan_action(Repository::CloneToVersion, repositories, version, repository_mapping[repositories],
+                                :repos_units => options[:repos_units])
+                  end
+                  plan_action(Repository::CloneToEnvironment, repository_mapping[repositories], library) unless options[:skip_promotion]
                 end
               end
 
@@ -55,16 +71,18 @@ module Actions
             end
             has_modules = content_view.publish_puppet_environment?
             plan_action(ContentViewPuppetEnvironment::CreateForVersion, version)
-            plan_action(ContentViewPuppetEnvironment::Clone, version, :environment => library,
-                :puppet_modules_present => has_modules)
-            plan_action(Candlepin::Environment::SetContent, content_view, library, content_view.content_view_environment(library))
-            plan_action(Katello::Foreman::ContentUpdate, library, content_view)
-            plan_action(ContentView::ErrataMail, content_view, library)
+            unless options[:skip_promotion]
+              plan_action(ContentViewPuppetEnvironment::Clone, version, :environment => library,
+                  :puppet_modules_present => has_modules)
+            end
+            plan_action(Candlepin::Environment::SetContent, content_view, library, content_view.content_view_environment(library)) unless options[:skip_promotion]
+            plan_action(Katello::Foreman::ContentUpdate, library, content_view) unless options[:skip_promotion]
+            plan_action(ContentView::ErrataMail, content_view, library) unless options[:skip_promotion]
             plan_self(history_id: history.id, content_view_id: content_view.id,
                       auto_publish_composite_ids: auto_publish_composite_ids(content_view),
                       content_view_version_name: version.name,
                       content_view_version_id: version.id,
-                      environment_id: library.id, user_id: ::User.current.id)
+                      environment_id: library.id, user_id: ::User.current.id, skip_promotion: options[:skip_promotion])
           end
         end
 
@@ -85,6 +103,7 @@ module Actions
 
           output[:content_view_id] = input[:content_view_id]
           output[:content_view_version_id] = input[:content_view_version_id]
+          output[:skip_promotion] = input[:skip_promotion]
         end
 
         def rescue_strategy_for_self
@@ -95,9 +114,11 @@ module Actions
           version = ::Katello::ContentViewVersion.find(input[:content_view_version_id])
           version.update_content_counts!
           # update errata applicability counts for all hosts in the CV & Library
-          ::Katello::Host::ContentFacet.where(:content_view_id => input[:content_view_id],
-                                              :lifecycle_environment_id => input[:environment_id]).each do |facet|
-            facet.update_applicability_counts
+          unless input[:skip_promotion]
+            ::Katello::Host::ContentFacet.where(:content_view_id => input[:content_view_id],
+                                                :lifecycle_environment_id => input[:environment_id]).each do |facet|
+              facet.update_applicability_counts
+            end
           end
 
           history = ::Katello::ContentViewHistory.find(input[:history_id])
@@ -105,7 +126,7 @@ module Actions
           history.save!
           environment = ::Katello::KTEnvironment.find(input[:environment_id])
           view = ::Katello::ContentView.find(input[:content_view_id])
-          if SmartProxy.sync_needed?(environment) && Setting[:foreman_proxy_content_auto_sync]
+          if SmartProxy.sync_needed?(environment) && Setting[:foreman_proxy_content_auto_sync] && !input[:skip_promotion]
             ForemanTasks.async_task(ContentView::CapsuleSync,
                                     view,
                                     environment)
@@ -115,6 +136,20 @@ module Actions
 
         private
 
+        def include_other_components(override_components, content_view)
+          if override_components.present?
+            content_view.components.each do |component|
+              component_has_override = override_components.detect do |override_component|
+                component.content_view_id == override_component.content_view_id
+              end
+              unless component_has_override
+                override_components << component
+              end
+            end
+            override_components
+          end
+        end
+
         def repos_to_delete(content_view)
           if content_view.composite?
             library_instances = content_view.repositories_to_publish.map(&:library_instance_id)
@@ -132,7 +167,11 @@ module Actions
 
         def version_for_publish(content_view, options)
           if options[:minor] && options[:major]
-            content_view.create_new_version(options[:major], options[:minor])
+            if options[:override_components]
+              content_view.create_new_version(options[:major], options[:minor], options[:override_components])
+            else
+              content_view.create_new_version(options[:major], options[:minor])
+            end
           else
             content_view.create_new_version
           end