@itentialopensource/adapter-netbox 0.6.1 → 0.7.0

package/utils/addAuth.js

@@ -0,0 +1,94 @@
+/* eslint-disable no-plusplus */
+/* eslint global-require: warn */
+/* eslint import/no-dynamic-require: warn */
+
+const rls = require('readline-sync');
+const path = require('path');
+const fs = require('fs');
+
+function getQuestions(props, obj) {
+  const questions = props.map((p) => `${p}: ${(obj[p] !== undefined) ? `(${obj[p]})` : ''} `);
+  return questions;
+}
+
+// function outputs each property for user to edit/confirm
+// props are the fields that need to be changed depending on what the user selects
+// obj is the JSON object that's being updated
+function confirm(props, obj) {
+  // create array of questions
+  const updatedObj = obj;
+  getQuestions(props, obj).forEach((q) => {
+    const answer = rls.question(q);
+    // only update the field if the answer is NOT and empty string
+    if (answer) {
+      updatedObj[q.split(':')[0].trim()] = answer;
+    }
+  });
+  return updatedObj;
+}
+
+const updateBasicAuth = (auth) => {
+  const propsToUpdate = ['username', 'password', 'auth_field', 'auth_field_format'];
+  return confirm(propsToUpdate, auth);
+};
+
+const updateStaticTokenAuth = (auth) => {
+  const propsToUpdate = ['token', 'auth_field', 'auth_field_format'];
+  return confirm(propsToUpdate, auth);
+};
+
+function updateTokenSchemas(user, pw, token) {
+  let schemaPath = path.join(__dirname, '..', 'entities/.system/schemaTokenReq.json');
+  const reqSchema = require(schemaPath);
+  reqSchema.properties.username.external_name = user;
+  reqSchema.properties.password.external_name = pw;
+  fs.writeFileSync(schemaPath, JSON.stringify(reqSchema, null, 2));
+  schemaPath = path.join(__dirname, '..', 'entities/.system/schemaTokenResp.json');
+  const respSchema = require(schemaPath);
+  respSchema.properties.token.external_name = token;
+  fs.writeFileSync(schemaPath, JSON.stringify(respSchema, null, 2));
+}
+
+function updateRequestToken(auth) {
+  const propsToUpdate = [
+    'username',
+    'password',
+    'auth_field',
+    'auth_field_format',
+    'token_user_field',
+    'token_password_field',
+    'token_result_field',
+    'token_URI_path'
+  ];
+  const newAuth = confirm(propsToUpdate, auth);
+  updateTokenSchemas(newAuth.token_user_field, newAuth.token_password_field, newAuth.token_result_field);
+
+  return newAuth;
+}
+
+// prompt users to pick an auth method from the list above
+const addAuthInfo = (props) => {
+  const authOptions = [
+    'basic user_password',
+    'static_token',
+    'request_token',
+    'no_authentication'
+  ];
+  const newProps = confirm(['host', 'port', 'base_path'], props);
+
+  const newAuthMethod = authOptions[rls.keyInSelect(authOptions, 'Which authentication method?')];
+  newProps.authentication.auth_method = newAuthMethod;
+
+  if (newAuthMethod === 'basic user_password') {
+    newProps.authentication = updateBasicAuth(newProps.authentication);
+  } else if (newAuthMethod === 'static_token') {
+    newProps.authentication = updateStaticTokenAuth(newProps.authentication);
+  } else if (newAuthMethod === 'request_token') {
+    newProps.authentication = updateRequestToken(newProps.authentication);
+  }
+  console.log('Connectivity and authentication properties have been configured');
+  console.log('If you want to make changes, rerun this script to reinstall the adapter');
+  return newProps;
+};
+
+module.exports = { addAuthInfo };

package/utils/basicGet.js

@@ -0,0 +1,50 @@
+/* @copyright Itential, LLC 2020 */
+
+/* eslint object-shorthand: warn */
+/* eslint import/no-extraneous-dependencies: warn */
+/* eslint global-require: warn */
+/* eslint import/no-unresolved: warn */
+/* eslint import/no-dynamic-require: warn */
+
+const winston = require('winston');
+
+const logLevel = 'none';
+const myCustomLevels = {
+  levels: {
+    spam: 6,
+    trace: 5,
+    debug: 4,
+    info: 3,
+    warn: 2,
+    error: 1,
+    none: 0
+  }
+};
+
+const basicGet = {
+  /**
+   * @summary create Adapter instance
+   *
+   * @function getAdapterInstance
+   * @param {Object} adapter - adaper configuration object required by IAP
+   */
+  getAdapterInstance: (adapter) => {
+    const Adapter = require('../adapter');
+    const adapterProps = JSON.parse(JSON.stringify(adapter.properties.properties));
+    adapterProps.stub = false;
+    // need to set global logging
+    global.log = winston.createLogger({
+      level: logLevel,
+      levels: myCustomLevels.levels,
+      transports: [
+        new winston.transports.Console()
+      ]
+    });
+    return new Adapter(
+      adapter.id,
+      adapterProps
+    );
+  }
+};
+
+module.exports = basicGet;

package/utils/checkMigrate.js

@@ -0,0 +1,63 @@
+const { execSync } = require('child_process');
+const semver = require('semver');
+const axios = require('axios');
+const fs = require('fs');
+const packageJson = require('../package.json');
+
+const localEngineVer = packageJson.engineVersion;
+const localUtils = execSync('npm list @itentialopensource/adapter-utils', { encoding: 'utf-8' });
+const localUtilsVer = localUtils.split('@').pop().replace(/(\r\n|\n|\r| )/gm, '');
+
+/**
+ * @summary Makes a GET call using axios
+ *
+ * @function get
+ * @param {String} url - url to make the call to
+ */
+function get(url) {
+  const config = {
+    method: 'get',
+    url
+  };
+  return axios(config);
+}
+
+/**
+ * @summary Checks if adapter can be migrated using migration package
+ *
+ * @function migratePossible
+ */
+function migratePossible() {
+  const adapterTestUnit = fs.readFileSync('./test/unit/adapterTestUnit.js', { encoding: 'utf-8' });
+  const readme = fs.readFileSync('./README.md', { encoding: 'utf-8' });
+  return packageJson.keywords !== null && adapterTestUnit.indexOf('DO NOT REMOVE THIS COMMENT BLOCK') !== -1
+  && readme.indexOf('available at ') !== -1 && readme.indexOf('You will need to change the credentials and possibly the host information below.') !== -1;
+}
+
+/**
+ * @summary Checks if adapter is up-to-date or if migration is needed
+ *
+ * @function migrateNeeded
+ */
+async function migrateNeeded() {
+  const engineUrl = 'https://adapters.itential.io/engineVersion';
+  const utilsUrl = 'https://registry.npmjs.org/@itentialopensource/adapter-utils';
+  const latestEngineVer = (await get(engineUrl)).data;
+  const latestUtilsVer = (await get(utilsUrl)).data['dist-tags'].latest;
+  return semver.lt(localEngineVer, latestEngineVer) || semver.lt(localUtilsVer, latestUtilsVer);
+}
+
+// Main Script
+if (migratePossible()) {
+  migrateNeeded().then((needed) => {
+    if (needed) {
+      console.log('Migration is needed and possible -- go to dev site to download migration package');
+    } else {
+      console.log('Migration is possible but not needed at the current time.');
+    }
+  }).catch((error) => {
+    console.log('Could not get latest engine or utils version.', error.message);
+  });
+} else {
+  console.log('Migration is not possible. Please contact Itential support for assistance');
+}

package/utils/entitiesToDB.js

@@ -0,0 +1,224 @@
+/* @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 { MongoClient } = require('mongodb');
+const path = require('path');
+// const { argv } = require('process');
+// const { string } = require('yargs');
+
+// 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 = (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
+  optionsHandler(options).then((currentProps) => {
+    let mongoUrl;
+    let dbName;
+
+    // find the mongo properties so we can connect
+    if (currentProps.mongoProps) {
+      mongoUrl = currentProps.mongoProps.url;
+      dbName = currentProps.mongoProps.db;
+    } else if (currentProps.mongo) {
+      if (currentProps.mongo.url) {
+        mongoUrl = currentProps.mongo.url;
+      } else {
+        mongoUrl = `mongodb://${currentProps.mongo.host}:${currentProps.mongo.port}`;
+      }
+      dbName = currentProps.mongo.database;
+    } else {
+      throw new Error('Mongo properties are not specified in adapter preferences!');
+    }
+
+    // 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
+    MongoClient.connect(mongoUrl, (err, db) => {
+      if (err) {
+        log.error(JSON.stringify(err));
+        throw err;
+      }
+
+      // get the proper collection
+      const collection = db.db(dbName).collection(myOpts.targetCollection);
+      // insert the documents into the collection
+      collection.insertMany(docs, { checkKeys: false }, (error, res) => {
+        if (error) {
+          log.error(JSON.stringify(error));
+          throw error;
+        }
+        // log the insertion, close the database and return
+        log.debug(`Inserted ${docs.length} documents to ${dbName}.${myOpts.targetCollection} with response ${JSON.stringify(res)}`);
+        db.close();
+        return res;
+      });
+    });
+  });
+};
+
+// const args = process.argv.slice(2);
+
+// throw new SyntaxError(args[0]);
+
+// if (args.length === 0) {
+//   console.error('ERROR: target path not specified!');
+// } else if (args[0] === 'help') {
+//   log.trace('node ./entitiesToDB <target path> <options object: {iapDir: string, pronghornProps: string, targetCollection: string}>');
+// } else if (args.length === 1) {
+//   console.error('ERROR: IAP directory not specified');
+// } else {
+//   moveEntitiesToDB(args[0], args[1]);
+// }
+
+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/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

@@ -4,7 +4,7 @@
 const fs = require('fs-extra');
 const path = require('path');
 const { spawnSync } = require('child_process');
-const { createBundle } = require('./artifactize.js');
+const { createBundle } = require('./artifactize');
 
 const nodeEntryPath = path.resolve('.');
 createBundle(nodeEntryPath).then((pathObj) => {