katello 3.12.3 → 3.13.0.rc1

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

@@ -0,0 +1,19 @@
+module Actions
+  module Pulp3
+    module Repository
+      class CopyVersion < Pulp3::AbstractAsyncTask
+        def plan(source_repository, smart_proxy, target_repository)
+          plan_self(:source_repository_id => source_repository.id,
+                    :target_repository_id => target_repository.id,
+                    :smart_proxy_id => smart_proxy.id)
+        end
+
+        def invoke_external_task
+          source = ::Katello::Repository.find(input[:source_repository_id])
+          target = ::Katello::Repository.find(input[:target_repository_id] || input[:target_repository])
+          output[:pulp_tasks] = target.backend_service(smart_proxy).copy_version(source)
+        end
+      end
+    end
+  end
+end

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

@@ -2,10 +2,11 @@ module Actions
   module Pulp3
     module Repository
       class CreatePublication < Pulp3::AbstractAsyncTask
+        middleware.use Actions::Middleware::ExecuteIfContentsChanged
         def plan(repository, smart_proxy, options)
           sequence do
-            action = plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id, :options => options)
-            plan_action(SavePublication, repository, action.output[:pulp_tasks])
+            action = plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id, :contents_changed => options[:contents_changed], :options => options)
+            plan_action(SavePublication, repository, action.output, :contents_changed => options[:contents_changed])
           end
         end
 

data/app/lib/actions/pulp3/repository/presenters/abstract_sync_presenter.rb

@@ -0,0 +1,42 @@
+module Actions
+  module Pulp3
+    module Repository
+      module Presenters
+        class AbstractSyncPresenter < Helpers::Presenter::Base
+          def humanized_output
+            if action.external_task
+              humanized_details
+            end
+          end
+
+          private
+
+          def humanized_details
+            fail NotImplementedError
+          end
+
+          def sync_task
+            tasks = action.external_task.select do |task|
+              if task.key? 'name'
+                task['name'].include?("sync")
+              end
+            end
+            tasks.first
+          end
+
+          def cancelled?
+            sync_task && sync_task['state'] == 'cancelled'
+          end
+
+          def task_result
+            sync_task['result']
+          end
+
+          def task_result_details
+            task_result && task_result['details']
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/repository/presenters/content_unit_presenter.rb

@@ -0,0 +1,57 @@
+module Actions
+  module Pulp3
+    module Repository
+      module Presenters
+        class ContentUnitPresenter < AbstractSyncPresenter
+          def progress
+            total_units == 0 ? 0.1 : finished_units.to_f / total_units
+          end
+
+          private
+
+          def humanized_details
+            ret = []
+            ret << _("Cancelled.") if cancelled?
+            ret << _("Total tasks: ") + ": #{finished_units}/#{total_units}"
+            ret << "--------------------------------"
+            progress_reports = sync_task.try(:[], 'progress_reports') || []
+            progress_reports.each do |pr|
+              done = pr.try(:[], 'done')
+              total = pr.try(:[], 'total') || pr.try(:[], 'done')
+              unless done.nil? || total.nil?
+                ret << _(pr.try(:[], 'message') + ": #{done}/#{total}")
+              end
+            end
+
+            ret.join("\n")
+          end
+
+          def total_units
+            total_unit = 0
+            progress_reports = sync_task.try(:[], 'progress_reports') || []
+            progress_reports.each do |pr|
+              total = pr.try(:[], 'total')
+              total = pr.try(:[], 'done') if total.nil?
+              unless total.nil?
+                total_unit += total.to_i
+              end
+            end
+            total_unit
+          end
+
+          def finished_units
+            finished_unit = 0
+            progress_reports = sync_task.try(:[], 'progress_reports') || []
+            progress_reports.each do |pr|
+              done = pr.try(:[], 'done')
+              unless done.nil?
+                finished_unit += done.to_i
+              end
+            end
+            finished_unit
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,10 +3,14 @@ module Actions
     module Repository
       class RefreshDistribution < Pulp3::AbstractAsyncTask
         include Helpers::Presenter
+        middleware.use Actions::Middleware::ExecuteIfContentsChanged
 
-        def plan(repository, smart_proxy)
-          action = plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id)
-          plan_action(SaveDistributionReferences, repository, smart_proxy, action.output[:pulp_tasks])
+        def plan(repository, smart_proxy, options = {})
+          sequence do
+            action = plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id, :contents_changed => options[:contents_changed])
+            plan_action(SaveDistributionReferences, repository, smart_proxy,
+                        action.output, :contents_changed => options[:contents_changed])
+          end
         end
 
         def invoke_external_task

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

@@ -0,0 +1,23 @@
+module Actions
+  module Pulp3
+    module Repository
+      class RemoveUnits < Pulp3::AbstractAsyncTask
+        def plan(repository, smart_proxy, options)
+          plan_self(repository_id: repository.id,
+                    smart_proxy_id: smart_proxy.id,
+                    options: options)
+        end
+
+        def invoke_external_task
+          repo = ::Katello::Repository.find(input[:repository_id])
+          content_unit_ids = input[:options][:contents]
+
+          content_type = ::Katello::RepositoryTypeManager.find_content_type(input[:options][:content_unit_type].downcase)
+          units = content_type.model_class.where(:id => content_unit_ids)
+
+          output[:pulp_tasks] = repo.backend_service(smart_proxy).remove_content(units)
+        end
+      end
+    end
+  end
+end

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

@@ -2,13 +2,15 @@ module Actions
   module Pulp3
     module Repository
       class SaveDistributionReferences < Pulp3::Abstract
-        def plan(repository, smart_proxy, tasks)
-          plan_self(repository_id: repository.id, smart_proxy_id: smart_proxy.id, tasks: tasks)
+        middleware.use Actions::Middleware::ExecuteIfContentsChanged
+
+        def plan(repository, smart_proxy, tasks, options = {})
+          plan_self(repository_id: repository.id, smart_proxy_id: smart_proxy.id, tasks: tasks, contents_changed: options[:contents_changed])
         end
 
         def run
-          if input[:tasks] && input[:tasks].first
-            distribution_hrefs = input[:tasks].map { |task| task[:created_resources].first }
+          if input[:tasks] && input[:tasks][:pulp_tasks] && input[:tasks][:pulp_tasks].first
+            distribution_hrefs = input[:tasks][:pulp_tasks].map { |task| task[:created_resources].first }
             distribution_hrefs.compact!
             if distribution_hrefs.any?
               repo = ::Katello::Repository.find(input[:repository_id])

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

@@ -2,13 +2,14 @@ module Actions
   module Pulp3
     module Repository
       class SavePublication < Pulp3::Abstract
-        def plan(repository, tasks)
-          plan_self(:repository_id => repository.id, :tasks => tasks)
+        middleware.use Actions::Middleware::ExecuteIfContentsChanged
+        def plan(repository, tasks, options = {})
+          plan_self(:repository_id => repository.id, :tasks => tasks, :contents_changed => options[:contents_changed])
         end
 
         def run
-          if input[:tasks] && input[:tasks].first
-            publication_href = input[:tasks].first[:created_resources].first
+          if input[:tasks] && input[:tasks][:pulp_tasks] && input[:tasks][:pulp_tasks].first
+            publication_href = input[:tasks][:pulp_tasks].first[:created_resources].first
             if publication_href
               repo = ::Katello::Repository.find(input[:repository_id])
               repo.update_attributes(:publication_href => publication_href)

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

@@ -7,10 +7,14 @@ module Actions
         end
 
         def run
-          publication_href = input[:tasks].first[:created_resources].first
-          if publication_href
-            repo = ::Katello::Repository.find(input[:repository_id])
-            repo.update_attributes(:version_href => publication_href)
+          version_href = input[:tasks].last[:created_resources].first
+          repo = ::Katello::Repository.find(input[:repository_id])
+          repo_version = repo.backend_service(::SmartProxy.pulp_master).lookup_version version_href
+          content_summary = send(:eval, repo_version.content_summary)
+          first_version = (repo_version.number == 1)
+          output[:contents_changed] = first_version || !(content_summary.dig(:added).empty? && content_summary.dig(:removed).empty?)
+          if version_href && output[:contents_changed]
+            repo.update_attributes(:version_href => version_href)
           end
         end
       end

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

@@ -0,0 +1,55 @@
+module Actions
+  module Pulp3
+    module Repository
+      class Sync < Pulp3::AbstractAsyncTask
+        include Helpers::Presenter
+
+        def plan(repo, smart_proxy, options = {})
+          plan_self(:repo_id => repo.id, :smart_proxy_id => smart_proxy.id, :options => options)
+        end
+
+        def invoke_external_task
+          repo = ::Katello::Repository.find(input[:repo_id])
+          output[:pulp_tasks] = repo.backend_service(::SmartProxy.find(input[:smart_proxy_id])).sync
+        end
+
+        def external_task=(tasks)
+          output[:create_version] = true
+          super
+        end
+
+        def finalize
+          check_error_details
+        end
+
+        def check_error_details
+          output[:pulp_tasks].each do |pulp_task|
+            error_details = pulp_task.try(:[], "error")
+            if error_details && !error_details.nil?
+              fail _("An error occurred during the sync \n%{error_message}") % {:error_message => error_details}
+            end
+          end
+        end
+
+        def run_progress
+          presenter.progress
+        end
+
+        def run_progress_weight
+          10
+        end
+
+        def presenter
+          Presenters::ContentUnitPresenter.new(self)
+        end
+
+        def rescue_strategy_for_self
+          # There are various reasons the syncing fails, not all of them are
+          # fatal: when fail on syncing, we continue with the task ending up
+          # in the warning state, but not locking further syncs
+          Dynflow::Action::Rescue::Skip
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/repository/{delete_publisher.rb → update_distributions.rb}

@@ -1,14 +1,14 @@
 module Actions
   module Pulp3
     module Repository
-      class DeletePublisher < Pulp3::AbstractAsyncTask
-        def plan(repository_id, smart_proxy)
-          plan_self(:repository_id => repository_id, :smart_proxy_id => smart_proxy.id)
+      class UpdateDistributions < Pulp3::Abstract
+        def plan(repository, smart_proxy)
+          plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id)
         end
 
-        def invoke_external_task
+        def run
           repo = ::Katello::Repository.find(input[:repository_id])
-          output[:response] = repo.backend_service(smart_proxy).delete_publisher
+          output[:response] = repo.backend_service(smart_proxy).refresh_distributions
         end
       end
     end

data/app/lib/actions/pulp3/repository/{create_publisher.rb → update_remote.rb}

@@ -1,14 +1,14 @@
 module Actions
   module Pulp3
     module Repository
-      class CreatePublisher < Pulp3::Abstract
+      class UpdateRemote < Pulp3::Abstract
         def plan(repository, smart_proxy)
           plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id)
         end
 
         def run
           repo = ::Katello::Repository.find(input[:repository_id])
-          output[:response] = repo.backend_service(smart_proxy).create_publisher
+          output[:response] = repo.backend_service(smart_proxy).update_remote
         end
       end
     end

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

@@ -0,0 +1,16 @@
+module Actions
+  module Pulp3
+    module Repository
+      class UpdateRepository < Pulp3::Abstract
+        def plan(repository, smart_proxy)
+          plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id)
+        end
+
+        def run
+          repo = ::Katello::Repository.find(input[:repository_id])
+          output[:response] = repo.backend_service(smart_proxy).update
+        end
+      end
+    end
+  end
+end

data/app/lib/katello/errors.rb

@@ -116,5 +116,14 @@ module Katello
         end
       end
     end
+
+    class UpstreamConsumerGone < StandardError
+      def message
+        _("The Subscription Allocation providing the imported manifest has been removed. " \
+          "Please create a new Subscription Allocation and import the new manifest.")
+      end
+    end
+
+    class UpstreamEntitlementGone < StandardError; end
   end
 end

data/app/lib/katello/resources/candlepin/activation_key.rb

@@ -10,13 +10,14 @@ module Katello
             ::Katello::Util::Data.array_with_indifferent_access akeys
           end
 
-          def create(name, owner_key, auto_attach)
+          def create(name, owner_key, auto_attach, purpose_role, purpose_usage, purpose_addons)
             url = "/candlepin/owners/#{owner_key}/activation_keys"
-            JSON.parse(self.post(url, {:name => name, :autoAttach => auto_attach}.to_json, self.default_headers).body).with_indifferent_access
+            JSON.parse(self.post(url, {:name => name, :autoAttach => auto_attach, :role => purpose_role, :usage => purpose_usage, :addOns => purpose_addons}.to_json, self.default_headers).body).with_indifferent_access
           end
 
-          def update(id, release_version, service_level, auto_attach)
-            attrs = { :releaseVer => release_version, :serviceLevel => service_level, :autoAttach => auto_attach }.delete_if { |_k, v| v.nil? }
+          # rubocop:disable Metrics/ParameterLists
+          def update(id, release_version, service_level, auto_attach, purpose_role, purpose_usage, purpose_addons)
+            attrs = { :releaseVer => release_version, :serviceLevel => service_level, :autoAttach => auto_attach, :role => purpose_role, :usage => purpose_usage, :addOns => purpose_addons }.delete_if { |_k, v| v.nil? }
             JSON.parse(self.put(path(id), attrs.to_json, self.default_headers).body).with_indifferent_access
           end
 

data/app/lib/katello/resources/candlepin/product.rb

@@ -110,6 +110,10 @@ module Katello
           def path(owner_label, id = nil)
             "/candlepin/owners/#{owner_label}/products/#{id}"
           end
+
+          def update(owner_label, attrs)
+            JSON.parse(self.put(path(owner_label, attrs[:id] || attrs['id']), JSON.generate(attrs), self.default_headers).body).with_indifferent_access
+          end
         end
       end
     end

data/app/lib/katello/resources/candlepin/upstream_consumer.rb

@@ -9,10 +9,21 @@ module Katello
             super(id)
           end
 
+          # Overrides the HttpResource get method to check if the upstream
+          # consumer exists.
+          def get(params)
+            includes = params.key?(:include_only) ? "&" + included_list(params.delete(:include_only)) : ""
+            JSON.parse(super(path + hash_to_query(params) + includes, self.default_headers).body)
+          rescue RestClient::Gone
+            raise ::Katello::Errors::UpstreamConsumerGone
+          end
+
           def remove_entitlement(entitlement_id)
             fail ArgumentError, "No entitlement ID given to remove." if entitlement_id.blank?
 
             self["entitlements/#{entitlement_id}"].delete
+          rescue RestClient::NotFound
+            raise ::Katello::Errors::UpstreamEntitlementGone
           end
 
           def export(url, client_cert, client_key, ca_file)

data/app/lib/katello/resources/candlepin/upstream_pool.rb

@@ -5,11 +5,15 @@ module Katello
         extend PoolResource
 
         class << self
+          def get(*args)
+            resource.get(*args)
+          rescue RestClient::Gone
+            raise Katello::Errors::UpstreamConsumerGone
+          end
+
           def path(id = nil, owner_label = nil)
             super(id, owner_label || upstream_owner_id)
           end
-
-          delegate :get, to: :resource
         end
       end
     end