katello 4.0.3 → 4.1.0.rc1

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

@@ -3,6 +3,7 @@ module Katello
     module ContentViewVersion
       class Export
         include ImportExportCommon
+        attr_reader :smart_proxy, :content_view_version, :destination_server, :from_content_view_version
 
         def initialize(smart_proxy:,
                         content_view_version: nil,
@@ -23,21 +24,21 @@ module Katello
         end
 
         def repositories(fetch_all: false)
-          repos = if @content_view_version.default?
-                    @content_view_version.repositories.yum_type
+          repos = if content_view_version.default?
+                    content_view_version.repositories.exportable
                   else
-                    @content_view_version.archived_repos.yum_type
+                    content_view_version.archived_repos.exportable
                   end
           if fetch_all
             repos
           else
-            repos.immediate
+            repos.immediate_or_none
           end
         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}"
+          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
@@ -53,8 +54,8 @@ module Katello
         def create_export(exporter_href, chunk_size: nil)
           options = { versions: version_hrefs }
           options[:chunk_size] = "#{chunk_size}MB" if chunk_size
-          if @from_content_view_version
-            from_exporter = Export.new(smart_proxy: @smart_proxy, content_view_version: @from_content_view_version)
+          if from_content_view_version
+            from_exporter = Export.new(smart_proxy: smart_proxy, content_view_version: from_content_view_version)
             start_versions = from_exporter.version_hrefs
 
             # current_cvv - cvv_from , i.e. repos in current cvv that are not in from
@@ -92,7 +93,7 @@ module Katello
 
         def validate!(fail_on_missing_content: true, validate_incremental: true)
           validate_repositories_immediate! if fail_on_missing_content
-          validate_incremental_export! if validate_incremental && !@from_content_view_version.blank?
+          validate_incremental_export! if validate_incremental && !from_content_view_version.blank?
         end
 
         def validate_repositories_immediate!
@@ -102,14 +103,14 @@ module Katello
                    " it contains repositories without the 'immediate' download policy."\
                    " Update the download policy and sync affected repositories. Once synced republish the content view"\
                    " and export the generated version. \n %{repos}" %
-                   { content_view: @content_view_version.content_view.name,
-                     current: @content_view_version.version,
+                   { content_view: content_view_version.content_view.name,
+                     current: content_view_version.version,
                      repos: self.class.generate_product_repo_strings(repositories: non_immediate_repos)})
           end
         end
 
         def validate_incremental_export!
-          from_exporter = Export.new(smart_proxy: @smart_proxy, content_view_version: @from_content_view_version)
+          from_exporter = Export.new(smart_proxy: smart_proxy, content_view_version: from_content_view_version)
 
           from_exporter_repos = generate_repo_mapping(from_exporter.repositories(fetch_all: true))
           to_exporter_repos = generate_repo_mapping(repositories(fetch_all: true))
@@ -120,9 +121,9 @@ module Katello
 
           if invalid_repos_exist
             fail _("The exported Content View Version '%{content_view} %{current}' cannot be incrementally updated from version '%{from}'."\
-                   " Please do a full export." % { content_view: @content_view_version.content_view.name,
-                                                   current: @content_view_version.version,
-                                                   from: @from_content_view_version.version})
+                   " Please do a full export." % { content_view: content_view_version.content_view.name,
+                                                   current: content_view_version.version,
+                                                   from: from_content_view_version.version})
           end
         end
 
@@ -137,36 +138,13 @@ module Katello
         end
 
         def generate_metadata
-          ret = { organization: @content_view_version.organization.name,
-                  repository_mapping: {},
-                  content_view: @content_view_version.content_view.name,
-                  content_view_version: @content_view_version.slice(:major, :minor),
-                  incremental: @from_content_view_version.present?
-          }
-
-          unless @from_content_view_version.blank?
-            ret[:from_content_view_version] = {
-              major: @from_content_view_version.major,
-              minor: @from_content_view_version.minor
-            }
-          end
-
-          repositories.each do |repo|
-            next if repo.version_href.blank?
-            pulp3_repo = fetch_repository_info(repo.version_href).name
-            ret[:repository_mapping][pulp3_repo] = {
-              repository: repo.root.name,
-              product: repo.root.product.name,
-              redhat: repo.redhat?
-            }
-          end
-          ret
+          MetadataGenerator.new(export_service: self).generate!
         end
 
         def self.find_library_export_view(create_by_default: false,
                                           destination_server:,
                                           organization:)
-          name = "Export-Library"
+          name = ::Katello::ContentView::EXPORT_LIBRARY
           name += "-#{destination_server}" unless destination_server.blank?
           select_method = create_by_default ? :first_or_create : :first
           ::Katello::ContentView.where(name: name, organization: organization).send(select_method)

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

@@ -13,10 +13,10 @@ module Katello
 
         def repository_mapping
           mapping = {}
-          @metadata[:repository_mapping].each do |key, value|
+          @metadata[:repositories].each do |key, value|
             repo = @content_view_version.importable_repositories.joins(:root, :product).
-                        where("#{::Katello::Product.table_name}" => {:name => value[:product]},
-                                                  "#{::Katello::RootRepository.table_name}" => {:name => value[:repository]}).first
+                        where("#{::Katello::Product.table_name}" => {:label => value[:product][:label]},
+                                                  "#{::Katello::RootRepository.table_name}" => {:label => value[:label]}).first
             next unless repo&.version_href
             repo_info = fetch_repository_info(repo.version_href)
             mapping[key] = repo_info.name
@@ -43,8 +43,59 @@ module Katello
           api.importer_api.delete(importer_href)
         end
 
-        def self.check!(content_view:, metadata:, path:)
-          ImportValidator.new(content_view: content_view, metadata: metadata, path: path).check!
+        def self.check!(content_view:, metadata:, path:, smart_proxy:)
+          ImportValidator.new(smart_proxy: smart_proxy,
+                               content_view: content_view,
+                               metadata: metadata,
+                               path: path).check!
+        end
+
+        def self.create_or_update_gpg!(organization:, params:)
+          return if params.blank?
+          gpg = organization.gpg_keys.find_by(:name => params[:name])
+          if gpg
+            gpg.update!(params.except(:name))
+          else
+            gpg = organization.gpg_keys.create!(params)
+          end
+          gpg
+        end
+
+        def self.metadata_map(metadata, product_only: false, custom_only: false)
+          # Create a map that looks like -> {[product, repo]: {name: 'Foo Repo', label:.....}}
+          # these values should be curated from the metadata.
+          metadata_map = {}
+          metadata[:repositories].values.each do |repo|
+            next if custom_only && repo[:redhat]
+            if product_only
+              metadata_map[repo[:product][:label]] = repo[:product]
+            else
+              metadata_map[[repo[:product][:label], repo[:label]]] = repo
+            end
+          end
+          metadata_map
+        end
+
+        def self.intersecting_repos_library_and_metadata(organization:, metadata:)
+          # Returns repositories in library that are part of the metadata
+          # In other words if metadata had repos {label:foo, product: bar}
+          # this would match it to the repo with the label foo and product bar
+          # in the library.
+          queries = metadata_map(metadata).keys.map do |product_label, repo_label|
+            repositories_in_library(organization).
+                        where("#{Katello::Product.table_name}.label": product_label,
+                              "#{Katello::RootRepository.table_name}.label": repo_label)
+          end
+          queries.inject(&:or)
+        end
+
+        def self.repositories_in_library(organization)
+          Katello::Repository.
+                    in_default_view.
+                    exportable.
+                    joins(:product => :provider, :content_view_version => :content_view).
+                    joins(:root).
+                    where("#{::Katello::ContentView.table_name}.organization_id": organization)
         end
 
         def self.reset_content_view_repositories_from_metadata!(content_view:, metadata:)
@@ -56,35 +107,29 @@ module Katello
           # 3) Adds the repositories matched from the dump
           # The main intent of this method is to assume that the user intends for the
           # content view to exaclty look like what is specified in metadata
+          repo_ids = intersecting_repos_library_and_metadata(organization: content_view.organization,
+                                                             metadata: metadata).
+                                                             pluck("#{Katello::Repository.table_name}.id")
+          content_view.update!(repository_ids: repo_ids)
+        end
 
-          repos_in_library = Katello::Repository.
-                    in_default_view.
-                    yum_type.
-                    joins(:product => :provider, :content_view_version => :content_view).
-                    joins(:root).
-                    where("#{::Katello::ContentView.table_name}.organization_id" => content_view.organization_id).
-                    pluck("#{::Katello::Repository.table_name}.id",
-                          "#{::Katello::RootRepository.table_name}.name",
-                          "#{::Katello::Product.table_name}.name",
-                          "#{::Katello::Provider.table_name}.provider_type"
-                          )
-          repos_in_library_map = {}
-          # repos_in_library_map is going to look like {['repo1', 'product1', false] => 100, ['repo1', 'product1', true] => 200 }
-          repos_in_library.each do |id, repo, product, provider_type|
-            repos_in_library_map[[repo, product, provider_type == Katello::Provider::REDHAT]] = id
+        def self.find_or_create_import_view(organization:, metadata:, library: false)
+          if library
+            metadata = { name: ::Katello::ContentView::IMPORT_LIBRARY,
+                         label: ::Katello::ContentView::IMPORT_LIBRARY,
+                         description: "Content View used for importing library"
+                        }
           end
 
-          repo_ids = metadata[:repository_mapping].values.map do |repo|
-            repos_in_library_map[[repo[:repository], repo[:product], repo[:redhat]]]
+          cv = ::Katello::ContentView.find_by(label: metadata[:label],
+                                              organization: organization,
+                                              import_only: true)
+          if cv.blank?
+            ::Katello::ContentView.create!(metadata.merge(organization: organization, import_only: true))
+          else
+            cv.update!(description: cv_metadata[:description]) if cv.description != metadata[:description]
+            cv
           end
-          content_view.update!(repository_ids: repo_ids)
-        end
-
-        def self.find_or_create_library_import_view(organization)
-          name = ::Katello::ContentView::IMPORT_LIBRARY
-          ::Katello::ContentView.where(name: name,
-                                       organization: organization,
-                                       import_only: true).first_or_create
         end
       end
     end

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

@@ -0,0 +1,32 @@
+module Katello
+  module Pulp3
+    module ContentViewVersion
+      class ImportGpgKeys
+        attr_accessor :organization, :metadata
+
+        def initialize(organization:, metadata:)
+          self.organization = organization
+          self.metadata = metadata
+        end
+
+        def create_or_update_gpg!(params)
+          return if params.blank?
+          gpg = organization.gpg_keys.find_by(:name => params[:name])
+          if gpg
+            gpg.update!(params.except(:name))
+          else
+            gpg = organization.gpg_keys.create!(params)
+          end
+          gpg
+        end
+
+        def import!
+          return if metadata[:gpg_keys].blank?
+          metadata[:gpg_keys].values.each do |gpg|
+            create_or_update_gpg!(gpg)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -2,19 +2,33 @@ module Katello
   module Pulp3
     module ContentViewVersion
       class ImportValidator
-        attr_accessor :metadata, :path, :content_view
-        def initialize(content_view:, path:, metadata:)
+        attr_accessor :metadata, :path, :content_view, :smart_proxy
+
+        delegate :organization, :to => :content_view
+
+        def initialize(content_view:, path:, metadata:, smart_proxy:)
           self.content_view = content_view
           self.path = path
           self.metadata = metadata
+          self.smart_proxy = smart_proxy
         end
 
         def check!
+          ensure_pulp_importable!
           unless content_view.default?
             ensure_importing_cvv_does_not_exist!
             ensure_from_cvv_exists!
           end
-          ensure_repositories_metadata_are_in_the_library!
+          ensure_metadata_matches_repos_in_library!
+          ensure_redhat_repositories_metadata_are_in_the_library!
+        end
+
+        def ensure_pulp_importable!
+          api = ::Katello::Pulp3::Api::Core.new(@smart_proxy).importer_check_api
+          response = api.pulp_import_check_post(toc: "#{@path}/#{@metadata[:toc]}")
+          unless response.toc.is_valid
+            fail response.toc.messages.join("\n")
+          end
         end
 
         def ensure_importing_cvv_does_not_exist!
@@ -43,21 +57,42 @@ module Katello
           end
         end
 
-        def ensure_repositories_metadata_are_in_the_library!
-          repos_in_library = Katello::Repository.
-                              in_default_view.
-                              yum_type.
-                              joins(:product => :provider, :content_view_version => :content_view).
-                              joins(:root).
-                              where("#{::Katello::ContentView.table_name}.organization_id" => content_view.organization_id).
-                              pluck("#{::Katello::Product.table_name}.name",
-                                    "#{::Katello::RootRepository.table_name}.name",
-                                    "#{::Katello::Provider.table_name}.provider_type"
-                                    )
+        def repos_in_library
+          ::Katello::Pulp3::ContentViewVersion::Import.
+                              repositories_in_library(content_view.organization)
+        end
+
+        def metadata_map
+          @metadata_map ||= ::Katello::Pulp3::ContentViewVersion::Import.metadata_map(metadata)
+        end
 
+        def ensure_metadata_matches_repos_in_library!
+          interested_repos = ::Katello::Pulp3::ContentViewVersion::Import.
+                                      intersecting_repos_library_and_metadata(organization: organization,
+                                                                              metadata: metadata)
+          bad_repos = interested_repos.select do |repo|
+            repo_in_metadata = metadata_map[[repo.product.label, repo.label]]
+            repo.redhat? != repo_in_metadata[:redhat] ||
+              repo.slice(:name, :label, :content_type) != repo_in_metadata.slice(:name, :label, :content_type)
+          end
+
+          if bad_repos.any?
+            repos_to_report = bad_repos.map { |repo| [repo.product.label, repo.label] }
+            fail _("The following repositories provided in the import metadata have an incorrect content type or provider type. "\
+                    "Make sure the export and import repositories are of the same type before importing\n "\
+                    "%{repos}" % { content_view: content_view.name,
+                                   repos: generate_product_repo_i18n_string(repos_to_report).join("")}
+                  )
+          end
+        end
+
+        def ensure_redhat_repositories_metadata_are_in_the_library!
           # repos_in_library look like [["prod1", "repo1", "Anonymous"], ["prod2", "repo2", "Red Hat"]]
-          product_repos_in_library = repos_in_library.map { |product, repo, provider| [product, repo, provider == ::Katello::Provider::REDHAT] }
-          product_repos_in_metadata = metadata[:repository_mapping].values.map { |repo| [repo[:product], repo[:repository], repo[:redhat]] }
+          rh_repos_in_library = repos_in_library.redhat
+          product_repos_in_library = rh_repos_in_library.map { |repo| [repo.product.label, repo.label] }
+          product_repos_in_metadata = metadata[:repositories].values.map { |repo| [repo[:product][:label], repo[:label]] if repo[:redhat] }
+          product_repos_in_metadata.compact!
+
           # product_repos_in_library & product_repos_in_metadata look like [["prod1", "repo1", false], ["prod2", "repo2", false]]
           product_repos_not_in_library = product_repos_in_metadata - product_repos_in_library
           unless product_repos_not_in_library.blank?
@@ -71,11 +106,8 @@ module Katello
 
         def generate_product_repo_i18n_string(product_repos)
           # product_repos look like [["prod1", "repo1", false], ["prod2", "repo2", false]]
-          product_repos.map do |product, repo, redhat|
-            repo_type = redhat ? _("Red Hat") : _("Custom")
-            _("\n* Product = '%{product}', Repository = '%{repository}', Repository Type = '%{repo_type}'" % { product: product,
-                                                                                                               repository: repo,
-                                                                                                               repo_type: repo_type})
+          product_repos.map do |product, repo|
+            _("\n* Product = '%{product}', Repository = '%{repository}'" % { product: product, repository: repo })
           end
         end
       end

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

@@ -0,0 +1,47 @@
+module Katello
+  module Pulp3
+    module ContentViewVersion
+      class ImportableProducts
+        attr_accessor :creatable, :updatable, :organization, :metadata
+
+        def initialize(organization:, metadata:)
+          self.organization = organization
+          self.metadata = metadata
+          self.creatable = []
+          self.updatable = []
+        end
+
+        def products_in_library
+          # Get the product labels in library
+          return @products_in_library unless @products_in_library.blank?
+          @products_in_library = Set.new(::Katello::Product.in_org(organization).custom.pluck(:label))
+        end
+
+        def generate!
+          # This returns a 2 different list of importable products
+          # creatable: products that are part of the metadata but not in the library.
+          #            They are ready to be created
+          # updatable: products that are both in the metadata and library.
+          #            These may contain updates to the product and hence ready to be updated.
+          metadata[:products].each do |product_label, params|
+            next if params[:redhat]
+            if params[:gpg_key].blank?
+              params[:gpg_key_id] = nil
+            else
+              params[:gpg_key_id] = organization.gpg_keys.find_by(name: params[:gpg_key][:name]).id
+            end
+            params = params.except(:gpg_key, :redhat)
+            if products_in_library.include? product_label
+              # add to the update list if product is already available
+              product = ::Katello::Product.in_org(organization).find_by(label: product_label)
+              updatable << { product: product, options: params.except(:name, :label) }
+            else
+              # add to the create list if its  a new product
+              creatable << { product: ::Katello::Product.new(params) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Katello
+  module Pulp3
+    module ContentViewVersion
+      class ImportableRepositories
+        attr_accessor :creatable, :updatable, :organization, :metadata
+
+        def initialize(organization:, metadata:)
+          self.organization = organization
+          self.metadata = metadata
+          self.creatable = []
+          self.updatable = []
+        end
+
+        def repositories_in_library
+          return @repositories_in_library unless @repositories_in_library.blank?
+
+          # fetch a list of [product, repo] pairs for every non-redhat library repo
+          product_repos_in_library = Import.repositories_in_library(organization).custom.
+                                      pluck("#{Katello::Product.table_name}.label",
+                                            "#{Katello::RootRepository.table_name}.label")
+          @repositories_in_library = Set.new(product_repos_in_library.compact)
+        end
+
+        def generate!
+          # This set's up a 2 different list of importable root repositories
+          # creatable: repos that are part of the metadata but not in the library.
+          #         They are ready to be created
+          # updatable: repo that are both in the metadata and library.
+          #         These may contain updates to the repo and hence ready to be updated.
+          metadata_map = Import.metadata_map(metadata, custom_only: true)
+          metadata_map.keys.each do |product_label, repo_label|
+            product = Katello::Product.in_org(organization).find_by(label: product_label)
+            fail _("Unable to find product '%s' in organization '%s'" % [product_label, organization.name]) if product.blank?
+            params = metadata_map[[product_label, repo_label]]
+            if params[:gpg_key].blank?
+              params[:gpg_key_id] = nil
+            else
+              params[:gpg_key_id] = organization.gpg_keys.find_by(name: params[:gpg_key][:name]).id
+            end
+            params = params.except(:redhat, :product, :gpg_key)
+            if repositories_in_library.include? [product_label, repo_label]
+              repo = ::Katello::RootRepository.find_by(product: product, label: repo_label)
+              updatable << { repository: repo, options: params.except(:label, :name, :content_type) }
+            else
+              creatable << { repository: product.add_repo(params) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+module Katello
+  module Pulp3
+    module ContentViewVersion
+      class MetadataGenerator
+        attr_accessor :export_service, :gpg_keys, :products
+
+        delegate :repositories, :content_view_version, :from_content_view_version, :to => :export_service
+        delegate :content_view, :to => :content_view_version
+        delegate :organization, :to => :content_view
+
+        def initialize(export_service:)
+          self.export_service = export_service
+          self.gpg_keys = {}
+          self.products = {}
+        end
+
+        def generate!
+          ret = { organization: organization.name,
+                  repositories: {},
+                  content_view: content_view.slice(:name, :label, :description),
+                  content_view_version: content_view_version.slice(:major, :minor, :description),
+                  incremental: from_content_view_version.present?
+          }
+
+          unless from_content_view_version.blank?
+            ret[:from_content_view_version] = from_content_view_version.slice(:major, :minor)
+          end
+          repositories.each do |repo|
+            next if repo.version_href.blank?
+            pulp3_repo = export_service.fetch_repository_info(repo.version_href).name
+            ret[:repositories][pulp3_repo] = generate_repository_metadata(repo)
+          end
+
+          zip_products(ret[:repositories].values)
+
+          zip_gpg_keys(ret[:repositories].values)
+          zip_gpg_keys(products.values)
+
+          ret[:products] = products
+          ret[:gpg_keys] = gpg_keys
+          ret
+        end
+
+        def generate_repository_metadata(repo)
+          repo.slice(:name, :label, :description, :arch, :content_type, :unprotected,
+                     :checksum_type, :os_versions, :major, :minor).
+            merge(product: generate_product_metadata(repo.product),
+                  gpg_key: generate_gpg_metadata(repo.gpg_key),
+                  redhat: repo.redhat?)
+        end
+
+        def generate_product_metadata(product)
+          product.slice(:name, :label, :description).
+            merge(gpg_key: generate_gpg_metadata(product.gpg_key),
+                  redhat: product.redhat?)
+        end
+
+        def generate_gpg_metadata(gpg)
+          return {} if gpg.blank?
+          gpg.slice(:name, :content_type, :content)
+        end
+
+        def zip_gpg_keys(entities)
+          # this goes through each repo/product
+          # identifies gpg keys
+          # updates the gpg_keys map if necessary
+          # replaces the value of gpg_key by just the name
+          # For example:
+          # Input: {label: 'repo', gpg_key: {name: 'who', content: 'great'}}
+          # Output: {label: 'repo', gpg_key: {name: 'who'}}
+          entities.each do |entity|
+            gpg = entity[:gpg_key]
+            unless gpg.blank? || gpg_keys.key?(gpg[:name])
+              gpg_keys[gpg[:name]] = gpg
+            end
+            entity[:gpg_key] = gpg.slice(:name)
+          end
+        end
+
+        def zip_products(repos)
+          # this goes through each repo
+          # identifies product
+          # updates the products map if necessary
+          # replaces the value of product by just the label
+          # For example:
+          # Input: {label: 'repo', product: {name: 'prod', label: 'foo', description: 'great'}}
+          # Output: {label: 'repo', product: {label: 'foo'}}
+          repos.each do |repo|
+            product = repo[:product]
+            unless products.key?(product[:label])
+              products[product[:label]] = product
+            end
+            repo[:product] = product.slice(:label)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -59,7 +59,7 @@ module Katello
 
       def self.pulp_units_batch_for_repo(repository, options = {})
         fetch_identifiers = options.fetch(:fetch_identifiers, false)
-        page_size = options.fetch(:page_size, SETTINGS[:katello][:pulp][:bulk_load_size])
+        page_size = options.fetch(:page_size, Setting[:bulk_load_size])
         repository_version_href = repository.version_href
         page_opts = { "offset" => 0, repository_version: repository_version_href, limit: page_size }
         page_opts[:fields] = self.const_get(:PULP_INDEXED_FIELDS).join(",") if self.constants.include?(:PULP_INDEXED_FIELDS)

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

@@ -8,7 +8,11 @@ module Katello
           if root.url.blank?
             super
           else
-            common_remote_options.merge(url: root.url.chomp("/"), requirements_file: root.ansible_collection_requirements.blank? ? nil : root.ansible_collection_requirements)
+            common_remote_options.merge(url: root.url,
+                                        requirements_file: root.ansible_collection_requirements.blank? ? nil : root.ansible_collection_requirements,
+                                        auth_url: root.ansible_collection_auth_url,
+                                        token: root.ansible_collection_auth_token,
+                                        tls_validation: root.verify_ssl_on_sync)
           end
         end
 

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

@@ -27,7 +27,8 @@ module Katello
           popts = super(repository_version)
           popts.merge!(
             {
-              structured: true, # publish real suites (e.g. 'stable')
+              # structured is not necessary for subscription-manager
+              #structured: true, # publish real suites (e.g. 'stable')
               simple: true # publish all into 'default'-suite
             }
           )

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

@@ -207,22 +207,6 @@ module Katello
           tasks
         end
 
-        def copy_all(source_repository, mirror: false)
-          if mirror
-            data = PulpRpmClient::RepositoryAddRemoveContent.new(
-                      base_version: source_repository.version_href)
-
-            [api.repositories_api.modify(repository_reference.repository_href, data)]
-          else
-            data = PulpRpmClient::Copy.new
-            data.config = [{
-              source_repo_version: source_repository.version_href,
-              dest_repo: repository_reference.repository_href
-            }]
-            [api.copy_api.copy_content(data)]
-          end
-        end
-
         def remove_all_content_from_repo(repo_href)
           data = PulpRpmClient::RepositoryAddRemoveContent.new(
             remove_content_units: ['*'])