katello 4.9.1 → 4.10.0.rc2

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

@@ -1,149 +0,0 @@
-require 'qpid_proton'
-
-module Katello
-  module Qpid
-    class Connection
-      class Sender < ::Qpid::Proton::MessagingHandler
-        def initialize(url, connection_options, address, messages)
-          super()
-          @url = url
-          @connection_options = connection_options
-          @address = address
-          @messages = messages
-          @sent = 0
-          @confirmed = 0
-        end
-
-        def on_container_start(container)
-          c = container.connect(@url, @connection_options)
-          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, connection_options, address, handler)
-          super()
-          @url = url
-          @connection_options = connection_options.merge(
-            idle_timeout: 30
-          )
-          @address = address
-          @handler = handler
-        end
-
-        def on_container_start(container)
-          c = container.connect(@url, @connection_options)
-          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:, ssl_cert_file:, ssl_key_file:, ssl_ca_file:)
-        @url = url
-        ssl_domain = ::Qpid::Proton::SSLDomain.new(::Qpid::Proton::SSLDomain::MODE_CLIENT)
-        ssl_domain.peer_authentication(::Qpid::Proton::SSLDomain::VERIFY_PEER_NAME)
-        ssl_domain.credentials(ssl_cert_file, ssl_key_file, nil) if ssl_cert_file && ssl_key_file
-        ssl_domain.trusted_ca_db(ssl_ca_file) if ssl_ca_file
-        @connection_options = {
-          ssl_domain: ssl_domain,
-          sasl_allowed_mechs: 'external',
-          virtual_host: URI.parse(url).host
-        }
-      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, @connection_options, 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, @connection_options, nil, qpid_messages)
-        with_connection(sender)
-      end
-
-      def receive_messages(address:, handler:)
-        receiver = Receiver.new(@url, @connection_options, address, handler)
-        with_connection(receiver)
-      end
-
-      def close
-        @container&.stop
-      end
-
-      def open?
-        (@container&.running || 0) > 0
-      end
-
-      private
-
-      def with_connection(handler)
-        @container = ::Qpid::Proton::Container.new(handler)
-        @container.run
-      ensure
-        close
-      end
-    end
-  end
-end

data/app/lib/katello/util/default_enablement_migrator.rb

@@ -1,183 +0,0 @@
-module Katello
-  module Util
-    class DefaultEnablementMigrator # used in lib/katello/tasks/upgrades/4.9/update_custom_products_enablement.rake
-      include ActionView::Helpers::TextHelper
-
-      def execute!
-        ds_errors = create_disabled_overrides_for_non_sca_org_hosts
-        dsak_errors = create_disabled_overrides_for_non_sca_org_activation_keys
-        ak_errors = create_activation_key_overrides
-        consumer_errors = create_consumer_overrides
-        cp_errors = update_enablement_in_candlepin
-        kt_errors = update_enablement_in_katello
-
-        total_errors = ds_errors + dsak_errors + ak_errors + consumer_errors + cp_errors + kt_errors
-        finish_message = "Finished updating custom products enablement; #{total_errors == 0 ? "no errors" : "#{pluralize(total_errors, "error")}"}"
-        Rails.logger.info finish_message
-        Rails.logger.info("#{pluralize(ds_errors, "error")} updating disabled overrides for unsubscribed content; see log messages above") if ds_errors > 0
-        Rails.logger.info("#{pluralize(dsak_errors, "error")} updating disabled overrides for unsubscribed content in activation keys; see log messages above") if dsak_errors > 0
-        Rails.logger.info("#{pluralize(ak_errors, "error")} updating activation key overrides; see log messages above") if ak_errors > 0
-        Rails.logger.info("#{pluralize(consumer_errors, "error")} updating consumer overrides; see log messages above") if consumer_errors > 0
-        Rails.logger.info("#{pluralize(cp_errors, "error")} updating default enablement in Candlepin; see log messages above") if cp_errors > 0
-        Rails.logger.info("#{pluralize(kt_errors, "error")} updating default enablement in Katello; see log messages above") if kt_errors > 0
-      end
-
-      def create_disabled_overrides_for_non_sca(consumable:)
-        content_finder = ::Katello::ProductContentFinder.new(
-                match_subscription: false,
-                match_environment: false,
-                consumable: consumable
-              )
-        subscribed_content_finder = ::Katello::ProductContentFinder.new(
-          match_subscription: true,
-          match_environment: false,
-          consumable: consumable
-        )
-        unsubscribed_content = content_finder.custom_content_labels - subscribed_content_finder.custom_content_labels
-        new_overrides = unsubscribed_content.map do |repo_label|
-          ::Katello::ContentOverride.new(
-            repo_label,
-            { name: "enabled", value: "0" } # Override to disabled
-          )
-        end
-        return if new_overrides.blank?
-        if consumable.is_a? ::Katello::Host::SubscriptionFacet
-          ::Katello::Resources::Candlepin::Consumer.update_content_overrides(
-            consumable.uuid,
-            new_overrides.map(&:to_entitlement_hash)
-          )
-        else
-          ::Katello::Resources::Candlepin::ActivationKey.update_content_overrides(
-            consumable.cp_id,
-            new_overrides.map(&:to_entitlement_hash)
-          )
-        end
-      end
-
-      def create_disabled_overrides_for_non_sca_org_hosts
-        errors = 0
-        Organization.all.each do |org|
-          next if org.simple_content_access? # subscription attachment is meaningless with SCA
-          Rails.logger.info("Creating disabled overrides for unsubscribed content in org #{org.name}")
-          hosts_to_update = org.hosts.joins(:subscription_facet).where.not("#{Katello::Host::SubscriptionFacet.table_name}.host_id" => nil)
-          hosts_to_update.each do |host|
-            create_disabled_overrides_for_non_sca(consumable: host.subscription_facet)
-          rescue => e
-            errors += 1
-            Rails.logger.info("Failed to update host #{host.name}: #{e.message}")
-          end
-        rescue => e
-          errors += 1
-          Rails.logger.info("Error while creating host overrides: #{e.message}")
-        end
-        errors
-      end
-
-      def create_disabled_overrides_for_non_sca_org_activation_keys
-        errors = 0
-        Organization.all.each do |org|
-          next if org.simple_content_access? # subscription attachment is meaningless with SCA
-          Rails.logger.info("Creating disabled overrides for unsubscribed content in activation keys in org #{org.name}")
-          aks_to_update = org.activation_keys
-          aks_to_update.each do |ak|
-            create_disabled_overrides_for_non_sca(consumable: ak)
-          rescue => e
-            errors += 1
-            Rails.logger.info("Failed to update activation key #{activation key.name}: #{e.message}")
-          end
-        rescue => e
-          errors += 1
-          Rails.logger.info("Error while creating non-SCA activation key overrides: #{e.message}")
-        end
-        errors
-      end
-
-      def create_overrides(consumable_id:, candlepin_resource:, all_repos:)
-        repos_with_existing_overrides = candlepin_resource.content_overrides(consumable_id).map do |override|
-          override[:contentLabel]
-        end
-        new_overrides = (all_repos - repos_with_existing_overrides).map do |repo_label|
-          ::Katello::ContentOverride.new(
-            repo_label,
-            { name: "enabled", value: "1" } # Override to enabled
-          )
-        end
-        return if new_overrides.blank?
-
-        candlepin_resource.update_content_overrides(
-          consumable_id,
-          new_overrides.map(&:to_entitlement_hash)
-        )
-      end
-
-      def create_activation_key_overrides
-        Rails.logger.info "Creating content overrides for all activation keys"
-        ak_errors = 0
-        cp_aks_to_update = ::Katello::Resources::Candlepin::ActivationKey.get.map { |ak| ak['id'] }
-        Organization.all.each do |org|
-          all_repos = ::Katello::RootRepository.custom.in_organization(org).map(&:custom_content_label) # update all custom repos
-
-          org_aks_to_update = ::Katello::ActivationKey.where(organization: org, cp_id: cp_aks_to_update)
-          org_aks_to_update.each do |ak|
-            Rails.logger.info "Updating activation key #{ak.name}"
-            create_overrides(consumable_id: ak.cp_id, candlepin_resource: ::Katello::Resources::Candlepin::ActivationKey, all_repos: all_repos)
-          rescue => e
-            ak_errors += 1
-            Rails.logger.info("Failed to update activation key #{ak.name}: #{e.message}")
-          end
-        rescue => e
-          ak_errors += 1
-          Rails.logger.info("Error while creating activation key overrides: #{e.message}")
-        end
-        ak_errors
-      end
-
-      def create_consumer_overrides
-        consumer_errors = 0
-        Rails.logger.info "Creating content overrides for all Candlepin consumers"
-        consumers_to_update = ::Katello::Resources::Candlepin::Consumer.all_uuids
-        # ["Default_Organization_Custom_Custom_Repo", "Default_Organization_TestProd2_TestRepo2"]
-        all_repos = ::Katello::RootRepository.custom.map(&:custom_content_label) # update all custom repos
-
-        consumers_to_update.each do |consumer_uuid|
-          Rails.logger.info "Updating consumer #{consumer_uuid}"
-          create_overrides(consumable_id: consumer_uuid, candlepin_resource: ::Katello::Resources::Candlepin::Consumer, all_repos: all_repos)
-        rescue => e
-          consumer_errors += 1
-          Rails.logger.info("Failed to update consumer #{consumer_uuid}: #{e.message}")
-        end
-        Rails.logger.info("Updated #{pluralize(consumers_to_update.count, 'consumer')} and #{pluralize(all_repos.count, 'repo')}")
-        consumer_errors
-      end
-
-      def update_enablement_in_candlepin
-        cp_errors = 0
-        Rails.logger.info "Updating custom products enablement in Candlepin"
-        ::Katello::ProductContent.custom.each do |product_content|
-          ::Katello::Resources::Candlepin::Product.add_content(
-            product_content.product.organization.label,
-            product_content.product.cp_id,
-            product_content.content.cp_content_id,
-            ::Actions::Candlepin::Product::ContentAdd::DEFAULT_ENABLEMENT
-          )
-        rescue => e
-          cp_errors += 1
-          Rails.logger.info("Failed to update ProductContent #{product_content.id}: #{e.message}")
-        end
-        cp_errors
-      end
-
-      def update_enablement_in_katello
-        kt_errors = 0
-        Rails.logger.info "Updating custom products enablement in Katello"
-        ::Katello::ProductContent.custom.each do |product_content|
-          product_content.set_enabled_from_candlepin!
-        rescue => e
-          kt_errors += 1
-          Rails.logger.info("Failed to update ProductContent #{product_content.id}: #{e.message}")
-        end
-        kt_errors
-      end
-    end
-  end
-end

data/app/models/katello/agent/dispatch_history.rb

@@ -1,19 +0,0 @@
-module Katello
-  module Agent
-    class DispatchHistory < Katello::Model
-      self.table_name = 'katello_agent_dispatch_histories'
-
-      belongs_to :host, :class_name => "::Host::Managed"
-
-      serialize :result, Hash
-
-      def accepted?
-        accepted_at.present?
-      end
-
-      def finished?
-        result.present?
-      end
-    end
-  end
-end

data/app/models/katello/events/delete_host_agent_queue.rb

@@ -1,19 +0,0 @@
-module Katello
-  module Events
-    class DeleteHostAgentQueue
-      EVENT_TYPE = 'delete_host_agent_queue'.freeze
-
-      attr_accessor :metadata
-
-      def initialize(_host_id)
-        yield(self) if block_given?
-      end
-
-      def run
-        if metadata[:queue_name]
-          Katello::Agent::Dispatcher.delete_client_queue(queue_name: metadata[:queue_name])
-        end
-      end
-    end
-  end
-end

data/app/services/katello/agent/dispatcher.rb

@@ -1,60 +0,0 @@
-module Katello
-  module Agent
-    class Dispatcher
-      @supported_messages = {}
-
-      def self.register_message(name, klass)
-        @supported_messages[name] = klass
-      end
-
-      register_message(:install_package, Katello::Agent::InstallPackageMessage)
-      register_message(:remove_package, Katello::Agent::RemovePackageMessage)
-      register_message(:update_package, Katello::Agent::UpdatePackageMessage)
-      register_message(:install_errata, Katello::Agent::InstallErrataMessage)
-      register_message(:install_package_group, Katello::Agent::InstallPackageGroupMessage)
-      register_message(:remove_package_group, Katello::Agent::RemovePackageGroupMessage)
-
-      def self.dispatch(message_type, histories, args)
-        message_class = @supported_messages[message_type]
-        fail("Unsupported message type: #{message_type}") unless message_class
-
-        messages = histories.map do |history|
-          message = message_class.new(**args.merge(consumer_id: history.host.subscription_facet.uuid))
-          message.dispatch_history_id = history.id
-          message.recipient_address = settings[:client_queue_format] % history.host.subscription_facet.uuid
-          message.reply_to = settings[:event_queue_name]
-          message
-        end
-
-        connection = Connection.new
-        connection.send_messages(messages)
-
-        histories
-      end
-
-      def self.create_histories(host_ids:)
-        histories = host_ids.map do |id|
-          Katello::Agent::DispatchHistory.new(host_id: id)
-        end
-
-        Katello::Agent::DispatchHistory.import(histories)
-
-        histories
-      end
-
-      def self.delete_client_queue(queue_name:)
-        connection = Connection.new
-        connection.delete_client_queue(queue_name)
-      end
-
-      def self.host_queue_name(host)
-        uuid = host.content_facet.uuid
-        settings[:client_queue_format] % uuid
-      end
-
-      def self.settings
-        SETTINGS[:katello][:agent]
-      end
-    end
-  end
-end

data/app/views/foreman/job_templates/change_content_source.erb

@@ -1,18 +0,0 @@
-<%#
-kind: job_template
-name: Change content source
-job_category: Katello
-model: JobTemplate
-provider_type: script
-description_format: Configure subscription manager to new content source
-feature: katello_change_content_source
-%>
-#!/bin/sh
-
-<%= change_content_source(@host, foreman_server_ca_cert) %>
-
-if [ -f /etc/yggdrasil/config.toml ]; then
-  cp /etc/yggdrasil/config.toml /etc/yggdrasil/config.toml.bak
-  export YGGDRASIL_RESTART_DELAY=10
-  <%= snippet 'remote_execution_pull_setup' %>
-fi

data/app/views/katello/api/v2/sync/index.json.rabl

@@ -1 +0,0 @@
-extends 'katello/api/v2/common/async'

data/engines/bastion_katello/app/assets/javascripts/bastion_katello/common/views/katello-agent-notice.html

@@ -1,8 +0,0 @@
-<section>
-  <p bst-alert="warning" >
-    <span translate>
-      Katello-agent is deprecated and will be removed in a future release.
-    </span>
-  </p>
-</section>
-

data/lib/katello/tasks/upgrades/4.9/update_custom_products_enablement.rake

@@ -1,13 +0,0 @@
-namespace :katello do
-  namespace :upgrades do
-    namespace '4.9' do
-      desc "Update custom products enablement"
-      task :update_custom_products_enablement => ['environment'] do
-        if ::Katello::ProductContent.custom.where(enabled: true).exists?
-          migrator = Katello::Util::DefaultEnablementMigrator.new
-          migrator.execute!
-        end
-      end
-    end
-  end
-end