katello 3.18.0.rc2.1 → 4.0.0.rc2

data/app/lib/actions/pulp3/content_view/delete_repository_references.rb

@@ -14,7 +14,7 @@ module Actions
           content_view.repository_references.each do |repository_reference|
             repo = repository_reference.root_repository.library_instance
             #force pulp3 in case we've done migrations, but haven't switched over yet
-            tasks << repo.backend_service(smart_proxy, true).delete(repository_reference.repository_href)
+            tasks << repo.backend_service(smart_proxy, true).delete_repository(repository_reference)
           end
           content_view.repository_references.destroy_all
 

data/app/lib/actions/pulp3/content_view_version/export.rb

@@ -15,8 +15,9 @@ module Actions
           from_cvv = ::Katello::ContentViewVersion.find(input[:from_content_view_version_id]) unless input[:from_content_view_version_id].blank?
           ::Katello::Pulp3::ContentViewVersion::Export.new(smart_proxy: smart_proxy,
                                                    content_view_version: cvv,
-                                                   from_content_view_version: from_cvv).create_export(input[:exporter_data][:pulp_href],
-                                                                                            chunk_size: input[:chunk_size])
+                                                   from_content_view_version: from_cvv)
+                                                   .create_export(input[:exporter_data][:pulp_href],
+                                                                        chunk_size: input[:chunk_size])
         end
       end
     end

data/app/lib/actions/pulp3/import_migration.rb

@@ -6,9 +6,14 @@ module Actions
       end
 
       def run
-        migration_service = ::Katello::Pulp3::Migration.new(SmartProxy.pulp_primary)
+        task_id = ForemanTasks::Task.find_by(external_id: self.execution_plan_id)&.id
+        migration_service = ::Katello::Pulp3::Migration.new(SmartProxy.pulp_primary, input.merge(task_id: task_id))
         migration_service.import_pulp3_content
       end
+
+      def humanized_output
+        output[:status]
+      end
     end
   end
 end

data/app/lib/actions/pulp3/orchestration/content_view_version/copy_version_units_to_library.rb

@@ -9,7 +9,8 @@ module Actions
                 sequence do
                   copy_action = plan_action(Actions::Pulp3::Repository::CopyContent, repo, SmartProxy.pulp_primary!,
                                                     repo.library_instance,
-                                                    copy_all: true)
+                                                    copy_all: true,
+                                                    mirror: content_view_version.content_view.library_import?)
                   plan_action(Actions::Pulp3::Repository::SaveVersion, repo.library_instance,
                                 tasks: copy_action.output[:pulp_tasks])
                   plan_action(Katello::Repository::IndexContent, id: repo.library_instance_id)

data/app/lib/actions/pulp3/orchestration/content_view_version/export.rb

@@ -18,7 +18,10 @@ module Actions
           end
 
           # rubocop:disable Metrics/MethodLength
-          def plan(content_view_version, destination_server:, chunk_size: nil, from_history: nil)
+          def plan(content_view_version:, destination_server: nil,
+                   chunk_size: nil, from_history: nil,
+                   validate_incremental: true,
+                   fail_on_missing_content: false)
             action_subject(content_view_version)
             unless File.directory?(Setting['pulpcore_export_destination'])
               fail ::Foreman::Exception, N_("Unable to export. 'pulpcore_export_destination' setting is not set to a valid directory.")
@@ -27,14 +30,13 @@ module Actions
             sequence do
               smart_proxy = SmartProxy.pulp_primary!
               from_content_view_version = from_history&.content_view_version
-              if from_content_view_version.present?
-                export_service = ::Katello::Pulp3::ContentViewVersion::Export.new(
-                                                       smart_proxy: smart_proxy,
-                                                       content_view_version: content_view_version,
-                                                       destination_server: destination_server,
-                                                       from_content_view_version: from_content_view_version)
-                export_service.validate_incremental_export!
-              end
+              export_service = ::Katello::Pulp3::ContentViewVersion::Export.new(
+                                                     smart_proxy: smart_proxy,
+                                                     content_view_version: content_view_version,
+                                                     destination_server: destination_server,
+                                                     from_content_view_version: from_content_view_version)
+              export_service.validate!(fail_on_missing_content: fail_on_missing_content,
+                                       validate_incremental: validate_incremental)
 
               action_output = plan_action(::Actions::Pulp3::ContentViewVersion::CreateExporter,
                                      content_view_version_id: content_view_version.id,
@@ -74,15 +76,17 @@ module Actions
                                                        content_view_version: cvv,
                                                        smart_proxy: smart_proxy,
                                                        from_content_view_version: from_cvv).generate_metadata
-            export_metadata[:incremental] = from_cvv.present?
-            toc = Dir.glob("#{path}/*toc.json").first
-            export_metadata[:toc] = File.basename(toc) if toc
-            ::Katello::ContentViewVersionExportHistory.create!(
+
+            toc_path_info = output[:exported_file_checksum].find { |item| item.first.end_with?("toc.json") }
+            export_metadata[:toc] = File.basename(toc_path_info.first)
+
+            history = ::Katello::ContentViewVersionExportHistory.create!(
               content_view_version_id: input[:content_view_version_id],
               destination_server: input[:destination_server],
               path: path,
               metadata: export_metadata
             )
+            output[:export_history_id] = history.id
           end
 
           def humanized_name

data/app/lib/actions/pulp3/orchestration/content_view_version/export_library.rb

@@ -0,0 +1,60 @@
+module Actions
+  module Pulp3
+    module Orchestration
+      module ContentViewVersion
+        class ExportLibrary < Actions::EntryAction
+          def plan(organization, destination_server: nil,
+                                 chunk_size: nil,
+                                 from_history: nil,
+                                 fail_on_missing_content: false)
+            action_subject(organization)
+            validate_repositories_immediate!(organization) if fail_on_missing_content
+
+            content_view = ::Katello::Pulp3::ContentViewVersion::Export.find_library_export_view(destination_server: destination_server,
+                                                                           organization: organization,
+                                                                           create_by_default: true)
+            repo_ids_in_library = organization.default_content_view_version.repositories.yum_type.immediate.pluck(:id)
+            content_view.update!(repository_ids: repo_ids_in_library)
+
+            sequence do
+              publish_action = plan_action(::Actions::Katello::ContentView::Publish, content_view, '')
+              export_action = plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::Export,
+                                          content_view_version: publish_action.version,
+                                          destination_server: destination_server,
+                                          chunk_size: chunk_size,
+                                          from_history: from_history,
+                                          validate_incremental: false,
+                                          fail_on_missing_content: fail_on_missing_content)
+              plan_self(export_action_output: export_action.output)
+            end
+          end
+
+          def run
+            output[:export_history_id] = input[:export_action_output][:export_history_id]
+          end
+
+          def humanized_name
+            _("Export Library")
+          end
+
+          def rescue_strategy
+            Dynflow::Action::Rescue::Skip
+          end
+
+          def validate_repositories_immediate!(organization)
+            non_immediate_repos = organization.default_content_view_version.repositories.yum_type.non_immediate
+            if non_immediate_repos.any?
+              fail _("NOTE: Unable to fully export '%{organization}' organization's library because"\
+                     " it contains repositories without the 'immediate' download policy."\
+                     " Update the download policy and sync affected repositories to include them in the export."\
+                     " \n %{repos}" %
+                     { organization: organization.name,
+                       repos: ::Katello::Pulp3::ContentViewVersion::Export
+                              .generate_product_repo_strings(repositories: non_immediate_repos)})
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/orchestration/content_view_version/import.rb

@@ -36,10 +36,6 @@ module Actions
           def humanized_name
             _("Import")
           end
-
-          def rescue_strategy
-            Dynflow::Action::Rescue::Skip
-          end
         end
       end
     end

data/app/lib/actions/pulp3/orchestration/repository/import_upload.rb

@@ -1,3 +1,4 @@
+# rubocop:disable Metrics/MethodLength
 module Actions
   module Pulp3
     module Orchestration
@@ -6,9 +7,19 @@ module Actions
           def plan(repository, smart_proxy, args)
             file = {:filename => args.dig(:unit_key, :name)}
             content_unit_href = args.dig(:unit_key, :content_unit_id)
+            docker_tag = (args.dig(:unit_type_id) == "docker_tag")
             sequence do
               if content_unit_href
                 plan_self(:commit_output => [], :content_unit_href => content_unit_href)
+                action_output = plan_action(Pulp3::Repository::ImportUpload, content_unit_href, repository, smart_proxy).output
+                plan_action(Pulp3::Repository::SaveVersion, repository, tasks: action_output[:pulp_tasks]).output
+              elsif docker_tag
+                tag_manifest_output = plan_action(Pulp3::Repository::UploadTag,
+                            repository,
+                            smart_proxy,
+                            args).output
+                plan_self(:commit_output => tag_manifest_output[:pulp_tasks])
+                plan_action(Pulp3::Repository::SaveVersion, repository, {force_fetch_version: true, tasks: tag_manifest_output[:pulp_tasks]})
               else
                 commit_output = plan_action(Pulp3::Repository::CommitUpload,
                                             repository,
@@ -24,9 +35,9 @@ module Actions
                                               args.dig(:unit_type_id)).output
                 content_unit_href = artifact_output[:pulp_tasks]
                 plan_self(:commit_output => commit_output[:pulp_tasks], :artifact_output => artifact_output[:pulp_tasks])
+                action_output = plan_action(Pulp3::Repository::ImportUpload, content_unit_href, repository, smart_proxy).output
+                plan_action(Pulp3::Repository::SaveVersion, repository, tasks: action_output[:pulp_tasks]).output
               end
-              action_output = plan_action(Pulp3::Repository::ImportUpload, content_unit_href, repository, smart_proxy).output
-              plan_action(Pulp3::Repository::SaveVersion, repository, tasks: action_output[:pulp_tasks]).output
             end
           end
 
@@ -34,8 +45,10 @@ module Actions
             output[:pulp_tasks] = input[:commit_output]
             if input[:content_unit_href]
               output[:content_unit_href] = input[:content_unit_href]
-            else
+            elsif input[:artifact_output]
               output[:content_unit_href] = input[:artifact_output].last[:created_resources].first
+            else
+              output[:content_unit_href] = nil
             end
           end
         end

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

@@ -4,12 +4,7 @@ module Actions
       module Repository
         class RefreshRepos < Pulp3::AbstractAsyncTask
           include ::Actions::Katello::CapsuleContent::RefreshRepos
-          input_format do
-            param :smart_proxy_id
-            param :environment_id
-            param :content_view_id
-            param :repository_id
-          end
+
           def fetch_proxy_service(smart_proxy)
             ::Katello::Pulp3::SmartProxyRepository.instance_for_type(smart_proxy)
           end

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

@@ -13,7 +13,7 @@ module Actions
           target = ::Katello::Repository.find(input[:target_repository_id] || input[:target_repository])
           service = target.backend_service(smart_proxy)
           output[:pulp_tasks] = if input[:copy_all]
-                                  service.copy_all(source)
+                                  service.copy_all(source, mirror: input[:mirror] || false)
                                 else
                                   service.copy_content_for_source(source, input)
                                 end

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

@@ -8,7 +8,7 @@ module Actions
 
         def invoke_external_task
           repo = ::Katello::Repository.find(input[:repository_id])
-          output[:response] = repo.backend_service(smart_proxy).delete
+          output[:response] = repo.backend_service(smart_proxy).delete_repository
         end
       end
     end

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

@@ -2,7 +2,7 @@ module Actions
   module Pulp3
     module Repository
       class SaveVersion < Pulp3::Abstract
-        def plan(repository, options)
+        def plan(repository, options = {})
           fail "Cannot accept tasks and repository_details into Save Version." if options[:tasks].present? && options[:repository_details].present?
           plan_self(:repository_id => repository.id, :tasks => options[:tasks], :repository_details => options[:repository_details], :force_fetch_version => options.fetch(:force_fetch_version, false))
         end

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

@@ -0,0 +1,18 @@
+module Actions
+  module Pulp3
+    module Repository
+      class UploadTag < Pulp3::AbstractAsyncTask
+        def plan(repository, smart_proxy, args)
+          plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id, :args => args)
+        end
+
+        def invoke_external_task
+          repo = ::Katello::Repository.find(input[:repository_id])
+          tag_name = input[:args].dig(:unit_key, :name)
+          manifest_digest = input[:args].dig(:unit_key, :digest)
+          output[:pulp_tasks] = [repo.backend_service(smart_proxy).tag_manifest(tag_name, manifest_digest)]
+        end
+      end
+    end
+  end
+end

data/app/lib/katello/agent/base_message.rb

@@ -0,0 +1,38 @@
+module Katello
+  module Agent
+    class BaseMessage
+      attr_accessor :dispatch_history_id, :recipient_address, :reply_to
+
+      def json
+        {
+          data: {
+            consumer_id: @consumer_id,
+            dispatch_history_id: dispatch_history_id
+          },
+          replyto: reply_to,
+          request: {
+            args: [
+              units,
+              {
+                importkeys: true
+              }
+            ],
+            classname: "Content",
+            cntr: [[], {}],
+            kws: {},
+            method: @method
+          },
+          routing: [
+            nil,
+            recipient_address
+          ],
+          version: "2.0"
+        }
+      end
+
+      def to_s
+        json.to_json
+      end
+    end
+  end
+end

data/app/lib/katello/agent/client_message_handler.rb

@@ -0,0 +1,60 @@
+module Katello
+  module Agent
+    class ClientMessageHandler
+      def initialize(message)
+        logger.debug("client message: #{message.body}")
+        @json = parse_message_json(message)
+        dispatch_history_id = @json&.dig(:data, :dispatch_history_id)
+        @dispatch_history = Katello::Agent::DispatchHistory.find_by_id(dispatch_history_id)
+
+        unless @dispatch_history
+          fail("No valid dispatch history in client message")
+        end
+      end
+
+      def accepted?
+        @json[:status] == 'accepted'
+      end
+
+      def result
+        @json.dig(:result, :retval, :details)
+      end
+
+      def handle
+        @dispatch_history.accepted_at = DateTime.now if accepted?
+        @dispatch_history.result = result if result
+        @dispatch_history.save!
+
+        if @dispatch_history.dynflow_execution_plan_id && @dispatch_history.dynflow_step_id
+          handle_dynflow_event
+        end
+      end
+
+      private
+
+      def handle_dynflow_event
+        task_exists = ForemanTasks::Task.exists?(external_id: @dispatch_history.dynflow_execution_plan_id, result: 'pending')
+        unless task_exists
+          logger.warn("Couldn't find pending task with external_id=#{@dispatch_history.dynflow_execution_plan_id} dispatch_history_id=#{@dispatch_history.id}")
+          return
+        end
+
+        if accepted?
+          ForemanTasks.dynflow.world.event(@dispatch_history.dynflow_execution_plan_id, @dispatch_history.dynflow_step_id, 'accepted')
+        elsif result
+          ForemanTasks.dynflow.world.event(@dispatch_history.dynflow_execution_plan_id, @dispatch_history.dynflow_step_id, 'finished')
+        end
+      end
+
+      def parse_message_json(message)
+        JSON.parse(message.body).with_indifferent_access
+      rescue
+        nil
+      end
+
+      def logger
+        ::Foreman::Logging.logger('katello/agent')
+      end
+    end
+  end
+end

data/app/lib/katello/agent/connection.rb

@@ -0,0 +1,24 @@
+module Katello
+  module Agent
+    class Connection
+      def send_messages(messages)
+        connection = ::Katello::Qpid::Connection.new(settings[:broker_url])
+        connection.send_messages(messages)
+      end
+
+      def fetch_agent_messages(handler = ClientMessageHandler)
+        connection = ::Katello::Qpid::Connection.new(settings[:broker_url])
+        connection.receive_messages(address: settings[:event_queue_name], handler: handler)
+      end
+
+      def delete_client_queue(queue_name)
+        connection = ::Katello::Qpid::Connection.new(settings[:broker_url])
+        connection.delete_queue(queue_name)
+      end
+
+      def settings
+        SETTINGS[:katello][:agent]
+      end
+    end
+  end
+end

data/app/lib/katello/agent/install_errata_message.rb

@@ -0,0 +1,25 @@
+module Katello
+  module Agent
+    class InstallErrataMessage < BaseMessage
+      def initialize(content:, consumer_id:)
+        @errata_ids = content
+        @consumer_id = consumer_id
+        @content_type = 'erratum'
+        @method = 'install'
+      end
+
+      protected
+
+      def units
+        @errata_ids.map do |id|
+          {
+            type_id: @content_type,
+            unit_key: {
+              id: id
+            }
+          }
+        end
+      end
+    end
+  end
+end