katello 4.1.4 → 4.2.0.rc1

data/app/models/katello/kt_environment.rb

@@ -7,7 +7,7 @@ module Katello
     self.table_name = "katello_environments"
     include Ext::LabelFromName
 
-    belongs_to :organization, :class_name => "Organization", :inverse_of => :environments
+    belongs_to :organization, :class_name => "Organization", :inverse_of => :kt_environments
     has_many :activation_keys, :class_name => "Katello::ActivationKey",
                                :dependent => :restrict_with_exception, :foreign_key => :environment_id
 

data/app/models/katello/product.rb

@@ -14,13 +14,13 @@ module Katello
     belongs_to :organization, :inverse_of => :products
     belongs_to :provider, :inverse_of => :products, :class_name => 'Katello::Provider'
     belongs_to :sync_plan, :inverse_of => :products, :class_name => 'Katello::SyncPlan'
-    belongs_to :gpg_key, :inverse_of => :products, :class_name => "Katello::GpgKey"
+    belongs_to :gpg_key, :inverse_of => :products, :class_name => "Katello::ContentCredential"
     has_many :product_contents, :foreign_key => 'product_id', :class_name => "Katello::ProductContent", :dependent => :destroy
     has_many :contents, :through => :product_contents
     has_many :displayable_product_contents, -> { displayable }, :foreign_key => 'product_id', :class_name => "Katello::ProductContent", :dependent => :destroy
-    belongs_to :ssl_ca_cert, :class_name => "Katello::GpgKey", :inverse_of => :ssl_ca_products
-    belongs_to :ssl_client_cert, :class_name => "Katello::GpgKey", :inverse_of => :ssl_client_products
-    belongs_to :ssl_client_key, :class_name => "Katello::GpgKey", :inverse_of => :ssl_key_products
+    belongs_to :ssl_ca_cert, :class_name => "Katello::ContentCredential", :inverse_of => :ssl_ca_products
+    belongs_to :ssl_client_cert, :class_name => "Katello::ContentCredential", :inverse_of => :ssl_client_products
+    belongs_to :ssl_client_key, :class_name => "Katello::ContentCredential", :inverse_of => :ssl_key_products
     has_many :root_repositories, :class_name => "Katello::RootRepository", :dependent => :restrict_with_exception
     has_many :repositories, :through => :root_repositories
 

data/app/models/katello/repository.rb

@@ -29,6 +29,7 @@ module Katello
     DOCKER_TYPE = 'docker'.freeze
     OSTREE_TYPE = 'ostree'.freeze
     ANSIBLE_COLLECTION_TYPE = 'ansible_collection'.freeze
+    GENERIC_TYPE = 'generic'.freeze
 
     EXPORTABLE_TYPES = [YUM_TYPE, FILE_TYPE, ANSIBLE_COLLECTION_TYPE].freeze
 
@@ -57,6 +58,9 @@ module Katello
     has_many :repository_srpms, :class_name => "Katello::RepositorySrpm", :dependent => :delete_all
     has_many :srpms, :through => :repository_srpms
 
+    has_many :repository_generic_content_units, :class_name => "Katello::RepositoryGenericContentUnit", :dependent => :delete_all
+    has_many :generic_content_units, :through => :repository_generic_content_units
+
     has_many :repository_file_units, :class_name => "Katello::RepositoryFileUnit", :dependent => :delete_all
     has_many :files, :through => :repository_file_units, :source => :file_unit
     alias_attribute :file_units, :files
@@ -130,6 +134,7 @@ module Katello
     scope :docker_type, -> { with_type(DOCKER_TYPE) }
     scope :ostree_type, -> { with_type(OSTREE_TYPE) }
     scope :ansible_collection_type, -> { with_type(ANSIBLE_COLLECTION_TYPE) }
+    scope :generic_type, -> { with_type(Katello::RepositoryTypeManager.enabled_repository_types.select { |_, v| v.pulp3_service_class == Katello::Pulp3::Repository::Generic }.keys) }
     scope :non_archived, -> { where('environment_id is not NULL') }
     scope :archived, -> { where('environment_id is NULL') }
     scope :in_published_environments, -> { in_content_views(Katello::ContentView.non_default).where.not(:environment_id => nil) }
@@ -148,7 +153,7 @@ module Katello
     scoped_search :rename => :product, :on => :name, :relation => :product, :complete_value => true
     scoped_search :rename => :product_id, :on => :id, :relation => :product
     scoped_search :on => :content_type, :relation => :root, :complete_value => -> do
-      Katello::RepositoryTypeManager.repository_types.keys.index_by { |value| value.to_sym }
+      Katello::RepositoryTypeManager.enabled_repository_types.keys.index_by { |value| value.to_sym }
     end
     scoped_search :on => :content_view_id, :relation => :content_view_repositories, :validator => ScopedSearch::Validators::INTEGER, :only_explicit => true
     scoped_search :on => :distribution_version, :complete_value => true
@@ -166,7 +171,7 @@ module Katello
     scoped_search :on => :content_label, :ext_method => :search_by_content_label
 
     delegate :product, :redhat?, :custom?, :to => :root
-    delegate :yum?, :docker?, :deb?, :file?, :ostree?, :ansible_collection?, :to => :root
+    delegate :yum?, :docker?, :deb?, :file?, :ostree?, :ansible_collection?, :generic?, :to => :root
     delegate :name, :label, :docker_upstream_name, :url, :download_concurrency, :to => :root
 
     delegate :name, :created_at, :updated_at, :major, :minor, :gpg_key_id, :gpg_key, :arch, :label, :url, :unprotected,
@@ -178,6 +183,7 @@ module Katello
              :ansible_collection_auth_url, :ansible_collection_auth_token, :http_proxy_policy, :http_proxy_id, :to => :root
 
     delegate :content_id, to: :root, allow_nil: true
+    delegate :repository_type, to: :root
 
     def self.with_type(content_type)
       joins(:root).where("#{RootRepository.table_name}.content_type" => content_type)
@@ -872,10 +878,6 @@ module Katello
       parts.map { |x| x.gsub(/[^-\w]/, "_") }.join("-").downcase
     end
 
-    def repository_type
-      RepositoryTypeManager.find(self.content_type)
-    end
-
     def copy_indexed_data(source_repository)
       repository_type.content_types_to_index.each do |type|
         type.model_class.copy_repository_associations(source_repository, self)
@@ -901,7 +903,11 @@ module Katello
       else
         repository_type.content_types_to_index.each do |type|
           Katello::Logging.time("CONTENT_INDEX", data: {type: type.model_class}) do
-            type.model_class.import_for_repository(self)
+            if self.generic?
+              type.model_class.import_for_repository(self, type.content_type)
+            else
+              type.model_class.import_for_repository(self)
+            end
           end
         end
         repository_type.index_additional_data_proc&.call(self)

data/app/models/katello/repository_generic_content_unit.rb

@@ -0,0 +1,7 @@
+module Katello
+  class RepositoryGenericContentUnit < Katello::Model
+    # Do not use active record callbacks in this join model.  Direct INSERTs and DELETEs are done
+    belongs_to :repository, :inverse_of => :repository_generic_content_units, :class_name => 'Katello::Repository'
+    belongs_to :generic_content_unit, :inverse_of => :repository_generic_content_units, :class_name => 'Katello::GenericContentUnit'
+  end
+end

data/app/models/katello/root_repository.rb

@@ -1,4 +1,5 @@
 module Katello
+  # rubocop:disable Metrics/ClassLength
   class RootRepository < Katello::Model
     audited :except => [:content_id]
     serialize :ignorable_content
@@ -41,10 +42,10 @@ module Katello
     ALLOWED_OS_VERSIONS = [RHEL6, RHEL7, RHEL8].freeze
 
     belongs_to :product, :inverse_of => :root_repositories, :class_name => "Katello::Product"
-    belongs_to :gpg_key, :inverse_of => :root_repositories, :class_name => "Katello::GpgKey"
-    belongs_to :ssl_ca_cert, :class_name => "Katello::GpgKey", :inverse_of => :ssl_ca_root_repos
-    belongs_to :ssl_client_cert, :class_name => "Katello::GpgKey", :inverse_of => :ssl_client_root_repos
-    belongs_to :ssl_client_key, :class_name => "Katello::GpgKey", :inverse_of => :ssl_key_root_repos
+    belongs_to :gpg_key, :inverse_of => :root_repositories, :class_name => "Katello::ContentCredential"
+    belongs_to :ssl_ca_cert, :class_name => "Katello::ContentCredential", :inverse_of => :ssl_ca_root_repos
+    belongs_to :ssl_client_cert, :class_name => "Katello::ContentCredential", :inverse_of => :ssl_client_root_repos
+    belongs_to :ssl_client_key, :class_name => "Katello::ContentCredential", :inverse_of => :ssl_key_root_repos
     belongs_to :http_proxy, :inverse_of => :root_repositories
     has_many :repositories, :class_name => "Katello::Repository", :foreign_key => :root_id,
                           :inverse_of => :root, :dependent => :destroy
@@ -68,6 +69,7 @@ module Katello
     validate :ensure_ostree_repo_protected, :if => :ostree?
     validate :ensure_compatible_download_policy, :if => :yum?
     validate :ensure_valid_collection_attributes, :if => :ansible_collection?
+    validate :ensure_valid_auth_url_token, :if => :ansible_collection?
     validate :ensure_valid_ignorable_content
     validate :ensure_valid_docker_tags_whitelist
     validate :ensure_valid_os_versions
@@ -81,9 +83,9 @@ module Katello
     validates :ostree_upstream_sync_depth, :presence => true, :numericality => { :only_integer => true },
       :if => proc { |r| r.ostree? && r.ostree_upstream_sync_policy == OSTREE_UPSTREAM_SYNC_POLICY_CUSTOM }
     validates :content_type, :inclusion => {
-      :in => ->(_) { Katello::RepositoryTypeManager.repository_types.keys },
+      :in => ->(_) { Katello::RepositoryTypeManager.enabled_repository_types.keys },
       :allow_blank => false,
-      :message => ->(_, _) { _("must be one of the following: %s") % Katello::RepositoryTypeManager.repository_types.keys.join(', ') }
+      :message => ->(_, _) { _("is not enabled. must be one of the following: %s") % Katello::RepositoryTypeManager.enabled_repository_types.keys.join(', ') }
     }
     validates :download_policy, inclusion: {
       :in => ::Runcible::Models::YumImporter::DOWNLOAD_POLICIES,
@@ -120,6 +122,10 @@ module Katello
       Repository.where(:root => self)
     end
 
+    def repository_type
+      RepositoryTypeManager.find(self.content_type)
+    end
+
     def custom?
       !redhat?
     end
@@ -253,7 +259,14 @@ module Katello
     end
 
     def ensure_valid_upstream_authorization
-      return if (self.upstream_username.blank? && self.upstream_password.blank?)
+      # Make sure that the upstream_username / upstream_password is really unset
+      # in case if the string is maybe just ""
+      if self.upstream_username.blank? && self.upstream_password.blank?
+        self.upstream_username = nil
+        self.upstream_password = nil
+        return
+      end
+
       if redhat?
         errors.add(:base, N_("Upstream username and password may only be set on custom repositories."))
       elsif self.upstream_username.blank?
@@ -263,6 +276,20 @@ module Katello
       end
     end
 
+    def ensure_valid_auth_url_token
+      if self.ansible_collection_auth_url.blank? && self.ansible_collection_auth_token.blank?
+        self.ansible_collection_auth_url = nil
+        self.ansible_collection_auth_token = nil
+        return
+      end
+
+      if self.ansible_collection_auth_url.blank?
+        errors.add(:base, N_("Auth token requires Auth URL be set."))
+      elsif !self.ansible_collection_auth_token
+        errors.add(:base, N_("Auth URL requires Auth token be set."))
+      end
+    end
+
     def custom_content_path
       parts = []
       # We generate repo path only for custom product content. We add this
@@ -306,6 +333,10 @@ module Katello
       self.content_type == Repository::ANSIBLE_COLLECTION_TYPE
     end
 
+    def generic?
+      Katello::RepositoryTypeManager.generic_repository_types(enabled_only: false).values.map(&:id).map(&:to_s).flatten.include? self.content_type
+    end
+
     def metadata_generate_needed?
       (%w(unprotected checksum_type container_repsoitory_name) & previous_changes.keys).any?
     end

data/app/models/setting/content.rb

@@ -143,6 +143,11 @@ class Setting::Content < Setting
       self.set('host_profile_assume', N_("Allow new Host registrations to assume registered profiles with matching hostname " \
                   "as long as the registering DMI UUID is not used by another host."),
                true, N_('Host Profile Assume')),
+      self.set('host_profile_assume_build_can_change', N_("Allow Host registrations to bypass 'Host Profile Assume' " \
+                  "as long as the host is in build mode."),
+               false, N_('Host Profile Can Change In Build')),
+      self.set('host_re_register_build_only', N_("Allow hosts to re-register themselves only when they are in build mode"),
+               false, N_('Host Can Re-Register Only In Build')),
       self.set('host_tasks_workers_pool_size', N_("Amount of workers in the pool to handle the execution of host-related tasks. When set to 0, the default queue will be used instead. Restart of the dynflowd/foreman-tasks service is required."),
                5, N_('Host Tasks Workers Pool Size')),
       self.set('applicability_batch_size', N_("Number of host applicability calculations to process per task."),

data/app/services/cert/certs.rb

@@ -12,20 +12,28 @@ module Cert
       File.read(SETTINGS[:katello][:candlepin][:ca_cert_file])
     end
 
-    def self.ssl_client_cert
-      @ssl_client_cert ||= OpenSSL::X509::Certificate.new(File.read(ssl_client_cert_filename))
+    def self.ssl_client_cert(use_admin_as_cn_cert: false)
+      @ssl_client_cert ||= OpenSSL::X509::Certificate.new(File.read(ssl_client_cert_filename(use_admin_as_cn_cert: use_admin_as_cn_cert)))
     end
 
-    def self.ssl_client_cert_filename
-      Setting['pulp_client_cert']
+    def self.ssl_client_cert_filename(use_admin_as_cn_cert: false)
+      if use_admin_as_cn_cert
+        Setting[:pulp_client_cert]
+      else
+        Setting[:ssl_certificate]
+      end
     end
 
-    def self.ssl_client_key
-      @ssl_client_key ||= OpenSSL::PKey::RSA.new(File.read(ssl_client_key_filename))
+    def self.ssl_client_key(use_admin_as_cn_cert: false)
+      @ssl_client_key ||= OpenSSL::PKey::RSA.new(File.read(ssl_client_key_filename(use_admin_as_cn_cert: use_admin_as_cn_cert)))
     end
 
-    def self.ssl_client_key_filename
-      Setting['pulp_client_key']
+    def self.ssl_client_key_filename(use_admin_as_cn_cert: false)
+      if use_admin_as_cn_cert
+        Setting[:pulp_client_key]
+      else
+        Setting[:ssl_priv_key]
+      end
     end
 
     def self.verify_ueber_cert(organization)

data/app/services/katello/applicability/applicable_content_helper.rb

@@ -92,8 +92,7 @@ module Katello
         ::Katello::ModuleStream.
           joins("inner join katello_available_module_streams on
             katello_module_streams.name = katello_available_module_streams.name and
-            katello_module_streams.stream = katello_available_module_streams.stream and
-            katello_module_streams.context = katello_available_module_streams.context").
+            katello_module_streams.stream = katello_available_module_streams.stream").
           joins("inner join katello_host_available_module_streams on
             katello_available_module_streams.id = katello_host_available_module_streams.available_module_stream_id").
           where("katello_host_available_module_streams.host_id = :content_facet_id and

data/app/services/katello/candlepin/consumer.rb

@@ -155,6 +155,12 @@ module Katello
           'Ubuntu'
         elsif name =~ /oracle/
           'OracleLinux'
+        elsif name =~ /almalinux/
+          'AlmaLinux'
+        elsif name =~ /rocky/
+          'Rocky'
+        elsif name =~ /amazon/
+          'Amazon'
         else
           'Unknown'
         end

data/app/services/katello/component_view_presenter.rb

@@ -0,0 +1,27 @@
+module Katello
+  class ComponentViewPresenter < SimpleDelegator
+    attr_accessor :view, :component_view
+
+    def initialize(composite_cv, component_content_view = nil, content_view_component = nil)
+      @view = component_content_view
+      cv_component_record = content_view_component || Katello::ContentViewComponent.where(composite_content_view_id: composite_cv.id, content_view_id: @view.id).first
+      @component_view = cv_component_record || Katello::ContentViewComponent.new(composite_content_view_id: composite_cv.id, content_view_id: @view.id, latest: true)
+      super(@component_view)
+    end
+
+    def self.component_presenter(composite_cv, status, views:)
+      case status
+      when 'All'
+        views.map { |component_content_view| ComponentViewPresenter.new(composite_cv, component_content_view) }
+      when 'Added'
+        added_cvs = views.map { |component_content_view| Katello::ContentViewComponent.where(composite_content_view_id: composite_cv.id, content_view_id: component_content_view.id).first }
+        added_cvs.compact.map { |content_view| ComponentViewPresenter.new(composite_cv, nil, content_view) }
+      when 'Not added'
+        not_added_cvs = views.reject { |component_content_view| Katello::ContentViewComponent.where(composite_content_view_id: composite_cv.id, content_view_id: component_content_view.id).first }
+        not_added_cvs.map { |component_content_view| ComponentViewPresenter.new(composite_cv, nil, Katello::ContentViewComponent.where(composite_content_view_id: composite_cv.id, content_view_id: component_content_view.id, latest: true).new) }
+      else
+        views.map { |component_content_view| ComponentViewPresenter.new(cv, component_content_view) }
+      end
+    end
+  end
+end

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

@@ -21,7 +21,7 @@ module Katello
       end
 
       def self.instance_for_type(repo, smart_proxy)
-        Katello::RepositoryTypeManager.repository_types[repo.root.content_type].service_class.new(repo, smart_proxy)
+        Katello::RepositoryTypeManager.enabled_repository_types[repo.root.content_type].service_class.new(repo, smart_proxy)
       end
 
       def unit_type_id(_uploads = [])

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

@@ -17,8 +17,8 @@ module Katello
             :debug => true
           },
           :cert_auth => {
-            :ssl_client_cert => ::Cert::Certs.ssl_client_cert,
-            :ssl_client_key => ::Cert::Certs.ssl_client_key
+            :ssl_client_cert => ::Cert::Certs.ssl_client_cert(use_admin_as_cn_pulp_cert: true),
+            :ssl_client_key => ::Cert::Certs.ssl_client_key(use_admin_as_cn_pulp_cert: true)
           }
         }
 

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

@@ -65,6 +65,10 @@ module Katello
           nil
         end
 
+        def self.repository_version_class
+          client_module::RepositoryVersion
+        end
+
         def cancel_task(task_href)
           data = PulpcoreClient::TaskResponse.new(state: 'canceled')
           self.class.ignore_409_exception do

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

@@ -0,0 +1,68 @@
+require "pulpcore_client"
+
+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)
+        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
+
+        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
+end

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

@@ -0,0 +1,29 @@
+module Katello
+  module Pulp3
+    class GenericContentUnit < PulpContentUnit
+      include LazyAccessor
+      CONTENT_TYPE = "generic_content_unit".freeze
+
+      def self.fetch_content_list(page_opts, repository_type, content_type)
+        content_unit_list page_opts, repository_type, content_type
+      end
+
+      def self.content_unit_list(page_opts, repository_type, content_type)
+        self.content_api(repository_type, content_type).list page_opts
+      end
+
+      def self.content_api(repository_type, content_type)
+        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)
+        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
+        model.update!(custom_json)
+      end
+    end
+  end
+end

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

@@ -72,7 +72,11 @@ module Katello
               (response["count"] && page_opts["offset"] < response["count"]) ||
               page_opts["offset"] == 0)
             page_opts = page_options page_opts
-            response = fetch_content_list page_opts
+            if repository.generic?
+              response = fetch_content_list page_opts, repository.repository_type, options[:content_type]
+            else
+              response = fetch_content_list page_opts
+            end
             response = response.as_json.with_indifferent_access
             yielder.yield response[:results]
             page_opts[:offset] += page_size

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

@@ -0,0 +1,94 @@
+module Katello
+  module Pulp3
+    class Repository
+      class Generic < ::Katello::Pulp3::Repository
+        def copy_content_for_source(source_repository, _options = {})
+          copy_units_by_href(source_repository.files.pluck(:pulp_id))
+        end
+
+        def distribution_options(path)
+          {
+            base_path: path,
+            publication: repo.publication_href,
+            name: "#{generate_backend_object_name}"
+          }
+        end
+
+        def remote_options
+          generic_remote_options = JSON.parse(root.generic_remote_options)
+          if generic_remote_options.any?
+            common_remote_options.merge(generic_remote_options.select { |_, v| !v.nil? }).symbolize_keys
+          else
+            common_remote_options
+          end
+        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)
+        end
+      end
+    end
+  end
+end

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

@@ -17,6 +17,10 @@ module Katello
           options.merge!(url: url, policy: root.download_policy)
         end
 
+        def specific_create_options
+          { retain_package_versions: retain_package_versions_count }
+        end
+
         def extract_sles_token
           return [nil, nil] if root.url.blank?
           uri = URI(root.url)
@@ -214,11 +218,6 @@ module Katello
           api.repositories_api.modify(repo_href, data)
         end
 
-        def repair(repository_version_href)
-          data = PulpRpmClient::RepositoryVersion.new
-          api.repository_versions_api.repair(repository_version_href, data)
-        end
-
         def remove_all_content
           data = PulpRpmClient::RepositoryAddRemoveContent.new(
             remove_content_units: ['*'])

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

@@ -60,6 +60,11 @@ module Katello
         !repo.publication_href.nil?
       end
 
+      def repair(repository_version_href)
+        data = api.class.repository_version_class.new
+        api.repository_versions_api.repair(repository_version_href, data)
+      end
+
       def skip_types
         nil
       end
@@ -99,7 +104,7 @@ module Katello
       end
 
       def self.instance_for_type(repo, smart_proxy)
-        Katello::RepositoryTypeManager.repository_types[repo.root.content_type].pulp3_service_class.new(repo, smart_proxy)
+        Katello::RepositoryTypeManager.enabled_repository_types[repo.root.content_type].pulp3_service_class.new(repo, smart_proxy)
       end
 
       def should_purge_empty_contents?
@@ -161,22 +166,19 @@ module Katello
         computed_options.except(:name, :client_key)
       end
 
-      def create(force = false)
-        if force || !repository_reference
-          response = api.repositories_api.create(name: generate_backend_object_name)
-          RepositoryReference.where(
-            root_repository_id: repo.root_id,
-            content_view_id: repo.content_view.id).destroy_all
-          RepositoryReference.where(
-            root_repository_id: repo.root_id,
-            content_view_id: repo.content_view.id,
-            repository_href: response.pulp_href).create!
+      def create
+        unless repository_reference
+          response = api.repositories_api.create(create_options)
+          RepositoryReference.create!(
+           root_repository_id: repo.root_id,
+           content_view_id: repo.content_view.id,
+           repository_href: response.pulp_href)
           response
         end
       end
 
       def update
-        api.repositories_api.update(repository_reference.try(:repository_href), name: generate_backend_object_name)
+        api.repositories_api.update(repository_reference.try(:repository_href), create_options)
       end
 
       def list(options)
@@ -360,6 +362,14 @@ module Katello
         remote_options.merge!(ssl_remote_options)
       end
 
+      def create_options
+        { name: generate_backend_object_name }.merge!(specific_create_options)
+      end
+
+      def specific_create_options
+        {}
+      end
+
       def secure_distribution_options(path)
         secured_distribution_options = {}
         if root.unprotected
@@ -425,6 +435,11 @@ module Katello
           upload.except('id')
         end
       end
+
+      def retain_package_versions_count
+        return 0 if root.retain_package_versions_count.nil? || root.mirror_on_sync?
+        root.retain_package_versions_count.to_i
+      end
     end
   end
 end