@itentialopensource/adapter-aruba_airwave 0.1.1

package/utils/artifactize.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+/* @copyright Itential, LLC 2019 */
+
+const fs = require('fs-extra');
+const path = require('path');
+
+async function createBundle(adapterOldDir) {
+  // set directories
+  const artifactDir = path.join(adapterOldDir, '../artifactTemp');
+  const workflowsDir = path.join(adapterOldDir, 'workflows');
+
+  // read adapter's package and set names
+  const adapterPackage = fs.readJSONSync(path.join(adapterOldDir, 'package.json'));
+  const originalName = adapterPackage.name.substring(adapterPackage.name.lastIndexOf('/') + 1);
+  const shortenedName = originalName.replace('adapter-', '');
+  const artifactName = originalName.replace('adapter', 'bundled-adapter');
+
+  const adapterNewDir = path.join(artifactDir, 'bundles', 'adapters', originalName);
+  fs.ensureDirSync(adapterNewDir);
+
+  const ops = [];
+
+  // copy old adapterDir to bundled hierarchy location
+  ops.push(() => fs.copySync(adapterOldDir, adapterNewDir));
+
+  // copy readme
+  ops.push(() => fs.copySync(path.join(adapterOldDir, 'README.md'), path.join(artifactDir, 'README.md')));
+
+  // copy changelog
+  if (fs.existsSync(path.join(adapterOldDir, 'CHANGELOG.md'))) {
+    ops.push(() => fs.copySync(path.join(adapterOldDir, 'CHANGELOG.md'), path.join(artifactDir, 'CHANGELOG.md')));
+  }
+
+  // copy license
+  if (fs.existsSync(path.join(adapterOldDir, 'LICENSE'))) {
+    ops.push(() => fs.copySync(path.join(adapterOldDir, 'LICENSE'), path.join(artifactDir, 'LICENSE')));
+  }
+
+  // create package
+  const artifactPackage = {
+    name: artifactName,
+    version: adapterPackage.version,
+    description: `A bundled version of the ${originalName} to be used in adapter-artifacts for easy installation`,
+    scripts: {
+      test: 'echo "Error: no test specified" && exit 1',
+      deploy: 'npm publish --registry=http://registry.npmjs.org'
+    },
+    keywords: [
+      'IAP',
+      'artifacts',
+      'Itential',
+      'Pronghorn',
+      'Adapter',
+      'Adapter-Artifacts',
+      shortenedName
+    ],
+    author: 'Itential Artifacts',
+    license: 'Apache-2.0',
+    repository: adapterPackage.repository,
+    private: false,
+    devDependencies: {
+      r2: '^2.0.1',
+      ajv: '6.10.0',
+      'better-ajv-errors': '^0.6.1',
+      'fs-extra': '^7.0.1'
+    }
+  };
+
+  ops.push(() => fs.writeJSONSync(path.join(artifactDir, 'package.json'), artifactPackage, { spaces: 2 }));
+
+  // create manifest
+  const manifest = {
+    bundleName: originalName,
+    version: adapterPackage.version,
+    fingerprint: 'Some verifiable token',
+    createdEpoch: '1554836984020',
+    artifacts: [
+      {
+        id: `${shortenedName}-adapter`,
+        name: `${shortenedName}-adapter`,
+        type: 'adapter',
+        location: `/bundles/adapters/${originalName}`,
+        description: artifactPackage.description,
+        properties: {
+          entryPoint: false
+        }
+      }
+    ]
+  };
+
+  // add workflows into artifact
+  if (fs.existsSync(workflowsDir)) {
+    const workflowFileNames = fs.readdirSync(workflowsDir);
+
+    // if folder isnt empty and only file is not readme
+    if (workflowFileNames.length !== 0 && (!(workflowFileNames.length === 1 && workflowFileNames[0].split('.')[1] === 'md'))) {
+      // add workflows to correct location in bundle
+      ops.push(() => fs.copySync(workflowsDir, path.join(artifactDir, 'bundles', 'workflows')));
+
+      // add workflows to manifest
+      workflowFileNames.forEach((filename) => {
+        const [filenameNoExt, ext] = filename.split('.');
+        if (ext === 'json') {
+          manifest.artifacts.push({
+            id: `workflow-${filenameNoExt}`,
+            name: filenameNoExt,
+            type: 'workflow',
+            location: `/bundles/workflows/${filename}`,
+            description: 'Main entry point to artifact',
+            properties: {
+              entryPoint: false
+            }
+          });
+        }
+      });
+    }
+  }
+
+  ops.push(() => fs.writeJSONSync(path.join(artifactDir, 'manifest.json'), manifest, { spaces: 2 }));
+
+  // Run the commands in parallel
+  try {
+    await Promise.all(ops.map(async (op) => op()));
+  } catch (e) {
+    throw new Error(e);
+  }
+
+  const pathObj = {
+    bundlePath: artifactDir,
+    bundledAdapterPath: path.join(artifactDir, 'bundles', 'adapters', originalName)
+  };
+  return pathObj;
+}
+
+async function artifactize(entryPathToAdapter) {
+  const truePath = path.resolve(entryPathToAdapter);
+  const packagePath = path.join(truePath, 'package');
+  // remove adapter from package and move bundle in
+  const pathObj = await createBundle(packagePath);
+  const { bundlePath } = pathObj;
+  fs.removeSync(packagePath);
+  fs.moveSync(bundlePath, packagePath);
+  return 'Bundle successfully created and old folder system removed';
+}
+
+module.exports = { createBundle, artifactize };

package/utils/basicGet.js

@@ -0,0 +1,63 @@
+/* @copyright Itential, LLC 2020 */
+
+/* eslint object-shorthand: warn */
+/* eslint import/no-extraneous-dependencies: warn */
+/* eslint global-require: warn */
+/* eslint import/no-unresolved: 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
+    );
+  },
+
+  /**
+   * @summary connect to mongodb
+   *
+   * @function connect
+   * @param {Object} properties - pronghornProps
+   */
+  connect: async function connect(properties) {
+    // Connect to Mongo
+    const { MongoDBConnection } = require('@itential/database');
+    const connection = new MongoDBConnection(properties.mongoProps);
+    const database = await connection.connect(true);
+    return database;
+  }
+};
+
+module.exports = basicGet;

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');
+});

package/utils/pre-commit.sh

@@ -0,0 +1,27 @@
+#!/bin/sh
+# @copyright Itential, LLC 2019
+
+#exit on any failure in the pipeline
+set -e
+
+# --------------------------------------------------
+# pre-commit
+# --------------------------------------------------
+# Contains the standard set of tasks to runbefore
+# committing changes to the repo. If any tasks fail
+# then the commit will be aborted.
+# --------------------------------------------------
+
+printf "%b" "Running pre-commit hooks...\\n"
+
+# verify testing script is stubbed and no credentials
+node utils/testRunner.js -r
+
+# security audit on the code
+npm audit --registry=https://registry.npmjs.org --audit-level=moderate
+
+# lint the code
+npm run lint
+
+# test the code
+npm run test

package/utils/setup.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+/* @copyright Itential, LLC 2019 */
+
+const fs = require('fs');
+
+/**
+ * This script will execute before an npm install command. The purpose is to
+ * write out some standard git hooks that will enable folks working on this
+ * project to benefit from the protections that the hooks provide.
+ */
+
+const precommit = fs.readFileSync('utils/pre-commit.sh', 'utf8');
+
+fs.stat('.git', (err) => {
+  if (err == null) {
+    // git repo, not an npm repo.
+    // add pre-commit hook if it doesn't exist
+    fs.stat('.git/hooks/pre-commit', (statErr) => {
+      if (statErr == null || statErr.code === 'ENOENT') {
+        fs.writeFile('.git/hooks/pre-commit', precommit, {
+          mode: 0o755
+        }, (writeErr) => {
+          if (writeErr) {
+            return console.log(writeErr.message);
+          }
+          return null;
+        });
+      } else {
+        console.log(statErr.message);
+      }
+    });
+  }
+});

package/utils/tbScript.js

@@ -0,0 +1,163 @@
+/* eslint no-console: warn */
+/* eslint import/no-unresolved: warn */
+/* eslint global-require: warn */
+
+// suppress eslint rule in adapter
+/* eslint arrow-parens: warn */
+/* 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 utils = require('./tbUtils');
+const basicGet = require('./basicGet');
+const { name } = require('../package.json');
+const sampleProperties = require('../sampleProperties.json');
+const adapterPronghorn = require('../pronghorn.json');
+
+const { troubleshoot, getAdapterConfig, offline } = require('./troubleshootingAdapter');
+
+const main = async (command) => {
+  const iapDir = path.join(__dirname, '../../../../');
+  if (!utils.withinIAP(iapDir)) {
+    if (command === 'connectivity') {
+      const { host } = sampleProperties.properties;
+      console.log(`perform networking diagnositics to ${host}`);
+      await utils.runConnectivity(host);
+      process.exit(0);
+    } else if (command === 'healthcheck') {
+      const a = basicGet.getAdapterInstance({ properties: sampleProperties });
+      await utils.healthCheck(a);
+      process.exit(0);
+    } else if (command === 'basicget') {
+      await utils.runBasicGet();
+      process.exit(0);
+    }
+    if (rls.keyInYN('Troubleshooting without IAP?')) {
+      await offline();
+    }
+    process.exit(0);
+  }
+
+  if (command === undefined) {
+    await troubleshoot({}, true, true);
+  } else if (command === 'install') {
+    const { database, serviceItem, pronghornProps } = await getAdapterConfig();
+    const filter = { id: pronghornProps.id };
+    const profileItem = await database.collection(utils.IAP_PROFILES_COLLECTION).findOne(filter);
+    if (!profileItem) {
+      console.log(`Could not find IAP profile for id ${pronghornProps.id}`);
+      process.exit(0);
+    }
+    if (serviceItem) {
+      console.log(`A service by the name ${name} already exits!`);
+      if (rls.keyInYN(`Do you want to completely remove ${name}?`)) {
+        console.log(`Removing ${name} from db...`);
+        await database.collection(utils.SERVICE_CONFIGS_COLLECTION).deleteOne({ model: name });
+        console.log(`${name} removed from db.`);
+        if (profileItem.services.includes(serviceItem.name)) {
+          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
+          );
+          console.log(`${serviceItem.name} removed from profileItem.services.`);
+          console.log(`Rerun the script to reinstall ${serviceItem.name}.`);
+          process.exit(0);
+        } else {
+          process.exit(0);
+        }
+      } else {
+        console.log('Exiting...');
+        process.exit(0);
+      }
+    } else {
+      utils.verifyInstallationDir(__dirname, name);
+      utils.npmInstall();
+      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
+        );
+        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
+        );
+        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);
+    }
+  }
+};
+
+program
+  .command('connectivity')
+  .alias('c')
+  .description('networking diagnostics')
+  .action(() => {
+    main('connectivity');
+  });
+
+program
+  .command('install')
+  .alias('i')
+  .description('install current adapter')
+  .action(() => {
+    main('install');
+  });
+
+program
+  .command('healthcheck')
+  .alias('hc')
+  .description('perfom none interative healthcheck with current setting')
+  .action(() => {
+    main('healthcheck');
+  });
+
+program
+  .command('basicget')
+  .alias('bg')
+  .description('perfom basicget')
+  .action(() => {
+    main('basicget');
+  });
+
+// Allow commander to parse `process.argv`
+program.parse(process.argv);
+
+if (process.argv.length < 3) {
+  main();
+}
+
+const allowedParams = ['install', 'healthcheck', 'basicget', 'connectivity'];
+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...');
+  process.exit(0);
+}