katello 3.14.1 → 3.15.0.rc1

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

@@ -0,0 +1,143 @@
+module Katello
+  module Pulp3
+    class Rpm < PulpContentUnit
+      include LazyAccessor
+      CONTENT_TYPE = "rpm".freeze
+
+      PULP_INDEXED_FIELDS = %w(pulp_href name version release arch epoch summary is_modular rpm_sourcerpm location_href pkgId).freeze
+
+      lazy_accessor :description, :license, :buildhost, :vendor, :relativepath, :children, :checksumtype,
+                    :changelog, :group, :size, :url, :build_time, :group,
+                    :initializer => :backend_data
+
+      def self.content_api
+        PulpRpmClient::ContentPackagesApi.new(Katello::Pulp3::Api::Yum.new(SmartProxy.pulp_master!).api_client)
+      end
+
+      def self.ids_for_repository(repo_id)
+        repo = Katello::Pulp3::Repository::Yum.new(Katello::Repository.find(repo_id), SmartProxy.pulp_master)
+        repo_content_list = repo.content_list
+        repo_content_list.map { |content| content.try(:pulp_href) }
+      end
+
+      def self.rpm_architectures
+        ['i386', 'i486', 'i586', 'i686', 'athlon', 'geode', 'pentium3', 'pentium4',
+         'x86_64', 'amd64',
+         'ia64',
+         'alpha', 'alphaev5', 'alphaev56', 'alphapca56', 'alphaev6', 'alphaev67',
+         'sparc', 'sparcv8', 'sparcv9', 'sparc64', 'sparc64v', 'sun4', 'sun4c', 'sun4d', 'sun4m', 'sun4u',
+         'armv3l', 'armv4b', 'armv4l', 'armv5tel', 'armv5tejl', 'armv6l', 'armv7l',
+         'mips', 'mipsel',
+         'ppc', 'ppciseries', 'ppcpseries', 'ppc64', 'ppc8260', 'ppc8560', 'ppc32dy4',
+         'm68k', 'm68kmint', 'atarist', 'atariste', 'ataritt', 'falcon', 'atariclone', 'milan', 'hades',
+         'Sgi',
+         'rs6000',
+         'i370', 's390x', 's390',
+         'noarch']
+      end
+
+      def requires
+        results = []
+        flags = {'GT' => '>', 'LT' => '>', 'EQ' => '=', 'GE' => '>=', 'LE' => '<='}
+        if backend_data['requires']
+          backend_data['requires'].each do |requirement|
+            requires_str = ""
+            if requirement.count < 3
+              requires_str = requirement.first
+              results << requires_str
+            else
+              requirement[1] = flags[requirement[1]]
+              requirement[0...2].each { |requirement_piece| requires_str += "#{requirement_piece} " }
+              requirement[2...-1].each { |requirement_piece| requires_str += "#{requirement_piece}." }
+              results << requires_str[0...-1]
+            end
+          end
+        end
+        results.uniq
+      end
+
+      def provides
+        results = []
+        flags = {'GT' => '>', 'LT' => '>', 'EQ' => '=', 'GE' => '>=', 'LE' => '<='}
+        if backend_data['provides']
+          backend_data['provides'].each do |provided|
+            provides_str = ""
+            if provided.count < 3
+              provides_str = provided.first
+              results << provides_str
+            else
+              provided[1] = flags[provided[1]]
+              provided[0...2].each { |provided_piece| provides_str += "#{provided_piece} " }
+              provided[2...-1].each { |provided_piece| provides_str += "#{provided_piece}." }
+              results << provides_str[0...-1]
+            end
+          end
+        end
+        results.uniq
+      end
+
+      def files
+        files = backend_data['files'].collect do |file_and_path|
+          # First item in the array might be a directive like "dir" or "ghost"
+          if file_and_path[0][0] != '/'
+            file_and_path.shift
+          end
+          file_and_path.join('')
+        end
+
+        files.uniq
+      end
+
+      def buildhost
+        backend_data['rpm_buildhost']
+      end
+
+      def vendor
+        backend_data['rpm_vendor']
+      end
+
+      def relativepath
+        backend_data['location_href']
+      end
+
+      def checksumtype
+        backend_data['checksum_type']
+      end
+
+      def changelog
+        backend_data['changelogs']
+      end
+
+      def group
+        backend_data['rpm_group']
+      end
+
+      def build_time
+        backend_data['time_build']
+      end
+
+      def size
+        backend_data['size_package']
+      end
+
+      def license
+        backend_data['rpm_license']
+      end
+
+      def update_model(model)
+        custom_json = {}
+        custom_json['modular'] = backend_data['is_modular']
+        custom_json['pulp_id'] = backend_data['pulp_href']
+        (PULP_INDEXED_FIELDS - ['is_modular', 'pulp_href', 'rpm_sourcerpm', 'pkgId', 'location_href']).
+          each { |field| custom_json[field] = backend_data[field] }
+        custom_json['release_sortable'] = Util::Package.sortable_version(backend_data['release'])
+        custom_json['version_sortable'] = Util::Package.sortable_version(backend_data['version'])
+        custom_json['nvra'] = model.build_nvra
+        custom_json['filename'] = backend_data['location_href']
+        custom_json['checksum'] = backend_data['pkgId']
+        custom_json['sourcerpm'] = backend_data['rpm_sourcerpm']
+        model.update_attributes!(custom_json)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+module Katello
+  module Pulp3
+    class SmartProxyMirrorRepository < SmartProxyRepository
+      def initialize(smart_proxy)
+        fail "Cannot use a central pulp smart proxy" if smart_proxy.pulp_master?
+        @smart_proxy = smart_proxy
+      end
+
+      def orphaned_repositories
+        repo_map = {}
+
+        smart_proxy_helper = ::Katello::SmartProxyHelper.new(smart_proxy)
+        katello_pulp_ids = smart_proxy_helper.repos_available_to_capsule.map(&:pulp_id)
+        pulp3_enabled_repo_types.each do |repo_type|
+          api = repo_type.pulp3_service_class.api(smart_proxy)
+          repo_map[api] = api.list_all.reject { |capsule_repo| katello_pulp_ids.include? capsule_repo.name }
+        end
+
+        repo_map
+      end
+
+      def orphan_repository_versions
+        repo_version_map = {}
+
+        pulp3_enabled_repo_types.each do |repo_type|
+          api = repo_type.pulp3_service_class.api(smart_proxy)
+          version_hrefs = api.repository_versions
+          orphan_version_hrefs = api.list_all.collect do |pulp_repo|
+            mirror_repo_versions = api.versions_list_for_repository(pulp_repo.pulp_href, ordering: :_created)
+            version_hrefs = mirror_repo_versions.collect { |version| version.pulp_href }
+
+            version_hrefs - [pulp_repo.latest_version_href]
+          end
+          repo_version_map[api] = orphan_version_hrefs.flatten
+        end
+
+        repo_version_map
+      end
+
+      def delete_orphan_repositories
+        tasks = []
+
+        orphaned_repositories.each do |api, pulp3_repo_list|
+          tasks << pulp3_repo_list.collect do |repo|
+            api.repositories_api.delete(repo.pulp_href)
+          end
+        end
+
+        tasks.flatten!
+      end
+
+      def delete_orphan_distributions
+        tasks = []
+        pulp3_enabled_repo_types.each do |repo_type|
+          pulp3_class = repo_type.pulp3_service_class
+          orphan_distributions(pulp3_class).each do |distribution|
+            tasks << pulp3_class.api(smart_proxy).delete_distribution(distribution.pulp_href)
+          end
+        end
+        tasks
+      end
+
+      def orphan_distributions(pulp3_service_class)
+        api = pulp3_service_class.api(smart_proxy)
+        api.distributions_list_all.select do |distribution|
+          dist = api.get_distribution(distribution.pulp_href)
+          self.class.orphan_distribution?(dist)
+        end
+      end
+
+      def self.orphan_distribution?(distribution)
+        distribution.try(:publication).nil? &&
+            distribution.try(:repository).nil? &&
+            distribution.try(:repository_version).nil?
+      end
+
+      def delete_orphan_remotes
+        tasks = []
+        repo_names = Katello::Repository.pluck(:pulp_id)
+        pulp3_enabled_repo_types.each do |repo_type|
+          api = repo_type.pulp3_service_class.api(smart_proxy)
+          remotes = api.remotes_list
+
+          remotes.each do |remote|
+            tasks << api.delete_remote(remote.pulp_href) unless repo_names.include?(remote.name)
+          end
+        end
+        tasks
+      end
+    end
+  end
+end

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

@@ -4,9 +4,18 @@ module Katello
       attr_accessor :smart_proxy
 
       def initialize(smart_proxy)
+        fail "Cannot use a mirror" if smart_proxy.pulp_mirror?
         @smart_proxy = smart_proxy
       end
 
+      def self.instance_for_type(smart_proxy)
+        if smart_proxy.pulp_master?
+          SmartProxyRepository.new(smart_proxy)
+        else
+          SmartProxyMirrorRepository.new(smart_proxy)
+        end
+      end
+
       def ==(other)
         other.class == self.class && other.smart_proxy == smart_proxy
       end
@@ -16,23 +25,43 @@ module Katello
         katello_repos = katello_repos.where(:environment_id => environment_id) if environment_id
         katello_repos = katello_repos.in_content_views([content_view_id]) if content_view_id
         katello_repos = katello_repos.select { |repo| smart_proxy.pulp3_support?(repo) }
-        repos_on_capsule = ::Katello::Pulp3::Repository.new(nil, smart_proxy).list(name_in: katello_repos.map(&:pulp_id))
+        repos_on_capsule = pulp3_enabled_repo_types.collect do |repo_type|
+          repo_type.pulp3_service_class.api(smart_proxy).list_all(name_in: katello_repos.map(&:pulp_id))
+        end
+        repos_on_capsule.flatten!
         repo_ids = repos_on_capsule.map(&:name)
         katello_repos.select { |repo| repo_ids.include? repo.pulp_id }
       end
 
-      def orphaned_repositories_for_mirror_proxies
-        smart_proxy_helper = ::Katello::SmartProxyHelper.new(smart_proxy)
-        katello_pulp_ids = smart_proxy_helper.repos_available_to_capsule.map(&:pulp_id)
-        repos_on_capsule = ::Katello::Pulp3::Repository.new(nil, smart_proxy).list({})
-        repos_on_capsule.reject { |capsule_repo| katello_pulp_ids.include? capsule_repo.name }
+      def delete_orphan_repository_versions
+        tasks = []
+
+        orphan_repository_versions.each do |api, version_hrefs|
+          tasks << version_hrefs.collect do |href|
+            api.repository_versions_api.delete(href)
+          end
+        end
+
+        tasks.flatten
       end
 
-      def delete_orphaned_repositories_for_mirror_proxies
-        orphaned_repositories_for_mirror_proxies.map do |repo|
-          ::Katello::Pulp3::Repository.new(nil, smart_proxy).repositories_api.delete(repo.pulp_href)
+      def pulp3_enabled_repo_types
+        Katello::RepositoryTypeManager.repository_types.values.select do |repository_type|
+          smart_proxy.pulp3_repository_type_support?(repository_type)
         end
       end
+
+      def orphan_repository_versions
+        # Each key is a Pulp 3 plugin API and each value is the list of version_hrefs
+        repo_version_map = {}
+        pulp3_enabled_repo_types.each do |repo_type|
+          api = repo_type.pulp3_service_class.api(smart_proxy)
+          version_hrefs = api.repository_versions
+          repo_version_map[api] = version_hrefs - ::Katello::Repository.where(version_href: version_hrefs).pluck(:version_href)
+        end
+
+        repo_version_map
+      end
     end
   end
 end

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

@@ -0,0 +1,74 @@
+module Katello
+  module Pulp3
+    class Srpm < PulpContentUnit
+      include LazyAccessor
+
+      PULP_INDEXED_FIELDS = %w(pulp_href name version release arch epoch summary location_href pkgId).freeze
+
+      lazy_accessor :pulp_facts, :initializer => :backend_data
+
+      lazy_accessor :description, :license, :buildhost, :vendor, :relativepath, :children, :checksumtype,
+                    :changelog, :group, :size, :url, :build_time, :group,
+                    :initializer => :pulp_facts
+
+      def self.content_api
+        PulpRpmClient::ContentPackagesApi.new(Katello::Pulp3::Api::Yum.new(SmartProxy.pulp_master!).api_client)
+      end
+
+      def self.ids_for_repository(repo_id)
+        repo = Katello::Pulp3::Repository::Yum.new(Katello::Repository.find(repo_id), SmartProxy.pulp_master)
+        repo_content_list = repo.content_list
+        repo_content_list.map { |content| content.try(:pulp_href) }
+      end
+
+      def buildhost
+        backend_data['rpm_buildhost']
+      end
+
+      def vendor
+        backend_data['rpm_vendor']
+      end
+
+      def relativepath
+        backend_data['location_href']
+      end
+
+      def checksumtype
+        backend_data['checksum_type']
+      end
+
+      def changelog
+        backend_data['changelogs']
+      end
+
+      def group
+        backend_data['rpm_group']
+      end
+
+      def build_time
+        backend_data['time_build']
+      end
+
+      def size
+        backend_data['size_package']
+      end
+
+      def license
+        backend_data['rpm_license']
+      end
+
+      def update_model(model)
+        custom_json = {}
+        custom_json['pulp_id'] = backend_data['pulp_href']
+        (PULP_INDEXED_FIELDS - ['pulp_href', 'pkgId', 'location_href']).
+          each { |field| custom_json[field] = backend_data[field] }
+        custom_json['release_sortable'] = Util::Package.sortable_version(backend_data['release'])
+        custom_json['version_sortable'] = Util::Package.sortable_version(backend_data['version'])
+        custom_json['nvra'] = model.build_nvra
+        custom_json['filename'] = backend_data['location_href']
+        custom_json['checksum'] = backend_data['pkgId']
+        model.update_attributes!(custom_json)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Katello
+  module Pulp3
+    class YumMetadataFile < PulpContentUnit
+      include LazyAccessor
+
+      def self.content_api
+        PulpRpmClient::ContentRepoMetadataFilesApi.new(Katello::Pulp3::Repository::Yum.api_client(SmartProxy.pulp_master!))
+      end
+
+      def self.ids_for_repository(repo_id)
+        repo = Katello::Pulp3::Repository::Yum.new(Katello::Repository.find(repo_id), SmartProxy.pulp_master)
+        repo_content_list = repo.content_list
+        repo_content_list.map { |content| content.try(:pulp_href) }
+      end
+
+      # TODO: The Pulp 3 Yum Metadata File API doesn't expose names or file paths yet.
+      # Need to decide if we'll still index Yum Metadata Files in Pulp 3.
+    end
+  end
+end

data/app/services/katello/registration_manager.rb

@@ -46,18 +46,19 @@ module Katello
         host
       end
 
-      def dmi_uuid_fact_id
-        RhsmFactName.find_or_create_by(name: 'dmi::system::uuid').id
-      end
-
       def dmi_uuid_allowed_dups
         Katello::Host::SubscriptionFacet::DMI_UUID_ALLOWED_DUPS
       end
 
       def find_existing_hosts(host_name, host_uuid)
-        ::Host.unscoped.distinct.left_outer_joins(:fact_values)
-          .where("#{::Host.table_name}.name = ? OR (#{FactValue.table_name}.fact_name_id = ?
-          AND #{FactValue.table_name}.value = ? AND #{FactValue.table_name}.value NOT IN (?))", host_name, dmi_uuid_fact_id, host_uuid, dmi_uuid_allowed_dups)
+        query = ::Host.unscoped.where("#{::Host.table_name}.name = ?", host_name)
+
+        unless host_uuid.nil? || dmi_uuid_allowed_dups.include?(host_uuid) # no need to include the dmi uuid lookup
+          query = query.left_outer_joins(:subscription_facet).or(::Host.unscoped.left_outer_joins(:subscription_facet)
+            .where("#{Katello::Host::SubscriptionFacet.table_name}.dmi_uuid = ?", host_uuid)).distinct
+        end
+
+        query
       end
 
       def validate_hosts(hosts, organization, host_name, host_uuid, host_uuid_overridden = false)
@@ -77,8 +78,8 @@ module Katello
 
           if host.name == host_name
             unless Setting[:host_profile_assume] || host.subscription_facet.nil? || host.build || host_uuid_overridden
-              found_uuid = host.fact_values.where(fact_name_id: dmi_uuid_fact_id).first
-              if found_uuid && found_uuid.value != host_uuid
+              current_dmi_uuid = host.subscription_facet.dmi_uuid
+              if current_dmi_uuid && current_dmi_uuid != host_uuid
                 registration_error("This host is reporting a DMI UUID that differs from the existing registration.")
               end
             end
@@ -271,7 +272,7 @@ module Katello
       def populate_subscription_facet(host, activation_keys, consumer_params, uuid)
         subscription_facet = host.subscription_facet || ::Katello::Host::SubscriptionFacet.new(:host => host)
         subscription_facet.last_checkin = Time.now
-        subscription_facet.update_from_consumer_attributes(consumer_params.except(:guestIds, :facts))
+        subscription_facet.update_from_consumer_attributes(consumer_params.except(:guestIds))
         subscription_facet.uuid = uuid
         subscription_facet.user = User.current unless User.current.nil? || User.current.hidden?
         subscription_facet.save!
@@ -297,7 +298,7 @@ module Katello
         host.get_status(::Katello::TraceStatus).destroy
         host.installed_packages.delete_all
 
-        host.rhsm_fact_values.destroy_all
+        host.rhsm_fact_values.delete_all
       end
     end
   end