katello 3.17.0.rc1 → 3.17.0.rc2

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

@@ -16,7 +16,7 @@ module Katello
         end
 
         private def pulp_content
-          SmartProxy.pulp_master.pulp_api.resources.content
+          SmartProxy.pulp_primary.pulp_api.resources.content
         end
       end
     end

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

@@ -42,7 +42,7 @@ module Katello
         fail NotImplementedError
       end
 
-      def master_importer_configuration
+      def primary_importer_configuration
         fail NotImplementedError
       end
 
@@ -58,7 +58,7 @@ module Katello
         fail NotImplementedError
       end
 
-      def generate_master_importer
+      def generate_primary_importer
         fail NotImplementedError
       end
 
@@ -120,7 +120,7 @@ module Katello
       end
 
       def external_url(force_https = false)
-        uri = URI.parse(::SmartProxy.pulp_master.pulp_url)
+        uri = URI.parse(::SmartProxy.pulp_primary.pulp_url)
         uri.scheme = (root.unprotected && !force_https) ? 'http' : 'https'
         uri.path = partial_repo_path
         uri.to_s
@@ -130,7 +130,7 @@ module Katello
         if smart_proxy.pulp_mirror?
           generate_mirror_importer
         elsif repo.in_default_view?
-          generate_master_importer
+          generate_primary_importer
         else #content view repositories don't need any importer configuration
           importer_class.new
         end
@@ -149,17 +149,17 @@ module Katello
         !distributors_match?(repo_details["distributors"])
       end
 
-      def master_importer_connection_options
+      def primary_importer_connection_options
         options = {
           basic_auth_username: root.upstream_username,
           basic_auth_password: root.upstream_password,
           ssl_validation: root.verify_ssl_on_sync?
         }
         options.merge!(proxy_options)
-        options.merge!(master_importer_ssl_options)
+        options.merge!(primary_importer_ssl_options)
       end
 
-      def master_importer_ssl_options
+      def primary_importer_ssl_options
         if root.redhat? && Katello::Resources::CDN::CdnResource.redhat_cdn?(root.url)
           {
             ssl_client_cert: root.product.certificate,

data/app/services/katello/pulp/repository/deb.rb

@@ -4,7 +4,7 @@ module Katello
       class Deb < ::Katello::Pulp::Repository
         REPOSITORY_TYPE = 'deb'.freeze
 
-        def generate_master_importer
+        def generate_primary_importer
           config = {
             feed: root.url,
             remove_missing: root.mirror_on_sync?,
@@ -14,7 +14,7 @@ module Katello
             gpg_keys: root&.gpg_key&.content,
             require_signature: root.gpg_key.present?
           }
-          importer_class.new(config.merge(master_importer_connection_options))
+          importer_class.new(config.merge(primary_importer_connection_options))
         end
 
         def generate_mirror_importer

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

@@ -14,23 +14,23 @@ module Katello
           end
         end
 
-        def generate_master_importer
+        def generate_primary_importer
           config = {
             feed: root.url,
             upstream_name: root.docker_upstream_name,
             tags: root.docker_tags_whitelist,
             enable_v1: false
           }
-          importer_class.new(config.merge(master_importer_connection_options))
+          importer_class.new(config.merge(primary_importer_connection_options))
         end
 
         #what foreman proxies w/ content pull docker content from
         def docker_registry_host
-          if SmartProxy.pulp_master.pulp3_repository_type_support?(Katello::Repository::DOCKER_TYPE)
+          if SmartProxy.pulp_primary.pulp3_repository_type_support?(Katello::Repository::DOCKER_TYPE)
             foreman_url = URI.parse(Setting[:foreman_url]).host.downcase
             "https://#{foreman_url}"
           else
-            pulp_uri = URI.parse(SmartProxy.pulp_master.pulp_url)
+            pulp_uri = URI.parse(SmartProxy.pulp_primary.pulp_url)
             "https://#{pulp_uri.host.downcase}:#{Setting['pulp_docker_registry_port']}"
           end
         end
@@ -56,7 +56,7 @@ module Katello
         end
 
         def external_url(_force_https = false)
-          pulp_uri = URI.parse(SmartProxy.pulp_master.pulp_url)
+          pulp_uri = URI.parse(SmartProxy.pulp_primary.pulp_url)
           "#{pulp_uri.host.downcase}:#{Setting['pulp_docker_registry_port']}/#{repo.container_repository_name}"
         end
 

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

@@ -10,9 +10,9 @@ module Katello
           end
         end
 
-        def generate_master_importer
+        def generate_primary_importer
           config = { feed: root.url }
-          importer_class.new(config.merge(master_importer_connection_options))
+          importer_class.new(config.merge(primary_importer_connection_options))
         end
 
         def generate_mirror_importer

data/app/services/katello/pulp/repository/ostree.rb

@@ -4,12 +4,12 @@ module Katello
       class Ostree < ::Katello::Pulp::Repository
         PULP_MIRROR_SYNC_DEPTH = -1
 
-        def generate_master_importer
+        def generate_primary_importer
           config = {
             feed: root.url,
             depth: root.compute_ostree_upstream_sync_depth
           }
-          Runcible::Models::OstreeImporter.new(config.merge(master_importer_connection_options))
+          Runcible::Models::OstreeImporter.new(config.merge(primary_importer_connection_options))
         end
 
         def generate_mirror_importer

data/app/services/katello/pulp/repository/puppet.rb

@@ -2,12 +2,12 @@ module Katello
   module Pulp
     class Repository
       class Puppet < ::Katello::Pulp::Repository
-        def generate_master_importer
+        def generate_primary_importer
           config = {
             feed: root.url,
             remove_missing: root.mirror_on_sync?
           }
-          importer_class.new(config.merge(master_importer_connection_options))
+          importer_class.new(config.merge(primary_importer_connection_options))
         end
 
         def generate_mirror_importer

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

@@ -4,14 +4,14 @@ module Katello
       class Yum < ::Katello::Pulp::Repository
         REPOSITORY_TYPE = 'yum'.freeze
 
-        def generate_master_importer
+        def generate_primary_importer
           config = {
             download_policy: root.download_policy,
             remove_missing: root.mirror_on_sync?,
             feed: root.url,
             type_skip_list: root.ignorable_content
           }
-          importer_class.new(config.merge(master_importer_connection_options))
+          importer_class.new(config.merge(primary_importer_connection_options))
         end
 
         def generate_mirror_importer
@@ -38,14 +38,14 @@ module Katello
             id: yum_dist_id,
             auto_publish: true
           }
-          if smart_proxy.pulp_master?
+          if smart_proxy.pulp_primary?
             options[:checksum_type] = repo.saved_checksum_type || root.checksum_type
           else
             options[:checksum_type] = nil
           end
           distributors = [Runcible::Models::YumDistributor.new(repo.relative_path, root.unprotected, true, options)]
 
-          if smart_proxy.pulp_master?
+          if smart_proxy.pulp_primary?
             distributors << Runcible::Models::YumCloneDistributor.new(:id => "#{repo.pulp_id}_clone",
                                                                    :destination_distributor_id => yum_dist_id)
             distributors << Runcible::Models::ExportDistributor.new(false, false, repo.relative_path)
@@ -55,7 +55,7 @@ module Katello
 
         def distributors_to_publish(options)
           source_repo_id = options[:source_repository]&.fetch(:id)
-          if (source_repo_id || !repo.master?) && smart_proxy.pulp_master?
+          if (source_repo_id || !repo.primary?) && smart_proxy.pulp_primary?
             source_repository = source_repo_id ? ::Katello::Repository.find(source_repo_id) : repo.target_repository
             source_service = source_repository.backend_service(smart_proxy)
             source_distributor_id = source_service.lookup_distributor_id(Runcible::Models::YumDistributor.type_id)
@@ -144,7 +144,6 @@ module Katello
               :distribution_arch => distribution["arch"],
               :distribution_family => distribution["family"],
               :distribution_variant => distribution["variant"],
-              :distribution_uuid => distribution["_id"],
               :distribution_bootable => self.class.distribution_bootable?(distribution)
             )
           end

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

@@ -12,7 +12,7 @@ module Katello
       end
 
       def default_capsule?
-        @smart_proxy.pulp_master?
+        @smart_proxy.pulp_primary?
       end
 
       def current_repositories(environment_id = nil, content_view_id = nil)

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

@@ -4,11 +4,11 @@ module Katello
       include LazyAccessor
 
       def self.content_api
-        PulpAnsibleClient::ContentCollectionVersionsApi.new(Katello::Pulp3::Api::AnsibleCollection.new(SmartProxy.pulp_master!).api_client)
+        PulpAnsibleClient::ContentCollectionVersionsApi.new(Katello::Pulp3::Api::AnsibleCollection.new(SmartProxy.pulp_primary!).api_client)
       end
 
       def self.ids_for_repository(repo_id)
-        repo = Katello::Pulp3::Repository::AnsibleCollection.new(Katello::Repository.find(repo_id), SmartProxy.pulp_master)
+        repo = Katello::Pulp3::Repository::AnsibleCollection.new(Katello::Repository.find(repo_id), SmartProxy.pulp_primary)
         repo_content_list = repo.content_list
         repo_content_list.map { |content| content.try(:pulp_href) }
       end

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

@@ -58,6 +58,22 @@ module Katello
           fail NotImplementedError
         end
 
+        def exporter_api
+          PulpcoreClient::ExportersPulpApi.new(core_api_client)
+        end
+
+        def importer_api
+          PulpcoreClient::ImportersPulpApi.new(core_api_client)
+        end
+
+        def export_api
+          PulpcoreClient::ExportersCoreExportsApi.new(core_api_client)
+        end
+
+        def import_api
+          PulpcoreClient::ImportersCoreImportsApi.new(core_api_client)
+        end
+
         def orphans_api
           PulpcoreClient::OrphansApi.new(core_api_client)
         end

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

@@ -7,7 +7,7 @@ module Katello
         def create_upload(size = 0, checksum = nil, content_type = nil)
           content_unit_href = nil
           if checksum
-            content_backend_service = SmartProxy.pulp_master.content_service(content_type)
+            content_backend_service = SmartProxy.pulp_primary.content_service(content_type)
             content_list = content_backend_service.content_api.list("sha256": checksum)
             content_unit_href = content_list.results.first.pulp_href unless content_list.results.empty?
             return {"content_unit_href" => content_unit_href} if content_unit_href
@@ -29,7 +29,7 @@ module Katello
             filechunk.write(content)
             filechunk.flush
             actual_chunk_size = File.size(filechunk)
-            uploads_api.update(upload_href, content_range(offset, offset + actual_chunk_size - 1, size), filechunk)
+            uploads_api.update(content_range(offset, offset + actual_chunk_size - 1, size), upload_href, filechunk)
           ensure
             filechunk.close
             filechunk.unlink
@@ -39,7 +39,7 @@ module Katello
         private
 
         def core_api_client
-          PulpcoreClient::ApiClient.new(SmartProxy.pulp_master.pulp3_configuration(PulpcoreClient::Configuration))
+          PulpcoreClient::ApiClient.new(SmartProxy.pulp_primary.pulp3_configuration(PulpcoreClient::Configuration))
         end
 
         def uploads_api

data/app/services/katello/pulp3/content_view_version/export.rb

@@ -0,0 +1,71 @@
+module Katello
+  module Pulp3
+    module ContentViewVersion
+      class Export
+        def initialize(smart_proxy:, content_view_version: nil, destination_server: nil)
+          @smart_proxy = smart_proxy
+          @content_view_version = content_view_version
+          @destination_server = destination_server
+        end
+
+        def exporter_name
+          @content_view_version.name.gsub(/\s/, '_')
+        end
+
+        def generate_exporter_id
+          "#{@content_view_version.organization.label}_#{exporter_name}"
+        end
+
+        def generate_exporter_path
+          export_path = "#{@content_view_version.content_view}/#{@content_view_version.version}/#{@destination_server}/#{date_dir}".gsub(/\s/, '_')
+          "#{@content_view_version.organization.label}/#{export_path}"
+        end
+
+        def date_dir
+          DateTime.now.to_s.gsub(/\W/, '-')
+        end
+
+        def api
+          ::Katello::Pulp3::Api::Core.new(@smart_proxy)
+        end
+
+        def repository_hrefs
+          version_hrefs.map { |href| version_href_to_repository_href(href) }.uniq
+        end
+
+        def version_hrefs
+          if @content_view_version.default?
+            @content_view_version.repositories.yum_type.pluck(:version_href).compact
+          else
+            @content_view_version.archived_repos.yum_type.pluck(:version_href).compact
+          end
+        end
+
+        def version_href_to_repository_href(version_href)
+          version_href.split("/")[0..-3].join("/") + "/"
+        end
+
+        def create_exporter(export_base_dir: Setting['pulpcore_export_destination'])
+          api.exporter_api.create(name: generate_exporter_id,
+                                  path: "#{export_base_dir}/#{generate_exporter_path}",
+                                  repositories: repository_hrefs)
+        end
+
+        def create_export(exporter_href)
+          [api.export_api.create(exporter_href, { versions: version_hrefs })]
+        end
+
+        def fetch_export(exporter_href)
+          api.export_api.list(exporter_href).results.first
+        end
+
+        def destroy_exporter(exporter_href)
+          export_data = fetch_export(exporter_href)
+          api.exporter_api.partial_update(exporter_href, :last_export => nil)
+          api.export_api.delete(export_data.pulp_href) unless export_data.blank?
+          api.exporter_api.delete(exporter_href)
+        end
+      end
+    end
+  end
+end

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

@@ -4,11 +4,11 @@ module Katello
       include LazyAccessor
 
       def self.content_api
-        PulpRpmClient::ContentDistributionTreesApi.new(Katello::Pulp3::Api::Yum.new(SmartProxy.pulp_master!).api_client)
+        PulpRpmClient::ContentDistributionTreesApi.new(Katello::Pulp3::Api::Yum.new(SmartProxy.pulp_primary!).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 = Katello::Pulp3::Repository::Yum.new(Katello::Repository.find(repo_id), SmartProxy.pulp_primary)
         repo_content_list = repo.content_list
         repo_content_list.map { |content| content.try(:pulp_href) }
       end

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

@@ -4,11 +4,11 @@ module Katello
       include LazyAccessor
 
       def self.content_api
-        PulpContainerClient::ContentBlobsApi.new(Katello::Pulp3::Api::Docker.new(SmartProxy.pulp_master!).api_client)
+        PulpContainerClient::ContentBlobsApi.new(Katello::Pulp3::Api::Docker.new(SmartProxy.pulp_primary!).api_client)
       end
 
       def self.ids_for_repository(repo_id)
-        repo = Katello::Pulp3::Repository::Docker.new(Katello::Repository.find(repo_id), SmartProxy.pulp_master)
+        repo = Katello::Pulp3::Repository::Docker.new(Katello::Repository.find(repo_id), SmartProxy.pulp_primary)
         repo_content_list = repo.content_list
         repo_content_list.map { |content| content.try(:pulp_href) }
       end

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

@@ -4,11 +4,11 @@ module Katello
       include LazyAccessor
 
       def self.content_api
-        PulpContainerClient::ContentManifestsApi.new(Katello::Pulp3::Api::Docker.new(SmartProxy.pulp_master!).api_client)
+        PulpContainerClient::ContentManifestsApi.new(Katello::Pulp3::Api::Docker.new(SmartProxy.pulp_primary!).api_client)
       end
 
       def self.ids_for_repository(repo_id)
-        repo = Katello::Pulp3::Repository::Docker.new(Katello::Repository.find(repo_id), SmartProxy.pulp_master)
+        repo = Katello::Pulp3::Repository::Docker.new(Katello::Repository.find(repo_id), SmartProxy.pulp_primary)
         repo_content_list = repo.content_list
         repo_content_list.map { |content| content.try(:pulp_href) }
       end

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

@@ -4,11 +4,11 @@ module Katello
       include LazyAccessor
 
       def self.content_api
-        PulpContainerClient::ContentManifestsApi.new(Katello::Pulp3::Api::Docker.new(SmartProxy.pulp_master!).api_client)
+        PulpContainerClient::ContentManifestsApi.new(Katello::Pulp3::Api::Docker.new(SmartProxy.pulp_primary!).api_client)
       end
 
       def self.ids_for_repository(repo_id)
-        repo = Katello::Pulp3::Repository::Docker.new(Katello::Repository.find(repo_id), SmartProxy.pulp_master)
+        repo = Katello::Pulp3::Repository::Docker.new(Katello::Repository.find(repo_id), SmartProxy.pulp_primary)
         repo_content_list = repo.content_list
         repo_content_list.map { |content| content.try(:pulp_href) }
       end

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

@@ -4,11 +4,11 @@ module Katello
       include LazyAccessor
 
       def self.content_api
-        PulpContainerClient::ContentTagsApi.new(Katello::Pulp3::Api::Docker.new(SmartProxy.pulp_master!).api_client)
+        PulpContainerClient::ContentTagsApi.new(Katello::Pulp3::Api::Docker.new(SmartProxy.pulp_primary!).api_client)
       end
 
       def self.ids_for_repository(repo_id)
-        repo = Katello::Pulp3::Repository::Docker.new(Katello::Repository.find(repo_id), SmartProxy.pulp_master)
+        repo = Katello::Pulp3::Repository::Docker.new(Katello::Repository.find(repo_id), SmartProxy.pulp_primary)
         repo_content_list = repo.content_list
         repo_content_list.map { |content| content.try(:pulp_href) }
       end

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

@@ -4,7 +4,7 @@ module Katello
       include LazyAccessor
 
       def self.content_api
-        PulpRpmClient::ContentAdvisoriesApi.new(Katello::Pulp3::Api::Yum.new(SmartProxy.pulp_master!).api_client)
+        PulpRpmClient::ContentAdvisoriesApi.new(Katello::Pulp3::Api::Yum.new(SmartProxy.pulp_primary!).api_client)
       end
 
       def self.unit_identifier
@@ -20,7 +20,7 @@ module Katello
       end
 
       def self.ids_for_repository(repo_id)
-        repo = Katello::Pulp3::Repository::Yum.new(Katello::Repository.find(repo_id), SmartProxy.pulp_master)
+        repo = Katello::Pulp3::Repository::Yum.new(Katello::Repository.find(repo_id), SmartProxy.pulp_primary)
         repo_content_list = repo.content_list
         repo_content_list.map { |content| content.try(:pulp_href) }
       end