katello 3.7.1.1 → 3.8.0.rc1

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

@@ -278,7 +278,7 @@ module Katello
     def get_parent_host(headers)
       hostnames = headers["HTTP_X_FORWARDED_SERVER"]
       host = hostnames.split(",")[0] if hostnames
-      host || Facter.value(:fqdn) || SETTINGS[:fqdn]
+      host || SETTINGS[:fqdn]
     end
 
     private

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

@@ -44,7 +44,7 @@ module Katello
       end
       sync_task(::Actions::Katello::ActivationKey::Create, @activation_key)
       @activation_key.reload
-      respond(:resource => @activation_key)
+      respond_for_create(:resource => @activation_key)
     end
 
     api :PUT, "/activation_keys/:id", N_("Update an activation key")
@@ -98,7 +98,7 @@ module Katello
         @new_activation_key.subscribe(pool[:id])
       end
       @new_activation_key.set_content_overrides(@activation_key.content_overrides) unless @activation_key.content_overrides.blank?
-      respond_for_show(:resource => @new_activation_key)
+      respond_for_create(:resource => @new_activation_key)
     end
 
     api :GET, "/activation_keys/:id/host_collections/available", N_("List host collections the activation key does not belong to")

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

@@ -20,7 +20,7 @@ module Katello
       param :search, String, :desc => N_("Search string")
       param :page, :number, :desc => N_("Page number, starting at 1")
       param :per_page, :number, :desc => N_("Number of results per page to return")
-      param :order, String, :desc => N_("Sort field and order, eg. 'name DESC'")
+      param :order, String, :desc => N_("Sort field and order, eg. 'id DESC'")
       param :full_result, :bool, :desc => N_("Whether or not to show all results")
       param :sort, Hash, :desc => N_("Hash version of 'order' param") do
         param :by, String, :desc => N_("Field to sort the results on")
@@ -77,6 +77,8 @@ module Katello
         query = resource.search_for(*search_options).where("#{resource.table_name}.id" => query)
       end
 
+      query = self.final_custom_index_relation(query) if self.respond_to?(:final_custom_index_relation)
+
       query = query.select(group).group(group) if group
       sub_total = total.zero? ? 0 : scoped_search_total(query, group)
 

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

@@ -56,7 +56,7 @@ module Katello
       end
 
       content_credential = @organization.gpg_keys.create!(content_credential_params.merge(:content => content))
-      respond_for_show(:resource => content_credential)
+      respond_for_create(:resource => content_credential)
     end
 
     api :GET, "/content_credentials/:id", N_("Show a content credential")

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

@@ -49,7 +49,7 @@ module Katello
       if rules.many?
         respond_for_index(:collection => {:results => rules}, :template => 'index')
       else
-        respond resource: rules.first
+        respond_for_create resource: rules.first
       end
     end
 

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

@@ -3,7 +3,7 @@ module Katello
     include Concerns::Api::V2::BulkHostsExtensions
     include Katello::Concerns::FilteredAutoCompleteSearch
 
-    before_action :find_content_view_version, :only => [:show, :promote, :destroy, :export, :republish_repositories]
+    before_action :find_content_view_version, :only => [:show, :update, :promote, :destroy, :export, :republish_repositories]
     before_action :find_content_view, :except => [:incremental_update]
     before_action :find_environment, :only => [:index]
     before_action :find_environments, :only => [:promote]
@@ -65,6 +65,20 @@ module Katello
       respond_for_async :resource => task
     end
 
+    api :PUT, "/content_view_versions/:id", N_("Update a content view version.")
+    param :id, :number, :desc => N_("Content view version identifier"), :required => true
+    param :description, String, :desc => N_("The description for the content view version"), :required => true
+    def update
+      history = @version.history.publish.successful.first
+      if history.blank?
+        fail HttpErrors::BadRequest, _("This content view version doesn't have a history.")
+      else
+        history.notes = params[:description]
+        history.save!
+        respond_for_show(:resource => @version)
+      end
+    end
+
     api :PUT, "/content_view_versions/:id/republish_repositories", N_("Forces a republish of the version's repositories' metadata.")
     param :id, :number, :desc => N_("Content view version identifier"), :required => true
     def republish_repositories

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

@@ -76,6 +76,7 @@ module Katello
     param :label, String, :desc => N_("label of the environment"), :required => false
     param :description, String, :desc => N_("description of the environment")
     param :registry_name_pattern, String, :desc => N_("pattern for container image names")
+    param :registry_unauthenticated_pull, :bool, :desc => N_("allow unauthenticed pull of container images")
     param :prior_id, Integer, :required => true, :desc => <<-DESC
       ID of an environment that is prior to the new environment in the chain. It has to be
       either the ID of Library or the ID of an environment at the end of a chain.
@@ -95,6 +96,7 @@ module Katello
     param :new_name, String, :desc => N_("new name to be given to the environment")
     param :description, String, :desc => N_("description of the environment")
     param :registry_name_pattern, String, :desc => N_("pattern for container image names")
+    param :registry_unauthenticated_pull, :bool, :desc => N_("allow unauthenticed pull of container images")
     param :async, :bool, desc: N_("Do not wait for the update action to finish. Default: true")
     def update
       async = ::Foreman::Cast.to_bool(params.fetch(:async, true))
@@ -102,6 +104,7 @@ module Katello
       fail HttpErrors::BadRequest, _("Can't update the '%s' environment") % "Library" if @environment.library? && update_params.empty?
       update_params[:name] = params[:environment][:new_name] if params[:environment][:new_name]
       @environment.update_attributes!(update_params)
+      @environment.update_container_repositories(update_params[:registry_unauthenticated_pull]) if update_params.key? :registry_unauthenticated_pull
       if update_params[:registry_name_pattern]
         task = send(async ? :async_task : :sync_task, ::Actions::Katello::Environment::PublishRepositories,
                     @environment, content_type: Katello::Repository::DOCKER_TYPE)
@@ -175,9 +178,9 @@ module Katello
 
     def environment_params
       if @environment && @environment.library?
-        attrs = [:registry_name_pattern]
+        attrs = [:registry_name_pattern, :registry_unauthenticated_pull]
       else
-        attrs = [:name, :description, :registry_name_pattern]
+        attrs = [:name, :description, :registry_name_pattern, :registry_unauthenticated_pull]
       end
       attrs << :label if params[:action] == "create"
       parms = params.require(:environment).permit(*attrs)

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

@@ -3,21 +3,31 @@ module Katello
     apipie_concern_subst(:a_resource => N_("an erratum"), :resource => "errata")
     include Katello::Concerns::Api::V2::RepositoryContentController
 
+    before_action :find_host, :only => [:index, :available_errata]
+    before_action :find_optional_organization, :only => :available_errata
+    before_action :find_environment, :only => :available_errata
+    before_action :find_filter, :only => :available_errata
+
     api :GET, "/errata", N_("List errata")
-    param :organization_id, :number, :desc => N_("organization identifier")
-    param :content_view_version_id, :number, :desc => N_("content view version identifier")
-    param :content_view_filter_id, :number, :desc => N_("content view filter identifier")
-    param :repository_id, :number, :desc => N_("repository identifier")
-    param :environment_id, :number, :desc => N_("environment identifier")
+    param :organization_id, :number, :desc => N_("Organization identifier")
+    param :content_view_version_id, :number, :desc => N_("Content View Version identifier")
+    param :content_view_filter_id, :number, :desc => N_("Content View Filter identifier")
+    param :repository_id, :number, :desc => N_("Repository identifier")
+    param :environment_id, :number, :desc => N_("Environment identifier")
     param :cve, String, :desc => N_("CVE identifier")
-    param :errata_restrict_applicable, :bool, :desc => N_("show only errata with one or more applicable hosts")
-    param :errata_restrict_installable, :bool, :desc => N_("show only errata with one or more installable hosts")
+    param :host_id, :number, :desc => N_("Host id to list applicable errata for")
+    param :errata_restrict_applicable, :bool, :desc => N_("Return errata that are applicable to one or more hosts (defaults to true if host_id is specified)")
+    param :errata_restrict_installable, :bool, :desc => N_("Return errata that are upgradable on one or more hosts")
+    param :available_for, String, :desc => N_("Return errata that can be added to the specified object.  The values 'content_view_version' and 'content_view_filter are supported.")
     param_group :search, Api::V2::ApiController
     def index
-      params[:errata_restrict_applicable] = false if ::Foreman::Cast.to_bool(params[:errata_restrict_installable])
       super
     end
 
+    def available_for_content_view_version(version)
+      version.available_errata
+    end
+
     def available_for_content_view_filter(filter, collection)
       collection = filter_by_content_view(filter, collection)
       ids = Katello::ContentViewErratumFilterRule.where(:content_view_filter_id => filter.id).pluck("errata_id")
@@ -37,44 +47,48 @@ module Katello
 
     def custom_index_relation(collection)
       collection = filter_by_cve(params[:cve], collection) if params[:cve]
-      hosts = ::Host::Managed.authorized("view_hosts")
-      hosts = hosts.where(:organization_id => params[:organization_id]) if params[:organization_id]
-      if ::Foreman::Cast.to_bool(params[:errata_restrict_applicable])
-        collection = collection.where(:id => Erratum.applicable_to_hosts(hosts))
-      end
-
-      if ::Foreman::Cast.to_bool(params[:errata_restrict_installable])
-        collection = collection.where(:id => Erratum.ids_installable_for_hosts(hosts))
+      applicable = ::Foreman::Cast.to_bool(params[:errata_restrict_applicable]) || @host
+      installable = ::Foreman::Cast.to_bool(params[:errata_restrict_installable])
+      if applicable || installable
+        hosts = @host ? [@host] : ::Host::Managed.authorized("view_hosts")
+        hosts = hosts.where(:organization_id => params[:organization_id]) if params[:organization_id]
+        if installable
+          collection = collection.where(:id => Erratum.ids_installable_for_hosts(hosts))
+        elsif applicable
+          collection = collection.applicable_to_hosts(hosts)
+        end
       end
       collection
     end
 
-    api :GET, "/content_view_versions/:id/available_errata", N_("List errata that can be added to the Content View Version via an Incremental Update")
+    api :GET, "/content_view_versions/:id/available_errata", N_("Return errata that can be added to the Content View Version via an Incremental Update"), :deprecated => true
     param :id, :number, :desc => N_("Content View Version identifier"), :required => true
-    param :repository_id, :number, :desc => N_("repository identifier")
+    param :organization_id, :number, :desc => N_("Organization identifier")
+    param :content_view_filter_id, :number, :desc => N_("Content View Filter identifier")
+    param :repository_id, :number, :desc => N_("Repository identifier")
+    param :environment_id, :number, :desc => N_("Environment identifier")
     param :cve, String, :desc => N_("CVE identifier")
-    param :errata_restrict_applicable, :bool, :desc => N_("show only errata with one or more applicable hosts")
-    param_group :search, ::Katello::Api::V2::ApiController
+    param :host_id, :number, :desc => N_("Host id to list applicable errata for")
+    param :errata_restrict_applicable, :bool, :desc => N_("Return errata that are applicable to one or more hosts (defaults to true if host_id is specified)")
+    param :errata_restrict_installable, :bool, :desc => N_("Return errata that are upgradable on one or more hosts")
+    param_group :search, Api::V2::ApiController
     def available_errata
-      version = ContentViewVersion.find(params[:id])
-      collection = version.available_errata
-      if @repo
-        collection = collection.joins(:repository_errata => :repository).where(:katello_repositories => { :id => @repo })
-      end
-      if params[:cve]
-        collection = collection.joins(:cves).where(:katello_erratum_cves => { :cve_id => params[:cve] })
-      end
-      if ::Foreman::Cast.to_bool(params[:errata_restrict_applicable])
-        hosts = ::Host::Managed.authorized("view_hosts")
-        collection = collection.applicable_to_hosts(hosts)
-      end
+      params[:content_view_version_id] = params[:id]
+      find_content_view_version
+      params[:available_for] = "content_view_version"
       sort_by, sort_order, options = sort_options
-      collection = scoped_search(collection, sort_by, sort_order, options)
-      respond_for_index(:collection => collection)
+      respond_for_index(:collection => scoped_search(index_relation, sort_by, sort_order, options))
     end
 
     private
 
+    def find_host
+      if params[:host_id]
+        @host = ::Host::Managed.authorized("view_hosts").find_by(:id => params[:host_id])
+        fail HttpErrors::NotFound, _('Could not find a host with id %s') % params[:host_id] unless @host
+      end
+    end
+
     def filter_by_cve(cve, collection)
       collection.joins(:cves).where('katello_erratum_cves.cve_id' => cve)
     end

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

@@ -48,7 +48,7 @@ module Katello
       end
 
       gpg_key = @organization.gpg_keys.create!(gpg_key_params.merge(:content => content))
-      respond_for_show(:resource => gpg_key)
+      respond_for_create(:resource => gpg_key)
     end
 
     api :GET, "/gpg_keys/:id", N_("Show a gpg key")

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

@@ -68,7 +68,7 @@ module Katello
       @host_collection = HostCollection.new(host_collection_params_with_host_ids)
       @host_collection.organization = @organization
       @host_collection.save!
-      respond_for_show(:resource => @host_collection)
+      respond_for_create(:resource => @host_collection)
     end
 
     api :PUT, "/host_collections/:id", N_("Update a host collection")

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

@@ -102,9 +102,13 @@ module Katello
       @host = resource_finder(::Host::Managed.authorized(:view_hosts, ::Host::Managed), params[:host_id])
     end
 
+    def valid_package_name?(package_name)
+      package_name =~ /^[a-zA-Z0-9\-\.\_\+\,]+$/
+    end
+
     def validate_package_list_format(packages)
       packages.each do |package|
-        unless package.is_a?(String) && ::Katello::Util::Package.valid_package_name_format(package).nil?
+        if !valid_package_name?(package) && !package.is_a?(Hash)
           fail HttpErrors::BadRequest, _("%s is not a valid package name") % package
         end
       end

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

@@ -78,7 +78,7 @@ module Katello
       @organization = Organization.new(resource_params)
       sync_task(::Actions::Katello::Organization::Create, @organization)
       @organization.reload
-      respond_for_show :resource => @organization
+      respond_for_create :resource => @organization
     rescue => e
       process_resource_error(message: e.message)
     end

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

@@ -26,42 +26,53 @@ module Katello
     api :GET, "/content_views/:content_view_id/filters/:filter_id/:resource_id", N_("List :resource_id")
     api :GET, "/content_view_filters/:content_view_filter_id/:resource_id", N_("List :resource_id")
     api :GET, "/repositories/:repository_id/:resource_id", N_("List :resource_id")
-    param :organization_id, :number, :desc => N_("organization identifier")
-    param :content_view_version_id, :number, :desc => N_("content view version identifier")
-    param :content_view_filter_id, :number, :desc => N_("content view filter identifier")
-    param :repository_id, :number, :desc => N_("repository identifier")
-    param :environment_id, :number, :desc => N_("environment identifier")
-    param :ids, Array, :desc => N_("ids to filter content by")
-    param :host_id, :number, :desc => N_("host id to list applicable packages for")
-    param :packages_restrict_upgradable, :boolean, :desc => N_("Only show packages that are upgradable in the host(s) Content View.")
-    param :packages_restrict_applicable, :boolean, :desc => N_("Only show packages that are applicable to hosts (defaults to true if host_id is specified)")
+    param :organization_id, :number, :desc => N_("Organization identifier")
+    param :content_view_version_id, :number, :desc => N_("Content View Version identifier")
+    param :content_view_filter_id, :number, :desc => N_("Content View Filter identifier")
+    param :repository_id, :number, :desc => N_("Repository identifier")
+    param :environment_id, :number, :desc => N_("Environment identifier")
+    param :ids, Array, :desc => N_("Package identifiers to filter content by")
+    param :host_id, :number, :desc => N_("Host id to list applicable packages for")
+    param :packages_restrict_applicable, :boolean, :desc => N_("Return packages that are applicable to one or more hosts (defaults to true if host_id is specified)")
+    param :packages_restrict_upgradable, :boolean, :desc => N_("Return packages that are upgradable on one or more hosts")
+    param :packages_restrict_latest, :boolean, :desc => N_("Return only the latest version of each package")
+    param :available_for, String, :desc => N_("Return packages that can be added to the specified object.  Only the value 'content_view_version' is supported.")
     param_group :search, ::Katello::Api::V2::ApiController
     def index
       super
     end
 
+    def available_for_content_view_version(version)
+      version.available_packages
+    end
+
     def custom_index_relation(collection)
-      if ::Foreman::Cast.to_bool(params[:packages_restrict_upgradable])
-        if @host
-          collection = collection.installable_for_hosts([@host])
-        else
-          hosts = ::Host::Managed.authorized("view_hosts")
-          hosts = hosts.where(:organization_id => params[:organization_id]) if params[:organization_id]
+      applicable = ::Foreman::Cast.to_bool(params[:packages_restrict_applicable]) || @host
+      upgradable = ::Foreman::Cast.to_bool(params[:packages_restrict_upgradable])
+      if applicable || upgradable
+        hosts = @host ? [@host] : ::Host::Managed.authorized("view_hosts")
+        hosts = hosts.where(:organization_id => params[:organization_id]) if params[:organization_id]
+        if upgradable
           collection = collection.installable_for_hosts(hosts)
-        end
-      elsif ::Foreman::Cast.to_bool(params[:packages_restrict_applicable]) || @host
-        if @host
-          collection = collection.applicable_to_hosts([@host])
-        else
-          hosts = ::Host::Managed.authorized("view_hosts")
-          hosts = hosts.where(:organization_id => params[:organization_id]) if params[:organization_id]
+        elsif applicable
           collection = collection.applicable_to_hosts(hosts)
         end
       end
+      collection
+    end
 
+    def final_custom_index_relation(collection)
+      # :packages_restrict_latest is intended to filter the result set after all
+      # other constraints have been applied, including the scoped_search
+      # constraints.  If any constraints are applied after this, then a package
+      # will not be returned if its latest version does not match those
+      # constraints, even if an older version does match those constraints.
+      collection = Katello::Rpm.latest(collection) if ::Foreman::Cast.to_bool(params[:packages_restrict_latest])
       collection
     end
 
+    private
+
     def find_host
       if params[:host_id]
         @host = ::Host::Managed.authorized("view_hosts").find_by(:id => params[:host_id])

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

@@ -80,7 +80,7 @@ module Katello
       product = Product.new(product_params.to_h)
 
       sync_task(::Actions::Katello::Product::Create, product, @organization)
-      respond(:resource => product)
+      respond_for_create(:resource => product)
     end
 
     api :GET, "/products/:id", N_("Show a product")

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

@@ -73,6 +73,7 @@ module Katello
     param :library, :bool, :desc => N_("show repositories in Library and the default content view")
     param :content_type, RepositoryTypeManager.repository_types.keys, :desc => N_("limit to only repositories of this type")
     param :name, String, :desc => N_("name of the repository"), :required => false
+    param :description, String, :desc => N_("description of the repository")
     param :available_for, String, :desc => N_("interpret specified object to return only Repositories that can be associated with specified object.  Only 'content_view' is supported."),
           :required => false
     param_group :search, Api::V2::ApiController
@@ -85,11 +86,11 @@ module Katello
           options[:csv] = true
           repos = scoped_search(*base_args, options)
           csv_response(repos,
-                       [:id, :name, :label, :content_type, :arch, :url, :major, :minor,
+                       [:id, :name, :description, :label, :content_type, :arch, :url, :major, :minor,
                         :cp_label, :content_label, :pulp_id, :container_repository_name,
                         :download_policy, 'relative_path', 'product.id', 'product.name',
                         'environment_id'],
-                       ['Id', 'Name', 'label', 'Content Type', 'Arch', 'Url', 'Major', 'Minor',
+                       ['Id', 'Name', 'label', 'Description', 'Content Type', 'Arch', 'Url', 'Major', 'Minor',
                         'Candlepin Label', 'Content Label', 'Pulp Id', 'Container Repository Name',
                         'Download Policy', 'Relative Path', 'Product Id', 'Product Name',
                         'Environment Id'])
@@ -198,7 +199,7 @@ module Katello
       repository = construct_repo_from_params(repo_params)
       sync_task(::Actions::Katello::Repository::Create, repository, false, true)
       repository = Repository.find(repository.id)
-      respond_for_show(:resource => repository)
+      respond_for_create(:resource => repository)
     end
 
     api :GET, "/repositories/repository_types", N_("Show the available repository types")
@@ -460,7 +461,7 @@ module Katello
     def repository_params
       keys = [:download_policy, :mirror_on_sync, :arch, :verify_ssl_on_sync, :upstream_password, :upstream_username,
               :ostree_upstream_sync_depth, :ostree_upstream_sync_policy, :ignore_global_proxy,
-              :deb_releases, :deb_components, :deb_architectures, {:ignorable_content => []}
+              :deb_releases, :deb_components, :deb_architectures, :description, {:ignorable_content => []}
              ]
 
       keys += [:label, :content_type] if params[:action] == "create"
@@ -481,7 +482,7 @@ module Katello
     end
 
     def construct_repo_from_params(repo_params)
-      repository = @product.add_repo(Hash[repo_params.slice(:label, :name, :url, :content_type, :arch, :unprotected,
+      repository = @product.add_repo(Hash[repo_params.slice(:label, :name, :description, :url, :content_type, :arch, :unprotected,
                                                             :gpg_key, :ssl_ca_cert, :ssl_client_cert, :ssl_client_key,
                                                             :checksum_type, :download_policy).to_h.map { |k, v| [k.to_sym, v] }])
       repository.docker_upstream_name = repo_params[:docker_upstream_name] if repo_params[:docker_upstream_name]

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

@@ -17,7 +17,6 @@ module Katello
     param :product_id, :number, :required => true, :desc => N_("ID of a product to list repository sets from")
     param :name, String, :required => false, :desc => N_("Repository set name to search on")
     param :enabled, :bool, :required => false, :desc => N_("If true, only return repository sets that have been enabled. Defaults to false")
-    param :with_active_subscription, :bool, :required => false, :desc => N_("If true, only return repository sets that are associated with an active subscriptions")
     param_group :search, Api::V2::ApiController
     def index
       respond(:collection => scoped_search(index_relation, nil, nil, :custom_sort => default_sort,
@@ -93,15 +92,7 @@ module Katello
         relation = @product.displayable_product_contents
       end
 
-      if ::Foreman::Cast.to_bool(params[:enabled])
-        relation = relation.enabled(@organization)
-      elsif ::Foreman::Cast.to_bool(params[:with_active_subscription])
-        relation = relation.with_valid_subscription(@organization)
-      else
-        relation = relation.where(:id => Katello::ProductContent.with_valid_subscription(@organization)).or(
-            relation.where(:id => Katello::ProductContent.enabled(@organization)))
-      end
-
+      relation = relation.enabled(@organization) if ::Foreman::Cast.to_bool(params[:enabled])
       relation = relation.where(Katello::Content.table_name => {:name => params[:name]}) if params[:name].present?
       relation.redhat
     end