katello 4.7.3 → 4.8.0.rc1

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

@@ -1,154 +0,0 @@
-module Actions
-  module Pulp
-    class AbstractAsyncTask < Pulp::Abstract
-      include Actions::Base::Polling
-      include ::Dynflow::Action::Cancellable
-
-      FINISHED_STATES = %w(finished error canceled skipped).freeze
-
-      # A call report (documented http://pulp-dev-guide.readthedocs.org/en/latest/conventions/sync-v-async.html)
-      # Looks like:  {
-      #     "result": {},
-      #     "error": {},
-      #     "spawned_tasks": [{"_href": "/pulp/api/v2/tasks/7744e2df-39b9-46f0-bb10-feffa2f7014b/",
-      #                    "task_id": "7744e2df-39b9-46f0-bb10-feffa2f7014b" }]
-      #     }
-      #
-      #
-
-      # A Task (documented http://pulp-dev-guide.readthedocs.org/en/latest/integration/rest-api/dispatch/task.html#task-management)
-      # Looks like:
-      # {
-      #  "_href": "/pulp/api/v2/tasks/0fe4fcab-a040-11e1-a71c-00508d977dff/",
-      #  "state": "running",
-      #  "queue": "reserved_resource_worker-0@your.domain.com",
-      #  "task_id": "0fe4fcab-a040-11e1-a71c-00508d977dff",
-      #  "task_type": "pulp.server.tasks.repository.sync_with_auto_publish",
-      #  "progress_report": {}, # contents depend on the operation
-      #  "result": null,
-      #  "start_time": "2012-05-17T16:48:00Z",
-      #  "finish_time": null,
-      #  "exception": null,
-      #  "traceback": null,
-      #  "tags": [
-      #    "pulp:repository:f16",
-      #    "pulp:action:sync"
-      #  ],
-      #  "spawned_tasks": [{"href": "/pulp/api/v2/tasks/7744e2df-39b9-46f0-bb10-feffa2f7014b/",
-      #                     "task_id": "7744e2df-39b9-46f0-bb10-feffa2f7014b" }],
-      #  "error": null
-      #}
-
-      def run(event = nil)
-        # do nothing when the action is being skipped
-        unless event == Dynflow::Action::Skip
-          super
-        end
-      end
-
-      def humanized_state
-        case state
-        when :running
-          if self.external_task.nil?
-            _("initiating Pulp task")
-          else
-            _("checking Pulp task status")
-          end
-        when :suspended
-          if external_task&.all? { |task| task[:start_time].nil? }
-            _("waiting for Pulp to start the task")
-          else
-            _("waiting for Pulp to finish the task")
-          end
-        else
-          super
-        end
-      end
-
-      def done?
-        external_task&.all? { |task| task[:finish_time] || FINISHED_STATES.include?(task[:state]) }
-      end
-
-      def external_task
-        output[:pulp_tasks]
-      end
-
-      def cancel!
-        output[:cancelled] = true
-        cancel
-        self.external_task = poll_external_task
-        # We suspend the action and the polling will take care of finding
-        # out if the cancelling was successful
-        suspend unless done?
-      end
-
-      def cancel
-        output[:pulp_tasks].each do |pulp_task|
-          task_resource.cancel(pulp_task['task_id'])
-          #the main task may have completed, so cancel spawned tasks too
-          pulp_task['spawned_tasks']&.each { |spawned| task_resource.cancel(spawned['task_id']) }
-        end
-      end
-
-      def rescue_external_task(error)
-        if error.is_a?(::Katello::Errors::PulpError)
-          fail error
-        else
-          super
-        end
-      end
-
-      private
-
-      def external_task=(external_task_data)
-        external_task_data = [] if external_task_data.nil?
-        external_task_data = [external_task_data] if external_task_data.is_a?(Hash)
-
-        new_tasks = []
-        external_task_data.each do |task|
-          if task['spawned_tasks'].length > 0
-            spawned_ids = task['spawned_tasks'].map { |spawned| spawned['task_id'] }
-            new_tasks.concat(get_new_tasks(external_task_data, spawned_ids))
-          end
-        end
-
-        # Combine new tasks and remove call reports and ignored tasks
-        output[:pulp_tasks] = (external_task_data + new_tasks).reject do |task|
-          task["task_id"].nil? || (task["tags"] && (task["tags"] & ignored_tags).present?)
-        end
-        output[:pulp_tasks].each do |pulp_task|
-          if (pulp_exception = ::Katello::Errors::PulpError.from_task(pulp_task))
-            fail pulp_exception
-          end
-        end
-      end
-
-      def get_new_tasks(current_list, spawned_task_ids)
-        new_tasks = (spawned_task_ids - current_list.map { |task| task['task_id'] }).map do |task_id|
-          task_resource.poll(task_id)
-        end
-
-        if new_tasks.empty?
-          []
-        else
-          spawned = new_tasks.map { |t| t['spawned_tasks'].map { |st| st['task_id'] } }.flatten
-          new_tasks + get_new_tasks(current_list + new_tasks, spawned)
-        end
-      end
-
-      def poll_external_task
-        external_task.map do |task|
-          task_resource.poll(task[:task_id])
-        end
-      end
-
-      def task_resource
-        pulp_resources.task
-      end
-
-      def ignored_tags
-        []
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/abstract_async_task_group.rb

@@ -1,94 +0,0 @@
-module Actions
-  module Pulp
-    class AbstractAsyncTaskGroup < Pulp::Abstract
-      include Actions::Base::Polling
-      include ::Dynflow::Action::Cancellable
-
-      # A call report (documented https://github.com/pulp/pulp/blob/master/docs/dev-guide/integration/rest-api/consumer/applicability.rst#id65)
-      # Looks like:
-      #  {
-      #    "_href": "/pulp/api/v2/task_groups/7744e2df-39b9-46f0-bb10-feffa2f7014b/",
-      #    "group_id": "7744e2df-39b9-46f0-bb10-feffa2f7014b"
-      #  }
-      #
-      # A TaskGroup (https://github.com/pulp/pulp/blob/master/docs/dev-guide/integration/rest-api/tasks.rst#task-group-management)
-      # Looks like:
-      # {
-      #  "accepted": 0,
-      #  "finished": 100,
-      #  "running": 4,
-      #  "canceled": 0,
-      #  "waiting": 2,
-      #  "skipped": 0,
-      #  "suspended": 0,
-      #  "error": 0,
-      #  "total": 106
-      # }
-
-      def run(event = nil)
-        # do nothing when the action is being skipped
-        unless event == Dynflow::Action::Skip
-          super
-        end
-      end
-
-      def cancel!
-        cancel
-        self.external_task = poll_external_task
-        # We suspend the action and the polling will take care of finding
-        # out if the cancelling was successful
-        suspend unless done?
-      end
-
-      def cancel
-        group = output['pulp_task_group']
-        if group
-          task_resource.cancel(group['id'])
-        end
-      rescue RestClient::ResourceNotFound
-        nil #Pulp throws a 404 if there are no tasks in the task group https://pulp.plan.io/issues/2943
-      end
-
-      def humanized_state
-        case state
-        when :running
-          if self.external_task.nil?
-            _("initiating Pulp task")
-          else
-            _("checking Pulp task status")
-          end
-        else
-          super
-        end
-      end
-
-      def done?
-        finishing_states = ["finished", "canceled", "skipped", "suspended", "error"]
-        return false if (finishing_states - external_task.keys).present?
-        task_resource.completed?(external_task)
-      end
-
-      def external_task
-        output["pulp_task_group"]
-      end
-
-      private
-
-      def external_task=(external_task_data)
-        if external_task_data.key?("group_id")
-          output["pulp_task_group"] = {"group_id" => external_task_data["group_id"]}
-        else
-          output["pulp_task_group"] = {"group_id" => output["pulp_task_group"]["group_id"]}.merge(external_task_data)
-        end
-      end
-
-      def poll_external_task
-        task_resource.summary(output["pulp_task_group"]["group_id"])
-      end
-
-      def task_resource
-        ::Katello.pulp_server.resources.task_group
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/consumer/sync_capsule.rb

@@ -1,45 +0,0 @@
-module Actions
-  module Pulp
-    module Consumer
-      class SyncCapsule < ::Actions::Pulp::AbstractAsyncTask
-        include ::Actions::Helpers::SmartProxySyncHistoryHelper
-        input_format do
-          param :capsule_id, Integer
-          param :repo_pulp_id, String
-          param :repository_id, Integer
-          param :sync_options
-        end
-
-        def plan(repository, smart_proxy, options)
-          plan_self(:capsule_id => smart_proxy.id, :repo_pulp_id => repository.pulp_id, :repository_id => repository.id, :sync_options => options)
-        end
-
-        def humanized_name
-          _("Synchronize capsule content")
-        end
-
-        def invoke_external_task
-          output[:pulp_tasks] = pulp_resources.repository.sync(input[:repo_pulp_id], override_config: input[:sync_options])
-        end
-
-        def run_progress
-          # override this method so this task's progress isn't 0.5
-          # when it is initiated, skewing the progress bar progress
-          self.done? ? 1 : 0.1
-        end
-
-        def rescue_strategy_for_self
-          if output[:cancelled]
-            Dynflow::Action::Rescue::Fail
-          else
-            Dynflow::Action::Rescue::Skip
-          end
-        end
-
-        def run_progress_weight
-          100
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/consumer/unassociate_units.rb

@@ -1,20 +0,0 @@
-module Actions
-  module Pulp
-    module Consumer
-      class UnassociateUnits < ::Actions::Pulp::AbstractAsyncTask
-        input_format do
-          param :capsule_id, Integer
-          param :repo_pulp_id, String
-        end
-
-        def humanized_name
-          _("Unassociate units in repository")
-        end
-
-        def invoke_external_task
-          pulp_resources.repository.unassociate_units(input[:repo_pulp_id])
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/expect_one_task.rb

@@ -1,11 +0,0 @@
-module Actions
-  module Pulp
-    module ExpectOneTask
-      def external_task=(external_task_data)
-        external_task_data = [external_task_data] unless external_task_data.is_a?(Array)
-        fail "Not expecting more than one task" if external_task_data.length > 1
-        super(external_task_data)
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/orchestration/orphan_cleanup/remove_orphans.rb

@@ -1,16 +0,0 @@
-module Actions
-  module Pulp
-    module Orchestration
-      module OrphanCleanup
-        class RemoveOrphans < Pulp::Abstract
-          def plan(proxy)
-            sequence do
-              plan_action(Actions::Pulp::OrphanCleanup::RemoveUnneededRepos, proxy) unless proxy.pulp_primary?
-              plan_action(Actions::Pulp::OrphanCleanup::RemoveOrphans, proxy)
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-module Actions
-  module Pulp
-    module Orchestration
-      module Repository
-        class CopyAllUnits < Pulp::Abstract
-          def plan(target_repo, smart_proxy, source_repos, options = {})
-            source_repos.each do |source_repo|
-              plan_action(Pulp::Repository::CopyAllUnits,
-                          target_repo,
-                          smart_proxy,
-                          source_repo,
-                          options)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/orchestration/repository/delete.rb

@@ -1,15 +0,0 @@
-module Actions
-  module Pulp
-    module Orchestration
-      module Repository
-        class Delete < Pulp::Abstract
-          def plan(repository, _smart_proxy)
-            sequence do
-              plan_action(Pulp::Repository::Destroy, repository_id: repository.id)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/orchestration/repository/refresh.rb

@@ -1,14 +0,0 @@
-module Actions
-  module Pulp
-    module Orchestration
-      module Repository
-        class Refresh < Pulp::Abstract
-          def plan(repository, smart_proxy, options = {})
-            options[:capsule_id] = smart_proxy.id
-            plan_action(Actions::Pulp::Repository::Refresh, repository, options)
-          end
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/orchestration/repository/refresh_if_needed.rb

@@ -1,13 +0,0 @@
-module Actions
-  module Pulp
-    module Orchestration
-      module Repository
-        class RefreshIfNeeded < Pulp::Abstract
-          def plan(repository, smart_proxy, _options = {})
-            plan_action(Actions::Pulp::Repository::Refresh, repository, smart_proxy_id: smart_proxy.id)
-          end
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/orchestration/repository/refresh_repos.rb

@@ -1,19 +0,0 @@
-module Actions
-  module Pulp
-    module Orchestration
-      module Repository
-        class RefreshRepos < Pulp::AbstractAsyncTask
-          include ::Actions::Katello::CapsuleContent::RefreshRepos
-
-          def fetch_proxy_service(smart_proxy)
-            ::Katello::Pulp::SmartProxyRepository.new(smart_proxy)
-          end
-
-          def act_on_repo?(repo, smart_proxy)
-            !smart_proxy.pulp3_support?(repo)
-          end
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/orchestration/repository/remove_units.rb

@@ -1,14 +0,0 @@
-module Actions
-  module Pulp
-    module Orchestration
-      module Repository
-        class RemoveUnits < Pulp::Abstract
-          def plan(repository, _smart_proxy, options)
-            options[:repo_id] = repository.id
-            plan_action(Actions::Pulp::Repository::RemoveUnits, options)
-          end
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/orchestration/repository/smart_proxy_sync.rb

@@ -1,34 +0,0 @@
-module Actions
-  module Pulp
-    module Orchestration
-      module Repository
-        class SmartProxySync < Pulp::Abstract
-          def plan(repository, smart_proxy, options)
-            skip_metadata_check = options.fetch(:skip_metadata_check, false)
-            sequence do
-              if repository && ['yum', 'puppet'].exclude?(repository.content_type)
-                # we unassociate units in non-yum/puppet repos in order to avoid version conflicts
-                # during publish. (i.e. two versions of a unit in the same repository)
-                plan_action(Pulp::Consumer::UnassociateUnits,
-                             capsule_id: smart_proxy.id,
-                             repo_pulp_id: repository.pulp_id)
-              end
-              pulp_options = { remove_missing: repository && ["deb", "puppet", "yum"].include?(repository.content_type) }
-              pulp_options[:force_full] = true if skip_metadata_check && repository.content_type == "yum"
-              pulp_options[:repair_sync] = true if skip_metadata_check && repository.content_type == "deb"
-
-              plan_action(Pulp::Consumer::SyncCapsule,
-                               repository, smart_proxy, pulp_options)
-              if skip_metadata_check
-                plan_action(Katello::Repository::MetadataGenerate,
-                            repository,
-                            smart_proxy: smart_proxy,
-                            force: true)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/orchestration/repository/sync.rb

@@ -1,18 +0,0 @@
-module Actions
-  module Pulp
-    module Orchestration
-      module Repository
-        class Sync < Pulp::Abstract
-          include Actions::Helpers::OutputPropagator
-          def plan(repository, smart_proxy, options)
-            sequence do
-              options.merge!(:repo_id => repository.id, :smart_proxy_id => smart_proxy.id)
-              action_output = plan_action(Actions::Pulp::Repository::Sync, options).output
-              plan_self(:subaction_output => action_output)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/orchestration/repository/upload_content.rb

@@ -1,37 +0,0 @@
-module Actions
-  module Pulp
-    module Orchestration
-      module Repository
-        class UploadContent < Pulp::Abstract
-          include Actions::Helpers::OutputPropagator
-          def plan(repository, smart_proxy, file, unit_type_id)
-            sequence do
-              upload_request = plan_action(Pulp::Repository::CreateUploadRequest)
-              plan_action(Pulp::Repository::UploadFile,
-                          upload_id: upload_request.output[:upload_id],
-                          file: file[:path])
-              plan_action(Pulp::Repository::ImportUpload,
-                          repository, smart_proxy,
-                          pulp_id: repository.pulp_id,
-                          unit_type_id: unit_type_id,
-                          unit_key: unit_key(file, repository),
-                          upload_id: upload_request.output[:upload_id])
-              plan_action(Pulp::Repository::DeleteUploadRequest,
-                          upload_id: upload_request.output[:upload_id])
-              plan_self(:subaction_output => nil)
-            end
-          end
-
-          def unit_key(file, repository)
-            return {} unless repository.file?
-            {
-              :checksum => Digest::SHA256.hexdigest(File.read(file[:path])),
-              :name => file[:filename],
-              :size => File.size(file[:path])
-            }
-          end
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/orphan_cleanup/remove_orphans.rb

@@ -1,15 +0,0 @@
-module Actions
-  module Pulp
-    module OrphanCleanup
-      class RemoveOrphans < Pulp::AbstractAsyncTask
-        def plan(proxy)
-          plan_self(:capsule_id => proxy.id)
-        end
-
-        def invoke_external_task
-          pulp_resources.content.remove_orphans
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/orphan_cleanup/remove_unneeded_repos.rb

@@ -1,16 +0,0 @@
-module Actions
-  module Pulp
-    module OrphanCleanup
-      class RemoveUnneededRepos < Pulp::AbstractAsyncTask
-        def plan(smart_proxy)
-          plan_self(:smart_proxy_id => smart_proxy.id)
-        end
-
-        def invoke_external_task
-          smart_proxy_service = ::Katello::Pulp::SmartProxyRepository.new(::SmartProxy.unscoped.find(input[:smart_proxy_id]))
-          smart_proxy_service.delete_orphaned_repos
-        end
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-module Actions
-  module Pulp
-    module Repository
-      class AbstractCopyContent < Pulp::AbstractAsyncTask
-        input_format do
-          param :source_pulp_id
-          param :target_pulp_id
-          param :clauses
-          param :full_clauses
-          param :override_config
-          param :include_result
-        end
-
-        # @api override - pulp extension representing the content type to copy
-        def content_extension
-          fail NotImplementedError
-        end
-
-        def invoke_external_task
-          optional = criteria
-          optional[:override_config] = input[:override_config] if input[:override_config]
-          content_extension.copy(input[:source_pulp_id],
-                                 input[:target_pulp_id],
-                                 optional)
-        end
-
-        def criteria
-          if input[:full_clauses]
-            input[:full_clauses]
-          elsif input[:clauses]
-            { filters: {:unit => input[:clauses] } }
-          else
-            {}
-          end
-        end
-
-        def external_task=(external_task_data)
-          external_task_data = [external_task_data] if external_task_data.is_a?(Hash)
-          external_task_data = external_task_data.map { |task| task.except('result') } unless input[:include_result]
-          super(external_task_data)
-        end
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-module Actions
-  module Pulp
-    module Repository
-      class AbstractRemoveContent < Pulp::AbstractAsyncTask
-        input_format do
-          param :pulp_id
-          param :clauses
-        end
-
-        def invoke_external_task
-          pulp_extensions.repository.unassociate_units(input[:pulp_id],
-                                                       criteria)
-        end
-
-        # @api override - pulp extension representing the content to remove
-        # e.g. pulp.extensions.rpm
-        def content_extension
-          fail NotImplementedError
-        end
-
-        def criteria
-          { type_ids: [content_extension.content_type], filters: input[:clauses] }
-        end
-
-        def external_task=(external_task_data)
-          external_task_data = [external_task_data] if external_task_data.is_a?(Hash)
-          super(external_task_data.map { |task| task.except('result') })
-        end
-      end
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-module Actions
-  module Pulp
-    module Repository
-      class Clear < Actions::Pulp::AbstractAsyncTask
-        def plan(repo, smart_proxy)
-          plan_self(:repo_id => repo.id, :smart_proxy_id => smart_proxy.id) unless (repo.yum? || repo.empty_in_pulp?)
-        end
-
-        def invoke_external_task
-          repo = ::Katello::Repository.find(input[:repo_id])
-          ::Katello::RepositoryTypeManager.find(repo.content_type).content_types.map do |type|
-            ::SmartProxy.unscoped.find(input[:smart_proxy_id]).content_service(type).remove(repo)
-          end
-        end
-      end
-    end
-  end
-end