katello 4.13.0 → 4.14.0.rc1

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

@@ -155,8 +155,7 @@ Pass [] to make repo available for clients regardless of OS version. Maximum len
       query = query.where(:root_id => RootRepository.where(:label => params[:label])) if params[:label]
       query = index_relation_content_unit(query)
       query = index_relation_content_view(query)
-      query = index_relation_environment(query)
-      query
+      index_relation_environment(query)
     end
 
     def index_relation_product(query)
@@ -439,7 +438,7 @@ Alternatively, use the 'force' parameter to regenerate metadata locally. On the
       respond_for_async :resource => sync_task(::Actions::Katello::Repository::RemoveContent, @repository, @content, content_type: params[:content_type], sync_capsule: sync_capsule)
     end
 
-    api :POST, "/repositories/:id/upload_content", N_("Upload content into the repository")
+    api :POST, "/repositories/:id/upload_content", N_("This endpoint is primarily designed for UI interactions and uploading content into the repository. For API-based uploads, please use the 'content_uploads' endpoint instead.")
     param :id, :number, :required => true, :desc => N_("repository ID")
     param :content, File, :required => true, :desc => N_("Content files to upload. Can be a single file or array of files.")
     param :content_type, String, :required => false, :desc => N_("The type of content to upload (srpm, file, etc.). Check uploadable types here: /katello/api/repositories/repository_types")
@@ -537,7 +536,7 @@ Alternatively, use the 'force' parameter to regenerate metadata locally. On the
       if @repository.root.gpg_key && @repository.root.gpg_key.content.present?
         render(:plain => @repository.root.gpg_key.content, :layout => false)
       else
-        head(404)
+        head(:not_found)
       end
     end
 

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

@@ -144,8 +144,8 @@ module Katello
 
       relation = relation.where(Katello::Content.table_name => {:name => params[:name]}) if params[:name].present?
       # ignore with_custom if repository_type is specified
-      if params[:repository_type].blank?
-        relation = relation.redhat unless ::Foreman::Cast.to_bool(params[:with_custom])
+      if params[:repository_type].blank? && !::Foreman::Cast.to_bool(params[:with_custom])
+        relation = relation.redhat
       end
       index_relation_with_consumable_overrides(relation)
     end
@@ -240,18 +240,17 @@ module Katello
     end
 
     def sort_score(pc) # sort order for enabled
-      score = if pc.enabled_content_override&.value == "1"
-                4 # overridden to enabled
-              elsif pc.enabled_content_override.nil? && pc.enabled
-                3 # enabled
-              elsif pc.enabled_content_override.nil? && !pc.enabled
-                2 # disabled
-              elsif pc.enabled_content_override&.value == "0"
-                1 # overridden to disabled
-              else
-                0
-              end
-      score
+      if pc.enabled_content_override&.value == "1"
+        4 # overridden to enabled
+      elsif pc.enabled_content_override.nil? && pc.enabled
+        3 # enabled
+      elsif pc.enabled_content_override.nil? && !pc.enabled
+        2 # disabled
+      elsif pc.enabled_content_override&.value == "0"
+        1 # overridden to disabled
+      else
+        0
+      end
     end
 
     def custom_sort_results(unsorted_relation)

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

@@ -41,16 +41,17 @@ module Katello
         format.csv do
           options[:csv] = true
           collection = scoped_search(*base_args, options)
-          csv_response(collection,
-                       [:id, :subscription_id, :name, :cp_id, :organization_id, :sockets, :cores,
-                        :start_date, :end_date, :consumed, :quantity, :account_number, :contract_number,
-                        :support_level, :ram, :stacking_id, :multi_entitlement, :type, :product_id,
-                        :unmapped_guest, :virt_only, :virt_who, :upstream?],
-                       ['Pool Id Number', 'Subscription Id', 'Name', 'Pool Id', 'Organization Id',
-                        'Sockets', 'Cores', 'Start Date', 'End Date', 'Consumed', 'Quantity', 'Account Number',
-                        'Contract Number', 'Support Level', 'RAM', 'Stacking Id', 'Multi Entitlement', 'Type',
-                        'Product Id', 'Unmapped Guest', 'Virt Only', 'Requires Virt Who', 'Upstream'])
+          fields = [:id, :subscription_id, :name, :cp_id, :organization_id, :sockets, :cores,
+                    :start_date, :end_date, :consumed, :quantity, :account_number, :contract_number,
+                    :support_level, :ram, :stacking_id, :multi_entitlement, :type, :product_id,
+                    :unmapped_guest, :virt_only, :virt_who, :upstream?, :product_host_count]
+          headers = ['Pool Id Number', 'Subscription Id', 'Name', 'Pool Id', 'Organization Id',
+                     'Sockets', 'Cores', 'Start Date', 'End Date', 'Consumed', 'Quantity', 'Account Number',
+                     'Contract Number', 'Support Level', 'RAM', 'Stacking Id', 'Multi Entitlement', 'Type',
+                     'Product Id', 'Unmapped Guest', 'Virt Only', 'Requires Virt Who', 'Upstream', 'Product Host Count']
+          csv_response(collection, fields, headers)
         end
+
         format.any do
           collection = scoped_search(*base_args, options)
           if params[:activation_key_id]
@@ -59,6 +60,9 @@ module Katello
               ActivationKeySubscriptionsPresenter.new(pool, key_pools)
             end
           end
+          collection[:results] = collection[:results].map do |pool|
+            ProductHostCountPresenter.new(pool)
+          end
           respond(:collection => collection)
         end
       end
@@ -88,6 +92,8 @@ module Katello
         fail HttpErrors::BadRequest, N_('This subscription is not relevant to the current organization.')
       end
 
+      @resource = ProductHostCountPresenter.new(@resource)
+
       respond(:resource => @resource)
     end
 

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

@@ -37,8 +37,8 @@ module Katello
     end
 
     def ensure_library
-      unless @repository.nil?
-        fail HttpErrors::NotFound, _("You can check sync status for repositories only in the library lifecycle environment.'") unless @repository.environment.library?
+      if !@repository.nil? && !@repository.environment.library?
+        fail HttpErrors::NotFound, _("You can check sync status for repositories only in the library lifecycle environment.'")
       end
     end
   end

data/app/controllers/katello/application_controller.rb

@@ -108,7 +108,7 @@ module Katello
       exception = args.find { |o| o.is_a? Exception }
       message   = args.find { |o| o.is_a? String } || exception.try(:message) || default_message
 
-      status = if exception&.respond_to?(:status_code)
+      status = if exception.respond_to?(:status_code)
                  exception.status_code
                else
                  400

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

@@ -99,9 +99,10 @@ module Katello
       def find_param_arrays(hash = params)
         list_of_paths = []
         hash.each do |key, value|
-          if value.is_a?(ActionController::Parameters) || value.is_a?(Hash)
+          case value
+          when ActionController::Parameters, Hash
             list_of_paths += find_param_arrays(value).compact.map { |inner_keys| [key] + inner_keys }
-          elsif value.is_a?(Array)
+          when Array
             list_of_paths << [key]
           end
         end

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

@@ -18,6 +18,7 @@ module Katello
       included do
         prepend Overrides
         before_action :purpose_addon_params, only: [:create, :update]
+        before_action :set_content_view_environments, only: [:create, :update]
 
         def destroy
           Katello::RegistrationManager.unregister_host(@host, :unregistering => false)
@@ -39,6 +40,33 @@ module Katello
           params[:host][:subscription_facet_attributes][:purpose_addon_ids] = addons.map { |addon_name| ::Katello::PurposeAddon.find_or_create_by(name: addon_name).id }
           params[:host][:subscription_facet_attributes].delete(:purpose_addons)
         end
+
+        def set_content_view_environments
+          content_facet_attributes = params.dig(:host, :content_facet_attributes)
+          return if content_facet_attributes.blank? || @host&.content_facet.blank? ||
+            (cve_params[:content_view_id].present? && cve_params[:lifecycle_environment_id].present?)
+          new_cves = nil
+          if cve_params[:content_view_environments].present? && cve_params[:content_view_environment_ids].blank?
+            # Must do maps here to ensure CVEs remain in the same order.
+            # Using ActiveRecord .where will return them in a different order.
+            environment_names = cve_params[:content_view_environments].map(&:strip)
+            Rails.logger.debug "new environment names: #{environment_names}"
+            new_cves = environment_names.map do |name|
+              ::Katello::ContentViewEnvironment.with_candlepin_name(name, organization: @host.organization)
+            end
+          end
+          if cve_params[:content_view_environment_ids].present?
+            new_cves = cve_params[:content_view_environment_ids].map do |id|
+              ::Katello::ContentViewEnvironment.find_by(id: id)
+            end
+          end
+
+          @host.content_facet.content_view_environments = new_cves.compact if new_cves.present?
+        end
+
+        def cve_params
+          params.require(:host).require(:content_facet_attributes).permit(:content_view_id, :lifecycle_environment_id, content_view_environments: [], content_view_environment_ids: [])
+        end
       end
     end
   end

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

@@ -28,7 +28,7 @@ module Katello
         update_api(:create) do
           param :registration_command, Hash do
             param :activation_key, String, desc: N_('Activation key for subscription-manager client, required for CentOS and Red Hat Enterprise Linux. For multiple keys use `activation_keys` param instead.'), deprecated: true
-            param :activation_keys, Array, desc: N_('Activation keys for subscription-manager client, required for CentOS and Red Hat Enterprise Linux. Required only if host group has no activation keys.')
+            param :activation_keys, Array, desc: N_('Activation keys for subscription-manager client, required for CentOS and Red Hat Enterprise Linux. Required only if host group has no activation keys or if you do not provide a host group.')
             param :force, :bool, required: false, desc: N_('Clear any previous registration and run subscription-manager with --force.')
             param :ignore_subman_errors, :bool, required: false, desc: N_('Ignore subscription-manager errors for `subscription-manager register` command')
           end

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

@@ -101,9 +101,10 @@ module Katello
       end
 
       def sort_options
-        if default_sort.is_a?(Array)
+        case default_sort
+        when Array
           return [default_sort[0], default_sort[1], {}]
-        elsif default_sort.is_a?(Proc)
+        when Proc
           return [nil, nil, { :custom_sort => default_sort }]
         else
           fail "Unsupported default_sort type"
@@ -145,7 +146,7 @@ module Katello
       def compare_same(collection, content_view_versions = nil)
         cv_version_first = content_view_versions[0]
         collection_ids = collection.in_repositories(Katello::Repository.where(:content_view_version_id => cv_version_first&.id))&.pluck(:id)
-        content_view_versions[1..-1].each do |version|
+        content_view_versions[1..].each do |version|
           collection_version_ids = collection.in_repositories(Katello::Repository.where(:content_view_version_id => version&.id))&.pluck(:id)
           collection_ids = collection_ids.intersection collection_version_ids
         end

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

@@ -94,10 +94,8 @@ module Katello
                                       .joins(:lifecycle_environments)
                                       .distinct
 
-          if Katello.with_remote_execution?
-            template_id = RemoteExecutionFeature.feature!(:katello_change_content_source).job_template_id
-            job_invocation_path = new_job_invocation_path(template_id: template_id, host_ids: content_hosts.map { |h| h[:id] }) if template_id
-          end
+          template_id = RemoteExecutionFeature.feature!(:katello_change_content_source).job_template_id
+          job_invocation_path = new_job_invocation_path(template_id: template_id, host_ids: content_hosts.map { |h| h[:id] }) if template_id
 
           render json: {
             content_hosts: content_hosts,

data/app/controllers/katello/remote_execution_controller.rb

@@ -1,75 +1,70 @@
 module Katello
-  if Katello.with_remote_execution?
-    class RemoteExecutionController < JobInvocationsController
-      include ::Api::V2::BulkHostsExtension
-      include Concerns::Api::V2::HostErrataExtensions
+  class RemoteExecutionController < JobInvocationsController
+    include ::Api::V2::BulkHostsExtension
+    include Concerns::Api::V2::HostErrataExtensions
 
-      def new
-        @composer = prepare_composer
-      end
-
-      def create
-        @composer = prepare_composer
-        if params[:customize] != 'true' && @composer.save
-          @composer.trigger
-          redirect_to job_invocation_path(@composer.job_invocation)
-        else
-          render :action => 'new'
-        end
-      end
+    def new
+      @composer = prepare_composer
+    end
 
-      # to overcome the isolated namespace engine difficulties with paths
-      helper Rails.application.routes.url_helpers
-      def _routes
-        Rails.application.routes
+    def create
+      @composer = prepare_composer
+      if params[:customize] != 'true' && @composer.save
+        @composer.trigger
+        redirect_to job_invocation_path(@composer.job_invocation)
+      else
+        render :action => 'new'
       end
+    end
 
-      private
+    # to overcome the isolated namespace engine difficulties with paths
+    helper Rails.application.routes.url_helpers
+    def _routes
+      Rails.application.routes
+    end
 
-      def prepare_composer
-        JobInvocationComposer.for_feature(feature_name, hosts, inputs)
-      end
+    private
 
-      def hosts
-        bulk_host_ids = ActiveSupport::JSON.decode(params[:bulk_host_ids]).deep_symbolize_keys
+    def prepare_composer
+      JobInvocationComposer.for_feature(feature_name, hosts, inputs)
+    end
 
-        find_bulk_hosts('edit_hosts', bulk_host_ids)
-      end
+    def hosts
+      bulk_host_ids = ActiveSupport::JSON.decode(params[:bulk_host_ids]).deep_symbolize_keys
 
-      def errata_inputs
-        if ::Foreman::Cast.to_bool(params[:install_all])
-          Erratum.installable_for_hosts(hosts).pluck(:errata_id).join(',')
-        elsif params[:bulk_errata_ids]
-          find_bulk_errata_ids(hosts, params[:bulk_errata_ids]).join(',')
-        else
-          params[:name]
-        end
-      end
+      find_bulk_hosts('edit_hosts', bulk_host_ids)
+    end
 
-      def inputs
-        case feature_name
-        when 'katello_errata_install'
-          { :errata => errata_inputs }
-        when 'katello_service_restart'
-          { :helper => params[:name] }
-        when 'katello_module_stream_action'
-          fail HttpErrors::NotFound, _('module streams not found') if params[:module_spec].blank?
-          fail HttpErrors::NotFound, _('actions not found') if params[:module_stream_action].blank?
-          inputs = { :module_spec => params[:module_spec], :action => params[:module_stream_action] }
-          inputs[:options] = params[:options] if params[:options]
-          inputs
-        else
-          { :package => params[:name] }
-        end
+    def errata_inputs
+      if ::Foreman::Cast.to_bool(params[:install_all])
+        Erratum.installable_for_hosts(hosts).pluck(:errata_id).join(',')
+      elsif params[:bulk_errata_ids]
+        find_bulk_errata_ids(hosts, params[:bulk_errata_ids]).join(',')
+      else
+        params[:name]
       end
+    end
 
-      def feature_name
-        # getting packageInstall from UI, translating to 'katello_package_install' feature
-        "katello_#{params[:remote_action].underscore}"
+    def inputs
+      case feature_name
+      when 'katello_errata_install'
+        { :errata => errata_inputs }
+      when 'katello_service_restart'
+        { :helper => params[:name] }
+      when 'katello_module_stream_action'
+        fail HttpErrors::NotFound, _('module streams not found') if params[:module_spec].blank?
+        fail HttpErrors::NotFound, _('actions not found') if params[:module_stream_action].blank?
+        inputs = { :module_spec => params[:module_spec], :action => params[:module_stream_action] }
+        inputs[:options] = params[:options] if params[:options]
+        inputs
+      else
+        { :package => params[:name] }
       end
     end
-  else
-    class RemoteExecutionController < ApplicationController
+
+    def feature_name
+      # getting packageInstall from UI, translating to 'katello_package_install' feature
+      "katello_#{params[:remote_action].underscore}"
     end
   end
 end

data/app/helpers/katello/hosts_and_hostgroups_helper.rb

@@ -12,6 +12,22 @@ module Katello
       edit_action? && !using_discovered_hosts_page?
     end
 
+    def content_source_inherited?(host)
+      !using_hostgroups_page? && host&.content_source.blank? && host&.hostgroup&.content_source.present? && cv_lce_disabled?
+    end
+
+    def lifecycle_environment_inherited?(host)
+      !using_hostgroups_page? && host&.lifecycle_environments&.empty? && host&.hostgroup&.lifecycle_environment.present? && cv_lce_disabled?
+    end
+
+    def content_view_inherited?(host)
+      !using_hostgroups_page? && host&.content_views&.empty? && host&.hostgroup&.content_view.present? && cv_lce_disabled?
+    end
+
+    def kickstart_repo_inheritable?(host)
+      host&.kickstart_repository_id.blank?
+    end
+
     def using_discovered_hosts_page?
       controller.controller_name == "discovered_hosts"
     end
@@ -138,9 +154,10 @@ module Katello
       all_options = []
       orgs.each do |org|
         content_object_options = ""
-        accessible_content_objects = if object_type == :lifecycle_environment
+        accessible_content_objects = case object_type
+                                     when :lifecycle_environment
                                        accessible_lifecycle_environments(org, host)
-                                     elsif object_type == :content_source
+                                     when :content_source
                                        accessible_content_proxies(host)
                                      end
         accessible_content_objects.each do |content_object|

data/app/helpers/katello/katello_urls_helper.rb

@@ -44,7 +44,7 @@ module Katello
       returns String, desc: 'Absolute path to a file'
     end
     def repository_url(content_path, _content_type = nil, schema = 'http')
-      return content_path if content_path =~ %r|^([\w\-\+]+)://|
+      return content_path if content_path =~ %r|^([\w\-+]+)://|
       url = if @host.content_source
               "#{schema}://#{@host.content_source.hostname}"
             else

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

@@ -4,7 +4,7 @@ module Actions
       module AlternateContentSourceCommon
         def create_simplified_acs(acs, smart_proxy)
           acs.products.each do |product|
-            product.repositories.has_url.library.with_type(acs.content_type).each do |repo|
+            product.acs_compatible_repositories.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

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

@@ -63,12 +63,13 @@ module Actions
               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|
+                product.acs_compatible_repositories.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|
+                # Don't use the acs_compatible_repositories filter here to ensure the proper repositories get disassociated
                 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) if smart_proxy_acs.present?

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

@@ -36,8 +36,7 @@ module Actions
           if repository
             [repository]
           else
-            repositories = smart_proxy_helper.repositories_available_to_capsule(environment, content_view).by_rpm_count
-            repositories
+            smart_proxy_helper.repositories_available_to_capsule(environment, content_view).by_rpm_count
           end
         end
 

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

@@ -6,6 +6,7 @@ module Actions
         include ::Katello::ContentViewHelper
         include ::Actions::ObservableAction
         attr_accessor :version
+
         execution_plan_hooks.use :trigger_capsule_sync, :on => :success
         execution_plan_hooks.use :notify_on_failure, :on => [:failure, :paused]
 

data/app/lib/actions/katello/content_view_version/create_repos.rb

@@ -4,6 +4,7 @@ module Actions
       class CreateRepos < Actions::Base
         # allows accessing the build object from the superior action
         attr_accessor :repository_mapping
+
         def plan(version, source_repositories = [])
           self.repository_mapping = {}
           concurrence do

data/app/lib/actions/katello/content_view_version/incremental_update.rb

@@ -127,9 +127,10 @@ module Actions
             ::Katello::Rpm.with_identifiers(content[:package_ids])
           unit_map = { :errata => [], :rpms => [] }
           units.each do |unit|
-            if unit.class.name == "Katello::Erratum"
+            case unit.class.name
+            when "Katello::Erratum"
               unit_map[:errata] << unit.id
-            elsif unit.class.name == "Katello::Rpm"
+            when "Katello::Rpm"
               unit_map[:rpms] << unit.id
             end
           end

data/app/lib/actions/katello/environment/{publish_repositories.rb → publish_container_repositories.rb}

@@ -1,7 +1,7 @@
 module Actions
   module Katello
     module Environment
-      class PublishRepositories < Actions::EntryAction
+      class PublishContainerRepositories < Actions::EntryAction
         middleware.use ::Actions::Middleware::RemoteAction
 
         input_format do
@@ -9,16 +9,18 @@ module Actions
           param :name
         end
 
-        def plan(env, options = {})
-          repositories = options[:content_type] ? env.repositories.with_type(options[:content_type]) : env.repositories
+        def plan(env)
+          repositories = env.repositories.docker_type
           action_subject(env)
           concurrence do
             repositories.each do |repository|
               sequence do
-                repository.set_container_repository_name
-                repository.clear_smart_proxy_sync_histories
-                plan_action(::Actions::Katello::Repository::InstanceUpdate, repository)
-                plan_action(::Actions::Katello::Repository::CapsuleSync, repository)
+                unless repository.root.is_container_push && repository.library_instance?
+                  repository.set_container_repository_name
+                  repository.clear_smart_proxy_sync_histories
+                  plan_action(::Actions::Katello::Repository::InstanceUpdate, repository)
+                  plan_action(::Actions::Katello::Repository::CapsuleSync, repository)
+                end
               end
             end
 
@@ -31,7 +33,7 @@ module Actions
         end
 
         def humanized_name
-          _("Publish Lifecycle Environment Repositories")
+          _("Publish Lifecycle Environment Container Repositories")
         end
 
         def humanized_input

data/app/lib/actions/katello/foreman/content_update.rb

@@ -20,12 +20,10 @@ module Actions
             content_view = ::Katello::ContentView.find(input[:content_view_id])
             repository = ::Katello::Repository.find(input[:repository_id]) if input[:repository_id]
 
-            if content_view.default? && repository
-              if repository.distribution_bootable?
-                os = Redhat.find_or_create_operating_system(repository)
-                arch = Architecture.where(:name => repository.distribution_arch).first_or_create!
-                os.architectures << arch unless os.architectures.include?(arch)
-              end
+            if content_view.default? && repository && repository.distribution_bootable?
+              os = Redhat.find_or_create_operating_system(repository)
+              arch = Architecture.where(:name => repository.distribution_arch).first_or_create!
+              os.architectures << arch unless os.architectures.include?(arch)
             end
           end
         end

data/app/lib/actions/katello/host/hypervisors_update.rb

@@ -33,6 +33,8 @@ module Actions
             end
           end
 
+          return if @duplicate_uuid_hypervisors.empty?
+
           @duplicate_uuid_hypervisors.each do |hypervisor, existing_host|
             fail _("Host creation was skipped for %s because it shares a BIOS UUID with %s. " \
                    "To report this hypervisor, override its dmi.system.uuid fact or set 'candlepin.use_system_uuid_for_matching' " \
@@ -120,8 +122,8 @@ module Actions
         end
 
         def validate_host_organization(host, organization)
-          if host.organization_id.nil? || host.organization_id != organization
-            fail _("Host '%{name}' does not belong to an organization") % {:name => host.name} unless host.organization
+          if (host.organization_id.nil? || host.organization_id != organization) && !host.organization
+            fail _("Host '%{name}' does not belong to an organization") % {:name => host.name}
           end
         end
 
@@ -175,8 +177,8 @@ module Actions
         end
 
         def update_facts(uuid, host)
-          if @candlepin_attributes.key?(uuid)
-            ::Katello::Host::SubscriptionFacet.update_facts(host, @candlepin_attributes[uuid][:facts]) unless @candlepin_attributes[uuid][:facts].blank?
+          if @candlepin_attributes.key?(uuid) && !@candlepin_attributes[uuid][:facts].blank?
+            ::Katello::Host::SubscriptionFacet.update_facts(host, @candlepin_attributes[uuid][:facts])
           end
         end
 

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

@@ -2,7 +2,7 @@ module Actions
   module Katello
     module Repository
       class Create < Actions::EntryAction
-        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
         def plan(repository, args = {})
           clone = args[:clone] || false
           force_repo_create = args[:force_repo_create] || false
@@ -15,7 +15,7 @@ module Actions
           sequence do
             # Container push repositories will already be in pulp. The version_href is
             # directly updated after a push.
-            unless root.is_container_push
+            unless root.is_container_push && repository.in_default_view?
               create_action = plan_action(Pulp3::Orchestration::Repository::Create,
                                           repository, SmartProxy.pulp_primary, force_repo_create)
               return if create_action.error
@@ -36,10 +36,10 @@ module Actions
             end
 
             # Container push repos do not need metadata generation or ACS (they do not sync)
-            unless root.is_container_push
+            unless root.is_container_push && repository.in_default_view?
               concurrence do
                 plan_self(:repository_id => repository.id, :clone => clone)
-                if !clone && repository.url.present?
+                if !clone && repository.url.present? && !repository.url.start_with?('uln')
                   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)

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

@@ -31,10 +31,17 @@ module Actions
             (on nil do
               unless output[:to_follow].empty?
                 password = decrypt_field(input[:upstream_password])
-                repo_discovery = ::Katello::RepoDiscovery.new(input[:url], input[:content_type],
-                                                              input[:upstream_username], password,
-                                                              input[:search],
-                                                              output[:crawled], output[:repo_urls], output[:to_follow])
+                repo_discovery = ::Katello::RepoDiscovery.class_for(input[:content_type]).new(
+                                                                                                input[:url],
+                                                                                                output[:crawled],
+                                                                                                output[:repo_urls],
+                                                                                                output[:to_follow],
+                                                                                                {
+                                                                                                  upstream_username: input[:upstream_username],
+                                                                                                  upstream_password: password,
+                                                                                                  search: input[:search]
+                                                                                                }
+                                                                                              )
 
                 repo_discovery.run(output[:to_follow].shift)
                 suspend { |suspended_action| world.clock.ping suspended_action, 0.001 }