katello 4.1.0.rc2.2 → 4.1.0

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

@@ -10,8 +10,15 @@ module Katello
           minor ||= '' # treat minor versions as empty string to not confuse with nil
           os = ::Redhat.where(:name => os_name, :major => major, :minor => minor).try(:first)
           return os if os
-          description = "#{os_name}-#{repo.distribution_version}"
-          create_os = lambda { ::Redhat.create!(:name => os_name, :major => major, :minor => minor, :description => description) }
+
+          if ::Redhat.where(:title => "#{os_name} #{repo.distribution_version}").present?
+            description = "#{os_name} #{repo.distribution_version} #{SecureRandom.uuid}"
+            create_os = lambda do
+              ::Redhat.create!(:name => os_name, :major => major, :minor => minor, :description => description)
+            end
+          else
+            create_os = lambda { ::Redhat.create!(:name => os_name, :major => major, :minor => minor) }
+          end
 
           begin
             create_os.call
@@ -42,10 +49,11 @@ module Katello
         end
       end
 
-      def kickstart_repos(host)
-        distros = distribution_repositories(host).where(distribution_bootable: true)
-        if distros && host&.content_facet&.content_source
-          distros.map { |distro| distro.to_hash(host.content_facet.content_source) }
+      def kickstart_repos(host, content_facet: nil)
+        distros = distribution_repositories(host, content_facet: content_facet).where(distribution_bootable: true)
+        content_facet ||= host.content_facet
+        if distros && content_facet&.content_source
+          distros.map { |distro| distro.to_hash(content_facet.content_source) }
         else
           []
         end
@@ -62,10 +70,10 @@ module Katello
         end
       end
 
-      def distribution_repositories(host)
-        content_view = host.try(:content_facet).try(:content_view) || host.try(:content_view)
-        lifecycle_environment = host.try(:content_facet).try(:lifecycle_environment) || host.try(:lifecycle_environment)
-
+      def distribution_repositories(host, content_facet: nil)
+        content_facet ||= host.content_facet
+        content_view = content_facet.try(:content_view) || host.try(:content_view)
+        lifecycle_environment = content_facet.try(:lifecycle_environment) || host.try(:lifecycle_environment)
         if content_view && lifecycle_environment && host.os && host.architecture
           Katello::Repository.in_environment(lifecycle_environment).in_content_views([content_view]).
               where(:distribution_arch => host.architecture.name).

data/app/models/katello/erratum.rb

@@ -98,10 +98,6 @@ module Katello
         where("#{Katello::ContentFacetRepository.table_name}.repository_id = #{Katello::RepositoryErratum.table_name}.repository_id")
     end
 
-    def self.installable_for_hosts(hosts = nil)
-      ApplicableContentHelper.new(Erratum).installable_for_hosts(hosts)
-    end
-
     def self.ids_installable_for_hosts(hosts = nil)
       installable_for_hosts(hosts).select(:id)
     end

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

@@ -73,11 +73,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
@@ -355,19 +350,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/host/content_facet.rb

@@ -54,37 +54,22 @@ module Katello
         end
 
         unless self.bound_repositories.sort == repos.sort
-          update_bound_repositories(repos)
+          self.bound_repositories = repos
+          self.save!
         end
         self.bound_repositories.pluck(:relative_path)
       end
 
-      def propagate_yum_repos
-        pulp_ids = self.bound_repositories.includes(:library_instance).map { |repo| repo.library_instance.try(:pulp_id) || repo.pulp_id }
-        Katello::Pulp::Consumer.new(self.uuid).bind_yum_repositories(pulp_ids)
-      end
-
-      def update_bound_repositories(repos)
-        self.bound_repositories = repos
-        self.save!
-        if SETTINGS[:katello][:katello_applicability]
-          ::Katello::EventQueue.push_event(::Katello::Events::GenerateHostApplicability::EVENT_TYPE, self.host.id)
-        else
-          self.propagate_yum_repos
-          ForemanTasks.async_task(Actions::Katello::Host::GenerateApplicability, [self.host])
-        end
-      end
-
       def installable_errata(env = nil, content_view = nil)
-        ApplicableContentHelper.new(Erratum, self).installable(env, content_view)
+        Erratum.installable_for_content_facet(self, env, content_view)
       end
 
       def installable_rpms(env = nil, content_view = nil)
-        ApplicableContentHelper.new(Rpm, self).installable(env, content_view)
+        Rpm.installable_for_content_facet(self, env, content_view)
       end
 
       def installable_module_streams(env = nil, content_view = nil)
-        ApplicableContentHelper.new(ModuleStream, self).installable(env, content_view)
+        ModuleStream.installable_for_content_facet(self, env, content_view)
       end
 
       def errata_counts
@@ -97,6 +82,12 @@ module Katello
         hash
       end
 
+      def self.trigger_applicability_generation(host_ids)
+        host_ids = [host_ids] unless host_ids.is_a?(Array)
+        ::Katello::ApplicableHostQueue.push_hosts(host_ids)
+        ::Katello::EventQueue.push_event(::Katello::Events::GenerateHostApplicability::EVENT_TYPE, 0)
+      end
+
       # Katello applicability
       def calculate_and_import_applicability
         bound_repos = bound_repositories.collect do |repo|

data/app/models/katello/host_available_module_stream.rb

@@ -32,13 +32,13 @@ module Katello
     def upgradable?
       return false if status != ENABLED
 
-      ApplicableContentHelper.new(ModuleStream).installable_for_hosts([host_id]).
-                                         where(ModuleStream.table_name => {:name => available_module_stream.name,
-                                                                           :stream => available_module_stream.stream}).exists?
+      ModuleStream.installable_for_hosts([host_id]).
+           where(ModuleStream.table_name => {:name => available_module_stream.name,
+                                             :stream => available_module_stream.stream}).exists?
     end
 
     def self.upgradable(host)
-      upgradable_module_name_streams = ApplicableContentHelper.new(ModuleStream).installable_for_hosts([host]).select(:name, :stream)
+      upgradable_module_name_streams = ModuleStream.installable_for_hosts([host]).select(:name, :stream)
 
       enabled.joins(:available_module_stream).where(:host_id => host).
               where("(#{AvailableModuleStream.table_name}.name, #{AvailableModuleStream.table_name}.stream) in (#{upgradable_module_name_streams.to_sql})")

data/app/models/katello/module_stream.rb

@@ -41,10 +41,6 @@ module Katello
       ContentFacetApplicableModuleStream
     end
 
-    def self.installable_for_hosts(hosts = nil)
-      ApplicableContentHelper.new(ModuleStream).installable_for_hosts(hosts)
-    end
-
     def self.available_for_hosts(hosts)
       where("#{table_name}.id" => ::Katello::ModuleStream.joins(repositories: :content_facets).
             select("#{table_name}.id").

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]
-        services += [:pulp3] if proxy&.pulp3_enabled? && pulpcore_enabled
+        services += [:pulp3] if proxy&.pulp3_enabled?
         services += [:katello_agent] if ::Katello.with_katello_agent?
         if proxy.nil? || proxy.has_feature?(SmartProxy::PULP_NODE_FEATURE) || proxy.has_feature?(SmartProxy::PULP_FEATURE)
           services += [:pulp, :pulp_auth]
@@ -73,7 +66,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

@@ -399,6 +399,20 @@ module Katello
       all_instances
     end
 
+    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
@@ -740,10 +754,6 @@ module Katello
       throw :abort unless destroyable?
     end
 
-    def hosts_with_applicability
-      ::Host.joins(:content_facet => :bound_repositories).where("#{Katello::Repository.table_name}.id" => (self.clones.pluck(:id) + [self.id]))
-    end
-
     def docker_meta_tag_count
       DockerMetaTag.in_repositories(self.id).count
     end

data/app/models/katello/root_repository.rb

@@ -156,6 +156,10 @@ module Katello
       end
     end
 
+    def self.hosts_with_applicability
+      ::Host.joins(:content_facet => :bound_repositories).where("#{Katello::Repository.table_name}.root_id" => self.select(:id))
+    end
+
     def ensure_no_download_policy
       if !yum? && download_policy.present?
         errors.add(:download_policy, _("cannot be set for non-yum repositories."))

data/app/models/katello/rpm.rb

@@ -210,10 +210,6 @@ module Katello
         where("#{Katello::ContentFacetRepository.table_name}.repository_id = #{Katello::RepositoryRpm.table_name}.repository_id").uniq
     end
 
-    def self.installable_for_hosts(hosts = nil)
-      ApplicableContentHelper.new(Rpm).installable_for_hosts(hosts)
-    end
-
     def self.applicable_to_hosts(hosts)
       self.joins(:content_facets).
         where("#{Katello::Host::ContentFacet.table_name}.host_id" => hosts).distinct

data/app/services/cert/certs.rb

@@ -8,6 +8,10 @@ module Cert
       File.read(Setting[:ssl_ca_file])
     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.read(ssl_client_cert_filename))
     end

data/app/services/katello/applicable_host_queue.rb

@@ -8,8 +8,8 @@ module Katello
       ::Katello::HostQueueElement.all.size
     end
 
-    def self.push_host(host_id)
-      HostQueueElement.create!({ host_id: host_id })
+    def self.push_hosts(ids)
+      HostQueueElement.import ids.map { |host_id| { host_id: host_id } }, validate: false
     end
 
     def self.pop_hosts(amount = self.batch_size)

data/app/services/katello/pulp/yum_metadata_file.rb

@@ -7,8 +7,12 @@ module Katello
         shared_attributes = backend_data.keys & model.class.column_names
         shared_json = backend_data.select { |key, _v| shared_attributes.include?(key) }
         repo = ::Katello::Repository.find_by(:pulp_id => backend_data['repo_id']).try(:id)
-        model.update!(shared_json.merge(repository_id: repo,
-                                                  name: find_name_from_json(backend_data)))
+        filename = find_name_from_json(backend_data)
+        model.update!(shared_json.merge(repository_id: repo, name: filename))
+        if repo
+          Katello::YumMetadataFile.where("id != ? AND repository_id = ? AND name = ? AND checksum = ?",
+                                         model.id, repo, filename, model.checksum).delete_all
+        end
       end
 
       def find_name_from_json(json)

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/repository/ansible_collection.rb

@@ -25,7 +25,7 @@ module Katello
         end
 
         def partial_repo_path
-          "/pulp_ansible/galaxy/#{repo.relative_path}/api/v2/collections"
+          "/pulp_ansible/galaxy/#{repo.relative_path}/api/"
         end
 
         def mirror_remote_options

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

@@ -18,6 +18,7 @@ module Katello
         end
 
         def extract_sles_token
+          return [nil, nil] if root.url.blank?
           uri = URI(root.url)
           query = uri.query
           uri.query = nil

data/app/services/katello/registration_manager.rb

@@ -113,7 +113,6 @@ module Katello
 
         # if this fails, there is not much to do about it right now. We can't really re-create the candlepin consumer.
         # This can be cleaned up later via clean_backend_objects.
-        pulp_consumer_destory(host.content_facet.uuid) if host.content_facet.try(:uuid) && pulp2_supported?
 
         delete_agent_queue(host) if host.content_facet.try(:uuid)
 
@@ -156,9 +155,9 @@ module Katello
 
         User.as_anonymous_admin do
           begin
-            create_in_cp_and_pulp(host, content_view_environment, consumer_params, activation_keys)
+            create_in_candlepin(host, content_view_environment, consumer_params, activation_keys)
           rescue StandardError => e
-            # we can't call CP or pulp here since something bad already happened. Just clean up our DB as best as we can.
+            # we can't call CP here since something bad already happened. Just clean up our DB as best as we can.
             host.subscription_facet.try(:destroy!)
             new_host ? remove_partially_registered_new_host(host) : remove_host_artifacts(host)
             raise e
@@ -174,8 +173,7 @@ module Katello
           ping_results = Katello::Ping.ping
         end
         candlepin_ok = ping_results[:services][:candlepin][:status] == "ok"
-        pulp_ok = ping_results[:services][:pulp] ? ping_results[:services][:pulp][:status] == "ok" : true
-        candlepin_ok && pulp_ok
+        candlepin_ok
       end
 
       private
@@ -187,10 +185,6 @@ module Katello
         Rails.logger.warn("Attempted to destroy host %s but host is already gone." % host_id)
       end
 
-      def pulp2_supported?
-        SmartProxy.pulp_primary.has_feature?(SmartProxy::PULP_FEATURE)
-      end
-
       def get_uuid(params)
         params.key?(:uuid) ? params[:uuid] : SecureRandom.uuid
       end
@@ -204,18 +198,10 @@ module Katello
         host.subscription_facet.update_subscription_status(::Katello::SubscriptionStatus::UNKNOWN)
       end
 
-      def create_in_cp_and_pulp(host, content_view_environment, consumer_params, activation_keys)
+      def create_in_candlepin(host, content_view_environment, consumer_params, activation_keys)
         # if CP fails, nothing to clean up yet w.r.t. backend services
         cp_create = ::Katello::Resources::Candlepin::Consumer.create(content_view_environment.cp_id, consumer_params, activation_keys.map(&:cp_name))
         ::Katello::Host::SubscriptionFacet.update_facts(host, consumer_params[:facts]) unless consumer_params[:facts].blank?
-
-        # if pulp fails, remove the CP consumer we just made
-        begin
-          ::Katello.pulp_server.extensions.consumer.create(cp_create[:uuid], display_name: host.name) if pulp2_supported?
-        rescue StandardError => e
-          ::Katello::Resources::Candlepin::Consumer.destroy(cp_create[:uuid])
-          raise e
-        end
         cp_create[:uuid]
       end
 
@@ -262,12 +248,6 @@ module Katello
         Rails.logger.warn(_("Candlepin consumer %s has already been removed") % host_uuid)
       end
 
-      def pulp_consumer_destory(host_uuid)
-        ::Katello.pulp_server.extensions.consumer.delete(host_uuid)
-      rescue RestClient::ResourceNotFound
-        Rails.logger.warn(_("Pulp Consumer %s has already been removed") % host_uuid)
-      end
-
       def delete_agent_queue(host)
         queue_name = Katello::Agent::Dispatcher.host_queue_name(host)
         Katello::EventQueue.push_event(::Katello::Events::DeleteHostAgentQueue::EVENT_TYPE, host.id) do |attrs|