katello 3.18.0.rc1 → 4.0.0.rc1

data/app/models/katello/content_view_environment.rb

@@ -2,8 +2,8 @@ module Katello
   class ContentViewEnvironment < Katello::Model
     audited :associated_with => :content_view
     include ForemanTasks::Concerns::ActionSubject
-    include Glue::Candlepin::Environment if SETTINGS[:katello][:use_cp]
-    include Glue if SETTINGS[:katello][:use_cp]
+    include Glue::Candlepin::Environment
+    include Glue
     include Authorization::ContentViewEnvironment
 
     belongs_to :content_view, :class_name => "Katello::ContentView", :inverse_of => :content_view_environments

data/app/models/katello/content_view_filter.rb

@@ -1,5 +1,6 @@
 module Katello
   class ContentViewFilter < Katello::Model
+    include Authorization::ContentViewFilter
     audited :associations => [:repositories]
     DOCKER = 'docker'.freeze
     RPM = Rpm::CONTENT_TYPE
@@ -157,6 +158,10 @@ module Katello
       if self.content_view.composite?
         errors.add(:base, _("cannot contain filters if composite view"))
       end
+
+      if self.content_view.import_only?
+        errors.add(:base, _("cannot add filter to import-only view"))
+      end
     end
 
     def validate_filter_repos(errors, content_view)

data/app/models/katello/content_view_history.rb

@@ -32,7 +32,8 @@ module Katello
       publish: 1,
       promotion: 2,
       removal: 3,
-      export: 4
+      export: 4,
+      importing: 5
     }
 
     def content_view

data/app/models/katello/content_view_package_filter.rb

@@ -43,7 +43,7 @@ module Katello
     end
 
     def self.generate_rpm_clauses(package_filenames = [])
-      { 'filename' => { "$in" => package_filenames } } unless package_filenames.empty?
+      { 'filename' => { "$in" => package_filenames.sort } } unless package_filenames.empty?
     end
 
     def applicable_rpms

data/app/models/katello/content_view_puppet_environment.rb

@@ -1,8 +1,8 @@
 module Katello
   class ContentViewPuppetEnvironment < Katello::Model
     include ForemanTasks::Concerns::ActionSubject
-    include Glue::Pulp::Repo if SETTINGS[:katello][:use_pulp]
-    include Glue if SETTINGS[:katello][:use_pulp]
+    include Glue::Pulp::Repo
+    include Glue
 
     belongs_to :environment, :class_name => "Katello::KTEnvironment",
                              :inverse_of => :content_view_puppet_environments

data/app/models/katello/content_view_puppet_module.rb

@@ -17,6 +17,8 @@ module Katello
 
     before_validation :set_attributes
 
+    validate :import_only_content_view
+
     def puppet_module
       PuppetModule.find_by(:pulp_id => self.uuid)
     end
@@ -42,6 +44,12 @@ module Katello
 
     private
 
+    def import_only_content_view
+      if self.content_view.import_only?
+        errors.add(:base, "Cannot add puppet modules to an import-only content view.")
+      end
+    end
+
     def set_attributes
       if self.uuid.present?
         puppet_module = PuppetModule.with_identifiers(self.uuid).first

data/app/models/katello/content_view_repository.rb

@@ -7,6 +7,10 @@ module Katello
                                 Repository::DEB_TYPE
                                ].freeze
 
+    ALLOWED_IMPORT_REPOSITORY_TYPES = [
+      Repository::YUM_TYPE
+    ].freeze
+
     belongs_to :content_view, :inverse_of => :content_view_repositories,
                               :class_name => "Katello::ContentView"
     belongs_to :repository, :inverse_of => :content_view_repositories,
@@ -27,7 +31,7 @@ module Katello
     end
 
     def ensure_repository_type
-      unless ALLOWED_REPOSITORY_TYPES.include?(repository.content_type)
+      unless allowed_repository_types.include?(repository.content_type)
         errors.add(:base, _("Cannot add %s repositories to a content view.") % repository.content_type)
       end
     end
@@ -41,5 +45,13 @@ module Katello
         errors.add(:base, _("Repositories from published Content Views are not allowed."))
       end
     end
+
+    def allowed_repository_types
+      if self.content_view.import_only?
+        ALLOWED_IMPORT_REPOSITORY_TYPES
+      else
+        ALLOWED_REPOSITORY_TYPES
+      end
+    end
   end
 end

data/app/models/katello/content_view_version.rb

@@ -322,7 +322,8 @@ module Katello
     end
 
     def content_counts_map
-      return {} if content_counts.blank?
+      # if its empty, calculate it on demand
+      update_content_counts! if content_counts.blank?
       counts = Hash[content_counts.map { |key, value| ["#{key}_count", value] }]
       counts.merge("module_stream_count" => counts["modulemd_count"],
                    "package_count" => counts["rpm_count"],

data/app/models/katello/content_view_version_export_history.rb

@@ -2,13 +2,24 @@ module Katello
   class ContentViewVersionExportHistory < Katello::Model
     include Authorization::ContentViewVersionExportHistory
 
+    COMPLETE = "complete".freeze
+    INCREMENTAL = "incremental".freeze
+    EXPORT_TYPES = [COMPLETE, INCREMENTAL].freeze
+
     belongs_to :content_view_version, :class_name => "Katello::ContentViewVersion", :inverse_of => :export_histories
     validates_lengths_from_database
     validates :content_view_version_id, :presence => true
-    validates :destination_server, :presence => true, :uniqueness => { :scope => [:content_view_version_id, :destination_server, :path] }
+    validates :destination_server, :uniqueness => { :scope => [:content_view_version_id, :destination_server, :path] }
+    validates :export_type, :inclusion => { :in => EXPORT_TYPES,
+                                            :allow_blank => false,
+                                            :message => _("Invalid export_type from one of the following: %s" % EXPORT_TYPES.join(', '))
+                                          }
+
     validates :metadata, :presence => true
     serialize :metadata, Hash
 
+    before_validation :set_export_type, :if => -> { export_type.blank? }
+
     scope :with_organization_id, ->(organization_id) do
       where(:content_view_version_id => ContentViewVersion.with_organization_id(organization_id))
     end
@@ -20,5 +31,19 @@ module Katello
     scoped_search :on => :content_view_id, :relation => :content_view_version, :validator => ScopedSearch::Validators::INTEGER, :only_explicit => true
     scoped_search :on => :content_view_version_id, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
     scoped_search :on => :id, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
+    scoped_search :on => :export_type, :rename => :type, :complete_value => EXPORT_TYPES
+
+    def self.latest(content_view, destination_server: nil)
+      where(content_view_version: content_view.versions,
+            destination_server: destination_server).order(:created_at).last
+    end
+
+    def export_type_from_metadata
+      cvve.metadata[:incremental] ? INCREMENTAL : COMPLETE
+    end
+
+    def set_export_type
+      self.export_type = export_type_from_metadata
+    end
   end
 end

data/app/models/katello/erratum.rb

@@ -173,9 +173,11 @@ module Katello
       property :package_names, array_of: String, desc: 'Returns names of packages the errata can be applied to'
       property :cves, array_of: 'ErratumCve', desc: 'Returns CVEs associated with the errata'
       property :reboot_suggested, one_of: [true, false], desc: 'Returns true if reboot is suggested after errata applying, false otherwise'
+      property :title, String, desc: 'Returns the errata title, e.g. "Important: net-snmp security update"'
+      property :summary, String, desc: 'Returns the errata summary, the length can very, it is usually in range of 60 to 1000 characters. It can include empty line characters.'
     end
     class Jail < ::Safemode::Jail
-      allow :errata_id, :errata_type, :issued, :created_at, :severity, :package_names, :cves, :reboot_suggested
+      allow :errata_id, :errata_type, :issued, :created_at, :severity, :package_names, :cves, :reboot_suggested, :title, :summary
     end
   end
 end

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

@@ -92,6 +92,8 @@ module Katello
       end
 
       # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
       def import_data(index_hosts_and_activation_keys = false)
         pool_attributes = {}.with_indifferent_access
         pool_json = self.backend_data

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

@@ -113,12 +113,6 @@ module Katello
         backend_service(capsule).generate_distributors
       end
 
-      def populate_from(repos_map)
-        found = repos_map[self.pulp_id]
-        prepopulate(found) if found
-        !found.nil?
-      end
-
       def package_group_count
         content_unit_counts = 0
         if self.pulp_repo_facts

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

@@ -12,27 +12,6 @@ module Katello
       "#{path_prefix}/#{path}"
     end
 
-    def self.prepopulate!(products, environment, repos = [], content_view = nil)
-      if content_view.nil?
-        if environment.library?
-          content_view = environment.default_content_view
-        else
-          fail "No content view specified for a Non library environment #{environment.inspect}"
-        end
-      end
-
-      items = Katello.pulp_server.extensions.repository.search_by_repository_ids(Repository.in_environment(environment).pluck(:pulp_id))
-      full_repos = {}
-      items.each { |item| full_repos[item["id"]] = item }
-
-      products.each do |prod|
-        prod.repos(environment, content_view).each do |repo|
-          repo.populate_from(full_repos)
-        end
-      end
-      repos.each { |repo| repo.populate_from(full_repos) }
-    end
-
     module InstanceMethods
       def distributions(env)
         to_ret = []
@@ -125,7 +104,7 @@ module Katello
             AND inner_select.resource_id = locks_foreman_tasks_tasks.resource_id")
           .distinct
 
-        max_per_repoid.map { |x| [x.resource_id, x] }.to_h
+        max_per_repoid.index_by { |x| [x.resource_id, x] }
       end
 
       def sync_state_aggregated

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

@@ -282,6 +282,10 @@ module Katello
         name.gsub('_', '-').chomp('.').downcase
       end
 
+      def unsubscribed_hypervisor?
+        self.hypervisor && !self.candlepin_consumer.entitlements?
+      end
+
       def candlepin_consumer
         @candlepin_consumer ||= Katello::Candlepin::Consumer.new(self.uuid, self.host.organization.label)
       end

data/app/models/katello/ping.rb

@@ -5,10 +5,17 @@ module Katello
     PACKAGES = %w(katello candlepin pulp qpid foreman tfm hammer).freeze
 
     class << self
+      def pulpcore_enabled # for downstream 6.9, remove in 6.10
+        SETTINGS[:katello][:use_pulp_2_for_content_type].nil? || (!SETTINGS[:katello][:use_pulp_2_for_content_type][:yum] &&
+        !SETTINGS[:katello][:use_pulp_2_for_content_type][:docker] &&
+        !SETTINGS[:katello][:use_pulp_2_for_content_type][:file]) ||
+        system('systemctl is-enabled pulpcore-api.service')
+      end
+
       def services(capsule_id = nil)
         proxy = fetch_proxy(capsule_id)
         services = [:candlepin, :candlepin_auth, :foreman_tasks, :katello_events, :candlepin_events]
-        services += [:pulp3] if proxy&.pulp3_enabled?
+        services += [:pulp3] if proxy&.pulp3_enabled? && pulpcore_enabled
         if proxy.nil? || proxy.has_feature?(SmartProxy::PULP_NODE_FEATURE) || proxy.has_feature?(SmartProxy::PULP_FEATURE)
           services += [:pulp, :pulp_auth]
         end
@@ -16,9 +23,7 @@ module Katello
         services
       end
 
-      #
       # Calls "status" services in all backend engines.
-      #
       def ping(services: nil, capsule_id: nil)
         services ||= self.services(capsule_id)
         result = {}
@@ -51,7 +56,7 @@ module Katello
         running = status&.dig(:running)
 
         if running
-          result[:message] = "#{status[:processed_count]} Processed, #{status[:failed_count]} Failed"
+          result[:message] = "#{status[:processed_count].to_i} Processed, #{status[:failed_count].to_i} Failed"
         else
           result[:status] = FAIL_RETURN_CODE
           result[:message] = _("Not running")
@@ -60,14 +65,14 @@ module Katello
 
       def ping_katello_events(result)
         exception_watch(result) do
-          status = Katello::EventMonitor::PollerThread.status(refresh: false)
+          status = Katello::EventDaemon::Runner.service_status(:katello_events)
           event_daemon_status(status, result)
         end
       end
 
       def ping_candlepin_events(result)
         exception_watch(result) do
-          status = Katello::CandlepinEventListener.status(refresh: false)
+          status = Katello::EventDaemon::Runner.service_status(:candlepin_events)
           event_daemon_status(status, result)
         end
       end

data/app/models/katello/pool.rb

@@ -22,6 +22,7 @@ module Katello
       where(["end_date < ?", days.to_i.days.from_now.end_of_day])
     end
     scope :upstream, -> { where.not(upstream_pool_id: nil) }
+    scope :redhat, -> { joins(:products).merge(Katello::Product.redhat).distinct }
 
     include Glue::Candlepin::Pool
     include Glue::Candlepin::CandlepinObject
@@ -51,6 +52,10 @@ module Katello
 
     DAYS_RECENTLY_EXPIRED = 30
 
+    def redhat?
+      self.class.redhat.where(:id => self.id).exists?
+    end
+
     def active?
       active
     end

data/app/models/katello/product.rb

@@ -3,9 +3,9 @@ module Katello
     audited
 
     include ForemanTasks::Concerns::ActionSubject
-    include Glue::Candlepin::Product if SETTINGS[:katello][:use_cp]
-    include Glue::Pulp::Repos if SETTINGS[:katello][:use_pulp]
-    include Glue if SETTINGS[:katello][:use_cp] || SETTINGS[:katello][:use_pulp]
+    include Glue::Candlepin::Product
+    include Glue::Pulp::Repos
+    include Glue
 
     include Katello::Authorization::Product
 

data/app/models/katello/repository.rb

@@ -12,9 +12,9 @@ module Katello
 
     include ForemanTasks::Concerns::ActionSubject
     include Glue::Candlepin::Repository
-    include Glue::Pulp::Repo if SETTINGS[:katello][:use_pulp]
+    include Glue::Pulp::Repo
 
-    include Glue if (SETTINGS[:katello][:use_cp] || SETTINGS[:katello][:use_pulp])
+    include Glue
     include Authorization::Repository
     include Katello::Engine.routes.url_helpers
 
@@ -109,6 +109,8 @@ module Katello
     has_many :distribution_references, :class_name => 'Katello::Pulp3::DistributionReference', :foreign_key => :repository_id,
              :dependent => :destroy, :inverse_of => :repository
 
+    has_many :smart_proxy_sync_histories, :class_name => "::Katello::SmartProxySyncHistory", :inverse_of => :repository, :dependent => :delete_all
+
     validates_with Validators::ContainerImageNameValidator, :attributes => :container_repository_name, :allow_blank => false, :if => :docker?
     validates :container_repository_name, :if => :docker?, :uniqueness => {message: ->(object, _data) do
       _("for repository '%{name}' is not unique and cannot be created in '%{env}'. Its Container Repository Name (%{container_name}) conflicts with an existing repository.  Consider changing the Lifecycle Environment's Registry Name Pattern to something more specific.") %
@@ -120,6 +122,8 @@ module Katello
 
     scope :has_url, -> { joins(:root).where.not("#{RootRepository.table_name}.url" => nil) }
     scope :on_demand, -> { joins(:root).where("#{RootRepository.table_name}.download_policy" => ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND) }
+    scope :immediate, -> { joins(:root).where("#{RootRepository.table_name}.download_policy" => ::Runcible::Models::YumImporter::DOWNLOAD_IMMEDIATE) }
+    scope :non_immediate, -> { joins(:root).where.not("#{RootRepository.table_name}.download_policy" => ::Runcible::Models::YumImporter::DOWNLOAD_IMMEDIATE) }
     scope :in_default_view, -> { joins(:content_view_version => :content_view).where("#{Katello::ContentView.table_name}.default" => true) }
     scope :in_non_default_view, -> { joins(:content_view_version => :content_view).where("#{Katello::ContentView.table_name}.default" => false) }
     scope :deb_type, -> { with_type(DEB_TYPE) }
@@ -141,7 +145,7 @@ module Katello
     scoped_search :rename => :product, :on => :name, :relation => :product, :complete_value => true
     scoped_search :rename => :product_id, :on => :id, :relation => :product
     scoped_search :on => :content_type, :relation => :root, :complete_value => -> do
-      Katello::RepositoryTypeManager.repository_types.keys.each_with_object({}) { |value, hash| hash[value.to_sym] = value }
+      Katello::RepositoryTypeManager.repository_types.keys.index_by { |value| value.to_sym }
     end
     scoped_search :on => :content_view_id, :relation => :content_view_repositories, :validator => ScopedSearch::Validators::INTEGER, :only_explicit => true
     scoped_search :on => :distribution_version, :complete_value => true
@@ -152,6 +156,7 @@ module Katello
     scoped_search :on => :redhat, :complete_value => { :true => true, :false => false }, :ext_method => :search_by_redhat
     scoped_search :on => :container_repository_name, :complete_value => true
     scoped_search :on => :description, :relation => :root, :only_explicit => true
+    scoped_search :on => :download_policy, :relation => :root, :only_explicit => true
     scoped_search :on => :name, :relation => :product, :rename => :product_name
     scoped_search :on => :id, :relation => :product, :rename => :product_id, :only_explicit => true
     scoped_search :on => :label, :relation => :root, :complete_value => true, :only_explicit => true
@@ -285,6 +290,10 @@ module Katello
       root.download_policy == Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND
     end
 
+    def immediate?
+      root.download_policy == ::Runcible::Models::YumImporter::DOWNLOAD_IMMEDIATE
+    end
+
     def yum_gpg_key_url
       # if the repo has a gpg key return a url to access it
       if self.root.gpg_key.try(:content).present?
@@ -531,6 +540,30 @@ module Katello
       clone
     end
 
+    def self.synced_on_capsule(smart_proxy)
+      smart_proxy.smart_proxy_sync_histories.map { |sph| sph.repository unless sph.finished_at.nil? }
+    end
+
+    def clear_smart_proxy_sync_histories(smart_proxy = nil)
+      if smart_proxy
+        self.smart_proxy_sync_histories.where(:smart_proxy_id => smart_proxy.id).try(:delete_all)
+      else
+        self.smart_proxy_sync_histories.delete_all
+      end
+    end
+
+    def create_smart_proxy_sync_history(smart_proxy)
+      clear_smart_proxy_sync_histories(smart_proxy)
+      sp_history_args = {
+        :smart_proxy_id => smart_proxy.id,
+        :repository_id => self.id,
+        :started_at => Time.now
+      }
+      sp_history = ::Katello::SmartProxySyncHistory.create sp_history_args
+      sp_history.save!
+      sp_history.id
+    end
+
     def latest_sync_audit
       self.audits.where(:action => AUDIT_SYNC_ACTION).order(:created_at).last
     end

data/app/models/katello/smart_proxy_sync_history.rb

@@ -0,0 +1,8 @@
+module Katello
+  class SmartProxySyncHistory < Katello::Model
+    self.table_name = 'katello_smart_proxy_sync_history'
+
+    belongs_to :smart_proxy, :class_name => "::SmartProxy", :inverse_of => :smart_proxy_sync_histories
+    belongs_to :repository, :class_name => "Katello::Repository", :inverse_of => :smart_proxy_sync_histories
+  end
+end