katello 4.7.6 → 4.8.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a0a050c517227f7841e9242a1a02bd8d035844684abb8ad25c61e42c3e16a5a
-  data.tar.gz: a6951453dcec4f9ae1fd49622c94d22dce1573a6e788697ec117146e412c61c2
+  metadata.gz: c4b8d6a07335f66fa2aa32144b730a13949137d827c6df5d6418d732f3c16ffb
+  data.tar.gz: 8b38219d487f142d85e53a53f0c839e021b31edfca2b3ba71cd789dee1e1d378
 SHA512:
-  metadata.gz: 5041a03d75d5a6cf5fc38aaf2d9a43a05123dbc7065f5dccdf9bd67f40f50483c67ed274d687ab7bafe8ccc8e918afa46406bbed21c0482552e964a6155bc126
-  data.tar.gz: 1a622363fcd90b70cd167ae71bb741a8de5e6ef4128a957c476ce90947289cf47d8374560e3e8088dea1aeaaab5f28875707f1a60a50eefc6f4485f4011fc52c
+  metadata.gz: c7a5a28b77b887eafbef71455fa92c9321c031bd986d76b4fa0a70609031aaebea564363463c96b354cbe4efd44c377ee4aa7b564f9b2e4e2a0a099923bff26e
+  data.tar.gz: 7e951a7f6782c464d0cf07f0a7fbdfcfbe8b273680e89cb49bfff44cc7ee136c4c76268c86f316f7e0a80e109011f23b7bc2a5646ac8f3c7997560d9b803516f

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

@@ -210,12 +210,10 @@ module Katello
     def pull_blob
       headers = {}
       headers['Accept'] = request.headers['Accept'] if request.headers['Accept']
-      if (blob_response = redirect_client { Resources::Registry::Proxy.get(@_request.fullpath, headers, max_redirects: 0) })
-        #when pulp 2 is removed, this should no longer be needed, and all clients should be redirected
-        render json: blob_response
-      end
+      redirect_client { Resources::Registry::Proxy.get(@_request.fullpath, headers, max_redirects: 0) }
     end
 
+    # FIXME: Reimplement for Pulp 3.
     def push_manifest
       repository = params[:repository]
       tag = params[:tag]
@@ -242,6 +240,8 @@ module Katello
       render json: {}
     end
 
+    # FIXME: This is referring to a non-existent Pulp 2 server.
+    # Pulp 3 container push support is needed instead.
     def pulp_content
       Katello.pulp_server.resources.content
     end
@@ -414,6 +414,7 @@ module Katello
       tar_file
     end
 
+    # FIXME: Reimplement for Pulp 3.
     def upload_manifest(tar_file)
       upload_id = pulp_content.create_upload_request['upload_id']
       filename = tmp_file(tar_file)
@@ -439,6 +440,7 @@ module Katello
       pulp_content.delete_upload_request(upload_id) if upload_id
     end
 
+    # FIXME: Reimplement for Pulp 3.
     def upload_tag(digest, tag)
       upload_id = pulp_content.create_upload_request['upload_id']
       uploads = [{

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

@@ -211,7 +211,7 @@ module Katello
 
     #api :POST, "/environments/:environment_id/consumers", N_("Register a consumer in environment")
     def consumer_create
-      host = Katello::RegistrationManager.process_registration(rhsm_params, find_content_view_environment)
+      host = Katello::RegistrationManager.process_registration(rhsm_params, find_content_view_environments)
 
       host.reload
 
@@ -271,7 +271,7 @@ module Katello
 
     def get_parent_host(headers)
       hostnames = headers["HTTP_X_FORWARDED_HOST"]
-      host = hostnames.split(/[\,,:]/)[0].strip if hostnames
+      host = hostnames.split(/[,,:]/)[0].strip if hostnames
       host || URI.parse(Setting[:foreman_url]).host
     end
 
@@ -308,24 +308,27 @@ module Katello
       @host = ::Host::Managed.unscoped.find(facet.host_id)
     end
 
-    def find_content_view_environment
-      environment = nil
+    def find_content_view_environments
+      environments = []
 
       if params.key?(:environment_id)
-        environment = get_content_view_environment("cp_id", params[:environment_id])
+        environments = [get_content_view_environment("cp_id", params[:environment_id])]
       elsif params.key?(:environments)
-        fail HttpErrors::BadRequest, _('Multiple environments are not supported.') if params['environments'].length > 1
-        environment = get_content_view_environment("cp_id", params['environments'].first['id'])
-      elsif params.key?(:organization_id) && !params.key?(:environment_id)
+        if params['environments'].length > 1 && !Setting['allow_multiple_content_views']
+          fail HttpErrors::BadRequest, _('Registering to multiple environments is not enabled.')
+        end
+        environments = params[:environments].map do |env|
+          get_content_view_environment("cp_id", env['id'])
+        end
+      elsif params.key?(:organization_id) && !params.key?(:environment_id) && !params.key?(:environments)
         organization = Organization.current
-        environment = organization.library.content_view_environment
+        environments = organization.library.content_view_environment
       elsif User.current.default_organization.present?
-        environment = User.current.default_organization.library.content_view_environment
+        environments = User.current.default_organization.library.content_view_environment
       else
         fail HttpErrors::NotFound, _("User '%s' did not specify an organization ID and does not have a default organization.") % current_user.login
       end
-
-      environment
+      environments
     end
 
     def find_hypervisor_organization

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

@@ -135,9 +135,5 @@ module Katello
     def find_repository
       @repository = Katello::Repository.readable.find(params[:repository_id])
     end
-
-    def smart_proxy_service
-      Pulp::SmartProxyRepository.new(@capsule)
-    end
   end
 end

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

@@ -1,5 +1,5 @@
 module Katello
-  class Api::V2::ContentExportIncrementalsController < Api::V2::ApiController
+  class Api::V2::ContentExportIncrementalsController < Api::V2::ExportsController
     before_action :find_exportable_organization, :only => [:library]
     before_action :find_exportable_content_view_version, :only => [:version]
     before_action :find_exportable_repository, :only => [:repository]
@@ -7,70 +7,45 @@ module Katello
     before_action :find_repository_export_view, :only => [:repository]
     before_action :find_history, :only => [:version, :library, :repository]
 
+    def_param_group :incremental do
+      param :from_history_id, :number, :desc => N_("Export history identifier used for incremental export. "\
+                                         "If not provided the most recent export history will be used."), :required => false
+    end
+
     api :POST, "/content_export_incrementals/version", N_("Performs an incremental-export of a content view version.")
     param :id, :number, :desc => N_("Content view version identifier"), :required => true
-    param :destination_server, String, :desc => N_("Destination Server name"), :required => false
-    param :chunk_size_gb, :number, :desc => N_("Split the exported content into archives "\
-                                               "no greater than the specified size in gigabytes."), :required => false
-    param :from_history_id, :number, :desc => N_("Export history identifier used for incremental export. "\
-                                                 "If not provided the most recent export history will be used."), :required => false
-    param :fail_on_missing_content, :bool, :desc => N_("Fails if any of the repositories belonging to this version"\
-                                                         " are unexportable. False by default."), :required => false
+    param_group :version_fail_on_missing_content, Api::V2::ExportsController
+    param_group :destination_server, Api::V2::ExportsController
+    param_group :export, Api::V2::ExportsController
+    param_group :incremental
     def version
-      tasks = async_task(Actions::Katello::ContentViewVersion::Export,
-                          content_view_version: @version,
-                          destination_server: params[:destination_server],
-                          chunk_size: params[:chunk_size_gb],
-                          from_history: @history,
-                          fail_on_missing_content: ::Foreman::Cast.to_bool(params[:fail_on_missing_content]))
-
-      respond_for_async :resource => tasks
+      export_content_view_version
     end
 
     api :POST, "/content_export_incrementals/library", N_("Performs an incremental-export of the repositories in library.")
     param :organization_id, :number, :desc => N_("Organization identifier"), :required => true
-    param :destination_server, String, :desc => N_("Destination Server name"), :required => false
-    param :chunk_size_gb, :number, :desc => N_("Split the exported content into archives "\
-                                               "no greater than the specified size in gigabytes."), :required => false
-    param :from_history_id, :number, :desc => N_("Export history identifier used for incremental export. "\
-                                                 "If not provided the most recent export history will be used."), :required => false
-    param :fail_on_missing_content, :bool, :desc => N_("Fails if any of the repositories belonging to this organization"\
-                                                         " are unexportable. False by default."), :required => false
+    param_group :org_fail_on_missing_content, Api::V2::ExportsController
+    param_group :destination_server, Api::V2::ExportsController
+    param_group :export, Api::V2::ExportsController
+    param_group :incremental
     def library
-      tasks = async_task(::Actions::Pulp3::Orchestration::ContentViewVersion::ExportLibrary,
-                          @organization,
-                          destination_server: params[:destination_server],
-                          chunk_size: params[:chunk_size_gb],
-                          from_history: @history,
-                          fail_on_missing_content: ::Foreman::Cast.to_bool(params[:fail_on_missing_content]))
-      respond_for_async :resource => tasks
+      export_library
     end
 
     api :POST, "/content_export_incrementals/repository", N_("Performs a incremental-export of the repository in library.")
     param :id, :number, :desc => N_("Repository identifier"), :required => true
-    param :chunk_size_gb, :number, :desc => N_("Split the exported content into archives "\
-                                               "no greater than the specified size in gigabytes."), :required => false
-    param :from_history_id, :number, :desc => N_("Export history identifier used for incremental export. "\
-                                                 "If not provided the most recent export history will be used."), :required => false
+    param_group :export, Api::V2::ExportsController
+    param_group :incremental
     def repository
-      tasks = async_task(::Actions::Pulp3::Orchestration::ContentViewVersion::ExportRepository,
-                          @repository,
-                          chunk_size: params[:chunk_size_gb],
-                          from_history: @history)
-      respond_for_async :resource => tasks
+      export_repository
     end
 
     private
 
-    def find_exportable_content_view_version
-      @version = ContentViewVersion.exportable.find_by_id(params[:id])
-      throw_resource_not_found(name: 'content view version', id: params[:id]) if @version.blank?
-      @view = @version.content_view
-    end
-
     def find_library_export_view
       @view = ::Katello::Pulp3::ContentViewVersion::Export.find_library_export_view(destination_server: params[:destination_server],
                                                                 organization: @organization,
+                                                                format: find_export_format,
                                                                 create_by_default: false)
       if @view.blank?
         msg = _("Unable to incrementally export. Do a Full Export on the library content "\
@@ -82,46 +57,12 @@ module Katello
     def find_repository_export_view
       @view = ::Katello::Pulp3::ContentViewVersion::Export.find_repository_export_view(
                                                                 repository: @repository,
-                                                                create_by_default: false)
+                                                                create_by_default: false,
+                                                                format: find_export_format)
       if @view.blank?
         msg = _("Unable to incrementally export. Do a Full Export on the repository content.")
         fail HttpErrors::BadRequest, msg
       end
     end
-
-    def find_history
-      if params[:from_history_id].present?
-        @history = ::Katello::ContentViewVersionExportHistory.find(params[:from_history_id])
-        if @history.blank?
-          throw_resource_not_found(name: 'export history',
-                                   id: params[:from_history_id])
-        end
-      else
-        @history = ::Katello::ContentViewVersionExportHistory.
-                      latest(@view, destination_server: params[:destination_server])
-        if @history.blank?
-          msg = _("No existing export history was found to perform an incremental export. A full export must be performed")
-          fail HttpErrors::NotFound, msg
-        end
-      end
-    end
-
-    def find_exportable_organization
-      find_organization
-      unless @organization.can_export_content?
-        throw_resource_not_found(name: 'organization', id: params[:organization_id])
-      end
-    end
-
-    def find_exportable_repository
-      @repository = Repository.find_by_id(params[:id])
-      if @repository.blank?
-        throw_resource_not_found(name: 'repository', id: params[:id])
-      end
-
-      unless @repository.organization.can_export_content?
-        throw_resource_not_found(name: 'organization', id: @repository.organization.id)
-      end
-    end
   end
 end

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

@@ -1,5 +1,5 @@
 module Katello
-  class Api::V2::ContentExportsController < Api::V2::ApiController
+  class Api::V2::ContentExportsController < Api::V2::ExportsController
     before_action :find_exportable_organization, :only => [:library]
     before_action :find_exportable_content_view_version, :only => [:version]
     before_action :find_exportable_repository, :only => [:repository]
@@ -29,96 +29,27 @@ module Katello
 
     api :POST, "/content_exports/version", N_("Performs a full-export of a content view version.")
     param :id, :number, :desc => N_("Content view version identifier"), :required => true
-    param :destination_server, String, :desc => N_("Destination Server name"), :required => false
-    param :chunk_size_gb, :number, :desc => N_("Split the exported content into archives "\
-                                               "no greater than the specified size in gigabytes."), :required => false
-    param :fail_on_missing_content, :bool, :desc => N_("Fails if any of the repositories belonging to this version"\
-                                                         " are unexportable. False by default."), :required => false
-    param :format, ::Katello::Pulp3::ContentViewVersion::Export::FORMATS,
-                   :desc => N_("Export formats. Choose syncable if content is to be imported via repository sync. "\
-                               "Choose importable if content is to be imported via hammer content-import.
-                                Defaults to importable."),
-                   :required => false
+    param_group :version_fail_on_missing_content, Api::V2::ExportsController
+    param_group :destination_server, Api::V2::ExportsController
+    param_group :export, Api::V2::ExportsController
     def version
-      tasks = async_task(::Actions::Katello::ContentViewVersion::Export,
-                          content_view_version: @version,
-                          destination_server: params[:destination_server],
-                          chunk_size: params[:chunk_size_gb],
-                          fail_on_missing_content: ::Foreman::Cast.to_bool(params[:fail_on_missing_content]),
-                          format: find_export_format)
-      respond_for_async :resource => tasks
+      export_content_view_version
     end
 
     api :POST, "/content_exports/library", N_("Performs a full-export of the repositories in library.")
     param :organization_id, :number, :desc => N_("Organization identifier"), :required => true
-    param :destination_server, String, :desc => N_("Destination Server name"), :required => false
-    param :chunk_size_gb, :number, :desc => N_("Split the exported content into archives "\
-                                               "no greater than the specified size in gigabytes."), :required => false
-    param :fail_on_missing_content, :bool, :desc => N_("Fails if any of the repositories belonging to this organization"\
-                                                         " are unexportable. False by default."), :required => false
-    param :format, ::Katello::Pulp3::ContentViewVersion::Export::FORMATS,
-                   :desc => N_("Export formats. Choose syncable if content is to be imported via repository sync. "\
-                               "Choose importable if content is to be imported via hammer content-import.
-                                Defaults to importable."),
-                   :required => false
+    param_group :org_fail_on_missing_content, Api::V2::ExportsController
+    param_group :destination_server, Api::V2::ExportsController
+    param_group :export, Api::V2::ExportsController
     def library
-      tasks = async_task(::Actions::Pulp3::Orchestration::ContentViewVersion::ExportLibrary,
-                          @organization,
-                          destination_server: params[:destination_server],
-                          chunk_size: params[:chunk_size_gb],
-                          fail_on_missing_content: ::Foreman::Cast.to_bool(params[:fail_on_missing_content]),
-                          format: find_export_format)
-      respond_for_async :resource => tasks
+      export_library
     end
 
     api :POST, "/content_exports/repository", N_("Performs a full-export of the repository in library.")
     param :id, :number, :desc => N_("Repository identifier"), :required => true
-    param :chunk_size_gb, :number, :desc => N_("Split the exported content into archives "\
-                                               "no greater than the specified size in gigabytes."), :required => false
-    param :format, ::Katello::Pulp3::ContentViewVersion::Export::FORMATS,
-                   :desc => N_("Export formats. Choose syncable if content is to be imported via repository sync. "\
-                               "Choose importable if content is to be imported via hammer content-import.
-                                Defaults to importable."),
-                   :required => false
+    param_group :export, Api::V2::ExportsController
     def repository
-      tasks = async_task(::Actions::Pulp3::Orchestration::ContentViewVersion::ExportRepository,
-                          @repository,
-                          chunk_size: params[:chunk_size_gb],
-                          format: find_export_format)
-      respond_for_async :resource => tasks
-    end
-
-    private
-
-    def find_exportable_repository
-      @repository = Repository.find_by_id(params[:id])
-      if @repository.blank? || !@repository.organization.can_export_content?
-        throw_resource_not_found(name: 'repository', id: params[:id])
-      end
-    end
-
-    def find_exportable_content_view_version
-      @version = ContentViewVersion.exportable.find_by_id(params[:id])
-      throw_resource_not_found(name: 'content view version', id: params[:id]) if @version.blank?
-    end
-
-    def find_exportable_organization
-      find_organization
-      unless @organization.can_export_content?
-        throw_resource_not_found(name: 'organization', id: params[:organization_id])
-      end
-    end
-
-    def find_export_format
-      if params[:format]
-        unless ::Katello::Pulp3::ContentViewVersion::Export::FORMATS.include?(params[:format])
-          fail HttpErrors::UnprocessableEntity, _('Invalid export format provided. Format must be one of  %s ') %
-                                            ::Katello::Pulp3::ContentViewVersion::Export::FORMATS.join(',')
-        end
-        params[:format]
-      else
-        ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE
-      end
+      export_repository
     end
   end
 end

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

@@ -67,6 +67,7 @@ module Katello
         :incremental,
         :destination_server,
         :format,
+        :base_path,
         gpg_keys: {},
         content_view: [:name, :label, :description, :generated_for],
         content_view_version: [:major, :minor, :description],

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

@@ -0,0 +1,130 @@
+module Katello
+  class Api::V2::ExportsController < Api::V2::ApiController
+    resource_description do
+      api_version 'v2'
+      api_base_url "/katello/api"
+    end
+
+    def_param_group :export do
+      param :chunk_size_gb, :number,
+                :desc => N_("Split the exported content into archives "\
+                              "no greater than the specified size in gigabytes."), :required => false
+
+      param :format, ::Katello::Pulp3::ContentViewVersion::Export::FORMATS,
+                     :desc => N_("Export formats."\
+                               "Choose syncable if the exported content needs to be in a yum format. "\
+                               "This option is only available for %{syncable_repos} repositories. "\
+                               "Choose importable if the importing server uses the same version "\
+                               " and exported content needs to be one "\
+                               "of %{importable_repos} repositories."\
+                                % {
+                                  syncable_repos: ::Katello::Repository.exportable_types(
+                                    format: ::Katello::Pulp3::ContentViewVersion::Export::SYNCABLE).join(", "),
+                                  importable_repos: ::Katello::Repository.exportable_types(
+                                    format: ::Katello::Pulp3::ContentViewVersion::Export::IMPORTABLE).join(", ")
+                                }),
+                     :required => false
+    end
+
+    def_param_group :org_fail_on_missing_content do
+      param :fail_on_missing_content, :bool,
+            :desc => N_("Fails if any of the repositories belonging to this organization"\
+                        " are unexportable. False by default."), :required => false
+    end
+
+    def_param_group :version_fail_on_missing_content do
+      param :fail_on_missing_content, :bool,
+              :desc => N_("Fails if any of the repositories belonging to this version"\
+                          " are unexportable. False by default."), :required => false
+    end
+
+    def_param_group :destination_server do
+      param :destination_server, String, :desc => N_("Destination Server name"), :required => false
+    end
+
+    def export_repository
+      tasks = async_task(::Actions::Pulp3::Orchestration::ContentViewVersion::ExportRepository,
+                          @repository,
+                          chunk_size: params[:chunk_size_gb],
+                          from_history: @history,
+                          format: find_export_format)
+      respond_for_async :resource => tasks
+    end
+
+    def export_content_view_version
+      tasks = async_task(Actions::Katello::ContentViewVersion::Export,
+                  content_view_version: @version,
+                  destination_server: params[:destination_server],
+                  chunk_size: params[:chunk_size_gb],
+                  from_history: @history,
+                  format: find_export_format,
+                  fail_on_missing_content: ::Foreman::Cast.to_bool(params[:fail_on_missing_content]))
+
+      respond_for_async :resource => tasks
+    end
+
+    def export_library
+      tasks = async_task(::Actions::Pulp3::Orchestration::ContentViewVersion::ExportLibrary,
+                          @organization,
+                          destination_server: params[:destination_server],
+                          chunk_size: params[:chunk_size_gb],
+                          from_history: @history,
+                          format: find_export_format,
+                          fail_on_missing_content: ::Foreman::Cast.to_bool(params[:fail_on_missing_content]))
+      respond_for_async :resource => tasks
+    end
+
+    def find_export_format
+      if params[:format]
+        unless ::Katello::Pulp3::ContentViewVersion::Export::FORMATS.include?(params[:format])
+          fail HttpErrors::UnprocessableEntity, _('Invalid export format provided. Format must be one of  %s ') %
+                                            ::Katello::Pulp3::ContentViewVersion::Export::FORMATS.join(',')
+        end
+        params[:format]
+      else
+        Setting[:default_export_format]
+      end
+    end
+
+    def find_exportable_repository
+      @repository = Repository.find_by_id(params[:id])
+      if @repository.blank?
+        throw_resource_not_found(name: 'repository', id: params[:id])
+      end
+
+      unless @repository.organization.can_export_content?
+        throw_resource_not_found(name: 'organization', id: @repository.organization.id)
+      end
+    end
+
+    def find_exportable_organization
+      find_organization
+      unless @organization.can_export_content?
+        throw_resource_not_found(name: 'organization', id: params[:organization_id])
+      end
+    end
+
+    def find_exportable_content_view_version
+      @version = ContentViewVersion.exportable.find_by_id(params[:id])
+      throw_resource_not_found(name: 'content view version', id: params[:id]) if @version.blank?
+      @view = @version.content_view
+    end
+
+    def find_history
+      if params[:from_history_id].present?
+        @history = ::Katello::ContentViewVersionExportHistory.find(params[:from_history_id])
+        if @history.blank?
+          throw_resource_not_found(name: 'export history',
+                                   id: params[:from_history_id])
+        end
+      else
+        @history = ::Katello::ContentViewVersionExportHistory.
+                      latest(@view, destination_server: params[:destination_server])
+        if @history.blank?
+          msg = _("No existing export history was found to perform an incremental export. A full export must be performed")
+          fail HttpErrors::NotFound, msg
+        end
+      end
+    end
+  end
+end

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

@@ -40,7 +40,7 @@ module Katello
       respond_for_index :collection => @collection
     end
 
-    def index_response(reload_host = false)
+    def index_response(reload_host: false)
       # Host needs to be reloaded because of lazy accessor
       @host.reload if reload_host
       presenter = ::Katello::HostSubscriptionsPresenter.new(@host)
@@ -55,7 +55,7 @@ module Katello
       end
 
       sync_task(::Actions::Katello::Host::AutoAttachSubscriptions, @host)
-      respond_for_index(:collection => index_response(true), :template => "index")
+      respond_for_index(:collection => index_response(reload_host: true), :template => "index")
     end
 
     api :DELETE, "/hosts/:host_id/subscriptions/", N_("Unregister the host as a subscription consumer")
@@ -126,7 +126,7 @@ module Katello
       end
 
       sync_task(::Actions::Katello::Host::RemoveSubscriptions, @host, pool_id_quantities.values)
-      respond_for_index(:collection => index_response(true), :template => "index")
+      respond_for_index(:collection => index_response(reload_host: true), :template => "index")
     end
 
     api :PUT, "/hosts/:host_id/subscriptions/add_subscriptions", N_("Add a subscription to a host")
@@ -145,7 +145,7 @@ module Katello
       end
 
       sync_task(::Actions::Katello::Host::AttachSubscriptions, @host, pools_with_quantities)
-      respond_for_index(:collection => index_response(true), :template => "index")
+      respond_for_index(:collection => index_response(reload_host: true), :template => "index")
     end
 
     api :GET, "/hosts/:host_id/subscriptions/product_content", N_("Get content and overrides for the host")
@@ -154,7 +154,7 @@ module Katello
     param :content_access_mode_env, :bool, :desc => N_("Limit content to just that available in the host's content view version")
     param_group :search, Api::V2::ApiController
     def product_content
-      # note this is just there as a place holder for apipie.
+      # NOTE: this is just there as a placeholder for apipie.
       # The routing would automatically redirect it to repository_sets#index
     end
 
@@ -176,7 +176,6 @@ module Katello
       content_override_values = @content_overrides.map do |override_params|
         validate_content_overrides_enabled(override_params)
       end
-
       sync_task(::Actions::Katello::Host::UpdateContentOverrides, @host, content_override_values, false)
       fetch_product_content
     end
@@ -206,7 +205,7 @@ module Katello
     def find_content_view_environment
       @content_view_environment = Katello::ContentViewEnvironment.where(:content_view_id => params[:content_view_id],
                                                                         :environment_id => params[:lifecycle_environment_id]).first
-      fail HttpErrors::NotFound, _("Couldn't find specified Content View and Lifecycle Environment.") if @content_view_environment.nil?
+      fail HttpErrors::NotFound, _("Couldn't find specified content view and lifecycle environment.") if @content_view_environment.nil?
     end
 
     def check_subscriptions
@@ -232,7 +231,7 @@ module Katello
     end
 
     def find_content_overrides
-      if params[:content_overrides_search]
+      if !params.dig(:content_overrides_search, :search).nil?
         content_labels = ::Katello::Content.joins(:product_contents)
                             .where("#{Katello::ProductContent.table_name}.product_id": @host.organization.products.subscribable.enabled)
                             .search_for(params[:content_overrides_search][:search])

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

@@ -281,7 +281,10 @@ module Katello
         version_environment[:environments] << cve.environment unless version_environment[:environments].include?(cve.environment)
         version_environment[:next_version] ||= version.next_incremental_version
         version_environment[:content_host_count] ||= 0
-        version_environment[:content_host_count] += content_facets.where(:content_view_id => cve.content_view).where(:lifecycle_environment_id => cve.environment).count
+        version_environment[:content_host_count] += content_facets.in_content_views_and_environments(
+          content_views: [cve.content_view],
+          lifecycle_environments: [cve.environment]
+        ).count
 
         if version.content_view.composite?
           version_environment[:components] = version.components_needing_errata(@errata)
@@ -323,9 +326,10 @@ module Katello
 
       hosts.each do |host|
         next unless host.content_facet
-
-        host.content_facet.lifecycle_environment = lifecycle_environment
-        host.content_facet.content_view = content_view
+        host.content_facet.assign_single_environment(
+          :content_view_id => content_view.id,
+          :environment_id => lifecycle_environment.id
+        )
         host.content_facet.content_source = content_source
 
         host.update_candlepin_associations

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

@@ -82,6 +82,9 @@ module Katello
       respond_for_create :resource => @organization
     rescue => e
       ::Foreman::Logging.exception('Could not create organization', e)
+      # Force @organization.errors to be populated
+      # Organization.new may raise so @organization may not be set
+      @organization&.valid?
       process_resource_error(message: e.message, resource: @organization)
     end