katello 3.13.4 → 3.14.0.rc1

data/app/models/katello/root_repository.rb

@@ -57,7 +57,6 @@ module Katello
     validates_with Validators::ContainerImageNameValidator, :attributes => :docker_upstream_name, :allow_blank => true, :if => :docker?
 
     validate :ensure_valid_docker_attributes, :if => :docker?
-    validate :ensure_valid_ansible_collection_attributes, :if => :ansible_collection?
     validate :ensure_docker_repo_unprotected, :if => :docker?
     validate :ensure_ostree_repo_protected, :if => :ostree?
     validate :ensure_compatible_download_policy, :if => :yum?
@@ -104,6 +103,16 @@ module Katello
     }
     delegate :redhat?, :provider, :organization, to: :product
 
+    # Note - Audit hook added to find records based on column except associations to display audit information
+    def self.audit_hook_to_find_records(name, change, _audit)
+      if name =~ /_id$/
+        case name
+        when 'content_id'
+          Katello::Content.find_by(:cp_content_id => change)
+        end
+      end
+    end
+
     def library_instance
       repositories.in_default_view.first
     end
@@ -213,10 +222,6 @@ module Katello
       end
     end
 
-    def ensure_valid_ansible_collection_attributes
-      errors.add(:base, N_("Whitelist cannot be blank.")) if ansible_collection_whitelist.blank?
-    end
-
     def ensure_valid_upstream_authorization
       return if (self.upstream_username.blank? && self.upstream_password.blank?)
       if redhat?
@@ -289,7 +294,7 @@ module Katello
                                  ssl_ca_cert_id ssl_client_cert_id ssl_client_key_id http_proxy_policy http_proxy_id)
       changeable_attributes += %w(name container_repository_name docker_tags_whitelist) if docker?
       changeable_attributes += %w(deb_releases deb_components deb_architectures gpg_key_id) if deb?
-      changeable_attributes += %w(ansible_collection_whitelist) if ansible_collection?
+      changeable_attributes += %w(ansible_collection_requirements) if ansible_collection?
       changeable_attributes.any? { |key| previous_changes.key?(key) }
     end
 

data/app/models/katello/rpm.rb

@@ -3,10 +3,6 @@ module Katello
     include Concerns::PulpDatabaseUnit
 
     CONTENT_TYPE = 'rpm'.freeze
-
-    has_many :repository_rpms, :class_name => "Katello::RepositoryRpm", :dependent => :destroy, :inverse_of => :rpm
-    has_many :repositories, :through => :repository_rpms, :class_name => "Katello::Repository"
-
     has_many :content_facet_applicable_rpms, :class_name => "Katello::ContentFacetApplicableRpm",
              :dependent => :destroy, :inverse_of => :rpm
     has_many :content_facets, :through => :content_facet_applicable_rpms, :class_name => "Katello::Host::ContentFacet"
@@ -31,10 +27,6 @@ module Katello
       order(:name).order(:epoch).order(:version_sortable).order(:release_sortable)
     end
 
-    def self.repository_association_class
-      RepositoryRpm
-    end
-
     def self.content_facet_association_class
       ContentFacetApplicableRpm
     end

data/app/models/katello/srpm.rb

@@ -3,20 +3,12 @@ module Katello
     include Concerns::PulpDatabaseUnit
 
     CONTENT_TYPE = 'srpm'.freeze
-
-    has_many :repository_srpms, :class_name => "Katello::RepositorySrpm", :dependent => :destroy, :inverse_of => :srpm
-    has_many :repositories, :through => :repository_srpms, :class_name => "Katello::Repository"
-
     before_save lambda { |rpm| rpm.summary = rpm.summary.truncate(255) unless rpm.summary.blank? }
 
     def self.default_sort
       order(:name).order(:epoch).order(:version_sortable).order(:release_sortable)
     end
 
-    def self.repository_association_class
-      RepositorySrpm
-    end
-
     def self.total_for_repositories(repos)
       self.in_repositories(repos).count
     end

data/app/models/katello/upstream_pool.rb

@@ -31,6 +31,8 @@ module Katello
       def base_params(params)
         attachable = ::Foreman::Cast.to_bool(params.delete(:attachable))
         params[:consumer] = upstream_consumer_id if attachable
+        params[:sort_by] = 'Product.name'
+        params[:order] = 'asc'
         params
       end
 

data/app/models/katello/yum_metadata_file.rb

@@ -10,10 +10,6 @@ module Katello
       super(repository)
     end
 
-    def self.many_repository_associations
-      false
-    end
-
     # yum metadata file only has one repo
     def repositories
       [repository]

data/app/models/setting/content.rb

@@ -8,12 +8,7 @@ class Setting::Content < Setting
     Hash[parameters.map { |p| [p, p] }]
   end
 
-  def self.load_defaults
-    return unless super
-
-    BLANK_ATTRS.concat %w(register_hostname_fact default_location_subscribed_hosts
-                          default_location_puppet_content content_default_http_proxy host_dmi_uuid_duplicates)
-
+  def self.default_settings
     download_policies = proc { hashify_parameters(::Runcible::Models::YumImporter::DOWNLOAD_POLICIES) }
     proxy_download_policies = proc { hashify_parameters(::SmartProxy::DOWNLOAD_POLICIES) }
     dependency_solving_options = proc { hashify_parameters(['conservative', 'greedy']) }
@@ -25,128 +20,129 @@ class Setting::Content < Setting
       text_method: 'name_and_url'
     }]
 
-    self.transaction do
-      [
-        self.set('content_default_http_proxy', N_("Default HTTP Proxy for syncing content"),
-                        nil, N_('Default http proxy'),
-                        nil,
-                        collection: proc { http_proxy_select }, include_blank: N_("no global default")
-                ),
-        self.set('katello_default_provision', N_("Default provisioning template for Operating Systems created from synced content"),
-                 'Kickstart default', N_('Default synced OS provisioning template'),
-                 nil, :collection => proc { katello_template_setting_values("provision") }
-                ),
-        self.set('katello_default_finish',
-                 N_("Default finish template for new Operating Systems created from synced content"),
-                 'Kickstart default finish', N_('Default synced OS finish template'),
-                 nil, :collection => proc { katello_template_setting_values("finish") }
-                ),
-        self.set('katello_default_user_data', N_("Default user data for new Operating Systems created from synced content"),
-                 'Kickstart default user data', N_('Default synced OS user-data'),
-                 nil, :collection => proc { katello_template_setting_values("user_data") }
-                ),
-        self.set('katello_default_PXELinux', N_("Default PXELinux template for new Operating Systems created from synced content"),
-                 'Kickstart default PXELinux', N_('Default synced OS PXELinux template'),
-                 nil, :collection => proc { katello_template_setting_values("PXELinux") }
-                ),
-        self.set('katello_default_PXEGrub', N_("Default PXEGrub template for new Operating Systems created from synced content"),
-                 'Kickstart default PXEGrub', N_('Default synced OS PXEGrub template'),
-                 nil, :collection => proc { katello_template_setting_values("PXEGrub") }
-                ),
-        self.set('katello_default_PXEGrub2', N_("Default PXEGrub2 template for new Operating Systems created from synced content"),
-                 'Kickstart default PXEGrub2', N_('Default synced OS PXEGrub2 template'),
-                 nil, :collection => proc { katello_template_setting_values("PXEGrub2") }
-                ),
-        self.set('katello_default_iPXE', N_("Default iPXE template for new Operating Systems created from synced content"),
-                 'Kickstart default iPXE', N_('Default synced OS iPXE template'),
-                 nil, :collection => proc { katello_template_setting_values("iPXE") }
-                ),
-        self.set('katello_default_ptable', N_("Default partitioning table for new Operating Systems created from synced content"),
-                 'Kickstart default', N_('Default synced OS partition table'),
-                 nil, :collection => proc { Hash[Template.all.where(:type => "Ptable").map { |tmp| [tmp[:name], tmp[:name]] }] }
-                ), self.set('katello_default_kexec', N_("Default kexec template for new Operating Systems created from synced content"), 'Discovery Red Hat kexec', N_('Default synced OS kexec template'),
-                 nil, :collection => proc { katello_template_setting_values("kexec") }
-                ),
-        self.set('katello_default_atomic_provision', N_("Default provisioning template for new Atomic Operating Systems created from synced content"),
-                 'Atomic Kickstart default', N_('Default synced OS Atomic template'),
-                 nil, :collection => proc { katello_template_setting_values("provision") }
-                ),
-        self.set('manifest_refresh_timeout', N_('Timeout when refreshing a manifest (in seconds)'), 60 * 20, N_("Manifest refresh timeout")),
-        self.set('content_action_accept_timeout', N_("Time in seconds to wait for a Host to pickup a remote action"),
-                 20, N_('Accept action timeout')),
-        self.set('content_action_finish_timeout', N_("Time in seconds to wait for a Host to finish a remote action"),
-                 3600, N_('Finish action timeout')),
-        self.set('content_disconnected', N_("A server operating in disconnected mode does not communicate with the Red Hat CDN."),
-                 false, N_('Disconnected mode')),
-        self.set('errata_status_installable', N_("Calculate errata host status based only on errata in a Host's Content View and Lifecycle Environment"),
-                 false, N_('Installable errata from Content View')),
-        self.set('restrict_composite_view', N_("If set to true, a composite content view may not be published or "\
-                 "promoted, unless the component content view versions that it includes exist in the target environment."),
-                 false, N_('Restrict Composite Content View promotion')),
-        self.set('check_services_before_actions', N_("Whether or not to check the status of backend services such as pulp and candlepin prior to performing some actions."),
-                 true, N_('Check services before actions')),
-        self.set('foreman_proxy_content_auto_sync', N_("Whether or not to auto sync the Smart Proxies after a Content View promotion."),
-                 true, N_('Sync Smart Proxies after Content View promotion')),
-        self.set('default_download_policy', N_("Default download policy for custom repositories (either 'immediate', 'on_demand', or 'background')"), "immediate",
-                 N_('Default Custom Repository download policy'), nil, :collection => download_policies),
-        self.set('default_redhat_download_policy', N_("Default download policy for enabled Red Hat repositories (either 'immediate', 'on_demand', or 'background')"), "on_demand",
-                         N_('Default Red Hat Repository download policy'), nil, :collection => download_policies),
-        self.set('default_proxy_download_policy', N_("Default download policy for Smart Proxy syncs (either 'inherit', immediate', 'on_demand', or 'background')"), "on_demand",
-                 N_('Default Smart Proxy download policy'), nil, :collection => proxy_download_policies),
-        self.set('pulp_docker_registry_port', N_("The port used by Pulp Crane to provide Docker Registries"),
-                 5000, N_('Pulp Docker registry port')),
-        self.set('pulp_export_destination', N_("On-disk location for exported repositories"),
-                 "/var/lib/pulp/katello-export", N_('Pulp export destination filepath')),
-        self.set('pulp_client_key', N_("Path for ssl key used for pulp server auth"),
-                 "/etc/pki/katello/private/pulp-client.key", N_('Pulp client key')),
-        self.set('pulp_client_cert', N_("Path for ssl cert used for pulp server auth"),
-                 "/etc/pki/katello/certs/pulp-client.crt", N_('Pulp client cert')),
-        self.set('remote_execution_by_default', N_("If set to true, use the remote execution over katello-agent for remote actions"),
-                 false, N_('Use remote execution by default')),
-        self.set('unregister_delete_host', N_("When unregistering a host via subscription-manager, also delete the host record. Managed resources linked to host " \
-                                              "such as virtual machines and DNS records may also be deleted."),
-                 false, N_('Delete Host upon unregister')),
-        self.set('register_hostname_fact', N_("When registering a host via subscription-manager, force use the specified fact (in the form of 'fact.fact')"),
-                 '', N_('Subscription manager name registration fact'), nil),
-        self.set('register_hostname_fact_strict_match', N_('If true, and register_hostname_fact is set and provided, registration will look for a new host by name only '\
-                  'using that fact, and will skip all hostname matching'), false, N_('Subscription manager name registration fact strict matching'), nil),
-        self.set('erratum_install_batch_size', N_("Errata installed via katello-agent will be triggered in batches of this size. Set to 0 to install all errata in one batch."),
-                 0, N_('Erratum Install Batch Size')),
-        self.set('default_location_subscribed_hosts',
-                 N_('Default Location where new subscribed hosts will put upon registration'),
-                 nil, N_('Default Location subscribed hosts'), nil,
-                 :collection => proc { Hash[Location.unscoped.all.map { |loc| [loc[:title], loc[:title]] }] }),
-        self.set('default_location_puppet_content',
-                 N_('Default Location where new Puppet content will be put upon Content View publish'),
-                 nil, N_('Default Location Puppet content'), nil,
-                 :collection => proc { Hash[Location.unscoped.all.map { |loc| [loc[:title], loc[:title]] }] }),
-        self.set('host_update_lock', N_("Allow multiple concurrent Actions::Katello::Host::Update calls for one host to be processed at the same time."),
-                 false, N_('Concurrent Actions::Katello::Host::Update allowed')),
-        self.set('expire_soon_days', N_('The number of days remaining in a subscription before you will be reminded about renewing it.'),
-                 120, N_('Expire soon days')),
-        self.set('content_view_solve_dependencies',
-                 N_('The default dependency solving value for new Content Views.'),
-                 false, N_('Content View Dependency Solving Default')),
-        self.set('dependency_solving_algorithm',
-                 N_("How the logic of solving dependencies in a Content View is managed. Conservative will only add " \
-                 "packages to solve the dependencies if the package needed doesn't exist. Greedy will pull in the " \
-                 "latest package to solve a dependency even if it already does exist in the repository."),
-                 'conservative', N_('Content View Dependency Solving Algorithm'), nil,
-                 :collection => dependency_solving_options),
-        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('host_dmi_uuid_duplicates',
-                 N_("If hosts fail to register because of duplicate DMI UUIDs " \
-                    "add their comma-separated values here. Subsequent registrations will generate a unique DMI UUID for the affected hosts."),
-                 [], N_('Host Duplicate DMI UUIDs')),
-        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_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'))
-      ].each { |s| self.create! s.update(:category => "Setting::Content") }
-    end
-    true
+    [
+      self.set('content_default_http_proxy', N_("Default HTTP Proxy for syncing content"),
+                      nil, N_('Default http proxy'),
+                      nil,
+                      collection: proc { http_proxy_select }, include_blank: N_("no global default")
+              ),
+      self.set('katello_default_provision', N_("Default provisioning template for Operating Systems created from synced content"),
+               'Kickstart default', N_('Default synced OS provisioning template'),
+               nil, :collection => proc { katello_template_setting_values("provision") }
+              ),
+      self.set('katello_default_finish',
+               N_("Default finish template for new Operating Systems created from synced content"),
+               'Kickstart default finish', N_('Default synced OS finish template'),
+               nil, :collection => proc { katello_template_setting_values("finish") }
+              ),
+      self.set('katello_default_user_data', N_("Default user data for new Operating Systems created from synced content"),
+               'Kickstart default user data', N_('Default synced OS user-data'),
+               nil, :collection => proc { katello_template_setting_values("user_data") }
+              ),
+      self.set('katello_default_PXELinux', N_("Default PXELinux template for new Operating Systems created from synced content"),
+               'Kickstart default PXELinux', N_('Default synced OS PXELinux template'),
+               nil, :collection => proc { katello_template_setting_values("PXELinux") }
+              ),
+      self.set('katello_default_PXEGrub', N_("Default PXEGrub template for new Operating Systems created from synced content"),
+               'Kickstart default PXEGrub', N_('Default synced OS PXEGrub template'),
+               nil, :collection => proc { katello_template_setting_values("PXEGrub") }
+              ),
+      self.set('katello_default_PXEGrub2', N_("Default PXEGrub2 template for new Operating Systems created from synced content"),
+               'Kickstart default PXEGrub2', N_('Default synced OS PXEGrub2 template'),
+               nil, :collection => proc { katello_template_setting_values("PXEGrub2") }
+              ),
+      self.set('katello_default_iPXE', N_("Default iPXE template for new Operating Systems created from synced content"),
+               'Kickstart default iPXE', N_('Default synced OS iPXE template'),
+               nil, :collection => proc { katello_template_setting_values("iPXE") }
+              ),
+      self.set('katello_default_ptable', N_("Default partitioning table for new Operating Systems created from synced content"),
+               'Kickstart default', N_('Default synced OS partition table'),
+               nil, :collection => proc { Hash[Template.all.where(:type => "Ptable").map { |tmp| [tmp[:name], tmp[:name]] }] }
+              ), self.set('katello_default_kexec', N_("Default kexec template for new Operating Systems created from synced content"), 'Discovery Red Hat kexec', N_('Default synced OS kexec template'),
+               nil, :collection => proc { katello_template_setting_values("kexec") }
+              ),
+      self.set('katello_default_atomic_provision', N_("Default provisioning template for new Atomic Operating Systems created from synced content"),
+               'Atomic Kickstart default', N_('Default synced OS Atomic template'),
+               nil, :collection => proc { katello_template_setting_values("provision") }
+              ),
+      self.set('manifest_refresh_timeout', N_('Timeout when refreshing a manifest (in seconds)'), 60 * 20, N_("Manifest refresh timeout")),
+      self.set('content_action_accept_timeout', N_("Time in seconds to wait for a Host to pickup a remote action"),
+               20, N_('Accept action timeout')),
+      self.set('content_action_finish_timeout', N_("Time in seconds to wait for a Host to finish a remote action"),
+               3600, N_('Finish action timeout')),
+      self.set('content_disconnected', N_("A server operating in disconnected mode does not communicate with the Red Hat CDN."),
+               false, N_('Disconnected mode')),
+      self.set('errata_status_installable', N_("Calculate errata host status based only on errata in a Host's Content View and Lifecycle Environment"),
+               false, N_('Installable errata from Content View')),
+      self.set('restrict_composite_view', N_("If set to true, a composite content view may not be published or "\
+               "promoted, unless the component content view versions that it includes exist in the target environment."),
+               false, N_('Restrict Composite Content View promotion')),
+      self.set('check_services_before_actions', N_("Whether or not to check the status of backend services such as pulp and candlepin prior to performing some actions."),
+               true, N_('Check services before actions')),
+      self.set('foreman_proxy_content_auto_sync', N_("Whether or not to auto sync the Smart Proxies after a Content View promotion."),
+               true, N_('Sync Smart Proxies after Content View promotion')),
+      self.set('default_download_policy', N_("Default download policy for custom repositories (either 'immediate', 'on_demand', or 'background')"), "immediate",
+               N_('Default Custom Repository download policy'), nil, :collection => download_policies),
+      self.set('default_redhat_download_policy', N_("Default download policy for enabled Red Hat repositories (either 'immediate', 'on_demand', or 'background')"), "on_demand",
+                       N_('Default Red Hat Repository download policy'), nil, :collection => download_policies),
+      self.set('default_proxy_download_policy', N_("Default download policy for Smart Proxy syncs (either 'inherit', immediate', 'on_demand', or 'background')"), "on_demand",
+               N_('Default Smart Proxy download policy'), nil, :collection => proxy_download_policies),
+      self.set('pulp_docker_registry_port', N_("The port used by Pulp Crane to provide Docker Registries"),
+               5000, N_('Pulp Docker registry port')),
+      self.set('pulp_export_destination', N_("On-disk location for exported repositories"),
+               "/var/lib/pulp/katello-export", N_('Pulp export destination filepath')),
+      self.set('pulp_client_key', N_("Path for ssl key used for pulp server auth"),
+               "/etc/pki/katello/private/pulp-client.key", N_('Pulp client key')),
+      self.set('pulp_client_cert', N_("Path for ssl cert used for pulp server auth"),
+               "/etc/pki/katello/certs/pulp-client.crt", N_('Pulp client cert')),
+      self.set('remote_execution_by_default', N_("If set to true, use the remote execution over katello-agent for remote actions"),
+               false, N_('Use remote execution by default')),
+      self.set('unregister_delete_host', N_("When unregistering a host via subscription-manager, also delete the host record. Managed resources linked to host " \
+                                            "such as virtual machines and DNS records may also be deleted."),
+               false, N_('Delete Host upon unregister')),
+      self.set('register_hostname_fact', N_("When registering a host via subscription-manager, force use the specified fact (in the form of 'fact.fact')"),
+               '', N_('Subscription manager name registration fact'), nil),
+      self.set('register_hostname_fact_strict_match', N_('If true, and register_hostname_fact is set and provided, registration will look for a new host by name only '\
+                'using that fact, and will skip all hostname matching'), false, N_('Subscription manager name registration fact strict matching'), nil),
+      self.set('erratum_install_batch_size', N_("Errata installed via katello-agent will be triggered in batches of this size. Set to 0 to install all errata in one batch."),
+               0, N_('Erratum Install Batch Size')),
+      self.set('default_location_subscribed_hosts',
+               N_('Default Location where new subscribed hosts will put upon registration'),
+               nil, N_('Default Location subscribed hosts'), nil,
+               :collection => proc { Hash[Location.unscoped.all.map { |loc| [loc[:title], loc[:title]] }] }),
+      self.set('default_location_puppet_content',
+               N_('Default Location where new Puppet content will be put upon Content View publish'),
+               nil, N_('Default Location Puppet content'), nil,
+               :collection => proc { Hash[Location.unscoped.all.map { |loc| [loc[:title], loc[:title]] }] }),
+      self.set('host_update_lock', N_("Allow multiple concurrent Actions::Katello::Host::Update calls for one host to be processed at the same time."),
+               false, N_('Concurrent Actions::Katello::Host::Update allowed')),
+      self.set('expire_soon_days', N_('The number of days remaining in a subscription before you will be reminded about renewing it.'),
+               120, N_('Expire soon days')),
+      self.set('content_view_solve_dependencies',
+               N_('The default dependency solving value for new Content Views.'),
+               false, N_('Content View Dependency Solving Default')),
+      self.set('dependency_solving_algorithm',
+               N_("How the logic of solving dependencies in a Content View is managed. Conservative will only add " \
+               "packages to solve the dependencies if the package needed doesn't exist. Greedy will pull in the " \
+               "latest package to solve a dependency even if it already does exist in the repository."),
+               'conservative', N_('Content View Dependency Solving Algorithm'), nil,
+               :collection => dependency_solving_options),
+      self.set('host_dmi_uuid_duplicates',
+               N_("If hosts fail to register because of duplicate DMI UUIDs " \
+                  "add their comma-separated values here. Subsequent registrations will generate a unique DMI UUID for the affected hosts."),
+               [], N_('Host Duplicate DMI UUIDs')),
+      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_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'))
+    ]
+  end
+
+  def self.load_defaults
+    BLANK_ATTRS.concat %w(register_hostname_fact default_location_subscribed_hosts
+                          default_location_puppet_content content_default_http_proxy host_dmi_uuid_duplicates)
+    super
   end
 
   def self.katello_template_setting_values(name)

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

@@ -13,7 +13,6 @@ module Katello
       CP_TYPES = [SYSTEM, HYPERVISOR, CANDLEPIN].freeze
 
       lazy_accessor :entitlements, :initializer => lambda { |_s| Resources::Candlepin::Consumer.entitlements(uuid) }
-      lazy_accessor :events, :initializer => lambda { |_s| Resources::Candlepin::Consumer.events(uuid) }
       lazy_accessor :consumer_attributes, :initializer => lambda { |_s| Resources::Candlepin::Consumer.get(uuid) }
       lazy_accessor :installed_products, :initializer => lambda { |_s| consumer_attributes['installedProducts'] }
       lazy_accessor :available_pools, :initializer => lambda { |_s| Resources::Candlepin::Consumer.available_pools(owner_label, uuid, false) }

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

@@ -3,10 +3,17 @@ module Katello
     class Content
       extend Katello::Abstract::Pulp::Content
       class << self
-        extend Forwardable
-        def_delegator :pulp_content, :create_upload_request, :create_upload
-        def_delegator :pulp_content, :delete_upload_request, :delete_upload
-        def_delegator :pulp_content, :upload_bits, :upload_chunk
+        def create_upload(_size = 0, _checksum = nil, _content_type = nil)
+          pulp_content.create_upload_request
+        end
+
+        def delete_upload(upload_id)
+          pulp_content.delete_upload_request(upload_id)
+        end
+
+        def upload_chunk(upload_id, offset, content, _size)
+          pulp_content.upload_bits(upload_id, offset, content)
+        end
 
         private def pulp_content
           SmartProxy.pulp_master.pulp_api.resources.content

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

@@ -6,7 +6,6 @@ module Katello
       def update_model(model)
         taggable_class = backend_data['manifest_type'] == "list" ? ::Katello::DockerManifestList : ::Katello::DockerManifest
         model.docker_taggable = taggable_class.find_by(:digest => backend_data['manifest_digest'])
-        model.repository_id = ::Katello::Repository.find_by(:pulp_id => backend_data['repo_id']).try(:id)
         model.name = backend_data['name']
         model.save!
       end

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

@@ -30,6 +30,10 @@ module Katello
         "_id"
       end
 
+      def self.content_type
+        self::CONTENT_TYPE
+      end
+
       def self.unit_handler
         Katello.pulp_server.extensions.send(self.name.demodulize.underscore)
       end

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

@@ -79,6 +79,14 @@ module Katello
         false
       end
 
+      def create_mirror_entities
+        create
+      end
+
+      def mirror_needs_updates?
+        needs_importer_updates? || needs_distributor_updates?
+      end
+
       def sync(overrides = {})
         sync_options = {}
         sync_options[:max_speed] = SETTINGS.dig(:katello, :pulp, :sync_KBlimit)
@@ -121,6 +129,19 @@ module Katello
         end
       end
 
+      def needs_importer_updates?
+        repo_details = backend_data
+        return unless repo_details
+        capsule_importer = repo_details["importers"][0]
+        !importer_matches?(capsule_importer)
+      end
+
+      def needs_distributor_updates?
+        repo_details = backend_data
+        return unless repo_details
+        !distributors_match?(repo_details["distributors"])
+      end
+
       def master_importer_connection_options
         options = {
           basic_auth_username: root.upstream_username,
@@ -185,6 +206,10 @@ module Katello
         tasks
       end
 
+      def refresh_mirror_entities
+        refresh
+      end
+
       def update_or_associate_importer
         existing_importers = backend_data["importers"]
         importer = generate_importer
@@ -273,6 +298,34 @@ module Katello
         end
         { proxy_host: '' }
       end
+
+      private
+
+      def filtered_distribution_config_equal?(generated_config, actual_config)
+        generated = generated_config.clone
+        actual = actual_config.clone
+        #We store 'default' checksum type as nil, but pulp will default to sha256, so if we haven't set it, ignore it
+        if generated.keys.include?('checksum_type') && generated['checksum_type'].nil?
+          generated.delete('checksum_type')
+          actual.delete('checksum_type')
+        end
+        generated.compact == actual.compact
+      end
+
+      def importer_matches?(capsule_importer)
+        generated_importer = generate_importer
+        capsule_importer.try(:[], 'importer_type_id') == generated_importer.id &&
+            generated_importer.config.compact == capsule_importer['config'].compact
+      end
+
+      def distributors_match?(capsule_distributors)
+        generated_distributor_configs = generate_distributors
+        generated_distributor_configs.all? do |gen_dist|
+          type = gen_dist.class.type_id
+          found_on_capsule = capsule_distributors.find { |dist| dist['distributor_type_id'] == type }
+          found_on_capsule && filtered_distribution_config_equal?(gen_dist.config, found_on_capsule['config'])
+        end
+      end
     end
   end
 end