katello 4.2.1 → 4.3.0.rc1

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

@@ -4,26 +4,6 @@ module Katello
   module Pulp3
     module Api
       class AnsibleCollection < Core
-        def self.api_exception_class
-          PulpAnsibleClient::ApiError
-        end
-
-        def self.client_module
-          PulpAnsibleClient
-        end
-
-        def self.remote_class
-          PulpAnsibleClient::AnsibleCollectionRemote
-        end
-
-        def self.distribution_class
-          PulpAnsibleClient::AnsibleAnsibleDistribution
-        end
-
-        def self.repository_sync_url_class
-          PulpAnsibleClient::AnsibleRepositorySyncURL
-        end
-
         def self.copy_class
           PulpAnsibleClient::Copy
         end
@@ -32,26 +12,6 @@ module Katello
           PulpAnsibleClient::RepositoryAddRemoveContent
         end
 
-        def api_client
-          api_client_class(PulpAnsibleClient::ApiClient.new(smart_proxy.pulp3_configuration(PulpAnsibleClient::Configuration)))
-        end
-
-        def repositories_api
-          PulpAnsibleClient::RepositoriesAnsibleApi.new(api_client)
-        end
-
-        def repository_versions_api
-          PulpAnsibleClient::RepositoriesAnsibleVersionsApi.new(api_client)
-        end
-
-        def remotes_api
-          PulpAnsibleClient::RemotesCollectionApi.new(api_client)
-        end
-
-        def distributions_api
-          PulpAnsibleClient::DistributionsAnsibleApi.new(api_client)
-        end
-
         def copy_api
           PulpAnsibleClient::AnsibleCopyApi.new(api_client)
         end

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

@@ -4,53 +4,6 @@ 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
-          api_client_class(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

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

@@ -8,7 +8,7 @@ module Katello
           'RHSMCertGuard'
         end
 
-        def self.client_module
+        def client_module
           PulpCertguardClient
         end
 

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

@@ -4,58 +4,63 @@ module Katello
   module Pulp3
     module Api
       class Core
-        attr_accessor :smart_proxy
+        attr_accessor :smart_proxy, :repository_type
 
-        def initialize(smart_proxy)
+        def initialize(smart_proxy, repository_type = Katello::RepositoryTypeManager.find_by(:pulp3_api_class, self.class))
           @smart_proxy = smart_proxy
+          @repository_type = repository_type
         end
 
-        def self.api_exception_class
-          fail NotImplementedError
+        def client_module
+          repository_type.client_module_class
         end
 
-        def self.client_module
-          fail NotImplementedError
-        end
+        delegate :remote_class, to: :repository_type
 
-        def self.remote_class
+        def self.remote_uln_class
           fail NotImplementedError
         end
 
-        def self.distribution_class
-          fail NotImplementedError
-        end
+        delegate :distribution_class, to: :repository_type
 
-        def self.publication_class
-          fail NotImplementedError
-        end
+        delegate :publication_class, to: :repository_type
 
-        def self.repository_sync_url_class
-          fail NotImplementedError
+        def repository_sync_url_class
+          repository_type.repo_sync_url_class
         end
 
         def api_client
-          fail NotImplementedError
+          config = smart_proxy.pulp3_configuration(repository_type.configuration_class)
+          config.params_encoder = Faraday::FlatParamsEncoder
+          api_client_class(repository_type.api_class.new(config))
+        end
+
+        def api_exception_class
+          client_module::ApiError
         end
 
         def remotes_api
+          repository_type.remotes_api_class.new(api_client)
+        end
+
+        def remotes_uln_api
           fail NotImplementedError
         end
 
         def publications_api
-          fail NotImplementedError #Optional
+          repository_type.publications_api_class.new(api_client) #Optional
         end
 
         def distributions_api
-          fail NotImplementedError
+          repository_type.distributions_api_class.new(api_client)
         end
 
         def repositories_api
-          fail NotImplementedError
+          repository_type.repositories_api_class.new(api_client)
         end
 
         def repository_versions_api
-          fail NotImplementedError
+          repository_type.repository_versions_api_class.new(api_client)
         end
 
         def self.ignore_409_exception(*)
@@ -65,7 +70,7 @@ module Katello
           nil
         end
 
-        def self.repository_version_class
+        def repository_version_class
           client_module::RepositoryVersion
         end
 
@@ -141,7 +146,7 @@ module Katello
 
         def ignore_404_exception(*)
           yield
-        rescue self.class.api_exception_class => e
+        rescue self.api_exception_class => e
           raise e unless e.code == 404
           nil
         end

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

@@ -4,30 +4,6 @@ module Katello
   module Pulp3
     module Api
       class Docker < Core
-        def self.api_exception_class
-          PulpContainerClient::ApiError
-        end
-
-        def self.client_module
-          PulpContainerClient
-        end
-
-        def self.remote_class
-          PulpContainerClient::ContainerContainerRemote
-        end
-
-        def self.distribution_class
-          PulpContainerClient::ContainerContainerDistribution
-        end
-
-        def self.publication_class
-          PulpContainerClient::ContainerPublication
-        end
-
-        def self.repository_sync_url_class
-          PulpContainerClient::RepositorySyncURL
-        end
-
         def self.recursive_manage_class
           PulpContainerClient::RecursiveManage
         end
@@ -36,32 +12,6 @@ module Katello
           PulpContainerClient::TagImage
         end
 
-        def api_client
-          config = smart_proxy.pulp3_configuration(PulpContainerClient::Configuration)
-          config.params_encoder = Faraday::FlatParamsEncoder
-          api_client_class(PulpContainerClient::ApiClient.new(config))
-        end
-
-        def repositories_api
-          PulpContainerClient::RepositoriesContainerApi.new(api_client)
-        end
-
-        def repository_versions_api
-          PulpContainerClient::RepositoriesContainerVersionsApi.new(api_client)
-        end
-
-        def remotes_api
-          PulpContainerClient::RemotesContainerApi.new(api_client)
-        end
-
-        def publications_api
-          PulpContainerClient::PublicationsContainerApi.new(api_client)
-        end
-
-        def distributions_api
-          PulpContainerClient::DistributionsContainerApi.new(api_client)
-        end
-
         def recursive_add_api
           PulpContainerClient::ContainerRecursiveAddApi.new(api_client)
         end

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

@@ -4,57 +4,9 @@ module Katello
   module Pulp3
     module Api
       class File < Core
-        def self.api_exception_class
-          PulpFileClient::ApiError
-        end
-
-        def self.client_module
-          PulpFileClient
-        end
-
-        def self.remote_class
-          PulpFileClient::FileFileRemote
-        end
-
-        def self.distribution_class
-          PulpFileClient::FileFileDistribution
-        end
-
-        def self.publication_class
-          PulpFileClient::FileFilePublication
-        end
-
-        def self.repository_sync_url_class
-          PulpFileClient::RepositorySyncURL
-        end
-
         def self.add_remove_content_class
           PulpFileClient::RepositoryAddRemoveContent
         end
-
-        def api_client
-          api_client_class(PulpFileClient::ApiClient.new(smart_proxy.pulp3_configuration(PulpFileClient::Configuration)))
-        end
-
-        def repositories_api
-          PulpFileClient::RepositoriesFileApi.new(api_client)
-        end
-
-        def repository_versions_api
-          PulpFileClient::RepositoriesFileVersionsApi.new(api_client)
-        end
-
-        def remotes_api
-          PulpFileClient::RemotesFileApi.new(api_client)
-        end
-
-        def publications_api
-          PulpFileClient::PublicationsFileApi.new(api_client)
-        end
-
-        def distributions_api
-          PulpFileClient::DistributionsFileApi.new(api_client)
-        end
       end
     end
   end

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

@@ -4,33 +4,14 @@ module Katello
   module Pulp3
     module Api
       class Generic < Core
-        attr_accessor :repository_type
-
         def initialize(smart_proxy, repository_type)
-          @repository_type = repository_type
-          super(smart_proxy)
+          super
         end
 
         def self.api_exception_class
           fail NotImplementedError
         end
 
-        def self.client_module(repository_type)
-          repository_type.client_module_class
-        end
-
-        def self.remote_class(repository_type)
-          repository_type.remote_class
-        end
-
-        def self.distribution_class(repository_type)
-          repository_type.distribution_class
-        end
-
-        def self.publication_class(repository_type)
-          repository_type.publication_class
-        end
-
         def self.repository_sync_url_class(repository_type)
           repository_type.repo_sync_url_class
         end
@@ -38,30 +19,6 @@ module Katello
         def self.add_remove_content_class
           fail NotImplementedError
         end
-
-        def api_client
-          api_client_class(@repository_type.api_class.new(smart_proxy.pulp3_configuration(@repository_type.configuration_class)))
-        end
-
-        def repositories_api
-          @repository_type.repositories_api_class.new(api_client)
-        end
-
-        def repository_versions_api
-          @repository_type.repository_versions_api_class.new(api_client)
-        end
-
-        def remotes_api
-          @repository_type.remotes_api_class.new(api_client)
-        end
-
-        def publications_api
-          @repository_type.publications_api_class.new(api_client)
-        end
-
-        def distributions_api
-          @repository_type.distributions_api_class.new(api_client)
-        end
       end
     end
   end

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

@@ -4,28 +4,8 @@ module Katello
   module Pulp3
     module Api
       class Yum < Core
-        def self.api_exception_class
-          PulpRpmClient::ApiError
-        end
-
-        def self.client_module
-          PulpRpmClient
-        end
-
-        def self.remote_class
-          PulpRpmClient::RpmRpmRemote
-        end
-
-        def self.distribution_class
-          PulpRpmClient::RpmRpmDistribution
-        end
-
-        def self.publication_class
-          PulpRpmClient::RpmRpmPublication
-        end
-
-        def self.repository_sync_url_class
-          PulpRpmClient::RpmRepositorySyncURL
+        def self.remote_uln_class
+          PulpRpmClient::RpmUlnRemote
         end
 
         def self.rpm_package_group_class
@@ -40,28 +20,8 @@ module Katello
           PulpRpmClient::RepositoryAddRemoveContent
         end
 
-        def api_client
-          api_client_class(PulpRpmClient::ApiClient.new(smart_proxy.pulp3_configuration(PulpRpmClient::Configuration)))
-        end
-
-        def repositories_api
-          PulpRpmClient::RepositoriesRpmApi.new(api_client)
-        end
-
-        def repository_versions_api
-          PulpRpmClient::RepositoriesRpmVersionsApi.new(api_client)
-        end
-
-        def remotes_api
-          PulpRpmClient::RemotesRpmApi.new(api_client)
-        end
-
-        def publications_api
-          PulpRpmClient::PublicationsRpmApi.new(api_client)
-        end
-
-        def distributions_api
-          PulpRpmClient::DistributionsRpmApi.new(api_client)
+        def remotes_uln_api
+          PulpRpmClient::RemotesUlnApi.new(api_client)
         end
 
         def copy_api

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

@@ -16,12 +16,16 @@ module Katello
         repository_type.content_types.find { |type| type.content_type == content_type }.pulp3_api.new(repository_type.pulp3_api_class.new(SmartProxy.pulp_primary!, repository_type).api_client)
       end
 
-      def update_model(model, repository_type, content_type)
+      def update_model(model, content_type)
+        content_type = ::Katello::RepositoryTypeManager.find_content_type(content_type)
+
         custom_json = {}
         custom_json['pulp_id'] = backend_data['pulp_href']
-        custom_json['name'] = repository_type.model_name.call(backend_data)
-        custom_json['version'] = repository_type.model_version.call(backend_data)
-        custom_json['content_type'] = content_type
+        custom_json['name'] = content_type&.model_name&.call(backend_data)
+        custom_json['version'] = content_type&.model_version&.call(backend_data)
+        custom_json['filename'] = content_type&.model_filename&.call(backend_data)
+        custom_json['additional_metadata'] = content_type&.model_additional_metadata&.call(backend_data)
+        custom_json['content_type'] = content_type&.label
         model.update!(custom_json)
       end
     end

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

@@ -4,6 +4,10 @@ module Katello
   module Pulp3
     class Repository
       class AnsibleCollection < ::Katello::Pulp3::Repository
+        def copy_content_for_source(source_repository, _options = {})
+          copy_units_by_href(source_repository.ansible_collections.pluck(:pulp_id))
+        end
+
         def remote_options
           common_remote_options.merge(url: root.url.chomp('/').concat('/'),
                                       requirements_file: root.ansible_collection_requirements.blank? ? nil : root.ansible_collection_requirements,

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

@@ -8,6 +8,7 @@ module Katello
 
         def remote_options
           deb_remote_options = {
+            policy: root.download_policy,
             distributions: root.deb_releases
           }
           deb_remote_options[:components] = root.deb_components.present? ? root.deb_components : nil
@@ -63,9 +64,8 @@ module Katello
           "/pulp/deb/#{repo.relative_path}/".sub('//', '/')
         end
 
-        def copy_content_for_source
-          # TODO
-          fail NotImplementedError
+        def copy_content_for_source(source_repository, _options = {})
+          copy_units_by_href(source_repository.debs.pluck(:pulp_id))
         end
 
         def regenerate_applicability

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

@@ -7,11 +7,18 @@ module Katello
         end
 
         def distribution_options(path)
-          {
+          options = {
             base_path: path,
-            publication: repo.publication_href,
             name: "#{generate_backend_object_name}"
           }
+
+          if ::Katello::RepositoryTypeManager.find(repo.content_type).pulp3_skip_publication
+            options.merge!(repository_version: repo.version_href)
+          else
+            options.merge!(publication: repo.publication_href)
+          end
+
+          options
         end
 
         def remote_options
@@ -24,69 +31,7 @@ module Katello
         end
 
         def partial_repo_path
-          repo.repository_type.partial_repo_path
-        end
-
-        def api
-          @api ||= repo.repository_type.pulp3_api(smart_proxy)
-        end
-
-        def self.api(smart_proxy, repo)
-          api_class = RepositoryTypeManager.find_by(:pulp3_service_class, self).pulp3_api_class
-          api_class ? api_class.new(smart_proxy, repo) : Katello::Pulp3::Api::Core.new(smart_proxy)
-        end
-
-        def create_distribution(path)
-          distribution_data = api.class.distribution_class(repo.repository_type).new(secure_distribution_options(path))
-          api.distributions_api.create(distribution_data)
-        end
-
-        def create_remote
-          remote_file_data = api.class.remote_class(repo.repository_type).new(remote_options)
-          response = api.remotes_api.create(remote_file_data)
-          repo.update!(:remote_href => response.pulp_href)
-        end
-
-        def refresh_distributions
-          dist = lookup_distributions(base_path: repo.relative_path).first
-
-          # 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(repo.repository_type)::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
-
-        def sync(options = {})
-          repository_sync_url_data = api.class.repository_sync_url_class(repo.repository_type).new(sync_url_params(options))
-          [api.repositories_api.sync(repository_reference.repository_href, repository_sync_url_data)]
-        end
-
-        def create_publication
-          publication_data = api.class.publication_class(repo.repository_type).new(publication_options(repo.version_href))
-          api.publications_api.create(publication_data)
+          "/pulp/content/#{repo.relative_path}/".sub('//', '/')
         end
       end
     end

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

@@ -19,6 +19,16 @@ module Katello
           options.merge!(url: uri.to_s, policy: root.download_policy)
         end
 
+        def publication_options(repository_version)
+          options = super(repository_version)
+          options.merge(
+            {
+              metadata_checksum_type: root.checksum_type,
+              package_checksum_type: root.checksum_type
+            }
+          )
+        end
+
         def specific_create_options
           { retain_package_versions: retain_package_versions_count }
         end