katello 4.9.1 → 4.10.0.rc2

data/app/lib/actions/katello/bulk_agent_action.rb

@@ -1,34 +0,0 @@
-module Actions
-  module Katello
-    class BulkAgentAction < Actions::BulkAction
-      def plan(agent_action, hosts, args)
-        host_ids = hosts.map(&:id)
-
-        histories = ::Katello::Agent::Dispatcher.create_histories(
-          host_ids: host_ids
-        )
-
-        grouped_histories = {}
-        histories.each { |h| grouped_histories[h.host_id] = h.id }
-        options = {
-          dispatch_histories: grouped_histories,
-          type: agent_action.agent_message,
-          content: args[:content],
-          bulk: true
-        }
-        super(agent_action, hosts, options)
-      end
-
-      def spawn_plans
-        args = input[:args].first
-        histories = ::Katello::Agent::DispatchHistory.where(id: args[:dispatch_histories].slice(*current_batch.map(&:to_s)).values)
-        ::Katello::Agent::Dispatcher.dispatch(
-          args[:type].to_sym,
-          histories,
-          content: args[:content]
-        )
-        super
-      end
-    end
-  end
-end

data/app/lib/actions/katello/host/erratum/applicable_errata_install.rb

@@ -1,44 +0,0 @@
-module Actions
-  module Katello
-    module Host
-      module Erratum
-        class ApplicableErrataInstall < Actions::EntryAction
-          include Helpers::Presenter
-
-          #takes a list of errata and schedules the installation of those that are applicable
-          def plan(host, options = {})
-            fail _("errata_ids or update_all must be provided") if !options[:errata_ids] && !options[:update_all]
-            errata_ids = options.fetch(:errata_ids, nil)
-
-            applicable_errata = host.content_facet.applicable_errata
-            applicable_errata = applicable_errata.with_identifiers(errata_ids) unless options[:update_all]
-            if applicable_errata.empty?
-              plan_self(:hostname => host.name, :skip => true)
-            else
-              plan_action(Actions::Katello::Host::Erratum::Install, host, content: applicable_errata.pluck(:errata_id))
-              plan_self(:hostname => host.name, :skip => false)
-            end
-          end
-
-          def run
-            if input[:skip]
-              output[:response] = _("No applicable errata for %s, skipping" % input[:hostname])
-            end
-          end
-
-          def humanized_name
-            if input.try(:[], :hostname).nil?
-              _("Install Applicable Errata")
-            else
-              _("Install Applicable Errata on %s") % input[:hostname]
-            end
-          end
-
-          def presenter
-            Helpers::Presenter::Delegated.new(self, planned_actions(Katello::Host::Erratum::Install))
-          end
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/katello/host/erratum/install.rb

@@ -1,38 +0,0 @@
-module Actions
-  module Katello
-    module Host
-      module Erratum
-        class Install < Actions::Katello::AgentAction
-          def self.agent_message
-            :install_errata
-          end
-
-          def agent_action_type
-            :content_install
-          end
-
-          def humanized_name
-            if input.try(:[], :hostname)
-              _("Install erratum for %s") % input[:hostname]
-            else
-              _("Install erratum")
-            end
-          end
-
-          def humanized_input
-            [input[:content].join(", ")] + super
-          end
-
-          def resource_locks
-            :link
-          end
-
-          def finalize
-            host = ::Host.find_by(:id => input[:host_id])
-            host.update(audit_comment: (_("Installation of errata requested: %{errata}") % {errata: input[:content].join(", ")}).truncate(255))
-          end
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/katello/host/package/install.rb

@@ -1,34 +0,0 @@
-module Actions
-  module Katello
-    module Host
-      module Package
-        class Install < Actions::Katello::AgentAction
-          def self.agent_message
-            :install_package
-          end
-
-          def agent_action_type
-            :content_install
-          end
-
-          def humanized_name
-            if input.try(:[], :hostname)
-              _("Install package for %s") % input[:hostname]
-            else
-              _("Install package")
-            end
-          end
-
-          def humanized_input
-            [input[:content].join(", ")] + super
-          end
-
-          def finalize
-            host = ::Host.find_by(:id => input[:host_id])
-            host.update(audit_comment: (_("Installation of package(s) requested: %{packages}") % {packages: input[:content].join(", ")}).truncate(255))
-          end
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/katello/host/package/remove.rb

@@ -1,48 +0,0 @@
-module Actions
-  module Katello
-    module Host
-      module Package
-        class Remove < Actions::Katello::AgentAction
-          def self.agent_message
-            :remove_package
-          end
-
-          def agent_action_type
-            :content_uninstall
-          end
-
-          def humanized_name
-            if input.try(:[], :hostname)
-              _("Remove package for %s") % input[:hostname]
-            else
-              _("Remove package")
-            end
-          end
-
-          def humanized_input
-            [humanized_package_names.join(', ')] + super
-          end
-
-          def humanized_package_names
-            input[:content].inject([]) do |result, package|
-              if package.is_a?(Hash)
-                new_name = package.include?(:name) ? package[:name] : ""
-                new_name += '-' + package[:version] if package.include?(:version)
-                new_name += '.' + package[:release] if package.include?(:release)
-                new_name += '.' + package[:arch] if package.include?(:arch)
-                result << new_name
-              else
-                result << package
-              end
-            end
-          end
-
-          def finalize
-            host = ::Host.find_by(:id => input[:host_id])
-            host.update(audit_comment: (_("Removal of package(s) requested: %{packages}") % {packages: input[:content].join(", ")}).truncate(255))
-          end
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/katello/host/package/update.rb

@@ -1,42 +0,0 @@
-module Actions
-  module Katello
-    module Host
-      module Package
-        class Update < Actions::Katello::AgentAction
-          def self.agent_message
-            :update_package
-          end
-
-          def agent_action_type
-            :content_install
-          end
-
-          def humanized_name
-            if input.try(:[], :hostname)
-              _("Update package for %s") % input[:hostname]
-            else
-              _("Update package")
-            end
-          end
-
-          def humanized_input
-            [(input[:content].present? && input[:content].join(", ") || "all packages")] + super
-          end
-
-          def finalize
-            host = ::Host.find_by(:id => input[:host_id])
-            host.update(audit_comment: audit_comment)
-          end
-
-          def audit_comment
-            if input[:content].present?
-              (_("Update of package(s) requested: %{packages}") % {packages: input[:content].join(", ")}).truncate(255)
-            else
-              _("Update of all packages requested")
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/katello/host/package_group/install.rb

@@ -1,30 +0,0 @@
-module Actions
-  module Katello
-    module Host
-      module PackageGroup
-        class Install < Actions::Katello::AgentAction
-          def self.agent_message
-            :install_package_group
-          end
-
-          def agent_action_type
-            :content_install
-          end
-
-          def humanized_name
-            _("Install package group")
-          end
-
-          def humanized_input
-            [input[:content].join(", ")] + super
-          end
-
-          def finalize
-            host = ::Host.find_by(:id => input[:host_id])
-            host.update(audit_comment: (_("Installation of package group(s) requested: %{groups}") % {groups: input[:content].join(", ")}).truncate(255))
-          end
-        end
-      end
-    end
-  end
-end

data/app/lib/actions/katello/host/package_group/remove.rb

@@ -1,30 +0,0 @@
-module Actions
-  module Katello
-    module Host
-      module PackageGroup
-        class Remove < Actions::Katello::AgentAction
-          def self.agent_message
-            :remove_package_group
-          end
-
-          def agent_action_type
-            :content_uninstall
-          end
-
-          def humanized_name
-            _("Remove package group")
-          end
-
-          def humanized_input
-            [input[:content].join(', ')] + super
-          end
-
-          def finalize
-            host = ::Host.find_by(:id => input[:host_id])
-            host.update(audit_comment: (_("Removal of package group(s) requested: %{groups}") % {groups: input[:content].join(", ")}).truncate(255))
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-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, options
-            ],
-            classname: "Content",
-            cntr: [[], {}],
-            kws: {},
-            method: @method
-          },
-          routing: [
-            nil,
-            recipient_address
-          ],
-          version: "2.0"
-        }
-      end
-
-      def options # may be overridden by children
-        {
-          importkeys: true
-        }
-      end
-
-      def to_s
-        json.to_json
-      end
-    end
-  end
-end

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

@@ -1,69 +0,0 @@
-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
-          logger.error("Invalid client message: #{@json}")
-          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
-        return unless accepted? || result
-
-        task = ForemanTasks::Task.find_by_external_id(@dispatch_history.dynflow_execution_plan_id)
-
-        unless task
-          logger.info("Task external_id=#{@dispatch_history.dynflow_execution_plan_id} wasn't found. Skipping dynflow event dispatch")
-          return
-        end
-
-        unless task.result == 'pending'
-          logger.info("Task is no longer pending. Skipping dynflow event dispatch. task_result=#{task.result} 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

@@ -1,38 +0,0 @@
-module Katello
-  module Agent
-    class Connection
-      def initialize
-        @connection = ::Katello::Qpid::Connection.new(
-          url: settings[:broker_url],
-          ssl_cert_file: settings[:broker_ssl_cert_file],
-          ssl_key_file: settings[:broker_ssl_key_file],
-          ssl_ca_file: settings[:broker_ssl_ca_file]
-        )
-      end
-
-      def send_messages(messages)
-        @connection.send_messages(messages)
-      end
-
-      def fetch_agent_messages(handler = ClientMessageHandler)
-        @connection.receive_messages(address: settings[:event_queue_name], handler: handler)
-      end
-
-      def delete_client_queue(queue_name)
-        @connection.delete_queue(queue_name)
-      end
-
-      def settings
-        SETTINGS[:katello][:agent]
-      end
-
-      def open?
-        @connection.open?
-      end
-
-      def close
-        @connection.close
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-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

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

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

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

@@ -1,28 +0,0 @@
-module Katello
-  module Agent
-    class InstallPackageMessage < BaseMessage
-      def initialize(content:, consumer_id:)
-        @packages = content
-        @consumer_id = consumer_id
-        @content_type = 'rpm'
-        @method = 'install'
-      end
-
-      protected
-
-      def units
-        @packages.map do |package|
-          nvra = ::Katello::Util::Package.parse_nvrea_nvre(package)
-          unit_key = nvra || {
-            name: package
-          }
-
-          {
-            type_id: @content_type,
-            unit_key: unit_key
-          }
-        end
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-module Katello
-  module Agent
-    class RemovePackageGroupMessage < BaseMessage
-      def initialize(content:, consumer_id:)
-        @groups = content
-        @consumer_id = consumer_id
-        @content_type = 'package_group'
-        @method = 'uninstall'
-      end
-
-      protected
-
-      def units
-        @groups.map do |group|
-          {
-            type_id: @content_type,
-            unit_key: {
-              name: group
-            }
-          }
-        end
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-module Katello
-  module Agent
-    class RemovePackageMessage < BaseMessage
-      def initialize(content:, consumer_id:)
-        @packages = content
-        @consumer_id = consumer_id
-        @content_type = 'rpm'
-        @method = 'uninstall'
-      end
-
-      protected
-
-      def units
-        @packages.map do |package|
-          nvra = ::Katello::Util::Package.parse_nvrea_nvre(package)
-          unit_key = nvra || {
-            name: package
-          }
-
-          {
-            type_id: @content_type,
-            unit_key: unit_key
-          }
-        end
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-module Katello
-  module Agent
-    class UpdatePackageMessage < BaseMessage
-      def initialize(content:, consumer_id:)
-        @packages = content
-        @consumer_id = consumer_id
-        @content_type = 'rpm'
-        @method = 'update'
-      end
-
-      protected
-
-      def options
-        ops = super
-        ops[:all] = true if @packages.blank?
-        ops
-      end
-
-      def units
-        return [{ type_id: @content_type, unit_key: {}}] if @packages.blank?
-
-        @packages.map do |package|
-          {
-            type_id: @content_type,
-            unit_key: {
-              name: package
-            }
-          }
-        end
-      end
-    end
-  end
-end

data/app/lib/katello/event_daemon/services/agent_event_receiver.rb

@@ -1,59 +0,0 @@
-module Katello
-  module EventDaemon
-    module Services
-      class AgentEventReceiver
-        class Handler
-          attr_accessor :processed, :failed
-
-          def initialize
-            @processed = 0
-            @failed = 0
-          end
-
-          def handle(message)
-            ::Katello::Util::Support.with_db_connection do
-              ::Katello::Agent::ClientMessageHandler.new(message).handle
-              @processed += 1
-            rescue => e
-              @failed += 1
-              Rails.logger.error("Error handling Katello Agent client message")
-              Rails.logger.error(e.message)
-              Rails.logger.error(e.backtrace.join("\n"))
-            end
-          end
-        end
-
-        def self.logger
-          ::Foreman::Logging.logger('katello/agent')
-        end
-
-        def self.run
-          fail("Katello agent event receiver already started") if running?
-
-          @thread = Thread.new do
-            @handler = Handler.new
-            @agent_connection = ::Katello::Agent::Connection.new
-            @agent_connection.fetch_agent_messages(@handler)
-          end
-        end
-
-        def self.close
-          @agent_connection&.close
-          @thread&.join
-        end
-
-        def self.running?
-          @agent_connection&.open? && @thread&.status.present?
-        end
-
-        def self.status
-          {
-            running: running?,
-            processed_count: @handler&.processed || 0,
-            failed_count: @handler&.failed || 0
-          }
-        end
-      end
-    end
-  end
-end