foreman_scc_manager 1.8.2 → 1.8.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb848728ea3961f30b44e6a02f43b84e73555ff703b0e0c3456e772e66132536
-  data.tar.gz: e7ca63acbe79ac2def4f203a0f10c269230652a35efd53e08d7fec4c536f2a18
+  metadata.gz: 843165a6092fcb04bf69d13131ae44acb02478ce347084c160a8f61891770eba
+  data.tar.gz: 892025747b9572a4b31d25f4c96ab28ea9af0099ef3302fe8c7aec07935b588b
 SHA512:
-  metadata.gz: 215eaa829b2d7e544d818e421850763f4d78bc2b3e62d38d397980c10d0d066bea28e6a9d1fcacfdcb93486a683c0350fdaa0ea80451aebb99f6a7761cda62cc
-  data.tar.gz: a93f9a77bcc06abff4e22e78268363f5ae2a71be7d64debd8184ecfdeed412586f9e92bd8a5d7ef11d6308c7149950e7fd0114ef806c6d9717766cc838ed131c
+  metadata.gz: 0cb42eeb656e4a0cca5c93d7c83e0fed14fa73a9b0e7f2ad0ddcb07b007156405f0e91d968e4eb38aafd6376551f334340bda0a4ff9d632d13d4818766e7eb75
+  data.tar.gz: 700546d7abfdc1ff7fc12f452c69bb6ca8869c41b63ae4e37fef99541dc229bf2287de3435ecd8c09dee32cb79465b8c896af09c78b4d0d498209e35c8a347cf

data/README.md

@@ -13,6 +13,8 @@ for how to install Foreman plugins
 
 | Foreman Version | Katello Version | Plugin Version |
 | --------------- | --------------- | -------------- |
+| 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       |
@@ -23,6 +25,9 @@ for how to install Foreman plugins
 | 1.16            | 3.5             | <= 1.3.0       |
 | 1.15            | 3.4             | ~> 1.1.0       |
 
+## Documentation
+The plugin documentation can be found at https://docs.orcharhino.com/sources/management_ui/the_content_menu/suse_subscriptions.html.
+
 ## Contributing
 
 Fork and send a Pull Request. Thanks!

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

@@ -18,7 +18,7 @@ module Api
       def index
         scope = resource_scope
         scope = scope.where(:organization => params[:organization_id]) if params[:organization_id].present?
-        @scc_accounts = scope.search_for(params[:search], :order => params[:order]).paginate(:page => params[:page])
+        @scc_accounts = scope.search_for(params[:search], :order => params[:order]).paginate(:page => params[:page], :per_page => params[:per_page])
       end
 
       api :GET, '/scc_accounts/:id/', N_('Show scc_account')
@@ -34,7 +34,8 @@ module Api
           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 :sync_date, String, :desc => N_('Last Sync time of 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
       end
 
@@ -79,9 +80,9 @@ module Api
         end
         respond_to do |format|
           if @scc_account.test_connection
-            format.json { render json: 'Success'.to_json, status: :ok }
+            format.json { render json: { 'success' => true }.to_json, status: :ok }
           else
-            format.json { render json: 'Failed'.to_json, status: :not_found }
+            format.json { render json: { 'success' => false, 'error' => 'Test failed. Check your credentials.' }.to_json, status: :not_found }
           end
         end
       end
@@ -102,7 +103,7 @@ module Api
 
       api :PUT, '/scc_accounts/:id/bulk_subscribe/', N_('Bulk subscription of scc_products for scc_account')
       param :id, :identifier_dottable, :required => true
-      param :scc_subscribe_product_ids, Array
+      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|
@@ -112,7 +113,7 @@ module Api
                                                      scc_products_to_subscribe)
             format.json { render json: subscribe_task.to_json, status: :ok }
           else
-            format.json { render json: 'No Product selected'.to_json, status: :expectation_failed }
+            format.json { render json: { error: 'No Product selected' }, status: :expectation_failed }
           end
         end
       rescue ::Foreman::Exception => e
@@ -132,7 +133,8 @@ module Api
           :base_url,
           :interval,
           :sync_date,
-          :organization_id
+          :organization_id,
+          :katello_gpg_key_id
         )
       end
 

data/app/controllers/scc_accounts_controller.rb

@@ -1,12 +1,19 @@
 class SccAccountsController < ApplicationController
+  helper_method :scc_filtered_products
   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]
   include Foreman::Controller::AutoCompleteSearch
 
   # GET /scc_accounts
   def index
-    @scc_accounts = resource_base.search_for(params[:search], order: params[:order])
-                                 .paginate(page: params[:page])
+    @scc_accounts = resource_base.where(organization: @organization)
+                                 .search_for(params[:search], order: params[:order])
+                                 .paginate(:page => params[:page], :per_page => params[:per_page])
+    # overwrite the product list with filtered products that do not include products with empty repositories
+    @scc_accounts.each do |scc_account|
+      scc_account.scc_products_with_repos_count = scc_account.scc_products.only_products_with_repos.count
+    end
   end
 
   # GET /scc_accounts/new
@@ -92,6 +99,11 @@ class SccAccountsController < ApplicationController
 
   private
 
+  def find_available_gpg_keys
+    @scc_account ? org = @scc_account.organization : org = @organization
+    @selectable_gpg_keys = ::Katello::GpgKey.where(organization: org).collect { |p| [p.name, p.id] }.unshift ['None', nil]
+  end
+
   def find_organization
     @organization = Organization.current
     redirect_to '/select_organization?toState=' + request.path unless @organization
@@ -108,7 +120,8 @@ class SccAccountsController < ApplicationController
       :base_url,
       :interval,
       :sync_date,
-      :organization_id
+      :organization_id,
+      :katello_gpg_key_id
     )
   end
 
@@ -121,9 +134,22 @@ class SccAccountsController < ApplicationController
     when 'sync', 'test_connection'
       :sync
     when 'bulk_subscribe'
-      :bulk_subscribe
+      :use
     else
       super
     end
   end
+
+  # Function filters a product list and removes all products without valid repositories
+  # The .order call is necessary to apply the ordering to repository that have already been loaded from the database.
+  # Input parameters:
+  # product_list: list of SccProduct
+  # product_type: return only base products if type is set (default), else all
+  def scc_filtered_products(product_list, product_type = 'base')
+    if product_type == 'base'
+      product_list.only_products_with_repos.where(product_type: 'base').order(:friendly_name)
+    else
+      product_list.only_products_with_repos.order(:friendly_name)
+    end
+  end
 end

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

@@ -8,27 +8,38 @@ module Actions
                           .info("Initiating subscription for SccProduct '#{scc_product.friendly_name}'.")
         sequence do
           product_create_action = plan_action(CreateProduct,
-                                              product_name: scc_product.uniq_name,
-                                              product_description: scc_product.description,
-                                              organization_id: scc_product.organization.id)
+                                              :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)
+          katello_repos = {}
           scc_product.scc_repositories.each do |repo|
-            uniq_name = scc_product.uniq_name + ' ' + repo.description
             arch = scc_product.arch || 'noarch'
-            plan_action(CreateRepository,
-                        :product_id => product_create_action.output[:product_id],
-                        :uniq_name => uniq_name,
-                        :url => repo.full_url,
-                        :arch => arch)
+            repo_create_action = plan_action(CreateRepository,
+                                             :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,
+                                             :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])
+          input.update(katello_repos: katello_repos)
           plan_self
         end
       end
 
       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)
+        # 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)
+        end
       end
 
       def humanized_name
@@ -43,6 +54,7 @@ module Actions
       def create_sub_plans
         product = ::Katello::Product.new
         product.name = input[:product_name]
+        product.gpg_key = ::Katello::GpgKey.find_by(id: input[:gpg_key], organization: input[:organization_id])
         product.description = input[:product_description]
         trigger(::Actions::Katello::Product::Create,
                 product,
@@ -58,12 +70,11 @@ module Actions
 
       def create_sub_plans
         product = ::Katello::Product.find(input[:product_id])
-        uniq_name = input[:uniq_name]
-        label = ::Katello::Util::Model.labelize(uniq_name)
+        label = ::Katello::Util::Model.labelize(input[:uniq_name])
         unprotected = true
         gpg_key = product.gpg_key
         repo_param = { :label => label,
-                       :name => uniq_name,
+                       :name => input[:pretty_repo_name],
                        :url => input[:url],
                        :content_type => 'yum',
                        :unprotected => unprotected,
@@ -73,7 +84,9 @@ module Actions
         repository = product.add_repo(repo_param)
         repository.mirror_on_sync = true
         repository.verify_ssl_on_sync = true
-        trigger(::Actions::Katello::Repository::CreateRoot, repository)
+        trigger(::Actions::Katello::Repository::CreateRoot, repository).tap do
+          output[:katello_root_repository_id] = repository.id
+        end
       end
     end
   end

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

@@ -1,21 +1,21 @@
 module Actions
   module SccManager
+    # for dynflow documentation see here: https://dynflow.github.io/documentation/
     class Sync < Actions::EntryAction
       def plan(scc_account)
         ::Foreman::Logging.logger('foreman_scc_manager')
                           .info("Initiating 'sync' for SccAccount '#{scc_account.name}'.")
         action_subject(scc_account)
         sequence do
-          sync_repo_action = plan_action(::Actions::SccManager::SyncRepositories, scc_account)
-          sync_prod_action = plan_action(::Actions::SccManager::SyncProducts, scc_account)
-          plan_self(repo_status: sync_repo_action.output[:status], prod_status: sync_prod_action.output[:status])
+          plan_action(::Actions::SccManager::SyncRepositories, scc_account)
+          plan_action(::Actions::SccManager::SyncProducts, scc_account)
+          plan_self
         end
       end
 
       def finalize
+        # this is only executed if run actions of SyncRepositories and SyncProducts were successful
         scc_account = SccAccount.find(input[:scc_account][:id])
-        raise 'Updating failed' unless input[:repo_status] == 'SUCCESS' && input[:prod_status] == 'SUCCESS'
-
         scc_account.update! synced: Time.current
       end
 

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

@@ -13,20 +13,19 @@ module Actions
       end
 
       def run
-        output[:status] = 'SUCCESS'
-        begin
-          products = ::SccManager.get_scc_data(input.fetch(:base_url),
-                                               '/connect/organizations/products',
-                                               input.fetch(:login),
-                                               decrypt_field(input.fetch(:password)))
-          output[:data] = ::SccManager.sanitize_products(products).values
-        rescue StandardError
-          output[:status] = 'FAILURE'
-        end
+        products = ::SccManager.get_scc_data(input.fetch(:base_url),
+                                             '/connect/organizations/products',
+                                             input.fetch(:login),
+                                             decrypt_field(input.fetch(:password)))
+        output[:data] = ::SccManager.sanitize_products(products).values
+      rescue StandardError => e
+        ::Foreman::Logging.logger('foreman_scc_manager').error "Error while syncronizing SCC-Products: #{e}"
+        error! e.to_s
       end
 
       def finalize
-        SccAccount.find(input.fetch(:id)).update_scc_products(output.fetch(:data)) if output[:status] == 'SUCCESS'
+        # this is only executed if 'run' succeeds
+        SccAccount.find(input.fetch(:id)).update_scc_products(output.fetch(:data))
       end
 
       def rescue_strategy

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

@@ -12,20 +12,18 @@ module Actions
       end
 
       def run
-        output[:status] = 'IN PROGRESS'
-        begin
-          output[:data] = ::SccManager.get_scc_data(input[:base_url],
-                                                    '/connect/organizations/repositories',
-                                                    input[:login],
-                                                    decrypt_field(input[:password]))
-          output[:status] = 'SUCCESS'
-        rescue StandardError
-          output[:status] = 'FAILURE'
-        end
+        output[:data] = ::SccManager.get_scc_data(input[:base_url],
+                                                  '/connect/organizations/repositories',
+                                                  input[:login],
+                                                  decrypt_field(input[:password]))
+      rescue StandardError => e
+        ::Foreman::Logging.logger('foreman_scc_manager').error "Error while syncronizing SCC-Repositories: #{e}"
+        error! e.to_s
       end
 
       def finalize
-        SccAccount.find(input[:scc_account][:id]).update_scc_repositories(output[:data]) if output[:status] == 'SUCCESS'
+        # this is only executed if 'run' succeeds
+        SccAccount.find(input[:scc_account][:id]).update_scc_repositories(output[:data])
       end
 
       def rescue_strategy

data/app/lib/scc_manager.rb

@@ -8,8 +8,8 @@ module SccManager
       uri.scheme = URI.parse(proxy_config[:host]).scheme
       uri.host = URI.parse(proxy_config[:host]).host
       uri.port = proxy_config[:port].try(:to_s)
-      uri.user = proxy_config[:user].try(:to_s)
-      uri.password = proxy_config[:password].try(:to_s)
+      uri.user = proxy_config[:user]
+      uri.password = proxy_config[:password] if uri.user.present?
 
       RestClient.proxy = uri.to_s
     end

data/app/models/scc_account.rb

@@ -2,6 +2,9 @@ class SccAccount < ApplicationRecord
   include Authorizable
   include Encryptable
   include ForemanTasks::Concerns::ActionSubject
+
+  attr_accessor :scc_products_with_repos_count
+
   encrypts :password
 
   NEVER = 'never'.freeze
@@ -166,38 +169,53 @@ class SccAccount < ApplicationRecord
   def test_connection
     get_scc_data('/connect/organizations/subscriptions')
     true
-  rescue StandardError
+  rescue StandardError => e
+    ::Foreman::Logging.logger('foreman_scc_manager').warn "Error occurred while testing SCC-Connection to Account #{self}: #{e}"
     false
   end
 
   def update_scc_repositories(upstream_repositories)
     upstream_repo_ids = []
+    # initially invalidate all repositories and validate them during update
+    invalidated_repos = invalidate_subscription_status(scc_repositories)
     # import repositories
     upstream_repositories.each do |ur|
       cached_repository = scc_repositories.find_or_initialize_by(scc_id: ur['id'])
-      cached_repository.name = ur['name']
       cached_repository.distro_target = ur['distro_target']
       cached_repository.description = ur['description']
       cached_repository.url, cached_repository.token = ur['url'].split('?')
       cached_repository.enabled = ur['enabled']
       cached_repository.autorefresh = ur['autorefresh']
       cached_repository.installer_updates = ur['installer_updates']
+      # should be called after all attributes are set in case of dependencies (currently: description)
+      cached_repository.name = cached_repository.pretty_name
+      cached_repository.subscription_valid = true
       cached_repository.save!
       upstream_repo_ids << ur['id']
+      # set invalidated record to true, if exists
+      invalidated_repos = revalidate_subscription_status(invalidated_repos, ur[id])
     end
-    logger.debug "Found #{upstream_repo_ids.length} repositories"
-    # delete repositories beeing removed upstream
+    ::Foreman::Logging.logger('foreman_scc_manager').debug "Found #{upstream_repo_ids.length} repositories"
+
+    # 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 }
+    ::Foreman::Logging.logger('foreman_scc_manager').debug "Invalidating #{to_invalidate.count} expired repositories"
+    invalidate_subscription_status(to_invalidate, true)
+
+    # delete repositories being removed upstream and that are not subscribed to
     to_delete = scc_repositories.where.not(scc_id: upstream_repo_ids)
-    logger.debug "Deleting #{to_delete.count} old repositories"
+    ::Foreman::Logging.logger('foreman_scc_manager').debug "Deleting #{to_delete.count} old repositories"
     to_delete.destroy_all
   end
 
   def update_scc_products(upstream_products)
     upstream_product_ids = []
+    # initially invalidate all products and validate them during update
+    invalidated_products = invalidate_subscription_status(scc_products)
     # import products
     upstream_products.each do |up|
       cached_product = scc_products.find_or_initialize_by(scc_id: up['id'])
-      cached_product.name = up['name']
       cached_product.version = up['version']
       cached_product.arch = up['arch']
       cached_product.description = up['description']
@@ -205,13 +223,26 @@ 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.description = cached_product.pretty_description
+      cached_product.subscription_valid = true
       cached_product.save!
       upstream_product_ids << up['id']
+      # set invalidated record to true, if exists
+      invalidated_products = revalidate_subscription_status(invalidated_products, up['id'])
     end
-    logger.debug "Found #{upstream_product_ids.length} products"
-    # delete products beeing removed upstream
-    to_delete = scc_products.where.not(scc_id: upstream_product_ids)
-    logger.debug "Deleting #{to_delete.count} old products"
+    ::Foreman::Logging.logger('foreman_scc_manager').debug "Found #{upstream_product_ids.length} products"
+
+    # all scc products that are kept but not available upstream need to be marked invalid
+    # subscription_valid can be set to nil
+    to_invalidate = invalidated_products.select { |ip| ip.product_id.present? && !ip.subscription_valid }
+    ::Foreman::Logging.logger('foreman_scc_manager').debug "Invalidating #{to_invalidate.count} expired products"
+    invalidate_subscription_status(to_invalidate, true)
+
+    # delete products being removed upstream and that are not subscribed to
+    to_delete = scc_products.where.not(scc_id: upstream_product_ids).where(product_id: nil)
+    ::Foreman::Logging.logger('foreman_scc_manager').debug "Deleting #{to_delete.count} old products"
     to_delete.destroy_all
     # rewire product to product relationships
     upstream_products.each do |up|
@@ -219,8 +250,36 @@ class SccAccount < ApplicationRecord
       begin
         scc_products.find_by!(scc_id: up['id']).update!(scc_extensions: extensions)
       rescue ActiveRecord::RecordNotFound
-        logger.info "Failed to find parent scc_product '#{up['name']}'."
+        ::Foreman::Logging.logger('foreman_scc_manager').info "Failed to find parent scc_product '#{up['name']}'."
+      end
+    end
+  end
+
+  # validate the subscription status of a product/repo
+  # no saving to database
+  # params: elements: scc repos or products, Array or ActiveRecord_(*)
+  #         scc_id: scc_id of the element that should be revalidated
+  # return: elements where for the element with scc_id subscription_valid is true
+  def revalidate_subscription_status(elements, scc_id)
+    return nil if elements.nil?
+
+    revalidate = elements.find { |e| e.scc_id == scc_id }
+    revalidate.subscription_valid = true unless revalidate.nil?
+    # return modified list
+    elements
+  end
+
+  # set all products/repos invalid
+  # params: items_to_invalidate: ActiveRecord_(*)
+  #         save_record: store in database or not (default)
+  # return: ActiveRecord elements with invalidated subscription status
+  def invalidate_subscription_status(items_to_invalidate, save_record = false)
+    if items_to_invalidate.present?
+      items_to_invalidate.each do |inv|
+        inv.subscription_valid = false
+        inv.save! if save_record
       end
     end
+    items_to_invalidate
   end
 end