foreman_maintain 1.9.2 → 1.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 353f969fb5c1563fa146f6f5cca6a9a5c0a42e22564aa6e26d0d5d2b58d1b943
-  data.tar.gz: b9f71f13a94ffef3cf8b338faf4d43f5aa053c58f84327713581c2f8b8bc6fa8
+  metadata.gz: f0e6da9a83b7060020dd78da8a1fd8887e4b76708471b3ee80802335e5252224
+  data.tar.gz: 4fdb27b3583aa2665bd76e725d748408c19e956c9959ed2513d17eb234ae4e7b
 SHA512:
-  metadata.gz: 81316471839fc3ac86ecc96edccecdf4b6475bdd908ab79c1d55eba6d07a8bad0e75aaa83a440449fc8bf357e1c93df87e0d5f45f4211ba602172be9fde31bd4
-  data.tar.gz: ae7ae727511fe75f9c517de28a93c66231c5e6e2a362541f769a5d99c364f4b49f9bf80b178b1def23fd6f4d83596fdc0d83e06e89540a17d0751bc838347797
+  metadata.gz: 8cd917d7a19d07c9674b8c7a31ffd45378d936b27fa8442ad18ebf004d1b9084fba86b9e67747c66f4dc91a23b0426c7e1fb9442f501678ece2b950eb45efe7d
+  data.tar.gz: 965c7051bc9623d274d7c38b0a13fb4919f9e84d5651e22cb8b7faf827e9fc0b1f883c9154fae72f56b33c0fa5fe4cae6fd5b4432ebc44d0cc943c8b44982926

data/definitions/checks/check_ipv6_disable.rb

@@ -12,7 +12,7 @@ class Checks::CheckIpv6Disable < ForemanMaintain::Check
 
   def error_message
     base = "\nThe kernel contains ipv6.disable=1 which is known to break installation and upgrade"\
-           ", remove and reboot before continuining."
+           ", remove and reboot before continuing."
 
     if feature(:instance).downstream
       base += " See https://access.redhat.com/solutions/5045841 for more details."

data/definitions/reports/compliance.rb

@@ -0,0 +1,28 @@
+module Reports
+  class Compliance < ForemanMaintain::Report
+    metadata do
+      description 'Check if OpenSCAP is used'
+    end
+
+    def run
+      self.data = {}
+      mapping = {
+        'policy':
+          'foreman_openscap_policies',
+        'policy_with_tailoring_file':
+          'foreman_openscap_policies WHERE tailoring_file_id IS NOT NULL',
+        'scap_contents':
+          "foreman_openscap_scap_contents",
+        'non_default_scap_contents':
+          "foreman_openscap_scap_contents WHERE NOT original_filename LIKE 'ssg-rhel%-ds.xml'",
+        'arf_report_last_year':
+          "reports WHERE type = 'ForemanOpenscap::ArfReport'
+                      AND reported_at < NOW() - INTERVAL '1 year'",
+      }
+
+      mapping.each do |k, query|
+        data["compliance_#{k}_count"] = sql_count(query)
+      end
+    end
+  end
+end

data/definitions/reports/external_auth_source.rb

@@ -0,0 +1,26 @@
+module Reports
+  class ExternalAuthSource < ForemanMaintain::Report
+    metadata do
+      description 'Checks the use of External auth source'
+    end
+
+    # Do you use external auth source?
+    def run
+      self.data = {}
+      # nil means no user linked to external auth source ever logged in
+      data["last_login_on_through_external_auth_source_in_days"] = nil
+
+      sql = <<~SQL
+        SELECT users.* FROM users
+        INNER JOIN auth_sources ON (auth_sources.id = users.auth_source_id)
+        WHERE auth_sources.type = 'AuthSourceExternal' AND users.last_login_on IS NOT NULL
+        ORDER BY users.last_login_on DESC LIMIT 1
+      SQL
+      user = query(sql).first
+      if user
+        data["last_login_on_through_external_auth_source_in_days"] =
+          (Date.today - Date.parse(user['last_login_on'])).to_i
+      end
+    end
+  end
+end

data/definitions/reports/grouping.rb

@@ -0,0 +1,31 @@
+module Reports
+  class Grouping < ForemanMaintain::Report
+    metadata do
+      description 'Check how resources are grouped'
+    end
+
+    def run
+      self.data = {}
+      data_field('host_collections_count') { sql_count('katello_host_collections') }
+
+      data_field('host_collections_with_limit_count') do
+        sql_count("katello_host_collections
+                   WHERE unlimited_hosts = 'f'")
+      end
+
+      hostgroup = sql_count('hostgroups')
+      hostgroup_nest_level = sql_as_count(
+        "COALESCE(MAX((CHAR_LENGTH(ancestry) - CHAR_LENGTH(REPLACE(ancestry, '/', '')))) + 2, 1)",
+        'hostgroups'
+      )
+      data['hostgroup_nesting'] = hostgroup_nest_level > 1
+      data['hostgroup_max_nesting_level'] = hostgroup.zero? ? 0 : hostgroup_nest_level
+
+      data_field('use_selectable_columns') { sql_count('table_preferences') > 0 }
+
+      if table_exists('config_groups')
+        data_field('config_group_count') { sql_count('config_groups') }
+      end
+    end
+  end
+end

data/definitions/reports/instance.rb

@@ -0,0 +1,11 @@
+module Reports
+  class Instance < ForemanMaintain::Report
+    metadata do
+      description 'Report information about the instance itself'
+    end
+
+    def run
+      data_field('instance_uuid') { YAML.safe_load(sql_setting('instance_id')) }
+    end
+  end
+end

data/definitions/reports/inventory.rb

@@ -0,0 +1,84 @@
+module Reports
+  class Inventory < ForemanMaintain::Report
+    metadata do
+      description 'Facts about hosts and the rest of the inventory'
+    end
+
+    def run
+      merge_data('hosts_by_type_count') { hosts_by_type_count }
+      merge_data('hosts_by_os_count') { hosts_by_os_count }
+      merge_data('facts_by_type') { facts_by_type }
+      merge_data('audits') { audits }
+      merge_data('parameters_count') { parameters }
+    end
+
+    # Hosts
+    def hosts_by_type_count
+      query("select type, count(*) from hosts group by type").
+        to_h { |row| [(row['type'] || '').sub('Host::', ''), row['count'].to_i] }
+    end
+
+    # OS usage
+    def hosts_by_os_count
+      query(
+        <<-SQL
+            select max(operatingsystems.name) as os_name, count(*) as hosts_count
+            from hosts inner join operatingsystems on operatingsystem_id = operatingsystems.id
+            group by operatingsystem_id
+        SQL
+      ).
+        to_h { |row| [row['os_name'], row['hosts_count'].to_i] }
+    end
+
+    # Facts usage
+    def facts_by_type
+      query(
+        <<-SQL
+            select fact_names.type,
+                    min(fact_values.updated_at) as min_update_time,
+                    max(fact_values.updated_at) as max_update_time,
+                    count(fact_values.id) as values_count
+            from fact_values inner join fact_names on fact_name_id = fact_names.id
+            group by fact_names.type
+        SQL
+      ).
+        to_h { |row| [row['type'].sub('FactName', ''), to_fact_hash(row)] }
+    end
+
+    # Audits
+    def audits
+      audits_query =
+        query(
+          <<-SQL
+            select count(*) as records_count,
+                    min(created_at) as min_created_at,
+                    max(created_at) as max_created_at
+            from audits
+          SQL
+        )
+      to_audits_record(audits_query.first)
+    end
+
+    # Parameters
+    def parameters
+      query("select type, count(*) from parameters group by type").
+        to_h { |row| [row['type'], row['count'].to_i] }
+    end
+
+    def to_fact_hash(row)
+      {
+        min_update_time: row['min_update_time'],
+        max_update_time: row['max_update_time'],
+        values_count: row['values_count'].to_i,
+      }
+    end
+
+    def to_audits_record(row)
+      {
+        records_count: row['records_count'].to_i,
+        min_created_at: row['min_created_at'],
+        max_created_at: row['max_created_at'],
+      }
+    end
+  end
+end

data/definitions/reports/kerberos.rb

@@ -0,0 +1,27 @@
+module Reports
+  class Kerberos < ForemanMaintain::Report
+    metadata do
+      description 'Checks the use of Kerberos'
+      tags :report
+    end
+
+    # Do you use kerberos?
+    # Do you use kerberos also for API authentication?
+    def run
+      authorize_login_delegation = sql_setting('authorize_login_delegation')
+      authorize_login_delegation_api = sql_setting('authorize_login_delegation_api')
+      oidc_issuer = sql_setting('oidc_issuer')
+      kerberos_result = authorize_login_delegation &&
+                        YAML.load(authorize_login_delegation) == true &&
+                        (oidc_issuer.nil? || YAML.load(oidc_issuer) == '')
+      kerberos_api_result = kerberos_result &&
+                            authorize_login_delegation_api &&
+                            YAML.load(authorize_login_delegation_api) == true
+
+      self.data = {
+        kerberos_use: !!kerberos_result,
+        kerberos_api_use: !!kerberos_api_result,
+      }
+    end
+  end
+end

data/definitions/reports/ldap_auth_source.rb

@@ -0,0 +1,73 @@
+module Reports
+  class LDAPAuthSource < ForemanMaintain::Report
+    metadata do
+      description 'Checks the use of LDAP auth sources'
+    end
+
+    # Do you use FreeIPA LDAP auth source?
+    # Do you use AD LDAP auth source?
+    # Do you use POSIX LDAP auth source?
+    # Do you use netgroups schema?
+    # Do you disable automatic account creation on any LDAP auth source?
+    # Do you disable user group syncrhonization on any LDAP auth source?
+    # Do you have external user groups mapping?
+    def run
+      self.data = {}
+      data_field("external_user_group_mapping_count") { sql_count('external_usergroups') }
+      %w[free_ipa posix active_directory].reduce({}) do |_acc, flavor|
+        record_flavor_usage(flavor)
+      end
+    end
+
+    private
+
+    # rubocop:disable Metrics/AbcSize
+    def record_flavor_usage(flavor)
+      flavored_query_base = query_base(flavor)
+      data["ldap_auth_source_#{flavor}_count"] = sql_count(flavored_query_base)
+
+      users = query(user_query(flavor))
+      data["users_authenticated_through_ldap_auth_source_#{flavor}"] = users.count
+
+      data["last_login_on_through_ldap_auth_source_#{flavor}_in_days"] = last_login(users)
+
+      data["ldap_auth_source_#{flavor}_with_net_groups_count"] =
+        sql_count("#{flavored_query_base} AND use_netgroups = true")
+
+      data["ldap_auth_source_#{flavor}_with_posix_groups_count"] =
+        sql_count("#{flavored_query_base} AND use_netgroups = false")
+
+      count = sql_count("#{flavored_query_base} AND onthefly_register = false")
+      data["ldap_auth_source_#{flavor}_with_account_creation_disabled_count"] = count
+
+      count = sql_count("#{flavored_query_base} AND usergroup_sync = false")
+      data["ldap_auth_source_#{flavor}_with_user_group_sync_disabled_count"] = count
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def last_login(users)
+      # nil means no user for a given LDAP type was found
+      if (user = users.first)
+        (Date.today - Date.parse(user['last_login_on'])).to_i
+      end
+    end
+
+    def query_base(flavor)
+      <<~SQL
+        auth_sources
+        WHERE auth_sources.type = 'AuthSourceLdap' AND auth_sources.server_type = '#{flavor}'
+      SQL
+    end
+
+    def user_query(flavor)
+      <<~SQL
+        SELECT users.* FROM users
+        INNER JOIN auth_sources ON (auth_sources.id = users.auth_source_id)
+        WHERE auth_sources.type = 'AuthSourceLdap'
+          AND auth_sources.server_type = '#{flavor}'
+          AND users.last_login_on IS NOT NULL
+        ORDER BY users.last_login_on DESC
+      SQL
+    end
+  end
+end

data/definitions/reports/oidc_usage.rb

@@ -0,0 +1,16 @@
+module Reports
+  class OIDC < ForemanMaintain::Report
+    metadata do
+      description 'Checks the use of Keycloak/OIDC'
+    end
+
+    # Do you use OIDC/keycloak?
+    def run
+      data_field('oidc_use') do
+        oidc_issuer = sql_setting('oidc_issuer') || ''
+        loaded = YAML.load(oidc_issuer)
+        loaded.is_a?(String) && loaded != ''
+      end
+    end
+  end
+end

data/definitions/reports/platform.rb

@@ -0,0 +1,98 @@
+module Reports
+  class Platform < ForemanMaintain::Report
+    metadata do
+      description 'Report about platform usages'
+    end
+
+    def run
+      general_fields
+      rbac_fields
+      settings_fields
+      bookmarks_fields
+      mail_notification_fields
+      user_groups_fields
+    end
+
+    def mail_notification_fields
+      # Mail notifications
+      # users_per_mail_notification =
+      #   query(
+      #     <<-SQL
+      #       select
+      #         max(mail_notifications.name) as notification_name,
+      #         count(user_mail_notifications.user_id)
+      #       from user_mail_notifications inner join mail_notifications
+      #         on mail_notification_id = mail_notifications.id
+      #       group by mail_notification_id
+      #     SQL
+      #   ).
+      #   to_h { |row| [row['notification_name'], row['count'].to_i] }
+
+      data_field('user_mail_notifications_count') { sql_count('user_mail_notifications') }
+    end
+
+    def user_groups_fields
+      data_field('user_groups_count') { sql_count('usergroups') }
+    end
+
+    def general_fields
+      data_field('smart_proxies_count') { sql_count('smart_proxies') }
+      merge_data('smart_proxies_creation_date') do
+        query("select id, created_at from smart_proxies").
+          to_h { |row| [row['id'], row['created_at']] }
+      end
+    end
+
+    def rbac_fields
+      data_field('total_users_count') { sql_count('users') }
+      data_field('non_admin_users_count') { sql_count('users where admin = false') }
+
+      data_field('custom_roles_count') { sql_count('roles where origin = null') }
+
+      merge_data('taxonomies_counts') do
+        query("select type, count(*) from taxonomies group by type").
+          to_h { |row| [row['type'], row['count'].to_i] }
+      end
+    end
+
+    def settings_fields
+      data_field('modified_settings') do
+        query("select name from settings").
+          map { |setting_line| setting_line['name'] }.
+          join(',')
+      end
+    end
+
+    def bookmarks_fields
+      merge_data('bookmarks_by_public_by_type') do
+        query(
+          <<-SQL
+              select public, owner_type, count(*)
+              from bookmarks
+              group by public, owner_type
+          SQL
+        ).
+          to_h do |row|
+          [
+            "#{row['public'] ? 'public' : 'private'}#{flatten_separator}#{row['owner_type']}",
+            row['count'].to_i,
+          ]
+        end
+      end
+      # bookmarks_by_owner =
+      #   query(
+      #     <<-SQL
+      #       select owner_type, owner_id, count(*)
+      #       from bookmarks
+      #       group by owner_type, owner_id
+      #     SQL
+      #   ).
+      #   to_h do |row|
+      #     [
+      #       "#{row['owner_type']}#{flatten_separator}#{row['owner_id']}",
+      #       row['count'].to_i,
+      #     ]
+      #   end
+    end
+  end
+end

data/definitions/reports/provisioning.rb

@@ -0,0 +1,109 @@
+module Reports
+  class Provisioning < ForemanMaintain::Report
+    metadata do
+      description 'Provisioning facts about the system'
+    end
+
+    def run
+      data_field('managed_hosts_created_in_last_3_months') do
+        sql_count(
+          <<-SQL
+            hosts WHERE managed = true AND created_at >= current_date - interval '3 months'
+          SQL
+        )
+      end
+
+      compute_resources_fields
+      bare_metal_fields
+      templates_fields
+    end
+
+    def compute_resources_fields
+      hosts_by_compute_resources_type
+      hosts_by_compute_profile
+
+      merge_data('compute_resources_by_type') do
+        query(
+          <<-SQL
+              select type, count(*)
+              from compute_resources
+              group by type
+          SQL
+        ).
+          to_h { |row| [row['type'], row['count'].to_i] }
+      end
+    end
+
+    def hosts_by_compute_resources_type
+      merge_data('hosts_by_compute_resources_type') do
+        query(
+          <<-SQL
+              select compute_resources.type, count(hosts.id)
+              from hosts left outer join compute_resources on compute_resource_id = compute_resources.id
+              group by compute_resources.type
+          SQL
+        ).
+          to_h { |row| [row['type'] || 'baremetal', row['count'].to_i] }
+      end
+    end
+
+    def hosts_by_compute_profile
+      merge_data('hosts_by_compute_profile') do
+        query(
+          <<-SQL
+              select max(compute_profiles.name) as name, count(hosts.id)
+              from hosts left outer join compute_profiles on compute_profile_id = compute_profiles.id
+              group by compute_profile_id
+          SQL
+        ).
+          to_h { |row| [row['name'] || 'none', row['count'].to_i] }
+      end
+    end
+
+    def bare_metal_fields
+      nics_by_type_count
+      hosts_by_managed_count
+
+      data_field('discovery_rules_count') { sql_count('discovery_rules') }
+    end
+
+    def nics_by_type_count
+      merge_data('nics_by_type_count') do
+        query(
+          <<-SQL
+              select type, count(*)
+              from nics
+              group by type
+          SQL
+        ).
+          to_h { |row| [(row['type'] || 'none').sub('Nic::', ''), row['count'].to_i] }
+      end
+    end
+
+    def hosts_by_managed_count
+      merge_data('hosts_by_managed_count') do
+        query(
+          <<-SQL
+              select managed, count(*)
+              from hosts
+              group by managed
+          SQL
+        ).
+          to_h { |row| [row['managed'] == 't' ? 'managed' : 'unmanaged', row['count'].to_i] }
+      end
+    end
+
+    def templates_fields
+      merge_data('non_default_templates_per_type') do
+        query(
+          <<-SQL
+              select type, count(*) from templates
+              where templates.default = false
+              group by type
+          SQL
+        ).
+          to_h { |row| [row['type'], row['count'].to_i] }
+      end
+    end
+  end
+end

data/definitions/reports/rbac.rb

@@ -0,0 +1,68 @@
+module Reports
+  class RBAC < ForemanMaintain::Report
+    metadata do
+      description 'Checks the RBAC use'
+    end
+
+    TAXONOMY_TYPES = %w[Organization Location].freeze
+
+    # How many users do you have in the system?
+    # How many non-admin users do you have?
+    # How many custom roles did you create and assigned to users?
+    def run
+      self.data = {}
+
+      data.merge!(user_counts)
+      data.merge!(custom_roles_counts)
+      data.merge!(taxonomy_counts)
+      data.merge!(taxonomy_ignore_type_uses)
+    end
+
+    def user_counts
+      users = sql_count("users" +
+                        " INNER JOIN auth_sources ON auth_sources.id = users.auth_source_id" +
+                        " WHERE auth_sources.name != 'Hidden'")
+
+      non_admin_users = sql_count("users" +
+        " LEFT OUTER JOIN cached_usergroup_members" +
+        "   ON cached_usergroup_members.user_id = users.id" +
+        " LEFT OUTER JOIN usergroups ON usergroups.id = cached_usergroup_members.usergroup_id" +
+        " INNER JOIN auth_sources ON auth_sources.id = users.auth_source_id" +
+        " WHERE ((users.admin = FALSE OR users.admin IS NULL)" +
+        "        AND (usergroups.admin = FALSE OR usergroups.admin IS NULL))" +
+        " AND auth_sources.name != 'Hidden'")
+
+      { 'users_count' => users, 'non_admin_users_count' => non_admin_users }
+    end
+
+    def custom_roles_counts
+      role_ids = query("SELECT id FROM roles WHERE roles.builtin != 2 AND roles.origin IS NULL")
+      roles_count = role_ids.size
+      role_ids = role_ids.flat_map(&:values)
+      assigned_count = if role_ids.empty?
+                         0
+                       else
+                         sql = "cached_user_roles" +
+                               "WHERE cached_user_roles.role_id IN (#{role_ids.join(',')})"
+                         sql_count(sql)
+                       end
+
+      { 'custom_roles_count' => roles_count, 'assigned_custom_roles_count' => assigned_count }
+    end
+
+    def taxonomy_counts
+      TAXONOMY_TYPES.to_h do |t|
+        ["#{t.downcase}s_count", sql_count("taxonomies WHERE type = '#{t}'")]
+      end
+    end
+
+    def taxonomy_ignore_type_uses
+      TAXONOMY_TYPES.to_h do |t|
+        count = sql_count("taxonomies" +
+                          " WHERE type = '#{t}'" +
+                          "   AND ignore_types IS NOT NULL")
+        ["#{t.downcase}_ignore_types_used", count.positive?]
+      end
+    end
+  end
+end

data/definitions/reports/recurring_logics.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Reports
+  class RecurringLogics < ForemanMaintain::Report
+    metadata do
+      description 'Check if recurring logics are used'
+    end
+
+    REX_TASK_GROUP_CTE = <<~SQL
+      WITH recurring_remote_execution_task_group_ids AS (
+        SELECT task_group_id
+        FROM foreman_tasks_task_groups as fttg
+        INNER JOIN foreman_tasks_task_group_members AS fttgm
+          ON fttgm.task_group_id = fttg.id
+        INNER JOIN foreman_tasks_tasks AS ftt
+          ON fttgm.task_id = ftt.id
+        WHERE
+          fttg.type = 'ForemanTasks::TaskGroups::RecurringLogicTaskGroup'
+          AND ftt.label = 'Actions::RemoteExecution::RunHostsJob'
+      ), indefinite_rex_recurring_logics AS (
+        SELECT * FROM foreman_tasks_recurring_logics AS ftrl
+        WHERE ftrl.task_group_id IN (SELECT task_group_id FROM recurring_remote_execution_task_group_ids)
+          AND (ftrl.end_time IS NULL OR ftrl.max_iteration IS NULL)
+      )
+    SQL
+
+    def run
+      self.data = {}
+      data['recurring_logics_indefinite_rex_count'] = sql_count('indefinite_rex_recurring_logics')
+      data['recurring_logics_indefinite_rex_ansible_count'] =
+        sql_count("indefinite_rex_recurring_logics WHERE purpose LIKE 'ansible-%'")
+    end
+
+    private
+
+    def sql_count(query)
+      super(query, cte: REX_TASK_GROUP_CTE)
+    end
+  end
+end

data/definitions/reports/template

@@ -0,0 +1,21 @@
+# copy the file and add the .rb suffix
+module Checks
+  module Report
+    class Template < ForemanMaintain::Report
+      metadata do
+        description 'One sentence description'
+      end
+
+      def run
+        data_field('some_value') { 'hello' }
+        merge_data('key_prefix') do
+          {
+            'key1': 'value1',
+            'key2': 'value2',
+            'nested': { 'another_key': 'another_value', 'more': 'more_value' }
+          }
+        end
+      end
+    end
+  end
+end

data/definitions/reports/virt_who.rb

@@ -0,0 +1,21 @@
+module Reports
+  class Virtwho < ForemanMaintain::Report
+    metadata do
+      description 'Check if virt-who is being used and what hypervisor types are present'
+    end
+
+    HYPERVISOR_TYPES = %w[ahv esx fakevirt hyperv kubevirt libvirtd].freeze
+
+    def run
+      self.data = {}
+      data_field('foreman_virt_who_configure_configurations_count') do
+        sql_count('foreman_virt_who_configure_configs')
+      end
+
+      HYPERVISOR_TYPES.each do |type|
+        data["foreman_virt_who_configure_#{type}_count"] =
+          sql_count("foreman_virt_who_configure_configs WHERE hypervisor_type = '#{type}'")
+      end
+    end
+  end
+end

data/definitions/reports/vmware.rb

@@ -0,0 +1,13 @@
+module Reports
+  class Vmware < ForemanMaintain::Report
+    metadata do
+      description 'Check if vmware compute resource is used'
+    end
+
+    def run
+      data_field('compute_resource_vmware_count') do
+        sql_count("compute_resources WHERE type = 'Foreman::Model::Vmware'")
+      end
+    end
+  end
+end

data/definitions/scenarios/report.rb

@@ -0,0 +1,12 @@
+module ForemanMaintain::Scenarios
+  module Report
+    class Generate < ForemanMaintain::Scenario::FilteredScenario
+      metadata do
+        description 'Generate the usage reports'
+        tags :report
+        label :generate_report
+        manual_detection
+      end
+    end
+  end
+end

data/lib/foreman_maintain/cli/report_command.rb

@@ -0,0 +1,25 @@
+module ForemanMaintain
+  module Cli
+    class ReportCommand < Base
+      extend Concerns::Finders
+
+      option '--output', 'FILE', 'Output the generate report into FILE'
+      subcommand 'generate', 'Generates the usage reports' do
+        def execute
+          scenario = run_scenario(Scenarios::Report::Generate.new({}, [:reports])).first
+
+          # description can be used too
+          report_data = scenario.steps.map(&:data).compact.reduce(&:merge).transform_keys(&:to_s)
+          report_data['version'] = 1
+          yaml = report_data.to_yaml
+          if @output
+            File.write(@output, yaml)
+          else
+            puts yaml
+          end
+          exit runner.exit_code
+        end
+      end
+    end
+  end
+end

data/lib/foreman_maintain/cli.rb

@@ -11,6 +11,7 @@ require 'foreman_maintain/cli/restore_command'
 require 'foreman_maintain/cli/maintenance_mode_command'
 require 'foreman_maintain/cli/packages_command'
 require 'foreman_maintain/cli/plugin_command'
+require 'foreman_maintain/cli/report_command'
 require 'foreman_maintain/cli/self_upgrade_command'
 require 'foreman_maintain/cli/update_command'
 
@@ -33,6 +34,7 @@ module ForemanMaintain
       subcommand 'self-upgrade', 'Perform major version self upgrade', SelfUpgradeCommand
       subcommand 'maintenance-mode', 'Control maintenance-mode for application',
         MaintenanceModeCommand
+      subcommand 'report', 'Generate usage report', ReportCommand
 
       def run(*arguments)
         logger.info("Running foreman-maintain command with arguments #{arguments.inspect}")

data/lib/foreman_maintain/detector.rb

@@ -41,6 +41,14 @@ module ForemanMaintain
       filter(@available_checks, filter_conditions)
     end
 
+    def available_reports(filter_conditions = nil)
+      unless @available_reports
+        ensure_features_detected
+        @available_reports = find_present_classes(Report)
+      end
+      filter(@available_reports, filter_conditions)
+    end
+
     def available_procedures(filter_conditions = nil)
       unless @available_procedures
         ensure_features_detected

data/lib/foreman_maintain/report.rb

@@ -0,0 +1,79 @@
+module ForemanMaintain
+  class Report < Executable
+    include Concerns::Logger
+    include Concerns::SystemHelpers
+    include Concerns::Metadata
+    include Concerns::Finders
+
+    attr_accessor :data
+
+    def query(sql)
+      feature(:foreman_database).query(sql)
+    end
+
+    def sql_count(sql, column: '*', cte: '')
+      sql_as_count("COUNT(#{column})", sql, cte: cte)
+    end
+
+    def sql_as_count(selection, sql, cte: '')
+      query = "#{cte} SELECT #{selection} AS COUNT FROM #{sql}"
+      feature(:foreman_database).query(query).first['count'].to_i
+    rescue StandardError
+      nil
+    end
+
+    def sql_setting(name)
+      sql = "SELECT value FROM settings WHERE name = '#{name}'"
+      result = feature(:foreman_database).query(sql).first
+      (result || {})['value']
+    end
+
+    def flatten(hash, prefix = '')
+      hash.each_with_object({}) do |(key, value), result|
+        new_key = "#{prefix}#{prefix.empty? ? '' : flatten_separator}#{key}"
+        if value.is_a? Hash
+          result.merge!(flatten(value, new_key))
+        else
+          result[new_key] = value
+        end
+      end
+    end
+
+    def table_exists(table)
+      sql_count("information_schema.tables WHERE table_name = '#{table}'").positive?
+    end
+
+    def data_field(field_name)
+      self.data ||= {}
+      value = yield
+      self.data[field_name] = value
+    rescue StandardError
+      nil
+    end
+
+    def merge_data(prefix)
+      self.data ||= {}
+      data_hash = yield
+      self.data.merge!(flatten(data_hash, prefix))
+    rescue StandardError
+      nil
+    end
+
+    def run
+      raise NoMethodError, 'method not implemented on abstract report classes'
+    end
+
+    # internal method called by executor
+    def __run__(execution)
+      super
+    rescue Error::Fail => e
+      set_fail(e.message)
+    rescue StandardError => e
+      set_warn(e.message)
+    end
+
+    def flatten_separator
+      '|'
+    end
+  end
+end

data/lib/foreman_maintain/scenario.rb

@@ -23,7 +23,9 @@ module ForemanMaintain
         @definition_kinds = definition_kinds
         @steps = []
         @steps += checks(filter) if definition_kinds.include?(:check)
+        @steps += reports(filter) if definition_kinds.include?(:reports)
         @steps += procedures(filter) if definition_kinds.include?(:procedure)
+
         @steps = DependencyGraph.sort(@steps)
       end
 
@@ -57,6 +59,10 @@ module ForemanMaintain
         ForemanMaintain.available_checks(filter).map(&:ensure_instance)
       end
 
+      def reports(filter)
+        ForemanMaintain.available_reports(filter).map(&:ensure_instance)
+      end
+
       def procedures(filter)
         ForemanMaintain.available_procedures(filter).map(&:ensure_instance)
       end

data/lib/foreman_maintain/utils/service/remote_db.rb

@@ -39,9 +39,8 @@ module ForemanMaintain::Utils
       end
 
       def restart
-        command_name = ForemanMaintain.command_name
         db_status(<<~MSG
-          Remote databases are not managed by #{command_name} and therefore was not restarted.
+          Remote databases are not managed and therefore no restart was performed.
         MSG
                  )
       end

data/lib/foreman_maintain/version.rb

@@ -1,3 +1,3 @@
 module ForemanMaintain
-  VERSION = '1.9.2'.freeze
+  VERSION = '1.10.0'.freeze
 end

data/lib/foreman_maintain.rb

@@ -36,6 +36,7 @@ module ForemanMaintain
   require 'foreman_maintain/feature'
   require 'foreman_maintain/executable'
   require 'foreman_maintain/check'
+  require 'foreman_maintain/report'
   require 'foreman_maintain/procedure'
   require 'foreman_maintain/scenario'
   require 'foreman_maintain/runner'
@@ -131,6 +132,10 @@ module ForemanMaintain
       detector.available_checks(*args)
     end
 
+    def available_reports(*args)
+      detector.available_reports(*args)
+    end
+
     def available_procedures(*args)
       detector.available_procedures(*args)
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: foreman_maintain
 version: !ruby/object:Gem::Version
-  version: 1.9.2
+  version: 1.10.0
 platform: ruby
 authors:
 - Ivan Nečas
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-08 00:00:00.000000000 Z
+date: 2025-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: clamp
@@ -307,11 +307,27 @@ files:
 - definitions/procedures/service/stop.rb
 - definitions/procedures/sync_plans/disable.rb
 - definitions/procedures/sync_plans/enable.rb
+- definitions/reports/compliance.rb
+- definitions/reports/external_auth_source.rb
+- definitions/reports/grouping.rb
+- definitions/reports/instance.rb
+- definitions/reports/inventory.rb
+- definitions/reports/kerberos.rb
+- definitions/reports/ldap_auth_source.rb
+- definitions/reports/oidc_usage.rb
+- definitions/reports/platform.rb
+- definitions/reports/provisioning.rb
+- definitions/reports/rbac.rb
+- definitions/reports/recurring_logics.rb
+- definitions/reports/template
+- definitions/reports/virt_who.rb
+- definitions/reports/vmware.rb
 - definitions/scenarios/backup.rb
 - definitions/scenarios/foreman_upgrade.rb
 - definitions/scenarios/maintenance_mode.rb
 - definitions/scenarios/packages.rb
 - definitions/scenarios/puppet.rb
+- definitions/scenarios/report.rb
 - definitions/scenarios/restore.rb
 - definitions/scenarios/satellite_upgrade.rb
 - definitions/scenarios/self_upgrade.rb
@@ -337,6 +353,7 @@ files:
 - lib/foreman_maintain/cli/maintenance_mode_command.rb
 - lib/foreman_maintain/cli/packages_command.rb
 - lib/foreman_maintain/cli/plugin_command.rb
+- lib/foreman_maintain/cli/report_command.rb
 - lib/foreman_maintain/cli/restore_command.rb
 - lib/foreman_maintain/cli/self_upgrade_command.rb
 - lib/foreman_maintain/cli/service_command.rb
@@ -378,6 +395,7 @@ files:
 - lib/foreman_maintain/package_manager/dnf.rb
 - lib/foreman_maintain/param.rb
 - lib/foreman_maintain/procedure.rb
+- lib/foreman_maintain/report.rb
 - lib/foreman_maintain/reporter.rb
 - lib/foreman_maintain/reporter/cli_reporter.rb
 - lib/foreman_maintain/repository_manager.rb