katello 4.13.0 → 4.14.0.rc1

data/app/lib/katello/resources/discovery/yum.rb

@@ -0,0 +1,95 @@
+require 'spidr'
+
+module Katello
+  module Resources
+    module Discovery
+      class Yum < RepoDiscovery
+        attr_reader :found, :crawled, :to_follow
+        def initialize(url, crawled = [], found = [], to_follow = [],
+                       upstream_credentials_and_search = {
+                         upstream_username: nil,
+                         upstream_password: nil
+                       })
+          @uri = uri(url)
+          @upstream_username = upstream_credentials_and_search[:upstream_username].presence
+          @upstream_password = upstream_credentials_and_search[:upstream_password].presence
+          @found = found
+          @crawled = crawled
+          @to_follow = to_follow
+        end
+
+        def run(resume_point)
+          if @uri.scheme == 'file'
+            crawl_file_path(uri(resume_point))
+          elsif %w(http https).include?(@uri.scheme)
+            spidr_crawl_pages(uri(resume_point))
+          end
+        end
+
+        private
+
+        def crawl_file_path(url)
+          if url.path.ends_with?('/repodata/')
+            found_path = Pathname(url.path).parent.to_s
+            @found << "file://#{found_path}"
+          end
+          if url.path == @uri.path
+            Dir.glob("#{@uri.path}**/").each { |path| @to_follow << path }
+            @to_follow.shift
+          end
+          @crawled << url.path
+        end
+
+        def spidr_proxy_details
+          details = {}
+
+          if proxy
+            details[:host] = proxy_host
+            details[:port] = proxy_port
+            details[:user] = proxy.username
+            details[:password] = proxy.password
+          end
+
+          details
+        end
+
+        def spidr_crawl_pages(url)
+          url = url.to_s
+          user, password = @upstream_username, @upstream_password
+          Spidr.site(url, proxy: spidr_proxy_details) do |spider|
+            spider.authorized.add(url, user, password) if user && password
+            spider.every_page do |page|
+              page.url.query = nil
+              @crawled << page.url.to_s
+              process_page_urls(page.urls)
+              spider.skip_page!
+            end
+          end
+        end
+
+        def process_page_urls(urls)
+          urls.each do |url|
+            # Remove query parameters to avoid duplicate processing of URLs with sorting parameters etc
+            url.query = nil
+            if url.path.ends_with? 'repodata/'
+              @found << url.to_s.split('repodata/').first
+            else
+              @to_follow << url.to_s if should_follow?(url)
+            end
+          end
+        end
+
+        def should_follow?(url)
+          #Verify:
+          # * link's path includes the base url
+          # * link hasn't already been crawled
+          # * link ends with '/' so it should be a directory
+          # * link doesn't end with '/Packages/', as this increases
+          #       processing time and memory usage considerably
+          return url.path.starts_with?(@uri.path) && url.hostname == @uri.hostname && !@crawled.include?(url.to_s) &&
+            url.path.ends_with?('/') && !url.path.ends_with?('/Packages/')
+        end
+      end
+    end
+  end
+end

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

@@ -1,8 +1,8 @@
 module Katello
   module Util
     class CdnVarSubstitutor
-      attr_reader :good_listings
-      attr_reader :bad_listings
+      attr_reader :good_listings, :bad_listings
+
       # cdn_resource - an object providing access to CDN. It has to
       # provide a get method that takes a path (e.g.
       # /content/rhel/6.2/listing) and returns the body response)
@@ -68,7 +68,9 @@ module Katello
 
           futures.each do |future|
             resolved << future.value
-            Rails.logger.error("Failed at scanning for repository: #{future.reason}") if future.rejected?
+            if future.rejected?
+              fail Errors::CdnSubstitutionError, "Failed at scanning for repository: #{future.reason}"
+            end
           end
         end
 

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

@@ -13,7 +13,8 @@ module Katello
         options[:prefix_keys] ||= []
         options[:prefix] ||= '_'
 
-        if obj.is_a? Hash
+        case obj
+        when Hash
 
           ostructized_hash = {}
           obj.each do |key, value|
@@ -31,7 +32,7 @@ module Katello
           end
           return OpenStruct.new ostructized_hash
 
-        elsif obj.is_a? Array
+        when Array
 
           return obj.map { |r| ostructize(r, options) }
 

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

@@ -29,11 +29,12 @@ module Katello
 
       def get_pulp_filter_type(type)
         filter_type = type.downcase
-        if filter_type == "bugfix"
+        case filter_type
+        when "bugfix"
           return ::Katello::Erratum::BUGZILLA
-        elsif filter_type == "enhancement"
+        when "enhancement"
           return ::Katello::Erratum::ENHANCEMENT
-        elsif filter_type == "security"
+        when "security"
           return ::Katello::Erratum::SECURITY
         end
       end

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

@@ -75,8 +75,8 @@ module Katello
         vrea =  [package[:version], package[:release]].compact.join('-')
         vrea = vrea + '.' + package[:arch] unless package[:arch].nil?
         vrea = vrea + '.' + package[:suffix] unless package[:suffix].nil?
-        unless package[:epoch].nil?
-          vrea = package[:epoch] + ':' + vrea if package[:epoch].to_i != 0 || include_zero_epoch
+        if !package[:epoch].nil? && (package[:epoch].to_i != 0 || include_zero_epoch)
+          vrea = package[:epoch] + ':' + vrea
         end
         vrea
       end
@@ -135,7 +135,7 @@ module Katello
       end
 
       def self.valid_package_characters
-        /[^abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\-\.\_\+\,]+/
+        /[^abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\-._+,]+/
       end
 
       def self.setup_shared_unique_filter(repoids, search_mode, search_results)

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

@@ -25,7 +25,7 @@ module Katello
       def substitutions_needed
         # e.g. if content_url = "/content/dist/rhel/server/7/$releasever/$basearch/kickstart"
         #      return ['releasever', 'basearch']
-        split_path.map { |word| word.start_with?('$') ? word[1..-1] : nil }.compact
+        split_path.map { |word| word.start_with?('$') ? word[1..] : nil }.compact
       end
 
       def substitutable?

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

@@ -19,9 +19,10 @@ module Katello
       end
 
       def as(type)
-        if type == :csv
+        case type
+        when :csv
           as_csv(transform_data)
-        elsif type == :text
+        when :text
           as_text(transform_data)
         end
       end

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

@@ -63,7 +63,7 @@ module Katello
           self.parts.each_with_index do |part, i|
             a << @match.parts[i] if part[0] == ':'
           end
-          a << @match.ext[1..-1] if self.ext[1] == ':'
+          a << @match.ext[1..] if self.ext[1] == ':'
           a
         end
         alias_method :vars, :variables

data/app/lib/katello/validators/alternate_content_source_path_validator.rb

@@ -3,11 +3,12 @@ module Katello
     class AlternateContentSourcePathValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
         if value
-          if attribute == :base_url
+          case attribute
+          when :base_url
             unless AlternateContentSourcePathValidator.validate_base_url(value)
               record.errors[attribute] << N_("%s is not a valid path") % value
             end
-          elsif attribute == :subpaths
+          when :subpaths
             unless AlternateContentSourcePathValidator.validate_subpaths(value)
               record.errors[attribute] << N_('All subpaths must have a slash at the end and none at the front')
             end
@@ -16,7 +17,7 @@ module Katello
       end
 
       def self.validate_base_url(base_url)
-        base_url =~ /\A#{URI::DEFAULT_PARSER.make_regexp}\z/
+        base_url =~ /\A(?!uln:\/\/)(#{URI::DEFAULT_PARSER.make_regexp})\z/
       end
 
       # Subpaths must have a slash at the end and none at the front: 'path/'

data/app/lib/katello/validators/alternate_content_source_products_validator.rb

@@ -2,13 +2,11 @@ module Katello
   module Validators
     class AlternateContentSourceProductsValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
-        if value
-          if attribute == :product_id
-            product = ::Katello::Product.find(value)
-            content_type = record.alternate_content_source.content_type
-            if product.repositories.with_type(content_type).has_url.empty?
-              record.errors.add(attribute, _("%{name} has no %{type} repositories with upstream URLs to add to the alternate content source.") % { name: product.name, type: content_type })
-            end
+        if value && (attribute == :product_id)
+          product = ::Katello::Product.find(value)
+          content_type = record.alternate_content_source.content_type
+          if product.acs_compatible_repositories.with_type(content_type).empty?
+            record.errors.add(attribute, _("%{name} has no %{type} repositories with upstream URLs to add to the alternate content source.") % { name: product.name, type: content_type })
           end
         end
       end

data/app/lib/katello/validators/container_image_name_validator.rb

@@ -8,7 +8,7 @@ module Katello
       end
 
       def self.validate_name(name)
-        if name.empty? || name.length > 255 || !/\A([a-z0-9]+[a-z0-9\-\_\.]*)+(\/[a-z0-9]+[a-z0-9\-\_\.]*)*\z/.match?(name)
+        if name.empty? || name.length > 255 || !/\A([a-z0-9]+[a-z0-9\-_.]*)+(\/[a-z0-9]+[a-z0-9\-_.]*)*\z/.match?(name)
           return false
         end
         true

data/app/lib/katello/validators/katello_name_format_validator.rb

@@ -13,8 +13,8 @@ module Katello
       end
 
       def self.validate_length(record, attribute, value, min_length = 1)
-        if value
-          record.errors[attribute] << _("must contain at least %s character") % min_length unless value.length >= min_length
+        if value && !(value.length >= min_length)
+          record.errors[attribute] << _("must contain at least %s character") % min_length
         end
       end
     end

data/app/lib/katello/validators/no_trailing_space_validator.rb

@@ -6,8 +6,8 @@ module Katello
       end
 
       def self.validate_trailing_space(record, attribute, value)
-        if value
-          record.errors[attribute] << _("must not contain leading or trailing white spaces.") unless value.strip == value
+        if value && !(value.strip == value)
+          record.errors[attribute] << _("must not contain leading or trailing white spaces.")
         end
       end
     end

data/app/lib/katello/validators/prior_validator.rb

@@ -7,8 +7,8 @@ module Katello
         # this is because in v1.0 we want
         # prior to have only one child (unless its the Library)
         ancestor = record.prior
-        if ancestor && !ancestor.library?
-          record.errors[:prior] << _("prior environment can only have one child") if ancestor.successors.count == 1 && !ancestor.successors.include?(record)
+        if ancestor && !ancestor.library? && (ancestor.successors.count == 1 && !ancestor.successors.include?(record))
+          record.errors[:prior] << _("prior environment can only have one child")
         end
       end
     end

data/app/lib/katello/validators/product_unique_attribute_validator.rb

@@ -12,10 +12,8 @@ module Katello
       def unique_attribute?(record, attribute, value)
         unique = true
 
-        if record.provider && !record.provider.redhat_provider? && record.send("#{attribute}_changed?")
-          if Product.in_org(record.provider.organization).where(attribute => value).exists?
-            unique = false
-          end
+        if record.provider && !record.provider.redhat_provider? && record.send("#{attribute}_changed?") && Product.in_org(record.provider.organization).where(attribute => value).exists?
+          unique = false
         end
 
         unique

data/app/models/katello/activation_key.rb

@@ -182,12 +182,10 @@ module Katello
     end
 
     def validate_destroyable!
-      unless organization.being_deleted?
-        if Parameter.where(name: 'kt_activation_keys').pluck(:value).any? { |value| value.split(",").include?(name) }
-          fail _("This activation key is associated to one or more Hosts/Hostgroups. "\
-                  "Search and unassociate Hosts/Hostgroups using params.kt_activation_keys ~ \"%{name}\" "\
-                  "before deleting." % {name: name})
-        end
+      if !organization.being_deleted? && Parameter.where(name: 'kt_activation_keys').pluck(:value).any? { |value| value.split(",").include?(name) }
+        fail _("This activation key is associated to one or more Hosts/Hostgroups. "\
+                "Search and unassociate Hosts/Hostgroups using params.kt_activation_keys ~ \"%{name}\" "\
+                "before deleting." % {name: name})
       end
       true
     end

data/app/models/katello/alternate_content_source.rb

@@ -54,7 +54,7 @@ module Katello
     validates :content_type, inclusion: {
       in: ->(_) { RepositoryTypeManager.defined_repository_types.keys & CONTENT_TYPES },
       allow_blank: false,
-      message: ->(_, _) { _("is not allowed for ACS. Must be one of the following: %s") % (RepositoryTypeManager.defined_repository_types.keys & CONTENT_TYPES).join(',') }
+      message: ->(_, _) { _("is not allowed for ACS. Must be one of the following: %s") % (RepositoryTypeManager.defined_repository_types.keys & CONTENT_TYPES).sort.join(',') }
     }
     validates :content_type, if: -> { rhui? }, inclusion: {
       in: [::Katello::Repository::YUM_TYPE],

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

@@ -6,8 +6,7 @@ module Katello
 
     module ClassMethods
       def resolvable
-        relation = joins_authorized(::Host::Managed, :edit_hosts)
-        relation
+        joins_authorized(::Host::Managed, :edit_hosts)
       end
     end
   end

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

@@ -64,7 +64,7 @@ module Katello
         sorted_substitutions = substitutions.sort_by { |k, _| k.to_s }.map(&:last)
         repo_name_parts = [content.name,
                            sorted_substitutions].flatten.compact
-        repo_name_parts.join(" ").gsub(/[^a-z0-9\-\._ ]/i, "")
+        repo_name_parts.join(" ").gsub(/[^a-z0-9\-._ ]/i, "")
       end
 
       def path
@@ -83,7 +83,7 @@ module Katello
 
       def feed_url
         return if product.organization.cdn_configuration.export_sync?
-        @feed_url ||= if product.cdn_resource&.respond_to?(:repository_url)
+        @feed_url ||= if product.cdn_resource.respond_to?(:repository_url)
                         product.cdn_resource.repository_url(content_label: content.label, arch: arch, major: version[:major], minor: version[:minor])
                       else
                         product.repo_url(path)

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

@@ -85,7 +85,7 @@ module Katello
       end
 
       included do
-        prepend ::ForemanRemoteExecution::HostExtensions if ::Katello.with_remote_execution?
+        prepend ::ForemanRemoteExecution::HostExtensions
         prepend Overrides
 
         delegate :content_source_id, :single_content_view, :single_lifecycle_environment, :default_environment?, :single_content_view_environment?, :multi_content_view_environment?, :kickstart_repository_id, :bound_repositories,
@@ -480,8 +480,10 @@ module Katello
 
       def rhel_eos_schedule_index
         return nil unless probably_rhel?
-        major = operatingsystem.major
+        major = operatingsystem&.major
+        return nil unless major
         return "RHEL#{major}" unless major == "7"
+
         arch_name = architecture&.name
         case arch_name
         when "ppc64le"
@@ -503,53 +505,82 @@ module Katello
         end
       end
 
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/MethodLength
       def yum_names_for_job_template(action:, search:, versions: nil)
         actions = %w(install remove update).freeze
         case action
         when 'install'
-          ::Katello::Rpm.yum_installable_for_host(self).search_for(search).distinct.pluck(:name)
+          yum_installable = ::Katello::Rpm.yum_installable_for_host(self).search_for(search).distinct.pluck(:name)
+          if yum_installable.empty?
+            fail N_("No available packages found for search term '%s'. Check the host's content view environments and already-installed packages.") % search
+          end
+          yum_installable
         when 'remove'
           return [] if search.empty?
 
-          installed_packages.search_for(search).distinct.pluck(:name)
+          yum_removable = installed_packages.search_for(search).distinct.pluck(:name)
+          if yum_removable.empty?
+            fail N_("Cannot remove package(s): This host does not have any installed packages matching the search term '%s'.") % search
+          end
+          yum_removable
         when 'update'
           return [] if search.empty?
 
           versions_by_name_arch = {}
           if versions.present?
             JSON.parse(versions).each do |nvra|
-              nvra =~ /([^\.]*)-[-\.\w]*\.(\w+)/
+              nvra =~ /([^.]*)-[-.\w]*\.(\w+)/
               versions_by_name_arch[[Regexp.last_match(1), Regexp.last_match(2)]] = nvra
             end
           end
           pkg_name_archs = installed_packages.search_for(search).distinct.pluck(:name, :arch)
+          if pkg_name_archs.empty?
+            fail _("Cannot upgrade packages: No installed packages found for search term '%s'") % search
+          end
           upgrades = ::Katello::Rpm.installable_for_hosts([self]).select(:id, :name, :arch, :nvra, :evr).order(evr: :desc).group_by { |i| [i.name, i.arch] }
-          pkg_name_archs.map { |name, arch| versions_by_name_arch[[name, arch]] || upgrades[[name, arch]]&.first&.nvra }.compact
+          result = pkg_name_archs.map { |name, arch| versions_by_name_arch[[name, arch]] || upgrades[[name, arch]]&.first&.nvra }.compact
+          if result.empty?
+            fail _("No upgradable packages found for search term '%s'. The host may already have the latest version(s) installed.") % search
+          end
+          result
         else
           fail ::Foreman::Exception.new(N_("package_names_for_job_template: Action must be one of %s"), actions.join(', '))
         end
       end
+      # rubocop:enable Metrics/CyclomaticComplexity
 
       def deb_names_for_job_template(action:, search:)
         actions = %w(install remove update).freeze
         case action
         when 'install'
-          ::Katello::Deb.apt_installable_for_host(self).search_for(search).distinct.pluck(:name)
+          deb_installable = ::Katello::Deb.apt_installable_for_host(self).search_for(search).distinct.pluck(:name)
+          if deb_installable.empty?
+            fail _("No available debs found for search term '%s'. Check the host's content view environments and already-installed debs.") % search
+          end
+          deb_installable
         when 'remove'
           return [] if search.empty?
 
           installed_debs.search_for(search).distinct.pluck(:name)
         when 'update'
           return [] if search.empty?
-
-          installed_debs.search_for(search).distinct.pluck(:name)
+          deb_results = installed_debs.search_for(search).distinct.pluck(:name)
+          if deb_results.empty?
+            fail _("No installed debs found for search term '%s'") % search
+          end
+          deb_results
         else
           fail ::Foreman::Exception.new(N_("deb_names_for_job_template: Action must be one of %s"), actions.join(', '))
         end
       end
 
       def advisory_ids(search:)
-        ::Katello::Erratum.installable_for_hosts([self]).search_for(search).pluck(:errata_id)
+        ids = ::Katello::Erratum.installable_for_hosts([self]).search_for(search).pluck(:errata_id)
+        if ids.empty?
+          fail _("Cannot install errata: No installable errata found for search term '%s'") % search
+        end
+        ids
       end
 
       def filtered_entitlement_quantity_consumed(pool)

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

@@ -39,10 +39,8 @@ module Katello
           self.medium = nil
         end
 
-        if content_facet&.kickstart_repository_id && !matching_kickstart_repository?(content_facet)
-          if (equivalent = equivalent_kickstart_repository)
-            self.content_facet.kickstart_repository_id = equivalent[:id]
-          end
+        if content_facet&.kickstart_repository_id && !matching_kickstart_repository?(content_facet) && (equivalent = equivalent_kickstart_repository)
+          self.content_facet.kickstart_repository_id = equivalent[:id]
         end
       end
 

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

@@ -16,10 +16,8 @@ module Katello
       end
 
       def reset_settings
-        if saved_change_to_attribute?(:title)
-          if ::Setting[:default_location_subscribed_hosts] == self.title_before_last_save
-            ::Setting[:default_location_subscribed_hosts] = self.title
-          end
+        if saved_change_to_attribute?(:title) && (::Setting[:default_location_subscribed_hosts] == self.title_before_last_save)
+          ::Setting[:default_location_subscribed_hosts] = self.title
         end
       end
 

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

@@ -6,33 +6,101 @@ module Katello
       REDHAT_ATOMIC_HOST_DISTRO_NAME = "Red Hat Enterprise Linux Atomic Host".freeze
       REDHAT_ATOMIC_HOST_OS = "RedHat_Enterprise_Linux_Atomic_Host".freeze
 
+      DEBIAN_DEFAULT_PROVISIONING_TEMPLATE = "Preseed default %{template_kind_name}".freeze
+      DEBIAN_DEFAULT_PTABLE = "Preseed default".freeze
+
+      SUSE_DEFAULT_PROVISIONING_TEMPLATE = "AutoYaST default %{template_kind_name}".freeze
+      SUSE_DEFAULT_PTABLE = "AutoYaST entire SCSI disk".freeze
+
       included do
         after_create :assign_templates!
         before_create :set_atomic_attributes, :if => proc { |os| os.name == ::Operatingsystem::REDHAT_ATOMIC_HOST_OS }
       end
 
-      def assign_templates!
-        # Automatically assign default templates
-        if self.family == 'Redhat'
-          TemplateKind.all.each do |kind|
-            if name == ::Operatingsystem::REDHAT_ATOMIC_HOST_OS && kind.name == "provision"
-              provisioning_template_name = Setting["katello_default_atomic_provision"]
-            else
-              provisioning_template_name = Setting["katello_default_#{kind.name}"]
-            end
+      def find_related_os
+        Operatingsystem.unscoped.where(name: self.name).order(major: :desc, minor: :desc).where.not(id: self.id)
+      end
+
+      def assign_related_os_templates
+        all_related_os = find_related_os
+        return false if all_related_os.nil?
+
+        boot_loader_template_kinds = TemplateKind.where(name: ["PXELinux", "PXEGrub", "PXEGrub2", "iPXE"]).pluck(:id)
+        provision_template_kinds = TemplateKind.where(name: ["provision", "finish"]).pluck(:id)
 
-            if (template = ProvisioningTemplate.unscoped.find_by_name(provisioning_template_name))
-              provisioning_templates << template unless provisioning_templates.include?(template)
-              if OsDefaultTemplate.where(:template_kind_id => kind.id, :operatingsystem_id => id).empty?
-                OsDefaultTemplate.create(:template_kind_id => kind.id, :provisioning_template_id => template.id, :operatingsystem_id => id)
-              end
+        all_related_os.each do |related_os|
+          next if related_os.provisioning_templates.empty? || related_os.ptables.empty?
+          next if related_os.provisioning_templates.where(template_kind_id: boot_loader_template_kinds).size == 0
+          next if related_os.provisioning_templates.where(template_kind_id: provision_template_kinds).size == 0
+
+          Rails.logger.info "Using operating system #{related_os.name} (major: #{related_os.major}, minor: #{related_os.minor}) " \
+                            "as a template source for the new OS #{name} (major: #{major}, minor: #{minor})."
+
+          related_os.ptables.each do |ptable|
+            ptables << ptable unless ptables.include?(ptable)
+          end
+
+          related_os.provisioning_templates.each do |template|
+            provisioning_templates << template unless provisioning_templates.include?(template)
+            OsDefaultTemplate.where(:operatingsystem_id => related_os.id, :provisioning_template_id => template.id).each do |os_default_temp|
+              OsDefaultTemplate.create(:template_kind_id => os_default_temp.template_kind_id,
+                                       :provisioning_template_id => os_default_temp.provisioning_template_id,
+                                       :operatingsystem_id => id)
             end
           end
+          return true
+        end
+        false
+      end
+
+      def provisioning_template_name_for_os(template_kind_name)
+        case self.family
+        when 'Redhat'
+          if name == ::Operatingsystem::REDHAT_ATOMIC_HOST_OS && template_kind_name == "provision"
+            Setting["katello_default_atomic_provision"]
+          else
+            Setting["katello_default_#{template_kind_name}"]
+          end
+        when 'Debian'
+          format(DEBIAN_DEFAULT_PROVISIONING_TEMPLATE, template_kind_name: template_kind_name)
+        when 'Suse'
+          format(SUSE_DEFAULT_PROVISIONING_TEMPLATE, template_kind_name: template_kind_name)
+        end
+      end
 
-          if (ptable = Ptable.unscoped.find_by_name(Setting["katello_default_ptable"]))
-            ptables << ptable unless ptables.include?(ptable)
+      def partition_table_name_for_os
+        case self.family
+        when 'Redhat'
+          Setting["katello_default_ptable"]
+        when 'Debian'
+          DEBIAN_DEFAULT_PTABLE
+        when 'Suse'
+          SUSE_DEFAULT_PTABLE
+        end
+      end
+
+      def assign_templates!
+        if [ 'Suse', 'Debian' ].include?(self.family) && assign_related_os_templates
+          return
+        end
+
+        # Automatically assign default templates
+        TemplateKind.all.each do |kind|
+          provisioning_template_name = provisioning_template_name_for_os(kind.name)
+          next if provisioning_template_name.nil?
+          if (template = ProvisioningTemplate.unscoped.find_by_name(provisioning_template_name))
+            provisioning_templates << template unless provisioning_templates.include?(template)
+            if OsDefaultTemplate.where(:template_kind_id => kind.id, :operatingsystem_id => id).empty?
+              OsDefaultTemplate.create(:template_kind_id => kind.id, :provisioning_template_id => template.id, :operatingsystem_id => id)
+            end
           end
         end
+
+        partition_table_name = partition_table_name_for_os
+        return if partition_table_name.nil?
+        if (ptable = Ptable.unscoped.find_by_name(partition_table_name)) && !ptables.include?(ptable)
+          ptables << ptable
+        end
       end
 
       def set_atomic_attributes