katello 3.17.0 → 3.18.0

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_export_history.rb

@@ -5,7 +5,9 @@ module Katello
     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 :metadata, :presence => true
+    serialize :metadata, Hash
 
     scope :with_organization_id, ->(organization_id) do
       where(:content_view_version_id => ContentViewVersion.with_organization_id(organization_id))
@@ -18,5 +20,10 @@ 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
+
+    def self.latest(content_view, destination_server: nil)
+      where(content_view_version: content_view.versions,
+            destination_server: destination_server).order(:created_at).last
+    end
   end
 end

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

@@ -21,6 +21,8 @@ module Katello
         lazy_accessor :available, :initializer => lambda { |_s| self.quantity_available }
 
         lazy_accessor :backend_data, :initializer => lambda { |_s| self.class.candlepin_data(self.cp_id) }
+
+        lazy_accessor :consumer_uuids, :initializer => lambda { |_s| Resources::Candlepin::Pool.consumer_uuids(self.cp_id) }
       end
     end
 
@@ -162,27 +164,20 @@ module Katello
       end
 
       def import_hosts
-        uuids = Resources::Candlepin::Pool.consumer_uuids(self.cp_id)
-
-        sub_facet_ids_from_cp, host_ids_from_cp = Katello::Host::SubscriptionFacet.where('uuid in (?)', uuids).pluck([:id, :host_id]).transpose
+        sub_facet_ids_from_cp, host_ids_from_cp = Katello::Host::SubscriptionFacet.where('uuid in (?)', consumer_uuids).pluck(:id, :host_id).transpose
         sub_facet_ids_from_cp ||= []
         host_ids_from_cp ||= []
 
-        sub_facet_ids_from_pool_table = Katello::SubscriptionFacetPool.where(:pool_id => self.id).select(:subscription_facet_id).pluck(:subscription_facet_id)
-        host_ids_from_pool_table = Katello::Host::SubscriptionFacet.where(:id => sub_facet_ids_from_pool_table).pluck(:host_id)
+        sub_facet_ids_from_pool_table, host_ids_from_pool_table = self.subscription_facets.pluck(:id, :host_id).transpose
+        sub_facet_ids_from_pool_table ||= []
+        host_ids_from_pool_table ||= []
 
         entries_to_add = sub_facet_ids_from_cp - sub_facet_ids_from_pool_table
-        unless entries_to_add.empty?
-          ActiveRecord::Base.transaction do
-            entries_to_add.each do |sub_facet_id|
-              query = "INSERT INTO #{Katello::SubscriptionFacetPool.table_name} (pool_id, subscription_facet_id) VALUES (#{self.id}, #{sub_facet_id})"
-              ActiveRecord::Base.connection.execute(query)
-            end
-          end
-        end
+        facet_pool_data = entries_to_add.map { |sub_facet_id| { pool_id: self.id, subscription_facet_id: sub_facet_id } }
+        Katello::SubscriptionFacetPool.import(facet_pool_data) unless facet_pool_data.empty?
 
         entries_to_remove = sub_facet_ids_from_pool_table - sub_facet_ids_from_cp
-        Katello::SubscriptionFacetPool.where(:pool_id => self.id, :subscription_facet_id => entries_to_remove).delete_all
+        self.subscription_facet_pools.where(subscription_facet_id: entries_to_remove).delete_all
         self.import_audit_record(host_ids_from_pool_table, host_ids_from_cp)
       end
 

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

@@ -240,6 +240,8 @@ module Katello
           "iso"
         when Repository::DEB_TYPE
           "deb"
+        when Repository::ANSIBLE_COLLECTION_TYPE
+          "ansible_collection"
         end
       end
 
@@ -271,6 +273,10 @@ module Katello
         self.content_type == Repository::DEB_TYPE
       end
 
+      def ansible_collection?
+        self.content_type == Repository::ANSIBLE_COLLECTION_TYPE
+      end
+
       def published?
         distributors.map { |dist| dist['last_publish'] }.compact.any?
       end
@@ -378,6 +384,8 @@ module Katello
         "#{scheme}://#{pulp_uri.host.downcase}/pulp/ostree/web/#{relative_path}"
       elsif deb?
         "#{scheme}://#{pulp_uri.host.downcase}/pulp/deb/#{relative_path}/"
+      elsif ansible_collection?
+        "#{scheme}://#{pulp_uri.host.downcase}/pulp/content/#{relative_path}/"
       else
         "#{scheme}://#{pulp_uri.host.downcase}/pulp/repos/#{relative_path}/"
       end

data/app/models/katello/gpg_key.rb

@@ -46,7 +46,7 @@ module Katello
     end
 
     def self.humanize_class_name(_name = nil)
-      _("GPG Keys")
+      _("Content Credentials")
     end
 
     def to_label

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 = {}

data/app/models/katello/repository.rb

@@ -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) }
@@ -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/root_repository.rb

@@ -3,6 +3,7 @@ module Katello
     audited :except => [:content_id]
     serialize :ignorable_content
     serialize :docker_tags_whitelist
+    serialize :os_versions
 
     include Ext::LabelFromName
     include Encryptable
@@ -34,6 +35,11 @@ module Katello
       NO_DEFAULT_HTTP_PROXY,
       USE_SELECTED_HTTP_PROXY].freeze
 
+    RHEL6 = 'rhel-6'.freeze
+    RHEL7 = 'rhel-7'.freeze
+    RHEL8 = 'rhel-8'.freeze
+    ALLOWED_OS_VERSIONS = [RHEL6, RHEL7, RHEL8].freeze
+
     belongs_to :product, :inverse_of => :root_repositories, :class_name => "Katello::Product"
     belongs_to :gpg_key, :inverse_of => :root_repositories, :class_name => "Katello::GpgKey"
     belongs_to :ssl_ca_cert, :class_name => "Katello::GpgKey", :inverse_of => :ssl_ca_root_repos
@@ -63,6 +69,7 @@ module Katello
     validate :ensure_compatible_download_policy, :if => :yum?
     validate :ensure_valid_ignorable_content
     validate :ensure_valid_docker_tags_whitelist
+    validate :ensure_valid_os_versions
     validate :ensure_content_attribute_restrictions
     validate :ensure_valid_upstream_authorization
     validate :ensure_no_checksum_on_demand
@@ -214,6 +221,24 @@ module Katello
       end
     end
 
+    def ensure_valid_os_versions
+      return if os_versions.empty?
+      # os_versions here translate to candlepin as 'required tags'.
+      # A host must provide ALL required tags in order for the repo to be enabled.
+      # So os_versions such as ['rhel-7', 'rhel-8'] is not allowed, since the repo would always be disabled.
+      unless yum?
+        errors.add(:os_versions, N_("are only allowed for Yum repositories."))
+      end
+      if os_versions.length > 1
+        errors.add(:os_versions, N_("invalid: Repositories can only require one OS version."))
+      end
+      os_versions.each do |tag|
+        unless ALLOWED_OS_VERSIONS.include?(tag)
+          errors.add(:os_versions, N_("must be one of: %s" % ALLOWED_OS_VERSIONS.join(', ')))
+        end
+      end
+    end
+
     def ensure_valid_upstream_authorization
       return if (self.upstream_username.blank? && self.upstream_password.blank?)
       if redhat?
@@ -340,7 +365,7 @@ module Katello
       property :url, String, desc: 'Returns repository source URL'
     end
     class Jail < ::Safemode::Jail
-      allow :name, :label, :docker_upstream_name, :url
+      allow :name, :label, :docker_upstream_name, :url, :os_versions
     end
   end
 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

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

@@ -30,6 +30,8 @@ module Katello
           reindex_subscription_status
         when /system_purpose_compliance\.created/
           reindex_purpose_status
+        when /owner_content_access_mode\.modified/
+          message_handler.handle_content_access_mode_modified
         end
       end
 

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

@@ -20,6 +20,10 @@ module Katello
         @event_data ||= (data = content['eventData']) ? JSON.parse(data) : {}
       end
 
+      def target_name
+        content['targetName']
+      end
+
       def status
         event_data['status']
       end
@@ -85,6 +89,36 @@ module Katello
           Rails.logger.info "deleted pool #{pool_id} from Katello"
         end
       end
+
+      def handle_content_access_mode_modified
+        # Ideally the target_name would be the Candlepin Owner key
+        # Since it's the displayName, and we don't update that after org creation, there could be a mismatch
+        # For now, find the Candlepin Owner displayName from this event, and tie it back to a Katello org based on owner key
+        owners = Katello::Resources::Candlepin::Owner.all
+        owner = owners.find { |o| o['displayName'] == target_name }
+
+        unless owner
+          fail("Candlepin Owner %s could not be found" % target_name)
+        end
+
+        org = ::Organization.find_by!(label: owner['key'])
+        hosts = org.hosts
+
+        if event_data['contentAccessMode'] == 'org_environment'
+          Katello::HostStatusManager.clear_syspurpose_status(hosts)
+          Katello::HostStatusManager.update_subscription_status_to_sca(hosts)
+        elsif event_data['contentAccessMode'] == 'entitlement'
+          cp_consumer_uuids = hosts.joins(:subscription_facet).pluck("#{Katello::Host::SubscriptionFacet.table_name}.uuid")
+          cp_consumer_uuids.each do |uuid|
+            Katello::Resources::Candlepin::Consumer.compliance(uuid)
+            Katello::Resources::Candlepin::Consumer.purpose_compliance(uuid)
+          rescue => e
+            Rails.logger.error("Error encountered while fetching compliance for consumer #{uuid}: #{e.message}")
+          end
+        end
+
+        org.simple_content_access?(cached: false)
+      end
     end
   end
 end

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

@@ -0,0 +1,28 @@
+module Katello
+  module Candlepin
+    class UpstreamConsumer
+      def initialize(organization)
+        @organization = organization
+      end
+
+      def simple_content_access_eligible?
+        eligible = true
+        ::Organization.as_org(@organization) do
+          content_modes = resource_class.content_access
+
+          if content_modes.key?(:contentAccessModeList)
+            eligible = content_modes[:contentAccessModeList].include?('org_environment')
+          end
+        end
+
+        eligible
+      end
+
+      private
+
+      def resource_class
+        Katello::Resources::Candlepin::UpstreamConsumer
+      end
+    end
+  end
+end

data/app/services/katello/host_status_manager.rb

@@ -16,5 +16,14 @@ module Katello
       Katello::PurposeRoleStatus,
       Katello::PurposeSlaStatus,
       Katello::PurposeUsageStatus].freeze
+
+    def self.update_subscription_status_to_sca(hosts)
+      HostStatus::Status.where(host: hosts, type: Katello::SubscriptionStatus.to_s).update(status: Katello::SubscriptionStatus::DISABLED)
+    end
+
+    def self.clear_syspurpose_status(hosts)
+      host_purpose = HostStatus::Status.where(type: ::Katello::HostStatusManager::PURPOSE_STATUS.map(&:to_s)).where('host_id in (?)', hosts.pluck(:id))
+      host_purpose.destroy_all
+    end
   end
 end

data/app/services/katello/pulp3/api/apt.rb

@@ -0,0 +1,57 @@
+require "pulpcore_client"
+
+module Katello
+  module Pulp3
+    module Api
+      class Apt < Core
+        def self.api_exception_class
+          PulpDebClient::ApiError
+        end
+
+        def self.client_module
+          PulpDebClient
+        end
+
+        def self.remote_class
+          PulpDebClient::DebAptRemote
+        end
+
+        def self.distribution_class
+          PulpDebClient::DebAptDistribution
+        end
+
+        def self.publication_class
+          PulpDebClient::DebAptPublication
+        end
+
+        def self.repository_sync_url_class
+          PulpDebClient::RepositorySyncURL
+        end
+
+        def api_client
+          PulpDebClient::ApiClient.new(smart_proxy.pulp3_configuration(PulpDebClient::Configuration))
+        end
+
+        def repositories_api
+          PulpDebClient::RepositoriesAptApi.new(api_client)
+        end
+
+        def repository_versions_api
+          PulpDebClient::RepositoriesDebVersionsApi.new(api_client)
+        end
+
+        def remotes_api
+          PulpDebClient::RemotesAptApi.new(api_client)
+        end
+
+        def publications_api
+          PulpDebClient::PublicationsAptApi.new(api_client)
+        end
+
+        def distributions_api
+          PulpDebClient::DistributionsAptApi.new(api_client)
+        end
+      end
+    end
+  end
+end