@itentialopensource/adapter-db_mysql 0.1.11 → 0.1.15

package/CHANGELOG.md

@@ -1,4 +1,36 @@
 
+## 0.1.15 [08-03-2022]
+
+* Patch/adapt 2277
+
+See merge request itentialopensource/adapters/persistence/adapter-db_mysql!9
+
+---
+
+## 0.1.14 [08-01-2022]
+
+* Patch/adapt 2277
+
+See merge request itentialopensource/adapters/persistence/adapter-db_mysql!8
+
+---
+
+## 0.1.13 [08-01-2022]
+
+* Changed connection handling. Added healthcheck.
+
+See merge request itentialopensource/adapters/persistence/adapter-db_mysql!7
+
+---
+
+## 0.1.12 [08-10-2021]
+
+* change the connection and base wait
+
+See merge request itentialopensource/adapters/persistence/adapter-db_mysql!6
+
+---
+
 ## 0.1.11 [08-10-2021]
 
 * add delays in the connect retries

package/adapter.js

@@ -19,8 +19,6 @@ const EventEmitter = require('events');
 
 let myid = null;
 let errors = [];
-const baseWait = 10000;
-const incrWait = 20000;
 
 /**
  * @summary Build a standard error object from the data provided
@@ -103,7 +101,6 @@ class MySQL extends EventEmitter {
     super();
 
     this.props = properties;
-    this.alive = false;
     this.id = prongid;
     myid = prongid;
 
@@ -119,60 +116,52 @@ class MySQL extends EventEmitter {
     // Read the action from the file system
     const errorData = JSON.parse(fs.readFileSync(errorFile, 'utf-8'));
     ({ errors } = errorData);
-  }
 
-  /**
-   * Itential connect call for system green/red light
-   *
-   * @param {function} callback
-   */
-  connect() {
-    const meth = 'adapter-connect';
-    const origin = `${this.id}-${meth}`;
-    log.trace(origin);
+    this.setConfiguration();
+  }
 
-    const config = {
+  setConfiguration() {
+    this.config = {
       host: this.props.host,
       port: this.props.port,
       user: this.props.authentication.username,
       password: this.props.authentication.password,
       database: this.props.database,
-      acquireTimeout: this.props.acquireTimout || 1000000
+      ...this.props.connectionOptions
     };
 
+    this.healthcheckType = this.props.healthcheck.type;
+    this.healthcheckInterval = this.props.healthcheck.frequency;
+
     if (this.props.ssl) {
       if (this.props.ssl.enabled === true) {
         log.info('Connecting to MySQL with SSL.');
         // validate the server's certificate
         if (this.props.ssl.accept_invalid_cert === false) {
           log.info('Certificate based SSL MySQL connections will be used.');
-          config.ssl = {
+          this.config.ssl = {
             rejectUnauthorized: true
           };
           // if validation is enabled, we need to read the CA file
           if (this.props.ssl.ca_file) {
             try {
-              config.ssl.ca = fs.readFileSync(this.props.ssl.ca_file);
+              this.config.ssl.ca = fs.readFileSync(this.props.ssl.ca_file);
             } catch (err) {
               log.error(`Error: Unable to load MySQL CA file: ${err}`);
-              this.alive = false;
               this.emit('OFFLINE', {
                 id: this.id
               });
-              return;
             }
           } else {
             log.error('Error: Certificate validation'
               + 'is enabled but a CA is not specified.');
-            this.alive = false;
             this.emit('OFFLINE', {
               id: this.id
             });
-            return;
           }
         } else {
           log.info('SSL MySQL connection without CA certificate validation.');
-          config.ssl = {
+          this.config.ssl = {
             rejectUnauthorized: false
           };
         }
@@ -182,19 +171,40 @@ class MySQL extends EventEmitter {
     } else {
       log.warn('WARNING: Connecting to MySQL without SSL.');
     }
+  }
+
+  /**
+   * Itential connect call for system green/red light
+   *
+   * @param {function} callback
+   */
+  connect() {
+    const meth = 'adapter-connect';
+    const origin = `${this.id}-${meth}`;
+    log.trace(origin);
+
+    // initially set as off
+    this.emit('OFFLINE', { id: this.id });
 
-    // get connection
-    this.connection = mysql.createConnection(config);
-    this.attempt = 1;
-    this.waitTime = baseWait;
     this.dbconnect();
 
-    this.connection.on('error', (myerr) => {
-      this.attempt += 1;
-      log.error(`Connection to MySQL took an error: ${myerr}`);
-      log.error(`Attampting Reconnect - attempt number ${this.attempt}`);
-      this.dbconnect();
-    });
+    if (this.healthcheckType === 'none') {
+      log.error(`${origin}: Waiting 1 Seconds to emit Online`);
+      setTimeout(() => {
+        this.emit('ONLINE', { id: this.id });
+        this.healthy = true;
+      }, 1000);
+    }
+
+    if (this.healthcheckType === 'startup' || this.healthcheckType === 'intermittent') {
+      this.healthCheck();
+    }
+
+    if (this.healthcheckType === 'intermittent') {
+      setInterval(() => {
+        this.healthCheck();
+      }, this.healthcheckInterval);
+    }
   }
 
   /**
@@ -207,82 +217,46 @@ class MySQL extends EventEmitter {
     const origin = `${this.id}-${meth}`;
     log.trace(origin);
 
-    if (this.attempt <= 5) {
-      setTimeout(() => {
-        this.connection.connect((error) => {
-          if (error) {
-            // emit failure
-            this.alive = false;
-            this.emit('OFFLINE', {
-              id: this.id
-            });
-            // increase the attempts and the timeout
-            this.attempt += 1;
-            this.waitTime += incrWait;
-            log.error(`error connecting to MySQL: ${error}`);
-            log.error(`Attampting Reconnect - attempt number ${this.attempt}`);
-            this.dbconnect();
-          } else {
-            // emit success
-            this.alive = true;
-            this.emit('ONLINE', {
-              id: this.id
-            });
-            // reset the attempts and timeout
-            this.attempt = 0;
-            this.waitTime = baseWait;
-            log.info(`connected as id: ${this.connection.threadId}`);
-          }
-        });
-      }, this.waitTime);
-    } else {
-      log.error('Maximum retries reached - check mysql and then restart the adapter!');
-    }
+    log.info(`Creating connection pool to mysql on host: ${this.config.host} and port: ${this.config.port}`);
+
+    this.pool = mysql.createPool(this.config);
+
+    this.pool.on('acquire', (connection) => log.debug('Connection', connection.threadId, 'acquired'));
+
+    this.pool.on('connection', (connection) => log.debug('New connection made within the pool:', connection.threadId, connection.state));
+
+    this.pool.on('enqueue', () => log.debug('Waiting for available connection slot'));
+
+    this.pool.on('release', (connection) => log.debug('Connection', connection.threadId, 'released'));
   }
 
   /**
    * Call to run a healthcheck on the mysql database
    *
    * @function healthCheck
-   * @param {healthCallback} callback - a callback function to return a result
-   *                                    healthcheck success or failure
    */
-  healthCheck(callback) {
+  healthCheck() {
     const meth = 'adapter-healthCheck';
     const origin = `${this.id}-${meth}`;
     log.trace(origin);
 
     try {
-      // verify that we are connected to MySQL
-      if (!this.alive || !this.connection) {
+      if (!this.pool) {
         log.error('Error during healthcheck: Not connected to MySQL Database');
-        return callback({
-          id: this.id,
-          status: 'fail'
-        });
+        return this.emit('OFFLINE', { id: this.id });
       }
 
-      this.connection.query('SELECT "test";', (error, results, fields) => {
+      this.pool.query('SELECT 1;', (error, results, fields) => {
         if (error) {
-          log.error(`Error during healthcheck: ${error}`);
-          return callback({
-            id: this.id,
-            status: 'fail'
-          });
+          log.error(`HEALTHCHECK FAIL, ${JSON.stringify(error)}`);
+          return this.emit('OFFLINE', { id: this.id });
         }
-
-        log.info(`result from mysql connect: ${JSON.stringify(results)}`);
-        return callback({
-          id: this.id,
-          status: 'success'
-        });
+        log.debug('HEALTHCHECK SUCCESSFUL');
+        return this.emit('ONLINE', { id: this.id });
       });
     } catch (ex) {
-      log.error(`Exception during healthcheck: ${ex}`);
-      return callback({
-        id: this.id,
-        status: 'fail'
-      });
+      log.error(`HEALTHCHECK EXCEPTION: ${JSON.stringify(ex)}`);
+      return this.emit('OFFLINE', { id: this.id });
     }
   }
 
@@ -326,7 +300,7 @@ class MySQL extends EventEmitter {
         break;
       }
       if (myfunctions[m] !== 'connect' && myfunctions[m] !== 'healthCheck' && myfunctions[m] !== 'dbconnect'
-        && myfunctions[m] !== 'getAllFunctions' && myfunctions[m] !== 'getWorkflowFunctions') {
+        && myfunctions[m] !== 'getAllFunctions' && myfunctions[m] !== 'getWorkflowFunctions' && myfunctions[m] !== 'setConfiguration') {
         wffunctions.push(myfunctions[m]);
       }
     }
@@ -345,39 +319,22 @@ class MySQL extends EventEmitter {
     const origin = `${this.id}-${meth}`;
     log.trace(origin);
     log.trace(`mysql query started with sql: ${sql}`);
-    try {
-      // verify the required data has been provided
-      if (!sql) {
-        const errorObj = formatErrorObject(origin, 'Missing Data', ['sql'], null, null, null);
-        log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
-        return callback(null, errorObj);
-      }
 
-      // if the connection is not up attempt to reconnect
-      if (!this.alive || !this.connection) {
-        this.connect();
-        if (!this.alive || !this.connection) {
-          return callback({
-            id: this.id,
-            status: 'fail'
-          });
-        }
-      }
-
-      // query connection
-      this.connection.query(sql, (error, results, fields) => {
-        // close connection
-        // this.connection.end();
+    if (!sql) {
+      const errorObj = formatErrorObject(origin, 'Missing Data', ['sql'], null, null, null);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
 
+    try {
+      this.pool.query(sql, (error, results, fields) => {
         log.debug(`result from query: ${JSON.stringify(results)}`);
-        log.debug(`result from query: ${JSON.stringify(fields)}`);
-
+        log.debug(`fields from query: ${JSON.stringify(fields)}`);
         if (error) {
           const errorObj = formatErrorObject(origin, 'Database Error', [error], null, null, null);
           log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
           return callback(null, errorObj);
         }
-
         return callback({
           status: 'success',
           code: 200,

package/package.json

@@ -1,20 +1,20 @@
 {
   "name": "@itentialopensource/adapter-db_mysql",
-  "version": "0.1.11",
+  "version": "0.1.15",
   "description": "Itential adapter to connect to mysql",
   "main": "adapter.js",
   "wizardVersion": "2.41.0",
   "engineVersion": "1.44.2",
   "scripts": {
     "artifactize": "npm i && node utils/packModificationScript.js",
-    "preinstall": "node utils/setup.js",
+    "preinstall": "node utils/setup.js && npm install --package-lock-only --ignore-scripts && npx npm-force-resolutions",
     "lint": "eslint . --ext .json --ext .js",
     "lint:errors": "node --max_old_space_size=4096 ./node_modules/eslint/bin/eslint.js . --ext .json --ext .js --quiet",
     "test:unit": "mocha test/unit/adapterTestUnit.js --LOG=error",
     "test:integration": "mocha test/integration/adapterTestIntegration.js --LOG=error",
     "test:cover": "nyc --reporter html --reporter text mocha --reporter dot test/*",
     "test": "npm run test:unit && npm run test:integration",
-    "deploy": "npm publish --registry=http://registry.npmjs.org --access=public",
+    "deploy": "npm publish --registry=https://registry.npmjs.org --access=public",
     "build": "npm run deploy"
   },
   "keywords": [
@@ -46,16 +46,19 @@
     "uuid": "^3.0.1"
   },
   "devDependencies": {
-    "chai": "^4.3.4",
+    "chai": "^4.3.6",
     "eslint": "^7.29.0",
     "eslint-config-airbnb-base": "^14.2.1",
-    "eslint-plugin-import": "^2.23.4",
+    "eslint-plugin-import": "^2.26.0",
     "eslint-plugin-json": "^3.0.0",
-    "mocha": "^9.0.1",
+    "mocha": "^9.2.2",
     "nyc": "^15.1.0",
     "package-json-validator": "^0.6.3",
-    "testdouble": "^3.16.1",
-    "winston": "^3.3.3"
+    "testdouble": "^3.16.6",
+    "winston": "^3.8.1"
   },
-  "private": false
+  "private": false,
+  "resolutions": {
+    "minimist": "^1.2.5"
+  }
 }

package/propertiesSchema.json

@@ -27,23 +27,40 @@
       "maximum": 65535
     },
     "authentication": {
-      "$ref":"#/definitions/authentication"
+      "$ref": "#/definitions/authentication",
+      "default": {}
     },
     "ssl": {
-      "$ref":"#/definitions/ssl"
+      "$ref": "#/definitions/ssl",
+      "default": {}
+    },
+    "connectionOptions": {
+      "$ref": "#/definitions/connectionOptions",
+      "default": {}
+    },
+    "healthcheck": {
+      "$ref": "#/definitions/healthcheck",
+      "default": {}
     }
   },
-  "required" : ["database","host","port"],
+  "required": [
+    "database",
+    "host",
+    "port",
+    "authentication",
+    "healthcheck",
+    "connectionOptions"
+  ],
   "definitions": {
     "authentication": {
       "$id": "/authentication",
       "type": "object",
       "properties": {
-        "dbAuth" : {
-            "$id" : "/credentials/properties/dbAuth",
-            "type" : "boolean",
-            "description": "whether or not to use user authentication to connect to mysql",
-            "default" : false
+        "dbAuth": {
+          "$id": "/credentials/properties/dbAuth",
+          "type": "boolean",
+          "description": "whether or not to use user authentication to connect to mysql",
+          "default": false
         },
         "password": {
           "type": "string",
@@ -62,7 +79,10 @@
           ]
         }
       },
-      "required" : ["username","password"]
+      "required": [
+        "username",
+        "password"
+      ]
     },
     "ssl": {
       "$id": "/ssl",
@@ -72,7 +92,7 @@
           "$id": "/ssl/properties/enabled",
           "type": "boolean",
           "description": "Whether or not ssl is enabled on PostgreSQL",
-          "default": false            
+          "default": false
         },
         "accept_invalid_cert": {
           "$id": "/ssl/properties/accept_invalid_cert",
@@ -90,20 +110,133 @@
           ]
         }
       },
-      "required" : ["enabled"],
+      "required": [
+        "enabled"
+      ],
       "allOf": [
         {
-          "if" : { "properties" : { "enabled": { "enum": [true] } } },
-          "then" : { "required" : ["acceptInvalidCerts", "checkServerIdentity"] }
+          "if": {
+            "properties": {
+              "enabled": {
+                "enum": [
+                  true
+                ]
+              }
+            }
+          },
+          "then": {
+            "required": [
+              "acceptInvalidCerts",
+              "checkServerIdentity"
+            ]
+          }
+        },
+        {
+          "if": {
+            "allOf": [
+              {
+                "properties": {
+                  "enabled": {
+                    "enum": [
+                      true
+                    ]
+                  }
+                }
+              },
+              {
+                "properties": {
+                  "acceptInvalidCerts": {
+                    "enum": [
+                      false
+                    ]
+                  }
+                }
+              }
+            ]
+          },
+          "then": {
+            "required": [
+              "sslCA"
+            ]
+          }
+        }
+      ]
+    },
+    "healthcheck": {
+      "$id": "/healthcheck",
+      "type": "object",
+      "properties": {
+        "type": {
+          "type": "string",
+          "description": "The type of healthcheck to run",
+          "default": "intermittent",
+          "enum": [
+            "none",
+            "startup",
+            "intermittent"
+          ]
         },
+        "frequency": {
+          "type": "integer",
+          "description": "How often the healthcheck should run (in milliseconds).",
+          "default": 300000,
+          "minimum": 60000,
+          "maximum": 3600000
+        }
+      },
+      "required": [
+        "type"
+      ],
+      "allOf": [
         {
-          "if" : { "allOf": [ 
-            { "properties" : { "enabled": { "enum": [true] } } },
-            { "properties" : { "acceptInvalidCerts": { "enum": [ false ] } } }
-          ] },
-          "then" : { "required" : ["sslCA"] }
+          "if": {
+            "properties": {
+              "type": {
+                "enum": [
+                  "intermittent"
+                ]
+              }
+            }
+          },
+          "then": {
+            "required": [
+              "frequency"
+            ]
+          }
         }
       ]
+    },
+    "connectionOptions": {
+      "$id": "/connectionOptions",
+      "type": "object",
+      "properties": {
+        "connectTimeout": {
+          "type": "number",
+          "description": "The milliseconds before a timeout occurs during the initial connection to the MySQL server.",
+          "default": 10000
+        },
+        "acquireTimeout": {
+          "type": "number",
+          "description": "The milliseconds before a timeout occurs during the connection acquisition",
+          "default": 10000
+        },
+        "waitForConnections": {
+          "type": "boolean",
+          "description": "Determines the pool's action when no connections are available and the limit has been reached",
+          "default": true
+        },
+        "connectionLimit": {
+          "type": "number",
+          "description": "The maximum number of connections to create at once",
+          "default": 10
+        },
+        "queueLimit": {
+          "type": "number",
+          "description": "The maximum number of connection requests the pool will queue before returning an error from getConnection",
+          "default": 0
+        }
+      },
+      "additionalProperties": false
     }
   }
-}
+}

package/sampleProperties.json

@@ -1,11 +1,14 @@
 {
-  "type": "MySQL",
   "id": "mysql",
+  "type": "MySQL",
+  "brokers": [],
+  "groups": [],
   "properties": {
     "database": "your database name",
     "host": "localhost",
     "port": 3306,
     "authentication": {
+      "dbAuth": false,
       "username": "your username",
       "password": "your password"
     },
@@ -13,10 +16,21 @@
       "enabled": false,
       "accept_invalid_cert": true,
       "ca_file": ""
+    },
+    "connectionOptions": {
+      "connectTimeout": 10000,
+      "acquireTimeout": 10000,
+      "waitForConnections": true,
+      "connectionLimit": 10,
+      "queueLimit": 0
+    },
+    "healthcheck": {
+      "type": "intermittent",
+      "frequency": 60000
     }
   },
   "groups": [],
   "brokers": [],
   "logLevel": "none",
   "timeout": 60000
-}
+}

package/test/integration/adapterTestIntegration.js

@@ -56,6 +56,17 @@ global.pronghornProps = {
         },
         replSet: {
           enabled: false
+        },
+        connectionOptions: {
+          connectTimeout: 10000,
+          acquireTimeout: 10000,
+          waitForConnections: true,
+          connectionLimit: 10,
+          queueLimit: 0
+        },
+        healthcheck: {
+          type: 'intermittent',
+          frequency: 60000
         }
       }
     }]

package/test/unit/adapterTestUnit.js

@@ -48,9 +48,10 @@ global.pronghornProps = {
         database: 'mydatabase',
         host,
         port,
-        credentials: {
-          username,
-          password
+        authentication: {
+          dbAuth: false,
+          username: 'itential',
+          password: 'itential'
         },
         ssl: {
           enabled: sslenable,
@@ -60,6 +61,17 @@ global.pronghornProps = {
         },
         replSet: {
           enabled: false
+        },
+        connectionOptions: {
+          connectTimeout: 10000,
+          acquireTimeout: 10000,
+          waitForConnections: true,
+          connectionLimit: 10,
+          queueLimit: 0
+        },
+        healthcheck: {
+          type: 'intermittent',
+          frequency: 60000
         }
       }
     }]