katello 3.18.0.rc2.1 → 4.0.0.rc2

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

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

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

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

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

@@ -0,0 +1,25 @@
+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 units
+        @packages.map do |package|
+          {
+            type_id: @content_type,
+            unit_key: {
+              name: package
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/app/lib/katello/concerns/base_template_scope_extensions.rb

@@ -19,6 +19,11 @@ module Katello
         host.subscriptions.redhat.pluck(:name)
       end
 
+      def host_redhat_subscriptions_consumed(host)
+        presenter = ::Katello::HostSubscriptionsPresenter.new(host)
+        presenter.subscriptions.select(&:redhat?).sum(&:quantity_consumed)
+      end
+
       def host_content_facet(host)
         host.content_facet
       end
@@ -87,6 +92,9 @@ module Katello
       end
 
       # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
       def load_errata_applications(filter_errata_type: nil, include_last_reboot: 'yes', since: nil, up_to: nil, status: nil, host_filter: nil)
         result = []
 

data/app/lib/katello/event_daemon/monitor.rb

@@ -0,0 +1,53 @@
+module Katello
+  module EventDaemon
+    class Monitor
+      def initialize(services)
+        @services = services
+        @service_statuses = {}
+        @services.keys.each do |service_name|
+          @service_statuses[service_name] = { running: 'starting' }
+        end
+      end
+
+      def start
+        write_statuses_to_cache
+        loop do
+          Rails.application.executor.wrap do
+            check_services
+          end
+          sleep 15
+        end
+      end
+
+      def write_statuses_to_cache
+        Rails.cache.write(
+          Katello::EventDaemon::Runner::STATUS_CACHE_KEY,
+          @service_statuses
+        )
+      end
+
+      def check_services
+        @services.each do |service_name, service_class|
+          @service_statuses[service_name] = service_class.status
+        rescue => error
+          Rails.logger.error("Error occurred while pinging #{service_class}")
+          Rails.logger.error(error.message)
+          Rails.logger.error(error.backtrace.join("\n"))
+        ensure
+          if error || !@service_statuses.dig(service_name, :running)
+            begin
+              service_class.close
+              service_class.run
+              @service_statuses[service_name] = service_class.status
+            rescue => error
+              Rails.logger.error("Error occurred while starting #{service_class}")
+              Rails.logger.error(error.message)
+              Rails.logger.error(error.backtrace.join("\n"))
+            end
+          end
+        end
+        write_statuses_to_cache
+      end
+    end
+  end
+end

data/app/lib/katello/event_daemon/runner.rb

@@ -0,0 +1,99 @@
+module Katello
+  module EventDaemon
+    class Runner
+      STATUS_CACHE_KEY = "katello_event_daemon_status".freeze
+      @services = {}
+      @cache = ActiveSupport::Cache::MemoryStore.new
+
+      class << self
+        def initialize
+          FileUtils.touch(lock_file)
+        end
+
+        def settings
+          SETTINGS[:katello][:event_daemon]
+        end
+
+        def pid
+          return unless pid_file && File.exist?(pid_file)
+
+          File.open(pid_file) { |f| f.read.to_i }
+        end
+
+        def pid_file
+          pid_dir.join('katello_event_daemon.pid')
+        end
+
+        def pid_dir
+          Rails.root.join('tmp', 'pids')
+        end
+
+        def lock_file
+          Rails.root.join('tmp', 'katello_event_daemon.lock')
+        end
+
+        def write_pid_file
+          return unless pid_file
+
+          FileUtils.mkdir_p(pid_dir)
+          File.open(pid_file, 'w') { |f| f.puts Process.pid }
+        end
+
+        def stop
+          return unless pid == Process.pid
+          @monitor_thread.kill
+          @cache.clear
+          @services.values.each(&:close)
+          File.unlink(pid_file) if pid_file && File.exist?(pid_file)
+        end
+
+        def start
+          return unless runnable?
+          lockfile = File.open(lock_file, 'r')
+          begin
+            lockfile.flock(File::LOCK_EX)
+            return if started? # ensure it wasn't started while we waited for the lock
+            start_monitor_thread
+            write_pid_file
+
+            at_exit do
+              stop
+            end
+
+            Rails.logger.info("Katello event daemon started process=#{Process.pid}")
+          ensure
+            lockfile.flock(File::LOCK_UN)
+          end
+        end
+
+        def started?
+          Process.kill(0, pid)
+          true
+        rescue Errno::ESRCH, TypeError # process no longer exists or we had no PID cached
+          false
+        end
+
+        def start_monitor_thread
+          @monitor_thread = Thread.new do
+            Katello::EventDaemon::Monitor.new(@services).start
+          end
+        end
+
+        def runnable?
+          # avoid accessing the disk on each request
+          @cache.fetch('katello_event_daemon_runnable', expires_in: 1.minute) do
+            !started? && settings[:enabled] && !::Foreman.in_rake? && !Rails.env.test?
+          end
+        end
+
+        def register_service(name, klass)
+          @services[name] = klass
+        end
+
+        def service_status(service_name = nil)
+          Rails.cache.read(STATUS_CACHE_KEY)&.dig(service_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module Katello
+  module EventDaemon
+    module Services
+      class AgentEventReceiver
+        STATUS_CACHE_KEY = 'katello_agent_events'.freeze
+
+        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
+          @thread&.kill
+        end
+
+        def self.running?
+          @thread&.status.present?
+        end
+
+        def self.status(refresh: true)
+          Rails.cache.fetch(STATUS_CACHE_KEY, force: refresh) do
+            {
+              running: running?,
+              processed_count: @handler&.processed || 0,
+              failed_count: @handler&.failed || 0
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/katello/logging.rb

@@ -10,5 +10,37 @@ module Katello
 
       logger.send(level, "#{message} #{data_string}")
     end
+
+    class Timer
+      def initialize(key = "default")
+        @key = key
+        @start_time = Time.now
+        Thread.current[:timers] ||= {}
+        Thread.current[:timers][key] = self
+      end
+
+      def start
+        Rails.logger.info "Timer #{@key} already started; resetting start time" if @start_time
+        Rails.logger.info "Timer #{@key} starting at #{Time.now}"
+        @start_time = Time.now
+        self
+      end
+
+      def stop
+        fail ::StandardError, "Timer #{@key} is not started" unless @start_time
+        duration = (Time.now - @start_time).truncate(2)
+        @start_time = nil
+        Rails.logger.info "Timer #{@key} stopping at #{Time.now}: #{duration} sec"
+      end
+
+      def self.find_by_key(key)
+        if Thread.current&.[](:timers)&.[](key)
+          Thread.current[:timers][key]
+        else
+          Rails.logger.warn "Timer #{key} not found on current thread; creating a new timer"
+          self.new(key)
+        end
+      end
+    end
   end
 end

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

@@ -2,13 +2,7 @@ module Katello
   module Messaging
     class Connection
       def self.create(connection_class:, settings:)
-        connection = connection_class.new(settings: settings)
-
-        at_exit do
-          connection.close
-        end
-
-        connection
+        connection_class.new(settings: settings)
       end
     end
   end

data/app/lib/katello/messaging/received_message.rb

@@ -3,7 +3,7 @@ module Katello
     class ReceivedMessage
       attr_reader :headers, :body
 
-      def initialize(body:, headers:)
+      def initialize(body:, headers: {})
         @body = body
         @headers = headers
       end

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

@@ -0,0 +1,130 @@
+require 'qpid_proton'
+
+module Katello
+  module Qpid
+    class Connection
+      class Sender < ::Qpid::Proton::MessagingHandler
+        def initialize(url, address, messages)
+          super()
+          @url = url
+          @address = address
+          @messages = messages
+          @sent = 0
+          @confirmed = 0
+        end
+
+        def on_container_start(container)
+          c = container.connect(@url)
+          c.open_sender
+          @receiver = c.open_receiver(@address) if @address
+        end
+
+        def on_sendable(sender)
+          @messages.each do |msg|
+            msg.reply_to = @receiver.remote_source.address if @receiver
+            sender.send(msg)
+            @sent += 1
+          end
+        ensure
+          sender.close
+        end
+
+        def on_tracker_accept(tracker)
+          @confirmed += 1
+          if @confirmed == @sent
+            tracker.connection.close
+          end
+        end
+
+        def on_message(_delivery, message)
+          opcode = message.properties['qmf.opcode']
+          if opcode == '_exception'
+            error_code = message.body.dig('_values', 'error_code')
+            if error_code != '7' # not found
+              error_message = message.body.dig('_values', 'error_text')
+              fail(error_message)
+            end
+          end
+        end
+      end
+
+      class Receiver < ::Qpid::Proton::MessagingHandler
+        def initialize(url, address, handler)
+          super()
+          @url = url
+          @address = address
+          @handler = handler
+        end
+
+        def on_container_start(container)
+          c = container.connect(@url,
+            idle_timeout: 4
+          )
+          c.open_receiver(@address)
+        end
+
+        def on_message(_delivery, message)
+          received = Katello::Messaging::ReceivedMessage.new(body: message.body)
+          @handler.handle(received)
+        end
+      end
+
+      def initialize(url)
+        @url = url
+      end
+
+      def delete_queue(queue_name)
+        address = "qmf.default.direct"
+        message = ::Qpid::Proton::Message.new
+        message.subject = 'broker'
+        message.address = address
+        message.body = {
+          '_object_id' => {
+            '_object_name' => 'org.apache.qpid.broker:broker:amqp-broker'
+          },
+          '_method_name' => 'delete',
+          '_arguments' => {
+            'strict' => true,
+            'name' => queue_name,
+            'type' => 'queue',
+            'properties' => {}
+          }
+        }
+
+        message.properties = {
+          'qmf.opcode' => '_method_request',
+          'x-amqp-0-10.app-id' => 'qmf2',
+          'method' => 'request'
+        }
+
+        sender = Sender.new(@url, address, [message])
+        with_connection(sender)
+      end
+
+      def send_messages(messages)
+        qpid_messages = messages.map do |message|
+          msg = ::Qpid::Proton::Message.new
+          msg.body = message.to_s
+          msg.address = message.recipient_address
+          msg
+        end
+        sender = Sender.new(@url, nil, qpid_messages)
+        with_connection(sender)
+      end
+
+      def receive_messages(address:, handler:)
+        receiver = Receiver.new(@url, address, handler)
+        with_connection(receiver)
+      end
+
+      private
+
+      def with_connection(handler)
+        container = ::Qpid::Proton::Container.new(handler)
+        container.run
+      ensure
+        container&.stop
+      end
+    end
+  end
+end