katello 4.0.0 → 4.0.2

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

@@ -18,6 +18,7 @@ module Katello
       PULP3_FEATURE = "Pulpcore".freeze
       PULP_FEATURE = "Pulp".freeze
       PULP_NODE_FEATURE = "Pulp Node".freeze
+      CONTAINER_GATEWAY_FEATURE = "Container_Gateway".freeze
 
       DOWNLOAD_INHERIT = 'inherit'.freeze
       DOWNLOAD_POLICIES = ::Runcible::Models::YumImporter::DOWNLOAD_POLICIES + [DOWNLOAD_INHERIT]
@@ -89,6 +90,10 @@ module Katello
         end
 
         def self.with_environment(environment, include_default = false)
+          (pulp2_proxies_with_environment(environment, include_default) + pulpcore_proxies_with_environment(environment)).try(:uniq)
+        end
+
+        def self.pulp2_proxies_with_environment(environment, include_default = false)
           features = [PULP_NODE_FEATURE]
           features << PULP_FEATURE if include_default
 
@@ -96,6 +101,11 @@ module Katello
               where(katello_capsule_lifecycle_environments: { lifecycle_environment_id: environment.id })
         end
 
+        def self.pulpcore_proxies_with_environment(environment)
+          unscoped.where(id: unscoped.select { |p| p.pulp_mirror? }.pluck(:id)).joins(:capsule_lifecycle_environments).
+              where(katello_capsule_lifecycle_environments: { lifecycle_environment_id: environment.id })
+        end
+
         def self.sync_needed?(environment)
           Setting[:foreman_proxy_content_auto_sync] && unscoped.with_environment(environment).any?
         end
@@ -119,6 +129,19 @@ module Katello
         path
       end
 
+      def update_container_repo_list(repo_list)
+        ProxyAPI::ContainerGateway.new(url: self.url).repository_list({ repositories: repo_list })
+      end
+
+      def update_user_container_repo_mapping(user_repo_map)
+        ProxyAPI::ContainerGateway.new(url: self.url).user_repository_mapping(user_repo_map)
+      end
+
+      def container_gateway_users
+        usernames = ProxyAPI::ContainerGateway.new(url: self.url).users
+        ::User.where(login: usernames['users'])
+      end
+
       def pulp_url
         uri = URI.parse(url)
         "#{uri.scheme}://#{uri.host}/pulp/api/v2/"

data/app/models/katello/content_view.rb

@@ -6,6 +6,7 @@ module Katello
     include Ext::LabelFromName
     include Katello::Authorization::ContentView
     include ForemanTasks::Concerns::ActionSubject
+    include Foreman::ObservableModel
 
     CONTENT_DIR = "content_views".freeze
     IMPORT_LIBRARY = "Import-Library".freeze
@@ -90,6 +91,17 @@ module Katello
     scoped_search :on => :label, :complete_value => true
     scoped_search :on => :composite, :complete_value => true
 
+    set_crud_hooks :content_view
+
+    apipie :class, desc: "A class representing #{model_name.human} object" do
+      name 'Content View'
+      refs 'ContentView'
+      sections only: %w[all additional]
+      prop_group :katello_idname_props, Katello::Model, meta: { friendly_name: 'Content View' }
+      property :label, String, desc: 'Returns label of the Content View'
+      property :organization, 'Organization', desc: 'Returns organization object'
+    end
+
     def self.in_environment(env)
       joins(:content_view_environments).
         where("#{Katello::ContentViewEnvironment.table_name}.environment_id = ?", env.id)
@@ -757,14 +769,8 @@ module Katello
       self.organization
     end
 
-    apipie :class, desc: "A class representing #{model_name.human} object" do
-      name 'Content View'
-      refs 'ContentView'
-      sections only: %w[all additional]
-      prop_group :katello_basic_props, Katello::Model, meta: { friendly_name: 'Content View' }
-    end
     class Jail < ::Safemode::Jail
-      allow :name, :label, :version
+      allow :id, :name, :label, :version, :organization
     end
   end
 end

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

@@ -74,11 +74,6 @@ module Katello
         pulp_repo_facts['content_unit_counts']['srpm']
       end
 
-      def uri
-        uri = URI.parse(SETTINGS[:katello][:pulp][:url])
-        "https://#{uri.host}/pulp/content/#{relative_path}"
-      end
-
       def to_hash
         pulp_repo_facts.merge(as_json).merge(:sync_state => sync_state)
       end
@@ -364,19 +359,5 @@ module Katello
         end
       end
     end
-
-    def full_path(smart_proxy = nil, force_http = false)
-      pulp_uri = URI.parse(smart_proxy ? smart_proxy.url : SETTINGS[:katello][:pulp][:url])
-      scheme = force_http ? 'http' : 'https'
-      if docker?
-        "#{pulp_uri.host.downcase}/#{container_repository_name}"
-      elsif ostree?
-        "#{scheme}://#{pulp_uri.host.downcase}/pulp/content/web/#{relative_path}"
-      elsif ansible_collection?
-        "#{scheme}://#{pulp_uri.host.downcase}/pulp_ansible/galaxy/#{relative_path}/api"
-      else
-        "#{scheme}://#{pulp_uri.host.downcase}/pulp/content/#{relative_path}/"
-      end
-    end
   end
 end

data/app/models/katello/ping.rb

@@ -5,17 +5,10 @@ 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 &>/dev/null')
-      end
-
       def services(capsule_id = nil)
         proxy = fetch_proxy(capsule_id)
-        services = [:candlepin, :candlepin_auth, :foreman_tasks, :katello_events, :candlepin_events, :katello_agent]
-        services += [:pulp3] if proxy&.pulp3_enabled? && pulpcore_enabled
+        services = [:candlepin, :candlepin_auth, :foreman_tasks, :katello_events, :candlepin_events]
+        services += [:pulp3] if proxy&.pulp3_enabled?
         if proxy.nil? || proxy.has_feature?(SmartProxy::PULP_NODE_FEATURE) || proxy.has_feature?(SmartProxy::PULP_FEATURE)
           services += [:pulp, :pulp_auth]
         end
@@ -72,7 +65,7 @@ module Katello
 
       def ping_katello_agent(result)
         exception_watch(result) do
-          status = Katello::EventDaemon::Services::AgentEventReceiver.status(refresh: false)
+          status = Katello::EventDaemon::Runner.service_status(:katello_agent_events)
           event_daemon_status(status, result)
         end
       end

data/app/models/katello/repository.rb

@@ -395,8 +395,22 @@ module Katello
       all_instances
     end
 
-    def to_hash(content_source = nil)
-      {id: id, name: label, url: full_path(content_source)}
+    def full_path(smart_proxy = nil, force_http = false)
+      pulp_uri = URI.parse(smart_proxy ? smart_proxy.url : ::SmartProxy.pulp_primary.url)
+      scheme = force_http ? 'http' : 'https'
+      if docker?
+        "#{pulp_uri.host.downcase}/#{container_repository_name}"
+      elsif ostree?
+        "#{scheme}://#{pulp_uri.host.downcase}/pulp/content/web/#{relative_path}"
+      elsif ansible_collection?
+        "#{scheme}://#{pulp_uri.host.downcase}/pulp_ansible/galaxy/#{relative_path}/api"
+      else
+        "#{scheme}://#{pulp_uri.host.downcase}/pulp/content/#{relative_path}/"
+      end
+    end
+
+    def to_hash(content_source = nil, force_http = false)
+      {id: id, name: label, url: full_path(content_source, force_http)}
     end
 
     #is the repo cloned in the specified environment

data/app/models/katello/root_repository.rb

@@ -139,7 +139,7 @@ module Katello
     def ensure_compatible_download_policy
       if !url.blank? && URI(url).scheme == 'file' &&
           [::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND, ::Runcible::Models::YumImporter::DOWNLOAD_BACKGROUND].include?(download_policy)
-        errors.add(:download_policy, _("Cannot sync file:// repositories with On Demand or Background Download Policies"))
+        errors.add(:download_policy, _("Cannot sync file:// repositories with the On Demand Download Policy"))
       end
     end
 

data/app/services/cert/certs.rb

@@ -8,6 +8,10 @@ module Cert
       File.open(Setting[:ssl_ca_file], 'r').read
     end
 
+    def self.candlepin_client_ca_cert
+      File.read(SETTINGS[:katello][:candlepin][:ca_cert_file])
+    end
+
     def self.ssl_client_cert
       @ssl_client_cert ||= OpenSSL::X509::Certificate.new(File.open(ssl_client_cert_filename, 'r').read)
     end

data/app/services/katello/agent/dispatcher.rb

@@ -14,37 +14,31 @@ module Katello
       register_message(:install_package_group, Katello::Agent::InstallPackageGroupMessage)
       register_message(:remove_package_group, Katello::Agent::RemovePackageGroupMessage)
 
-      def self.dispatch(message_type, host_ids, args)
+      def self.dispatch(message_type, histories, args)
         message_class = @supported_messages[message_type]
-
-        fail("Unsupported message type") unless message_class
-
-        uuid_data = ::Katello::Host::ContentFacet.where(host_id: host_ids).pluck(:host_id, :uuid)
-        fail("Couldn't find all hosts specified") unless host_ids.size == uuid_data.size
-
-        host_data = uuid_data.map do |host_id, consumer_id|
-          {
-            host_id: host_id,
-            consumer_id: consumer_id,
-            history: Katello::Agent::DispatchHistory.new(host_id: host_id),
-            message: message_class.new(**args.merge(consumer_id: consumer_id))
-          }
+        fail("Unsupported message type: #{message_type}") unless message_class
+
+        messages = histories.map do |history|
+          message = message_class.new(**args.merge(consumer_id: history.host.subscription_facet.uuid))
+          message.dispatch_history_id = history.id
+          message.recipient_address = settings[:client_queue_format] % history.host.subscription_facet.uuid
+          message.reply_to = settings[:event_queue_name]
+          message
         end
 
-        histories = host_data.map { |attrs| attrs[:history] }
-        ActiveRecord::Base.transaction do
-          Katello::Agent::DispatchHistory.import(histories)
+        connection = Connection.new
+        connection.send_messages(messages)
 
-          host_data.each do |d|
-            d[:message].dispatch_history_id = d[:history].id
-            d[:message].recipient_address = settings[:client_queue_format] % [d[:consumer_id]]
-            d[:message].reply_to = settings[:event_queue_name]
-          end
+        histories
+      end
 
-          connection = Connection.new
-          connection.send_messages(host_data.map { |d| d[:message] })
+      def self.create_histories(host_ids:)
+        histories = host_ids.map do |id|
+          Katello::Agent::DispatchHistory.new(host_id: id)
         end
 
+        Katello::Agent::DispatchHistory.import(histories)
+
         histories
       end
 

data/app/services/katello/applicability/applicable_content_helper.rb

@@ -122,20 +122,22 @@ module Katello
       end
 
       def applicable_differences
-        consumer_ids = content_facet.send(applicable_units).pluck("#{content_unit_class.table_name}.id")
-        content_ids = fetch_content_ids
+        ActiveRecord::Base.connection.uncached do
+          consumer_ids = content_facet.send(applicable_units).pluck("#{content_unit_class.table_name}.id")
+          content_ids = fetch_content_ids
 
-        to_remove = consumer_ids - content_ids
-        to_add = content_ids - consumer_ids
+          to_remove = consumer_ids - content_ids
+          to_add = content_ids - consumer_ids
 
-        [to_add, to_remove]
+          [to_add, to_remove]
+        end
       end
 
       def insert(applicable_ids)
         unless applicable_ids.empty?
           inserts = applicable_ids.map { |applicable_id| "(#{applicable_id.to_i}, #{content_facet.id.to_i})" }
           sql = "INSERT INTO #{content_facet_association_class.table_name} (#{content_unit_association_id}, content_facet_id) VALUES #{inserts.join(', ')}"
-          ActiveRecord::Base.connection.execute(sql)
+          ActiveRecord::Base.connection.exec_insert(sql)
         end
       end
 

data/app/services/katello/managed_content_medium_provider.rb

@@ -14,11 +14,11 @@ module Katello
       URI.parse(url)
     end
 
-    # If there is an 'AppStream' variant, we need to make it
+    # If there are any 'AppStream' variants, we need to make them
     # available to Anaconda
     def additional_media
-      appstream = entity.operatingsystem.variant_repo(entity, 'AppStream')
-      super + (appstream ? [appstream] : [])
+      appstream_repos = entity.operatingsystem.variant_repos(entity, 'AppStream')
+      super + (appstream_repos.present? ? appstream_repos : [])
     end
 
     def unique_id

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

@@ -4,6 +4,10 @@ module Katello
   module Pulp3
     module Api
       class ContentGuard < Core
+        def default_name
+          'RHSMCertGuard'
+        end
+
         def self.client_module
           PulpCertguardClient
         end
@@ -20,19 +24,49 @@ module Katello
           PulpCertguardClient::ContentguardsRhsmApi.new(api_client)
         end
 
-        def create(name = "RHSMCertGuard", ca_certificate = Cert::Certs.ca_cert)
-          data = PulpCertguardClient::CertguardRHSMCertGuard.new(name: name, ca_certificate: ca_certificate)
+        def ca_cert
+          Cert::Certs.candlepin_client_ca_cert
+        end
+
+        def refresh
+          found = list(name: default_name).results.first
+          if found && found.ca_certificate != ca_cert
+            partial_update(found.pulp_href)
+          else
+            found = create
+          end
+          persist_if_needed(found.pulp_href)
+        end
+
+        def persist_if_needed(href)
+          return if self.smart_proxy.pulp_mirror?
+          Katello::Util::Support.active_record_retry do
+            found = Katello::Pulp3::ContentGuard.find_by(:name => default_name)
+            if found
+              found.update(pulp_href: href)
+            else
+              Katello::Pulp3::ContentGuard.create(name: default_name, pulp_href: href)
+            end
+          end
+        end
+
+        def create(name = default_name)
+          data = PulpCertguardClient::CertguardRHSMCertGuard.new(name: name, ca_certificate: ca_cert)
           rhsm_api_client.create(data)
         rescue self.class.api_exception_class => e
-          raise e unless list&.results&.first
+          if (found = list&.results&.first) #check for possible race condition
+            found
+          else
+            raise e
+          end
         end
 
         def list(options = {})
           rhsm_api_client.list options
         end
 
-        def partial_update(href, ca_certificate = Cert::Certs.ca_cert)
-          data = PulpCertguardClient::CertguardRHSMCertGuard.new(ca_certificate: ca_certificate)
+        def partial_update(href)
+          data = PulpCertguardClient::CertguardRHSMCertGuard.new(ca_certificate: ca_cert)
           rhsm_api_client.partial_update(href, data)
         end
 

data/app/services/katello/pulp3/migration.rb

@@ -293,10 +293,11 @@ module Katello
               to_import[[errata_id, repo_id]] ||= {erratum_id: errata_id, erratum_pulp3_href: pulp3_href, repository_id: repo_id}
             end
           end
-        end
 
-        Katello::RepositoryErratum.import([:erratum_id, :erratum_pulp3_href, :repository_id], to_import.values, :validate => false,
-                                          on_duplicate_key_update: {conflict_target: [:erratum_id, :repository_id], columns: [:erratum_pulp3_href]})
+          Katello::RepositoryErratum.import([:erratum_id, :erratum_pulp3_href, :repository_id], to_import.values, :validate => false,
+                                            on_duplicate_key_update: {conflict_target: [:erratum_id, :repository_id], columns: [:erratum_pulp3_href]})
+          to_import = {}
+        end
       end
 
       def import_content_type(content_type)

data/app/services/katello/pulp3/repository.rb

@@ -222,11 +222,38 @@ module Katello
       end
 
       def refresh_distributions
-        dist_ref = distribution_reference
-        if dist_ref
-          update_distribution
+        if repo.docker?
+          dist = lookup_distributions(base_path: repo.container_repository_name).first
         else
+          dist = lookup_distributions(base_path: repo.relative_path).first
+        end
+
+        # First check if the distribution exists
+        if dist
+          dist_ref = distribution_reference
+          # If we have a DistributionReference, update the distribution
+          if dist_ref
+            return update_distribution
+          # If no DistributionReference, create a DistributionReference and return
+          else
+            save_distribution_references([dist.pulp_href])
+            return []
+          end
+        end
+
+        # So far, it looks like there is no distribution. Try to create one.
+        begin
           create_distribution(relative_path)
+        rescue api.class.client_module::ApiError => e
+          # Now it seems there is a distribution. Fetch it and save the reference.
+          if e.message.include?("\"base_path\":[\"This field must be unique.\"]") ||
+              e.message.include?("\"base_path\":[\"Overlaps with existing distribution\"")
+            dist = lookup_distributions(base_path: repo.relative_path).first
+            save_distribution_references([dist.pulp_href])
+            return []
+          else
+            raise e
+          end
         end
       end
 
@@ -276,7 +303,8 @@ module Katello
           pulp3_distribution_data = api.get_distribution(href)
           path, content_guard_href = pulp3_distribution_data&.base_path, pulp3_distribution_data&.content_guard
           unless distribution_reference
-            DistributionReference.create!(path: path, href: href, repository_id: repo.id, content_guard_href: content_guard_href)
+            # Ensure that duplicates won't be created in the case of a race condition
+            DistributionReference.where(path: path, href: href, repository_id: repo.id, content_guard_href: content_guard_href).first_or_create!
           end
         end
       end

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

@@ -27,8 +27,7 @@ module Katello
           popts = super(repository_version)
           popts.merge!(
             {
-              # structured is not necessary for subscription-manager
-              #structured: true, # publish real suites (e.g. 'stable')
+              structured: true, # publish real suites (e.g. 'stable')
               simple: true # publish all into 'default'-suite
             }
           )