katello 3.7.0 → 3.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8fac07da0f8761539cf0d1277ef31e4afd4252e7
-  data.tar.gz: 0c327b63c0b1ea5296657f5551e80e61c98f84fd
+  metadata.gz: d88404b2afad190e4d14c345ac95118fbf2f8f44
+  data.tar.gz: 2f5cb4dfb3a91dd1733bc84866d303131ce96546
 SHA512:
-  metadata.gz: 0fa3348cfe3b738493a89038154f305bf1ba9ecb142c89e23851049f4d548e50bcdaeb564ed6bc7132e227cb54975df908f1b0114efc521b8c73e55e131c2924
-  data.tar.gz: '0941f97d419cea37695d53344727dfd59c8bae0104fa27ffe42bfcbb031dbdba8d029ab6b428383f5d494a1f74a426911685d39c3816bddc100787c786f17e43'
+  metadata.gz: af4305e274f7c50eff1aa319b28d0e9f5a678ac4a09436e1a6ad8fe629749e486758b19ff50b624f6283767717d717003e89bbc471e91fadc6674b7b1738c791
+  data.tar.gz: 23365d77760637b47a6f4ca0a5234702f254f979a464d5f115e778551553958f73e22e79ffa49a5ca19d0d0c9fe17767147ef716ba78a17e937c61c32ac31b6a

data/app/assets/javascripts/katello/common/index.js

@@ -1,3 +1,4 @@
+//= require bastion/lodash/lodash
 //= require "katello/common/katello.global"
 //= require "katello/common/katello.common.js"
 //= require "katello/common/katello"

data/app/assets/javascripts/katello/sync_management/index.js

@@ -1,2 +1,3 @@
 //= require "katello/jquery.treeTable"
+//= require "katello/common/katello.common.js"
 //= require "katello/sync_management/sync_management"

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

@@ -102,13 +102,9 @@ 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|
-        if !valid_package_name?(package) && !package.is_a?(Hash)
+        unless package.is_a?(String) && ::Katello::Util::Package.valid_package_name_format(package).nil?
           fail HttpErrors::BadRequest, _("%s is not a valid package name") % package
         end
       end

data/app/controllers/katello/remote_execution_controller.rb

@@ -15,6 +15,12 @@ module Katello
         end
       end
 
+      # to overcome the isolated namespace engine difficulties with paths
+      helper Rails.application.routes.url_helpers
+      def _routes
+        Rails.application.routes
+      end
+
       private
 
       def prepare_composer
@@ -43,12 +49,6 @@ module Katello
         # getting packageInstall from UI, translating to 'katello_package_install' feature
         "katello_#{params[:remote_action].underscore}"
       end
-
-      # to overcome the isolated namespace engine difficulties with paths
-      helper Rails.application.routes.url_helpers
-      def _routes
-        Rails.application.routes
-      end
     end
   else
     class RemoteExecutionController < ApplicationController

data/app/helpers/katello/hosts_and_hostgroups_helper.rb

@@ -72,6 +72,12 @@ module Katello
       return selected_host_group.content_view if selected_host_group.present?
     end
 
+    def fetch_content_source(host, options = {})
+      return host.content_source if host.content_source.present?
+      selected_host_group = options.fetch(:selected_host_group, nil)
+      return selected_host_group.content_source if selected_host_group.present?
+    end
+
     def accessible_lifecycle_environments(org, host)
       selected = host.lifecycle_environment
       envs = org.kt_environments.readable
@@ -97,24 +103,28 @@ module Katello
       end
     end
 
-    def lifecycle_environment_options(host, options = {})
+    # Generic method to provide a list of options in the UI
+    def content_options(host, selected_id, object_type, options = {})
       include_blank = options.fetch(:include_blank, nil)
       include_blank = '<option></option>' if include_blank == true #check for true specifically
-
-      selected_id = fetch_lifecycle_environment(host, options).try(:id)
       orgs = relevant_organizations(host)
       all_options = []
       orgs.each do |org|
-        env_options = ""
-        accessible_lifecycle_environments(org, host).each do |env|
-          selected = selected_id == env.id ? 'selected' : ''
-          env_options << %(<option value="#{env.id}" class="kt-env" #{selected}>#{h(env.name)}</option>)
+        content_object_options = ""
+        accessible_content_objects = if object_type == :lifecycle_environment
+                                       accessible_lifecycle_environments(org, host)
+                                     elsif object_type == :content_source
+                                       accessible_content_proxies(host)
+                                     end
+        accessible_content_objects.each do |content_object|
+          selected = selected_id == content_object.id ? 'selected' : ''
+          content_object_options << %(<option value="#{content_object.id}" class="kt-env" #{selected}>#{h(content_object.name)}</option>)
         end
 
         if orgs.count > 1
-          all_options << %(<optgroup label="#{org.name}">#{env_options}</optgroup>)
+          all_options << %(<optgroup label="#{org.name}">#{content_object_options}</optgroup>)
         else
-          all_options << env_options
+          all_options << content_object_options
         end
       end
 
@@ -123,6 +133,24 @@ module Katello
       all_options.html_safe
     end
 
+    def lifecycle_environment_options(host, options = {})
+      content_options(
+        host,
+        fetch_lifecycle_environment(host, options).try(:id),
+        :lifecycle_environment,
+        options
+      )
+    end
+
+    def content_source_options(host, options = {})
+      content_options(
+        host,
+        fetch_content_source(host, options).try(:id),
+        :content_source,
+        options
+      )
+    end
+
     def content_views_for_host(host, options)
       include_blank = options.fetch(:include_blank, nil)
       if include_blank == true #check for true specifically

data/app/lib/actions/katello/host/hypervisors_update.rb

@@ -13,37 +13,86 @@ module Actions
         end
 
         def finalize
-          hypervisors = input[:hypervisors]
+          @hypervisors = input[:hypervisors]
+          return unless @hypervisors
 
-          if hypervisors
-            User.as_anonymous_admin do
-              hypervisors.each { |hypervisor| update_or_create_hypervisor(hypervisor) }
+          User.as_anonymous_admin do
+            load_resources
+
+            @hosts.each do |uuid, host|
+              update_subscription_facet(uuid, host)
             end
           end
         end
 
-        def update_or_create_hypervisor(hypervisor_json)
-          organization = ::Organization.find_by(:label => hypervisor_json[:organization_label])
+        # Loads all resources needed for refreshing subscription facet
+        def load_resources
+          @organizations = ::Organization.where(label: hypervisors_field(:organization_label)).map { |org| [org.label, org] }.to_h
+          @hosts = {}
+
+          load_hosts_by_uuid
+          load_hosts_by_duplicate_name
+          create_missing_hosts
+
+          candlepin_data = ::Katello::Resources::Candlepin::Consumer.get(uuid: @hosts.keys)
+          @candlepin_attributes = candlepin_data.map { |consumer| [consumer[:uuid], consumer] }.to_h
+        end
+
+        def load_hosts_by_uuid
+          hosts_by_uuid = ::Host.eager_load(:subscription_facet).where(katello_subscription_facets: { uuid: hypervisors_field(:uuid) })
+          @hosts.merge(hosts_by_uuid.map { |host| [host.subscription_facet.uuid, host] }.to_h)
+        end
+
+        def load_hosts_by_duplicate_name
+          duplicate_names, duplicate_name_orgs = generate_duplicates_list
+
+          hosts_by_dup_name = ::Host.preload(:subscription_facet).where(name: duplicate_names.keys)
+
+          hosts_by_dup_name.each do |host|
+            validate_host_organization(host, duplicate_name_orgs[host.name].try(:id))
+          end
+
+          @hosts.merge!(hosts_by_dup_name.map { |host| [duplicate_names[host.name], host] }.to_h)
+        end
+
+        def create_missing_hosts
+          # remaining hypervisors
+          @hypervisors.each do |hypervisor|
+            next if @hosts.key?(hypervisor[:uuid])
+            duplicate_name, org = duplicate_name(hypervisor)
+            @hosts[hypervisor[:uuid]] = create_host_for_hypervisor(duplicate_name, org)
+          end
+        end
+
+        def generate_duplicates_list
+          duplicate_names = {}
+          duplicate_name_orgs = {}
+          @hypervisors.each do |hypervisor|
+            next if @hosts.key?(hypervisor[:uuid])
+
+            duplicate_name, org = duplicate_name(hypervisor)
+            duplicate_names[duplicate_name] = hypervisor[:uuid]
+            duplicate_name_orgs[duplicate_name] = org
+          end
 
-          # Since host names must be unique yet hypervisors may have unique subscription
-          # facets in different orgs
-          sanitized_name = ::Katello::Host::SubscriptionFacet.sanitize_name(hypervisor_json[:name])
-          duplicate_name = "virt-who-#{sanitized_name}-#{organization.id}"
-          host = ::Katello::Host::SubscriptionFacet.find_by(:uuid => hypervisor_json[:uuid]).try(:host)
-          host ||= ::Host.find_by(:name => duplicate_name)
-          if host && host.organization.try(:id) != organization.id
+          [duplicate_names, duplicate_name_orgs]
+        end
+
+        def validate_host_organization(host, organization)
+          if host.organization_id.nil? || host.organization_id != organization
             fail _("Host '%{name}' does not belong to an organization") % {:name => host.name} unless host.organization
-            host = nil
           end
+        end
 
-          host ||= create_host_for_hypervisor(duplicate_name, organization)
-          host.subscription_facet ||= ::Katello::Host::SubscriptionFacet.new
-          host.subscription_facet.host_id = host.id
-          host.subscription_facet.uuid = hypervisor_json[:uuid]
-          host.subscription_facet.import_database_attributes(host.subscription_facet.candlepin_consumer.consumer_attributes)
-          host.subscription_facet.save!
-          host.subscription_facet.update_subscription_status
-          host.save!
+        # extracts a single field from a given list og hypervisors data.
+        def hypervisors_field(field, hypervisors = @hypervisors)
+          hypervisors.map { |h| h[field] }.uniq
+        end
+
+        def duplicate_name(hypervisor)
+          organization = @organizations[hypervisor[:organization_label]]
+          sanitized_name = ::Katello::Host::SubscriptionFacet.sanitize_name(hypervisor[:name])
+          ["virt-who-#{sanitized_name}-#{organization.id}", organization]
         end
 
         def create_host_for_hypervisor(name, organization, location = nil)
@@ -54,6 +103,17 @@ module Actions
           host
         end
 
+        def update_subscription_facet(uuid, host)
+          host.subscription_facet ||= host.build_subscription_facet(uuid: uuid)
+          if @candlepin_attributes.key?(uuid)
+            host.subscription_facet.candlepin_consumer.consumer_attributes = @candlepin_attributes[uuid]
+            host.subscription_facet.import_database_attributes
+            host.subscription_facet.save!
+            host.subscription_facet.update_subscription_status(@candlepin_attributes[uuid].try(:[], :entitlementStatus))
+          end
+          host.save!
+        end
+
         def rescue_strategy
           Dynflow::Action::Rescue::Skip
         end

data/app/lib/actions/pulp/consumer/abstract_content_action.rb

@@ -44,6 +44,18 @@ module Actions
           messages
         end
 
+        # by default runcible puts whatever we pass into a hash under the 'name' key
+        # here we can make the unit hash more precise
+        def parse_units_for_type
+          if input[:type] == 'rpm'
+            input[:args].collect do |unit|
+              ::Katello::Util::Package.parse_nvrea_nvre(unit) || unit
+            end
+          else
+            input[:args]
+          end
+        end
+
         def presenter
           Consumer::ContentPresenter.new(self)
         end

data/app/lib/actions/pulp/consumer/content_install.rb

@@ -14,7 +14,7 @@ module Actions
         def invoke_external_task
           task = pulp_extensions.consumer.install_content(input[:consumer_uuid],
                                                    input[:type],
-                                                   input[:args],
+                                                   parse_units_for_type,
                                                     "importkeys" => true)
           schedule_timeout(Setting['content_action_accept_timeout'])
           task

data/app/lib/actions/pulp/consumer/content_uninstall.rb

@@ -14,7 +14,7 @@ module Actions
         def invoke_external_task
           pulp_extensions.consumer.uninstall_content(input[:consumer_uuid],
                                                      input[:type],
-                                                     input[:args])
+                                                     parse_units_for_type)
         end
 
         def presenter

data/app/lib/actions/pulp/consumer/content_update.rb

@@ -17,7 +17,7 @@ module Actions
 
           pulp_extensions.consumer.update_content(input[:consumer_uuid],
                                                   input[:type],
-                                                  input[:args],
+                                                  parse_units_for_type,
                                                   options)
         end
 

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

@@ -50,7 +50,7 @@ module Katello
         scoped_search :on => :hypervisor, :relation => :subscription_facet, :complete_value => true
         scoped_search :on => :name, :relation => :hypervisor_host, :complete_value => true, :rename => :hypervisor_host, :ext_method => :find_by_hypervisor_host
         scoped_search :on => :name, :relation => :subscriptions, :rename => :subscription_name, :complete_value => true, :ext_method => :find_by_subscription_name
-        scoped_search :on => :id, :relation => :pools, :rename => :subscription_id, :complete_value => true, :ext_method => :find_by_subscription_id
+        scoped_search :on => :id, :relation => :pools, :rename => :subscription_id, :complete_value => true, :ext_method => :find_by_subscription_id, :only_explicit => true
       end
 
       module ClassMethods

data/app/models/katello/content_view.rb

@@ -579,14 +579,22 @@ module Katello
 
     def check_composite_action_allowed!(env)
       if composite? && Setting['restrict_composite_view']
-        # verify that the composite's component view versions exist in the target environment.
+        if components.size != content_view_components.size
+          fail _("Make sure all the component content views are published before publishing/promoting the composite content view. "\
+               "This restriction is optional and can be modified in the Administrator -> Settings -> Content "\
+                "page using the restrict_composite_view flag.")
+        end
+
+        env_ids = env.try(:pluck, 'id') || []
+        env_ids << env.id unless env_ids.size > 0
         components.each do |component|
-          unless component.environments.include?(env)
+          component_environment_ids = component.environments.pluck('id')
+          unless (env_ids - component_environment_ids).empty?
             fail _("The action requested on this composite view cannot be performed until all of the "\
                    "component content view versions have been promoted to the target environment: %{env}.  "\
-                   "This restriction is optional and can be modified in the Administrator -> Settings "\
+                   "This restriction is optional and can be modified in the Administrator -> Settings -> Content "\
                    "page using the restrict_composite_view flag.") %
-                   { :env => env.name }
+                   { :env => env.try(:pluck, 'name') || env.name }
           end
         end
       end

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

@@ -40,6 +40,16 @@ module Katello
         end
         pool.import_data(index_hosts)
       end
+
+      def stacking_subscription(org_label, stacking_id)
+        org = Organization.find_by(:label => org_label)
+        subscription = ::Katello::Subscription.find_by(:organization_id => org.id, :cp_id => stacking_id)
+        if subscription.nil?
+          found_product = ::Katello::Resources::Candlepin::Product.find_for_stacking_id(org_label, stacking_id)
+          subscription = ::Katello::Subscription.find_by(:organization_id => org.id, :cp_id => found_product['id']) if found_product
+        end
+        subscription
+      end
     end
 
     module InstanceMethods
@@ -80,16 +90,6 @@ module Katello
         providers.any?
       end
 
-      def stacking_subscription(org_label, stacking_id)
-        org = Organization.find_by(:label => org_label)
-        subscription = ::Katello::Subscription.find_by(:organization_id => org.id, :product_id => stacking_id)
-        if subscription.nil?
-          found_product = ::Katello::Resources::Candlepin::Product.find_for_stacking_id(org_label, stacking_id)
-          subscription = ::Katello::Subscription.find_by(:organization_id => org.id, :cp_id => found_product['id']) if found_product
-        end
-        subscription
-      end
-
       # rubocop:disable MethodLength,Metrics/AbcSize
       def import_data(index_hosts_and_activation_keys = false)
         pool_attributes = {}.with_indifferent_access
@@ -101,7 +101,7 @@ module Katello
         product_attributes.map { |attr| pool_attributes[attr["name"].underscore.to_sym] = attr["value"] }
 
         if pool_json["sourceStackId"]
-          subscription = stacking_subscription(pool_json['owner']['key'], pool_json["sourceStackId"])
+          subscription = Pool.stacking_subscription(pool_json['owner']['key'], pool_json["sourceStackId"])
         else
           subscription = ::Katello::Subscription.find_by(:cp_id => pool_json["productId"])
         end

data/app/models/katello/host/content_facet.rb

@@ -83,13 +83,14 @@ module Katello
       end
 
       def update_applicability_counts
-        self.update_attributes!(
+        self.assign_attributes(
             :installable_security_errata_count => self.installable_errata.security.count,
             :installable_bugfix_errata_count => self.installable_errata.bugfix.count,
             :installable_enhancement_errata_count => self.installable_errata.enhancement.count,
             :applicable_rpm_count => self.content_facet_applicable_rpms.count,
             :upgradable_rpm_count => self.installable_rpms.count
         )
+        self.save!(:validate => false)
       end
 
       def import_rpm_applicability(partial)

data/app/models/katello/rpm.rb

@@ -16,7 +16,7 @@ module Katello
     scoped_search :on => :release, :complete_value => true, :ext_method => :scoped_search_release
     scoped_search :on => :arch, :complete_value => true
     scoped_search :on => :epoch, :complete_value => true
-    scoped_search :on => :evr, :ext_method => :scoped_search_evr
+    scoped_search :on => :evr, :ext_method => :scoped_search_evr, :only_explicit => true
     scoped_search :on => :filename, :complete_value => true
     scoped_search :on => :sourcerpm, :complete_value => true
     scoped_search :on => :checksum
@@ -222,15 +222,23 @@ module Katello
     end
 
     def self.installable_for_hosts(hosts = nil)
-      query = Katello::Rpm.joins(:content_facet_applicable_rpms).joins(:repository_rpms).
+      hosts = ::Host.where(:id => hosts) if hosts && hosts.is_a?(Array)
+
+      query = Katello::Rpm.joins(:content_facet_applicable_rpms).
         joins("INNER JOIN #{Katello::ContentFacetRepository.table_name} on \
         #{Katello::ContentFacetRepository.table_name}.content_facet_id = #{Katello::ContentFacetApplicableRpm.table_name}.content_facet_id").
         joins("INNER JOIN #{Katello::RepositoryRpm.table_name} AS host_repo_rpm ON \
-          host_repo_rpm.rpm_id = #{Katello::Rpm.table_name}.id").
-        where("#{Katello::ContentFacetRepository.table_name}.repository_id = host_repo_rpm.repository_id")
+          host_repo_rpm.rpm_id = #{Katello::Rpm.table_name}.id AND \
+          #{Katello::ContentFacetRepository.table_name}.repository_id = host_repo_rpm.repository_id")
 
-      query = query.joins(:content_facets).where("#{Katello::Host::ContentFacet.table_name}.host_id" => hosts.map(&:id)) if hosts
-      query.distinct
+      if hosts
+        query = query.where("#{Katello::ContentFacetRepository.table_name}.content_facet_id" => hosts.joins(:content_facet)
+                                .select("#{Katello::Host::ContentFacet.table_name}.id"))
+      else
+        query = query.joins(:content_facet_applicable_rpms)
+      end
+
+      query
     end
 
     def self.applicable_to_hosts(hosts)