katello 3.3.2 → 3.4.0.rc1

data/app/lib/actions/katello/product/content_destroy.rb

@@ -6,10 +6,12 @@ module Actions
           fail _("Cannot delete redhat product content") if repository.product.redhat?
           sequence do
             plan_action(Candlepin::Product::ContentRemove,
+                        owner: repository.product.organization.label,
                         product_id: repository.product.cp_id,
                         content_id: repository.content_id)
             if repository.other_repos_with_same_content.empty?
               plan_action(Candlepin::Product::ContentDestroy,
+                          owner: repository.product.organization.label,
                           content_id: repository.content_id)
             end
           end

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

@@ -8,6 +8,7 @@ module Actions
             product.organization = organization
 
             cp_create = plan_action(::Actions::Candlepin::Product::Create,
+                                    :owner => product.organization.label,
                                     :name => product.name,
                                     :multiplier => 1,
                                     :attributes => [{:name => "arch", :value => "ALL"}])
@@ -20,8 +21,6 @@ module Actions
 
             subscription_id = sub_create.output[:response][:id]
 
-            plan_action(::Actions::Candlepin::Owner::RefreshSubscriptions,
-                                  :label => organization.label)
             product.save!
             action_subject product, :cp_id => cp_id
 

data/app/lib/actions/katello/product/destroy.rb

@@ -32,15 +32,16 @@ module Actions
                             cp_id: product.cp_id, organization_label: product.organization.label)
             end
 
-            if !product.used_by_another_org? && !organization_destroy
+            unless organization_destroy
               concurrence do
                 product.productContent.each do |pc|
                   plan_action(Candlepin::Product::ContentRemove,
+                              owner: product.organization.label,
                               product_id: product.cp_id,
                               content_id: pc.content.id)
                 end
+                plan_action(Candlepin::Product::Destroy, cp_id: product.cp_id, :owner => product.organization.label)
               end
-              plan_action(Candlepin::Product::Destroy, cp_id: product.cp_id)
             end
 
             plan_self(:product_id => product.id)

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

@@ -0,0 +1,49 @@
+module Actions
+  module Katello
+    module Repository
+      class CheckMatchingContent < Actions::Base
+        input_format do
+          param :source_repo
+          param :target_repo
+        end
+
+        # Check if content in the repositories has changed. We can use
+        # this info to skip regenerating metadata in pulp, keeping the
+        # revision number on the repo the same
+        def run
+          source_repo = ::Katello::Repository.find(input[:source_repo_id])
+          target_repo = ::Katello::Repository.find(input[:target_repo_id])
+
+          rpms = rpms_match?(source_repo, target_repo)
+          errata = errata_match?(source_repo, target_repo)
+          package_groups = package_groups_match?(source_repo, target_repo)
+          distributions = distributions_match?(source_repo, target_repo)
+
+          output[:matching_content] = rpms && errata && package_groups && distributions
+        end
+
+        def rpms_match?(source_repo, target_repo)
+          source_repo_ids = source_repo.rpm_ids.sort
+          target_repo_ids = target_repo.rpm_ids.sort
+          source_repo_ids == target_repo_ids
+        end
+
+        def errata_match?(source_repo, target_repo)
+          source_repo_ids = source_repo.erratum_ids.sort
+          target_repo_ids = target_repo.erratum_ids.sort
+          source_repo_ids == target_repo_ids
+        end
+
+        def package_groups_match?(source_repo, target_repo)
+          source_repo_ids = source_repo.package_group_ids.sort
+          target_repo_ids = target_repo.package_group_ids.sort
+          source_repo_ids == target_repo_ids
+        end
+
+        def distributions_match?(source_repo, target_repo)
+          source_repo.distribution_information == target_repo.distribution_information
+        end
+      end
+    end
+  end
+end

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

@@ -4,7 +4,7 @@ module Actions
       # Clones the contnet of the repository into the environment
       # effectively promotion the repository to the environment
       class CloneToEnvironment < Actions::Base
-        def plan(repository, environment)
+        def plan(repository, environment, options = {})
           clone = find_or_build_environment_clone(repository, environment)
 
           sequence do
@@ -21,7 +21,8 @@ module Actions
             end
 
             if repository.yum?
-              plan_action(Repository::CloneYumContent, repository, clone, [], false)
+              plan_action(Repository::CloneYumContent, repository, clone, [], false,
+                          :force_yum_metadata_regeneration => options[:force_yum_metadata_regeneration])
             elsif repository.docker?
               plan_action(Repository::CloneDockerContent, repository, clone, [])
             elsif repository.ostree?

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

@@ -38,6 +38,15 @@ module Actions
             plan_copy(Pulp::Repository::CopyYumMetadataFile, source_repo, target_repo)
             plan_copy(Pulp::Repository::CopyDistribution, source_repo, target_repo)
 
+            # Check for matching content before indexing happens, the content in pulp is
+            # actually updated, but it is not reflected in the database yet.
+            output = {}
+            if target_repo.environment && !options[:force_yum_metadata_regeneration]
+              output = plan_action(Katello::Repository::CheckMatchingContent,
+                                   :source_repo_id => source_repo.id,
+                                   :target_repo_id => target_repo.id).output
+            end
+
             plan_action(Katello::Repository::IndexContent, id: target_repo.id) if index_content
 
             if purge_empty_units
@@ -47,7 +56,14 @@ module Actions
               plan_action(Katello::Repository::IndexPackageGroups, target_repo)
             end
 
-            plan_action(Katello::Repository::MetadataGenerate, target_repo, filters.empty? ? source_repo : nil) if generate_metadata
+            source_repository = filters.empty? ? source_repo : nil
+
+            if generate_metadata
+              plan_action(Katello::Repository::MetadataGenerate,
+                          target_repo,
+                          :source_repository => source_repository,
+                          :matching_content => output[:matching_content])
+            end
           end
         end
 

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

@@ -26,11 +26,14 @@ module Actions
                                         checksum_type: repository.checksum_type,
                                         path: path,
                                         download_policy: repository.download_policy,
+                                        ostree_upstream_sync_depth: repository.compute_ostree_upstream_sync_depth,
+                                        ostree_publish_depth: repository.compute_ostree_upstream_sync_depth,
                                         with_importer: true,
                                         mirror_on_sync: repository.mirror_on_sync?,
                                         ssl_validation: certs[:ssl_validation],
                                         upstream_username: repository.upstream_username,
-                                        upstream_password: repository.upstream_password)
+                                        upstream_password: repository.upstream_password,
+                                        repo_registry_id: repository.container_repository_name)
 
             return if create_action.error
 

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

@@ -0,0 +1,26 @@
+module Actions
+  module Katello
+    module Repository
+      class DestroyPackageGroup < Actions::EntryAction
+        def plan(repository, pkg_group_id)
+          action_subject(repository)
+          criteria = { type_ids: ["package_group"], filters: {"unit": {"name": pkg_group_id} } }
+
+          sequence do
+            ::Katello.pulp_server.extensions.repository.unassociate_units(repository.pulp_id, criteria)
+            plan_action(IndexPackageGroups, repository)
+            plan_action(Katello::Repository::MetadataGenerate, repository)
+          end
+        end
+
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
+
+        def humanized_name
+          _("Delete Package Group")
+        end
+      end
+    end
+  end
+end

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

@@ -6,14 +6,17 @@ module Actions
 
         input_format do
           param :url, String
+          param :content_type, String
+          param :upstream_username, String
+          param :upstream_password, String
         end
 
         output_format do
           param :repo_urls, array_of(String)
         end
 
-        def plan(url)
-          plan_self(url: url)
+        def plan(url, content_type, upstream_username, upstream_password)
+          plan_self(url: url, content_type: content_type, upstream_username: upstream_username, upstream_password: upstream_password)
         end
 
         def run(event = nil)
@@ -21,7 +24,9 @@ module Actions
           output[:crawled] = output[:crawled] || []
           output[:to_follow] = output[:to_follow] || [input[:url]]
 
-          repo_discovery = ::Katello::RepoDiscovery.new(input[:url], proxy, output[:crawled], output[:repo_urls], output[:to_follow])
+          repo_discovery = ::Katello::RepoDiscovery.new(input[:url], input[:content_type],
+                                                        input[:upstream_username], input[:upstream_password], proxy,
+                                                        output[:crawled], output[:repo_urls], output[:to_follow])
 
           match(event,
             (on nil do

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

@@ -17,7 +17,7 @@ module Actions
           errata = ::Katello::Erratum.where(:id => repo.repository_errata.where('katello_repository_errata.updated_at > ?', input[:last_updated].to_datetime).pluck(:erratum_id))
 
           begin
-            MailNotification[:sync_errata].deliver_now(:users => users, :repo => repo, :errata => errata) unless users.blank?
+            MailNotification[:sync_errata].deliver_now(:users => users, :repo => repo, :errata => errata) unless (users.blank? || errata.blank?)
           rescue => e
             message = _('Unable to send errata e-mail notification: %{error}' % {:error => e})
             Rails.logger.error(message)

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

@@ -2,8 +2,12 @@ module Actions
   module Katello
     module Repository
       class FinishUpload < Actions::Base
-        def plan(repository, dependency = nil)
-          plan_action(Katello::Repository::MetadataGenerate, repository, nil, dependency)
+        middleware.use Actions::Middleware::KeepCurrentUser
+
+        def plan(repository, options = {})
+          dependency = options.fetch(:dependency, nil)
+          generate_metadata = options.fetch(:generate_metadata, true)
+          plan_action(Katello::Repository::MetadataGenerate, repository, :dependency => dependency) if generate_metadata
 
           recent_range = 5.minutes.ago.utc.iso8601
           plan_action(Katello::Repository::FilteredIndexContent,

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

@@ -1,16 +1,39 @@
+# rubocop:disable HandleExceptions
 module Actions
   module Katello
     module Repository
       class ImportUpload < Actions::EntryAction
-        def plan(repository, upload_id, unit_key = {})
+        middleware.use Actions::Middleware::KeepCurrentUser
+
+        def plan(repository, upload_ids, options = {})
           action_subject(repository)
-          import_upload = plan_action(Pulp::Repository::ImportUpload,
-                                      pulp_id: repository.pulp_id,
-                                      unit_type_id: repository.unit_type_id,
-                                      unit_key: unit_key,
-                                      upload_id: upload_id)
+          unit_keys = options.fetch(:unit_keys, {})
+          generate_metadata = options.fetch(:generate_metadata, true)
+          sync_capsule = options.fetch(:sync_capsule, true)
+          sequence do
+            concurrence do
+              upload_ids.zip(unit_keys) do |upload_id, unit_key|
+                import_upload = plan_action(Pulp::Repository::ImportUpload,
+                                            pulp_id: repository.pulp_id,
+                                            unit_type_id: repository.unit_type_id,
+                                            unit_key: unit_key,
+                                            upload_id: upload_id)
+
+                plan_action(FinishUpload, repository, :dependency => import_upload.output,
+                            generate_metadata: false)
+              end
+            end
+            plan_action(Katello::Repository::MetadataGenerate, repository) if generate_metadata
+            plan_self(repository_id: repository.id, sync_capsule: sync_capsule)
+          end
+        end
 
-          plan_action(FinishUpload, repository, import_upload.output)
+        def run
+          repository = ::Katello::Repository.find(input[:repository_id])
+          if input[:sync_capsule]
+            ForemanTasks.async_task(Katello::Repository::CapsuleGenerateAndSync, repository)
+          end
+        rescue ::Katello::Errors::CapsuleCannotBeReached # skip any capsules that cannot be connected to
         end
 
         def rescue_strategy

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

@@ -9,11 +9,12 @@ module Actions
           param :id, Integer
           param :dependency, Hash
           param :contents_changed
+          param :full_index
         end
 
         def run
           repo = ::Katello::Repository.find(input[:id])
-          repo.index_content
+          repo.index_content(input[:full_index])
         end
       end
     end

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

@@ -2,13 +2,27 @@ module Actions
   module Katello
     module Repository
       class MetadataGenerate < Actions::Base
-        def plan(repository, source_repository = nil, dependency = nil)
+        def plan(repository, options = {})
+          dependency = options.fetch(:dependency, nil)
+          source_repository = options.fetch(:source_repository, nil)
+          force = options.fetch(:force, false)
+
           distributors(repository, source_repository).each do |distributor|
             plan_action(Pulp::Repository::DistributorPublish,
-                        pulp_id: repository.pulp_id,
-                        distributor_type_id: distributor.type_id,
-                        source_pulp_id: source_repository.try(:pulp_id),
-                        dependency: dependency)
+                        :pulp_id => repository.pulp_id,
+                        :distributor_type_id => distributor.type_id,
+                        :source_pulp_id => source_repository.try(:pulp_id),
+                        :override_config => override_config(distributor, force),
+                        :dependency => dependency,
+                        :matching_content => options[:matching_content])
+          end
+        end
+
+        def override_config(distributor_class, force)
+          if distributor_class == Runcible::Models::YumDistributor
+            {:force_full => force}
+          else
+            {}
           end
         end
 

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

@@ -4,7 +4,8 @@ module Actions
       class RemoveContent < Actions::EntryAction
         middleware.use Actions::Middleware::KeepCurrentUser
 
-        def plan(repository, content_units)
+        def plan(repository, content_units, options = {})
+          sync_capsule = options.fetch(:sync_capsule, true)
           if repository.redhat?
             fail _("Cannot remove content from a non-custom repository")
           end
@@ -33,7 +34,9 @@ module Actions
                                      :clauses => {:association => {'unit_id' => {'$in' => uuids}}
             })
 
-            plan_self(:repository_id => repository.id, :user_id => ::User.current.id)
+            plan_self(:repository_id => repository.id, :user_id => ::User.current.id,
+                      sync_capsule: sync_capsule)
+            plan_action(CapsuleGenerateAndSync, repository) if sync_capsule
           end
         end
 
@@ -46,8 +49,8 @@ module Actions
         end
 
         def run
-          output[:task_id] = ForemanTasks.async_task(Actions::Katello::Repository::MetadataGenerate,
-                                                     ::Katello::Repository.find(input['repository_id'])).id
+          output[:task_id] = ForemanTasks.sync_task(Actions::Katello::Repository::MetadataGenerate,
+                                                    ::Katello::Repository.find(input[:repository_id])).id
         end
       end
     end

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

@@ -15,32 +15,40 @@ module Actions
         # @param repo
         # @param pulp_sync_task_id in case the sync was triggered outside
         #   of Katello and we just need to finish the rest of the orchestration
-        # @param source_url optional url to override source URL with
-        def plan(repo, pulp_sync_task_id = nil, source_url = nil, incremental = false)
+        def plan(repo, pulp_sync_task_id = nil, options = {})
           action_subject(repo)
 
-          if repo.url.blank? && source_url.blank?
-            fail _("Unable to sync repo. This repository does not have a feed url.")
-          end
+          source_url = options.fetch(:source_url, nil)
+          incremental = options.fetch(:incremental, false)
+          validate_contents = options.fetch(:validate_contents, false)
+          skip_metadata_check = options.fetch(:skip_metadata_check, false) || validate_contents
 
-          sequence do
-            sync_args = {:pulp_id => repo.pulp_id,
-                         :task_id => pulp_sync_task_id,
-                         :source_url => source_url}
+          pulp_sync_options = {}
+          pulp_sync_options[:download_policy] = ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND if validate_contents
+          pulp_sync_options[:force_full] = true if skip_metadata_check
+          pulp_sync_options[:auto_publish] = false if skip_metadata_check #skip auto publish, and force it later
+          pulp_sync_options[:remove_missing] = false if incremental
 
-            sync_args[:remove_missing] = false if incremental
+          fail ::Katello::Errors::InvalidActionOptionError, _("Unable to sync repo. This repository does not have a feed url.") if repo.url.blank? && source_url.blank?
+          fail ::Katello::Errors::InvalidActionOptionError, _("Cannot validate contents on non-yum repositories.") if validate_contents && !repo.yum?
+          fail ::Katello::Errors::InvalidActionOptionError, _("Cannot skip metadata check on non-yum repositories.") if skip_metadata_check && !repo.yum?
 
+          sequence do
+            sync_args = {:pulp_id => repo.pulp_id, :task_id => pulp_sync_task_id, :source_url => source_url, :options => pulp_sync_options}
             output = plan_action(Pulp::Repository::Sync, sync_args).output
 
-            contents_changed = output[:contents_changed]
-            plan_action(Katello::Repository::IndexContent, :id => repo.id, :contents_changed => contents_changed)
+            contents_changed = skip_metadata_check || output[:contents_changed]
+            plan_action(Katello::Repository::IndexContent, :id => repo.id, :contents_changed => contents_changed, :full_index => skip_metadata_check)
             plan_action(Katello::Foreman::ContentUpdate, repo.environment, repo.content_view, repo)
             plan_action(Katello::Repository::CorrectChecksum, repo)
             concurrence do
+              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_self(:id => repo.id, :sync_result => output, :user_id => ::User.current.id, :contents_changed => contents_changed)
               plan_action(Pulp::Repository::RegenerateApplicability, :pulp_id => repo.pulp_id, :contents_changed => contents_changed)
             end
+            plan_self(:id => repo.id, :sync_result => output, :skip_metadata_check => skip_metadata_check, :validate_contents => validate_contents,
+                      :contents_changed => contents_changed)
             plan_action(Katello::Repository::ImportApplicability, :repo_id => repo.id, :contents_changed => contents_changed)
           end
         end
@@ -51,7 +59,13 @@ module Actions
         end
 
         def humanized_name
-          _("Synchronize") # TODO: rename class to Synchronize and remove this method, add Sync = Synchronize
+          if input[:validate_contents]
+            _("Synchronize: Validate Content")
+          elsif input[:skip_metadata_check]
+            _("Synchronize: Skip Metadata Check")
+          else
+            _("Synchronize")
+          end
         end
 
         def presenter