katello 3.10.2 → 3.11.0.rc1

data/app/lib/actions/katello/host/hypervisors_update.rb

@@ -10,17 +10,22 @@ module Actions
 
         def run
           output[:results] = input[:results]
-        end
-
-        def finalize
           @hypervisors = input[:hypervisors]
           return unless @hypervisors
 
           User.as_anonymous_admin do
-            load_resources
+            ActiveRecord::Base.transaction do
+              load_resources
+            end
+
+            ActiveRecord::Base.transaction do
+              @hosts.each do |uuid, host|
+                update_subscription_facet(uuid, host)
+              end
+            end
 
             @hosts.each do |uuid, host|
-              update_subscription_facet(uuid, host)
+              update_facts(uuid, host)
             end
           end
         end
@@ -34,7 +39,7 @@ module Actions
           @hosts.merge!(load_hosts_by_duplicate_name)
           @hosts.merge!(create_missing_hosts)
 
-          candlepin_data = ::Katello::Resources::Candlepin::Consumer.get_all(@hosts.keys)
+          candlepin_data = ::Katello::Resources::Candlepin::Consumer.get_all_with_facts(@hosts.keys)
           @candlepin_attributes = candlepin_data.map { |consumer| [consumer[:uuid], consumer] }.to_h
         end
 
@@ -119,6 +124,12 @@ module Actions
           host.save!
         end
 
+        def update_facts(uuid, host)
+          if @candlepin_attributes.key?(uuid)
+            ::Katello::Host::SubscriptionFacet.update_facts(host, @candlepin_attributes[uuid][:facts]) unless @candlepin_attributes[uuid][:facts].blank?
+          end
+        end
+
         def rescue_strategy
           Dynflow::Action::Rescue::Skip
         end

data/app/lib/actions/katello/organization/manifest_delete.rb

@@ -39,9 +39,7 @@ module Actions
         end
 
         def finalize
-          subject_organization.update_attributes!(
-            :manifest_refreshed_at => Time.now,
-            :audit_comment => _('Manifest deleted'))
+          subject_organization.audit_manifest_action(_('Manifest deleted'))
         end
       end
     end

data/app/lib/actions/katello/organization/manifest_import.rb

@@ -44,9 +44,7 @@ module Actions
         end
 
         def finalize
-          subject_organization.update_attributes!(
-            :manifest_refreshed_at => Time.now,
-            :audit_comment => _('Manifest imported'))
+          subject_organization.audit_manifest_action(_('Manifest imported'))
         end
       end
     end

data/app/lib/actions/katello/organization/manifest_refresh.rb

@@ -60,9 +60,7 @@ module Actions
         end
 
         def finalize
-          subject_organization.manifest_refreshed_at = Time.now
-          subject_organization.audit_comment = _('Manifest refreshed')
-          subject_organization.save(validate: false)
+          subject_organization.audit_manifest_action(_('Manifest refreshed'))
         end
       end
     end

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

@@ -30,7 +30,7 @@ module Actions
             next unless repository.url
             path = repository.url.split(current_base_url)[1]
             url = "#{new_base_url}#{path}"
-            plan_action(::Actions::Katello::Repository::Update, repository, :url => url)
+            plan_action(::Actions::Katello::Repository::Update, repository.root, :url => url)
           end
         end
       end

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

@@ -20,9 +20,9 @@ module Actions
             errata = errata_match?(source_repo, target_repo)
             package_groups = package_groups_match?(source_repo, target_repo)
             distributions = distributions_match?(source_repo, target_repo)
-            checksum_match = (target_repo.saved_checksum_type == source_repo.saved_checksum_type)
+            yum_metadata_files = yum_metadata_files_match?(source_repo, target_repo)
 
-            output[:matching_content] = srpms_match && rpms && errata && package_groups && distributions && target_repo.published? && checksum_match
+            output[:matching_content] = yum_metadata_files && srpms_match && rpms && errata && package_groups && distributions && target_repo.published?
           end
 
           if source_repo.content_type == ::Katello::Repository::DEB_TYPE
@@ -63,6 +63,12 @@ module Actions
         def distributions_match?(source_repo, target_repo)
           source_repo.distribution_information == target_repo.distribution_information
         end
+
+        def yum_metadata_files_match?(source_repo, target_repo)
+          source_repo_items = source_repo.yum_metadata_files.pluck(:name, :checksum).sort
+          target_repo_items = target_repo.yum_metadata_files.pluck(:name, :checksum).sort
+          source_repo_items == target_repo_items
+        end
       end
     end
   end

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

@@ -0,0 +1,52 @@
+module Actions
+  module Katello
+    module Repository
+      class CloneContents < Actions::Base
+        def plan(source_repositories, new_repository, options)
+          filters = options.fetch(:filters, nil)
+          rpm_filenames = options.fetch(:rpm_filenames, nil)
+          generate_metadata = options.fetch(:generate_metadata, true)
+          index_content = options.fetch(:index_content, true)
+          purge_empty_contents = options.fetch(:purge_empty_contents, false)
+          copy_contents = options.fetch(:copy_contents, true)
+
+          sequence do
+            if copy_contents
+              source_repositories.each do |repository|
+                plan_action(Pulp::Repository::CopyAllUnits, repository, new_repository,
+                            filters: filters, rpm_filenames: rpm_filenames)
+              end
+            end
+
+            metadata_generate(source_repositories, new_repository, filters, rpm_filenames) if generate_metadata
+
+            plan_action(Katello::Repository::IndexContent, id: new_repository.id) if index_content
+
+            if purge_empty_contents && new_repository.backend_service(SmartProxy.pulp_master).should_purge_empty_contents?
+              plan_action(Katello::Repository::PurgeEmptyContent, id: new_repository.id)
+            end
+          end
+        end
+
+        def metadata_generate(source_repositories, new_repository, filters, rpm_filenames)
+          metadata_options = {}
+
+          if source_repositories.count == 1 && filters.empty? && rpm_filenames.empty?
+            metadata_options[:source_repository] = source_repositories.first
+          end
+
+          check_matching_content = ::Katello::RepositoryTypeManager.find(new_repository.content_type).metadata_publish_matching_check
+          if new_repository.environment && source_repositories.count == 1 && check_matching_content
+            match_check_output = plan_action(Katello::Repository::CheckMatchingContent,
+                                :source_repo_id => source_repositories.first.id,
+                                :target_repo_id => new_repository.id).output
+
+            metadata_options[:matching_content] = match_check_output[:matching_content]
+          end
+
+          plan_action(Katello::Repository::MetadataGenerate, new_repository, metadata_options)
+        end
+      end
+    end
+  end
+end

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

@@ -19,17 +19,7 @@ module Actions
               end
             end
 
-            if repository.yum?
-              plan_action(Repository::CloneYumMetadata, repository, clone)
-            elsif repository.deb?
-              plan_action(Repository::CloneDebContent, repository, clone, [], false)
-            elsif repository.docker?
-              plan_action(Repository::CloneDockerContent, repository, clone, [])
-            elsif repository.ostree?
-              plan_action(Repository::CloneOstreeContent, repository, clone)
-            elsif repository.file?
-              plan_action(Repository::CloneFileContent, repository, clone)
-            end
+            plan_action(::Actions::Katello::Repository::CloneContents, [repository], clone, :copy_contents => !clone.yum?)
           end
         end
 

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

@@ -2,7 +2,7 @@ module Actions
   module Katello
     module Repository
       class CloneToVersion < Actions::Base
-        # allows accessing the built object from the superior action
+        # allows accessing the build object from the superior action
         attr_accessor :new_repository
 
         def plan(repositories, content_view_version, options = {})
@@ -14,40 +14,30 @@ module Actions
                                                                version: content_view_version)
 
           rpm_filenames = extract_rpm_filenames(options.fetch(:repos_units, nil), repositories.first.label)
+          fail _('Cannot publish a composite with rpm filenames') if content_view.composite? && rpm_filenames&.any?
+          if rpm_filenames&.any?
+            verify_rpm_filenames(repositories.first, rpm_filenames)
+            Rails.logger.warn("Filters on content view have been overridden by passed-in filename list during publish") if filters.any?
+          end
+
+          copy_contents = new_repository.master?
+          fail _('Cannot publish a link repository if multiple component clones are specified') if !copy_contents && repositories.count > 1
 
           sequence do
             plan_action(Repository::Create, new_repository, true, false)
-
-            if new_repository.link?
-              fail "Cannot clone metadata if more than one repository" if repositories.count > 1
-              plan_action(Repository::CloneYumMetadata, repositories[0], new_repository)
-            else
-              clone_repository_content(repositories, new_repository, filters, incremental, rpm_filenames)
-            end
-
-            plan_action(Katello::Repository::MetadataGenerate, new_repository) if repositories.length > 1
+            plan_action(::Actions::Katello::Repository::CloneContents, repositories, new_repository,
+                        purge_empty_contents: true,
+                        filters: filters,
+                        rpm_filenames: rpm_filenames,
+                        copy_contents: copy_contents,
+                        metadata_generate: !incremental)
           end
         end
 
-        def clone_repository_content(repositories, new_repository, filters, incremental, rpm_filenames)
-          repositories.each do |repository|
-            if new_repository.yum?
-              # If there is more than one repository passed here, that means that there are duplicate repos in a composite content view.
-              # We skip generating metadata in this case and generate it later to prevent conflicting data, such as filters.
-              skip_metadata = incremental || repositories.length > 1
-              plan_action(Repository::CloneYumContent, repository, new_repository, filters, :purge_empty_units => !incremental,
-                          :generate_metadata => !skip_metadata, :index_content => !incremental,
-                          :simple_clone => incremental, :rpm_filenames => rpm_filenames)
-            elsif new_repository.deb?
-              plan_action(Repository::CloneDebContent, repository, new_repository, filters, !incremental,
-                          :generate_metadata => !incremental, :index_content => !incremental, :simple_clone => incremental)
-            elsif new_repository.docker?
-              plan_action(Repository::CloneDockerContent, repository, new_repository, filters)
-            elsif new_repository.ostree?
-              plan_action(Repository::CloneOstreeContent, repository, new_repository)
-            elsif new_repository.file?
-              plan_action(Repository::CloneFileContent, repository, new_repository)
-            end
+        def verify_rpm_filenames(repo, filenames)
+          rpms_available = repo.rpms.pluck(:filename)
+          filenames.each do |filename|
+            fail "%s not available in repository %s" % [filename, repo.label] unless rpms_available.include? filename
           end
         end
 

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

@@ -18,13 +18,12 @@ module Actions
             # when creating a clone, the following actions are handled by the
             # publish/promote process
             unless clone
+              view_env = org.default_content_view.content_view_environment(org.library)
               if repository.product.redhat?
-                plan_action(ContentView::UpdateEnvironment, org.default_content_view,
-                            org.library, repository.content_id)
+                plan_action(Actions::Candlepin::Environment::AddContentToEnvironment, :view_env_cp_id => view_env.cp_id, :content_id => repository.content_id)
               else
                 content_create = plan_action(Katello::Product::ContentCreate, root)
-                plan_action(ContentView::UpdateEnvironment, org.default_content_view,
-                            org.library, content_create.input[:content_id])
+                plan_action(Actions::Candlepin::Environment::AddContentToEnvironment, :view_env_cp_id => view_env.cp_id, :content_id => content_create.input[:content_id])
               end
             end
 

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

@@ -69,8 +69,7 @@ module Actions
               sequence do
                 if repo.link?
                   plan_action(Katello::Repository::Clear, repo)
-                  plan_action(Katello::Repository::CloneYumContent, repo.target_repository, repo, [], :purge_empty_units => false,
-                              :generate_metadata => false, :index_content => false)
+                  plan_action(Pulp::Repository::CopyAllUnits, repo.target_repository, repo)
                 end
               end
             end

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

@@ -3,13 +3,15 @@ module Actions
   module Katello
     module Repository
       class ImportUpload < Actions::EntryAction
-        def plan(repository, upload_ids, options = {})
+        def plan(repository, uploads, options = {})
           action_subject(repository)
+          repo_service = repository.backend_service(::SmartProxy.pulp_master)
 
-          unit_keys = options.fetch(:unit_keys, {})
+          upload_ids = uploads.pluck('id')
+          unit_keys = repo_service.unit_keys(uploads)
           generate_metadata = options.fetch(:generate_metadata, true)
           sync_capsule = options.fetch(:sync_capsule, true)
-          unit_type_id = options.fetch(:unit_type_id, repository.unit_type_id)
+          unit_type_id = repo_service.unit_type_id(uploads)
 
           sequence do
             upload_results = concurrence do
@@ -57,12 +59,12 @@ module Actions
             result[:pulp_tasks].each do |task|
               details = task ? task.dig(:result, :details, :unit) : nil
               if details && details.dig('type_id') == 'docker_manifest'
-                manifest = ::Katello::DockerManifest.find_by_uuid(details.dig(:metadata, :id))
+                manifest = ::Katello::DockerManifest.find_by(:pulp_id => details.dig(:metadata, :id))
                 json_result = JSON.parse(::Rabl.render(manifest, '/katello/api/v2/docker_manifests/show'))
                 json_result[:type] = 'docker_manifest'
                 json_results << json_result
               elsif details && details.dig('type_id') == 'docker_tag'
-                manifest = ::Katello::DockerTag.find_by_uuid(details.dig(:metadata, :id))
+                manifest = ::Katello::DockerTag.find_by(:pulp_id => details.dig(:metadata, :id))
                 json_result = JSON.parse(::Rabl.render(manifest, '/katello/api/v2/docker_tags/show'))
                 json_result[:type] = 'docker_tag'
                 json_results << json_result

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

@@ -0,0 +1,16 @@
+module Actions
+  module Katello
+    module Repository
+      class PurgeEmptyContent < Pulp::AbstractAsyncTask
+        input_format do
+          param :id, Integer
+        end
+
+        def invoke_external_task
+          repo = ::Katello::Repository.find(input[:id])
+          repo.backend_service(SmartProxy.pulp_master).purge_empty_contents
+        end
+      end
+    end
+  end
+end

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

@@ -28,12 +28,12 @@ module Actions
                           Pulp::Repository::RemoveDeb
                         end
 
-          uuids = content_units.map(&:uuid)
+          pulp_ids = content_units.map(&:pulp_id)
           repository.remove_content(content_units)
 
           sequence do
             plan_action(pulp_action, :pulp_id => repository.pulp_id,
-                                     :clauses => {:association => {'unit_id' => {'$in' => uuids}}
+                                     :clauses => {:association => {'unit_id' => {'$in' => pulp_ids}}
             })
             plan_self
             plan_action(CapsuleSync, repository) if sync_capsule

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

@@ -50,7 +50,7 @@ module Actions
               plan_action(Pulp::Repository::Download, :pulp_id => repo.pulp_id, :options => {:verify_all_units => true}) if validate_contents
               plan_action(Katello::Repository::MetadataGenerate, repo, :force => true) if skip_metadata_check
               plan_action(Katello::Repository::ErrataMail, repo, nil, contents_changed)
-              plan_action(Pulp::Repository::RegenerateApplicability, :pulp_id => repo.pulp_id, :contents_changed => contents_changed) if generate_applicability
+              plan_action(Pulp::Repository::RegenerateApplicability, :repository_id => repo.id, :contents_changed => contents_changed) 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)

data/app/lib/actions/pulp/content_view_puppet_environment/copy_contents.rb

@@ -0,0 +1,36 @@
+module Actions
+  module Pulp
+    module ContentViewPuppetEnvironment
+      class CopyContents < Pulp::AbstractAsyncTask
+        def plan(target_env, options = {})
+          unless options[:source_repository_id] || options[:source_content_view_puppet_environment_id]
+            fail 'Must provide source_repository_id or source_content_view_puppet_environment_id'
+          end
+
+          to_plan = {
+            target_content_view_puppet_environment_id: target_env.id,
+            source_content_view_puppet_environment_id: options[:source_content_view_puppet_environment_id],
+            source_repository_id: options[:source_repository_id]
+          }
+
+          to_plan[:puppet_module_ids] = options[:puppet_modules].pluck(:id) if options[:puppet_modules]
+          plan_self(to_plan)
+        end
+
+        def invoke_external_task
+          if input[:source_repository_id]
+            source_repository = ::Katello::Repository.find(input[:source_repository_id])
+          else
+            env = ::Katello::ContentViewPuppetEnvironment.find(input[:source_content_view_puppet_environment_id])
+            source_repository = env.nonpersisted_repository
+          end
+
+          target_env = ::Katello::ContentViewPuppetEnvironment.find(input[:target_content_view_puppet_environment_id])
+
+          puppet_modules = input[:puppet_module_ids] ? ::Katello::PuppetModule.where(:id => input[:puppet_module_ids]) : nil
+          source_repository.backend_service(SmartProxy.pulp_master).copy_contents(target_env.nonpersisted_repository, puppet_modules: puppet_modules)
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp/repository/copy_all_units.rb

@@ -0,0 +1,27 @@
+module Actions
+  module Pulp
+    module Repository
+      class CopyAllUnits < Pulp::AbstractAsyncTask
+        def plan(source_repo, target_repo, options = {})
+          filter_ids = options.fetch(:filters, nil)&.map(&:id)
+          rpm_filenames = options.fetch(:rpm_filenames, nil)
+
+          plan_self(source_repo_id: source_repo.id,
+                    target_repo_id: target_repo.id,
+                    filter_ids: filter_ids,
+                    rpm_filenames: rpm_filenames)
+        end
+
+        def invoke_external_task
+          source_repo = ::Katello::Repository.find(input[:source_repo_id])
+          target_repo = ::Katello::Repository.find(input[:target_repo_id])
+          filters = ::Katello::ContentViewFilter.where(:id => input[:filter_ids])
+
+          source_repo.backend_service(SmartProxy.pulp_master).copy_contents(target_repo,
+                                                                            filters: filters,
+                                                                            rpm_filenames: input[:rpm_filenames])
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp/repository/copy_units.rb

@@ -0,0 +1,29 @@
+module Actions
+  module Pulp
+    module Repository
+      class CopyUnits < Pulp::AbstractAsyncTask
+        def plan(source_repo, target_repo, units, options = {})
+          if units.any?
+            plan_self(source_repo_id: source_repo.id,
+                      target_repo_id: target_repo.id,
+                      class_name: units.first.class.name,
+                      unit_ids: units.pluck(:id),
+                      recursive: options[:recursive],
+                      resolve_dependencies: options[:resolve_dependencies])
+          end
+        end
+
+        def invoke_external_task
+          source_repo = ::Katello::Repository.find(input[:source_repo_id])
+          target_repo = ::Katello::Repository.find(input[:target_repo_id])
+
+          units = input[:class_name].constantize.where(:id => input[:unit_ids])
+
+          source_repo.backend_service(SmartProxy.pulp_master).copy_units(target_repo, units,
+                                                                         recursive: input[:recursive],
+                                                                         resolve_dependencies: input[:resolve_dependencies])
+        end
+      end
+    end
+  end
+end