console messaging for config-manager

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',
+      0,
+      'Exporting access config'
+    );
     const exportData = (
       await exportConfigEntity('access', {
         envReplaceParams: options.envReplaceParams,
@@ -29,9 +39,17 @@ export async function configManagerExportAccessConfig(
       getFilePath('access-config/access.json', true),
       false
     );
+    stopProgressIndicator(indicatorId, 'Exported access config');
     return true;
   } catch (error) {
-    printError(error, `Error exporting config entity access`);
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting access config',
+        'fail'
+      );
+    }
+    printError(error, `Error exporting access configuration`);
   }
   return false;
 }
@@ -50,7 +68,7 @@ export async function configManagerImportAccessConfig(): Promise<boolean> {
     await importConfigEntities(accessConfigImportData);
     return true;
   } catch (error) {
-    printError(error, `Error importing config entity access`);
+    printError(error, `Error importing access configuration`);
   }
   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',
+      0,
+      'Exporting audit'
+    );
     const exportData = (
       await exportConfigEntity('audit', {
         envReplaceParams: options.envReplaceParams,
@@ -25,9 +35,13 @@ export async function configManagerExportAudit(
     ).idm['audit'];
 
     saveJsonToFile(exportData, getFilePath('audit/audit.json', true), false);
+    stopProgressIndicator(indicatorId, 'Exported audit');
     return true;
   } catch (error) {
-    printError(error, `Error exporting config entity audit`);
+    if (indicatorId) {
+      stopProgressIndicator(indicatorId, 'Error exporting audit', 'fail');
+    }
+    printError(error, `Error exporting audit configuration`);
   }
   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,7 +24,13 @@ const { getFilePath, saveJsonToFile } = frodo.utils;
 export async function configManagerExportAuthentication(
   realm?: string
 ): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting authentication settings'
+    );
     if (realm && realm !== '__default__realm__') {
       const exportData = await _readAuthenticationSettings(false);
       const fileName = `realms/${state.getRealm()}/realm-config/authentication.json`;
@@ -34,6 +45,10 @@ export async function configManagerExportAuthentication(
           continue;
 
         state.setRealm(realmName);
+        updateProgressIndicator(
+          indicatorId,
+          `Exporting authentication settings (${realmName})`
+        );
         const exportData = await _readAuthenticationSettings(false);
         const fileName = `realms/${realmName}/realm-config/authentication.json`;
         saveJsonToFile(
@@ -45,9 +60,17 @@ export async function configManagerExportAuthentication(
       }
     }
 
+    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 authentication settings`);
   }
   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;
@@ -74,7 +80,13 @@ export async function configManagerExportAuthzPolicySet(
   criteria: ByName | BySkeleton,
   configFile: string = null
 ): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting authorization policies'
+    );
     // policySet.readPolicySet() will fail if the provided policy-set doesn't exist in the current-state realm
     const ps: PolicySetSkeleton =
       'ps' in criteria
@@ -128,6 +140,7 @@ export async function configManagerExportAuthzPolicySet(
       await policy.readPoliciesByPolicySet(ps.name);
     if (allPoliciesOfThis.length !== 0) {
       for (const p of allPoliciesOfThis) {
+        updateProgressIndicator(indicatorId, `Exporting policy ${p.name}`);
         await exportPolicy(p);
       }
     } else {
@@ -136,8 +149,16 @@ export async function configManagerExportAuthzPolicySet(
       );
     }
 
+    stopProgressIndicator(indicatorId, 'Exported authorization policies');
     return true;
   } catch (error) {
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting authorization policies',
+        'fail'
+      );
+    }
     printError(error);
     return false;
   }

src/configManagerOps/FrConfigConnectorDefinitionsOps.ts

@@ -2,7 +2,12 @@ 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,
+  verboseMessage,
+} from '../utils/Console';
 
 const { connector } = frodo.idm;
 const { getFilePath, saveJsonToFile } = frodo.utils;
@@ -64,15 +69,29 @@ export async function configManagerExportConnectorDefinition(
  * @returns
  */
 export async function configManagerExportConnectorDefinitionsAll(): Promise<boolean> {
+  let indicatorId: string | undefined;
   try {
+    indicatorId = createProgressIndicator(
+      'indeterminate',
+      0,
+      'Exporting connector definitions'
+    );
     const cs: ConnectorSkeleton[] = await connector.readConnectors();
     for (const c of cs) {
       if (c._id.includes('provisioner.openicf/')) {
         configManagerExportConnectorDefinition({ c: c });
       }
     }
+    stopProgressIndicator(indicatorId, 'Exported connector definitions');
     return true;
   } catch (error) {
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting connector definitions',
+        'fail'
+      );
+    }
     printError(error);
   }
 }
@@ -113,7 +132,7 @@ export async function configManagerImportConnectors(
 
     return true;
   } catch (error) {
-    printError(error, `Error exporting mappings to files`);
+    printError(error, `Error importing connectors `);
   }
   return false;
 }

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,15 +51,34 @@ 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 fileDir = `sync/mappings`;
-    for (const mapping of Object.values(exportData.mappings)) {
+    const mappings = Object.values(exportData.mappings);
+    indicatorId = createProgressIndicator(
+      'determinate',
+      mappings.length,
+      'Exporting connector mappings'
+    );
+    for (const mapping of mappings) {
+      updateProgressIndicator(
+        indicatorId,
+        `Exporting connector mapping ${mapping.name}`
+      );
       processMappings(mapping, `${fileDir}/${mapping.name}`, mapping.name);
     }
+    stopProgressIndicator(indicatorId, `Exported ${mappings.length} mappings`);
     return true;
   } catch (error) {
-    printError(error, `Error exporting mappings to files`);
+    if (indicatorId) {
+      stopProgressIndicator(
+        indicatorId,
+        'Error exporting connector mappings',
+        'fail'
+      );
+    }
+    printError(error, `Error exporting connector mappings`);
   }
   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',
+      0,
+      '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;
 }
@@ -37,7 +55,7 @@ export async function configManagerImportCookieDomains(): Promise<boolean> {
     await updateCookieDomains(importData);
     return true;
   } catch (error) {
-    printError(error, `Error importing custom domains`);
+    printError(error, `Error importing cookie domains`);
   }
   return false;
 }