katello 4.7.4 → 4.8.0.rc1

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

@@ -1,30 +0,0 @@
-module Actions
-  module Pulp
-    module Repository
-      class CopyAllUnits < Pulp::AbstractAsyncTask
-        def plan(target_repo, _smart_proxy, source_repo, options = {})
-          filter_ids = options.fetch(:filters, nil)&.map(&:id)
-          rpm_filenames = options.fetch(:rpm_filenames, nil)
-          solve_dependencies = options.fetch(:solve_dependencies, false)
-
-          plan_self(source_repo_id: source_repo.id,
-                    target_repo_id: target_repo.id,
-                    filter_ids: filter_ids,
-                    solve_dependencies: solve_dependencies,
-                    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_primary).copy_contents(target_repo,
-                                                                            filters: filters,
-                                                                            solve_dependencies: input[:solve_dependencies],
-                                                                            rpm_filenames: input[:rpm_filenames])
-        end
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-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),
-                      incremental_update: options[:incremental_update])
-          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_primary).copy_units(target_repo, units,
-                                                                          incremental_update: input[:incremental_update])
-        end
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-module Actions
-  module Pulp
-    module Repository
-      class Create < Pulp::Abstract
-        include Helpers::Presenter
-
-        input_format do
-          param :repository_id
-          param :capsule_id
-        end
-
-        def plan(repository, smart_proxy = SmartProxy.pulp_primary!)
-          plan_self(:repository_id => repository.id, :capsule_id => smart_proxy.id)
-        end
-
-        def run
-          if input[:repository_id]
-            repo = ::Katello::Repository.find(input[:repository_id])
-          end
-          output[:response] = repo.backend_service(smart_proxy(input[:capsule_id])).create
-        rescue RestClient::Conflict
-          Rails.logger.warn("Tried to add repository #{input[:pulp_id]} that already exists.")
-          []
-        end
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-module Actions
-  module Pulp
-    module Repository
-      class CreateInPlan < Create
-        alias_method :perform_run, :run
-
-        def plan(repository, smart_proxy)
-          input[:response] = repository.backend_service(smart_proxy).create
-        rescue RestClient::Conflict
-          Rails.logger.warn("Tried to add repository #{input[:pulp_id]} that already exists.")
-        end
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-module Actions
-  module Pulp
-    module Repository
-      class CreateUploadRequest < Pulp::Abstract
-        input_format do
-        end
-
-        output_format do
-          param :response
-          param :upload_id
-        end
-
-        def run
-          output[:response] = pulp_resources.content.create_upload_request
-          output[:upload_id] = output[:response][:upload_id]
-        end
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-module Actions
-  module Pulp
-    module Repository
-      class DeleteUploadRequest < Pulp::Abstract
-        input_format do
-          param :upload_id
-        end
-
-        output_format do
-          param :response
-        end
-
-        def run
-          output[:response] = pulp_resources.content.delete_upload_request(input[:upload_id])
-        end
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-module Actions
-  module Pulp
-    module Repository
-      class Destroy < Pulp::AbstractAsyncTask
-        input_format do
-          param :repository_id
-          param :capsule_id
-          param :content_view_puppet_environment_id
-        end
-
-        def invoke_external_task
-          begin
-            if input[:content_view_puppet_environment_id]
-              repo = ::Katello::ContentViewPuppetEnvironment.find(input[:content_view_puppet_environment_id]).nonpersisted_repository
-            else
-              repo = ::Katello::Repository.find(input[:repository_id])
-            end
-          rescue ActiveRecord::RecordNotFound
-            Rails.logger.warn("Tried to delete repository #{input[:repository_id]}, but it did not exist.")
-            return []
-          end
-          capsule = input[:capsule_id] ? smart_proxy(input[:capsule_id]) : SmartProxy.pulp_primary
-          output[:pulp_tasks] = repo.backend_service(capsule).delete
-        end
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-module Actions
-  module Pulp
-    module Repository
-      class DistributorPublish < Pulp::AbstractAsyncTask
-        middleware.use Actions::Middleware::SkipIfMatchingContent
-
-        def plan(repository, smart_proxy, options)
-          options = {:smart_proxy_id => smart_proxy.id, :options => options, :dependency => options[:dependency]}
-          options[:repository_id] = repository.id
-          plan_self(options)
-        end
-
-        def invoke_external_task
-          repo = ::Katello::Repository.find_by(:id => input[:repository_id])
-          repo.clear_smart_proxy_sync_histories if smart_proxy(input[:smart_proxy_id]).pulp_primary?
-          repo.backend_service(smart_proxy(input[:smart_proxy_id])).distributor_publish(input[:options])
-        end
-
-        def humanized_name
-          _("Repository metadata publish")
-        end
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-module Actions
-  module Pulp
-    module Repository
-      class Download < Pulp::AbstractAsyncTask
-        input_format do
-          param :pulp_id
-          param :options
-        end
-
-        def invoke_external_task
-          output[:pulp_tasks] = pulp_resources.repository.download(input[:pulp_id], input[:options])
-        end
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-module Actions
-  module Pulp
-    module Repository
-      class ImportUpload < Pulp::AbstractAsyncTask
-        def plan(_repo, _smart_proxy, options)
-          plan_self(:options => options)
-        end
-
-        def invoke_external_task
-          output[:pulp_tasks] = [pulp_resources.content.import_into_repo(input[:options][:pulp_id],
-                                                   input[:options][:unit_type_id],
-                                                   input[:options][:upload_id],
-                                                   input[:options][:unit_key],
-                                                   unit_metadata: input[:options][:unit_metadata] || {})]
-        end
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-module Actions
-  module Pulp
-    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? 'tags'
-                task['tags'].include?("pulp:action:sync")
-              else
-                # workaround for https://bugzilla.redhat.com/show_bug.cgi?id=1131537
-                # as the sync plan tasks don't have tags in pulp
-                task['result'] &&
-                    task['result']['importer_type_id'].to_s =~ /_importer$/
-              end
-            end
-            tasks.first
-          end
-
-          def cancelled?
-            sync_task['state'] == 'canceled'
-          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/pulp/repository/presenters/deb_presenter.rb

@@ -1,95 +0,0 @@
-module Actions
-  module Pulp
-    module Repository
-      module Presenters
-        class DebPresenter < AbstractSyncPresenter
-          def progress
-            if items_total > 0
-              items_done.to_f / items_total
-            else
-              0.01
-            end
-          end
-
-          private
-
-          def humanized_details
-            task_details&.inject([]) do |res, step|
-              res.append("#{step[:description]} (#{step[:num_processed]}/#{step[:items_total]})") if step[:state] == "IN_PROGRESS"
-              res
-            end
-          end
-
-          def size_summary
-            helper = Object.new.extend(ActionView::Helpers::NumberHelper)
-            if content_details[:state] == "IN_PROGRESS"
-              "#{helper.number_to_human_size(size_done)}/#{helper.number_to_human_size(size_total)}"
-            else
-              helper.number_to_human_size(size_total)
-            end
-          end
-
-          def task_progress
-            sync_task[:progress_report]
-          end
-
-          def task_progress_details
-            task_progress && task_progress[:deb_importer]
-          end
-
-          def task_details
-            task_result_details || task_progress_details
-          end
-
-          def content_details
-            task_details && task_details[:content]
-          end
-
-          def error_details
-            content_details.nil? ? [] : content_details[:error_details]
-          end
-
-          def metadata_details
-            task_details && task_details[:metadata]
-          end
-
-          def items_done
-            task_details&.inject(0) { |sum, details| sum + details[:num_success].to_i } || 0
-          end
-
-          def items_total
-            task_details&.inject(0) { |sum, details| sum + details[:items_total].to_i } || 0
-          end
-
-          def size_done
-            size_total - content_details[:size_left]
-          end
-
-          def size_total
-            (content_details && content_details[:size_total]).to_i
-          end
-
-          def cancelled?
-            task_details.nil? ? false : task_details.values.map { |item| item['state'] }.include?('CANCELLED')
-          end
-
-          def content_started?
-            content_details && content_details[:state] != 'NOT_STARTED'
-          end
-
-          def metadata_in_progress?
-            metadata_details && metadata_details[:state] == 'IN_PROGRESS'
-          end
-
-          def metadata_error
-            metadata_details && metadata_details[:error]
-          end
-
-          def pending?
-            metadata_details.nil? || metadata_details['state'] == 'NOT_RUNNING'
-          end
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/repository/presenters/docker_presenter.rb

@@ -1,103 +0,0 @@
-module Actions
-  module Pulp
-    module Repository
-      module Presenters
-        class DockerPresenter < AbstractSyncPresenter
-          def progress
-            details = task_progress_details
-            if details
-              completion = 0.0
-              completion += 0.1 if content_completed?(details("sync_step_metadata"))
-              completion += 0.1 if content_completed?(details("get_local"))
-              completion += 0.1 if content_completed?(details("sync_step_save"))
-              download_details = details("sync_step_download")
-              if content_completed?(download_details)
-                completion += 0.7
-              elsif content_started?(download_details) && items_total(download_details) > 0
-                completion += 0.7 * items_done(download_details) / items_total(download_details)
-              end
-              completion
-            else
-              0.01
-            end
-          end
-
-          private
-
-          def humanized_details
-            download_details = details("sync_step_download")
-            ret = []
-            ret << _("Cancelled.") if cancelled?
-
-            if content_started?(download_details)
-              if items_total(download_details) > 0
-                ret << (_("New blobs: %{count}.") % {:count => count_summary})
-              end
-            elsif sync_task["state"] == "running"
-              ret << _("Processing metadata")
-            end
-
-            ret << metadata_error if metadata_error
-            ret.join("\n")
-          end
-
-          def count_summary
-            download_details = details("sync_step_download")
-
-            if download_details[:state] == "IN_PROGRESS"
-              "#{items_done(download_details)}/#{items_total(download_details)}"
-            else
-              items_done(download_details)
-            end
-          end
-
-          def details(step_type)
-            task_progress_details&.find do |step|
-              step[:step_type] == step_type
-            end
-          end
-
-          def task_progress
-            sync_task['progress_report']
-          end
-
-          def task_progress_details
-            task_progress && task_progress['docker_importer']
-          end
-
-          def total
-            task_progress_details
-          end
-
-          def items_done(content_details)
-            content_details[:num_processed]
-          end
-
-          def items_total(content_details)
-            content_details && content_details[:items_total].to_i
-          end
-
-          def content_started?(content_details)
-            content_details && content_details[:state] != 'NOT_STARTED'
-          end
-
-          def content_completed?(content_details)
-            content_details && content_details[:state] == 'FINISHED'
-          end
-
-          def pending?(_content_details)
-            task_progress.nil? || task_progress['state'] == 'NOT_RUNNING'
-          end
-
-          def metadata_in_progress?
-            sync_task && sync_task[:state] == 'started'
-          end
-
-          def metadata_error
-            sync_task && sync_task[:state] == 'error' && sync_task[:error][:description]
-          end
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/repository/presenters/file_unit_presenter.rb

@@ -1,42 +0,0 @@
-module Actions
-  module Pulp
-    module Repository
-      module Presenters
-        class FileUnitPresenter < AbstractSyncPresenter
-          def progress
-            total_bytes == 0 ? 0.01 : finished_bytes.to_f / total_bytes
-          end
-
-          private
-
-          def humanized_details
-            ret = []
-            ret << _("Cancelled.") if cancelled?
-            ret << _("New Files: %s") % num_isos
-            ret.join("\n")
-          end
-
-          def num_isos
-            task_progress_details && task_progress_details['num_isos'] || 0
-          end
-
-          def total_bytes
-            task_progress_details && task_progress_details['total_bytes'] || 0
-          end
-
-          def finished_bytes
-            task_progress_details && task_progress_details['finished_bytes'] || 0
-          end
-
-          def task_progress_details
-            task_progress && task_progress['iso_importer']
-          end
-
-          def task_progress
-            sync_task['progress_report']
-          end
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/pulp/repository/presenters/yum_presenter.rb

@@ -1,131 +0,0 @@
-module Actions
-  module Pulp
-    module Repository
-      module Presenters
-        class YumPresenter < AbstractSyncPresenter
-          def progress
-            if sync_task && size_total > 0
-              size_done.to_f / size_total
-            else
-              0.01
-            end
-          end
-
-          private
-
-          def humanized_details
-            ret = []
-            ret << _("Cancelled.") if cancelled?
-
-            if pending?
-              ret << _("Pending")
-            elsif content_started?
-              if items_total > 0
-                ret << (_("New packages: %{count} (%{size}).") % {:count => count_summary, :size => size_summary})
-              else
-                #if there are no new packages, it could just mean that they have not started downloading yet
-                # so only tell the user no new packages if errata have been processed
-                if errata_details && errata_details['state'] != 'NOT_STARTED'
-                  ret << _("No new packages.")
-                else
-                  ret << _("Processing metadata.")
-                end
-              end
-            elsif metadata_in_progress?
-              ret << _("Processing metadata")
-            end
-
-            ret << _('Yum Metadata: %s') % metadata_error if metadata_error
-
-            if error_details.any?
-              ret << n_("Failed to download %s package.", "Failed to download %s packages.",
-                        error_details.count) % error_details.count
-            end
-            ret.join("\n")
-          end
-
-          def count_summary
-            if content_details[:state] == "IN_PROGRESS"
-              "#{items_done}/#{items_total}"
-            else
-              items_done
-            end
-          end
-
-          def size_summary
-            helper = Object.new.extend(ActionView::Helpers::NumberHelper)
-            if content_details[:state] == "IN_PROGRESS"
-              "#{helper.number_to_human_size(size_done)}/#{helper.number_to_human_size(size_total)}"
-            else
-              helper.number_to_human_size(size_total)
-            end
-          end
-
-          def task_progress
-            sync_task[:progress_report]
-          end
-
-          def task_progress_details
-            task_progress && task_progress[:yum_importer]
-          end
-
-          def task_details
-            task_result_details || task_progress_details
-          end
-
-          def content_details
-            task_details && task_details[:content]
-          end
-
-          def error_details
-            content_details.nil? ? [] : content_details[:error_details]
-          end
-
-          def metadata_details
-            task_details && task_details[:metadata]
-          end
-
-          def errata_details
-            task_details && task_details[:errata]
-          end
-
-          def items_done
-            items_total - content_details[:items_left]
-          end
-
-          def items_total
-            content_details[:items_total].to_i
-          end
-
-          def size_done
-            size_total - content_details[:size_left]
-          end
-
-          def size_total
-            (content_details && content_details[:size_total]).to_i
-          end
-
-          def cancelled?
-            task_details.nil? ? false : task_details.values.map { |item| item['state'] }.include?('CANCELLED')
-          end
-
-          def content_started?
-            content_details && content_details[:state] != 'NOT_STARTED'
-          end
-
-          def metadata_in_progress?
-            metadata_details && metadata_details[:state] == 'IN_PROGRESS'
-          end
-
-          def metadata_error
-            metadata_details && metadata_details[:error]
-          end
-
-          def pending?
-            metadata_details.nil? || metadata_details['state'] == 'NOT_RUNNING'
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-module Actions
-  module Pulp
-    module Repository
-      class Refresh < Pulp::AbstractAsyncTask
-        def plan(repository, options = {})
-          options[:capsule_id] ||= SmartProxy.default_capsule!.id
-          plan_self(:capsule_id => options[:capsule_id], :pulp_id => repository.pulp_id)
-        end
-
-        def invoke_external_task
-          repo = ::Katello::Repository.find_by(:pulp_id => input[:pulp_id])
-          if repo.nil?
-            repo = ::Katello::ContentViewPuppetEnvironment.find_by(:pulp_id => input[:pulp_id])
-            repo = repo.nonpersisted_repository
-          end
-          repo.backend_service(smart_proxy(input[:capsule_id])).refresh_if_needed
-        end
-      end
-    end
-  end
-end