@itentialopensource/adapter-netbox_v33 0.1.1

package/utils/entitiesToDB.js

@@ -0,0 +1,178 @@
+/* @copyright Itential, LLC 2021 */
+
+// Set globals
+/* global log */
+
+/* eslint import/no-dynamic-require: warn */
+/* eslint global-require: warn */
+/* eslint no-unused-vars: warn */
+/* eslint import/no-unresolved: warn */
+
+/**
+ *  This script is used to read through an adapter's entities files
+ *  and then creates documents and enters them into the IAP mongodb
+ */
+
+const fs = require('fs');
+const path = require('path');
+const utils = require('./tbUtils');
+
+// get the pronghorn database information
+const getPronghornProps = async (iapDir) => {
+  log.trace('Retrieving properties.json file...');
+  const rawProps = require(path.join(iapDir, 'properties.json'));
+  log.trace('Decrypting properties...');
+  const { PropertyEncryption } = require('@itential/itential-utils');
+  const propertyEncryption = new PropertyEncryption();
+  const pronghornProps = await propertyEncryption.decryptProps(rawProps);
+  log.trace('Found properties.\n');
+  return pronghornProps;
+};
+
+/**
+ *  Function used to take a file path to a entity directory and build
+ *  a document that corresponds to the entity files.
+ */
+const buildDoc = (pathstring) => {
+  let files = fs.readdirSync(pathstring);
+
+  // load the mockdatafiles
+  const mockdatafiles = {};
+  if (files.includes('mockdatafiles') && fs.lstatSync(`${pathstring}/mockdatafiles`).isDirectory()) {
+    fs.readdirSync(`${pathstring}/mockdatafiles`).forEach((file) => {
+      if (file.split('.').pop() === 'json') {
+        const mockpath = `${pathstring}/mockdatafiles/${file}`;
+        const data = JSON.parse(fs.readFileSync(mockpath));
+        mockdatafiles[mockpath.split('/').pop()] = data;
+      }
+    });
+  }
+
+  // load the action data
+  let actions;
+  if (files.includes('action.json')) {
+    actions = JSON.parse(fs.readFileSync(`${pathstring}/action.json`));
+  }
+
+  // Load schema.json and other schemas in remaining json files
+  files = files.filter((f) => (f !== 'action.json') && f.endsWith('.json'));
+  const schema = [];
+  files.forEach((file) => {
+    const data = JSON.parse(fs.readFileSync(`${pathstring}/${file}`));
+    schema.push({
+      name: file,
+      schema: data
+    });
+  });
+
+  // return the data
+  return {
+    actions: actions.actions,
+    schema,
+    mockdatafiles
+  };
+};
+
+/**
+ *  Function used to get the database from the options or a provided directory
+ */
+const optionsHandler = (options) => {
+  // if the database properties were provided in the options - return them
+  if (options.pronghornProps) {
+    if (typeof options.pronghornProps === 'string') {
+      return JSON.parse(options.pronghornProps);
+    }
+    return new Promise((resolve, reject) => resolve(options.pronghornProps));
+  }
+
+  // if the directory was provided, get the pronghorn props from the directory
+  if (options.iapDir) {
+    return getPronghornProps(options.iapDir);
+  }
+
+  // if nothing was provided, error
+  return new Promise((resolve, reject) => reject(new Error('Neither pronghornProps nor iapDir defined in options!')));
+};
+
+/**
+ *  Function used to put the adapter configuration into the provided database
+ */
+const moveEntitiesToDB = async (targetPath, options) => {
+  // set local variables
+  let myOpts = options;
+  let myPath = targetPath;
+
+  // if we got a string parse into a JSON object
+  if (typeof myOpts === 'string') {
+    myOpts = JSON.parse(myOpts);
+  }
+
+  // if there is no target collection - set the collection to the default
+  if (!myOpts.targetCollection) {
+    myOpts.targetCollection = 'adapter_configs';
+  }
+
+  // if there is no id error since we need an id for the entities
+  if (!myOpts.id) {
+    throw new Error('Adapter ID required!');
+  }
+
+  // get the pronghorn database properties
+  return optionsHandler(options).then(async (currentProps) => {
+    // Check valid filepath provided
+    if (!myPath) {
+      // if no path use the current directory without the utils
+      myPath = path.join(__dirname, '../');
+    } else if (myPath.slice(-1) === '/') {
+      myPath = myPath.slice(0, -1);
+    }
+
+    // verify set the entity path
+    const entitiesPath = `${myPath}/entities`;
+    if (!fs.existsSync(entitiesPath)) {
+      throw new Error(`Entities path does not exist in filesystem: ${entitiesPath}`);
+    } else {
+      log.trace('Target found on filesystem');
+    }
+
+    // Get adapter details
+    if (!fs.existsSync(`${myPath}/pronghorn.json`)) {
+      throw new Error(`pronghorn.json does not exist in path: ${myPath}`);
+    } else {
+      log.trace('pronghorn.json found on filesystem');
+    }
+    const adapterData = JSON.parse(fs.readFileSync(`${myPath}/pronghorn.json`));
+
+    // Load files from the filesystem
+    const docs = [];
+    const entities = fs.readdirSync(entitiesPath);
+    entities.forEach((entity) => {
+      const entityPath = `${entitiesPath}/${entity}`;
+      const isDir = fs.lstatSync(entitiesPath).isDirectory();
+
+      // Build doc for entity
+      if (isDir) {
+        let doc = buildDoc(entityPath);
+        doc = {
+          id: myOpts.id,
+          type: adapterData.id,
+          entity,
+          ...doc
+        };
+        docs.push(doc);
+      }
+    });
+
+    // Upload documents to db collection
+    const db = await utils.connect(currentProps).catch((err) => { console.error(err); throw err; });
+    if (!db) {
+      console.error('Error occured when connectiong to database', currentProps);
+      throw new Error('Database not found');
+    }
+    const collection = db.collection(myOpts.targetCollection);
+    const res = await collection.insertMany(docs, { checkKeys: false }).catch((err) => { console.error(err); throw err; });
+    return res;
+  });
+};
+
+module.exports = { moveEntitiesToDB };

package/utils/findPath.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+/* @copyright Itential, LLC 2019 */
+/* eslint global-require:warn */
+/* eslint import/no-dynamic-require:warn */
+/* eslint prefer-destructuring:warn */
+
+const fs = require('fs-extra');
+const path = require('path');
+const rls = require('readline-sync');
+
+/**
+ * This script will determine the type of integration test to run
+ * based on input. If other information is needed, it will solicit
+ * that input and then edit the integration test accordingly.
+ */
+
+/**
+ * Updates the action files
+ */
+function checkActionFiles(apath) {
+  // verify the path
+  if (!apath) {
+    console.log('  NO PATH PROVIDED!');
+    return 'Done';
+  }
+
+  // make sure the entities directory exists
+  const entitydir = path.join(__dirname, '../entities');
+  if (!fs.statSync(entitydir).isDirectory()) {
+    console.log('Could not find the entities directory');
+    return 'error';
+  }
+
+  const entities = fs.readdirSync(entitydir);
+  let found = false;
+
+  // need to go through each entity in the entities directory
+  for (let e = 0; e < entities.length; e += 1) {
+    // make sure the entity is a directory - do not care about extra files
+    // only entities (dir)
+    if (fs.statSync(`${entitydir}/${entities[e]}`).isDirectory()) {
+      // see if the action file exists in the entity
+      if (fs.existsSync(`${entitydir}/${entities[e]}/action.json`)) {
+        // Read the entity actions from the file system
+        const actions = require(`${entitydir}/${entities[e]}/action.json`);
+
+        // go through all of the actions set the appropriate info in the newActions
+        for (let a = 0; a < actions.actions.length; a += 1) {
+          if (actions.actions[a].entitypath.indexOf(apath) >= 0) {
+            found = true;
+            console.log(`  Found - entity: ${entities[e]} action: ${actions.actions[a].name}`);
+            console.log(`          method: ${actions.actions[a].method} path: ${actions.actions[a].entitypath}`);
+            console.log(' ');
+          }
+        }
+      } else {
+        console.log(`Could not find entities ${entities[e]} action.json file`);
+        return 'error';
+      }
+    } else {
+      console.log(`Could not find entities ${entities[e]} directory`);
+      return 'error';
+    }
+  }
+
+  if (!found) {
+    console.log('  PATH NOT FOUND!');
+  }
+  return 'Done';
+}
+
+const findPath = rls.question('Enter the path/partial path you are looking for: ');
+console.log(`PATH: ${findPath}`);
+checkActionFiles(findPath);

package/utils/methodDocumentor.js

@@ -0,0 +1,225 @@
+/* eslint global-require:warn */
+/* eslint import/no-dynamic-require:warn */
+/* eslint no-param-reassign:warn */
+
+const fs = require('fs-extra');
+const esprima = require('esprima');
+
+// 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) {
+        epath = action.entitypath;
+      }
+    });
+  }
+  return epath;
+}
+
+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 = esprima.parseScript(aFile);
+
+  // 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 {
+            const args = `${param.left.name} = ${param.right.value}`;
+            funcArgs.push(args);
+          }
+        });
+
+        // Getting the entity for the method:
+        let entity;
+        method.value.body.body.forEach((statementType) => {
+          if (statementType.type === 'TryStatement') {
+            entity = statementType.block.body[0].argument.arguments[0].value;
+          }
+        });
+        const entityPath = getPathFromEntity(entity, funcName);
+
+        // 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.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,154 @@
+const fs = require('fs-extra');
+const Ajv = require('ajv');
+const rls = require('readline-sync');
+const { execSync } = require('child_process');
+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' });
+}
+
+/**
+ * @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');
+  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

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+/* @copyright Itential, LLC 2019 */
+
+const fs = require('fs-extra');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { createBundle } = require('./artifactize');
+
+const nodeEntryPath = path.resolve('.');
+createBundle(nodeEntryPath).then((pathObj) => {
+  const { bundlePath, bundledAdapterPath } = pathObj;
+  const npmIgnorePath = path.join(bundledAdapterPath, '.npmignore');
+  const adapterPackagePath = path.join(bundledAdapterPath, 'package.json');
+  const artifactPackagePath = path.join(bundlePath, 'package.json');
+
+  // remove node_modules from .npmIgnore so that node_modules are included in the resulting tar from npm pack
+  let npmIgnoreString;
+  if (fs.existsSync(npmIgnorePath)) {
+    npmIgnoreString = fs.readFileSync(npmIgnorePath, 'utf8');
+    npmIgnoreString = npmIgnoreString.replace('node_modules', '');
+    npmIgnoreString = npmIgnoreString.replace('\n\n', '\n');
+    fs.writeFileSync(npmIgnorePath, npmIgnoreString);
+  }
+
+  // add files to package so that node_modules are included in the resulting tar from npm pack
+  const adapterPackage = fs.readJSONSync(adapterPackagePath);
+  adapterPackage.files = ['*'];
+  fs.writeJSONSync(artifactPackagePath, adapterPackage, { spaces: 2 });
+  const npmResult = spawnSync('npm', ['pack', '-q', bundlePath], { cwd: path.resolve(bundlePath, '..') });
+  if (npmResult.status === 0) {
+    fs.removeSync(bundlePath);
+    console.log('Bundle folder removed');
+  }
+  console.log('Script successful');
+});