katello 3.4.5 → 3.5.0.rc1

data/app/lib/actions/katello/product/content_create.rb

@@ -11,11 +11,11 @@ module Actions
                                            owner:       repository.product.organization.label,
                                            name:        repository.name,
                                            type:        repository.content_type,
+                                           arches:      repository.arch == "noarch" ? nil : repository.arch,
                                            label:       repository.custom_content_label,
                                            content_url: content_url(repository))
               content_id = content_create.output[:response][:id]
-              plan_action(Candlepin::Product::ContentAdd,
-                                    owner: repository.product.organization.label,
+              plan_action(Candlepin::Product::ContentAdd, owner: repository.product.organization.label,
                                     product_id: repository.product.cp_id,
                                     content_id: content_id)
 
@@ -29,13 +29,13 @@ module Actions
                           content_id:  content_id,
                           name:        repository.name,
                           type:        repository.content_type,
+                          arches:      repository.arch == "noarch" ? "" : repository.arch,
                           label:       repository.custom_content_label,
                           content_url: content_url(repository),
                           gpg_key_url: repository.yum_gpg_key_url)
             end
 
-            plan_self(repository_id: repository.id,
-                      content_id: content_id)
+            plan_self(repository_id: repository.id, content_id: content_id)
           end
         end
 

data/app/lib/actions/katello/product/create.rb

@@ -2,27 +2,29 @@ module Actions
   module Katello
     module Product
       class Create < Actions::EntryAction
-        def plan(product, organization)
+        def plan(product, organization, subscription_start = nil)
           sequence do
             product.provider = organization.anonymous_provider
             product.organization = organization
+            product.setup_label_from_name
+            product.cp_id = ::Katello::Product.unused_product_id
+            product.save!
 
-            cp_create = plan_action(::Actions::Candlepin::Product::Create,
-                                    :owner => product.organization.label,
-                                    :name => product.name,
-                                    :multiplier => 1,
-                                    :attributes => [{:name => "arch", :value => "ALL"}])
-
-            cp_id = cp_create.output[:response][:id]
+            plan_action(::Actions::Candlepin::Product::Create,
+                        :owner => product.organization.label,
+                        :name => product.name,
+                        :id => product.cp_id,
+                        :multiplier => 1,
+                        :attributes => [{:name => "arch", :value => "ALL"}])
 
             sub_create = plan_action(::Actions::Candlepin::Product::CreateUnlimitedSubscription,
                         :owner_key => organization.label,
-                        :product_id => cp_id)
+                        :product_id => product.cp_id,
+                        :start_time => subscription_start)
 
             subscription_id = sub_create.output[:response][:id]
 
-            product.save!
-            action_subject product, :cp_id => cp_id
+            action_subject product, :cp_id => product.cp_id
 
             plan_self
             plan_action Katello::Product::ReindexSubscriptions, product, subscription_id

data/app/lib/actions/katello/repository/sync.rb

@@ -26,7 +26,6 @@ module Actions
           pulp_sync_options = {}
           pulp_sync_options[:download_policy] = ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND if validate_contents
           pulp_sync_options[:force_full] = true if skip_metadata_check
-          pulp_sync_options[:auto_publish] = false if skip_metadata_check #skip auto publish, and force it later
           pulp_sync_options[:remove_missing] = false if incremental
 
           fail ::Katello::Errors::InvalidActionOptionError, _("Unable to sync repo. This repository does not have a feed url.") if repo.url.blank? && source_url.blank?

data/app/lib/actions/katello/repository/update.rb

@@ -18,7 +18,8 @@ module Actions
                         :content_url => ::Katello::Glue::Pulp::Repos.custom_content_path(repository.product, repository.label),
                         :gpg_key_url => repository.yum_gpg_key_url,
                         :label => repository.content.label,
-                        :type => repository.content_type)
+                        :type => repository.content_type,
+                        :arches => repository.arch == "noarch" ? nil : repository.arch)
           end
 
           if SETTINGS[:katello][:use_pulp] && repository.pulp_update_needed?

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

@@ -7,7 +7,11 @@ module Actions
         end
 
         def invoke_external_task
-          pulp_extensions.consumer.regenerate_applicability_by_ids(input[:uuids])
+          if input[:uuids].length == 1
+            pulp_resources.consumer.regenerate_applicability_by_id(input[:uuids].first)
+          else
+            pulp_extensions.consumer.regenerate_applicability_by_ids(input[:uuids])
+          end
         end
       end
     end

data/app/lib/actions/pulp/repository/create.rb

@@ -92,6 +92,7 @@ module Actions
           importer.ssl_client_cert = input[:ssl_client_cert]
           importer.ssl_client_key  = input[:ssl_client_key]
           importer.ssl_validation  = input[:ssl_validation]
+          importer.remove_missing  = input[:mirror_on_sync]
           importer.basic_auth_username = input[:upstream_username] if input[:upstream_username].present?
           importer.basic_auth_password = input[:upstream_password] if input[:upstream_password].present?
           importer

data/app/lib/actions/pulp/repository/create_in_plan.rb

@@ -7,11 +7,11 @@ module Actions
         def plan(input)
           plan_self(input)
           pulp_extensions.repository.create_with_importer_and_distributors(input[:pulp_id],
-                                                                                      importer,
-                                                                                      distributors,
-                                                                                      display_name: input[:name])
+                                                                           importer,
+                                                                           distributors,
+                                                                           display_name: input[:name])
         rescue => e
-          raise error_message(e.http_body) || e
+          raise e.try(:http_body) ? error_message(e.http_body) || e : e
         end
 
         def error_message(body)

data/app/lib/actions/pulp/repository/sync.rb

@@ -33,7 +33,7 @@ module Actions
             sync_options.merge!(input[:options]) if input[:options]
 
             output[:pulp_tasks] = pulp_tasks =
-                [pulp_resources.repository.sync(input[:pulp_id], override_config: sync_options)]
+                                    [pulp_resources.repository.sync(input[:pulp_id], override_config: sync_options)]
 
             pulp_tasks
           end

data/app/lib/katello/http_resource.rb

@@ -55,7 +55,7 @@ module Katello
             logger.error "Remote server status code " << resp.code.to_s
             raise RestClientException, {:message => error.to_s, :service_code => service_code, :code => status_code}, caller
           else
-            raise NetworkException, [resp.code.to_s, resp.body].reject { |s| s.nil? || s.empty? }.join(' ')
+            raise NetworkException, [resp.code.to_s, resp.body].reject { |s| s.blank? }.join(' ')
           end
         end
         fail RestClientException, {:message => message, :service_code => service_code, :code => status_code}, caller

data/app/lib/katello/lazy_accessor.rb

@@ -105,7 +105,7 @@ module Katello
 
       def lazy_attribute_will_change!(attr)
         changed_remote_attributes[attr.to_s] ||=
-            instance_variable_get("@#{attr}").nil? ? remote_attribute_value(attr) : instance_variable_get("@#{attr}")
+          instance_variable_get("@#{attr}").nil? ? remote_attribute_value(attr) : instance_variable_get("@#{attr}")
       end
 
       def lazy_attribute_change(attr)

data/app/lib/katello/resources/candlepin.rb

@@ -158,7 +158,7 @@ module Katello
           end
 
           def available_pools(owner_label, uuid, listall = false)
-            url = Pool.path(nil, owner_label) + "?consumer=#{uuid}&listall=#{listall}"
+            url = Pool.path(nil, owner_label) + "?consumer=#{uuid}&listall=#{listall}&add_future=true"
             response = Candlepin::CandlepinResource.get(url, self.default_headers).body
             JSON.parse(response)
           end
@@ -707,7 +707,7 @@ module Katello
             self.delete(join_path(path(owner_label, product_id), "content/#{content_id}"), self.default_headers).code.to_i
           end
 
-          def create_unlimited_subscription(owner_key, product_id)
+          def create_unlimited_subscription(owner_key, product_id, start_date)
             start_date ||= Time.now
             # End it 100 years from now
             end_date ||= start_date + 10_950.days

data/app/lib/katello/util/data.rb

@@ -5,6 +5,12 @@ module Katello
         variable.map { |x| x.with_indifferent_access }
       end
 
+      def self.md5hash(string)
+        md5 = Digest::MD5.new
+        md5.update(string)
+        md5.hexdigest
+      end
+
       def self.ostructize(obj, options = {})
         options[:prefix_keys] ||= []
         options[:prefix] ||= '_'

data/app/lib/katello/util/support.rb

@@ -68,7 +68,7 @@ module Katello
         end
         diff_data = diff_data.compact.flatten
 
-        return diff_data unless diff_data.nil? || diff_data.empty?
+        return diff_data unless diff_data.blank?
         stringify(params.keys) - stringify(rule.keys)
       end
 

data/app/models/katello/activation_key.rb

@@ -1,11 +1,10 @@
 module Katello
   class ActivationKey < Katello::Model
-    self.include_root_in_json = false
-
     include Glue::Candlepin::ActivationKey if SETTINGS[:katello][:use_cp]
     include Glue if SETTINGS[:katello][:use_cp]
     include Katello::Authorization::ActivationKey
     include ForemanTasks::Concerns::ActionSubject
+    include ScopedSearchExtensions
 
     belongs_to :organization, :inverse_of => :activation_keys
     belongs_to :environment, :class_name => "KTEnvironment", :inverse_of => :activation_keys
@@ -16,6 +15,7 @@ module Katello
     has_many :host_collections, :through => :key_host_collections
 
     has_many :pools, :through => :pool_activation_keys, :class_name => "Katello::Pool"
+    has_many :subscriptions, :through => :pools
     has_many :pool_activation_keys, :class_name => "Katello::PoolActivationKey", :dependent => :destroy, :inverse_of => :activation_key
     has_many :subscription_facet_activation_keys, :class_name => "Katello::SubscriptionFacetActivationKey", :dependent => :destroy
     has_many :subscription_facets, :through => :subscription_facet_activation_keys
@@ -54,6 +54,8 @@ module Katello
     scoped_search :rename => :content_view, :on => :name, :relation => :content_view, :complete_value => true
     scoped_search :on => :content_view_id, :complete_value => true, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
     scoped_search :on => :description, :complete_value => true
+    scoped_search :on => :name, :relation => :subscriptions, :rename => :subscription_name, :complete_value => true, :ext_method => :find_by_subscription_name
+    scoped_search :on => :id, :relation => :subscriptions, :rename => :subscription_id, :complete_value => true, :ext_method => :find_by_subscription_id
 
     def environment_exists
       if environment_id && environment.nil?
@@ -79,10 +81,6 @@ module Katello
       end
     end
 
-    def subscriptions
-      self.pools
-    end
-
     def available_subscriptions
       all_pools = self.get_pools.map { |pool| pool["id"] }
       added_pools = self.pools.pluck(:cp_id)
@@ -105,7 +103,7 @@ module Katello
     end
 
     def all_products
-      Katello::Product.joins(:subscriptions => :pools).where(:organization_id => organization.id).enabled.uniq
+      organization.products.enabled.uniq
     end
 
     def available_content(content_access_mode_all = false, content_access_mode_env = false)
@@ -170,6 +168,26 @@ module Katello
       _("Activation Keys")
     end
 
+    def self.find_by_subscription_name(_key, operator, value)
+      conditions = sanitize_sql_for_conditions(["#{Katello::Subscription.table_name}.name #{operator} ?", value_to_sql(operator, value)])
+      activation_keys = ::Katello::ActivationKey.joins(pools: :subscription).where(conditions)
+      return_activation_keys_by_id(activation_keys.pluck(:id))
+    end
+
+    def self.find_by_subscription_id(_key, operator, value)
+      conditions = sanitize_sql_for_conditions(["#{Katello::Subscription.table_name}.id #{operator} ?", value_to_sql(operator, value)])
+      activation_keys = ::Katello::ActivationKey.joins(pools: :subscription).where(conditions)
+      return_activation_keys_by_id(activation_keys.pluck(:id))
+    end
+
+    def self.return_activation_keys_by_id(activation_key_ids)
+      if activation_key_ids.empty?
+        {:conditions => "1=0"}
+      else
+        {:conditions => "#{Katello::ActivationKey.table_name}.id IN (#{activation_key_ids.join(',')})"}
+      end
+    end
+
     private
 
     def set_default_content_view

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

@@ -7,7 +7,6 @@ module Katello
 
       included do
         alias_method_chain :validate_media?, :capsule
-        alias_method_chain :info, :katello
         alias_method_chain :smart_proxy_ids, :katello
 
         has_many :host_installed_packages, :class_name => "::Katello::HostInstalledPackage", :foreign_key => :host_id, :dependent => :destroy
@@ -46,19 +45,6 @@ module Katello
         ids.uniq.compact
       end
 
-      def info_with_katello
-        info = info_without_katello
-        info['parameters']['kt_env'] = self.lifecycle_environment.try(:label) #deprecated
-        info['parameters']['kt_cv'] = self.content_view.try(:label) #deprecated
-        info['parameters']['lifecycle_environment'] = self.lifecycle_environment.try(:label)
-        info['parameters']['content_view'] = self.content_view.try(:label)
-        info['parameters']['foreman_host_collections'] = self.host_collections.map(&:name)
-        if self.content_facet.present?
-          info['parameters']['kickstart_repository'] = self.content_facet.kickstart_repository.try(:label)
-        end
-        info
-      end
-
       def correct_puppet_environment
         if content_and_puppet_matched?
           new_environment = content_facet.content_view.puppet_env(content_facet.lifecycle_environment).try(:puppet_environment)
@@ -77,10 +63,67 @@ module Katello
       end
 
       def import_package_profile(simple_packages)
-        self.installed_packages.where("nvra not in (?)", simple_packages.map(&:nvra)).destroy_all
-        existing_nvras = self.installed_packages.pluck(:nvra)
+        if Setting[:bulk_query_installed_packages]
+          #this method is slow if the clean_installed_packages rake task has not been run, but faster if it has
+          found = import_package_profile_in_bulk(simple_packages)
+        else
+          found = import_package_profile_individually(simple_packages)
+        end
+
+        sync_package_associations(found.map(&:id))
+      end
+
+      def import_package_profile_in_bulk(simple_packages)
+        nvras = simple_packages.map { |sp| sp.nvra }
+        found = InstalledPackage.where(:nvra => nvras).select(:id, :nvra)
+        found_nvras = found.map(&:nvra)
+        new_packages = simple_packages.select { |sp| !found_nvras.include?(sp.nvra) }
+
+        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
+        end
+        found
+      end
+
+      def import_package_profile_individually(simple_packages)
+        found = []
         simple_packages.each do |simple_package|
-          self.installed_packages.create!(:name => simple_package.name, :nvra => simple_package.nvra) unless existing_nvras.include?(simple_package.nvra)
+          ::Katello::Util::Support.active_record_retry do
+            #use limit(1)[0] here to avoid a sort by id
+            pkg = InstalledPackage.where(:nvra => simple_package.nvra, :name => simple_package.name).limit(1)[0]
+            if pkg.nil?
+              pkg = InstalledPackage.create!(:nvra => simple_package.nvra, :name => simple_package.name)
+            end
+            found << pkg
+          end
+        end
+        found
+      end
+
+      def sync_package_associations(new_installed_package_ids)
+        old_associated_ids = self.installed_package_ids
+        table_name = self.host_installed_packages.table_name
+
+        new_ids = new_installed_package_ids - old_associated_ids
+        delete_ids = old_associated_ids - new_installed_package_ids
+
+        queries = []
+
+        if delete_ids.any?
+          queries << "DELETE FROM #{table_name} WHERE host_id=#{self.id} AND installed_package_id IN (#{delete_ids.join(', ')})"
+        end
+
+        unless new_ids.empty?
+          inserts = new_ids.map { |unit_id| "(#{unit_id.to_i}, #{self.id.to_i})" }
+          queries << "INSERT INTO #{table_name} (installed_package_id, host_id) VALUES #{inserts.join(', ')}"
+        end
+
+        ActiveRecord::Base.transaction do
+          queries.each do |query|
+            ActiveRecord::Base.connection.execute(query)
+          end
         end
       end
 

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

@@ -15,6 +15,8 @@ module Katello
         accepts_nested_attributes_for :subscription_facet, :update_only => true, :reject_if => lambda { |attrs| attrs.values.compact.empty? }
 
         has_many :activation_keys, :through => :subscription_facet
+        has_many :pools, :through => :subscription_facet
+        has_many :subscriptions, :through => :pools
         has_one :subscription_status_object, :class_name => 'Katello::SubscriptionStatus', :foreign_key => 'host_id'
         has_one :hypervisor_host, :through => :subscription_facet
 
@@ -33,6 +35,8 @@ module Katello
                       :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
         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
       end
 
       def update_action
@@ -45,28 +49,45 @@ module Katello
         def find_by_activation_key(_key, operator, value)
           conditions = sanitize_sql_for_conditions(["#{Katello::ActivationKey.table_name}.name #{operator} ?", value_to_sql(operator, value)])
           hosts = ::Host::Managed.joins(:activation_keys).where(conditions)
-          if hosts.empty?
-            { :conditions => "1=0" }
-          else
-            { :conditions => "#{::Host::Managed.table_name}.id IN (#{hosts.pluck(:id).join(',')})" }
-          end
+          return_hosts(hosts)
         end
 
         def find_by_activation_key_id(_key, operator, value)
           conditions = sanitize_sql_for_conditions(["#{Katello::ActivationKey.table_name}.id #{operator} ?", value_to_sql(operator, value)])
           hosts = ::Host::Managed.joins(:activation_keys).where(conditions)
-          if hosts.empty?
-            { :conditions => "1=0" }
-          else
-            { :conditions => "#{::Host::Managed.table_name}.id IN (#{hosts.pluck(:id).join(',')})" }
-          end
+          return_hosts(hosts)
         end
 
         def find_by_hypervisor_host(_key, operator, value)
           conditions = sanitize_sql_for_conditions(["#{::Host.table_name}.name #{operator} ?", value_to_sql(operator, value)])
           hosts = ::Host.where(conditions)
           hosts = ::Host.joins(:subscription_facet).where("#{Katello::Host::SubscriptionFacet.table_name}.hypervisor_host_id" => hosts)
+          return_hosts(hosts)
+        end
+
+        def find_by_subscription_name(_key, operator, value)
+          conditions = sanitize_sql_for_conditions(["#{Katello::Subscription.table_name}.name #{operator} ?", value_to_sql(operator, value)])
+          sub_facets = ::Katello::Host::SubscriptionFacet.joins(pools: :subscription).where(conditions)
+          host_ids = sub_facets.select(:host_id)
+          return_hosts_by_id(host_ids)
+        end
+
+        def find_by_subscription_id(_key, operator, value)
+          conditions = sanitize_sql_for_conditions(["#{Katello::Pool.table_name}.id #{operator} ?", value_to_sql(operator, value)])
+          sub_facets = ::Katello::Host::SubscriptionFacet.joins(:pools).where(conditions)
+          host_ids = sub_facets.select(:host_id)
+          return_hosts_by_id(host_ids)
+        end
+
+        def return_hosts_by_id(host_ids)
+          if host_ids.empty?
+            {:conditions => "1=0"}
+          else
+            {:conditions => "#{::Host::Managed.table_name}.id IN (#{host_ids.to_sql})"}
+          end
+        end
 
+        def return_hosts(hosts)
           if hosts.empty?
             {:conditions => "1=0"}
           else