katello 4.3.0.rc4 → 4.4.0.rc2

data/app/lib/actions/katello/cdn_configuration/update.rb

@@ -4,23 +4,21 @@ module Actions
       class Update < Actions::EntryAction
         def plan(cdn_configuration, options)
           cdn_configuration.update!(options)
+          return if cdn_configuration.airgapped?
 
-          if cdn_configuration.redhat?
-            cdn_configuration.ssl_cert = nil
-            cdn_configuration.ssl_key = nil
-          else
+          if cdn_configuration.upstream_server?
             resource = ::Katello::Resources::CDN::CdnResource.create(cdn_configuration: cdn_configuration)
             keypair = resource.debug_certificate
             cdn_configuration.ssl_cert = OpenSSL::X509::Certificate.new(keypair)
             cdn_configuration.ssl_key = OpenSSL::PKey::RSA.new(keypair)
-          end
 
-          cdn_configuration.save!
+            cdn_configuration.save!
+          end
 
           org = cdn_configuration.organization
           roots = ::Katello::RootRepository.redhat.in_organization(org)
           roots.each do |root|
-            full_path = if cdn_configuration.redhat?
+            full_path = if cdn_configuration.redhat_cdn?
                           root.product.repo_url(root.library_instance.generate_content_path)
                         else
                           resource.repository_url(content_label: root.content.label)

data/app/lib/actions/katello/content_view/publish.rb

@@ -200,6 +200,11 @@ module Actions
                 plan_action(Katello::Repository::IndexContent, id: id, full_index: true)
               end
             end
+            concurrence do
+              version.importable_repositories.each do |repo|
+                plan_action(::Actions::Katello::Repository::MetadataGenerate, repo)
+              end
+            end
             plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::CopyVersionUnitsToLibrary, version)
           end
         end

data/app/lib/actions/katello/content_view_version/incremental_update.rb

@@ -72,6 +72,18 @@ module Actions
 
                 unless extended_repo_mapping.empty? || unit_map.values.flatten.empty?
                   sequence do
+                    # Pre-copy content if dest_repo is a soft copy of its library instance.
+                    # Don't use extended_repo_mapping because the source repositories are library instances.
+                    # We want the old CV snapshot repositories here so as to not pull in excess new content.
+                    separated_repo_map[:pulp3_yum_multicopy].each do |source_repos, dest_repo|
+                      if dest_repo.soft_copy_of_library?
+                        source_repos.each do |source_repo|
+                          # remove_all flag is set to cover the case of incrementally updating more than once with different content.
+                          # Without it, content from the previous incremental update will be copied as well due to how Pulp repo versions work.
+                          plan_action(Pulp3::Repository::CopyContent, source_repo, SmartProxy.pulp_primary, dest_repo, copy_all: true, remove_all: true)
+                        end
+                      end
+                    end
                     copy_action_outputs << plan_action(Pulp3::Repository::MultiCopyUnits, extended_repo_mapping, unit_map,
                                                        dependency_solving: dep_solve).output
                     repos_to_clone.each do |source_repos|
@@ -125,10 +137,12 @@ module Actions
             source_library_repo = source_repos.first.library_instance? ? source_repos.first : source_repos.first.library_instance
 
             source_repos = [source_library_repo]
-            if old_version_repo.version_href
-              base_version = old_version_repo.version_href.split("/")[-1].to_i
-            else
+            if old_version_repo.version_href.nil?
               base_version = 0
+            elsif old_version_repo.soft_copy_of_library?
+              base_version = nil
+            else
+              base_version = old_version_repo.version_href.split("/")[-1].to_i
             end
 
             pulp3_repo_mapping[source_repos.map(&:id)] = { dest_repo: dest_repo.id, base_version: base_version }

data/app/lib/actions/katello/repository/discover.rb

@@ -33,7 +33,7 @@ module Actions
                 password = decrypt_field(input[:upstream_password])
                 repo_discovery = ::Katello::RepoDiscovery.new(input[:url], input[:content_type],
                                                               input[:upstream_username], password,
-                                                              input[:search], proxy,
+                                                              input[:search],
                                                               output[:crawled], output[:repo_urls], output[:to_follow])
 
                 repo_discovery.run(output[:to_follow].shift)
@@ -49,19 +49,6 @@ module Actions
         def task_output
           output[:repo_urls] || []
         end
-
-        def proxy
-          proxy_details = {}
-          if (proxy = ::HttpProxy.default_global_content_proxy)
-            uri = URI(proxy.url)
-            proxy_details[:proxy_host] = "#{uri.scheme}://#{uri.host}#{uri.path}"
-            proxy_details[:proxy_port] = uri.port
-            proxy_details[:proxy_user] = proxy.username
-            proxy_details[:proxy_password] = proxy.password
-          end
-
-          proxy_details
-        end
       end
     end
   end

data/app/lib/actions/katello/repository/errata_mail.rb

@@ -4,17 +4,16 @@ module Actions
       class ErrataMail < Actions::EntryAction
         middleware.use Actions::Middleware::ExecuteIfContentsChanged
 
-        def plan(repo, last_updated = nil, contents_changed = nil)
-          last_updated ||= repo.repository_errata.order('updated_at ASC').last.try(:updated_at) || Time.now
-          plan_self(:repo => repo.id, :last_updated => last_updated.to_s, :contents_changed => contents_changed)
+        def plan(repo, contents_changed = nil)
+          plan_self(:repo => repo.id, :contents_changed => contents_changed)
         end
 
         def run
           ::User.current = ::User.anonymous_admin
-
           repo = ::Katello::Repository.find(input[:repo])
+          last_updated = repo.repository_errata.order('updated_at ASC').last.try(:updated_at) || Time.now
           users = ::User.select { |user| user.receives?(:sync_errata) && user.organization_ids.include?(repo.organization.id) && user.can?(:view_products, repo.product) }.compact
-          errata = ::Katello::Erratum.where(:id => repo.repository_errata.where('katello_repository_errata.updated_at > ?', input[:last_updated].to_datetime).pluck(:erratum_id))
+          errata = ::Katello::Erratum.where(:id => repo.repository_errata.where('katello_repository_errata.updated_at > ?', last_updated).pluck(:erratum_id))
 
           begin
             MailNotification[:sync_errata].deliver(:users => users, :repo => repo, :errata => errata) unless (users.blank? || errata.blank?)

data/app/lib/actions/katello/repository/filtered_index_content.rb

@@ -24,7 +24,7 @@ module Actions
             ::Katello::FileUnit.import_for_repository(repo)
           elsif repo.generic?
             repo.repository_type.content_types_to_index.each do |type|
-              type.model_class.import_for_repository(repo, generic_content_type: type.content_type)
+              type.model_class.import_for_repository(repo, content_type: type.content_type)
             end
           elsif repo.deb?
             if input[:import_upload_task] && input[:import_upload_task][:content_unit_href]

data/app/lib/actions/katello/repository/sync.rb

@@ -51,11 +51,11 @@ module Actions
               plan_action(Katello::Repository::FetchPxeFiles, :id => repo.id)
               plan_action(Katello::Repository::CorrectChecksum, repo)
               concurrence do
-                plan_action(Katello::Repository::ErrataMail, repo, nil, contents_changed)
+                plan_action(Katello::Repository::ErrataMail, repo, output[:contents_changed])
                 plan_action(Actions::Katello::Applicability::Repository::Regenerate, :repo_ids => [repo.id]) if generate_applicability
               end
               plan_self(:id => repo.id, :sync_result => output, :skip_metadata_check => skip_metadata_check, :validate_contents => validate_contents,
-                        :contents_changed => contents_changed)
+                        :contents_changed => output[:contents_changed])
               plan_action(Katello::Repository::SyncHook, :id => repo.id)
             end
           end

data/app/lib/actions/pulp3/abstract.rb

@@ -1,6 +1,6 @@
 module Actions
   module Pulp3
-    class Abstract < Actions::Base
+    class Abstract < Actions::EntryAction
       middleware.use ::Actions::Middleware::RemoteAction
       middleware.use Actions::Middleware::Pulp3ServicesCheck
 

data/app/lib/actions/pulp3/abstract_async_task.rb

@@ -113,7 +113,7 @@ module Actions
       def overwrite_pulp_error(message)
         case message
         when 'This repository uses features which are incompatible with \'mirror\' sync. Please sync without mirroring enabled.'
-          'Please disable \'mirror on sync\' because the upstream repository refers to external resources.'
+          'The "Complete Mirroring" mirroring policy is not compatible with this repository.  You may want to update it to use "Content Only"'
         else
           message
         end

data/app/lib/actions/pulp3/content_view/delete_repository_references.rb

@@ -11,15 +11,25 @@ module Actions
         def invoke_external_task
           tasks = []
           content_view = ::Katello::ContentView.find(input[:content_view_id])
-          content_view.repository_references.each do |repository_reference|
+          to_delete = content_view.repository_references.select do |repository_reference|
             repo = repository_reference.root_repository.library_instance
-            #force pulp3 in case we've done migrations, but haven't switched over yet
-            tasks << repo.backend_service(smart_proxy, true).delete_repository(repository_reference)
+            if delete_href?(repository_reference.repository_href, content_view)
+              #force pulp3 in case we've done migrations, but haven't switched over yet
+              tasks << repo.backend_service(smart_proxy, true).delete_repository(repository_reference)
+              true
+            else
+              false
+            end
           end
-          content_view.repository_references.destroy_all
+          to_delete.each(&:destroy)
 
           output[:pulp_tasks] = tasks
         end
+
+        #migrated composites may have the same RepositoryReference as their component
+        def delete_href?(href, content_view)
+          ::Katello::Pulp3::RepositoryReference.where(:repository_href => href).where.not(:content_view_id => content_view.id).empty?
+        end
       end
     end
   end

data/app/lib/actions/pulp3/content_view_version/create_import_history.rb

@@ -18,8 +18,7 @@ module Actions
             content_view_version_id: input[:content_view_version_id],
             path: input[:path],
             metadata: input[:metadata],
-            audit_comment: ::Katello::ContentViewVersionImportHistory.generate_audit_comment(path: input[:path],
-                                                                                             user: User.current,
+            audit_comment: ::Katello::ContentViewVersionImportHistory.generate_audit_comment(user: User.current,
                                                                                              content_view_name: input[:content_view_name])
           )
           output[:import_history_id] = history.id

data/app/lib/actions/pulp3/content_view_version/import.rb

@@ -19,6 +19,13 @@ module Actions
             metadata: input[:metadata]
           ).create_import(input[:importer_data][:pulp_href])
         end
+
+        def rescue_strategy_for_self
+          # There are various reasons the importing fails, not all of them are
+          # fatal: when fail on import, we continue with the task ending up
+          # in the warning state, but not locking further imports
+          Dynflow::Action::Rescue::Skip
+        end
       end
     end
   end

data/app/lib/actions/pulp3/orchestration/content_view_version/import.rb

@@ -15,17 +15,19 @@ module Actions
                 metadata: metadata
               ).output
 
-              import_output = plan_action(
+              plan_action(
                 ::Actions::Pulp3::ContentViewVersion::Import,
                 content_view_version_id: content_view_version.id,
                 smart_proxy_id: smart_proxy.id,
                 importer_data: importer_output[:importer_data],
                 path: path,
                 metadata: metadata
-              ).output
-
-              plan_action(Actions::Pulp3::Repository::SaveVersions, content_view_version.importable_repositories.pluck(:id),
-                          tasks: import_output[:pulp_tasks])
+              )
+              concurrence do
+                content_view_version.importable_repositories.each do |repo|
+                  plan_action(Actions::Pulp3::Repository::SaveVersion, repo)
+                end
+              end
               plan_action(
                 ::Actions::Pulp3::ContentViewVersion::CreateImportHistory,
                 content_view_version_id: content_view_version.id,

data/app/lib/actions/pulp3/repository/copy_content.rb

@@ -13,7 +13,7 @@ module Actions
           target = ::Katello::Repository.find(input[:target_repository_id] || input[:target_repository])
           service = target.backend_service(smart_proxy)
           output[:pulp_tasks] = if input[:copy_all]
-                                  service.copy_all(source, mirror: input[:mirror] || false)
+                                  service.copy_all(source, input)
                                 else
                                   service.copy_content_for_source(source, input)
                                 end

data/app/lib/actions/pulp3/repository/reclaim_space.rb

@@ -2,16 +2,9 @@ module Actions
   module Pulp3
     module Repository
       class ReclaimSpace < Pulp3::AbstractAsyncTask
-        def plan(repositories, smart_proxy = SmartProxy.pulp_primary)
-          repositories = [repositories] if repositories.is_a?(::Katello::Repository)
-          if repositories.empty?
-            fail _("No repositories selected.")
-          end
-          repositories = repositories.select { |repo| repo.download_policy == ::Katello::RootRepository::DOWNLOAD_ON_DEMAND }
-          if repositories.empty?
-            fail _("Only On Demand repositories may have space reclaimed.")
-          end
-          repository_hrefs = ::Katello::Pulp3::RepositoryReference.default_cv_repository_hrefs(repositories, Organization.current)
+        def plan(repo, smart_proxy = SmartProxy.pulp_primary)
+          action_subject(repo)
+          repository_hrefs = ::Katello::Pulp3::RepositoryReference.default_cv_repository_hrefs([repo], Organization.current || repositories.first.organization)
           plan_self(repository_hrefs: repository_hrefs, smart_proxy_id: smart_proxy.id)
         end
 

data/app/lib/actions/pulp3/repository/save_artifact.rb

@@ -27,6 +27,7 @@ module Actions
               []
             else
               output[:pulp_tasks] = [content_backend_service.content_api_create(relative_path: input[:options][:file_name],
+                                                                                repository_id: repository.id,
                                                                                 artifact: artifact_href,
                                                                                 content_type: content_type)]
             end

data/app/lib/katello/concerns/base_template_scope_extensions.rb

@@ -288,6 +288,17 @@ module Katello
         Katello.with_katello_agent?
       end
 
+      include Katello::ContentSourceHelper
+
+      apipie :method, "Generate script to change a host's content source" do
+        returns String
+      end
+      def change_content_source(host, ca_cert)
+        return missing_content_source(host) unless host.content_source
+
+        prepare_ssl_cert(ca_cert) + configure_subman(host.content_source)
+      end
+
       private
 
       def host_subscription_facet(host)

data/app/lib/katello/errors.rb

@@ -145,10 +145,10 @@ module Katello
       end
     end
 
-    class DisconnectedMode < StandardError
+    class SubscriptionConnectionNotEnabled < StandardError
       def message
-        _("You are currently operating in disconnected mode where access to Red Hat Subcription Management " \
-        "is prohibited. If you would like to change this, please update the content setting 'Disconnected mode'.")
+        _("Access to Red Hat Subscription Management " \
+        "is prohibited. If you would like to change this, please update the content setting 'Subscription connection enabled'.")
       end
     end
 

data/app/lib/katello/logging.rb

@@ -19,9 +19,9 @@ module Katello
     class Timer
       def initialize(key = "default")
         @key = key
-        @start_time = Time.now
         Thread.current[:timers] ||= {}
         Thread.current[:timers][key] = self
+        self.start
       end
 
       def start
@@ -38,6 +38,11 @@ module Katello
         Rails.logger.info "Timer #{@key} stopping at #{Time.now}: #{duration} sec"
       end
 
+      def log(msg = nil)
+        duration = (Time.now - @start_time).truncate(2)
+        Rails.logger.info ["Timer #{@key} running at #{Time.now}", msg, "#{duration} sec"].compact.join(': ')
+      end
+
       def self.find_by_key(key)
         if Thread.current&.[](:timers)&.[](key)
           Thread.current[:timers][key]

data/app/lib/katello/repo_discovery.rb

@@ -1,10 +1,12 @@
 module Katello
   class RepoDiscovery
+    include Katello::Util::HttpProxy
+
     attr_reader :found, :crawled, :to_follow
 
     # rubocop:disable Metrics/ParameterLists
     def initialize(url, content_type = 'yum', upstream_username = nil,
-      upstream_password = nil, search = '*', proxy = {}, crawled = [],
+      upstream_password = nil, search = '*', crawled = [],
       found = [], to_follow = [])
       @uri = uri(url)
       @content_type = content_type
@@ -14,7 +16,6 @@ module Katello
       @found = found
       @crawled = crawled
       @to_follow = to_follow
-      @proxy = proxy
     end
     # rubocop:enable Metrics/ParameterLists
 
@@ -42,42 +43,49 @@ module Katello
     private
 
     def docker_search
-      params = {
-        :accept => :json
+      request_params = {
+        method: :get,
+        headers: { accept: :json },
+        url: "#{@uri}v1/search?q=#{@search}"
       }
-      params[:user] = @upstream_username unless @upstream_username.empty?
-      params[:password] = @upstream_password unless @upstream_password.empty?
-
-      RestClient.proxy = nil
 
-      if @proxy && @proxy[:proxy_host]
-        proxy_uri = URI(@proxy[:proxy_host])
-        proxy_uri.user = @proxy[:proxy_user] if @proxy[:proxy_user]
-        proxy_uri.password = @proxy[:proxy_password] if @proxy[:proxy_password]
-        proxy_uri.port = @proxy[:proxy_port] if @proxy[:proxy_port]
-
-        RestClient.proxy = proxy_uri.to_s
-      end
+      request_params[:headers][:user] = @upstream_username unless @upstream_username.empty?
+      request_params[:headers][:password] = @upstream_password unless @upstream_password.empty?
+      request_params[:proxy] = proxy_uri if proxy
 
       begin
-        results = RestClient.get(@uri.to_s + "v1/search?q=#{@search}", params)
+        results = RestClient::Request.execute(request_params)
         JSON.parse(results)['results'].each do |result|
           @found << result['name']
         end
       rescue
         # Note: v2 endpoint does not support search
-        results = RestClient.get(@uri.to_s + "v2/_catalog", params)
+        request_params[:url] = "#{@uri}v2/_catalog"
+        results = RestClient::Request.execute(request_params)
         @found = JSON.parse(results)['repositories']
       end
       @found.sort!
     end
 
+    def anemone_proxy_details
+      details = {}
+
+      if proxy
+        details[:proxy_host] = proxy_host
+        details[:proxy_port] = proxy_port
+        details[:proxy_user] = proxy.username
+        details[:proxy_password] = proxy.password
+      end
+
+      details
+    end
+
     def http_crawl(resume_point)
       resume_point_uri = URI(resume_point)
       resume_point_uri.user = @upstream_username if @upstream_username
       resume_point_uri.password = @upstream_password if @upstream_password
 
-      Anemone.crawl(resume_point_uri, @proxy) do |anemone|
+      Anemone.crawl(resume_point_uri, anemone_proxy_details) do |anemone|
         anemone.focus_crawl do |page|
           @crawled << page.url.path
 

data/app/lib/katello/resources/cdn/katello_cdn.rb

@@ -4,6 +4,8 @@ module Katello
       class KatelloCdn < CdnResource
         def initialize(url, options)
           @organization_label = options.delete(:organization_label)
+          @content_view_label = options.delete(:content_view_label)
+          @lifecycle_environment_label = options.delete(:lifecycle_environment_label)
           fail ArgumentError, "No upstream organization was specified" if @organization_label.nil?
 
           super
@@ -38,14 +40,50 @@ module Katello
           get("/katello/api/v2/organizations/#{organization['id']}/download_debug_certificate")
         end
 
+        def content_view_id
+          rs = get("/katello/api/v2/organizations/#{organization['id']}/content_views?name=#{CGI.escape(@content_view_label)}")
+          content_view = JSON.parse(rs)['results']&.first
+          if content_view.blank?
+            fail _("Upstream organization %{org_label} does not have a content view with the label %{cv_label}") % { org_label: @organization_label,
+                                                                                                                     cv_label: @content_view_label }
+          end
+          content_view["id"]
+        end
+
+        def lifecycle_environment_id
+          rs = get("/katello/api/v2/organizations/#{organization['id']}/environments")
+          env = JSON.parse(rs)['results'].find { |lce| lce['label'] == @lifecycle_environment_label }
+
+          if env.blank?
+            fail _("Upstream organization %{org_label} does not have a lifecycle environment with the label %{lce_label}") % { org_label: @organization_label,
+                                                                                                                               lce_label: @lifecycle_environment_label }
+          end
+          env["id"]
+        end
+
         def repository_url(content_label:)
-          response = get("/katello/api/v2/organizations/#{organization['id']}/repositories?search=#{CGI.escape("content_label = #{content_label}")}")
+          params = {
+            search: CGI.escape("content_label = #{content_label}")
+          }
+
+          params[:content_view_id] = content_view_id if @content_view_label
+          params[:environment_id] = lifecycle_environment_id if @lifecycle_environment_label
+
+          query_params = params.map { |key, value| "#{key}=#{value}" }
+          url = "/katello/api/v2/organizations/#{organization['id']}/repositories?#{query_params.join('&')}"
+          response = get(url)
           repository = JSON.parse(response)['results'].first
 
           if repository.nil?
-            fail _("Repository with content label %{content_label} was not found in upstream organization %{org_label}") % { content_label: content_label, org_label: @organization_label }
-          end
+            msg_params = { content_label: content_label,
+                           org_label: @organization_label,
+                           cv_label: @content_view_label || Katello::OrganizationCreator::DEFAULT_CONTENT_VIEW_LABEL,
+                           env_label: @lifecycle_environment_label || Katello::OrganizationCreator::DEFAULT_LIFECYCLE_ENV_LABEL
+            }
 
+            fail _("Repository with content label %{content_label} was not found in upstream organization %{org_label},"\
+                   " content view %{cv_label} and lifecycle environment %{env_label} ") % msg_params
+          end
           repository['full_path']
         end
 

data/app/lib/katello/resources/cdn.rb

@@ -58,7 +58,7 @@ module Katello
 
         def self.create(product: nil, cdn_configuration:)
           options = {}
-          if cdn_configuration.redhat?
+          if cdn_configuration.redhat_cdn?
             options[:ssl_client_cert] = OpenSSL::X509::Certificate.new(product.certificate)
             options[:ssl_client_key] = OpenSSL::PKey::RSA.new(product.key)
             options[:ssl_ca_file] = self.ca_file
@@ -67,6 +67,8 @@ module Katello
             options[:username] = cdn_configuration.username
             options[:password] = cdn_configuration.password
             options[:organization_label] = cdn_configuration.upstream_organization_label
+            options[:content_view_label] = cdn_configuration.upstream_content_view_label
+            options[:lifecycle_environment_label] = cdn_configuration.upstream_lifecycle_environment_label
             options[:ssl_ca_cert] = cdn_configuration.ssl_ca
             CDN::KatelloCdn.new(cdn_configuration.url, options)
           end
@@ -184,7 +186,7 @@ module Katello
         def net_http_class
           if proxy
             uri = URI(proxy.url) #Net::HTTP::Proxy ignores port as part of the url
-            Net::HTTP::Proxy("#{uri.host}#{uri.path}", uri.port, proxy.username, proxy.password)
+            Net::HTTP::Proxy("#{uri.host}", uri.port, proxy.username, proxy.password)
           else
             Net::HTTP
           end

data/app/lib/katello/util/deduplication_migrator.rb

@@ -0,0 +1,105 @@
+module Katello
+  module Util
+    class DeduplicationMigrator # used in db/migrate/20211201154845_add_unique_indexes.rb
+      include ActionView::Helpers::TextHelper
+
+      def models_to_clean
+        [
+          {
+            :model => ::Katello::CapsuleLifecycleEnvironment,
+            :fields => [:lifecycle_environment_id, :capsule_id]
+          },
+          {
+            :model => ::Katello::ContentViewErratumFilterRule,
+            :fields => [:errata_id, :content_view_filter_id]
+          },
+          {
+            :model => ::Katello::ContentViewModuleStreamFilterRule,
+            :fields => [:module_stream_id, :content_view_filter_id]
+          },
+          {
+            :model => ::Katello::ContentViewPackageGroupFilterRule,
+            :fields => [:uuid, :content_view_filter_id]
+          },
+          {
+            :model =>
+            ::Katello::ContentViewRepository,
+            :fields => [:content_view_id, :repository_id]
+          }
+        ]
+      end
+
+      def models_to_rename
+        [
+          {
+            :model => ::Katello::ContentView,
+            :fields => [:name, :organization_id]
+          }
+        ]
+      end
+
+      # example ---- (IDs 1/7 and 6/8 are duplicates ) ::Katello::CapsuleLifecycleEnvironment.all
+      # => [#<Katello::CapsuleLifecycleEnvironment:0x0000000017e11060 id: 1, capsule_id: 1, lifecycle_environment_id: 1>,
+      # #<Katello::CapsuleLifecycleEnvironment:0x0000000017e10f98 id: 2, capsule_id: 1, lifecycle_environment_id: 2>,
+      # #<Katello::CapsuleLifecycleEnvironment:0x0000000017e10ed0 id: 3, capsule_id: 1, lifecycle_environment_id: 3>,
+      # ...
+      # #<Katello::CapsuleLifecycleEnvironment:0x0000000017e10c78 id: 6, capsule_id: 1, lifecycle_environment_id: 6>,
+      # #<Katello::CapsuleLifecycleEnvironment:0x0000000017e10bb0 id: 7, capsule_id: 1, lifecycle_environment_id: 1>,
+      # #<Katello::CapsuleLifecycleEnvironment:0x0000000017e10ac0 id: 8, capsule_id: 1, lifecycle_environment_id: 6>]
+      def execute!
+        models_to_clean.each do |model_to_clean|
+          rows_deleted = 0
+          model = model_to_clean[:model]
+          cleaning_queries(model_to_clean).each { |query| rows_deleted += clean_duplicates(query, model) }
+          if rows_deleted > 0
+            Rails.logger.info("Deleted #{pluralize(rows_deleted, 'duplicate table row')} from #{model.table_name}")
+          end
+        end
+        Rails.logger.info("Finished cleaning duplicate table rows")
+
+        models_to_rename.each do |model_to_rename|
+          rows_renamed = 0
+          model = model_to_rename[:model]
+          cleaning_queries(model_to_rename).each { |query| rows_renamed += rename_duplicates(query, model) }
+          if rows_renamed > 0
+            Rails.logger.info("Renamed #{pluralize(rows_renamed, 'duplicate table row')} from #{model.table_name}")
+          end
+        end
+        Rails.logger.info("Finished renaming duplicate table rows")
+      end
+
+      def cleaning_queries(model_to_clean)
+        model = model_to_clean[:model]
+        fields = model_to_clean[:fields]
+        dup_query = model.group(fields).having("count(*) > 1")
+        duplicate_entries = dup_query.count.try(:keys) #  [[1, 1], [6, 1]] - the set of duplicate combinations
+        return [] if duplicate_entries.blank?
+        min_ids = dup_query.pluck('min(id)') # [1, 6] - the ids of the duplicate entries with the lowest id, in the same order as duplicate_entries
+        duplicate_entries.map.with_index do |entry, idx|
+          # [{:lifecycle_environment_id=>1, :capsule_id=>1, :min_id=>1},
+          # {:lifecycle_environment_id=>6, :capsule_id=>1, :min_id=>6}]
+          Hash[fields.zip(entry)].merge({ min_id: min_ids[idx] })
+        end
+      end
+
+      def clean_duplicates(query, model)
+        min_id = query.delete(:min_id)
+        model.where(query).where.not(id: min_id).delete_all # returns quantity deleted
+      end
+
+      def rename_duplicates(query, model)
+        min_id = query.delete(:min_id)
+        counter = 0
+        model.where(query).where.not(id: min_id).each do |duplicate|
+          counter += 1
+          old_name = duplicate.name
+          new_name = "#{duplicate.name}_#{duplicate.id}"
+          duplicate.name = new_name
+          duplicate.save(validate: false) # skip validation since migrations should never fail
+          Rails.logger.info("Content view #{old_name} (id #{duplicate.id}) renamed to #{new_name}")
+        end
+        counter
+      end
+    end
+  end
+end