katello 3.0.0.rc1 → 3.0.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6556a9a45be788950f7121e13324f371dae87f9c
-  data.tar.gz: e5df82ecc9631da6506fa9d86120c3e487261719
+  metadata.gz: d6829678768affb483093b13a2110018c840afa8
+  data.tar.gz: 1fc206b7a87207c04f93769ff55dce2f4ade0728
 SHA512:
-  metadata.gz: f816179cda53ada12c385dbd8006096fcd3f218a9e12a993b5eaec365b7f89ca1ebd8d93a324808249fe96c167ebf69953c30d7f31cbe00871ae9c6322b82237
-  data.tar.gz: f669b7c4724baef60b37de2416500cff4373d27b3b85c5a0d3167b1f3fc107d8d64e98c6a27b11fb6fd2529850d073521a94a68e58bb3ffa79c0acdbbc9b6e67
+  metadata.gz: bb875205693ff0f2cdc55a4fd06dedf91ebb571f70a33e44c69655b1d08c365630efe93a0d0b491372d2f84462a0e946f832eebf23a7eb54c2fb047e27730ff9
+  data.tar.gz: 7a5a4f83be8c4d6c8f81d44ea9bcc4fae3820ad37e3059d2a5e15f108ecfdde6783cfa20f9557df674ab8addc62ad10362fbef721f9740424cf5a0c12e92852f

data/app/assets/stylesheets/katello/katello.scss

@@ -8,11 +8,11 @@
 @import "katello/widgets/tabs";
 @import "katello/katello_sprites";
 
-@import "jquery-ui-1.8.11.custom.css";
-@import "jquery.loadmask.css";
-@import "jquery.treeTable.css";
-@import "jquery.jscrollpane.css";
-@import "ui.spinner.css";
+@import "katello/jquery.loadmask";
+@import "katello/jquery-ui-1.8.11.custom";
+@import "katello/jquery.treeTable";
+@import "katello/jquery.jscrollpane";
+@import "katello/ui.spinner";
 
 @import "katello/contents";
 @import "katello/generic";

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

@@ -352,9 +352,9 @@ module Katello
           activation_key = organization.activation_keys.find_by(:name => ak_name)
           fail HttpErrors::NotFound, _("Couldn't find activation key '%s'") % ak_name unless activation_key
 
-          if !activation_key.unlimited_content_hosts && activation_key.usage_count >= activation_key.max_content_hosts
-            fail Errors::MaxContentHostsReachedException, _("Max Content Hosts (%{limit}) reached for activation key '%{name}'") %
-                { :limit => activation_key.max_content_hosts, :name => activation_key.name }
+          if !activation_key.unlimited_hosts && activation_key.usage_count >= activation_key.max_hosts
+            fail Errors::MaxHostsReachedException, _("Max Hosts (%{limit}) reached for activation key '%{name}'") %
+                { :limit => activation_key.max_hosts, :name => activation_key.name }
           end
           activation_key
         end

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

@@ -33,8 +33,8 @@ module Katello
     param :environment, Hash, :desc => N_("environment")
     param :environment_id, :identifier, :desc => N_("environment id")
     param :content_view_id, :identifier, :desc => N_("content view id")
-    param :max_content_hosts, :number, :desc => N_("maximum number of registered content hosts")
-    param :unlimited_content_hosts, :bool, :desc => N_("can the activation key have unlimited content hosts")
+    param :max_hosts, :number, :desc => N_("maximum number of registered content hosts")
+    param :unlimited_hosts, :bool, :desc => N_("can the activation key have unlimited hosts")
     def create
       @activation_key = ActivationKey.new(activation_key_params) do |activation_key|
         activation_key.environment = @environment if @environment
@@ -53,8 +53,8 @@ module Katello
     param :description, String, :desc => N_("description")
     param :environment_id, :identifier, :desc => N_("environment id")
     param :content_view_id, :identifier, :desc => N_("content view id")
-    param :max_content_hosts, :number, :desc => N_("maximum number of registered content hosts")
-    param :unlimited_content_hosts, :bool, :desc => N_("can the activation key have unlimited content hosts")
+    param :max_hosts, :number, :desc => N_("maximum number of registered content hosts")
+    param :unlimited_hosts, :bool, :desc => N_("can the activation key have unlimited hosts")
     param :release_version, String, :desc => N_("content release version")
     param :service_level, String, :desc => N_("service level")
     param :auto_attach, :bool, :desc => N_("auto attach subscriptions upon registration")
@@ -302,22 +302,22 @@ module Katello
                                                           :release_version,
                                                           :service_level,
                                                           :auto_attach,
-                                                          :max_content_hosts,
-                                                          :unlimited_content_hosts,
+                                                          :max_hosts,
+                                                          :unlimited_hosts,
                                                           :content_overrides => [],
                                                           :host_collection_ids => [])
 
       key_params[:environment_id] = params[:environment][:id] if params[:environment].try(:[], :id)
       key_params[:content_view_id] = params[:content_view][:id] if params[:content_view].try(:[], :id)
-      unlimited = params[:activation_key].try(:[], :unlimited_content_hosts)
-      max_hosts = params[:activation_key].try(:[], :max_content_hosts)
+      unlimited = params[:activation_key].try(:[], :unlimited_hosts)
+      max_hosts = params[:activation_key].try(:[], :max_hosts)
 
       if unlimited && max_hosts
-        key_params[:unlimited_content_hosts] = true
-        key_params[:max_content_hosts] = nil
+        key_params[:unlimited_hosts] = true
+        key_params[:max_hosts] = nil
       else
-        key_params[:unlimited_content_hosts] = false if max_hosts
-        key_params[:max_content_hosts] = nil if unlimited
+        key_params[:unlimited_hosts] = false if max_hosts
+        key_params[:max_hosts] = nil if unlimited
       end
 
       key_params

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

@@ -44,7 +44,6 @@ module Katello
         :subtotal => collection.count }
     end
 
-    # rubocop:disable MethodLength
     def scoped_search(query, default_sort_by, default_sort_order, options = {})
       resource = options[:resource_class] || resource_class
       includes = options.fetch(:includes, [])
@@ -76,18 +75,27 @@ module Katello
       else
         query = query.paginate(paginate_options)
       end
+      page = params[:page] || 1
+      per_page = params[:per_page] || ::Setting::General.entries_per_page
 
+      scoped_search_results(query, sub_total, total, page, per_page)
+    rescue ScopedSearch::QueryNotSupported => error
+      return scoped_search_results(query, sub_total, total, page, per_page, error.message)
+    end
+
+    protected
+
+    def scoped_search_results(query, sub_total, total, page, per_page, error = nil)
       {
         :results  => query,
         :subtotal => sub_total,
         :total    => total,
-        :page     => params[:page] || 1,
-        :per_page => params[:per_page] || ::Setting::General.entries_per_page
+        :page     => page,
+        :per_page => per_page,
+        :error    => error
       }
     end
 
-    protected
-
     def labelize_params(param_hash)
       return param_hash[:label] unless param_hash.try(:[], :label).nil?
       return Util::Model.labelize(param_hash[:name]) unless param_hash.try(:[], :name).nil?

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

@@ -1,6 +1,6 @@
 module Katello
   class Api::V2::ContentViewVersionsController < Api::V2::ApiController
-    include Concerns::Api::V2::BulkSystemsExtensions
+    include Concerns::Api::V2::BulkHostsExtensions
     include Katello::Concerns::FilteredAutoCompleteSearch
 
     before_filter :find_content_view_version, :only => [:show, :promote, :destroy, :export]
@@ -94,47 +94,47 @@ module Katello
     param :resolve_dependencies, :bool, :desc => N_("If true, when adding the specified errata or packages, any needed dependencies will be copied as well.")
     param :propagate_all_composites, :bool, :desc => N_("If true, will publish a new composite version using any specified content_view_version_id that has been promoted to a lifecycle environment.")
     param :add_content, Hash  do
-      param :errata_ids, Array, :desc => "Errata uuids to copy into the new versions."
-      param :package_ids, Array, :desc => "Package uuids to copy into the new versions."
-      param :puppet_module_ids, Array, :desc => "Puppet Modules to copy into the new versions."
+      param :errata_ids, Array, :desc => "Errata ids or uuids to copy into the new versions."
+      param :package_ids, Array, :desc => "Package ids or uuids to copy into the new versions."
+      param :puppet_module_ids, Array, :desc => "Puppet Module ids or uuids to copy into the new versions."
     end
-    param :update_systems, Hash, :desc => N_("After generating the incremental update, apply the changes to the specified systems.  Only Errata are supported currently.") do
+    param :update_hosts, Hash, :desc => N_("After generating the incremental update, apply the changes to the specified hosts.  Only Errata are supported currently.") do
       param :included, Hash, :required => true, :action_aware => true do
-        param :search, String, :required => false, :desc => N_("Search string for systems to perform an action on")
-        param :ids, Array, :required => false, :desc => N_("List of system ids to perform an action on")
+        param :search, String, :required => false, :desc => N_("Search string for host to perform an action on")
+        param :ids, Array, :required => false, :desc => N_("List of host ids to perform an action on")
       end
       param :excluded, Hash, :required => false, :action_aware => true do
-        param :ids, Array, :required => false, :desc => N_("List of system ids to exclude and not run an action on")
+        param :ids, Array, :required => false, :desc => N_("List of host ids to exclude and not run an action on")
       end
-      param :update_all_systems, :bool, :required => false, :desc => N_("Update all editable and applicable systems, not just ones using the selected Content View Versions and Environments")
     end
     def incremental_update
-      if params[:add_content] && params[:add_content].key?(:errata_ids) && params[:update_systems]
-        systems = calculate_systems_for_incremental(params[:update_systems], params[:propagate_to_composites])
+      if params[:add_content] && params[:add_content].key?(:errata_ids) && params[:update_hosts]
+        hosts = calculate_hosts_for_incremental(params[:update_hosts], params[:propagate_to_composites])
       else
-        systems = []
+        hosts = []
       end
 
       validate_content(params[:add_content])
       task = async_task(::Actions::Katello::ContentView::IncrementalUpdates, @version_environments, @composite_version_environments, params[:add_content],
-                        params[:resolve_dependencies], systems, params[:description])
+                        params[:resolve_dependencies], hosts, params[:description])
       respond_for_async :resource => task
     end
 
     private
 
-    def calculate_systems_for_incremental(bulk_params, use_composites)
-      if bulk_params[:update_all_systems]
-        version_environments  = find_version_environments_for_systems(use_composites)
-        restrict_systems = lambda do |relation|
-          errata = Erratum.where(:uuid => params[:add_content][:errata_ids])
-          relation.in_content_view_version_environments(version_environments).with_applicable_errata(errata)
+    def calculate_hosts_for_incremental(bulk_params, use_composites)
+      if bulk_params[:included].try(:[], :search)
+        version_environments  = find_version_environments_for_hosts(use_composites)
+        restrict_hosts = lambda do |relation|
+          errata = Erratum.with_identifiers(params[:add_content][:errata_ids])
+          content_facets = Host::ContentFacet.in_content_view_version_environments(version_environments).with_applicable_errata(errata)
+          relation.where(:id => content_facets.pluck(:host_id))
         end
       else
-        restrict_systems = nil
+        restrict_hosts = nil
       end
 
-      find_bulk_systems(:editable, params[:update_systems], restrict_systems)
+      find_bulk_hosts(:editable, params[:update_hosts], restrict_hosts)
     end
 
     def find_content_view_version
@@ -178,14 +178,14 @@ module Katello
           @composite_version_environments << version_environment
         else
           @version_environments << version_environment
-          @composite_version_environments += lookup_all_composites(version) if params[:propagate_all_composites]
+          @composite_version_environments += lookup_all_composites(version_environment[:content_view_version]) if params[:propagate_all_composites]
         end
       end
       @composite_version_environments.uniq! { |cve| cve[:content_view_version] }
     end
 
     def lookup_all_composites(component)
-      component.composites.select { |c| c.environment.any? }.map do |composite|
+      component.composites.select { |c| c.environments.any? }.map do |composite|
         {
           :content_view_version => composite,
           :environments =>  composite.environments
@@ -193,7 +193,7 @@ module Katello
       end
     end
 
-    def find_version_environments_for_systems(include_composites)
+    def find_version_environments_for_hosts(include_composites)
       if include_composites
         version_environments_for_systems_map = {}
         @version_environments.each do |version_environment|
@@ -220,9 +220,12 @@ module Katello
 
     def validate_content(content)
       if content[:errata_ids]
-        errata = Erratum.where(:uuid => content[:errata_ids])
-        not_found = content[:errata_ids] - errata.pluck(:uuid)
-        fail _("Could not find errata with id: %s") % not_found.join(", ") unless not_found.empty?
+        errata = Erratum.with_identifiers(content[:errata_ids])
+        not_found_count = content[:errata_ids].length - errata.length
+        if not_found_count > 0
+          fail _("Could not find %{count} errata.  Only found: %{found}") %
+                   { :count => not_found_count, :found => errata.pluck(:errata_id).join(',') }
+        end
       end
 
       if content[:package_ids]

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

@@ -191,7 +191,10 @@ module Katello
     def view_params
       attrs = [:name, :description, {:repository_ids => []}, {:component_ids => []}]
       attrs.push(:label, :composite) if action_name == "create"
-      params.require(:content_view).permit(*attrs)
+      permitted_params = params.require(:content_view).permit(*attrs)
+      permitted_params[:repository_ids] ||= [] if params[:content_view].key?(:repository_ids)
+      permitted_params[:component_ids] ||= [] if params[:content_view].key?(:component_ids)
+      permitted_params
     end
 
     def find_environment

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

@@ -1,7 +1,8 @@
 module Katello
   class Api::V2::HostSubscriptionsController < Katello::Api::V2::ApiController
-    before_filter :find_host
+    before_filter :find_host, :except => :create
     before_filter :check_subscriptions, :only => [:add_subscriptions, :remove_subscriptions]
+    before_filter :find_content_view_environment, :only => :create
 
     resource_description do
       api_version 'v2'
@@ -35,6 +36,56 @@ module Katello
       respond_for_index :collection => collection
     end
 
+    api :DELETE, "/hosts/:host_id/subscriptions/", N_("Unregister the host as a subscription consumer")
+    param :host_id, Integer, :desc => N_("Id of the host"), :required => true
+    def destroy
+      sync_task(::Actions::Katello::Host::Unregister, @host)
+      @host.reload
+      respond_for_destroy(:resource => @host)
+    end
+
+    api :POST, "/hosts/subscriptions/", N_("Register a host with subscription and information.")
+    param :name, String, :desc => N_("Name of the host"), :required => true
+    param :uuid, String, :desc => N_("UUID to use for registered host, random uuid is generated if not provided")
+    param :facts, Hash, :desc => N_("Key-value hash of subscription-manager facts, nesting uses a period delimiter (.)")
+    param :hypervisor_guest_uuids, Array, :desc => N_("UUIDs of the virtual guests from the host's hypervisor")
+    param :installed_products, Array, :desc => N_("List of products installed on the host") do
+      param :product_id, String, :desc => N_("Product id as listed from a host's installed products, \
+        this is not the same product id as the products api returns")
+      param :product_name, String, :desc => N_("Product name as listed from a host's installed products")
+    end
+    param :release_version, String, :desc => N_("Release version of the content host")
+    param :service_level, String, :desc => N_("A service level for auto-healing process, e.g. SELF-SUPPORT")
+    param :lifecycle_environment_id, Integer, :desc => N_("Lifecycle Environment ID"), :required => true
+    param :content_view_id, Integer, :desc => N_("Content View ID"), :required => true
+    def create
+      rhsm_params = params_to_rhsm_params
+      name = rhsm_params[:facts]['network.hostname']
+
+      host = Katello::Host::SubscriptionFacet.find_or_create_host(name, @content_view_environment.environment.organization, rhsm_params)
+      sync_task(::Actions::Katello::Host::Register, host, System.new, rhsm_params, @content_view_environment)
+      host.reload
+
+      respond_for_show(:resource => host, :template => '../../../api/v2/hosts/show')
+    end
+
+    def params_to_rhsm_params
+      rhsm_params = params.slice(:facts, :uuid, :name)
+      rhsm_params[:releaseVer] = params['release_version'] if params['release_version']
+      rhsm_params[:serviceLevel] = params['service_level'] if params['service_level']
+      rhsm_params[:guestIds] = params['hypervisor_guest_uuids'] if params[:hypervisor_guest_uuids]
+      rhsm_params[:type] = Katello::Candlepin::Consumer::SYSTEM
+      rhsm_params[:facts] ||= {}
+      rhsm_params[:facts]['network.hostname'] ||= rhsm_params[:name]
+
+      if params['installed_products']
+        rhsm_params[:installedProducts] = params['installed_products'].map do |product|
+          { :productId => product['product_id'], :productName => product['product_name'] }
+        end
+      end
+      rhsm_params
+    end
+
     api :PUT, "/hosts/:host_id/subscriptions/remove_subscriptions"
     param :host_id, Integer, :desc => N_("Id of the host"), :required => true
     param :subscriptions, Array, :desc => N_("Array of subscriptions to remove") do
@@ -68,8 +119,54 @@ module Katello
       respond_for_index(:collection => index_response, :template => "index")
     end
 
+    api :PUT, "/hosts/:host_id/subscriptions/content_override", N_("Set content overrides for the host")
+    param :host_id, String, :desc => N_("Id of the content host"), :required => true
+    param :content_label, String, :desc => N_("Label of the content"), :required => true
+    param :value, [0, 1, "default"], :desc => N_("Override to 0/1, or 'default'"), :required => true
+    def content_override
+      content_override = validate_content_overrides(params)
+      @host.subscription_facet.candlepin_consumer.set_content_override(content_override[:content_label], 'enabled', content_override[:value])
+
+      product_content
+    end
+
+    api :GET, "/hosts/:host_id/subscriptions/product_content", N_("Get content and overrides for the host")
+    param :host_id, String, :desc => N_("Id of the host"), :required => true
+    def product_content
+      content = @host.subscription_facet.candlepin_consumer.available_product_content
+      overrides = @host.subscription_facet.candlepin_consumer.content_overrides
+      results = content.map { |product_content| Katello::ProductContentPresenter.new(product_content, overrides) }
+
+      respond_for_index(:collection => full_result_response(results))
+    end
+
     private
 
+    def validate_content_overrides(content_params)
+      case content_params[:value].to_s
+      when 'default'
+        content_params[:value] = nil
+      when '1'
+        content_params[:value] = 1
+      when '0'
+        content_params[:value] = 0
+      else
+        fail HttpErrors::BadRequest, _("Value must be 0/1, or 'default'")
+      end
+
+      available_content = @host.subscription_facet.candlepin_consumer.available_product_content
+      unless available_content.map(&:content).any? { |content| content.label == content_params[:content_label] }
+        fail HttpErrors::BadRequest, _("Invalid content label: %s") % content_params[:content_label]
+      end
+      content_params
+    end
+
+    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?
+    end
+
     def check_subscriptions
       fail HttpErrors::BadRequest, _("subscriptions not specified") if params[:subscriptions].nil? || params[:subscriptions].empty?
     end
@@ -79,9 +176,9 @@ module Katello
     end
 
     def action_permission
-      if ['add_subscriptions', 'remove_subscriptions', 'auto_attach'].include?(params[:action])
+      if ['add_subscriptions', 'remove_subscriptions', 'auto_attach', 'content_override'].include?(params[:action])
         :edit
-      elsif ['index', 'events'].include?(params[:action])
+      elsif ['index', 'events', 'product_content'].include?(params[:action])
         :view
       end
     end

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

@@ -144,7 +144,7 @@ module Katello
       render :json => repo_types.values
     end
 
-    api :GET, "/repositories/:id", N_("Show a custom repository")
+    api :GET, "/repositories/:id", N_("Show a repository")
     param :id, :identifier, :required => true, :desc => N_("repository ID")
     def show
       respond_for_show(:resource => @repository)
@@ -194,7 +194,7 @@ module Katello
       respond_for_async :resource => task
     end
 
-    api :PUT, "/repositories/:id", N_("Update a custom repository")
+    api :PUT, "/repositories/:id", N_("Update a repository")
     param :name, String, :desc => N_("New name for the repository")
     param :id, :identifier, :required => true, :desc => N_("repository ID")
     param :gpg_key_id, :number, :desc => N_("ID of a gpg key that will be assigned to this repository")

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

@@ -15,7 +15,7 @@ module Katello
     param :name, String, :required => false, :desc => N_("Repository set name to search on")
     def index
       collection = {}
-      collection[:results] = @product.productContent
+      collection[:results] = @product.displayable_product_contents
       # filter on name if it is provided
       collection[:results] = collection[:results].select { |pc| pc.content.name == params[:name] } if params[:name]
       collection[:subtotal] = collection[:results].size

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

@@ -81,7 +81,6 @@ module Katello
     end
 
     api :POST, "/organizations/:organization_id/subscriptions/upload", N_("Upload a subscription manifest")
-    api :POST, "/subscriptions/upload", N_("Upload a subscription manifest")
     param :organization_id, :number, :desc => N_("Organization id"), :required => true
     param :content, File, :desc => N_("Subscription manifest file"), :required => true
     param :repository_url, String, :desc => N_("repository url"), :required => false

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

@@ -7,7 +7,7 @@ module Katello
 
     skip_before_filter :set_default_response_format, :only => :report
 
-    before_filter :find_system, :only => [:destroy, :show, :update, :enabled_repos, :releases, :tasks,
+    before_filter :find_system, :only => [:show, :update, :enabled_repos, :releases, :tasks,
                                           :content_override, :product_content]
     before_filter :find_environment, :only => [:index, :report]
     before_filter :find_optional_organization, :only => [:create, :index, :report]
@@ -61,37 +61,6 @@ module Katello
       collection
     end
 
-    api :POST, "/systems", N_("Register a content host"), :deprecated => true
-    api :POST, "/environments/:environment_id/systems", N_("Register a content host in environment"), :deprecated => true
-    api :POST, "/host_collections/:host_collection_id/systems", N_("Register a content host in environment"), :deprecated => true
-    param :name, String, :desc => N_("Name of the content host"), :required => true, :action_aware => true
-    param :description, String, :desc => N_("Description of the content host")
-    param :location, String, :desc => N_("Physical location of the content host")
-    param :facts, Hash, :desc => N_("Key-value hash of content host-specific facts"), :action_aware => true, :required => true do
-      param :fact, String, :desc => N_("Any number of facts about this content host")
-    end
-    param :type, String, :desc => N_("Type of the content host, it should always be 'system'"), :required => true, :action_aware => true
-    param :guest_ids, Array, :desc => N_("IDs of the virtual guests running on this content host")
-    param :installed_products, Array, :desc => N_("List of products installed on the content host"), :action_aware => true
-    param :release_ver, String, :desc => N_("Release version of the content host")
-    param :service_level, String, :allow_nil => true, :desc => N_("A service level for auto-healing process, e.g. SELF-SUPPORT"), :action_aware => true
-    param :last_checkin, String, :desc => N_("Last check-in time of this content host")
-    param :organization_id, :number, :desc => N_("Specify the organization"), :required => true
-    param :environment_id, String, :desc => N_("Specify the environment")
-    param :content_view_id, String, :desc => N_("Specify the content view")
-    param :host_collection_ids, Array, :desc => N_("Specify the host collections as an array")
-    def create
-      rhsm_params = system_params(params)
-      rhsm_params[:facts] ||= {}
-      rhsm_params[:facts]['network.hostname'] ||= rhsm_params[:name]
-      content_view_environment = ContentViewEnvironment.where(:content_view_id => @content_view, :environment_id => @environment).first
-      host = Katello::Host::SubscriptionFacet.new_host_from_facts(rhsm_params[:facts], @organization, Location.default_location)
-
-      sync_task(::Actions::Katello::Host::Register, host, System.new, rhsm_params, content_view_environment)
-      @system = host.reload.content_host
-      respond_for_create
-    end
-
     api :PUT, "/systems/:id", N_("Update content host information"), :deprecated => true
     param :id, String, :desc => N_("UUID of the content host"), :required => true
     param :release_ver, String, :desc => N_("Release version of the content host")
@@ -111,13 +80,6 @@ module Katello
       respond
     end
 
-    api :DELETE, "/systems/:id", N_("Unregister a content host"), :deprecated => true
-    param :id, String, :desc => N_("UUID of the content host"), :required => true
-    def destroy
-      sync_task(::Actions::Katello::System::Destroy, @system, :unregistering => true)
-      respond :message => _("Deleted content host '%s'") % params[:id], :status => 204
-    end
-
     api :GET, "/systems/:id/releases", N_("Show releases available for the content host"), :deprecated => true
     param :id, String, :desc => N_("UUID of the content host"), :required => true
     desc <<-DESC
@@ -130,37 +92,6 @@ module Katello
       respond_for_index :collection => response
     end
 
-    api :PUT, "/systems/:id/content_override", N_("Set content overrides for the content host")
-    param :id, String, :desc => N_("UUID of the content host"), :required => true
-    param :content_override, Hash, :desc => N_("Content override parameters") do
-      param :content_label, String, :desc => N_("Label of the content"), :required => true
-      param :value, [0, 1, "default"], :desc => N_("Override to 0/1, or 'default'"), :required => true
-    end
-    def content_override
-      content_override = validate_content_overrides(params[:content_override])
-      @system.set_content_override(content_override[:content_label], 'enabled', content_override[:value])
-
-      content = @system.available_content
-      response = {
-        :results => content,
-        :total => content.size,
-        :subtotal => content.size
-      }
-      respond_for_index :collection => response
-    end
-
-    api :GET, "/systems/:id/product_content", N_("Get content overrides for the content host")
-    param :id, String, :desc => N_("UUID of the content host"), :required => true
-    def product_content
-      content = @system.available_content
-      response = {
-        :results => content,
-        :total => content.size,
-        :subtotal => content.size
-      }
-      respond_for_index :collection => response
-    end
-
     private
 
     def system_params_to_host_params(sys_params)
@@ -179,24 +110,6 @@ module Katello
       host_params
     end
 
-    def validate_content_overrides(content_params)
-      case content_params[:value].to_s
-      when 'default'
-        content_params[:value] = nil
-      when '1'
-        content_params[:value] = 1
-      when '0'
-        content_params[:value] = 0
-      else
-        fail HttpErrors::BadRequest, _("Value must be 0/1, or 'default'")
-      end
-
-      unless @system.available_content.map(&:content).any? { |content| content.label == content_params[:content_label] }
-        fail HttpErrors::BadRequest, _("Invalid content label: %s") % content_params[:content_label]
-      end
-      content_params
-    end
-
     def find_system
       @system = System.where(:uuid => params[:id]).first
       if @system.nil?