katello 3.14.1 → 3.15.0.rc1

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

@@ -4,34 +4,6 @@ module Katello
   module Pulp3
     class Repository
       class AnsibleCollection < ::Katello::Pulp3::Repository
-        def self.api_client(smart_proxy)
-          PulpAnsibleClient::ApiClient.new(smart_proxy.pulp3_configuration(PulpAnsibleClient::Configuration))
-        end
-
-        def client_class
-          PulpAnsibleClient
-        end
-
-        def api_exception_class
-          PulpAnsibleClient::ApiError
-        end
-
-        def remote_class
-          PulpAnsibleClient::CollectionRemote
-        end
-
-        def remotes_api
-          PulpAnsibleClient::RemotesCollectionApi.new(api_client)
-        end
-
-        def distribution_class
-          PulpAnsibleClient::AnsibleDistribution
-        end
-
-        def distributions_api
-          PulpAnsibleClient::DistributionsAnsibleApi.new(api_client)
-        end
-
         def remote_options
           if root.url.blank?
             super
@@ -44,7 +16,7 @@ module Katello
           {
             base_path: path,
             repository_version: repo.version_href,
-            name: "#{backend_object_name}"
+            name: "#{generate_backend_object_name}"
           }
         end
       end

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

@@ -1,49 +1,17 @@
-require 'pulp_docker_client'
+require 'pulp_container_client'
 
 module Katello
   module Pulp3
     class Repository
       class Docker < ::Katello::Pulp3::Repository
-        def self.api_client(smart_proxy)
-          PulpDockerClient::ApiClient.new(smart_proxy.pulp3_configuration(PulpDockerClient::Configuration))
-        end
-
-        def api_exception_class
-          PulpDockerClient::ApiError
-        end
-
-        def client_class
-          PulpDockerClient
-        end
-
-        def remote_class
-          PulpDockerClient::DockerRemote
-        end
-
-        def remotes_api
-          PulpDockerClient::RemotesDockerApi.new(api_client)
-        end
-
-        def distribution_class
-          PulpDockerClient::DockerDistribution
-        end
-
-        def distributions_api
-          PulpDockerClient::DistributionsDockerApi.new(api_client)
-        end
-
-        def recursive_manage_class
-          PulpDockerClient::RecursiveManage
-        end
-
-        def recursive_add_api
-          PulpDockerClient::DockerRecursiveAddApi.new(api_client)
+        def relative_path
+          repo.container_repository_name
         end
 
         def remote_options
           options = {url: root.url, upstream_name: root.docker_upstream_name}
           if root.docker_tags_whitelist && root.docker_tags_whitelist.any?
-            options[:whitelist_tags] = root.docker_tags_whitelist.join(",")
+            options[:whitelist_tags] = root.docker_tags_whitelist
           else
             options[:whitelist_tags] = nil
           end
@@ -51,28 +19,40 @@ module Katello
         end
 
         def mirror_remote_options
-          docker_options = {
+          {
             url: "https://#{SmartProxy.pulp_master.pulp3_host!.downcase}",
             upstream_name: repo.container_repository_name
           }
-          common_mirror_remote_options.merge(docker_options)
         end
 
         def distribution_options(path)
           {
             base_path: path,
             repository_version: repo.version_href,
-            name: "#{backend_object_name}"
+            name: "#{generate_backend_object_name}"
           }
         end
 
+        def create_version(options = {})
+          api.repositories_api.add(repository_reference.repository_href,
+                                   api.class.recursive_manage_class.new(content_units: options[:add_content_units]))
+          api.repositories_api.remove(repository_reference.repository_href,
+                                      api.class.recursive_manage_class.new(content_units: options[:remove_content_units]))
+        end
+
+        def add_content(content_unit_href)
+          content_unit_href = [content_unit_href] unless content_unit_href.is_a?(Array)
+          api.repositories_api.add(repository_reference.repository_href, content_units: content_unit_href)
+        end
+
         def copy_units_recursively(unit_hrefs, clear_repo = false)
           tasks = []
           if clear_repo
-            tasks << create_version(:remove_content_units => ["*"])
+            tasks << api.repositories_api.remove(repository_reference.repository_href,
+                                                 api.class.recursive_manage_class.new(:content_units => ["*"]))
           end
-          tasks << recursive_add_api.create(recursive_manage_class.new(repository: repository_reference.repository_href,
-                                                                       content_units: unit_hrefs))
+          tasks << api.repositories_api.add(repository_reference.repository_href,
+                                            api.class.recursive_manage_class.new(content_units: unit_hrefs))
           tasks
         end
 
@@ -89,7 +69,7 @@ module Katello
           end
 
           if whitelist_ids.empty?
-            copy_units_recursively(source_repository.docker_tags.pluck(:pulp_id) - blacklist_ids, true)
+            copy_units_recursively(source_repository.docker_tags.pluck(:pulp_id).sort - blacklist_ids, true)
           else
             copy_units_recursively(whitelist_ids - blacklist_ids, true)
           end

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

@@ -4,42 +4,6 @@ module Katello
   module Pulp3
     class Repository
       class File < ::Katello::Pulp3::Repository
-        def api_exception_class
-          PulpFileClient::ApiError
-        end
-
-        def client_class
-          PulpFileClient
-        end
-
-        def remote_class
-          PulpFileClient::FileRemote
-        end
-
-        def self.api_client(smart_proxy)
-          PulpFileClient::ApiClient.new(smart_proxy.pulp3_configuration(PulpFileClient::Configuration))
-        end
-
-        def remotes_api
-          PulpFileClient::RemotesFileApi.new(api_client)
-        end
-
-        def publication_class
-          PulpFileClient::FilePublication
-        end
-
-        def publications_api
-          PulpFileClient::PublicationsFileApi.new(api_client)
-        end
-
-        def distribution_class
-          PulpFileClient::FileDistribution
-        end
-
-        def distributions_api
-          PulpFileClient::DistributionsFileApi.new(api_client)
-        end
-
         def copy_content_for_source(source_repository, _options = {})
           copy_units_by_href(source_repository.files.pluck(:pulp_id))
         end
@@ -48,7 +12,7 @@ module Katello
           {
             base_path: path,
             publication: repo.publication_href,
-            name: "#{backend_object_name}"
+            name: "#{generate_backend_object_name}"
           }
         end
 

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

@@ -4,42 +4,6 @@ module Katello
   module Pulp3
     class Repository
       class Yum < ::Katello::Pulp3::Repository
-        def self.api_client(smart_proxy)
-          PulpRpmClient::ApiClient.new(smart_proxy.pulp3_configuration(PulpRpmClient::Configuration))
-        end
-
-        def api_exception_class
-          PulpRpmClient::ApiError
-        end
-
-        def client_class
-          PulpRpmClient
-        end
-
-        def remote_class
-          PulpRpmClient::RpmRemote
-        end
-
-        def remotes_api
-          PulpRpmClient::RemotesRpmApi.new(api_client)
-        end
-
-        def publication_class
-          PulpRpmClient::RpmPublication
-        end
-
-        def publications_api
-          PulpRpmClient::PublicationsRpmApi.new(api_client)
-        end
-
-        def distribution_class
-          PulpRpmClient::RpmDistribution
-        end
-
-        def distributions_api
-          PulpRpmClient::DistributionsRpmApi.new(api_client)
-        end
-
         def remote_options
           if root.url.blank?
             common_remote_options.merge(url: nil, policy: root.download_policy)
@@ -52,9 +16,44 @@ module Katello
           {
             base_path: path,
             publication: repo.publication_href,
-            name: "#{backend_object_name}"
+            name: "#{generate_backend_object_name}"
           }
         end
+
+        def import_distribution_data
+          distribution = ::Katello::Pulp3::Distribution.fetch_content_list(repository_version: repo.version_href)
+          if distribution.results.present?
+            repo.update_attributes!(
+              :distribution_version => distribution.results.first.release_version,
+              :distribution_arch => distribution.results.first.arch,
+              :distribution_family => distribution.results.first.release_name,
+              :distribution_uuid => distribution.results.first.pulp_href,
+              :distribution_bootable => self.class.distribution_bootable?(distribution)
+            )
+            unless distribution.results.first.variants.empty?
+              unless distribution.results.first.variants.first.name.nil?
+                repo.update_attributes!(:distribution_variant => distribution.results.first.variants.first.name)
+              end
+            end
+          end
+        end
+
+        def self.distribution_bootable?(distribution)
+          file_paths = distribution.results.first.images.map(&:path)
+          file_paths.any? do |path|
+            path.include?('vmlinuz') || path.include?('pxeboot') || path.include?('kernel.img') || path.include?('initrd.img') || path.include?('boot.iso')
+          end
+        end
+
+        def copy_content_for_source
+          # TODO
+          fail NotImplementedError
+        end
+
+        def regenerate_applicability
+          # TODO
+          fail NotImplementedError
+        end
       end
     end
   end

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

@@ -0,0 +1,171 @@
+module Katello
+  module Pulp3
+    class RepositoryMirror
+      attr_accessor :repo_service
+      delegate :repo, to: :repo_service
+      delegate :smart_proxy, to: :repo_service
+
+      delegate :api, to: :repo_service
+
+      def initialize(repository_service)
+        @repo_service = repository_service
+      end
+
+      def backend_object_name
+        #Create repos in pulp3 instance with the name as this repo's pulp_id
+        repo.pulp_id
+      end
+
+      def refresh_entities
+        href = remote_href
+        if href
+          [api.remotes_api.partial_update(href, remote_options)]
+        else
+          create_remote
+          []
+        end
+      end
+
+      def needs_updates?
+        remote = fetch_remote
+        return true if remote.blank?
+        options = repo_service.compute_remote_options
+        options.keys.any? { |key| remote.send(key) != options[key] }
+      end
+
+      def remote_href
+        fetch_remote.try(:pulp_href)
+      end
+
+      def create_entities
+        create
+        create_remote unless fetch_remote
+      end
+
+      def create
+        api.repositories_api.create(name: backend_object_name)
+      end
+
+      def update
+        api.repositories_api.update(repository_href, name: backend_object_name)
+      end
+
+      def delete(href = repository_href)
+        api.repositories_api.delete(href) if href
+      end
+
+      def repository_href
+        fetch_repository.try(:pulp_href)
+      end
+
+      def fetch_repository
+        repo_service.api.list_all(name: backend_object_name).first
+      end
+
+      def version_href
+        fetch_repository.latest_version_href
+      end
+
+      def create_version(options = {})
+        api.repository_versions_api.create(repository_href, options)
+      end
+
+      def distribution_options(path, options = {})
+        ret = {
+          base_path: path,
+          name: "#{backend_object_name}"
+        }
+        ret[:publication] = options[:publication] if options.key? :publication
+        ret[:repository_version] = options[:repository_version] if options.key? :repository_version
+        ret
+      end
+
+      def remote_options
+        base_options = common_remote_options
+        if (type_specific_options = repo_service.try(:mirror_remote_options))
+          base_options.merge(type_specific_options)
+        else
+          base_options.merge(url: remote_feed_url)
+        end
+      end
+
+      def create_remote
+        remote_file_data = @repo_service.api.class.remote_class.new(remote_options)
+        api.remotes_api.create(remote_file_data)
+      end
+
+      def compute_remote_options
+        repo_service.compute_remote_options(remote_options)
+      end
+
+      def fetch_remote
+        api.remotes_list(name: backend_object_name).first
+      end
+
+      def sync
+        api_module = api.class.client_module
+        repository_sync_url_data = api_module::RepositorySyncURL.new(remote: remote_href, mirror: true)
+        [api.repositories_api.sync(repository_href, repository_sync_url_data)]
+      end
+
+      def common_remote_options
+        remote_options = {
+          name: backend_object_name
+        }
+        remote_options.merge!(ssl_remote_options)
+      end
+
+      def ssl_remote_options
+        ueber_cert = ::Cert::Certs.ueber_cert(repo.root.organization)
+        {
+          client_cert: ueber_cert[:cert],
+          client_key: ueber_cert[:key],
+          ca_cert: ::Cert::Certs.ca_cert,
+          tls_validation: true
+        }
+      end
+
+      def remote_feed_url
+        uri = ::SmartProxy.pulp_master.pulp3_uri!
+        uri.path = repo_service.partial_repo_path
+        uri.to_s
+      end
+
+      def create_publication
+        if (href = version_href)
+          publication_data = api.class.publication_class.new(repository_version: href)
+          api.publications_api.create(publication_data)
+        end
+      end
+
+      def refresh_distributions(options = {})
+        path = repo_service.relative_path
+        dist_params = {}
+        dist_params[:publication] = options[:publication] if options[:publication]
+        dist_params[:repository_version] = version_href if options[:use_repository_version]
+        dist_options = distribution_options(path, dist_params)
+        if (distro = repo_service.lookup_distributions(base_path: path).first) ||
+          (distro = repo_service.lookup_distributions(name: "#{backend_object_name}").first)
+          # update dist
+          dist_options = dist_options.except(:name, :base_path)
+          api.distributions_api.partial_update(distro.pulp_href, dist_options)
+        else
+          # create dist
+          distribution_data = api.class.distribution_class.new(dist_options)
+          api.distributions_api.create(distribution_data)
+        end
+      end
+
+      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 create_distribution(path)
+        distribution_data = api.class.distribution_class.new(distribution_options(path))
+        repo_service.distributions_api.create(distribution_data)
+      end
+    end
+  end
+end