@itentialopensource/adapter-efficientip_solidserver 0.1.1 → 0.3.0

package/utils/taskMover.js

@@ -0,0 +1,309 @@
+/* eslint-disable */
+const fs = require('fs');
+
+const blacklistTasks = [
+  'genericAdapterRequest',
+  'genericAdapterRequestNoBasePath',
+  'hasEntities',
+  'healthcheck'
+];
+
+const adapterBaseTasks = [
+    'getDevicesFiltered',
+    'isAlive',
+    'getConfig',
+    'getDevice',
+    'iapUpdateAdapterConfiguration',
+    'iapFindAdapterPath',
+    'iapSuspendAdapter',
+    'iapUnsuspendAdapter',
+    'iapGetAdapterQueue',
+    'iapTroubleshootAdapter',
+    'iapRunAdapterHealthcheck',
+    'iapRunAdapterConnectivity',
+    'iapRunAdapterBasicGet',
+    'iapMoveAdapterEntitiesToDB',
+    'getDevice',
+    'getDevicesFiltered',
+    'isAlive',
+    'getConfig',
+    'iapGetDeviceCount',
+    'iapRunAdapterLint',
+    'iapRunAdapterTests',
+    'iapGetAdapterInventory'
+];
+
+function updatePronghorn(tasks, original, updated) {
+  const originalFile = require(original);
+  const unusedMethods = [];
+  const usedMethods = originalFile.methods.filter((method) => {
+    if (tasks.includes(method.name)) {
+      unusedMethods.push(method);
+      return false;
+    }
+    return true;
+  });
+  //write used and unused to new files
+  let updatedFile;
+  if (!fs.existsSync(updated)) {
+    updatedFile = { ...originalFile, methods: [], src: 'adapter-inactive.js' };
+  } else {
+    updatedFile = require(updated);
+  }
+  updatedFile.methods = updatedFile.methods.concat(unusedMethods);
+  originalFile.methods = usedMethods;
+  fs.writeFileSync(updated, JSON.stringify(updatedFile, null, 2));
+  fs.writeFileSync(original, JSON.stringify(originalFile, null, 2));
+  return 'Done';
+}
+
+function flipTaskFlag(task, pronghornPath, value)
+{
+  const pronghorn = require(pronghornPath);
+  const index = pronghorn.methods.findIndex((method) => method.name === task);
+  pronghorn.methods[index] = { ...pronghorn.methods[index], task: value };
+  fs.writeFileSync(pronghornPath, JSON.stringify(pronghorn, null, 2));
+}
+
+//Return array of relevant paths given adapter directory
+function createPaths(currentAdapter) {
+  const paths = [];
+  const filePaths = [
+    'adapter.js',
+    'pronghorn.json',
+    'test/integration/adapterTestIntegration.js',
+    'test/unit/adapterTestUnit.js',
+    'adapter-inactive.js',
+    'pronghorn-inactive.json',
+  ];
+  filePaths.forEach((file) => {
+    paths.push(`${currentAdapter}/${file}`);
+  });
+  return paths;
+}
+
+function insert(str, index, value) {
+  return str.substr(0, index) + value + str.substr(index);
+}
+
+//modify adapter js
+//original - path to file containing tasks we want to remove
+// updated - path to file we want to move the tasks to
+function updateAdapterJs(tasks, original, updated, adapterDir) {
+  if (!fs.existsSync(original)) {
+    //could do this or just let the error ocurr lower down and catch in warpper
+    throw new Error(`Original file ${original} does not exist.`);
+  }
+  let originalFile = fs.readFileSync(original, 'utf8');
+  let updatedFile;
+  if (!fs.existsSync(updated)) {
+    const adapterExport = require(`${adapterDir}/pronghorn.json`).export;
+    updatedFile = `/* @copyright Itential, LLC 2019 */\n\n/* eslint import/no-dynamic-require: warn */\n/* eslint no-unused-vars: warn */\n/* global log */\n\nconst path = require('path');\n\nconst AdapterBaseCl = require(path.join(__dirname, 'adapterBase.js'));\n\nclass ${adapterExport}Inactive extends AdapterBaseCl {}\n`;
+    //To do handles backup files where og doesn't exist
+  } else {
+    updatedFile = fs.readFileSync(updated, 'utf8');
+  }
+
+  tasks.forEach((method) => {
+    //accounting for different js docs format
+    const comment = originalFile.indexOf(`* @function ${method}`);
+    const start = originalFile.slice(0, comment).lastIndexOf('/**');
+    if (start !== -1) {
+      //next comment block
+      const end = originalFile.indexOf('/**\n', start + 1);
+      let func = end === -1
+        ? originalFile.substring(start - 3, originalFile.lastIndexOf('}'))
+        : originalFile.substring(start, end);
+      originalFile = originalFile.replace(func, '');
+      func = '\n  ' + func.trim() + '\n';
+      updatedFile = insert(updatedFile, updatedFile.lastIndexOf('}'), func);
+    } else {
+      console.log(`Task ${method} wasn't found in original file. Skipping.`);
+    }
+  });
+  fs.writeFileSync(original, originalFile, 'utf8');
+  fs.writeFileSync(updated, updatedFile, 'utf8');
+  return 'done';
+}
+
+//Update test file for when we deactivate a task
+function deactivateTest(adapterPath, testPath, tasks) {
+  let unitTest = fs.readFileSync(`${adapterPath}/${testPath}`, 'utf8');
+  tasks.forEach((task) => {
+    const searchStr = `describe('#${task}`;
+    unitTest = unitTest.replace(searchStr, `describe.skip('#${task}`);
+  });
+  fs.writeFileSync(`${adapterPath}/${testPath}`, unitTest, 'utf8');
+}
+
+//Update test file when we activate tasks
+function activateTest(adapterPath, testPath, tasks) {
+  let unitTest = fs.readFileSync(`${adapterPath}/${testPath}`, 'utf8');
+  //tasks ==> toMove
+  tasks.forEach((task) => {
+    const searchStr = `describe.skip('#${task}`;
+    unitTest = unitTest.replace(searchStr, `describe('#${task}`);
+  });
+  fs.writeFileSync(`${adapterPath}/${testPath}`, unitTest, 'utf8');
+}
+
+//backups are not actually being written back
+function rollbackChanges(adapterPath) {
+  const backups = fs.readdirSync(`${adapterPath}/temp`); //this is an array of file names not the full path
+  const filePaths = createPaths(adapterPath);
+  for (let i = 0; i < backups.length; i++) {
+    const file = fs.readFileSync(`${adapterPath}/temp/${backups[i]}`, 'utf8'); //make sure this is getting the file
+    const currentFile = filePaths.find((path) => {
+      const index = path.split('/').length - 1;
+      const fileName = path.split('/')[index];
+      return fileName === backups[i].replace('temp-', '');
+    }); //returns undefined if no match
+
+    if (currentFile) {
+      fs.writeFileSync(currentFile, file, 'utf8');
+    }
+  }
+  //inactive didn't exist before script
+  if (!backups.includes('temp-adapter-inactive.js')) {
+    fs.unlinkSync(`${adapterPath}/pronghorn-inactive.json`);
+    fs.unlinkSync(`${adapterPath}/adapter-inactive.js`);
+  }
+  deleteBackups(adapterPath);
+}
+
+function deleteBackups(adapterPath) {
+  fs.rmSync(`${adapterPath}/temp`, { recursive: true });
+}
+
+function activateTasks(adapterDir, tasks) {
+  const toDelete = [];
+  const backupFiles = [];
+  const filePaths = createPaths(adapterDir);
+  try {
+    //take backup of each file here
+    if (!fs.existsSync(`${adapterDir}/temp`)) {
+      fs.mkdirSync(`${adapterDir}/temp`);
+    }
+    filePaths.forEach((filePath) => {
+      if (fs.existsSync(filePath)) {
+        const index = filePath.split('/').length - 1;
+        const backupName = `temp-${filePath.split('/')[index]}`;
+        backupFiles.push(`${adapterDir}/temp/${backupName}`);
+        fs.copyFileSync(filePath, `${adapterDir}/temp/${backupName}`);
+      } else {
+        //File doesn't exist before script
+        toDelete.push(filePath);
+      }
+    });
+    tasks = tasks.filter((task) => {
+      if (adapterBaseTasks.includes(task)) {
+        flipTaskFlag(task, `${adapterDir}/pronghorn.json`, true);
+        return false;
+      } else {
+        return true;
+      }
+    });
+    updateAdapterJs(
+      tasks,
+      `${adapterDir}/adapter-inactive.js`,
+      `${adapterDir}/adapter.js`,
+      adapterDir
+    );
+    updatePronghorn(
+      tasks,
+      `${adapterDir}/pronghorn-inactive.json`,
+      `${adapterDir}/pronghorn.json`
+    );
+    activateTest(
+      adapterDir,
+      '/test/integration/adapterTestIntegration.js',
+      tasks
+    );
+    activateTest(adapterDir, '/test/unit/adapterTestUnit.js', tasks);
+    return 'success';
+  } catch (e) {
+    console.log(`Error: ${e} ocurred during execution. Rolling back changes.`);
+    for (let i = 0; i < backupFiles.length; i++) {
+      const file = fs.readFileSync(backupFiles[i], 'utf8');
+      fs.writeFileSync(filePaths[i], file, 'utf8');
+    }
+    toDelete.forEach((filePath) => {
+      if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+      }
+    });
+    deleteBackups(adapterDir);
+    process.exit(1);
+  }
+}
+
+//moving from adapter.js to adapter-inactive.js
+function deactivateTasks(adapterDir, tasks) {
+  const toDelete = [];
+  const backupFiles = [];
+  const filePaths = createPaths(adapterDir);
+  try {
+    //take backup of each file here
+    if (!fs.existsSync(`${adapterDir}/temp`)) {
+      fs.mkdirSync(`${adapterDir}/temp`);
+    }
+    filePaths.forEach((filePath) => {
+      if (fs.existsSync(filePath)) {
+        const index = filePath.split('/').length - 1;
+        const backupName = `temp-${filePath.split('/')[index]}`;
+        backupFiles.push(`${adapterDir}/temp/${backupName}`);
+        fs.copyFileSync(filePath, `${adapterDir}/temp/${backupName}`);
+      } else {
+        //File doesn't exist before script
+        toDelete.push(filePath);
+      }
+    });
+    //filter tasks for blacklisted tasks or IAP tasks
+    tasks = tasks.filter((task) => {
+      if (blacklistTasks.includes(task)) {
+        console.log(`${task} cannot be deactivated.`);
+        return false;
+      } else if (adapterBaseTasks.includes(task)) {
+        flipTaskFlag(task, `${adapterDir}/pronghorn.json`, false);
+        return false;
+      } else {
+        return true;
+      }
+    });
+    updateAdapterJs(
+      tasks,
+      `${adapterDir}/adapter.js`,
+      `${adapterDir}/adapter-inactive.js`,
+      adapterDir
+    );
+    updatePronghorn(
+      tasks,
+      `${adapterDir}/pronghorn.json`,
+      `${adapterDir}/pronghorn-inactive.json`
+    );
+    deactivateTest(
+      adapterDir,
+      '/test/integration/adapterTestIntegration.js',
+      tasks
+    );
+    deactivateTest(adapterDir, '/test/unit/adapterTestUnit.js', tasks);
+    return 'success';
+  } catch (e) {
+    console.log(`Error: ${e} ocurred during execution. Rolling back changes.`);
+    for (let i = 0; i < backupFiles.length; i++) {
+      const file = fs.readFileSync(backupFiles[i], 'utf8');
+      fs.writeFileSync(filePaths[i], file, 'utf8');
+    }
+    toDelete.forEach((filePath) => {
+      if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+      }
+    });
+    deleteBackups(adapterDir);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  activateTasks, deactivateTasks, rollbackChanges, deleteBackups
+};

package/utils/tbScript.js

@@ -1,4 +1,4 @@
-/* eslint no-console: warn */
+/* eslint-disable no-console */
 /* eslint import/no-unresolved: warn */
 /* eslint global-require: warn */
 
@@ -7,43 +7,126 @@
 /* eslint import/no-extraneous-dependencies: warn */
 /* eslint import/no-dynamic-require: warn */
 
-const path = require('path');
 const program = require('commander');
 const rls = require('readline-sync');
+const prompts = require('prompts');
 const utils = require('./tbUtils');
 const basicGet = require('./basicGet');
 const { name } = require('../package.json');
 const sampleProperties = require('../sampleProperties.json');
 const adapterPronghorn = require('../pronghorn.json');
+const { addAuthInfo } = require('./addAuth');
 
-const { troubleshoot, getAdapterConfig, offline } = require('./troubleshootingAdapter');
+const { troubleshoot, offline } = require('./troubleshootingAdapter');
 
-const main = async (command) => {
-  const iapDir = path.join(__dirname, '../../../../');
-  if (!utils.withinIAP(iapDir)) {
-    if (command === 'connectivity') {
+const executeInStandaloneMode = async (command) => {
+  console.info('\n> Executing the script outside of IAP installation directory');
+  console.info('> Using sampleProperties.json configuration');
+  switch (command) {
+    case 'install': {
+      console.error('Not currently in IAP directory - installation not possible');
+      break;
+    }
+    case 'connectivity': {
       const { host } = sampleProperties.properties;
       console.log(`perform networking diagnositics to ${host}`);
-      await utils.runConnectivity(host);
-      process.exit(0);
-    } else if (command === 'healthcheck') {
+      utils.runConnectivity(host);
+      break;
+    }
+    case 'healthcheck': {
       const a = basicGet.getAdapterInstance({ properties: sampleProperties });
       await utils.healthCheck(a);
-      process.exit(0);
-    } else if (command === 'basicget') {
-      await utils.runBasicGet();
-      process.exit(0);
+      break;
     }
-    if (rls.keyInYN('Troubleshooting without IAP?')) {
-      await offline();
+    case 'basicget': {
+      utils.runBasicGet();
+      break;
     }
+    default: {
+      if (rls.keyInYN('Troubleshooting without IAP?')) {
+        await offline();
+      }
+    }
+  }
+  process.exit(0);
+};
+
+const getAdapterInstanceConfig = async (command) => {
+  const instances = await utils.getAllAdapterInstances();
+  if (!instances || instances.length === 0) {
+    return console.log('None adapter instances found!');
+  }
+
+  let instance;
+  if (instances.length === 1) {
+    [instance] = instances;
+  } else {
+    const choices = instances.map((item) => ({ title: item.name }));
+    const menu = {
+      type: 'select',
+      name: 'index',
+      message: `Pick an adapter for ${command} check`,
+      choices
+    };
+
+    console.log('\n');
+    const selected = await prompts(menu);
+    console.log('\n');
+    instance = instances[selected.index];
+  }
+
+  if (!instance) {
+    console.error('No adapter instance selected');
+    return null;
+  }
+
+  const { serviceItem: adapterConfig } = await utils.getAdapterConfig(instance._id); /* eslint-disable-line no-underscore-dangle */
+
+  console.log('\nAdapter instance configuration =>');
+  console.log('======================================');
+  console.log(adapterConfig);
+  console.log('======================================');
+
+  return adapterConfig;
+};
+
+const executeCommandOnInstance = async (command) => {
+  const adapterConfig = await getAdapterInstanceConfig(command);
+  if (!adapterConfig) {
     process.exit(0);
   }
 
-  if (command === undefined) {
-    await troubleshoot({}, true, true);
-  } else if (command === 'install') {
-    const { database, serviceItem, pronghornProps } = await getAdapterConfig();
+  switch (command) {
+    case 'connectivity': {
+      const { host } = adapterConfig.properties.properties;
+      console.log(`perform networking diagnositics to ${host}`);
+      utils.runConnectivity(host, true);
+      break;
+    }
+    case 'healthcheck': {
+      const adapterInstance = basicGet.getAdapterInstance(adapterConfig);
+      await utils.healthCheck(adapterInstance);
+      break;
+    }
+    case 'basicget': {
+      utils.runBasicGet(true);
+      break;
+    }
+    case 'troubleshoot': {
+      const adapter = { properties: adapterConfig };
+      await troubleshoot({}, true, true, adapter);
+      break;
+    }
+    default: {
+      console.error(`Unknown command: ${command}`);
+    }
+  }
+  return process.exit(0);
+};
+
+const executeUnderIAPInstallationDirectory = async (command) => {
+  if (command === 'install') {
+    const { database, serviceItem, pronghornProps } = await utils.getAdapterConfig();
     const filter = { id: pronghornProps.id };
     const profileItem = await database.collection(utils.IAP_PROFILES_COLLECTION).findOne(filter);
     if (!profileItem) {
@@ -60,9 +143,7 @@ const main = async (command) => {
           const serviceIndex = profileItem.services.indexOf(serviceItem.name);
           profileItem.services.splice(serviceIndex, 1);
           const update = { $set: { services: profileItem.services } };
-          await database.collection(utils.IAP_PROFILES_COLLECTION).updateOne(
-            { id: pronghornProps.id }, update
-          );
+          await database.collection(utils.IAP_PROFILES_COLLECTION).updateOne({ id: pronghornProps.id }, update);
           console.log(`${serviceItem.name} removed from profileItem.services.`);
           console.log(`Rerun the script to reinstall ${serviceItem.name}.`);
           process.exit(0);
@@ -74,45 +155,33 @@ const main = async (command) => {
         process.exit(0);
       }
     } else {
-      utils.verifyInstallationDir(__dirname, name);
-      utils.npmInstall();
+      const dirname = utils.getCurrentExecutionPath();
+      utils.verifyInstallationDir(dirname, name);
       utils.runTest();
       if (rls.keyInYN(`Do you want to install ${name} to IAP?`)) {
         console.log('Creating database entries...');
-        const adapter = utils.createAdapter(
-          pronghornProps, profileItem, sampleProperties, adapterPronghorn
-        );
+        const adapter = utils.createAdapter(pronghornProps, profileItem, sampleProperties, adapterPronghorn);
+        adapter.properties.properties = await addAuthInfo(adapter.properties.properties);
+
         await database.collection(utils.SERVICE_CONFIGS_COLLECTION).insertOne(adapter);
         profileItem.services.push(adapter.name);
         const update = { $set: { services: profileItem.services } };
-        await database.collection(utils.IAP_PROFILES_COLLECTION).updateOne(
-          { id: pronghornProps.id }, update
-        );
+        await database.collection(utils.IAP_PROFILES_COLLECTION).updateOne({ id: pronghornProps.id }, update);
         console.log('Database entry creation complete.');
       }
       console.log('Exiting...');
       process.exit(0);
     }
-  } else if (['healthcheck', 'basicget', 'connectivity'].includes(command)) {
-    const { serviceItem } = await getAdapterConfig();
-    if (serviceItem) {
-      const adapter = serviceItem;
-      const a = basicGet.getAdapterInstance(adapter);
-      if (command === 'healthcheck') {
-        await utils.healthCheck(a);
-        process.exit(0);
-      } else if (command === 'basicget') {
-        await utils.runBasicGet(true);
-      } else if (command === 'connectivity') {
-        const { host } = adapter.properties.properties;
-        console.log(`perform networking diagnositics to ${host}`);
-        await utils.runConnectivity(host, true);
-        process.exit(0);
-      }
-    } else {
-      console.log(`${name} not installed. Run npm \`run install:adapter\` to install.`);
-      process.exit(0);
-    }
+  } else if (['healthcheck', 'basicget', 'connectivity', 'troubleshoot'].includes(command)) {
+    await executeCommandOnInstance(command);
+  }
+};
+
+const main = async (command) => {
+  if (!utils.areWeUnderIAPinstallationDirectory()) {
+    executeInStandaloneMode(command); // configuration from sampleproperties.json
+  } else {
+    executeUnderIAPInstallationDirectory(command); // configuration from $IAP_HOME/properties.json
   }
 };
 
@@ -148,14 +217,21 @@ program
     main('basicget');
   });
 
+program
+  .command('troubleshoot')
+  .alias('tb')
+  .description('perfom troubleshooting')
+  .action(() => {
+    main('troubleshoot');
+  });
+
 // Allow commander to parse `process.argv`
 program.parse(process.argv);
 
 if (process.argv.length < 3) {
   main();
 }
-
-const allowedParams = ['install', 'healthcheck', 'basicget', 'connectivity'];
+const allowedParams = ['install', 'healthcheck', 'basicget', 'connectivity', 'troubleshoot'];
 if (process.argv.length === 3 && !allowedParams.includes(process.argv[2])) {
   console.log(`unknown parameter ${process.argv[2]}`);
   console.log('try `node troubleshootingAdapter.js -h` to see allowed parameters. Exiting...');