katello 3.17.3 → 3.18.0.rc1

data/app/services/katello/applicability/applicable_content_helper.rb

@@ -78,8 +78,7 @@ module Katello
           joins("INNER JOIN katello_installed_packages ON
             katello_rpms.name = katello_installed_packages.name AND
             katello_rpms.arch = katello_installed_packages.arch AND
-            katello_rpms.evr > katello_installed_packages.evr AND
-            katello_installed_packages.id in (#{newest_distinct_installed_packages_query})").
+            katello_rpms.evr > katello_installed_packages.evr").
           joins("LEFT JOIN katello_module_stream_rpms ON
             katello_rpms.id = katello_module_stream_rpms.rpm_id").
           joins("INNER JOIN katello_host_installed_packages ON
@@ -93,16 +92,6 @@ module Katello
             :enabled_module_streams => enabled_module_stream_ids).pluck(:id).uniq
       end
 
-      def newest_distinct_installed_packages_query
-        "SELECT DISTINCT ON (katello_installed_packages.name) katello_installed_packages.id " \
-          "FROM katello_installed_packages INNER JOIN " \
-          "katello_host_installed_packages ON " \
-          "katello_installed_packages.id = " \
-          "katello_host_installed_packages.installed_package_id " \
-          "WHERE katello_host_installed_packages.host_id = " \
-          "#{content_facet.host.id} ORDER BY katello_installed_packages.name, katello_installed_packages.evr DESC"
-      end
-
       def applicable_differences
         consumer_ids = content_facet.send(applicable_units).pluck("#{content_unit_class.table_name}.id")
         content_ids = fetch_content_ids

data/app/services/katello/candlepin/event_handler.rb

@@ -30,6 +30,8 @@ module Katello
           reindex_subscription_status
         when /system_purpose_compliance\.created/
           reindex_purpose_status
+        when /owner_content_access_mode\.modified/
+          message_handler.handle_content_access_mode_modified
         end
       end
 

data/app/services/katello/candlepin/message_handler.rb

@@ -20,6 +20,10 @@ module Katello
         @event_data ||= (data = content['eventData']) ? JSON.parse(data) : {}
       end
 
+      def target_name
+        content['targetName']
+      end
+
       def status
         event_data['status']
       end
@@ -85,6 +89,36 @@ module Katello
           Rails.logger.info "deleted pool #{pool_id} from Katello"
         end
       end
+
+      def handle_content_access_mode_modified
+        # Ideally the target_name would be the Candlepin Owner key
+        # Since it's the displayName, and we don't update that after org creation, there could be a mismatch
+        # For now, find the Candlepin Owner displayName from this event, and tie it back to a Katello org based on owner key
+        owners = Katello::Resources::Candlepin::Owner.all
+        owner = owners.find { |o| o['displayName'] == target_name }
+
+        unless owner
+          fail("Candlepin Owner %s could not be found" % target_name)
+        end
+
+        org = ::Organization.find_by!(label: owner['key'])
+        hosts = org.hosts
+
+        if event_data['contentAccessMode'] == 'org_environment'
+          Katello::HostStatusManager.clear_syspurpose_status(hosts)
+          Katello::HostStatusManager.update_subscription_status_to_sca(hosts)
+        elsif event_data['contentAccessMode'] == 'entitlement'
+          cp_consumer_uuids = hosts.joins(:subscription_facet).pluck("#{Katello::Host::SubscriptionFacet.table_name}.uuid")
+          cp_consumer_uuids.each do |uuid|
+            Katello::Resources::Candlepin::Consumer.compliance(uuid)
+            Katello::Resources::Candlepin::Consumer.purpose_compliance(uuid)
+          rescue => e
+            Rails.logger.error("Error encountered while fetching compliance for consumer #{uuid}: #{e.message}")
+          end
+        end
+
+        org.simple_content_access?(cached: false)
+      end
     end
   end
 end

data/app/services/katello/candlepin/upstream_consumer.rb

@@ -0,0 +1,28 @@
+module Katello
+  module Candlepin
+    class UpstreamConsumer
+      def initialize(organization)
+        @organization = organization
+      end
+
+      def simple_content_access_eligible?
+        eligible = true
+        ::Organization.as_org(@organization) do
+          content_modes = resource_class.content_access
+
+          if content_modes.key?(:contentAccessModeList)
+            eligible = content_modes[:contentAccessModeList].include?('org_environment')
+          end
+        end
+
+        eligible
+      end
+
+      private
+
+      def resource_class
+        Katello::Resources::Candlepin::UpstreamConsumer
+      end
+    end
+  end
+end

data/app/services/katello/host_status_manager.rb

@@ -16,5 +16,14 @@ module Katello
       Katello::PurposeRoleStatus,
       Katello::PurposeSlaStatus,
       Katello::PurposeUsageStatus].freeze
+
+    def self.update_subscription_status_to_sca(hosts)
+      HostStatus::Status.where(host: hosts, type: Katello::SubscriptionStatus.to_s).update(status: Katello::SubscriptionStatus::DISABLED)
+    end
+
+    def self.clear_syspurpose_status(hosts)
+      host_purpose = HostStatus::Status.where(type: ::Katello::HostStatusManager::PURPOSE_STATUS.map(&:to_s)).where('host_id in (?)', hosts.pluck(:id))
+      host_purpose.destroy_all
+    end
   end
 end

data/app/services/katello/pulp3/api/apt.rb

@@ -0,0 +1,57 @@
+require "pulpcore_client"
+
+module Katello
+  module Pulp3
+    module Api
+      class Apt < Core
+        def self.api_exception_class
+          PulpDebClient::ApiError
+        end
+
+        def self.client_module
+          PulpDebClient
+        end
+
+        def self.remote_class
+          PulpDebClient::DebAptRemote
+        end
+
+        def self.distribution_class
+          PulpDebClient::DebAptDistribution
+        end
+
+        def self.publication_class
+          PulpDebClient::DebAptPublication
+        end
+
+        def self.repository_sync_url_class
+          PulpDebClient::RepositorySyncURL
+        end
+
+        def api_client
+          PulpDebClient::ApiClient.new(smart_proxy.pulp3_configuration(PulpDebClient::Configuration))
+        end
+
+        def repositories_api
+          PulpDebClient::RepositoriesAptApi.new(api_client)
+        end
+
+        def repository_versions_api
+          PulpDebClient::RepositoriesDebVersionsApi.new(api_client)
+        end
+
+        def remotes_api
+          PulpDebClient::RemotesAptApi.new(api_client)
+        end
+
+        def publications_api
+          PulpDebClient::PublicationsAptApi.new(api_client)
+        end
+
+        def distributions_api
+          PulpDebClient::DistributionsAptApi.new(api_client)
+        end
+      end
+    end
+  end
+end

data/app/services/katello/pulp3/api/core.rb

@@ -86,6 +86,14 @@ module Katello
           PulpcoreClient::UploadsApi.new(core_api_client)
         end
 
+        def upload_commit_class
+          PulpcoreClient::UploadCommit
+        end
+
+        def signing_services_api
+          PulpcoreClient::SigningServicesApi.new(core_api_client)
+        end
+
         def tasks_api
           PulpcoreClient::TasksApi.new(core_api_client)
         end

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

@@ -3,7 +3,6 @@ module Katello
     module ContentViewVersion
       class Export
         include ImportExportCommon
-        METADATA_FILE = "metadata.json".freeze
 
         def initialize(smart_proxy:, content_view_version: nil, destination_server: nil)
           @smart_proxy = smart_proxy
@@ -26,8 +25,10 @@ module Katello
                                   repositories: repository_hrefs)
         end
 
-        def create_export(exporter_href)
-          [api.export_api.create(exporter_href, { versions: version_hrefs })]
+        def create_export(exporter_href, chunk_size = nil)
+          options = { versions: version_hrefs }
+          options[:chunk_size] = "#{chunk_size}MB" if chunk_size
+          [api.export_api.create(exporter_href, options)]
         end
 
         def fetch_export(exporter_href)

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

@@ -5,15 +5,16 @@ module Katello
         include ImportExportCommon
         BASEDIR = '/var/lib/pulp'.freeze
 
-        def initialize(smart_proxy:, content_view_version: nil, path: nil)
+        def initialize(smart_proxy:, content_view_version: nil, path: nil, metadata: nil)
           @smart_proxy = smart_proxy
           @content_view_version = content_view_version
           @path = path
+          @metadata = metadata
         end
 
         def repository_mapping
           mapping = {}
-          metadata[:repository_mapping].each do |key, value|
+          @metadata[:repository_mapping].each do |key, value|
             repo = @content_view_version.importable_repositories.joins(:root, :product).
                         where("#{::Katello::Product.table_name}" => {:name => value[:product]},
                                                   "#{::Katello::RootRepository.table_name}" => {:name => value[:repository]}).first
@@ -30,7 +31,7 @@ module Katello
         end
 
         def create_import(importer_href)
-          [api.import_api.create(importer_href, toc: "#{@path}/#{metadata[:toc]}")]
+          [api.import_api.create(importer_href, toc: "#{@path}/#{@metadata[:toc]}")]
         end
 
         def fetch_import(importer_href)
@@ -43,24 +44,13 @@ module Katello
           api.importer_api.delete(importer_href)
         end
 
-        def metadata
-          @metadata ||= self.class.metadata(@path)
-        end
-
         class << self
-          def metadata(path)
-            JSON.parse(File.read("#{path}/#{Export::METADATA_FILE}")).with_indifferent_access
-          end
-
           def check_permissions!(path)
             fail _("Invalid path specified.") if path.blank? || !File.directory?(path)
             fail _("The import path must be in a subdirectory under '%s'." % BASEDIR) unless path.starts_with?(BASEDIR)
-            metadata_file = "#{path}/#{::Katello::Pulp3::ContentViewVersion::Export::METADATA_FILE}"
-            fail _("Could not find metadata.json at '%s'." % metadata_file) unless File.exist?(metadata_file)
-            fail _("Unable to read the metadata.json at '%s'." % metadata_file) unless File.readable?(metadata_file)
             fail _("Pulp user or group unable to read content in '%s'." % path) unless pulp_user_accessible?(path)
+
             Dir.glob("#{path}/*").each do |file|
-              next if file == metadata_file
               fail _("Pulp user or group unable to read '%s'." % file) unless pulp_user_accessible?(file)
             end
           end

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

@@ -0,0 +1,38 @@
+module Katello
+  module Pulp3
+    class Deb < PulpContentUnit
+      include LazyAccessor
+      CONTENT_TYPE = "deb".freeze
+
+      def self.content_api
+        PulpDebClient::ContentPackagesApi.new(Katello::Pulp3::Api::Apt.new(SmartProxy.pulp_primary!).api_client)
+      end
+
+      def self.content_api_create(opts = {})
+        self.content_api.create(opts)
+      end
+
+      def self.create_content(options)
+        fail _("Artifact Id and relative path are needed to create content") unless options.dig(:file_name) && options.dig(:artifact)
+        PulpDebClient::DebContent.new(relative_path: options[:file_name], artifact: options[:artifact])
+      end
+
+      def self.ids_for_repository(repo_id)
+        repo = Katello::Pulp3::Repository::Apt.new(Katello::Repository.find(repo_id), SmartProxy.pulp_primary)
+        repo_content_list = repo.content_list
+        repo_content_list.map { |content| content.try(:pulp_href) }
+      end
+
+      def update_model(model)
+        custom_json = {}
+        custom_json['checksum'] = backend_data['sha256']
+        custom_json['filename'] = backend_data['relative_path']
+        custom_json['name'] = backend_data['package']
+        custom_json['version'] = backend_data['version']
+        custom_json['description'] = backend_data['description']
+        custom_json['architecture'] = backend_data['architecture']
+        model.update!(custom_json)
+      end
+    end
+  end
+end

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

@@ -35,8 +35,7 @@ module Katello
         custom_json["issued"] = convert_date_if_epoch(custom_json["issued"])
         custom_json["updated"] = convert_date_if_epoch(custom_json["updated"]) unless custom_json["updated"].blank?
 
-        if model.updated.blank? ||
-            (custom_json['updated'] && (custom_json['updated'].to_datetime != model.updated.to_datetime))
+        if model.updated.blank? || (custom_json['updated'].to_datetime != model.updated.to_datetime)
           custom_json['errata_id'] = custom_json.delete('id')
           custom_json['errata_type'] = custom_json.delete('type')
           custom_json['updated'] = custom_json['updated'].blank? ? custom_json['issued'] : custom_json['updated']

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

@@ -11,6 +11,11 @@ module Katello
         fail NotImplementedError
       end
 
+      def self.content_api_create(opts = {})
+        relative_path = opts.delete(:relative_path)
+        self.content_api.create(relative_path, opts)
+      end
+
       def self.create_content
         fail NotImplementedError
       end

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

@@ -19,6 +19,15 @@ module Katello
             name: "#{generate_backend_object_name}"
           }
         end
+
+        def partial_repo_path
+          "/pulp_ansible/galaxy/#{repo.relative_path}/api/v2/collections"
+        end
+
+        def mirror_remote_options
+          {
+          }
+        end
       end
     end
   end

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

@@ -0,0 +1,63 @@
+require 'pulp_deb_client'
+
+module Katello
+  module Pulp3
+    class Repository
+      class Apt < ::Katello::Pulp3::Repository
+        SIGNING_SERVICE_NAME = 'katello_deb_sign'.freeze
+
+        def remote_options
+          deb_remote_options = {
+            distributions: root.deb_releases
+          }
+          deb_remote_options[:components] = root.deb_components.present? ? root.deb_components : nil
+          deb_remote_options[:architectures] = root.deb_architectures.present? ? root.deb_architectures : nil
+
+          if root.url.blank?
+            deb_remote_options[:url] = nil
+          end
+
+          deb_remote_options[:gpgkey] = root.gpg_key.present? ? root.gpg_key.content : nil
+
+          common_remote_options.merge(deb_remote_options)
+        end
+
+        def publication_options(repository_version)
+          ss = api.signing_services_api.list(name: SIGNING_SERVICE_NAME).results
+          popts = super(repository_version)
+          popts.merge!(
+            {
+              # structured is not necessary for subscription-manager
+              #structured: true, # publish real suites (e.g. 'stable')
+              simple: true # publish all into 'default'-suite
+            }
+          )
+          popts[:signing_service] = ss[0].pulp_href if ss && ss.length == 1
+          popts
+        end
+
+        def distribution_options(path)
+          {
+            base_path: path,
+            publication: repo.publication_href,
+            name: "#{generate_backend_object_name}"
+          }
+        end
+
+        def partial_repo_path
+          "/pulp/deb/#{repo.relative_path}/".sub('//', '/')
+        end
+
+        def copy_content_for_source
+          # TODO
+          fail NotImplementedError
+        end
+
+        def regenerate_applicability
+          # TODO
+          fail NotImplementedError
+        end
+      end
+    end
+  end
+end

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

@@ -8,6 +8,10 @@ module Katello
           repo.container_repository_name
         end
 
+        def partial_repo_path
+          ''
+        end
+
         def remote_options
           options = {url: root.url, upstream_name: root.docker_upstream_name}
           if root.docker_tags_whitelist&.any?

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

@@ -159,7 +159,8 @@ module Katello
 
             data_dup.config[i][:content] = leftover_units.pop(copy_amount)
             unit_copy_counter += copy_amount
-            if unit_copy_counter != 0
+            # Do copy call if limit is reached or if we're under the limit but on the last repo config.
+            if unit_copy_counter >= UNIT_LIMIT || (i == data_dup.config.size - 1 && leftover_units.empty?)
               tasks << api.copy_api.copy_content(data_dup)
               unit_copy_counter = 0
             end

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

@@ -1,4 +1,5 @@
 require "pulpcore_client"
+
 module Katello
   module Pulp3
     class Repository
@@ -187,9 +188,8 @@ module Katello
         api.repositories_api.read(repository_reference.try(:repository_href))
       end
 
-      def delete_repository(repo_reference = repository_reference)
-        href = repo_reference.try(:repository_href)
-        repo_reference.try(:destroy)
+      def delete(href = repository_reference.try(:repository_href))
+        repository_reference.try(:destroy)
         ignore_404_exception { api.repositories_api.delete(href) } if href
       end
 
@@ -205,10 +205,16 @@ module Katello
       end
 
       def create_publication
-        publication_data = api.class.publication_class.new(repository_version: repo.version_href)
+        publication_data = api.class.publication_class.new(publication_options(repo.version_href))
         api.publications_api.create(publication_data)
       end
 
+      def publication_options(repository_version)
+        {
+          repository_version: repository_version
+        }
+      end
+
       def relative_path
         repo.relative_path.sub(/^\//, '')
       end
@@ -251,12 +257,8 @@ module Katello
         create_version(:base_version => from_repository.version_href)
       end
 
-      def version_zero?
-        repo.version_href.ends_with?('/versions/0/')
-      end
-
       def delete_version
-        ignore_404_exception { api.repository_versions_api.delete(repo.version_href) } unless version_zero?
+        ignore_404_exception { api.repository_versions_api.delete(repo.version_href) }
       end
 
       def create_version(options = {})

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

@@ -91,10 +91,11 @@ module Katello
 
       def remote_options
         base_options = common_remote_options
-        base_options.merge(url: remote_feed_url)
+        base_options.merge!(url: remote_feed_url)
         if (type_specific_options = repo_service.try(:mirror_remote_options))
-          base_options.merge(type_specific_options)
+          base_options.merge!(type_specific_options)
         end
+        base_options
       end
 
       def create_remote
@@ -110,8 +111,11 @@ module Katello
         api.remotes_list(name: backend_object_name).first
       end
 
-      def sync
-        repository_sync_url_data = api.class.repository_sync_url_class.new(remote: remote_href, mirror: true)
+      def sync(options = {})
+        sync_params = repo_service.sync_url_params(options)
+        sync_params[:remote] = remote_href
+        sync_params[:mirror] = true
+        repository_sync_url_data = api.class.repository_sync_url_class.new(sync_params)
         [api.repositories_api.sync(repository_href, repository_sync_url_data)]
       end
 
@@ -152,6 +156,7 @@ module Katello
         dist_params[:publication] = options[:publication] if options[:publication]
         dist_params[:repository_version] = version_href if options[:use_repository_version]
         dist_options = distribution_options(path, dist_params)
+        dist_options.delete(:content_guard) if repo_service.repo.content_type == "docker"
         if (distro = repo_service.lookup_distributions(base_path: path).first) ||
           (distro = repo_service.lookup_distributions(name: "#{backend_object_name}").first)
           # update dist

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

@@ -79,7 +79,7 @@ module Katello
 
       def error
         if task_data[:state] == CANCELED
-          _("Task canceled")
+          self.new(_("Task canceled"))
         elsif task_data[:state] == FAILED
           if task_data[:error][:description].blank?
             _("Pulp task error")
@@ -90,8 +90,8 @@ module Katello
       end
 
       def cancel
-        data = PulpcoreClient::TaskResponse.new(state: 'canceled')
-        tasks_api.tasks_cancel(task_data['pulp_href'], data)
+        data = PulpcoreClient::Task.new(state: 'canceled')
+        tasks_api.tasks_cancel(pulp_task['pulp_href'], data)
         #the main task may have completed, so cancel spawned tasks too
         task_data['spawned_tasks']&.each { |spawned| tasks_api.tasks_cancel(spawned['pulp_href'], data) }
       end

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

@@ -73,12 +73,6 @@ module Katello
       end
 
       def cancel
-        tasks_api = ::Katello::Pulp3::Api::Core.new(@smart_proxy).tasks_api
-        tasks_response = tasks_api.list(task_group: task_group_data['pulp_href'])
-        data = PulpcoreClient::TaskResponse.new(state: 'canceled')
-        tasks_response.results.collect do |result|
-          tasks_api.tasks_cancel(result.pulp_href, data)
-        end
       end
     end
   end

data/app/views/dashboard/_subscription_widget.html.erb

@@ -4,11 +4,6 @@
 
 <% if Organization.current.blank? %>
   <p class="ca"><%= _("Please select an organization to view subscription status.") %></p>
-<% elsif Organization.current.simple_content_access?%>
-  <div class="bastion alert alert-info">
-    <span translate>This organization has Simple Content Access enabled. Hosts can consume from all repositories in their Content View regardless of subscription status.
-    </span>
-  </div>
 <% else %>
   <% total_count = total_host_count() %>
   <% partial_consumer_count = partial_consumer_count() %>

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

@@ -1,6 +1,6 @@
 object @resource
 
-attributes :destination_server, :path, :id
+attributes :destination_server, :path, :id, :metadata
 
 node :content_view_version do |h|
   h.content_view_version.name

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

@@ -7,7 +7,7 @@ attributes :relative_path, :container_repository_name, :full_path, :library_inst
 attributes :version_href, :remote_href, :publication_href
 
 glue(@object.root) do
-  attributes :content_type, :url, :arch, :content_id
+  attributes :content_type, :url, :arch, :os_versions, :content_id
   attributes :major, :minor
 
   child :product do |_product|

data/app/views/overrides/organizations/_index_row_override.html.erb

@@ -1,3 +1,3 @@
 <% if taxonomy.is_a?(Organization) %>
-  <td><%= taxonomy.simple_content_access? ? _("Enabled") : _("Disabled") %></td>
+  <td><%= checked_icon taxonomy.simple_content_access? %></td>
 <% end %>

data/config/routes/api/v2.rb

@@ -122,6 +122,7 @@ Katello::Engine.routes.draw do
           end
           collection do
             get :export_histories
+            get :export_api_status
             get :auto_complete_search
             post :incremental_update
             post :import
@@ -357,6 +358,7 @@ Katello::Engine.routes.draw do
               get :ping
               match '/simple_content_access/enable', :to => 'upstream_subscriptions#enable_simple_content_access', :via => :put
               match '/simple_content_access/disable', :to => 'upstream_subscriptions#disable_simple_content_access', :via => :put
+              match '/simple_content_access/eligible', :to => 'upstream_subscriptions#simple_content_access_eligible', :via => :get
             end
           end
         end

data/config/routes/overrides.rb

@@ -78,6 +78,7 @@ Foreman::Application.routes.draw do
             match '/bulk/release_version' => 'hosts_bulk_actions#release_version', :via => :put
             match '/bulk/traces' => 'hosts_bulk_actions#traces', :via => :post
             match '/bulk/resolve_traces' => 'hosts_bulk_actions#resolve_traces', :via => :put
+            match '/bulk/system_purpose' => 'hosts_bulk_actions#system_purpose', :via => :put
             match '/bulk/available_incremental_updates' => 'hosts_bulk_actions#available_incremental_updates', :via => :post
             match '/bulk/module_streams' => 'hosts_bulk_actions#module_streams', :via => :post
             match '/subscriptions/' => 'host_subscriptions#create', :via => :post

data/db/migrate/20150930183738_migrate_content_hosts.rb

@@ -329,7 +329,7 @@ class MigrateContentHosts < ActiveRecord::Migration[4.2]
   # rubocop:disable Metrics/MethodLength
   # rubocop:disable Metrics/AbcSize
   def up
-    unless User.unscoped.where(:login => User::ANONYMOUS_API_ADMIN).exists?
+    if User.where(:login => User::ANONYMOUS_API_ADMIN).first.nil?
       logger.warn("Foreman anonymous admin does not exist, skipping content host migration.")
       return
     end

data/db/migrate/20200514092553_move_katello_fields_from_hostgroups.katello.rb

@@ -1,6 +1,6 @@
 class MoveKatelloFieldsFromHostgroups < ActiveRecord::Migration[6.0]
   def up
-    if User.unscoped.where(login: User::ANONYMOUS_ADMIN).exists?
+    if User.where(login: User::ANONYMOUS_ADMIN).exists?
       User.as_anonymous_admin do
         copy_data_from_hostgroup
       end
@@ -46,10 +46,7 @@ class MoveKatelloFieldsFromHostgroups < ActiveRecord::Migration[6.0]
         content_facet.kickstart_repository_id = kickstart_repository_id
         content_facet.content_view_id = content_view_id
         content_facet.lifecycle_environment_id = lifecycle_environment_id
-        unless content_facet.save
-          Rails.logger.warn("Unable to save content facet hostgroup for #{content_facet.inspect} ")
-          Rails.logger.warn(content_facet.errors.full_messages.join("\n"))
-        end
+        content_facet.save!
       end
     end
   end