katello 3.6.0.1.rc2 → 3.7.0.rc1

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

@@ -4,6 +4,8 @@ module Actions
       class ManifestRefresh < Actions::AbstractAsyncTask
         middleware.use Actions::Middleware::PropagateCandlepinErrors
 
+        include Helpers::Notifications
+
         def plan(organization)
           action_subject organization
           manifest_update = organization.products.redhat.any?
@@ -32,9 +34,23 @@ module Actions
                 plan_action(Katello::Repository::RefreshRepository, repo, :dependency => import_products.output)
               end
             end
+            plan_self
           end
         end
 
+        def failure_notification(plan)
+          ::Katello::UINotifications::Subscriptions::ManifestRefreshError.deliver!(
+            :subject => subject_organization,
+            :task => get_foreman_task(plan)
+          )
+        end
+
+        def success_notification(_plan)
+          ::Katello::UINotifications::Subscriptions::ManifestRefreshSuccess.deliver!(
+            subject_organization
+          )
+        end
+
         def rescue_strategy
           Dynflow::Action::Rescue::Skip
         end
@@ -42,6 +58,12 @@ module Actions
         def humanized_name
           _("Refresh Manifest")
         end
+
+        def finalize
+          subject_organization.manifest_refreshed_at = Time.now
+          subject_organization.audit_comment = _('Manifest refreshed')
+          subject_organization.save(validate: false)
+        end
       end
     end
   end

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

@@ -17,25 +17,22 @@ module Actions
                         :multiplier => 1,
                         :attributes => [{:name => "arch", :value => "ALL"}])
 
-            sub_create = plan_action(::Actions::Candlepin::Product::CreateUnlimitedSubscription,
+            plan_action(::Actions::Candlepin::Product::CreateUnlimitedSubscription,
                         :owner_key => organization.label,
                         :product_id => product.cp_id,
                         :start_time => subscription_start)
 
-            subscription_id = sub_create.output[:response][:id]
-
             action_subject product, :cp_id => product.cp_id
 
             plan_self
-            plan_action Katello::Product::ReindexSubscriptions, product, subscription_id
+            plan_action ::Actions::Pulp::Repository::EnsureSyncNotification
+            plan_action Katello::Product::ReindexSubscriptions, product
           end
         end
 
         def run
           product = ::Katello::Product.find(input[:product][:id])
           product.update_attributes!(:cp_id => input[:cp_id])
-
-          ::Katello::Repository.ensure_sync_notification
         end
 
         def humanized_name

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

@@ -6,18 +6,17 @@ module Actions
 
         input_format do
           param :id
-          param :subscription_id
         end
 
-        def plan(product, subscription_id)
+        def plan(product)
           fail "Only custom products supported." if product.redhat?
           Type! product, ::Katello::Product
-          plan_self(id: product.id, subscription_id: subscription_id)
+          plan_self(id: product.id)
         end
 
         def run
           product = ::Katello::Product.find_by!(:id => input[:id])
-          product.import_subscription(input[:subscription_id])
+          product.import_custom_subscription
         end
       end
     end

data/app/lib/actions/katello/repository/{capsule_generate_and_sync.rb → capsule_sync.rb}

@@ -1,7 +1,7 @@
 module Actions
   module Katello
     module Repository
-      class CapsuleGenerateAndSync < Actions::Base
+      class CapsuleSync < Actions::Base
         def humanized_name
           _("Sync Repository on Smart Proxy(ies)")
         end

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

@@ -7,7 +7,8 @@ module Actions
             # 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]
+            if !target_repo.previous_changes.include?(:unprotected) &&
+                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

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

@@ -37,7 +37,8 @@ module Actions
                                         upstream_username: repository.upstream_username,
                                         upstream_password: repository.upstream_password,
                                         repo_registry_id: repository.container_repository_name,
-                                        proxy_host: repository.proxy_host_value)
+                                        proxy_host: repository.proxy_host_value,
+                                        ignorable_content: repository.ignorable_content)
 
             return if create_action.error
 

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

@@ -17,6 +17,8 @@ module Actions
             ::Katello::PuppetModule.import_for_repository(repo)
           elsif repo.docker?
             ::Katello::DockerManifest.import_for_repository(repo)
+            ::Katello::DockerTag.import_for_repository(repo)
+            ::Katello::DockerManifestList.import_for_repository(repo)
           elsif repo.file?
             ::Katello::FileUnit.import_for_repository(repo)
           elsif repo.deb?

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

@@ -7,32 +7,41 @@ module Actions
 
         def plan(repository, upload_ids, options = {})
           action_subject(repository)
+
           unit_keys = options.fetch(:unit_keys, {})
           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)
+
           sequence do
-            concurrence do
-              upload_ids.zip(unit_keys) do |upload_id, unit_key|
+            upload_results = concurrence do
+              upload_ids.zip(unit_keys).collect do |upload_id, unit_key|
+                if unit_type_id == 'docker_tag'
+                  unit_metadata = unit_key
+                end
                 import_upload = plan_action(Pulp::Repository::ImportUpload,
                                             pulp_id: repository.pulp_id,
-                                            unit_type_id: repository.unit_type_id,
+                                            unit_type_id: unit_type_id,
                                             unit_key: unit_key,
-                                            upload_id: upload_id)
+                                            upload_id: upload_id,
+                                            unit_metadata: unit_metadata)
 
                 plan_action(FinishUpload, repository, :dependency => import_upload.output,
                             generate_metadata: false)
+                import_upload.output
               end
             end
             plan_action(Katello::Repository::MetadataGenerate, repository) if generate_metadata
-            plan_self(repository_id: repository.id, sync_capsule: sync_capsule)
+            plan_self(repository_id: repository.id, sync_capsule: sync_capsule, upload_results: upload_results)
           end
         end
 
         def run
           repository = ::Katello::Repository.find(input[:repository_id])
           if input[:sync_capsule]
-            ForemanTasks.async_task(Katello::Repository::CapsuleGenerateAndSync, repository)
+            ForemanTasks.async_task(Katello::Repository::CapsuleSync, repository)
           end
+          output[:upload_results] = results_to_json(input[:upload_results])
         rescue ::Katello::Errors::CapsuleCannotBeReached # skip any capsules that cannot be connected to
         end
 
@@ -43,6 +52,29 @@ module Actions
         def humanized_name
           _("Upload into")
         end
+
+        def results_to_json(results)
+          json_results = []
+          results.each do |result|
+            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))
+                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))
+                json_result = JSON.parse(::Rabl.render(manifest, '/katello/api/v2/docker_tags/show'))
+                json_result[:type] = 'docker_tag'
+                json_results << json_result
+              else
+                json_results << {:type => 'file'}
+              end
+            end
+          end
+          json_results
+        end
       end
     end
   end

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

@@ -38,7 +38,7 @@ module Actions
                                      :clauses => {:association => {'unit_id' => {'$in' => uuids}}
             })
             plan_self
-            plan_action(CapsuleGenerateAndSync, repository) if sync_capsule
+            plan_action(CapsuleSync, repository) if sync_capsule
           end
         end
 

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

@@ -16,6 +16,7 @@ module Actions
         # @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
         # rubocop:disable MethodLength
+        # rubocop:disable CyclomaticComplexity
         def plan(repo, pulp_sync_task_id = nil, options = {})
           action_subject(repo)
 
@@ -35,6 +36,11 @@ module Actions
           fail ::Katello::Errors::InvalidActionOptionError, _("Cannot skip metadata check on non-yum repositories.") if skip_metadata_check && !repo.yum?
 
           sequence do
+            plan_action(::Actions::Pulp::Repository::EnsureSyncNotification)
+
+            # clear yum metadata if validate_contents is on (to avoid metadata corruption issues)
+            plan_action(Pulp::Repository::RemoveYumMetadataFile, :pulp_id => repo.pulp_id) if validate_contents
+
             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
 
@@ -52,11 +58,12 @@ module Actions
             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) if generate_applicability
+            plan_action(Katello::Repository::SyncHook, :id => repo.id)
           end
         end
 
         def run
-          ForemanTasks.async_task(Repository::CapsuleGenerateAndSync, ::Katello::Repository.find(input[:id]))
+          ForemanTasks.async_task(Repository::CapsuleSync, ::Katello::Repository.find(input[:id]))
         rescue ::Katello::Errors::CapsuleCannotBeReached # skip any capsules that cannot be connected to
         end
 

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

@@ -0,0 +1,11 @@
+module Actions
+  module Katello
+    module Repository
+      class SyncHook < Actions::Base
+        def finalize
+          ::Katello::Repository.find(input[:id]).sync_hook
+        end
+      end
+    end
+  end
+end

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

@@ -3,6 +3,7 @@ module Actions
     module Repository
       class Update < Actions::EntryAction
         middleware.use Actions::Middleware::KeepCurrentUser
+        # rubocop:disable MethodLength
         def plan(repository, repo_params)
           action_subject repository
           repository = repository.reload
@@ -37,10 +38,12 @@ module Actions
           end
 
           if SETTINGS[:katello][:use_pulp] && (repository.previous_changes.key?('unprotected') ||
-              repository.previous_changes.key?('checksum_type'))
+              repository.previous_changes.key?('checksum_type') ||
+              repository.previous_changes.key?('container_repository_name'))
             plan_self(:repository_id => repository.id)
           end
         end
+        # rubocop:enable MethodLength
 
         def run
           repository = ::Katello::Repository.find(input[:repository_id])

data/app/lib/actions/katello/sync_plan/add_products.rb

@@ -7,7 +7,7 @@ module Actions
         def plan(sync_plan, product_ids)
           action_subject(sync_plan)
 
-          ::Katello::Repository.ensure_sync_notification
+          plan_action(::Actions::Pulp::Repository::EnsureSyncNotification)
 
           products = ::Katello::Product.where(:id => product_ids).editable
           sync_plan.product_ids = (sync_plan.product_ids + products.collect { |p| p.id }).uniq

data/app/lib/actions/katello/upstream_subscriptions/bind_entitlement.rb

@@ -0,0 +1,31 @@
+module Actions
+  module Katello
+    module UpstreamSubscriptions
+      class BindEntitlement < Actions::Base
+        middleware.use Actions::Middleware::KeepCurrentTaxonomies
+
+        def run
+          output[:response] = ::Katello::Resources::Candlepin::UpstreamConsumer
+            .bind_entitlement(pool)
+        end
+
+        def humanized_name
+          N_("Bind an entitlement to an allocation")
+        end
+
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
+
+        private
+
+        def pool
+          {
+            pool: input[:pool],
+            quantity: input[:quantity]
+          }
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/katello/upstream_subscriptions/bind_entitlements.rb

@@ -0,0 +1,28 @@
+module Actions
+  module Katello
+    module UpstreamSubscriptions
+      class BindEntitlements < Actions::Base
+        middleware.use Actions::Middleware::KeepCurrentTaxonomies
+
+        def plan(pools = [])
+          fail _("No pools were provided.") unless pools.any?
+          fail _("Current organization is not set.") unless ::Organization.current
+          input[:pools] = pools
+
+          sequence do
+            concurrence do
+              pools.each do |pool|
+                plan_action(Katello::UpstreamSubscriptions::BindEntitlement, pool)
+              end
+            end
+            plan_action(Katello::Organization::ManifestRefresh, ::Organization.current)
+          end
+        end
+
+        def humanized_name
+          N_("Bind entitlements to an allocation")
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/katello/upstream_subscriptions/remove_entitlement.rb

@@ -0,0 +1,22 @@
+module Actions
+  module Katello
+    module UpstreamSubscriptions
+      class RemoveEntitlement < Actions::Base
+        middleware.use Actions::Middleware::KeepCurrentTaxonomies
+        middleware.use Actions::Middleware::PropagateCandlepinErrors
+
+        input_format do
+          param :entitlement_id
+        end
+
+        def run
+          output[:response] = ::Katello::Resources::Candlepin::UpstreamConsumer.remove_entitlement(input[:entitlement_id])
+        end
+
+        def run_progress_weight
+          0.01
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/katello/upstream_subscriptions/remove_entitlements.rb

@@ -0,0 +1,35 @@
+module Actions
+  module Katello
+    module UpstreamSubscriptions
+      class RemoveEntitlements < Actions::Base
+        middleware.use Actions::Middleware::KeepCurrentTaxonomies
+
+        def plan(pool_ids = [])
+          ids = pool_ids.uniq.compact
+          fail _("No pool IDs were provided.") if ids.blank?
+          fail _("Current organization is not set.") unless ::Organization.current
+
+          sequence do
+            ids.each do |pid|
+              pool = ::Katello::Pool.find(pid)
+
+              fail _("Provided pool with id %s has no upstream entitlement" % pid) if pool.upstream_entitlement_id.nil?
+
+              plan_action(::Actions::Katello::UpstreamSubscriptions::RemoveEntitlement, entitlement_id: pool.upstream_entitlement_id)
+            end
+
+            plan_action(::Actions::Katello::Organization::ManifestRefresh, ::Organization.current)
+          end
+        end
+
+        def humanized_name
+          N_("Delete Upstream Subscription")
+        end
+
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/katello/upstream_subscriptions/update_entitlement.rb

@@ -0,0 +1,23 @@
+module Actions
+  module Katello
+    module UpstreamSubscriptions
+      class UpdateEntitlement < Actions::Base
+        middleware.use Actions::Middleware::KeepCurrentTaxonomies
+        middleware.use Actions::Middleware::PropagateCandlepinErrors
+
+        input_format do
+          param :entitlement_id
+          param :quantity
+        end
+
+        def run
+          output[:response] = ::Katello::Resources::Candlepin::UpstreamEntitlement.update(input[:entitlement_id], input[:quantity])
+        end
+
+        def run_progress_weight
+          0.01
+        end
+      end
+    end
+  end
+end