katello 3.15.0.rc1.1 → 3.15.0.rc1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3be0c8c8ae873a3c811d7488ca8084b3fe6dd549b03459bb70f7065d48d194c4
-  data.tar.gz: 86161c33ee551a26af3bfea7c18b9e6e84fe69ecb094867c7d0def2636cfd40c
+  metadata.gz: f4e6d74795c4700eaab2d82f34ed4b4b32e5f8d20d230751271cbf404f71b566
+  data.tar.gz: 1e12676685c7f06488ba46b24750793bb95cae690a9e112f52fc7c375971b3a6
 SHA512:
-  metadata.gz: 15fc64e48e634518a8934f1da8fac2f2b8b89a4096022b2eab9df164d2bfee68c0897b540fce2c87ead33ffeb4a1ec42acf13a1baa9f6e8544d02a4827b31531
-  data.tar.gz: d52d8fc881a6512c2f6c292c67be41c15843c5c6916003e857b6448402626aab4481d12e06248241f81b4745882ac0cb600cf6abcd7a7894f89ac51c58f9422e
+  metadata.gz: 601efee72a0e6519e02cd65b6277bf0d229c16bc384c2fbb1e11094d9d4db5319ec661012ca6d2a724eac3952f5c950ef8dd00eb7aabfbb28c5f73e2d3eaec99
+  data.tar.gz: 02522ad2348bf3c740ce7e9b0dc14b911390521a738781e5ccd54d9f93d7f6b047412e9f2656d3db15724ed9f9a2234c710c82dcb08a6f598ebb843f832c1eb7

data/app/assets/javascripts/katello/hosts/activation_key_edit.js

@@ -12,6 +12,7 @@ function ktLoadActivationKeys() {
         return; //no Katello-specific env selected
     }
 
+    $("#ak-load-error").hide();
     $("#ak-subscriptions-info").hide();
     $("#ak-subscriptions-spinner").show();
 
@@ -26,17 +27,14 @@ function ktLoadActivationKeys() {
             $.each(response['results'], function (i, key) {
                 KT.hosts.availableActivationKeys[key.name] = [];
             });
-            ktAkUpdateSubscriptionsInfo();
+            tfm.typeAheadSelect.updateOptions(Object.keys(KT.hosts.availableActivationKeys), KT.KT_AK_LABEL);
+        },
+        error: function() {
+          $("#ak-load-error").show();
         },
-        error: ktErrorLoadingActivationKeys
     });
 }
 
-function ktErrorLoadingActivationKeys(error) {
-    $.jnotify("Error while loading activation keys from Katello", { type: "error", sticky: true });
-    ktAkUpdateSubscriptionsInfo();
-}
-
 function ktFindParamContainer(name){
     var ret;
     $("div#parameters .fields input[ type = 'text']").each(function () {
@@ -82,28 +80,27 @@ function ktSetParam(name, value) {
             paramContainer.find("input[name*='name']").val(name);
         }
         paramContainer.find("textarea").val(value);
+        paramContainer.find("input[ type = 'hidden' ]").val(0);
     } else if(paramContainer) {
         // we remove the param by setting destroy to 1
         paramContainer.find("input[ type = 'hidden' ]").val(1);
     }
 }
 
-function ktParamToAkInput() {
+function ktAkGetKeysFromParam() {
     var paramContainer = ktFindParamContainer(KT.KT_AK_LABEL);
+    var keys = [];
     if(paramContainer) {
-        $("#kt_activation_keys").val(paramContainer.find("textarea").val());
+        keys = paramContainer.find("textarea").val().split(',').map(function(key) {
+          return key.trim();
+        });
     }
+    return keys;
 }
 
-function ktAkInputToParam() {
-    var ktActivationKeysValue = $("#kt_activation_keys").val().replace(/,\s*/g,",").replace(/,$/g,"");
-    ktSetParam(KT.KT_AK_LABEL, ktActivationKeysValue);
-}
-
-function ktAkUpdateSubscriptionsInfo() {
+function ktAkUpdateSubscriptionsInfo(selectedKeys) {
     var subsInfo = $("ul#ak-subscriptions-info");
     subsInfo.empty();
-    var selectedKeys = $("#kt_activation_keys").val().split(/,\s*/);
     $.each(selectedKeys, function(i, key) {
       if(KT.hosts.availableActivationKeys[key]) {
         // hack to make it working with deface
@@ -127,50 +124,31 @@ function ktAkTab() {
 }
 
 function ktOnLoad() {
-    ktHideParams();
-    ktParamToAkInput();
-    ktLoadActivationKeys();
-}
-
-$(document).on('ContentLoad', function(){
+    tfm.store.observeStore('typeAheadSelect', function(items, unsubscribe) {
+        if (items.kt_activation_keys) { // Wait until after initialization to subscribe to store changes
+            unsubscribe();
 
-    $("#kt_activation_keys").parents("form").submit(ktAkInputToParam);
+            tfm.typeAheadSelect.updateSelected(ktAkGetKeysFromParam(), KT.KT_AK_LABEL);
 
-    ktOnLoad();
+            tfm.store.observeStore('typeAheadSelect', function(items) {
+                if (items.kt_activation_keys) {
+                    var selected = items.kt_activation_keys.selected || [];
 
-    $("#kt_activation_keys").autocomplete({
-        minLength: 0,
-        source: function(request, response) {
-            var terms = request.term.split(/,\s*/);
-            var part = terms.pop();
-            var items = [];
-            for(key in KT.hosts.availableActivationKeys) {
-                if(terms.indexOf(key) == -1) {
-                    items.push(key);
+                    ktAkUpdateSubscriptionsInfo(selected);
+                    ktSetParam(KT.KT_AK_LABEL, selected.map(function(key) {
+                      return key.trim();
+                    }).join(','));
                 }
-            }
-            response($.ui.autocomplete.filter(
-                items, part));
-        },
-
-        focus: function() {
-            // prevent value inserted on focus
-            return false;
-        },
-        select: function(event, ui) {
-            var oldTerms = this.value.replace(/[^, ][^,]*$/,"");
-            this.value = oldTerms + ui.item.value;
-            ktAkUpdateSubscriptionsInfo();
-            return false;
-        },
-        close: function() {
-            ktAkUpdateSubscriptionsInfo();
+            });
         }
+    });
 
-    }).bind("focus", function(event) {
-        if($(this)[0].value == "") {
-     $(this).autocomplete( "search" );
-        }});
+    ktHideParams();
+    ktLoadActivationKeys();
+}
+
+$(document).on('ContentLoad', function(){
+    ktOnLoad();
 
     $("#hostgroup_lifecycle_environment_id").change(ktLoadActivationKeys);
     $("#hostgroup_content_view_id").change(ktLoadActivationKeys);

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

@@ -266,7 +266,7 @@ module Katello
     def get_parent_host(headers)
       hostnames = headers["HTTP_X_FORWARDED_SERVER"]
       host = hostnames.split(",")[0] if hostnames
-      host || SETTINGS[:fqdn]
+      host || URI.parse(Setting[:foreman_url]).host
     end
 
     private

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

@@ -95,17 +95,19 @@ module Katello
     end
 
     api :POST, "/hosts/bulk/applicable_errata",
-        N_("Fetch applicable errata for a host.")
+        N_("Fetch applicable errata for one or more hosts.")
     param_group :bulk_params
     def applicable_errata
+      ::Foreman::Deprecation.api_deprecation_warning("The 'applicable_hosts' field will be removed from this API in Katello 2.0")
       respond_for_index(:collection => scoped_search(Katello::Erratum.applicable_to_hosts(@hosts), 'updated', 'desc',
                                                      :resource_class => Erratum))
     end
 
     api :POST, "/hosts/bulk/installable_errata",
-        N_("Fetch installable errata for a host.")
+        N_("Fetch installable errata for one or more hosts.")
     param_group :bulk_params
     def installable_errata
+      ::Foreman::Deprecation.api_deprecation_warning("The 'applicable_hosts' field will be removed from this API in Katello 2.0")
       respond_for_index(:collection => scoped_search(Katello::Erratum.installable_for_hosts(@hosts), 'updated', 'desc',
                                                      :resource_class => Erratum))
     end
@@ -115,7 +117,8 @@ module Katello
     param :content_type, String,
           :desc => N_("The type of content.  The following types are supported: 'package', 'package_group' and 'errata'."),
           :required => true
-    param :content, Array, :desc => N_("List of content (e.g. package names, package group names or errata ids)"), :required => true
+    param :content, Array, :desc => N_("List of content (e.g. package names, package group names or errata ids)")
+    param :install_all, :bool, :desc => N_("Only used for errata, but will install all installable errata.")
     def install_content
       content_action
     end
@@ -305,7 +308,11 @@ module Katello
 
     def content_action
       if params[:content_type] == 'errata'
-        task = async_task(::Actions::BulkAction, ::Actions::Katello::Host::Erratum::ApplicableErrataInstall, @hosts, params[:content].uniq)
+        options = {}
+        options[:update_all] = true if ::Foreman::Cast.to_bool(params[:install_all])
+        options[:errata_ids] = params[:content]
+
+        task = async_task(::Actions::BulkAction, ::Actions::Katello::Host::Erratum::ApplicableErrataInstall, @hosts, options)
         respond_for_async :resource => task
       else
         content = params[:content]

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

@@ -35,9 +35,9 @@ module Katello
     def_param_group :repo do
       param :url, String, :desc => N_("repository source url")
       param :gpg_key_id, :number, :desc => N_("id of the gpg key that will be assigned to the new repository")
-      param :ssl_ca_cert_id, :number, :desc => N_("Idenifier of the SSL CA Cert")
-      param :ssl_client_cert_id, :number, :desc => N_("Identifier of the SSL Client Cert")
-      param :ssl_client_key_id, :number, :desc => N_("Identifier of the SSL Client Key")
+      param :ssl_ca_cert_id, :number, :desc => N_("Identifier of the content credential containing the SSL CA Cert")
+      param :ssl_client_cert_id, :number, :desc => N_("Identifier of the content credential containing the SSL Client Cert")
+      param :ssl_client_key_id, :number, :desc => N_("Identifier of the content credential containing the SSL Client Key")
       param :unprotected, :bool, :desc => N_("true if this repository can be published via HTTP")
       param :checksum_type, String, :desc => N_("Checksum of the repository, currently 'sha1' & 'sha256' are supported")
       param :docker_upstream_name, String, :desc => N_("Name of the upstream docker repository")
@@ -219,6 +219,10 @@ module Katello
         fail HttpErrors::UnprocessableEntity, msg
       end
 
+      if repo_params['content_type'] == "puppet" || repo_params['content_type'] == "ostree"
+        ::Foreman::Deprecation.api_deprecation_warning("Puppet and OSTree will no longer be supported in Katello 3.16")
+      end
+
       gpg_key = get_content_credential(repo_params, CONTENT_CREDENTIAL_GPG_KEY_TYPE)
       ssl_ca_cert = get_content_credential(repo_params, CONTENT_CREDENTIAL_SSL_CA_CERT_TYPE)
       ssl_client_cert = get_content_credential(repo_params, CONTENT_CREDENTIAL_SSL_CLIENT_CERT_TYPE)

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

@@ -65,7 +65,7 @@ module Katello
       return available_for_activation_key if params[:available_for] == "activation_key"
       collection = Pool.readable
       collection = collection.where(:unmapped_guest => false)
-      collection = collection.get_for_organization(Organization.find(params[:organization_id])) if params[:organization_id]
+      collection = collection.where(organization: Organization.find(params[:organization_id])) if params[:organization_id]
       collection = collection.for_activation_key(@activation_key) if params[:activation_key_id]
       collection
     end
@@ -75,10 +75,9 @@ module Katello
     param :organization_id, :number, :desc => N_("Organization identifier")
     param :id, :number, :desc => N_("Subscription identifier"), :required => true
     def show
-      org_id = Organization.current&.id
       @resource = Katello::Pool.with_identifier(params[:id])
       fail ActiveRecord::RecordNotFound, N_('Subscription not found') unless @resource
-      if @resource.organization_id != org_id && !User.current.organizations&.pluck(:id)&.include?(@resource.organization_id)
+      unless @resource.readable?
         fail ActiveRecord::RecordNotFound, N_('This subscription is not relevant to the current user and organization.')
       end
       respond(:resource => @resource)

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

@@ -31,7 +31,7 @@ module Actions
             if hosts.any? && !content[:errata_ids].blank?
               errata = ::Katello::Erratum.with_identifiers(content[:errata_ids])
               hosts = hosts.where(:id => ::Katello::Host::ContentFacet.with_applicable_errata(errata).pluck(:host_id))
-              plan_action(::Actions::BulkAction, ::Actions::Katello::Host::Erratum::ApplicableErrataInstall, hosts, content[:errata_ids])
+              plan_action(::Actions::BulkAction, ::Actions::Katello::Host::Erratum::ApplicableErrataInstall, hosts, :errata_ids => content[:errata_ids])
             end
             plan_self(:version_outputs => output_for_version_ids)
           end

data/app/lib/actions/katello/host/erratum/applicable_errata_install.rb

@@ -6,8 +6,12 @@ module Actions
           include Helpers::Presenter
 
           #takes a list of errata and schedules the installation of those that are applicable
-          def plan(host, errata_ids)
-            applicable_errata = host.content_facet.applicable_errata.with_identifiers(errata_ids)
+          def plan(host, options = {})
+            fail _("errata_ids or update_all must be provided") if !options[:errata_ids] && !options[:update_all]
+            errata_ids = options.fetch(:errata_ids, nil)
+
+            applicable_errata = host.content_facet.applicable_errata
+            applicable_errata = applicable_errata.with_identifiers(errata_ids) if errata_ids
             plan_action(Actions::Katello::Host::Erratum::Install, host, applicable_errata.pluck(:errata_id))
             plan_self(:hostname => host.name)
           end

data/app/lib/actions/pulp3/content_migration.rb

@@ -1,16 +1,16 @@
 module Actions
   module Pulp3
     class ContentMigration < Pulp3::AbstractAsyncTask
-      def plan(repository_type_labels, smart_proxy = SmartProxy.pulp_master)
+      def plan(smart_proxy = SmartProxy.pulp_master)
         sequence do
-          plan_self(repository_type_labels: repository_type_labels, smart_proxy_id: smart_proxy.id)
-          plan_action(Actions::Pulp3::ImportMigration, repository_type_labels)
+          plan_self(smart_proxy_id: smart_proxy.id)
+          plan_action(Actions::Pulp3::ImportMigration)
         end
       end
 
       def invoke_external_task
-        migration_service = ::Katello::Pulp3::Migration.new(smart_proxy, input[:repository_type_labels])
-        migration_service.create_and_run_migration
+        migration_service = ::Katello::Pulp3::Migration.new(smart_proxy)
+        migration_service.create_and_run_migrations
       end
     end
   end

data/app/lib/actions/pulp3/import_migration.rb

@@ -1,12 +1,12 @@
 module Actions
   module Pulp3
     class ImportMigration < Pulp3::Abstract
-      def plan(repository_type_labels)
-        plan_self(repository_type_labels: repository_type_labels)
+      def plan
+        plan_self
       end
 
       def run
-        migration_service = ::Katello::Pulp3::Migration.new(SmartProxy.pulp_master, input[:repository_type_labels])
+        migration_service = ::Katello::Pulp3::Migration.new(SmartProxy.pulp_master)
         migration_service.import_pulp3_content
       end
     end

data/app/lib/actions/pulp3/orchestration/repository/import_upload.rb

@@ -25,7 +25,7 @@ module Actions
             else
               repo = ::Katello::Repository.find(input[:repository_id])
               repo_backend_service = repo.backend_service(smart_proxy)
-              uploads_api = repo_backend_service.uploads_api
+              uploads_api = repo_backend_service.core_api.uploads_api
               output[:pulp_tasks] = [uploads_api.commit(input[:upload_href], sha256: input[:sha256])]
             end
           end

data/app/lib/katello/concerns/base_template_scope_extensions.rb

@@ -87,7 +87,7 @@ module Katello
 
         tasks = load_resource(klass: ForemanTasks::Task,
                               where: condition,
-                              permission: 'view_tasks',
+                              permission: 'view_foreman_tasks',
                               joins: 'LEFT OUTER JOIN template_invocations ON foreman_tasks_tasks.id = template_invocations.run_host_job_task_id LEFT OUTER JOIN templates ON template_invocations.template_id = templates.id',
                               select: 'foreman_tasks_tasks.*,template_invocations.id AS template_invocation_id',
                               search: search

data/app/models/katello/authorization/pool.rb

@@ -2,9 +2,13 @@ module Katello
   module Authorization::Pool
     extend ActiveSupport::Concern
 
+    def readable?
+      self.class.readable.where(id: self.id).any?
+    end
+
     module ClassMethods
       def readable
-        where(:subscription_id => Katello::Subscription.authorized(:view_subscriptions))
+        where(:subscription_id => Katello::Subscription.readable)
       end
     end
   end

data/app/models/katello/authorization/subscription.rb

@@ -10,7 +10,9 @@ module Katello
 
     module ClassMethods
       def readable
-        authorized(:view_subscriptions)
+        return all if User.current.admin?
+
+        authorized(:view_subscriptions).where(organization_id: User.current.organization_ids)
       end
     end
   end

data/app/models/katello/candlepin/repository_mapper.rb

@@ -6,7 +6,7 @@ module Katello
       def initialize(product, content, substitutions)
         @product = product
         @content = content
-        @substitutions = substitutions.try(:with_indifferent_access)
+        @substitutions = prune_substitutions(substitutions.try(:with_indifferent_access), content.content_url)
       end
 
       def find_repository
@@ -69,6 +69,10 @@ module Katello
         ::Katello::Glue::Pulp::Repos.repo_path_from_content_path(product.organization.library, path)
       end
 
+      def prune_substitutions(subs, url)
+        subs.select { |key, _| url.include?("$#{key}") }
+      end
+
       def feed_url
         product.repo_url(path)
       end

data/app/models/katello/concerns/host_managed_extensions.rb

@@ -110,17 +110,26 @@ module Katello
       end
 
       def import_package_profile_in_bulk(simple_packages)
-        nvras = simple_packages.map { |sp| sp.nvra }
-        found = InstalledPackage.where(:nvra => nvras).select(:id, :nvra).to_a
-        found_nvras = found.map(&:nvra)
-        new_packages = simple_packages.select { |sp| !found_nvras.include?(sp.nvra) }
+        nvreas = simple_packages.map { |sp| sp.nvrea }
+        found = InstalledPackage.where(:nvrea => nvreas).select(:id, :nvrea).to_a
+        found_nvreas = found.map(&:nvrea)
 
+        new_packages = simple_packages.select { |sp| !found_nvreas.include?(sp.nvrea) }
+
+        installed_packages = []
         new_packages.each do |simple_package|
-          ::Katello::Util::Support.active_record_retry do
-            found << InstalledPackage.where(:nvra => simple_package.nvra, :name => simple_package.name).first_or_create!
-          end
+          installed_packages << InstalledPackage.new(:nvrea => simple_package.nvrea,
+                                          :nvra => simple_package.nvra,
+                                          :name => simple_package.name,
+                                          :epoch => simple_package.epoch,
+                                          :version => simple_package.version,
+                                          :release => simple_package.release,
+                                          :arch => simple_package.arch)
         end
-        found
+        InstalledPackage.import(installed_packages, validate: false, on_duplicate_key_ignore: true)
+
+        found << installed_packages
+        found.flatten
       end
 
       def import_enabled_repositories(repos)

data/app/models/katello/concerns/pulp_database_unit.rb

@@ -127,7 +127,7 @@ module Katello
 
       def sync_repository_associations(repository, options = {})
         additive = options.fetch(:additive, false)
-        pulp_ids = options.fetch(:pulp_ids)
+        pulp_ids = options.fetch(:pulp_ids, nil)
         associated_ids = with_pulp_id(pulp_ids).pluck(:id) if pulp_ids
 
         table_name = self.repository_association_class.table_name

data/app/models/katello/content_view.rb

@@ -84,6 +84,10 @@ module Katello
         where("#{Katello::ContentViewEnvironment.table_name}.environment_id = ?", env.id)
     end
 
+    def self.published_with_repositories(root_repository)
+      joins(:content_view_versions => :repositories).where("katello_repositories.root_id" => root_repository.id).uniq
+    end
+
     def to_s
       name
     end

data/app/models/katello/glue/candlepin/candlepin_object.rb

@@ -3,12 +3,6 @@ module Katello
     extend ActiveSupport::Concern
 
     module ClassMethods
-      def get_for_organization(organization)
-        # returns objects from AR database rather than candlepin data
-        pool_ids = self.get_for_owner(organization.label).collect { |x| x['id'] }
-        self.where(:cp_id => pool_ids)
-      end
-
       def get_candlepin_ids(organization)
         self.get_for_owner(organization.label).map { |subscription| subscription["id"] }
       end