filter out root realm for authz policy pulling

src/cli/config-manager/config-manager-pull/config-manager-pull-authz-policies.ts

@@ -157,7 +157,7 @@ export default function setup() {
 
         if (!outcome) {
           printMessage(
-            `Failed to export one or more authorization policy sets. ${options.verbose ? '' : 'Check --verbose for me details.'}`
+            `Failed to export one or more authorization policy sets. ${options.verbose ? '' : 'Check --verbose for more details.'}`
           );
           process.exitCode = 1;
         }

src/configManagerOps/FrConfigAccessConfigOps.ts

@@ -2,7 +2,11 @@ import { frodo } from '@rockcarver/frodo-lib';
 import fs from 'fs';
 
 import { getIdmImportExportOptions } from '../ops/IdmOps';
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+} from '../utils/Console';
 
 const { exportConfigEntity, importConfigEntities } = frodo.idm.config;
 const { getFilePath, saveJsonToFile } = frodo.utils;
@@ -15,8 +19,14 @@ const { getFilePath, saveJsonToFile } = frodo.utils;
 export async function configManagerExportAccessConfig(
   envFile?: string
 ): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
     const options = getIdmImportExportOptions(undefined, envFile);
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      undefined,
+      'Exporting access config'
+    );
     const exportData = (
       await exportConfigEntity('access', {
         envReplaceParams: options.envReplaceParams,
@@ -29,8 +39,17 @@ export async function configManagerExportAccessConfig(
       getFilePath('access-config/access.json', true),
       false
     );
+
+    stopProgressIndicator(indicatorId, 'Exported access config');
     return true;
   } catch (error) {
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting access config',
+        'fail'
+      );
+    }
     printError(error, `Error exporting config entity access`);
   }
   return false;

src/configManagerOps/FrConfigAuditOps.ts

@@ -2,7 +2,11 @@ import { frodo } from '@rockcarver/frodo-lib';
 import fs from 'fs';
 
 import { getIdmImportExportOptions } from '../ops/IdmOps';
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+} from '../utils/Console';
 
 const { exportConfigEntity, importConfigEntities } = frodo.idm.config;
 const { getFilePath, saveJsonToFile } = frodo.utils;
@@ -15,8 +19,14 @@ const { getFilePath, saveJsonToFile } = frodo.utils;
 export async function configManagerExportAudit(
   envFile?: string
 ): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
     const options = getIdmImportExportOptions(undefined, envFile);
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      undefined,
+      'Exporting audit'
+    );
     const exportData = (
       await exportConfigEntity('audit', {
         envReplaceParams: options.envReplaceParams,
@@ -25,8 +35,13 @@ export async function configManagerExportAudit(
     ).idm['audit'];
 
     saveJsonToFile(exportData, getFilePath('audit/audit.json', true), false);
+
+    stopProgressIndicator(indicatorId, 'Exported audit');
     return true;
   } catch (error) {
+    if (indicatorId) {
+      stopProgressIndicator(indicatorId, 'Error exporting audit', 'fail');
+    }
     printError(error, `Error exporting config entity audit`);
   }
   return false;

src/configManagerOps/FrConfigAuthenticationOps.ts

@@ -2,7 +2,12 @@ import { frodo, state } from '@rockcarver/frodo-lib';
 import { AuthenticationSettingsExportInterface } from '@rockcarver/frodo-lib/types/ops/AuthenticationSettingsOps';
 import fs from 'fs';
 
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+  updateProgressIndicator,
+} from '../utils/Console';
 import { realmList } from '../utils/FrConfig';
 
 const {
@@ -19,19 +24,40 @@ const { getFilePath, saveJsonToFile } = frodo.utils;
 export async function configManagerExportAuthentication(
   realm?: string
 ): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
     if (realm && realm !== '__default__realm__') {
+      indicatorId = createProgressIndicator(
+        'indeterminate',
+        0,
+        'Exporting authentication settings'
+      );
       const exportData = await _readAuthenticationSettings(false);
       const fileName = `realms/${state.getRealm()}/realm-config/authentication.json`;
       saveJsonToFile(exportData, getFilePath(`${fileName}`, true), false, true);
+      stopProgressIndicator(indicatorId, 'Exported authentication settings');
     } else {
-      for (const realmName of await realmList()) {
+      const realmNames = (await realmList()).filter((realmName) => {
         if (
           realmName === '/' &&
           state.getDeploymentType() ===
             frodo.utils.constants.CLOUD_DEPLOYMENT_TYPE_KEY
         )
-          continue;
+          return false;
+        return true;
+      });
+
+      indicatorId = createProgressIndicator(
+        'determinate',
+        realmNames.length,
+        'Exporting authentication settings'
+      );
+
+      for (const realmName of realmNames) {
+        updateProgressIndicator(
+          indicatorId,
+          `Exporting authentication settings (${realmName})`
+        );
 
         state.setRealm(realmName);
         const exportData = await _readAuthenticationSettings(false);
@@ -43,11 +69,19 @@ export async function configManagerExportAuthentication(
           true
         );
       }
+      stopProgressIndicator(indicatorId, 'Exported authentication settings');
     }
 
     return true;
   } catch (error) {
-    printError(error, `Error exporting config entity ui-configuration`);
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting authentication settings',
+        'fail'
+      );
+    }
+    printError(error, `Error exporting config entity authentication`);
   }
   return false;
 }

src/configManagerOps/FrConfigAuthzPoliciesOps.ts

@@ -4,7 +4,13 @@ import { PolicySetSkeleton } from '@rockcarver/frodo-lib/types/api/PolicySetApi'
 import { ResourceTypeSkeleton } from '@rockcarver/frodo-lib/types/api/ResourceTypesApi';
 import { readFile } from 'fs/promises';
 
-import { printError, verboseMessage } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+  updateProgressIndicator,
+  verboseMessage,
+} from '../utils/Console';
 
 const { getFilePath, saveJsonToFile } = frodo.utils;
 const { policySet, policy, resourceType } = frodo.authz;
@@ -127,9 +133,16 @@ export async function configManagerExportAuthzPolicySet(
     const allPoliciesOfThis: PolicySkeleton[] =
       await policy.readPoliciesByPolicySet(ps.name);
     if (allPoliciesOfThis.length !== 0) {
+      const indicatorId = createProgressIndicator(
+        'determinate',
+        allPoliciesOfThis.length,
+        `Exporting policies (${ps.name})`
+      );
       for (const p of allPoliciesOfThis) {
+        updateProgressIndicator(indicatorId, `Exporting policy ${p.name}`);
         await exportPolicy(p);
       }
+      stopProgressIndicator(indicatorId, 'Exported authorization policies');
     } else {
       verboseMessage(
         `    There are no policies in the policy-set "${ps.name}"`
@@ -216,6 +229,12 @@ export async function configManagerExportAuthzPolicySetsRealm(): Promise<boolean
 export async function configManagerExportAuthzPoliciesAll(): Promise<boolean> {
   try {
     for (const realm of await readRealms()) {
+      if (
+        realm.name === '/' &&
+        state.getDeploymentType() ===
+          frodo.utils.constants.CLOUD_DEPLOYMENT_TYPE_KEY
+      )
+        continue;
       // set realm of state because policySet.readPolicySets() uses state to check realm
       state.setRealm(realm.name);
       if (!(await configManagerExportAuthzPolicySetsRealm())) {

src/configManagerOps/FrConfigConnectorDefinitionsOps.ts

@@ -2,7 +2,13 @@ import { frodo } from '@rockcarver/frodo-lib';
 import { ConnectorSkeleton } from '@rockcarver/frodo-lib/types/ops/ConnectorOps';
 import fs from 'fs';
 
-import { printError, verboseMessage } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+  updateProgressIndicator,
+  verboseMessage,
+} from '../utils/Console';
 
 const { connector } = frodo.idm;
 const { getFilePath, saveJsonToFile } = frodo.utils;
@@ -64,15 +70,37 @@ export async function configManagerExportConnectorDefinition(
  * @returns
  */
 export async function configManagerExportConnectorDefinitionsAll(): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
     const cs: ConnectorSkeleton[] = await connector.readConnectors();
+    indicatorId = createProgressIndicator(
+      'determinate',
+      cs.length,
+      'Exporting connector definitions'
+    );
     for (const c of cs) {
+      updateProgressIndicator(
+        indicatorId,
+        `Exporting connector definition ${c._id}`
+      );
       if (c._id.includes('provisioner.openicf/')) {
-        configManagerExportConnectorDefinition({ c: c });
+        await configManagerExportConnectorDefinition({ c: c });
       }
     }
+
+    stopProgressIndicator(
+      indicatorId,
+      `Exported ${cs.length} connector definitions`
+    );
     return true;
   } catch (error) {
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting connector definitions',
+        'fail'
+      );
+    }
     printError(error);
   }
 }

src/configManagerOps/FrConfigConnectorMappingOps.ts

@@ -1,7 +1,12 @@
 import { frodo } from '@rockcarver/frodo-lib';
 
 import { extractFrConfigDataToFile } from '../utils/Config';
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+  updateProgressIndicator,
+} from '../utils/Console';
 
 const { getFilePath, saveJsonToFile } = frodo.utils;
 const { readConfigEntity } = frodo.idm.config;
@@ -46,14 +51,33 @@ function processMappings(mapping, targetDir, name) {
  * @returns {Promise<boolean>} true if successful, false otherwise
  */
 export async function configManagerExportMappings(): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
     const exportData = await readConfigEntity('sync');
+    const allMappings = Object.values(exportData.mappings);
     const fileDir = `sync/mappings`;
-    for (const mapping of Object.values(exportData.mappings)) {
-      processMappings(mapping, `${fileDir}/${mapping.name}`, mapping.name);
+    indicatorId = createProgressIndicator(
+      'determinate',
+      allMappings.length,
+      'Exporting mappings'
+    );
+    for (const mapping of allMappings) {
+      const m = mapping as { _id?: string; name: string };
+      updateProgressIndicator(
+        indicatorId,
+        `Exporting mapping ${m._id ?? m.name}`
+      );
+      processMappings(m, `${fileDir}/${m.name}`, m.name);
     }
+    stopProgressIndicator(
+      indicatorId,
+      `${allMappings.length} mappings exported.`
+    );
     return true;
   } catch (error) {
+    if (indicatorId) {
+      stopProgressIndicator(indicatorId, `Error exporting mappings`, 'fail');
+    }
     printError(error, `Error exporting mappings to files`);
   }
   return false;

src/configManagerOps/FrConfigCookieDomainsOps.ts

@@ -1,7 +1,11 @@
 import { frodo } from '@rockcarver/frodo-lib';
 import fs from 'fs';
 
-import { printError } from '../utils/Console';
+import {
+  createProgressIndicator,
+  printError,
+  stopProgressIndicator,
+} from '../utils/Console';
 
 const { getFilePath, saveJsonToFile } = frodo.utils;
 const { readCookieDomains, updateCookieDomains } = frodo.cloud.env;
@@ -11,16 +15,30 @@ const { readCookieDomains, updateCookieDomains } = frodo.cloud.env;
  * @return {Promise<boolean>} a promise that resolves to true if successful, false otherwise
  */
 export async function configManagerExportCookieDomains(): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      undefined,
+      'Exporting cookie domains'
+    );
     const exportData = await readCookieDomains();
     saveJsonToFile(
       exportData,
       getFilePath('cookie-domains/cookie-domains.json', true),
       false
     );
+    stopProgressIndicator(indicatorId, 'Exported cookie domains');
     return true;
   } catch (error) {
-    printError(error, `Error exporting custom domains`);
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting cookie domains',
+        'fail'
+      );
+    }
+    printError(error, `Error exporting cookie domains`);
   }
   return false;
 }