foreman_scc_manager 1.8.19 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94924eef8de5143907ca81d9ea6c41915d51c931d394356497e7168b8ffbe09e
-  data.tar.gz: 49d822f0d3c70abd53a0d818c3dc7c2102c9e12e8c325a3580f9e966bf50dd61
+  metadata.gz: 73d2510abbdbe51fef59bba613502fb02ef1fe14eeb441f0bee716b17e2eba8d
+  data.tar.gz: c61b9f852d58033c290204508d0d4653e5379c6c8b73e6d5b58d026ea485b0f0
 SHA512:
-  metadata.gz: c26c8d840bd3a97a3cbc99e84dc53bc17c48a8175dd026cfd618d5597cbf934373ed048c978e5805db1942ef0b3b4ef9283ee60b8e36b26e5d3a886e48f20067
-  data.tar.gz: 6599cad1358b63afba7824ca2d8f7328d30c8f2d851814b681be2b7ec4de42116e9e3160680cd814f960cb49b65fd09edda863a7383e5fabd93925791bd6600e
+  metadata.gz: d3ce92fbe191d0aaa6f10d0015ed4a3e3320892d1f45a519a965cdbd63a93e49a0fe6918fcc1b7cfb4618b8a8fc016349bfbceba5825a93ca5400dce5dd18e03
+  data.tar.gz: a48593aa198df8fbc5b4c88a2654facb7dc1f77f80373d3cf7a03fa46e84bd5f02af338af0a0e1dd2968da7e7afa6e44548f992e51d1ece7a0a82fa05922f0d9

data/README.md

@@ -8,7 +8,13 @@ Foreman plugin to sync SUSE Customer Center products and repositories into Katel
 
 ## Installation
 
-This plugin installation is not supported by foreman-installer and has to be installed manually:
+This plugin installation is supported since Foreman 3.4 / Katello 4.6 by the foreman-installer, but only with the scenario Katello:
+
+```sh
+foreman-install --scenario katello --enable-foreman-plugin-scc-manager
+```
+
+You can also install it manually:
 
 ```sh
 yum install tfm-rubygem-foreman_scc_manager
@@ -20,18 +26,16 @@ foreman-installer
 
 | Foreman Version | Katello Version | Plugin Version |
 | --------------- | --------------- | -------------- |
+| 3.5             | 4.5             | ~> 2.0.0       |
+| 3.1             | 4.3             | ~> 1.8.20\*    |
+| 3.0             | 4.2             | ~> 1.8.20      |
+| 2.5             | 4.1             | ~> 1.8.20      |
 | 2.3             | 3.18            | ~> 1.8.9       |
 | 2.1             | 3.16            | ~> 1.8.5       |
 | 2.0             | 3.16            | ~> 1.8.4       |
 | 1.24            | 3.14            | ~> 1.8.0       |
-| 1.22            | 3.12            | ~> 1.7.0       |
-| 1.21            | 3.10            | ~> 1.6.0       |
-| 1.20            | 3.9             | ~> 1.6.0       |
-| 1.19            | 3.8             | ~> 1.5.1       |
-| 1.18            | 3.7             | ~> 1.5.0       |
-| 1.17            | 3.6             | >= 1.3.1       |
-| 1.16            | 3.5             | <= 1.3.0       |
-| 1.15            | 3.4             | ~> 1.1.0       |
+
+\* If you are using foreman_scc_manager in version 1.8.20 and then upgrade to Katello 4.3, you need to manually run the following rake task on your Foreman instance: `foreman-rake foreman_scc_manager:setup_authentication_tokens`.
 
 ## Documentation
 
@@ -47,7 +51,7 @@ Fork and send a Pull Request. Thanks!
 
 ## Copyright
 
-Copyright (c) 2021 ATIX AG - https://atix.de
+Copyright (c) 2022 ATIX AG - https://atix.de
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by

data/app/controllers/api/v2/scc_accounts_controller.rb

@@ -10,7 +10,7 @@ module Api
         api_base_url '/api/v2'
       end
 
-      before_action :find_resource, :only => [:show, :update, :destroy, :sync, :bulk_subscribe]
+      before_action :find_resource, :only => [:show, :update, :destroy, :sync, :bulk_subscribe, :bulk_subscribe_with_repos]
 
       api :GET, '/scc_accounts/', N_('List all scc_accounts')
       param :organization_id, :identifier, :required => true
@@ -33,7 +33,7 @@ module Api
           param :login, String, :required => true, :desc => N_('Login id of scc_account')
           param :password, String, :required => true, :desc => N_('Password of scc_account')
           param :base_url, String, :required => false, :desc => N_('URL of SUSE for scc_account')
-          param :interval, ['never', 'daily', 'weekly', 'monthy'], :desc => N_('Interval for syncing scc_account')
+          param :interval, ['never', 'daily', 'weekly', 'monthly'], :desc => N_('Interval for syncing scc_account')
           param :sync_date, String, :desc => N_('Date and time relative to which the sync interval is run')
           param :katello_gpg_key_id, :identifier, :required => false, :desc => N_('Associated GPG key of scc_account')
         end
@@ -105,12 +105,16 @@ module Api
       param :id, :identifier_dottable, :required => true
       param :scc_subscribe_product_ids, Array, :required => true
       def bulk_subscribe
-        scc_products_to_subscribe = @scc_account.scc_products.where(:id => params[:scc_subscribe_product_ids])
         respond_to do |format|
-          if scc_products_to_subscribe.count > 0
+          if params[:scc_subscribe_product_ids].count > 0
+            # we need to pass two parameters to the product subscribe task,
+            # the product itself and an array of repo ids
+            # if the id array is empty, all repositories will be subscribed to
+            scc_products = @scc_account.scc_products.where(:id => params[:scc_subscribe_product_ids])
             subscribe_task = ForemanTasks.async_task(::Actions::BulkAction,
                                                      ::Actions::SccManager::SubscribeProduct,
-                                                     scc_products_to_subscribe)
+                                                     scc_products,
+                                                     {})
             format.json { render json: subscribe_task.to_json, status: :ok }
           else
             format.json { render json: { error: 'No Product selected' }, status: :expectation_failed }
@@ -122,6 +126,43 @@ module Api
         render json: { error: ('Lock on SCC account already taken: %s' % e).to_s }, status: :unprocessable_entity
       end
 
+      def_param_group :scc_product_data do
+        param :scc_product_data, Array, :required => true, :desc => 'Array of Hash elements. One hash element contains an scc_product_id and a repository_list.' do
+          param :scc_product_id, Integer, :required => true, :desc => 'Product ID of SCC product'
+          param :repository_list, Array, of: Integer, :required => false,
+                                         :desc => 'List of SCC repositories belonging to the SCC product. If the list is empty, all repositories will be subscribed to.'
+        end
+      end
+
+      api :PUT, '/scc_accounts/:id/bulk_subscribe_with_repos/', N_('Bulk subscription of scc_products with individual repository selection for scc_account.')
+      param :id, :identifier_dottable, :required => true
+      param_group :scc_product_data
+      def bulk_subscribe_with_repos
+        respond_to do |format|
+          # if we want to subscribe to specific repos, we need to pass the product and the
+          # corresponding repository ids instead of scc products only
+          if params[:scc_product_data].count > 0
+            scc_products = @scc_account.scc_products.where(:id => params[:scc_product_data].pluck(:scc_product_id))
+            if scc_products.empty?
+              format.json { render json: { error: _('The selected products cannot be found for this SCC account.') }, status: :unprocessable_entity }
+            else
+              action_args = params[:scc_product_data].map { |p| { p['scc_product_id'] => p['repository_list'] } }.inject(:merge)
+              subscribe_task = ForemanTasks.async_task(::Actions::BulkAction,
+                                                       ::Actions::SccManager::SubscribeProduct,
+                                                       scc_products,
+                                                       action_args)
+              format.json { render json: subscribe_task.to_json, status: :ok }
+            end
+          else
+            format.json { render json: { error: 'No Product selected' }, status: :expectation_failed }
+          end
+        end
+      rescue ::Foreman::Exception => e
+        render json: { error: ('Failed to add task to queue: %s' % e).to_s }, status: :unprocessable_entity
+      rescue ForemanTasks::Lock::LockConflict => e
+        render json: { error: ('Lock on SCC account already taken: %s' % e).to_s }, status: :unprocessable_entity
+      end
+
       private
 
       def scc_account_params
@@ -152,6 +193,8 @@ module Api
           :sync
         when 'bulk_subscribe'
           :bulk_subscribe
+        when 'bulk_subscribe_with_repos'
+          :bulk_subscribe_with_repos
         else
           super
         end

data/app/controllers/api/v2/scc_products_controller.rb

@@ -41,7 +41,7 @@ module Api
       param :id, :identifier_dottable, :required => true
       param :scc_account_id, :identifier_dottable, :required => true
       def subscribe
-        subcribe_task = ForemanTasks.async_task(::Actions::SccManager::SubscribeProduct, @scc_product) if @scc_product
+        subcribe_task = ForemanTasks.async_task(::Actions::SccManager::SubscribeProduct, @scc_product, {}) if @scc_product
         respond_to do |format|
           if subcribe_task
             format.json { render json: subcribe_task.to_json, status: :ok }

data/app/controllers/scc_accounts_controller.rb

@@ -1,5 +1,6 @@
 class SccAccountsController < ApplicationController
   helper_method :scc_filtered_products
+  helper_method :create_nested_product_tree
   before_action :find_organization
   before_action :find_resource, only: %i[show edit update destroy sync bulk_subscribe]
   before_action :find_available_gpg_keys, only: %i[new edit update create]
@@ -97,6 +98,52 @@ class SccAccountsController < ApplicationController
     redirect_to scc_accounts_path
   end
 
+  def create_nested_product_tree(scc_products, subscribed_only:)
+    if subscribed_only
+      scc_products_base = scc_products.where(:product_type => 'base').where.not(:product_id => nil).includes([:scc_extensions])
+    else
+      scc_products_base = scc_products.where(:product_type => 'base').includes([:scc_extensions])
+    end
+    tree = []
+    scc_products_base.each do |p|
+      tree.push(get_product_tree_hash(p))
+    end
+
+    tree
+  end
+
+  def scc_product_hash(scc_product)
+    scc_product_json = scc_product.as_json(:only => [:scc_id, :id, :arch, :version, :product_id, :subscription_valid],
+                                           include: { :scc_repositories => { :only => [:id, :name, :subscription_valid] } })
+                                  .merge('name' => scc_product.pretty_name, 'product_category' => scc_product.product_category)
+    # find if and which Katello root repository is associated with this SCC product
+    repo_ids_katello = scc_product.product.blank? || scc_product.product.root_repository_ids.blank? ? nil : scc_product.product.root_repository_ids
+    scc_product_json['scc_repositories'].each do |repo|
+      # byebug
+      if repo_ids_katello.blank?
+        repo['katello_root_repository_id'] = nil
+      else
+        repo_ids_scc = scc_product.scc_repositories.find(repo['id']).katello_root_repository_ids
+        repo['katello_root_repository_id'] = repo_ids_scc.blank? ? nil : (repo_ids_scc & repo_ids_katello).first
+      end
+    end
+    scc_product_json
+  end
+
+  def get_product_tree_hash(scc_product_base)
+    if scc_product_base.scc_extensions.blank?
+      scc_product_hash(scc_product_base)
+    else
+      children = []
+      scc_product_base.scc_extensions.each do |ext|
+        children.push(get_product_tree_hash(ext))
+      end
+      scc_product_base_hash = scc_product_hash(scc_product_base)
+      scc_product_base_hash['children'] = children
+      scc_product_base_hash
+    end
+  end
+
   private
 
   def find_available_gpg_keys

data/app/lib/actions/scc_manager/subscribe_product.rb

@@ -1,44 +1,80 @@
 module Actions
   module SccManager
     class SubscribeProduct < Actions::EntryAction
-      def plan(scc_product)
-        raise _('Product already subscribed!') if scc_product.product
+      # scc_product is an ActiveRecord object of Class SccProduct
+      # scc_repos_to_subscribe is a hash with the product id as keys and an array of
+      # repos to subscribe as values
+      # rubocop:disable Metrics/MethodLength
+      def plan(scc_product, scc_repos_to_subscribe)
+        if scc_product.product
+          ::Foreman::Logging.logger('foreman_scc_manager')
+                            .info("SccProduct '#{scc_product.friendly_name}' is already subscribed to.")
+        else
+          ::Foreman::Logging.logger('foreman_scc_manager')
+                            .info("Initiating subscription for SccProduct '#{scc_product.friendly_name}'.")
+        end
 
-        ::Foreman::Logging.logger('foreman_scc_manager')
-                          .info("Initiating subscription for SccProduct '#{scc_product.friendly_name}'.")
         sequence do
-          product_create_action = plan_action(CreateProduct,
-                                              :product_name => scc_product.pretty_name,
-                                              :product_description => scc_product.pretty_description,
-                                              :organization_id => scc_product.organization.id,
-                                              :gpg_key => scc_product.scc_account.katello_gpg_key_id)
+          if scc_product.product_id.nil?
+            product_create_action = plan_action(CreateProduct,
+                                                :product_name => scc_product.pretty_name,
+                                                :product_description => scc_product.pretty_description,
+                                                :organization_id => scc_product.organization.id,
+                                                :gpg_key => scc_product.scc_account.katello_gpg_key_id)
+          end
           katello_repos = {}
-          scc_product.scc_repositories.each do |repo|
+          # we need to set the repositories to subscribe to
+          scc_repos = []
+          if scc_repos_to_subscribe.empty?
+            scc_repos = scc_product.scc_repositories
+          else
+            # at this point, we need to make sure that the repository list is valid
+            # we want to subscribe only to repos that we have not subscribed before
+            repo_ids_katello = scc_product.product.blank? || scc_product.product.root_repository_ids.blank? ? nil : scc_product.product.root_repository_ids
+            scc_repos = scc_product.scc_repositories.where(id: scc_repos_to_subscribe[scc_product.id])
+            unless repo_ids_katello.nil? || scc_repos.empty?
+              # remove repo if Katello repo is already associated
+              scc_repos.reject { |repo| (repo.katello_root_repositories & repo_ids_katello).present? }
+            end
+          end
+          if scc_repos.empty?
+            ::Foreman::Logging.logger('foreman_scc_manager')
+                              .info('The repositories you have selected are either already subscribed to or invalid.')
+          else
+            ::Foreman::Logging.logger('foreman_scc_manager')
+                              .info("Subscribing to SCC repositories '#{scc_repos.pluck(:id)}'.
+                                    If you requested more repositories, please check if those are already subscribed to or invalid.")
+          end
+          scc_repos.each do |repo|
             arch = scc_product.arch || 'noarch'
             repo_create_action = plan_action(CreateRepository,
-                                             :product_id => product_create_action.output[:product_id],
+                                             :product_id => scc_product.product_id || product_create_action.output[:product_id],
                                              :uniq_name => repo.uniq_name(scc_product),
                                              :pretty_repo_name => repo.pretty_name,
-                                             :url => repo.full_url,
+                                             :url => repo.url,
+                                             :token => repo.token,
                                              :arch => arch)
             katello_repos[repo.id] = repo_create_action.output[:katello_root_repository_id]
           end
+
           # connect action to resource (=> make parameters accessable in input)
-          action_subject(scc_product, product_id: product_create_action.output[:product_id])
+          action_subject(scc_product, product_id: product_create_action.output[:product_id]) if scc_product.product_id.nil?
           input.update(katello_repos: katello_repos)
           plan_self
         end
       end
+      # rubocop:enable Metrics/MethodLength
 
       def finalize
         # connect Scc products and Katello products
-        scc_product = SccProduct.find(input[:scc_product][:id])
-        product = ::Katello::Product.find(input[:product_id])
-        scc_product.update!(product: product)
+        # it may happen that we only append repos to an existing product
+        unless input[:scc_product].nil?
+          scc_product = SccProduct.find(input[:scc_product][:id])
+          scc_product.update!(product_id: input[:product_id])
+        end
         # extract Katello repo ids from input hash and store to database
         input[:katello_repos].each do |scc_repo_id, katello_root_repository_id|
-          scc_repo = SccRepository.find(scc_repo_id)
-          scc_repo.update!(katello_root_repository_id: katello_root_repository_id)
+          SccKatelloRepository.find_or_create_by(scc_repository_id: scc_repo_id, katello_root_repository_id: katello_root_repository_id)
         end
       end
 
@@ -79,7 +115,6 @@ module Actions
         gpg_key = product.gpg_key
         repo_param = { :label => label,
                        :name => input[:pretty_repo_name],
-                       :url => input[:url],
                        :content_type => 'yum',
                        :unprotected => unprotected,
                        :gpg_key => gpg_key,
@@ -91,6 +126,13 @@ module Actions
         else
           repository.mirroring_policy = ::Katello::RootRepository::MIRRORING_POLICY_CONTENT
         end
+        if repository.has_attribute?('upstream_authentication_token')
+          repository.url = input[:url]
+          repository.upstream_authentication_token = input[:token]
+        else
+          repository.url = input[:token].blank? ? input[:url] : "#{input[:url]}?#{input[:token]}"
+        end
+
         repository.verify_ssl_on_sync = true
         trigger(::Actions::Katello::Repository::CreateRoot, repository).tap do
           output[:katello_root_repository_id] = repository.id

data/app/models/scc_account.rb

@@ -194,12 +194,13 @@ class SccAccount < ApplicationRecord
 
     # all scc repos that are kept but not available upstream need to be marked invalid
     # subscription_valid can be set to nil
-    to_invalidate = invalidated_repos.select { |ir| ir.katello_root_repository_id.present? && !ir.subscription_valid }
+    to_invalidate = invalidated_repos.select { |ir| ir.katello_root_repositories.count > 0 && !ir.subscription_valid }
     ::Foreman::Logging.logger('foreman_scc_manager').debug "Invalidating #{to_invalidate.count} expired repositories"
     invalidate_subscription_status(to_invalidate, save_record: true)
 
     # delete repositories being removed upstream and that are not subscribed to
-    to_delete = scc_repositories.where.not(scc_id: upstream_repo_ids)
+    to_delete = scc_repositories.where.not(scc_id: upstream_repo_ids).includes(:scc_katello_repositories).where(scc_katello_repositories: { id: nil })
+
     ::Foreman::Logging.logger('foreman_scc_manager').debug "Deleting #{to_delete.count} old repositories"
     to_delete.destroy_all
   end
@@ -218,8 +219,8 @@ class SccAccount < ApplicationRecord
       cached_product.product_type = up['product_type']
       cached_product.scc_repositories =
         scc_repositories.where(scc_id: up['repositories'].map { |repo| repo['id'] })
-      # name should be set after friendly_name because it depends on friendly_name
       cached_product.name = cached_product.pretty_name
+      cached_product.product_category = up['name']
       cached_product.description = cached_product.pretty_description
       cached_product.subscription_valid = true
       cached_product.save!

data/app/models/scc_katello_repository.rb

@@ -0,0 +1,4 @@
+class SccKatelloRepository < ApplicationRecord
+  belongs_to :scc_repository
+  belongs_to :katello_root_repository, class_name: 'Katello::RootRepository'
+end

data/app/models/scc_product.rb

@@ -56,13 +56,19 @@ class SccProduct < ApplicationRecord
       label = Katello::Util::Model.labelize(uniq_repo_name)
       unprotected = true
       gpg_key = new_product.gpg_key
-      new_repo = new_product.add_repo(label, uniq_repo_name, repo.full_url, 'yum', unprotected, gpg_key)
+      new_repo = new_product.add_repo(label, uniq_repo_name, repo.url, 'yum', unprotected, gpg_key)
       new_repo.arch = arch || 'noarch'
       if new_repo.has_attribute?('mirror_on_sync')
         new_repo.mirror_on_sync = true
       else
         new_repo.mirroring_policy = ::Katello::RootRepository::MIRRORING_POLICY_CONTENT
       end
+      if new_repo.has_attribute?('upstream_authentication_token')
+        new_repo.upstream_authentication_token = repo.token
+        new_repo.url = repo.url
+      else
+        new_repo.url = repo.full_url
+      end
       new_repo.verify_ssl_on_sync = true
       ForemanTasks.sync_task(::Actions::Katello::Repository::Create, new_repo, false, false)
     end

data/app/models/scc_repository.rb

@@ -4,7 +4,8 @@ class SccRepository < ApplicationRecord
   self.include_root_in_json = false
 
   belongs_to :scc_account
-  belongs_to :katello_root_repository, class_name: 'Katello::RootRepository'
+  has_many :scc_katello_repositories
+  has_many :katello_root_repositories, through: :scc_katello_repositories
   has_one :organization, through: :scc_account
   has_and_belongs_to_many :scc_products
 
@@ -27,9 +28,16 @@ class SccRepository < ApplicationRecord
     # as uniq_name was changed, we need to look for repo labels that end with the repo name
     katello_repos = Katello::RootRepository.where('label like ?', "%#{::Katello::Util::Model.labelize(self.description)}%")
     katello_repos.each do |repo|
-      unless repo.url == full_url
-        ::Foreman::Logging.logger('foreman_scc_manager').info "Update URL-token for repository '#{repo.name}'."
-        ForemanTasks.async_task(::Actions::Katello::Repository::Update, repo, url: full_url)
+      if repo.has_attribute?('upstream_authentication_token')
+        unless repo.url == url && repo.upstream_authentication_token == token
+          ForemanTasks.async_task(::Actions::Katello::Repository::Update, repo, url: url, upstream_authentication_token: token)
+          ::Foreman::Logging.logger('foreman_scc_manager').info "Update URL and authentication token for repository '#{repo.name}'."
+        end
+      else
+        unless repo.url == full_url
+          ForemanTasks.async_task(::Actions::Katello::Repository::Update, repo, url: full_url)
+          ::Foreman::Logging.logger('foreman_scc_manager').info "Update URL-token for repository '#{repo.name}'."
+        end
       end
     end
   end

data/app/views/scc_accounts/show.html.erb

@@ -1,52 +1,8 @@
 <% title (_("Product Selection for Account %s") % @scc_account) %>
-
-<% javascript 'foreman_scc_manager/scc_accounts' %>
-<%= form_for([:bulk_subscribe, @scc_account], method: :put) do |f| %>
-  <% def render_list_node(f, scc_product, parent_id = "") %>
-    <li>
-      <span class="scc_product_checkbox" id="<%= "scc_product_span_#{parent_id + "_" + scc_product.id.to_s}" %>" <%= "data-parent=scc_product_span_#{parent_id}" if parent_id != "" %>>
-        <% if scc_product.product %>
-          <%= check_box_tag("scc_account[scc_unsubscribe_product_ids][]", scc_product.id, true, disabled: true) %>
-          <%= link_to(scc_product.pretty_name, "/products/#{scc_product.product_id}") %>
-        <% else %>
-          <%= check_box_tag("scc_account[scc_subscribe_product_ids][]", scc_product.id, false) %>
-          <%= scc_product.pretty_name %>
-        <% end %>
-        <% unless scc_product.subscription_valid? %>
-          <span style="color:red">
-            <%= _('(WARNING: Please check your SUSE subscription)') %>
-          </span>
-        <% end %>
-      </span>
-      <% if scc_product.scc_extensions.any? %>
-        <ul style='padding-left: 20px;'>
-          <% scc_filtered_products(scc_product.scc_extensions, 'extension').each do |scc_extension| %>
-            <% render_list_node(f, scc_extension, parent_id + "_" + scc_product.id.to_s) %>
-          <% end %>
-        </ul>
-      <% end %>
-    </li>
-  <% end %>
-
-  <%= f.hidden_field :prevent_missing, value: 1 %>
-  <ul class="nav nav-tabs" data-tabs="tabs">
-    <li class="active"><a href="#primary" data-toggle="tab"><%= _("SUSE Customer Center") %></a></li>
-  </ul>
-
-  <div class="tab-content">
-    <div class="tab-pane active" id="primary">
-      <ul>
-        <% if @scc_account.synced %>
-          <% scc_filtered_products(@scc_account.scc_products).each do |scc_product| %>
-            <% render_list_node(f, scc_product) %>
-          <% end %>
-        <% else %>
-          <%= _('Please sync your SUSE subscriptions first.') %>
-          <% submit_disabled = true %>
-        <% end %>
-      </ul>
-    </div>
-    <%= submit_or_cancel f, false, {disabled: submit_disabled || false} %>
-  </div>
-<% end %>
-
+<%= webpacked_plugins_js_for :foreman_scc_manager %>
+<%= webpacked_plugins_css_for :foreman_scc_manager %>
+<%= react_component('SCCProductPage', {
+  :canCreate => authorized_for(action: :sync),
+  :sccAccountId => @scc_account.id,
+  :sccProductsInit => create_nested_product_tree(@scc_account.scc_products, subscribed_only: false)
+}) %>

data/config/routes.rb

@@ -32,6 +32,7 @@ Rails.application.routes.draw do
           put 'test_connection'
           put 'sync'
           put 'bulk_subscribe'
+          put 'bulk_subscribe_with_repos'
         end
       end
       constraints(:scc_account_id => /[^\/]+/) do

data/db/migrate/20220425132605_add_scc_katello_repository_relation.rb

@@ -0,0 +1,10 @@
+class AddSccKatelloRepositoryRelation < ActiveRecord::Migration[6.0]
+  def change
+    create_table(:scc_katello_repositories) do |t|
+      t.references :scc_repository, null: false, foreign_key: { on_delete: :cascade }
+      t.references :katello_root_repository, null: false, foreign_key: { on_delete: :cascade }
+
+      t.timestamps null: false
+    end
+  end
+end

data/db/migrate/20220429100843_remove_root_repository_id_from_scc_repository.rb

@@ -0,0 +1,6 @@
+class RemoveRootRepositoryIdFromSccRepository < ActiveRecord::Migration[6.0]
+  def change
+    remove_foreign_key :scc_repositories, :katello_root_repositories, column: :katello_root_repository_id, on_delete: :nullify
+    remove_column :scc_repositories, :katello_root_repository_id, :integer, index: true, null: true
+  end
+end

data/db/migrate/20220429102717_populate_scc_katello_repositories.rb

@@ -0,0 +1,21 @@
+class PopulateSccKatelloRepositories < ActiveRecord::Migration[6.0]
+  class SccProduct < ApplicationRecord
+    belongs_to :product, class_name: 'Katello::Product'
+    has_and_belongs_to_many :scc_repositories
+  end
+  class SccRepository < ApplicationRecord
+    has_many :scc_katello_repositories
+    has_many :katello_root_repositories, through: :scc_katello_repositories
+    has_and_belongs_to_many :scc_products
+  end
+
+  def up
+    SccProduct.where.not(product_id: nil).each do |scc_p|
+      scc_p.scc_repositories.each do |scc_r|
+        # find all Katello repositories that were derived from that SCC repository
+        katello_repos = Katello::RootRepository.where('label like ?', "%#{::Katello::Util::Model.labelize(scc_r.description)}%")
+        scc_r.update!(katello_root_repositories: katello_repos)
+      end
+    end
+  end
+end

data/db/migrate/20220513132652_populate_upstream_authentication_token.rb

@@ -0,0 +1,23 @@
+class PopulateUpstreamAuthenticationToken < ActiveRecord::Migration[6.0]
+  def up
+    return unless ActiveRecord::Base.connection.column_exists?('katello_root_repositories', 'upstream_authentication_token')
+
+    scc_repositories = SccRepository.includes(:scc_katello_repositories).where.not(scc_katello_repositories: { id: nil })
+    scc_repositories.each do |scc_repo|
+      scc_repo.katello_root_repositories.each do |katello_repo|
+        katello_repo.update!(url: scc_repo.url, upstream_authentication_token: scc_repo.token)
+      end
+    end
+  end
+
+  def down
+    return if ActiveRecord::Base.connection.column_exists?('katello_root_repositories', 'upstream_authentication_token')
+
+    scc_repositories = SccRepository.includes(:scc_katello_repositories).where.not(scc_katello_repositories: { id: nil })
+    scc_repositories.each do |scc_repo|
+      scc_repo.katello_root_repositories.each do |katello_repo|
+        katello_repo.update!(url: scc_repo.full_url)
+      end
+    end
+  end
+end

data/db/migrate/20220531120722_add_product_category_to_scc_products.rb

@@ -0,0 +1,5 @@
+class AddProductCategoryToSccProducts < ActiveRecord::Migration[6.0]
+  def change
+    add_column :scc_products, :product_category, :string, null: true
+  end
+end

data/lib/foreman_scc_manager/engine.rb

@@ -38,7 +38,7 @@ module ForemanSccManager
 
           permission :use_scc_accounts,
                      { :scc_accounts => [:bulk_subscribe],
-                       :'api/v2/scc_accounts' => [:bulk_subscribe] },
+                       :'api/v2/scc_accounts' => [:bulk_subscribe, :bulk_subscribe_with_repos] },
                      :resource_type => 'SccAccount'
 
           permission :new_scc_accounts,

data/lib/foreman_scc_manager/version.rb

@@ -1,3 +1,3 @@
 module ForemanSccManager
-  VERSION = '1.8.19'.freeze
+  VERSION = '2.0.0'.freeze
 end

data/lib/tasks/republish_repositories.rake

@@ -0,0 +1,13 @@
+namespace :foreman_scc_manager do
+  desc 'Republish all SCC-repositories.'
+  task :republish_scc_repositories => ['dynflow:client', 'katello:check_ping'] do
+    needing_publish = SccKatelloRepository.joins(:katello_root_repository)
+                                          .joins(:katello_root_repository => :repositories)
+                                          .pluck("#{Katello::Repository.table_name}.id")
+    if needing_publish.any?
+      ForemanTasks.async_task(::Actions::Katello::Repository::BulkMetadataGenerate, Katello::Repository.where(:id => needing_publish))
+    else
+      puts 'Skipped. No repository found which was created by the SCC plugin.'
+    end
+  end
+end

data/lib/tasks/setup_authentication_token.rake

@@ -0,0 +1,27 @@
+begin
+  require 'rubocop/rake_task'
+
+  namespace :foreman_scc_manager do
+    desc 'Set up authentication tokens for Katello 4.3.'
+    task :setup_authentication_tokens => ['environment'] do
+      unless ActiveRecord::Base.connection.column_exists?('katello_root_repositories', 'upstream_authentication_token')
+        puts 'Your Katello version needs to be at 4.3 and up to run this task.'
+        return
+      end
+      begin
+        scc_repositories = SccRepository.includes(:scc_katello_repositories).where.not(scc_katello_repositories: { id: nil })
+        scc_repositories.each do |scc_repo|
+          scc_repo.katello_root_repositories.each do |katello_repo|
+            katello_repo.update!(url: scc_repo.url, upstream_authentication_token: scc_repo.token)
+          end
+        end
+        puts 'Authentication tokens created successfully.'
+      rescue StandardError => e
+        puts 'There was an error while creating the authentication tokens.'
+        puts e.to_s
+      end
+    end
+  end
+rescue LoadError
+  puts 'Rubocop not loaded.'
+end