katello 3.0.0.rc1 → 3.0.0.rc2

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

@@ -65,6 +65,10 @@ module Katello
         super
       end
 
+      def displayable_product_contents
+        self.productContent.select(&:displayable?)
+      end
+
       def orphaned?
         self.provider.redhat_provider? && self.certificate.nil?
       end

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

@@ -47,7 +47,7 @@ module Katello
         cp_product_ids = products.map { |product| product["id"] }
         cp_product_ids << self.product_id if self.product_id
         cp_product_ids.each do |cp_id|
-          product = ::Katello::Product.where(:cp_id => cp_id)
+          product = ::Katello::Product.where(:cp_id => cp_id, :organization_id => self.organization_id)
           if product.any?
             ::Katello::SubscriptionProduct.where(:subscription_id => self.id, :product_id => product.first.id).first_or_create
           end

data/app/models/katello/glue/pulp/repo.rb

@@ -130,7 +130,7 @@ module Katello
           Runcible::Models::IsoImporter.new(importer_ssl_options(capsule).merge(:feed => importer_feed_url(capsule)))
         when Repository::PUPPET_TYPE
           options = {}
-          options[:feed] = importer_feed_url(capsule) if self.respond_to?(:url)
+          options[:feed] = importer_feed_url(capsule)
           Runcible::Models::PuppetImporter.new(options)
         when Repository::DOCKER_TYPE
           options = {}
@@ -203,7 +203,7 @@ module Katello
         end
       end
 
-      def generate_distributors
+      def generate_distributors(capsule = false)
         case self.content_type
         when Repository::YUM_TYPE
           yum_dist_id = self.pulp_id
@@ -215,7 +215,8 @@ module Katello
           clone_dist = Runcible::Models::YumCloneDistributor.new(:id => "#{self.pulp_id}_clone",
                                                                  :destination_distributor_id => yum_dist_id)
           export_dist = Runcible::Models::ExportDistributor.new(false, false, self.relative_path)
-          distributors = [yum_dist, clone_dist, export_dist]
+          distributors = [yum_dist, export_dist]
+          distributors << clone_dist unless capsule
         when Repository::FILE_TYPE
           dist = Runcible::Models::IsoDistributor.new(true, true)
           dist.auto_publish = true
@@ -777,8 +778,35 @@ module Katello
         end
       end
 
+      def distributors_match?(capsule_distributors)
+        generated_distributors = self.generate_distributors(true).map(&:as_json)
+        capsule_distributors.each do |dist|
+          dist.merge!(dist["config"])
+          dist.delete("config")
+        end
+
+        config_check = generated_distributors.any? do |gen_dist|
+          capsule_distributors.any? do |cap_dist|
+            (gen_dist.to_a - cap_dist.to_a).empty?
+          end
+        end
+        equal_amount_check = generated_distributors.count == capsule_distributors.count
+        config_check && equal_amount_check
+      end
+
+      def importer_matches?(capsule_importer)
+        generated_importer = self.generate_importer(true).as_json
+        (generated_importer.to_a - capsule_importer.to_a).empty?
+      end
+
       protected
 
+      def object_to_hash(object)
+        hash = {}
+        object.instance_variables.each { |var| hash[var.to_s.delete("@")] = object.instance_variable_get(var) }
+        hash
+      end
+
       def _get_most_recent_sync_status
         begin
           history = Katello.pulp_server.extensions.repository.sync_status(pulp_id)

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

@@ -52,22 +52,34 @@ module Katello
 
       def import_applicability(partial = false)
         facet = self
+        errata_uuids = ::Katello::Pulp::Consumer.new(self.uuid).applicable_errata_ids
         ::Katello::Util::Support.active_record_retry do
+          if partial
+            consumer_uuids = applicable_errata.pluck("#{Erratum.table_name}.uuid")
+            to_remove = consumer_uuids - errata_uuids
+            to_add = errata_uuids - consumer_uuids
+          else
+            to_add = errata_uuids
+            to_remove = nil
+            Katello::ContentFacetErratum.where(:content_facet_id => facet.id).delete_all
+          end
+
           ActiveRecord::Base.transaction do
-            errata_uuids = ::Katello::Pulp::Consumer.new(self.uuid).applicable_errata_ids
-            if partial
-              consumer_uuids = applicable_errata.pluck("#{Erratum.table_name}.uuid")
-              to_remove = consumer_uuids - errata_uuids
-              to_add = errata_uuids - consumer_uuids
-            else
-              to_add = errata_uuids
-              to_remove = nil
-              Katello::ContentFacetErratum.where(:content_facet_id => facet.id).delete_all
-            end
             insert_errata_applicability(to_add) unless to_add.blank?
             remove_errata_applicability(to_remove) unless to_remove.blank?
           end
         end
+        self.update_errata_status
+      end
+
+      def self.in_content_view_version_environments(version_environments)
+        #takes a structure of [{:content_view_version => ContentViewVersion, :environments => [KTEnvironment]}]
+        queries = version_environments.map do |version_environment|
+          version = version_environment[:content_view_version]
+          env_ids = version_environment[:environments].map(&:id)
+          "(#{table_name}.content_view_id = #{version.content_view_id} AND #{table_name}.lifecycle_environment_id IN (#{env_ids.join(',')}))"
+        end
+        where(queries.join(" OR "))
       end
 
       def self.with_non_installable_errata(errata)
@@ -81,13 +93,19 @@ module Katello
       end
 
       def self.with_installable_errata(errata)
-        non_installable = Katello::Host::ContentFacet.with_non_installable_errata(errata)
-        subquery = Katello::Erratum.select("#{Katello::Erratum.table_name}.id").installable_for_hosts.
-            where("#{Katello::ContentFacetRepository.table_name}.content_facet_id = #{Katello::Host::ContentFacet.table_name}.id")
+        joins_installable_errata.where("#{Katello::Erratum.table_name}.id" => errata)
+      end
 
-        query = self.joins(:applicable_errata).where("#{Katello::Erratum.table_name}.id" => errata).where("#{Katello::Erratum.table_name}.id" => subquery)
-        query = query.where.not("#{Katello::Host::ContentFacet.table_name}.id" => non_installable) unless non_installable.empty?
-        query.uniq
+      def self.joins_installable_errata
+        facet_repository = Katello::ContentFacetRepository.table_name
+        facet_errata = Katello::ContentFacetErratum.table_name
+        repository_erratum = Katello::RepositoryErratum.table_name
+        erratum = Katello::Erratum.table_name
+
+        self.joins("INNER JOIN #{facet_repository} on #{facet_repository}.content_facet_id = #{table_name}.id",
+                   "INNER JOIN #{repository_erratum} on #{repository_erratum}.repository_id = #{facet_repository}.repository_id",
+                   "INNER JOIN #{erratum} on #{erratum}.id = #{repository_erratum}.erratum_id",
+                   "INNER JOIN #{facet_errata} on #{facet_errata}.erratum_id = #{erratum}.id")
       end
 
       def content_view_version
@@ -98,6 +116,15 @@ module Katello
         self.content_view.version(self.lifecycle_environment).available_releases
       end
 
+      def katello_agent_installed?
+        self.host.installed_packages.where("#{Katello::InstalledPackage.table_name}.name" => 'katello-agent').any?
+      end
+
+      def update_errata_status
+        host.get_status(::Katello::ErrataStatus).refresh!
+        host.refresh_global_status!
+      end
+
       private
 
       def insert_errata_applicability(uuids)

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

@@ -44,6 +44,7 @@ module Katello
 
       def update_subscription_status
         host.get_status(::Katello::SubscriptionStatus).refresh!
+        host.refresh_global_status!
       end
 
       def self.new_host_from_facts(facts, org, location)

data/app/models/katello/pool.rb

@@ -38,21 +38,16 @@ module Katello
     DAYS_EXPIRING_SOON = 120
     DAYS_RECENTLY_EXPIRED = 30
 
-    def self.active(subscriptions)
-      subscriptions.select { |s| s.active }
+    def active?
+      active
     end
 
-    def self.expiring_soon(subscriptions)
-      subscriptions.select { |s| (s.end_date.to_date - Date.today) <= DAYS_EXPIRING_SOON }
+    def expiring_soon?
+      (end_date.to_date - Date.today) <= DAYS_EXPIRING_SOON
     end
 
-    def self.recently_expired(subscriptions)
-      today_date = Date.today
-
-      subscriptions.select do |s|
-        end_date = s.end_date.to_date
-        today_date >= end_date && today_date - end_date <= DAYS_RECENTLY_EXPIRED
-      end
+    def recently_expired?
+      Date.today >= end_date.to_date && (Date.today - end_date.to_date) <= DAYS_RECENTLY_EXPIRED
     end
 
     def quantity_available

data/app/models/katello/repository.rb

@@ -33,7 +33,7 @@ module Katello
              :dependent   => :restrict_with_exception,
              :foreign_key => :library_instance_id
     has_many :content_view_repositories, :class_name => "Katello::ContentViewRepository",
-                                         :dependent => :destroy
+                                         :dependent => :destroy, :inverse_of => :repository
     has_many :content_views, :through => :content_view_repositories
 
     has_many :repository_errata, :class_name => "Katello::RepositoryErratum", :dependent => :destroy
@@ -90,7 +90,10 @@ module Katello
       :allow_blank => false,
       :message => ->(_, _) { _("must be one of the following: %s") % Katello::RepositoryTypeManager.repository_types.keys.join(', ') }
     }
-    validates :download_policy, inclusion: { in: ::Runcible::Models::YumImporter::DOWNLOAD_POLICIES }, if: :yum?
+    validates :download_policy, inclusion: {
+      :in => ::Runcible::Models::YumImporter::DOWNLOAD_POLICIES,
+      :message => _("must be one of the following: %s") % ::Runcible::Models::YumImporter::DOWNLOAD_POLICIES.join(', ')
+    }, if: :yum?
     validate :ensure_no_download_policy, if: ->(repo) { !repo.yum? }
     validate :ensure_valid_docker_attributes, :if => :docker?
     validate :ensure_docker_repo_unprotected, :if => :docker?
@@ -463,18 +466,6 @@ module Katello
       end
     end
 
-    def systems_with_applicability
-      ::Katello::System.joins(:bound_repositories).
-              where("#{::Katello::Repository.table_name}.id" => (self.clones.pluck(:id) + [self.id]))
-    end
-
-    def import_system_applicability
-      fail "Can only calculate applicability for Library repositories" unless self.content_view.default?
-      systems_with_applicability.find_each do |system|
-        system.import_applicability
-      end
-    end
-
     def ostree_branch_names
       self.ostree_branches.map(&:name)
     end
@@ -554,6 +545,20 @@ module Katello
       end
     end
 
+    def import_host_applicability
+      self.hosts_with_applicability.find_each do |host|
+        begin
+          host.content_facet.import_applicability if host.content_facet.try(:uuid)
+        rescue => e
+          Rails.logger.error("Could not import applicability for #{host.name}: #{e}")
+        end
+      end
+    end
+
+    def hosts_with_applicability
+      ::Host.joins(:content_facet => :bound_repositories).where("#{Katello::Repository.table_name}.id" => (self.clones.pluck(:id) + [self.id]))
+    end
+
     protected
 
     def removable_unit_association
@@ -579,7 +584,7 @@ module Katello
     end
 
     def ensure_valid_docker_attributes
-      if url.blank? || docker_upstream_name.blank?
+      if library_instance? && (url.blank? || docker_upstream_name.blank?)
         errors.add(:base, N_("Repository URL or Upstream Name is empty. Both are required for syncing from the upstream."))
       end
     end

data/app/models/katello/subscription.rb

@@ -10,8 +10,22 @@ module Katello
 
     belongs_to :organization, :class_name => "Organization", :inverse_of => :subscriptions
 
+    scope :in_organization, ->(org) { where(:organization => org) }
+
     def redhat?
       self.products.any? { |product| product.redhat? }
     end
+
+    def active?
+      pools.any?(&:active?)
+    end
+
+    def expiring_soon?
+      pools.any?(&:expiring_soon?)
+    end
+
+    def recently_expired?
+      pools.any?(&:recently_expired?)
+    end
   end
 end

data/app/models/katello/sync_plan.rb

@@ -53,6 +53,11 @@ module Katello
       date_obj.strftime('%I:%M %p')
     end
 
+    def plan_date_time(localtime = true)
+      date_obj = localtime ? self.zone_converted : self.sync_date
+      date_obj.strftime('%m/%d/%Y %I:%M:%p')
+    end
+
     def schedule_format
       if (self.interval != DURATION[self.interval])
         format = self.sync_date.iso8601 << "/P" << DURATION[self.interval]

data/app/models/katello/system.rb

@@ -65,16 +65,6 @@ module Katello
       where(:environment_id => organization.kt_environments.pluck(:id))
     end
 
-    def self.in_content_view_version_environments(version_environments)
-      #takes a structure of [{:content_view_version => ContentViewVersion, :environments => [KTEnvironment]}]
-      queries = version_environments.map do |version_environment|
-        version = version_environment[:content_view_version]
-        env_ids = version_environment[:environments].map(&:id)
-        "(#{table_name}.content_view_id = #{version.content_view_id} AND #{table_name}.environment_id IN (#{env_ids.join(',')}))"
-      end
-      where(queries.join(" OR "))
-    end
-
     def self.uuids_to_ids(uuids)
       systems = by_uuids(uuids)
       ids_not_found = Set.new(uuids).subtract(systems.pluck(:uuid))

data/app/models/setting/katello.rb

@@ -4,13 +4,14 @@ class Setting::Katello < Setting
 
     self.transaction do
       [
-        self.set('default_cdn_ostree_branch_name', N_("Name of the default OSTree branch when enabling a Red Hat OSTree repo"), 'rhel-atomic-host/7/x86_64/standard'),
         self.set('katello_default_provision', N_("Default provisioning template for new Operating Systems"), 'Katello Kickstart Default'),
         self.set('katello_default_finish', N_("Default finish template for new Operating Systems"), 'Katello Kickstart Default Finish'),
         self.set('katello_default_user_data', N_("Default user data for new Operating Systems"), 'Katello Kickstart Default User Data'),
         self.set('katello_default_PXELinux', N_("Default PXElinux template for new Operating Systems"), 'Kickstart default PXELinux'),
         self.set('katello_default_iPXE', N_("Default iPXE template for new Operating Systems"), 'Kickstart default iPXE'),
         self.set('katello_default_ptable', N_("Default partitioning table for new Operating Systems"), 'Kickstart default'),
+        self.set('katello_default_kexec', N_("Default kexec template for new Operating Systems"), 'Discovery Red Hat kexec'),
+        self.set('katello_default_atomic_provision', N_("Default provisioning template for new Atomic Operating Systems"), 'Katello Atomic Kickstart Default'),
         self.set('content_action_accept_timeout', N_("Time in seconds to wait for a Host to pickup a remote action"), 20),
         self.set('content_action_finish_timeout', N_("Time in seconds to wait for a Host to finish a remote action"), 3600),
         self.set('restrict_composite_view', N_("If set to true, a composite content view may not be published or "\

data/app/presenters/katello/product_content_presenter.rb

@@ -0,0 +1,16 @@
+module Katello
+  class ProductContentPresenter
+    attr_accessor :product_content, :overrides
+    delegate :content, :enabled, :product, :to => :product_content
+
+    def initialize(product_content, overrides)
+      @product_content = product_content
+      @overrides = overrides
+    end
+
+    def enabled_override
+      override = overrides.find { |pc| pc[:contentLabel] == content.label }
+      override.nil? ? 'default' : override[:value]
+    end
+  end
+end

data/app/services/katello/candlepin/consumer.rb

@@ -7,12 +7,18 @@ module Katello
       ENTITLEMENTS_PARTIAL = 'partial'
       ENTITLEMENTS_INVALID = 'invalid'
 
+      SYSTEM = "system"
+      HYPERVISOR = "hypervisor"
+      CANDLEPIN = "candlepin"
+      CP_TYPES = [SYSTEM, HYPERVISOR, CANDLEPIN]
+
       lazy_accessor :entitlements, :initializer => lambda { |_s| Resources::Candlepin::Consumer.entitlements(uuid) }
       lazy_accessor :events, :initializer => lambda { |_s| Resources::Candlepin::Consumer.events(uuid) }
       lazy_accessor :consumer_attributes, :initializer => lambda { |_s| Resources::Candlepin::Consumer.get(uuid) }
       lazy_accessor :installed_products, :initializer => lambda { |_s| consumer_attributes['installedProducts'] }
       lazy_accessor :available_pools, :initializer => lambda { |_s| Resources::Candlepin::Consumer.available_pools(uuid, false) }
       lazy_accessor :all_available_pools, :initializer => lambda { |_s| Resources::Candlepin::Consumer.available_pools(uuid, true) }
+      lazy_accessor :content_overrides, :initializer => lambda { |_s| Resources::Candlepin::Consumer.content_overrides(uuid) }
 
       attr_accessor :uuid
 
@@ -91,10 +97,23 @@ module Katello
 
       def virtual_host
         if virtual_host_info = Resources::Candlepin::Consumer.virtual_host(self.uuid)
-          Katello::Host::SubscriptionFacet.find_by_uuid(virtual_host_info[:uuid])
+          ::Host.joins(:subscription_facet).where("#{Katello::Host::SubscriptionFacet.table_name}.uuid" => virtual_host_info[:uuid]).first
         end
       end
 
+      def set_content_override(content_label, name, value = nil)
+        Resources::Candlepin::Consumer.update_content_override(self.uuid, content_label, name, value)
+      end
+
+      def products
+        pool_ids = self.entitlements.map { |entitlement| entitlement['pool']['id'] }
+        Katello::Product.joins(:subscriptions => :pools).where("#{Katello::Pool.table_name}.cp_id" => pool_ids).enabled.uniq
+      end
+
+      def available_product_content
+        products.flat_map(&:available_content)
+      end
+
       def compliance_reasons
         Resources::Candlepin::Consumer.compliance(uuid)['reasons'].map do |reason|
           "#{reason['attributes']['name']}: #{reason['message']}"
@@ -102,6 +121,8 @@ module Katello
       end
 
       def self.distribution_to_puppet_os(name)
+        return ::Operatingsystem::REDHAT_ATOMIC_HOST_OS if name == ::Operatingsystem::REDHAT_ATOMIC_HOST_DISTRO_NAME
+
         name = name.downcase
         if name =~ /red\s*hat/
           'RedHat'

data/app/services/katello/repository_type_manager.rb

@@ -28,6 +28,10 @@ module Katello
       def find(repository_type)
         repository_types[repository_type.to_s]
       end
+
+      def enabled?(repository_type)
+        find(repository_type).present?
+      end
     end
   end
 end

data/app/views/dashboard/_content_views_widget.html.erb

@@ -9,7 +9,7 @@
 <% if histories.empty? %>
   <p class="ca"><%= _("No content view history events found.") %></p>
 <% else %>
-  <table class="table table-striped ellipsis table-bordered">
+  <table class="table table-fixed table-striped table-bordered">
     <thead>
       <tr>
         <th>Content View</th>
@@ -20,7 +20,7 @@
     <tbody>
       <% histories.each do |history| %>
         <tr>
-          <td>
+          <td class='ellipsis'>
             <a href="/content_views/<%= history.content_view_version.content_view.id %>/versions/<%= history.content_view_version.id %>/details">
               <%= history.content_view_version.content_view.name %> <%= history.content_view_version.version %>
             </a>