foreman_scc_manager 1.8.4 → 1.8.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ad2397229cd491566c2860224641db959be83c82254864cd06f5c37648cd60e
-  data.tar.gz: f9a8e1e8f6ab872e1e0528beab2563421d498e5aaa32a38c21b00756d4cf84b6
+  metadata.gz: ab78f155bda869b47a6124ada7ebcdf9d067c6173c400dfd9c052c70227695f9
+  data.tar.gz: '009d1c1db82b1c52e4e0ab47ebdb1769dbb4ea0e71fb6a2a0b5b26fff5b0cb41'
 SHA512:
-  metadata.gz: 962060eff9906bfb01a629a3700adaa460d5120d57e2823a19ce786f1aecafad65ddd903d2430a40a431f53a7ed341fd39103324382c9cf33fd07380b1cc49e4
-  data.tar.gz: 2d3fd9536db98424c81f7b730727d5c7fd6034428e9cbd64eb238ed4b4b022267b4f6c2a39b1f6d6008f28e751d05da3341476d7f9366151f481d3ec95b8c91c
+  metadata.gz: da25af4b803899a68ef9b3fae9646901437051d5b69dd4b5c588cca5e0018ea0b797d32255ed4dc5ba6ccb5044a119c2d712bb3b35905aeb231182145f910878
+  data.tar.gz: 15b7aa5a3f7a05e3c517aa6aa41fcef1c9bee3fb00d5f49405166264d21a7857fc348940c06a0279d88330d29b7480e90d2f3e32025ee2bcba95c1acf84f1c7b

data/README.md

@@ -13,6 +13,9 @@ for how to install Foreman plugins
 
 | Foreman Version | Katello Version | Plugin Version |
 | --------------- | --------------- | -------------- |
+| 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       |
@@ -23,13 +26,19 @@ 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.
+
+A Hammer CLI extension is available for this plugin:
+https://github.com/ATIX-AG/hammer-cli-foreman-scc-manager
+
 ## Contributing
 
 Fork and send a Pull Request. Thanks!
 
 ## Copyright
 
-Copyright (c) 2017 ATIX AG - http://www.atix.de
+Copyright (c) 2021 ATIX AG - http://www.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

@@ -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,22 +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 => e
-          ::Foreman::Logging.logger('foreman_scc_manager').error "Error while syncronizing SCC-Products: #{e}"
-          output[:error] = e.to_s
-          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,22 +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 => e
-          ::Foreman::Logging.logger('foreman_scc_manager').error "Error while syncronizing SCC-Repositories: #{e}"
-          output[:error] = e.to_s
-          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/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
@@ -173,21 +176,34 @@ class SccAccount < ApplicationRecord
 
   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
     ::Foreman::Logging.logger('foreman_scc_manager').debug "Found #{upstream_repo_ids.length} repositories"
-    # delete repositories beeing removed upstream
+
+    # 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)
     ::Foreman::Logging.logger('foreman_scc_manager').debug "Deleting #{to_delete.count} old repositories"
     to_delete.destroy_all
@@ -195,10 +211,11 @@ class SccAccount < ApplicationRecord
 
   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']
@@ -206,12 +223,25 @@ 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
     ::Foreman::Logging.logger('foreman_scc_manager').debug "Found #{upstream_product_ids.length} products"
-    # delete products beeing removed upstream
-    to_delete = scc_products.where.not(scc_id: upstream_product_ids)
+
+    # 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
@@ -224,4 +254,32 @@ class SccAccount < ApplicationRecord
       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