@rockcarver/frodo-lib 0.11.0

package/src/ops/ScriptOps.js

@@ -0,0 +1,211 @@
+import fs from 'fs';
+import { v4 as uuidv4 } from 'uuid';
+import { applyNameCollisionPolicy } from './utils/OpsUtils.js';
+import {
+  createProgressBar,
+  createTable,
+  printMessage,
+  stopProgressBar,
+  updateProgressBar,
+} from './utils/Console.js';
+import { getScriptByName, getScripts, putScript } from '../api/ScriptApi.js';
+import wordwrap from './utils/Wordwrap.js';
+import {
+  convertBase64TextToArray,
+  convertTextArrayToBase64,
+  getTypedFilename,
+  saveToFile,
+  titleCase,
+  validateImport,
+} from './utils/ExportImportUtils.js';
+import storage from '../storage/SessionStorage.js';
+
+/**
+ * List scripts
+ */
+export async function listScripts(long = false) {
+  try {
+    const scripts = (await getScripts()).data.result;
+    scripts.sort((a, b) => a.name.localeCompare(b.name));
+    if (long) {
+      const table = createTable([
+        'Name',
+        'UUID',
+        'Language',
+        'Context',
+        'Description',
+      ]);
+      const langMap = { JAVASCRIPT: 'JS', GROOVY: 'Groovy' };
+      scripts.forEach((script) => {
+        table.push([
+          wordwrap(script.name, 25, '  '),
+          script._id,
+          langMap[script.language],
+          wordwrap(titleCase(script.context.split('_').join(' ')), 25),
+          wordwrap(script.description, 30),
+        ]);
+      });
+      printMessage(table.toString(), 'data');
+    } else {
+      scripts.forEach((script) => {
+        printMessage(`${script.name}`, 'data');
+      });
+    }
+  } catch (error) {
+    printMessage(`Error listing scripts - ${error}`, 'error');
+  }
+}
+
+/**
+ * Export script to file
+ * @param {String} name script name
+ * @param {String} file file name
+ */
+export async function exportScriptByName(name, file) {
+  let fileName = getTypedFilename(name, 'script');
+  if (file) {
+    fileName = file;
+  }
+  const scriptData = (await getScriptByName(name)).data.result;
+  if (scriptData.length > 1) {
+    printMessage(`Multiple scripts with name ${name} found...`, 'error');
+  }
+  scriptData.forEach((element) => {
+    const scriptTextArray = convertBase64TextToArray(element.script);
+    // eslint-disable-next-line no-param-reassign
+    element.script = scriptTextArray;
+  });
+  saveToFile('script', scriptData, '_id', fileName);
+}
+
+/**
+ * Export all scripts to single file
+ * @param {String} file file name
+ */
+export async function exportScriptsToFile(file) {
+  let fileName = getTypedFilename(
+    `all${storage.session.getRealm()}Scripts`,
+    'script'
+  );
+  if (file) {
+    fileName = file;
+  }
+  const scriptList = (await getScripts()).data.result;
+  const allScriptsData = [];
+  createProgressBar(scriptList.length, 'Exporting script');
+  for (const item of scriptList) {
+    updateProgressBar(`Reading script ${item.name}`);
+    // eslint-disable-next-line no-await-in-loop
+    const scriptData = (await getScriptByName(item.name)).data.result;
+    scriptData.forEach((element) => {
+      const scriptTextArray = convertBase64TextToArray(element.script);
+      // eslint-disable-next-line no-param-reassign
+      element.script = scriptTextArray;
+      allScriptsData.push(element);
+    });
+  }
+  stopProgressBar('Done');
+  saveToFile('script', allScriptsData, '_id', fileName);
+}
+
+/**
+ * Export all scripts to individual files
+ */
+export async function exportScriptsToFiles() {
+  const scriptList = (await getScripts()).data.result;
+  createProgressBar(scriptList.length, 'Exporting script');
+  for (const item of scriptList) {
+    updateProgressBar(`Reading script ${item.name}`);
+    // eslint-disable-next-line no-await-in-loop
+    const scriptData = (await getScriptByName(item.name)).data.result;
+    scriptData.forEach((element) => {
+      const scriptTextArray = convertBase64TextToArray(element.script);
+      // eslint-disable-next-line no-param-reassign
+      element.script = scriptTextArray;
+    });
+    const fileName = getTypedFilename(item.name, 'script');
+    saveToFile('script', scriptData, '_id', fileName);
+  }
+  stopProgressBar('Done');
+}
+
+/**
+ * Import script
+ * @param {String} id script uuid
+ * @param {Object} data script object
+ * @returns {Object} a status object
+ */
+export async function createOrUpdateScript(id, data) {
+  try {
+    await putScript(id, data);
+    return { error: false, name: data.name };
+  } catch (e) {
+    if (e.response.status === 409) {
+      printMessage(
+        `createOrUpdateScript WARNING: script with name ${data.name} already exists, using renaming policy... <name> => <name - imported (n)>`,
+        'warn'
+      );
+      const newName = applyNameCollisionPolicy(data.name);
+      // console.log(newName);
+      printMessage(`Trying to save script as ${newName}`, 'warn');
+      // eslint-disable-next-line no-param-reassign
+      data.name = newName;
+      await createOrUpdateScript(id, data);
+      return { error: false, name: data.name };
+    }
+    printMessage(
+      `createOrUpdateScript ERROR: put script error, script ${id} - ${e.message}`,
+      'error'
+    );
+    return { error: true, name: data.name };
+  }
+}
+
+export async function importScriptsFromFile(name, file, reUuid = false) {
+  fs.readFile(file, 'utf8', (err, data) => {
+    if (err) throw err;
+    const scriptData = JSON.parse(data);
+    if (validateImport(scriptData.meta)) {
+      createProgressBar(Object.keys(scriptData.script).length, '');
+      for (const existingId in scriptData.script) {
+        if ({}.hasOwnProperty.call(scriptData.script, existingId)) {
+          let newId = existingId;
+          // console.log(id);
+          const encodedScript = convertTextArrayToBase64(
+            scriptData.script[existingId].script
+          );
+          scriptData.script[existingId].script = encodedScript;
+          if (reUuid) {
+            newId = uuidv4();
+            // printMessage(
+            //   `Re-uuid-ing script ${scriptData.script[existingId].name} ${existingId} => ${newId}...`
+            // );
+            scriptData.script[existingId]._id = newId;
+          }
+          if (name) {
+            // printMessage(
+            //   `Renaming script ${scriptData.script[existingId].name} => ${options.script}...`
+            // );
+            scriptData.script[existingId].name = name;
+          }
+          updateProgressBar(`Importing ${scriptData.script[existingId].name}`);
+          // console.log(scriptData.script[id]);
+          createOrUpdateScript(newId, scriptData.script[existingId]).then(
+            (result) => {
+              if (result == null)
+                printMessage(
+                  `Error importing ${scriptData.script[existingId].name}`,
+                  'error'
+                );
+            }
+          );
+          if (name) break;
+        }
+      }
+      stopProgressBar('Done');
+      // printMessage('Done');
+    } else {
+      printMessage('Import validation failed...', 'error');
+    }
+  });
+}

package/src/ops/SecretsOps.js

@@ -0,0 +1,288 @@
+import {
+  createKeyValueTable,
+  createProgressBar,
+  createTable,
+  failSpinner,
+  printMessage,
+  showSpinner,
+  stopProgressBar,
+  succeedSpinner,
+  updateProgressBar,
+} from './utils/Console.js';
+import {
+  createNewVersionOfSecret,
+  deleteSecret,
+  deleteVersionOfSecret,
+  getSecret,
+  getSecrets,
+  getSecretVersions,
+  putSecret,
+  setSecretDescription,
+  setStatusOfVersionOfSecret,
+} from '../api/SecretsApi.js';
+import wordwrap from './utils/Wordwrap.js';
+import { resolveUserName } from './ManagedObjectOps.js';
+
+/**
+ * List secrets
+ * @param {boolean} long Long version, all the fields
+ */
+export async function listSecrets(long) {
+  let secrets = [];
+  try {
+    secrets = (await getSecrets()).data.result;
+  } catch (error) {
+    printMessage(`${error.message}`, 'error');
+    printMessage(error.response.data, 'error');
+  }
+  if (long) {
+    const table = createTable([
+      'Id'.brightCyan,
+      { hAlign: 'right', content: 'Active\nVersion'.brightCyan },
+      { hAlign: 'right', content: 'Loaded\nVersion'.brightCyan },
+      'Status'.brightCyan,
+      'Description'.brightCyan,
+      'Modifier'.brightCyan,
+      'Modified'.brightCyan,
+    ]);
+    secrets.sort((a, b) => a._id.localeCompare(b._id));
+    for (const secret of secrets) {
+      table.push([
+        secret._id,
+        { hAlign: 'right', content: secret.activeVersion },
+        { hAlign: 'right', content: secret.loadedVersion },
+        secret.loaded ? 'loaded'.brightGreen : 'unloaded'.brightRed,
+        wordwrap(secret.description, 40),
+        // eslint-disable-next-line no-await-in-loop
+        await resolveUserName('teammember', secret.lastChangedBy),
+        new Date(secret.lastChangeDate).toLocaleString(),
+      ]);
+    }
+    printMessage(table.toString());
+  } else {
+    secrets.forEach((secret) => {
+      printMessage(secret._id);
+    });
+  }
+}
+
+/**
+ * Create secret
+ * @param {String} id secret id
+ * @param {String} value secret value
+ * @param {String} description secret description
+ * @param {String} encoding secret encoding
+ * @param {boolean} useInPlaceholders use secret in placeholders
+ */
+export async function createSecret(
+  id,
+  value,
+  description,
+  encoding,
+  useInPlaceholders
+) {
+  showSpinner(`Creating secret ${id}...`);
+  try {
+    await putSecret(id, value, description, encoding, useInPlaceholders);
+    succeedSpinner(`Created secret ${id}`);
+  } catch (error) {
+    failSpinner(
+      `Error: ${error.response.data.code} - ${error.response.data.message}`
+    );
+  }
+}
+
+/**
+ * Set description of secret
+ * @param {String} secretId secret id
+ * @param {String} description secret description
+ */
+export async function setDescriptionOfSecret(secretId, description) {
+  showSpinner(`Setting description of secret ${secretId}...`);
+  try {
+    await setSecretDescription(secretId, description);
+    succeedSpinner(`Set description of secret ${secretId}`);
+  } catch (error) {
+    failSpinner(
+      `Error: ${error.response.data.code} - ${error.response.data.message}`
+    );
+  }
+}
+
+/**
+ * Delete a secret
+ * @param {String} secretId secret id
+ */
+export async function deleteSecretCmd(secretId) {
+  showSpinner(`Deleting secret ${secretId}...`);
+  try {
+    await deleteSecret(secretId);
+    succeedSpinner(`Deleted secret ${secretId}`);
+  } catch (error) {
+    failSpinner(
+      `Error: ${error.response.data.code} - ${error.response.data.message}`
+    );
+  }
+}
+
+/**
+ * Delete all secrets
+ */
+export async function deleteSecretsCmd() {
+  try {
+    const secrets = (await getSecrets()).data.result;
+    createProgressBar(secrets.length, `Deleting secrets...`);
+    for (const secret of secrets) {
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        await deleteSecret(secret._id);
+        updateProgressBar(`Deleted secret ${secret._id}`);
+      } catch (error) {
+        printMessage(
+          `Error: ${error.response.data.code} - ${error.response.data.message}`,
+          'error'
+        );
+      }
+    }
+    stopProgressBar(`Secrets deleted.`);
+  } catch (error) {
+    printMessage(
+      `Error: ${error.response.data.code} - ${error.response.data.message}`,
+      'error'
+    );
+  }
+}
+
+/**
+ * List all the versions of the secret
+ * @param {String} secretId secret id
+ */
+export async function listSecretVersionsCmd(secretId) {
+  let versions = [];
+  try {
+    versions = (await getSecretVersions(secretId)).data;
+  } catch (error) {
+    printMessage(`${error.message}`, 'error');
+    printMessage(error.response.data, 'error');
+  }
+  const table = createTable([
+    { hAlign: 'right', content: 'Version'.brightCyan },
+    'Status'.brightCyan,
+    'Loaded'.brightCyan,
+    'Created'.brightCyan,
+  ]);
+  // versions.sort((a, b) => a._id.localeCompare(b._id));
+  const statusMap = {
+    ENABLED: 'active'.brightGreen,
+    DISABLED: 'inactive'.brightRed,
+    DESTROYED: 'deleted'.brightRed,
+  };
+  versions.forEach((version) => {
+    table.push([
+      { hAlign: 'right', content: version.version },
+      statusMap[version.status],
+      version.loaded ? 'loaded'.brightGreen : 'unloaded'.brightRed,
+      new Date(version.createDate).toLocaleString(),
+    ]);
+  });
+  printMessage(table.toString());
+}
+
+/**
+ * Describe a secret
+ * @param {String} secretId Secret id
+ */
+export async function describeSecret(secretId) {
+  const secret = (await getSecret(secretId)).data;
+  const table = createKeyValueTable();
+  table.push(['Name'.brightCyan, secret._id]);
+  table.push(['Active Version'.brightCyan, secret.activeVersion]);
+  table.push(['Loaded Version'.brightCyan, secret.loadedVersion]);
+  table.push([
+    'Status'.brightCyan,
+    secret.loaded ? 'loaded'.brightGreen : 'unloaded'.brightRed,
+  ]);
+  table.push(['Description'.brightCyan, wordwrap(secret.description, 60)]);
+  table.push([
+    'Modified'.brightCyan,
+    new Date(secret.lastChangeDate).toLocaleString(),
+  ]);
+  table.push([
+    'Modifier'.brightCyan,
+    await resolveUserName('teammember', secret.lastChangedBy),
+  ]);
+  table.push(['Modifier UUID'.brightCyan, secret.lastChangedBy]);
+  table.push(['Encoding'.brightCyan, secret.encoding]);
+  table.push(['Use In Placeholders'.brightCyan, secret.useInPlaceholders]);
+  printMessage(table.toString());
+  printMessage('\nSecret Versions:');
+  await listSecretVersionsCmd(secretId);
+}
+
+/**
+ * Create new version of secret
+ * @param {String} secretId secret id
+ * @param {String} value secret value
+ */
+export async function createNewVersionOfSecretCmd(secretId, value) {
+  showSpinner(`Creating new version of secret ${secretId}...`);
+  try {
+    const version = (await createNewVersionOfSecret(secretId, value)).data;
+    succeedSpinner(`Created version ${version.version} of secret ${secretId}`);
+  } catch (error) {
+    failSpinner(
+      `Error: ${error.response.data.code} - ${error.response.data.message}`
+    );
+  }
+}
+
+/**
+ * Activate a version of a secret
+ * @param {String} secretId secret id
+ * @param {Number} version version of secret
+ */
+export async function activateVersionOfSecret(secretId, version) {
+  showSpinner(`Activating version ${version} of secret ${secretId}...`);
+  try {
+    await setStatusOfVersionOfSecret(secretId, version, 'ENABLED');
+    succeedSpinner(`Activated version ${version} of secret ${secretId}`);
+  } catch (error) {
+    failSpinner(
+      `Error: ${error.response.data.code} - ${error.response.data.message}`
+    );
+  }
+}
+
+/**
+ * Deactivate a version of a secret
+ * @param {String} secretId secret id
+ * @param {Number} version version of secret
+ */
+export async function deactivateVersionOfSecret(secretId, version) {
+  showSpinner(`Deactivating version ${version} of secret ${secretId}...`);
+  try {
+    await setStatusOfVersionOfSecret(secretId, version, 'DISABLED');
+    succeedSpinner(`Deactivated version ${version} of secret ${secretId}`);
+  } catch (error) {
+    failSpinner(
+      `Error: ${error.response.data.code} - ${error.response.data.message}`
+    );
+  }
+}
+
+/**
+ * Delete version of secret
+ * @param {String} secretId secret id
+ * @param {Number} version version of secret
+ */
+export async function deleteVersionOfSecretCmd(secretId, version) {
+  showSpinner(`Deleting version ${version} of secret ${secretId}...`);
+  try {
+    await deleteVersionOfSecret(secretId, version);
+    succeedSpinner(`Deleted version ${version} of secret ${secretId}`);
+  } catch (error) {
+    failSpinner(
+      `Error: ${error.response.data.code} - ${error.response.data.message}`
+    );
+  }
+}

package/src/ops/StartupOps.js

@@ -0,0 +1,114 @@
+import yesno from 'yesno';
+import {
+  createTable,
+  failSpinner,
+  printMessage,
+  showSpinner,
+  spinSpinner,
+  succeedSpinner,
+} from './utils/Console.js';
+import { getSecrets } from '../api/SecretsApi.js';
+import { getStatus, initiateRestart } from '../api/StartupApi.js';
+import { resolveUserName } from './ManagedObjectOps.js';
+import { getVariables } from '../api/VariablesApi.js';
+
+export async function checkForUpdates() {
+  showSpinner(`Checking for updates to apply...`);
+  const updates = createTable([
+    'Type'.brightCyan,
+    'Name'.brightCyan,
+    'Modified'.brightCyan,
+    'Modifier'.brightCyan,
+  ]);
+  let secrets = [];
+  let variables = [];
+  try {
+    secrets = (await getSecrets()).data.result;
+    for (const secret of secrets) {
+      if (!secret.loaded) {
+        updates.push([
+          'secret',
+          secret._id,
+          new Date(secret.lastChangeDate).toLocaleString(),
+          // eslint-disable-next-line no-await-in-loop
+          await resolveUserName('teammember', secret.lastChangedBy),
+        ]);
+      }
+    }
+    variables = (await getVariables()).data.result;
+    for (const variable of variables) {
+      if (!variable.loaded) {
+        updates.push([
+          'variable',
+          variable._id,
+          new Date(variable.lastChangeDate).toLocaleString(),
+          // eslint-disable-next-line no-await-in-loop
+          await resolveUserName('teammember', variable.lastChangedBy),
+        ]);
+      }
+    }
+  } catch (error) {
+    failSpinner(
+      `Error: ${error.response.data.code} - ${error.response.data.message}`
+    );
+  }
+  if (updates.length > 0) {
+    succeedSpinner(`${updates.length} update(s) need to be applied`);
+    printMessage(updates.toString(), 'data');
+    return true;
+  }
+  succeedSpinner(`No updates need to be applied`);
+  return false;
+}
+
+export async function applyUpdates(force, wait, yes) {
+  if ((await checkForUpdates()) || force) {
+    const ok =
+      yes ||
+      (await yesno({
+        question: `\nChanges may take up to 10 minutes to propagate, during which time you will not be able to make further updates.\n\nApply updates? (y|n):`,
+      }));
+    if (ok) {
+      showSpinner(`Applying updates...`);
+      try {
+        await initiateRestart();
+        if (wait) {
+          const timeout = 10 * 60 * 1000;
+          const start = new Date().getTime();
+          let runtime = 0;
+          // eslint-disable-next-line no-await-in-loop
+          let status = (await getStatus()).data.restartStatus;
+          while (status !== 'ready' && start + timeout > new Date().getTime()) {
+            // eslint-disable-next-line no-await-in-loop, no-promise-executor-return
+            await new Promise((resolve) => setTimeout(resolve, 5000));
+            // eslint-disable-next-line no-await-in-loop
+            status = (await getStatus()).data.restartStatus;
+            runtime = new Date().getTime() - start;
+            spinSpinner(`${status} (${Math.round(runtime / 1000)}s)`);
+          }
+          if (runtime < timeout) {
+            succeedSpinner(
+              `Updates applied in ${Math.round(
+                runtime / 1000
+              )}s with final status: ${status}`
+            );
+          } else {
+            succeedSpinner(
+              `Updates timed out after ${Math.round(
+                runtime / 1000
+              )}s with final status: ${status}`
+            );
+          }
+        } else {
+          succeedSpinner(
+            `Updates are being applied. Changes may take up to 10 minutes to propagate, during which time you will not be able to make further updates.`
+          );
+        }
+      } catch (error) {
+        failSpinner(
+          `Error: ${error.response.data.code} - ${error.response.data.message}`
+        );
+      }
+    }
+  }
+}