@itentialopensource/adapter-aruba_airwave 0.2.1 → 0.3.0

package/utils/methodDocumentor.js

@@ -0,0 +1,273 @@
+/* eslint global-require:warn */
+/* eslint import/no-dynamic-require:warn */
+/* eslint no-param-reassign:warn */
+
+const fs = require('fs-extra');
+const acorn = require('acorn');
+
+// Getting the base directory:
+let adaptdir = __dirname;
+if (adaptdir.endsWith('/utils')) {
+  adaptdir = adaptdir.substring(0, adaptdir.length - 6);
+}
+
+function createObjectForFunction(
+  funcName,
+  funcArgs,
+  entityPath,
+  description,
+  workflow
+) {
+  const funcObject = {};
+  // if the entity path is not set, then the object is not created.
+  if (entityPath !== undefined) {
+    funcObject.method_signature = `${funcName}(${funcArgs.join(', ')})`;
+    funcObject.path = entityPath;
+    if (description === undefined) {
+      funcObject.description = '';
+      funcObject.workflow = 'No';
+    } else {
+      funcObject.description = description;
+      funcObject.workflow = workflow;
+    }
+  }
+  return funcObject;
+}
+
+function getPathFromEntity(entity, funcName) {
+  let epath;
+  if (entity === undefined || entity === '.generic') {
+    epath = undefined;
+  } else {
+    // Access the action.js file for the certain entity to get the path
+    const entityPath = `${adaptdir}/entities/${entity}/action.json`;
+    const actionJSON = require(entityPath);
+    actionJSON.actions.forEach((action) => {
+      if (action.name === funcName) {
+        if (typeof action.entitypath === 'object') {
+          epath = '';
+          const keys = Object.keys(action.entitypath);
+          for (let k = 0; k < keys.length; k += 1) {
+            epath += `${keys[k]}:${action.entitypath[keys[k]]} <br /> `;
+          }
+          epath = epath.substring(0, epath.length - 8);
+        } else {
+          epath = action.entitypath;
+        }
+      }
+    });
+  }
+  return epath;
+}
+
+function recurseCallExpressions(statement, callList) {
+  // Recursively finds all CallExpressions in the syntax tree
+  if (statement.type === 'CallExpression') callList.push(statement);
+  const keys = Object.keys(statement);
+  for (let k = 0; k < keys.length; k += 1) {
+    if (typeof statement[keys[k]] === 'object' && statement[keys[k]] !== null) {
+      recurseCallExpressions(statement[keys[k]], callList);
+    }
+  }
+}
+
+function readFileUsingLib(filename, descriptionObj, workflowObj, functionList) {
+  // read the file
+  const aFile = fs.readFileSync(filename, 'utf8');
+  // parsing the file to get the function and class declarations.
+  const aFileFuncArgs = acorn.parse(aFile, { ecmaVersion: 2020 });
+
+  let callName = 'identifyRequest';
+  // Looping through all the declarations parsed:
+  aFileFuncArgs.body.forEach((e) => {
+    // Getting only the class declaration as it has our required functions.
+    if (e.type === 'ClassDeclaration') {
+      const methodDefinition = e.body;
+      methodDefinition.body.forEach((method) => {
+        // Getting method name and its params in the class.
+        const funcName = method.key.name;
+        const funcArgs = [];
+        method.value.params.forEach((param) => {
+          if (param.type === 'Identifier') {
+            funcArgs.push(param.name);
+          } else if (param.type === 'RestElement') {
+            funcArgs.push(`...${param.argument.name}`);
+          } else {
+            const args = `${param.left.name} = ${param.right.raw}`;
+            funcArgs.push(args);
+          }
+        });
+
+        // Getting the entity for the method:
+        const callList = [];
+        method.value.body.body.forEach((statement) => {
+          recurseCallExpressions(statement, callList);
+        });
+        const requests = [];
+        for (let i = 0; i < callList.length; i += 1) {
+          if (callList[i].callee.property && callList[i].callee.property.name === callName) {
+            requests.push(callList[i]);
+          }
+        }
+        if (requests.length > 0) {
+          const expr = requests[0];
+          if (expr.arguments.length < 2) {
+            throw new Error(`Bad inputs in method ${funcName}`);
+          }
+          const entity = expr.arguments[0].value;
+          const actionName = expr.arguments[1].value;
+          if (expr !== undefined && (expr.arguments[0].type !== 'Literal' || expr.arguments[1].type !== 'Literal')) {
+            const param1 = method.value.params[0];
+            const param2 = method.value.params[1];
+            if (param1.type !== 'Identifier' || param2.type !== 'Identifier'
+                || expr.arguments[0].type !== 'Identifier' || expr.arguments[1].type !== 'Identifier'
+                || param1.name !== expr.arguments[0].name || param2.name !== expr.arguments[1].name) {
+              throw new Error(`identifyRequest proxy method ${funcName} unknown format`);
+            } else if (callName !== 'identifyRequest') {
+              throw new Error(`MethodDocumentor not yet programmed to handle multiple helper methods: 1) ${callName}, 2) ${funcName}`);
+            }
+            callName = funcName;
+          }
+          const entityPath = getPathFromEntity(entity, actionName);
+
+          // Creating and storing the object for the method.
+          if (entityPath !== undefined) {
+            functionList.push(
+              createObjectForFunction(
+                funcName,
+                funcArgs,
+                entityPath,
+                descriptionObj[funcName],
+                workflowObj[funcName]
+              )
+            );
+          }
+        }
+      });
+    }
+  });
+}
+
+function readJSONFile(filename, descriptionObj, workflowObj) {
+  // Accessing the JSON file.
+  const phJSON = require(filename);
+  // Getting the methods array.
+  const methodArray = phJSON.methods;
+  methodArray.forEach((methodName) => {
+    // Getting the method description and workflow:
+    const funcName = methodName.name;
+    descriptionObj[funcName] = methodName.summary ? methodName.summary : methodName.description;
+    workflowObj[funcName] = methodName.task ? 'Yes' : 'No';
+  });
+}
+
+function readMDFile(filename, functionList) {
+  // Reading in the .md file and creating an array with each line as an element.
+  const mdFile = fs.readFileSync(filename, 'utf-8');
+  const fileSplit = mdFile.split('\n');
+  // Storing the data that should added later to the updated data.
+  const linesToAddLater = [];
+  let index = fileSplit.length - 1;
+
+  // Removing all the blank lines at the end of the file.
+  if (fileSplit[index] === '') {
+    while (fileSplit[index] === '') {
+      linesToAddLater.push(fileSplit.pop());
+      index -= 1;
+    }
+  }
+
+  // Checking if the last 2 lines are <br> and </table>. If not, the file is corrupted and the
+  // data at the end of the file should be fixed.
+  if (fileSplit[index] === '<br>' || fileSplit[index - 1] === '</table>') {
+    // Storing <br> and </table> to add later.
+    linesToAddLater.push(fileSplit.pop());
+    linesToAddLater.push(fileSplit.pop());
+    index -= 2;
+  } else {
+    console.log('The file has bad content at the end.');
+    return;
+  }
+  // if (fileSplit[index] !== '<br>' && fileSplit[index - 1] !== '</table>') {
+  //   console.log('The file has bad content at the end.');
+  //   return;
+  // } else {
+  //   // Storing <br> and </table> to add later.
+  //   linesToAddLater.push(fileSplit.pop());
+  //   linesToAddLater.push(fileSplit.pop());
+  //   index -= 2;
+  // }
+
+  // Removing all the lines until the header tags are reached.
+  while (!fileSplit[index].includes('<th')) {
+    fileSplit.pop();
+    index -= 1;
+  }
+  // Adding </tr> for the header row, because it got removed in the above loop.
+  fileSplit.push('  </tr>');
+
+  // Creating the tags for each method to be appended to the file.
+  const tdBeginTag = '    <td style="padding:15px">';
+  const tdEndTag = '</td>';
+
+  functionList.forEach((func) => {
+    const signCommand = `${tdBeginTag}${func.method_signature}${tdEndTag}`;
+    const descCommand = `${tdBeginTag}${func.description}${tdEndTag}`;
+    const pathCommand = `${tdBeginTag}${func.path}${tdEndTag}`;
+    const workflowCommand = `${tdBeginTag}${func.workflow}${tdEndTag}`;
+    fileSplit.push('  <tr>');
+    fileSplit.push(signCommand);
+    fileSplit.push(descCommand);
+    fileSplit.push(pathCommand);
+    fileSplit.push(workflowCommand);
+    fileSplit.push('  </tr>');
+  });
+
+  // Adding </table> and <br> at the end of the file to complete the table and the file.
+  while (linesToAddLater.length > 0) {
+    fileSplit.push(linesToAddLater.pop());
+  }
+
+  // Writing all the content back into the file.
+  fs.writeFileSync(filename, fileSplit.join('\n'), {
+    encoding: 'utf-8',
+    flag: 'w'
+  });
+}
+
+function getFileInfo() {
+  // If files don't exist:
+  if (!fs.existsSync(`${adaptdir}/adapter.js`)) {
+    console.log('Missing - utils/adapter.js');
+    return;
+  }
+  if (!fs.existsSync(`${adaptdir}/pronghorn.json`)) {
+    console.log('Missing - pronghorn.json');
+    return;
+  }
+  if (!fs.existsSync(`${adaptdir}/CALLS.md`)) {
+    console.log('Missing - CALLS.md');
+    return;
+  }
+
+  const descriptionObj = {};
+  const workflowObj = {};
+
+  // Get the method descriptions and the workflow values from pronghorn.json file.
+  readJSONFile(`${adaptdir}/pronghorn.json`, descriptionObj, workflowObj);
+
+  // Get the method signature, entity path and create an object that contains all the info regarding
+  // the method and push it to the functionList array.
+  const functionList = [];
+  readFileUsingLib(
+    `${adaptdir}/adapter.js`,
+    descriptionObj,
+    workflowObj,
+    functionList
+  );
+
+  // createMarkDown(functionList);
+  readMDFile(`${adaptdir}/CALLS.md`, functionList);
+}
+
+getFileInfo();

package/utils/modify.js

@@ -0,0 +1,152 @@
+const { execSync } = require('child_process');
+const fs = require('fs-extra');
+const Ajv = require('ajv');
+const rls = require('readline-sync');
+const { existsSync } = require('fs-extra');
+const { getAdapterConfig } = require('./tbUtils');
+const { name } = require('../package.json');
+const propertiesSchema = require('../propertiesSchema.json');
+
+const flags = process.argv[2];
+
+/**
+ * @summary Updates database instance with new adapter properties
+ *
+ * @function updateServiceItem
+ */
+async function updateServiceItem() {
+  const { database, serviceItem } = await getAdapterConfig();
+  const currentProps = serviceItem.properties.properties;
+  const ajv = new Ajv({ allErrors: true, useDefaults: true });
+  const validate = ajv.compile(propertiesSchema);
+  validate(currentProps);
+  console.log('Updating Properties...');
+  await database.collection('service_configs').updateOne({ model: name }, { $set: serviceItem });
+  console.log('Properties Updated');
+}
+
+/**
+ * @summary Creates a backup zip file of current adapter
+ *
+ * @function backup
+ */
+function backup() {
+  // zip all files except node_modules and package-lock
+  const backupCmd = 'zip -r previousVersion.zip .';
+  execSync(backupCmd, { encoding: 'utf-8', maxBuffer: 1024 * 1024 * 2 });
+}
+
+/**
+ * @summary Archives previous modifications and removes the modification package
+ *
+ * @function archiveMod
+ * @param {String} modType - update(UPD) or migrate(MIG)
+ */
+function archiveMod(modType) {
+  if (!existsSync('./adapter_modifications/archive')) {
+    execSync('mkdir ./adapter_modifications/archive');
+  }
+  const zipFile = modType === 'UPD' ? 'updatePackage.zip' : 'migrationPackage.zip';
+  const now = new Date();
+  const archiveName = `${modType}-${now.toISOString()}`;
+  execSync(`mkdir adapter_modifications/archive/${archiveName}`);
+  const archiveCmd = 'mv adapter_modifications/archive .'
+    + ` && mv adapter_modifications/* archive/${archiveName}`
+    + ' && mv archive adapter_modifications'
+    + ` && rm ${zipFile}`;
+  execSync(archiveCmd, { encoding: 'utf-8' });
+}
+
+/**
+ * @summary Reverts modifications using backup zip file
+ *
+ * @function revertMod
+ */
+function revertMod() {
+  const files = fs.readdirSync('./');
+  // remove all files except previousVersion
+  files.forEach((file) => {
+    if (file !== 'previousVersion.zip') {
+      fs.removeSync(file);
+    }
+  });
+  // // unzip previousVersion, reinstall dependencies and delete zipfile
+  execSync('unzip -o previousVersion.zip && rm -rf node_modules && rm package-lock.json && npm install', { maxBuffer: 1024 * 1024 * 2 });
+  execSync('rm previousVersion.zip');
+  console.log('Changes have been reverted');
+}
+
+// Main Script
+
+// Migrate
+if (flags === '-m') {
+  if (!fs.existsSync('migrationPackage.zip')) {
+    console.log('Migration Package not found. Download and place migrationPackage in the adapter root directory');
+    process.exit();
+  }
+  // Backup current adapter
+  backup();
+  console.log('Migrating adapter and running tests...');
+  const migrateCmd = 'unzip -o migrationPackage.zip'
+    + ' && cd adapter_modifications'
+    + ' && node migrate';
+  const migrateOutput = execSync(migrateCmd, { encoding: 'utf-8' });
+  console.log(migrateOutput);
+  if (migrateOutput.indexOf('Lint exited with code 1') >= 0
+    || migrateOutput.indexOf('Tests exited with code 1') >= 0) {
+    if (rls.keyInYN('Adapter failed tests or lint after migrating. Would you like to revert the changes?')) {
+      console.log('Reverting changes...');
+      revertMod();
+      process.exit();
+    }
+    console.log('Adapter Migration will continue. If you want to revert the changes, run the command npm run adapter:revert');
+  }
+  console.log('Installing new dependencies..');
+  const updatePackageCmd = 'rm -rf node_modules && rm package-lock.json && npm install';
+  const updatePackageOutput = execSync(updatePackageCmd, { encoding: 'utf-8' });
+  console.log(updatePackageOutput);
+  console.log('New dependencies installed');
+  console.log('Updating adapter properties..');
+  updateServiceItem().then(() => {
+    console.log('Adapter Successfully Migrated. Restart adapter in IAP to apply the changes');
+    archiveMod('MIG');
+    process.exit();
+  });
+}
+
+// Update
+if (flags === '-u') {
+  if (!fs.existsSync('updatePackage.zip')) {
+    console.log('Update Package not found. Download and place updateAdapter.zip in the adapter root directory');
+    process.exit();
+  }
+  // Backup current adapter
+  backup();
+  const updateCmd = 'unzip -o updatePackage.zip'
+    + ' && cd adapter_modifications'
+    + ' && node update.js updateFiles';
+  execSync(updateCmd, { encoding: 'utf-8' });
+  const updateOutput = execSync(updateCmd, { encoding: 'utf-8' });
+  if (updateOutput.indexOf('Lint exited with code 1') >= 0
+    || updateOutput.indexOf('Tests exited with code 1') >= 0) {
+    if (rls.keyInYN('Adapter failed tests or lint after updating. Would you like to revert the changes?')) {
+      console.log('Reverting changes...');
+      revertMod();
+      process.exit();
+    }
+    console.log('Adapter Update will continue. If you want to revert the changes, run the command npm run adapter:revert');
+  }
+  console.log(updateOutput);
+  console.log('Adapter Successfully Updated. Restart adapter in IAP to apply the changes');
+  archiveMod('UPD');
+  process.exit();
+}
+
+// Revert
+if (flags === '-r') {
+  if (!fs.existsSync('previousVersion.zip')) {
+    console.log('Previous adapter version not found. There are no changes to revert');
+    process.exit();
+  }
+  revertMod();
+}

package/utils/packModificationScript.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 /* @copyright Itential, LLC 2019 */
 
-const fs = require('fs-extra');
 const path = require('path');
 const { spawnSync } = require('child_process');
+const fs = require('fs-extra');
 const { createBundle } = require('./artifactize');
 
 const nodeEntryPath = path.resolve('.');

package/utils/patches2bundledDeps.js

@@ -0,0 +1,90 @@
+const fs = require('fs');
+const semverSatisfies = require('semver/functions/satisfies');
+const packageJson = require('../package.json');
+
+try {
+  // pattern supplied by semver.org via https://regex101.com/r/vkijKf/1/ but removed gm from end to only match a single semver
+  // const semverPat = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+  // pattern supplied by semver.org via https://regex101.com/r/Ly7O1x/3/ with following changes
+  // removed P's from before capturing group names and
+  // removed  gm from end to only match a single semver
+  // const semverPat = /^(?<major>0|[1-9]\d*)\.(?<minor>0|[1-9]\d*)\.(?<patch>0|[1-9]\d*)(?:-(?<prerelease>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+(?<buildmetadata>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+
+  const patches = (fs.existsSync('./patches')) ? fs.readdirSync('./patches', { withFileTypes: true }) : [];
+  if (!patches.length) {
+    console.error('\nno patches - nothing to do\n');
+    process.exitCode = 1;
+  }
+
+  const dependencies = packageJson.dependencies || {};
+  if (!Object.keys(dependencies).length) {
+    console.error('\nno dependencies - nothing to do\n');
+    process.exitCode = 1;
+  }
+
+  let changed = false;
+  console.error('\nprocessing patches');
+  const bundledDependencies = packageJson.bundledDependencies || packageJson.bundleDependencies || [];
+
+  patches.forEach((patch) => {
+    if (!patch.isFile()) {
+      console.error(`${patch.name} skipped, is not a regular file`);
+      return;
+    }
+    if (!patch.name.endsWith('.patch')) {
+      console.error(`${patch.name} skipped, does not end with .patch`);
+      return;
+    }
+    const splits = patch.name.slice(0, -6).split('+');
+    if (splits.length > 4) {
+      console.error(`${patch.name} skipped, does not follow the naming convention (cannot use '+' other than to separate scope/package/semver and at most once within semver)`);
+      return;
+    }
+    const scope = splits[0][0] === '@' ? splits.shift() : null;
+    const packageName = splits.shift();
+    const semver = splits.join('+');
+    // const { groups } = semver.match(semverPat);
+    const file = scope ? `${scope}/${packageName}` : packageName;
+    if (dependencies[file] && semverSatisfies(semver, dependencies[file])) {
+      if (!bundledDependencies.includes(file)) {
+        bundledDependencies.push(file);
+        console.error(`added ${file} to bundledDependencies`);
+        changed = true;
+      } else {
+        console.error(`bundledDependencies already has ${file}`);
+      }
+    } else {
+      const depmsg = dependencies[file] ? `version mismatch (${dependencies[file]}) in dependencies` : 'not found in dependencies';
+      console.error(`patch ${patch.name} ${depmsg}`);
+    }
+  });
+
+  if (!packageJson.bundledDependencies && bundledDependencies.length) {
+    delete packageJson.bundleDependencies;
+    packageJson.bundledDependencies = bundledDependencies;
+    console.error('renaming bundleDependencies to bundledDependencies');
+    changed = true;
+  }
+  if (changed) {
+    fs.writeFileSync('./package.json.new', JSON.stringify(packageJson, null, 2));
+    console.error('wrote package.json.new');
+    fs.renameSync('./package.json', './package.json.old');
+    console.error('moved package.json to package.json.old');
+    fs.renameSync('./package.json.new', './package.json');
+    console.error('moved package.json.new to package.json');
+  } else {
+    console.error('no changes\n');
+    process.exitCode = 1;
+  }
+} catch (e) {
+  if (e) {
+    // caught error, exit with status 2 to signify abject failure
+    console.error(`\ncaught exception - ${e}\n`);
+    process.exitCode = 2;
+  } else {
+    // caught false, exit with status 1 to signify nothing done
+    process.exitCode = 1;
+  }
+} finally {
+  console.error('done\n');
+}

package/utils/pre-commit.sh

@@ -17,6 +17,11 @@ printf "%b" "Running pre-commit hooks...\\n"
 # verify testing script is stubbed and no credentials
 node utils/testRunner.js -r
 
+# update the adapter information file
+node utils/adapterInfo.js
+node utils/methodDocumentor.js
+git add CALLS.md report/adapterInfo.json
+
 # security audit on the code
 npm audit --registry=https://registry.npmjs.org --audit-level=moderate
 

package/utils/removeHooks.js

@@ -0,0 +1,20 @@
+const fs = require('fs');
+
+/**
+ * This script will uninstall pre-commit or pre-push hooks in case there's ever a need to
+ * commit/push something that has issues
+ */
+
+const precommitPath = '.git/hooks/pre-commit';
+const prepushPath = '.git/hooks/pre-push';
+fs.unlink(precommitPath, (err) => {
+  if (err && err.code !== 'ENOENT') {
+    console.log(`${err.message}`);
+  }
+});
+
+fs.unlink(prepushPath, (err) => {
+  if (err && err.code !== 'ENOENT') {
+    console.log(`${err.message}`);
+  }
+});