@itentialopensource/adapter-f5_bigiq 0.5.7 → 0.6.0

package/utils/modify.js

@@ -1,29 +1,7 @@
 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
@@ -70,21 +48,20 @@ function revertMod() {
       fs.removeSync(file);
     }
   });
-  // // unzip previousVersion, reinstall dependencies and delete zipfile
+  // 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();
+/**
+ * @summary Handle migration logic
+ */
+function handleMigration() {
+  if (!existsSync('migrationPackage.zip')) {
+    throw new Error('Migration Package not found. Download and place migrationPackage in the adapter root directory');
   }
-  // Backup current adapter
+
   backup();
   console.log('Migrating adapter and running tests...');
   const migrateCmd = 'unzip -o migrationPackage.zip'
@@ -92,61 +69,85 @@ if (flags === '-m') {
     + ' && 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 (migrateOutput.includes('Lint exited with code 1') || migrateOutput.includes('Tests exited with code 1')) {
     if (rls.keyInYN('Adapter failed tests or lint after migrating. Would you like to revert the changes?')) {
       console.log('Reverting changes...');
       revertMod();
-      process.exit();
+      throw new Error('Adapter failed tests or lint after migrating. Changes reverted');
     }
     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();
-  });
+  archiveMod('MIG');
 }
 
-// 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();
+/**
+ * @summary Handle update logic
+ */
+function handleUpdate() {
+  if (!existsSync('updatePackage.zip')) {
+    throw new Error('Update Package not found. Download and place updateAdapter.zip in the adapter root directory');
   }
-  // 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 (updateOutput.includes('Lint exited with code 1') || updateOutput.includes('Tests exited with code 1')) {
     if (rls.keyInYN('Adapter failed tests or lint after updating. Would you like to revert the changes?')) {
       console.log('Reverting changes...');
       revertMod();
-      process.exit();
+      throw new Error('Adapter failed tests or lint after updating. Changes reverted');
     }
     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();
+/**
+ * @summary Handle revert logic
+ */
+function handleRevert() {
+  if (!existsSync('previousVersion.zip')) {
+    throw new Error('Previous adapter version not found. There are no changes to revert');
   }
   revertMod();
 }
+
+/**
+ * @summary Entrypoint for the script
+ */
+function main() {
+  const flags = process.argv[2];
+
+  switch (flags) {
+    case '-m':
+      return handleMigration();
+    case '-u':
+      return handleUpdate();
+    case '-r':
+      return handleRevert();
+    default:
+      throw new Error('Invalid flag. Use -m for migrate, -u for update, or -r for revert.');
+  }
+}
+
+try {
+  main();
+  process.exit(0);
+} catch (error) {
+  console.error(error.message || error);
+  process.exit(1);
+}

package/utils/mongoDbConnection.js

@@ -0,0 +1,79 @@
+// Set globals
+/* global log */
+
+const { MongoClient } = require('mongodb');
+const MongoUtils = require('./mongoUtils');
+
+class MongoDBConnection {
+  constructor(properties) {
+    this.properties = properties;
+    this.initialize(properties);
+  }
+
+  initialize(properties) {
+    const {
+      url, database, maxPoolSize, appname
+    } = properties;
+
+    // Handle URL first - if provided, it takes precedence
+    if (url) {
+      const urlObj = new URL(url);
+      const urlDbName = urlObj.pathname.slice(1);
+      this.dbName = database || urlDbName;
+
+      // Update URL if database name is different
+      if (this.dbName !== urlDbName) {
+        urlObj.pathname = `${this.dbName}`;
+      }
+
+      this.url = urlObj.toString();
+    } else {
+      const connectionObj = MongoUtils.generateConnectionObj(properties);
+      this.url = MongoUtils.generateConnectionString(connectionObj);
+      this.dbName = database;
+    }
+
+    // Set options using generateTlsSettings
+    this.options = MongoUtils.generateTlsSettings(properties);
+
+    // Add maxPoolSize if configured
+    if (maxPoolSize > 0 && maxPoolSize <= 65535) {
+      this.options.maxPoolSize = maxPoolSize;
+    }
+
+    // Add application name if provided
+    if (appname) {
+      this.options.appname = appname;
+    }
+  }
+
+  async closeConnection() {
+    if (this.connection && this.connection.close) {
+      try {
+        await this.connection.close();
+      } catch (err) {
+        log.error(`Failed to close MongoDB connection - ${err.message}`);
+      }
+    }
+  }
+
+  async connect() {
+    const client = new MongoClient(this.url, this.options);
+
+    client.on('serverHeartbeatSucceeded', (msg) => log.info(`Connection established and heartbeat succeeded - ${JSON.stringify(msg)}`));
+    client.on('connectionClosed', (msg) => log.info(`Connection closed - ${JSON.stringify(msg)}`));
+    client.on('error', (msg) => log.error(`Connection error - ${JSON.stringify(msg)}`));
+    client.on('commandFailed', (msg) => log.error(`Command failed - ${JSON.stringify(msg)}`));
+    client.on('serverHeartbeatFailed', (msg) => log.error(`Connection timeout - ${JSON.stringify(msg)}`));
+
+    await client.connect().catch((error) => {
+      throw new Error(MongoUtils.resolveMongoError(error));
+    });
+
+    this.db = client.db(this.dbName);
+    this.connection = client;
+    return this;
+  }
+}
+
+module.exports = MongoDBConnection;

package/utils/mongoUtils.js

@@ -0,0 +1,162 @@
+const fs = require('fs-extra');
+
+class MongoUtils {
+  /**
+     * Parses a MongoDB connection string and extracts its components.
+     * @param {string} connectionString - The MongoDB connection string.
+     * @returns {object} Parsed connection details.
+     */
+  static parseConnectionString(connectionString) {
+    try {
+      const url = new URL(connectionString);
+      return {
+        protocol: url.protocol.replace(':', ''),
+        host: url.hostname,
+        port: url.port || '27017',
+        database: url.pathname.replace('/', ''),
+        username: url.username || null,
+        password: url.password || null,
+        options: Object.fromEntries(url.searchParams.entries())
+      };
+    } catch (error) {
+      throw new Error(`Invalid MongoDB URI: ${error.message}`);
+    }
+  }
+
+  /**
+     * Generates a MongoDB connection string from given properties.
+     * @param {object} config - MongoDB connection properties.
+     * @returns {string} A valid MongoDB connection string.
+     */
+  static generateConnectionString(config) {
+    // Determine protocol based on addSrv flag
+    const protocol = config.addSrv ? 'mongodb+srv' : 'mongodb';
+
+    // Build authentication part if credentials are provided and dbAuth is true
+    const authPart = (config.dbAuth && config.username && config.password)
+      ? `${encodeURIComponent(config.username)}:${encodeURIComponent(config.password)}@`
+      : '';
+
+    // Build host and port part
+    const hostPart = config.host;
+    const portPart = !config.addSrv && config.port ? `:${config.port}` : '';
+
+    // Build options part
+    let optionsPart = '';
+    if (config.options && Object.keys(config.options).length) {
+      optionsPart = `?${new URLSearchParams(config.options).toString()}`;
+    }
+
+    // Build database part
+    const dbPart = config.database ? `/${config.database}` : '';
+
+    return `${protocol}://${authPart}${hostPart}${portPart}${dbPart}${optionsPart}`;
+  }
+
+  /**
+     * Generates TLS settings for MongoDB connection
+     * @param {object} properties - Connection properties containing TLS configuration
+     * @returns {object} TLS settings object
+     */
+  static generateTlsSettings(properties) {
+    // Handle TLS properties
+    if (properties.tls) {
+      return {
+        tls: properties.tls.enabled,
+        tlsAllowInvalidCertificates: properties.tls.tlsAllowInvalidCertificates || false,
+        tlsCAFile: properties.tls.tlsCAFile
+      };
+    }
+
+    // Handle db_ssl properties (standard adapter format)
+    if (!properties.db_ssl) {
+      return { tls: false };
+    }
+
+    const tlsProperties = {
+      tls: properties.db_ssl.enabled || false,
+      tlsAllowInvalidCertificates: properties.db_ssl.accept_invalid_cert || false
+    };
+
+    const hasValidCaFile = properties.db_ssl.enabled && properties.db_ssl.ca_file && fs.existsSync(properties.db_ssl.ca_file);
+
+    if (hasValidCaFile) {
+      tlsProperties.tlsCAFile = properties.db_ssl.ca_file;
+    }
+
+    return tlsProperties;
+  }
+
+  /**
+     * Generates a connection object from properties
+     * @param {object} properties - Connection properties
+     * @returns {object} Connection object with host, port, database, and credentials
+     */
+  static generateConnectionObj(properties) {
+    try {
+      const connectionObj = {
+        host: properties.host,
+        port: properties.port,
+        database: properties.database,
+        addSrv: properties.addSrv || false,
+        dbAuth: properties.dbAuth || false,
+        options: properties.replSet && !properties.addSrv ? { replicaSet: properties.replSet } : undefined
+      };
+
+      // Only include credentials if dbAuth is true
+      if (properties.dbAuth) {
+        // Validate that both username and password are provided when dbAuth is true
+        if (!properties.username || !properties.password) {
+          throw new Error('Both username and password are required when dbAuth is enabled');
+        }
+        connectionObj.username = properties.username;
+        connectionObj.password = properties.password;
+      }
+
+      return connectionObj;
+    } catch (error) {
+      throw new Error(`Invalid MongoDB configuration: ${error.message}`);
+    }
+  }
+
+  /**
+     * Resolves MongoDB error messages to user-friendly format
+     * @param {object} mongoError - The MongoDB error object
+     * @returns {string} User-friendly error message
+     */
+  static resolveMongoError(mongoError) {
+    if (mongoError && mongoError.code === 13) {
+      return 'User unauthorized to perform the requested action: ';
+    }
+    if (mongoError && mongoError.code === 18) {
+      return `User Authentication failed. Username/Password combination is incorrect ${mongoError}`;
+    }
+    return mongoError;
+  }
+
+  /**
+     * Helper function to validate and process MongoDB connection properties
+     * @param {Object} mongoProps - MongoDB connection properties to validate
+     * @returns {Object|undefined} - Validated and processed MongoDB properties or undefined if invalid
+    */
+  static getAndValidateMongoProps(mongoProps) {
+    if (!mongoProps) return undefined;
+
+    // Handle URL-based connection
+    const url = mongoProps.url && mongoProps.url.trim();
+    if (!url) {
+      // Handle host-based connection
+      const hasHost = mongoProps.hostname || mongoProps.host;
+      const hasDatabase = mongoProps.database;
+      return (hasHost && hasDatabase) ? mongoProps : undefined;
+    }
+
+    // Process URL-based connection
+    const props = { ...mongoProps };
+    const { database } = props;
+    const urlHasDatabase = database && url.includes(`/${database}`);
+    return urlHasDatabase ? props : { ...props, url: `${url}/${database}` };
+  }
+}
+
+module.exports = MongoUtils;

package/utils/taskMover.js

@@ -9,30 +9,32 @@ const blacklistTasks = [
 ];
 
 const adapterBaseTasks = [
-    'getDevicesFiltered',
-    'isAlive',
-    'getConfig',
-    'getDevice',
-    'iapUpdateAdapterConfiguration',
-    'iapFindAdapterPath',
-    'iapSuspendAdapter',
-    'iapUnsuspendAdapter',
-    'iapGetAdapterQueue',
-    'iapTroubleshootAdapter',
-    'iapRunAdapterHealthcheck',
-    'iapRunAdapterConnectivity',
-    'iapRunAdapterBasicGet',
-    'iapMoveAdapterEntitiesToDB',
-    'getDevice',
-    'getDevicesFiltered',
-    'isAlive',
-    'getConfig',
-    'iapGetDeviceCount',
-    'iapRunAdapterLint',
-    'iapRunAdapterTests',
-    'iapGetAdapterInventory'
+  'getDevicesFiltered',
+  'isAlive',
+  'getConfig',
+  'getDevice',
+  'iapUpdateAdapterConfiguration',
+  'iapFindAdapterPath',
+  'iapSuspendAdapter',
+  'iapUnsuspendAdapter',
+  'iapGetAdapterQueue',
+  'iapTroubleshootAdapter',
+  'iapRunAdapterHealthcheck',
+  'iapRunAdapterConnectivity',
+  'iapRunAdapterBasicGet',
+  'iapMoveAdapterEntitiesToDB',
+  'getDevice',
+  'getDevicesFiltered',
+  'isAlive',
+  'getConfig',
+  'iapGetDeviceCount',
+  'iapRunAdapterLint',
+  'iapRunAdapterTests',
+  'iapGetAdapterInventory'
 ];
 
+let shouldExitWithFailure = false;
+
 function updatePronghorn(tasks, original, updated) {
   const originalFile = require(original);
   const unusedMethods = [];
@@ -57,15 +59,13 @@ function updatePronghorn(tasks, original, updated) {
   return 'Done';
 }
 
-function flipTaskFlag(task, pronghornPath, value)
-{
+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 = [
@@ -86,12 +86,8 @@ 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');
@@ -99,7 +95,6 @@ function updateAdapterJs(tasks, original, updated, adapterDir) {
   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');
   }
@@ -223,6 +218,7 @@ function activateTasks(adapterDir, tasks) {
     return 'success';
   } catch (e) {
     console.log(`Error: ${e} ocurred during execution. Rolling back changes.`);
+    shouldExitWithFailure = true;
     for (let i = 0; i < backupFiles.length; i++) {
       const file = fs.readFileSync(backupFiles[i], 'utf8');
       fs.writeFileSync(filePaths[i], file, 'utf8');
@@ -233,7 +229,6 @@ function activateTasks(adapterDir, tasks) {
       }
     });
     deleteBackups(adapterDir);
-    process.exit(1);
   }
 }
 
@@ -290,6 +285,7 @@ function deactivateTasks(adapterDir, tasks) {
     return 'success';
   } catch (e) {
     console.log(`Error: ${e} ocurred during execution. Rolling back changes.`);
+    shouldExitWithFailure = true;
     for (let i = 0; i < backupFiles.length; i++) {
       const file = fs.readFileSync(backupFiles[i], 'utf8');
       fs.writeFileSync(filePaths[i], file, 'utf8');
@@ -300,10 +296,13 @@ function deactivateTasks(adapterDir, tasks) {
       }
     });
     deleteBackups(adapterDir);
-    process.exit(1);
   }
 }
 
+if (shouldExitWithFailure) {
+  process.exit(1);
+}
+
 module.exports = {
   activateTasks, deactivateTasks, rollbackChanges, deleteBackups
 };