nodejs-poolcontroller 7.6.1 → 8.0.0

package/web/interfaces/influxInterface.ts

@@ -1,245 +1,283 @@
-/*  nodejs-poolController.  An application to control pool equipment.
-Copyright (C) 2016, 2017, 2018, 2019, 2020.  Russell Goldin, tagyoureit.  russ.goldin@gmail.com
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU Affero General Public License as
-published by the Free Software Foundation, either version 3 of the
-License, or (at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU Affero General Public License for more details.
-
-You should have received a copy of the GNU Affero General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-import extend = require("extend");
-import { ClientOptions, InfluxDB, Point, WriteApi, WritePrecisionType } from '@influxdata/influxdb-client';
-import { utils, Timestamp } from '../../controller/Constants';
-import { logger } from "../../logger/Logger";
-import { BaseInterfaceBindings, InterfaceContext, InterfaceEvent } from "./baseInterface";
-export class InfluxInterfaceBindings extends BaseInterfaceBindings {
-    constructor(cfg) {
-        super(cfg);
-    }
-    private writeApi: WriteApi;
-    declare context: InterfaceContext;
-    declare cfg;
-    declare events: InfluxInterfaceEvent[];
-    private init = () => {
-        let baseOpts = extend(true, this.cfg.options, this.context.options);
-        let url = 'http://';
-        if (typeof baseOpts.protocol !== 'undefined' && baseOpts.protocol) url = baseOpts.protocol;
-        if (!url.endsWith('://')) url += '://';
-        url = `${url}${baseOpts.host}:${baseOpts.port}`;
-        let influxDB: InfluxDB;
-        let bucket;
-        let org;
-        if (typeof baseOpts.host === 'undefined' || !baseOpts.host) {
-            logger.warn(`Interface: ${this.cfg.name} has not resolved to a valid host.`);
-            return;
-        }
-        if (baseOpts.version === 1) {
-            if (typeof baseOpts.database === 'undefined' || !baseOpts.database) {
-                logger.warn(`Interface: ${this.cfg.name} has not resolved to a valid database.`);
-                return;
-            }
-            bucket = `${baseOpts.database}/${baseOpts.retentionPolicy}`;
-            const clientOptions: ClientOptions = {
-                url,
-                token: `${baseOpts.username}:${baseOpts.password}`,
-            }
-            influxDB = new InfluxDB(clientOptions);
-        }
-        else if (baseOpts.version === 2) {
-            org = baseOpts.org;
-            bucket = baseOpts.bucket;
-            const clientOptions: ClientOptions = {
-                url,
-                token: baseOpts.token,
-            }
-            influxDB = new InfluxDB(clientOptions);
-        }
-        this.writeApi = influxDB.getWriteApi(org, bucket, 'ms');
-
-
-        // set global tags from context
-        let baseTags = {}
-        baseOpts.tags.forEach(tag => {
-            let toks = {};
-            let sname = this.tokensReplacer(tag.name, undefined, toks, undefined, {})
-            let svalue = this.tokensReplacer(tag.value, undefined, toks, { vars: {} } as any, {});
-            if (typeof sname !== 'undefined' && typeof svalue !== 'undefined' && !sname.includes('@bind') && !svalue.includes('@bind'))
-                baseTags[sname] = svalue;
-        })
-        this.writeApi.useDefaultTags(baseTags);
-    }
-    public bindEvent(evt: string, ...data: any) {
-
-        // if (state.status.value !== sys.board.valueMaps.controllerStatus.getValue('ready')) return; // miss values?  or show errors?  or?
-        if (typeof this.events !== 'undefined') {
-            if (typeof this.writeApi === 'undefined') this.init();
-            let evts = this.events.filter(elem => elem.name === evt);
-            if (evts.length > 0) {
-                let toks = {};
-                for (let i = 0; i < evts.length; i++) {
-                    let e = evts[i];
-                    if (typeof e.enabled !== 'undefined' && !e.enabled) continue;
-                    // Figure out whether we need to check the filter.
-                    if (typeof e.filter !== 'undefined') {
-                        this.buildTokens(e.filter, evt, toks, e, data[0]);
-                        if (eval(this.replaceTokens(e.filter, toks)) === false) continue;
-                    }
-                    for (let j = 0; j < e.points.length; j++) {
-                        let _point = e.points[j];
-                        // Figure out whether we need to check the filter for each point.
-                        if (typeof _point.filter !== 'undefined') {
-                            this.buildTokens(_point.filter, evt, toks, e, data[0]);
-                            if (eval(this.replaceTokens(_point.filter, toks)) === false) continue;
-                        }
-                        // iterate through points array
-                        let point = new Point(_point.measurement)
-                        let point2 = new Point(_point.measurement);
-                        _point.tags.forEach(_tag => {
-                            let sname = _tag.name;
-                            this.buildTokens(sname, evt, toks, e, data[0]);
-                            sname = this.replaceTokens(sname, toks);
-                            let svalue = _tag.value;
-                            this.buildTokens(svalue, evt, toks, e, data[0]);
-                            svalue = this.replaceTokens(svalue, toks);
-                            if (typeof sname !== 'undefined' && typeof svalue !== 'undefined' && !sname.includes('@bind') && !svalue.includes('@bind') && svalue !== null) {
-                                point.tag(sname, svalue);
-                                if (typeof _point.storePrevState !== 'undefined' && _point.storePrevState) point2.tag(sname, svalue);
-                            }
-                            else {
-                                logger.error(`InfluxDB tag binding failure on ${evt}:${_tag.name}/${_tag.value} --> ${svalue || 'undefined'}  ${JSON.stringify(data[0])}`);
-                                if (typeof sname === 'undefined') logger.error(`InfluxDB tag name is undefined`);
-                                if (typeof svalue === 'undefined') logger.error(`InfluxDB value is undefined`);
-                                if (svalue.includes('@bind')) logger.error(`InfluxDB value not bound`);
-                                if (svalue === null) logger.error(`InfluxDB value is null`);
-                            }
-                        })
-                        _point.fields.forEach(_field => {
-                            try {
-                                let sname = _field.name;
-                                this.buildTokens(sname, evt, toks, e, data[0]);
-                                //console.log(toks);
-                                sname = this.replaceTokens(sname, toks);
-                                let svalue = _field.value;
-                                this.buildTokens(svalue, evt, toks, e, data[0]);
-                                svalue = this.replaceTokens(svalue, toks);
-                                if (typeof sname !== 'undefined' && typeof svalue !== 'undefined' && !sname.includes('@bind') && !svalue.includes('@bind') && svalue !== null)
-                                    switch (_field.type) {
-                                        case 'int':
-                                        case 'integer':
-                                            let int = parseInt(svalue, 10);
-                                            if (!isNaN(int)) point.intField(sname, int);
-                                            // if (!isNaN(int) && typeof _point.storePrevState !== 'undefined' && _point.storePrevState) point2.intField(sname, int);
-                                            break;
-                                        case 'string':
-                                            point.stringField(sname, svalue);
-                                            // if (typeof _point.storePrevState !== 'undefined' && _point.storePrevState) point2.stringField(sname, svalue);
-                                            break;
-                                        case 'boolean':
-                                            point.booleanField(sname, utils.makeBool(svalue));
-                                            if (typeof _point.storePrevState !== 'undefined' && _point.storePrevState) point2.booleanField(sname, !utils.makeBool(svalue));
-                                            break;
-                                        case 'float':
-                                            let float = parseFloat(svalue);
-                                            if (!isNaN(float)) point.floatField(sname, float);
-                                            // if (!isNaN(float) && typeof _point.storePrevState !== 'undefined' && _point.storePrevState) point2.intField(sname, int);
-                                            break;
-                                        case 'timestamp':
-                                        case 'datetime':
-                                        case 'date':
-                                            //let dt = Date.parse(svalue.replace(/^["'](.+(?=["']$))["']$/, '$1'));
-                                            // RKS: 07-06-21 - I think this is missing the eval function around all of this. The strings still have the quotes around them.  I think
-                                            // maybe we need to create a closure and execute it as a code segment for variable data.
-                                            let sdt = eval(svalue);
-                                            if (sdt !== null && typeof sdt !== 'undefined') {
-                                                let dt = Date.parse(sdt);
-                                                if (!isNaN(dt)) point.intField(sname, dt);
-                                                else if (svalue !== '') logger.warn(`Influx error parsing date from ${sname}: ${svalue}`);
-                                            }
-                                            break;
-                                    }
-                                else {
-                                    logger.error(`InfluxDB point binding failure on ${evt}:${_field.name}/${_field.value} --> ${svalue || 'undefined'}`);
-                                }
-                            } catch (err) { logger.error(`Error binding InfluxDB point fields ${err.message}`); }
-                        });
-                        if (typeof _point.series !== 'undefined') {
-                            try {
-                                this.buildTokens(_point.series.value, evt, toks, e, data[0]);
-                                let ser = eval(this.replaceTokens(_point.series.value, toks));
-                                let ts = Date.parse(ser);
-                                if (isNaN(ts)) {
-                                    logger.error(`Influx series timestamp is invalid ${ser}`);
-                                }
-                                else
-                                    point.timestamp(new Date(ts));
-                            } catch (err) { logger.error(`Error parsing Influx point series for ${evt} - ${_point.series.value}`); }
-                        }
-                        else
-                            point.timestamp(new Date());
-                        try {
-
-                            if (typeof _point.storePrevState !== 'undefined' && _point.storePrevState) {
-                                // copy the point and subtract a second and keep inverse value
-                                let ts = new Date();
-                                let sec = ts.getSeconds() - 1;
-                                ts.setSeconds(sec);
-                                point2.timestamp(ts);
-                                logger.silly(`Writing influx ${e.name} inverse data point ${point2.toString()})`)
-                                this.writeApi.writePoint(point2);
-                            }
-                            if (typeof point.toLineProtocol() !== 'undefined') {
-                                logger.silly(`Writing influx ${e.name} data point ${point.toString()}`)
-                                this.writeApi.writePoint(point);
-                                this.writeApi.flush()
-                                    .catch(error => { logger.error(`Error flushing Influx data point ${point.toString()} ${error}`); });
-                                //logger.info(`INFLUX: ${point.toLineProtocol()}`)
-                            }
-                            else {
-                                logger.silly(`Skipping INFLUX write because some data is missing with ${e.name} event on measurement ${_point.measurement}.`)
-                            }
-                        }
-                        catch (err) {
-                            logger.error(`Error writing to Influx: ${err.message}`)
-                        }
-                    }
-                }
-            }
-        }
-    }
-    public close = () => {
-
-    }
-}
-
-class InfluxInterfaceEvent extends InterfaceEvent {
-    public points: IPoint[];
-}
-
-export interface IPoint {
-    measurement: string;
-    series?: ISeries;
-    tags: ITag[];
-    fields: IFields[];
-    storePrevState?: boolean;
-    filter?: any;
-}
-export interface ITag {
-    name: string;
-    value: string;
-}
-export interface IFields {
-    name: string;
-    value: string;
-    type: string;
-}
-export interface ISeries {
-    value: string;
-}
+/*  nodejs-poolController.  An application to control pool equipment.
+Copyright (C) 2016, 2017, 2018, 2019, 2020, 2021, 2022.  
+Russell Goldin, tagyoureit.  russ.goldin@gmail.com
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import extend = require("extend");
+import { ClientOptions, DEFAULT_WriteOptions, InfluxDB, Point, WriteApi, WriteOptions, WritePrecisionType } from '@influxdata/influxdb-client';
+import { utils, Timestamp } from '../../controller/Constants';
+import { logger } from "../../logger/Logger";
+import { BaseInterfaceBindings, InterfaceContext, InterfaceEvent } from "./baseInterface";
+export class InfluxInterfaceBindings extends BaseInterfaceBindings {
+    constructor(cfg) {
+        super(cfg);
+    }
+    private writeApi: WriteApi;
+    declare context: InterfaceContext;
+    declare cfg;
+    declare events: InfluxInterfaceEvent[];
+    private init = () => {
+        let baseOpts = extend(true, this.cfg.options, this.context.options);
+        let url = 'http://';
+        if (typeof baseOpts.protocol !== 'undefined' && baseOpts.protocol) url = baseOpts.protocol;
+        if (!url.endsWith('://')) url += '://';
+        url = `${url}${baseOpts.host}`;
+        if(typeof baseOpts.port !== 'undefined' && baseOpts.port !== null && !isNaN(baseOpts.port)) url = `${url}:${baseOpts.port}`;
+        let influxDB: InfluxDB;
+        let bucket;
+        let org;
+        if (typeof baseOpts.host === 'undefined' || !baseOpts.host) {
+            logger.warn(`Interface: ${this.cfg.name} has not resolved to a valid host.`);
+            return;
+        }
+        if (baseOpts.version === 1) {
+            if (typeof baseOpts.database === 'undefined' || !baseOpts.database) {
+                logger.warn(`Interface: ${this.cfg.name} has not resolved to a valid database.`);
+                return;
+            }
+            bucket = `${baseOpts.database}/${baseOpts.retentionPolicy}`;
+            const clientOptions: ClientOptions = {
+                url,
+                token: `${baseOpts.username}:${baseOpts.password}`,
+            }
+            influxDB = new InfluxDB(clientOptions);
+        }
+        else if (baseOpts.version === 2) {
+            org = baseOpts.org;
+            bucket = baseOpts.bucket;
+            const clientOptions: ClientOptions = {
+                url,
+                token: baseOpts.token,
+            }
+            influxDB = new InfluxDB(clientOptions);
+        }
+        // set global tags from context
+        let baseTags = {}
+        baseOpts.tags.forEach(tag => {
+            let toks = {};
+            let sname = this.tokensReplacer(tag.name, undefined, toks, undefined, {})
+            let svalue = this.tokensReplacer(tag.value, undefined, toks, { vars: {} } as any, {});
+            if (typeof sname !== 'undefined' && typeof svalue !== 'undefined' && !sname.includes('@bind') && !svalue.includes('@bind'))
+                baseTags[sname] = svalue;
+        })
+        //this.writeApi.useDefaultTags(baseTags);
+        const writeOptions:WriteOptions = {
+            /* the maximum points/line to send in a single batch to InfluxDB server */
+            batchSize: baseOpts.batchSize || 100, 
+            /* default tags to add to every point */
+            defaultTags: baseTags,
+            /* maximum time in millis to keep points in an unflushed batch, 0 means don't periodically flush */
+            flushInterval: DEFAULT_WriteOptions.flushInterval,
+            /* maximum size of the retry buffer - it contains items that could not be sent for the first time */
+            maxBufferLines: DEFAULT_WriteOptions.maxBufferLines,
+            /* the count of retries, the delays between retries follow an exponential backoff strategy if there is no Retry-After HTTP header */
+            maxRetries: DEFAULT_WriteOptions.maxRetries,
+            /* maximum delay between retries in milliseconds */
+            maxRetryDelay: DEFAULT_WriteOptions.maxRetryDelay,
+            /* minimum delay between retries in milliseconds */
+            minRetryDelay: DEFAULT_WriteOptions.minRetryDelay, // minimum delay between retries
+            /* a random value of up to retryJitter is added when scheduling next retry */
+            retryJitter: DEFAULT_WriteOptions.retryJitter,
+            // ... or you can customize what to do on write failures when using a writeFailed fn, see the API docs for details
+            writeFailed: function(error, lines, failedAttempts){
+                /** return promise or void */
+                logger.error(`InfluxDB batch write failed writing ${lines.length} lines with ${failedAttempts} failed attempts.  ${error.message}`);
+                //console.log(lines);
+            },
+            writeSuccess: function(lines){
+                logger.silly(`InfluxDB successfully wrote ${lines.length} lines.`)
+            },
+            writeRetrySkipped: function(entry){
+                logger.silly(`Influx write retry skipped ${JSON.stringify(entry)}`);
+            },
+            maxRetryTime: DEFAULT_WriteOptions.maxRetryTime,
+            exponentialBase: DEFAULT_WriteOptions.exponentialBase,
+            randomRetry: DEFAULT_WriteOptions.randomRetry,
+            maxBatchBytes: 4096
+           
+        }
+        this.writeApi = influxDB.getWriteApi(org, bucket, 'ms', writeOptions);
+
+
+
+    }
+    public bindEvent(evt: string, ...data: any) {
+
+        // if (state.status.value !== sys.board.valueMaps.controllerStatus.getValue('ready')) return; // miss values?  or show errors?  or?
+        if (typeof this.events !== 'undefined') {
+            if (typeof this.writeApi === 'undefined') this.init();
+            let evts = this.events.filter(elem => elem.name === evt);
+            if (evts.length > 0) {
+                let toks = {};
+                for (let i = 0; i < evts.length; i++) {
+                    let e = evts[i];
+                    if (typeof e.enabled !== 'undefined' && !e.enabled) continue;
+                    // Figure out whether we need to check the filter.
+                    if (typeof e.filter !== 'undefined') {
+                        this.buildTokens(e.filter, evt, toks, e, data[0]);
+                        if (eval(this.replaceTokens(e.filter, toks)) === false) continue;
+                    }
+                    for (let j = 0; j < e.points.length; j++) {
+                        let _point = e.points[j];
+                        // Figure out whether we need to check the filter for each point.
+                        if (typeof _point.filter !== 'undefined') {
+                            this.buildTokens(_point.filter, evt, toks, e, data[0]);
+                            if (eval(this.replaceTokens(_point.filter, toks)) === false) continue;
+                        }
+                        // iterate through points array
+                        let point = new Point(_point.measurement)
+                        let point2 = new Point(_point.measurement);
+                        _point.tags.forEach(_tag => {
+                            let sname = _tag.name;
+                            this.buildTokens(sname, evt, toks, e, data[0]);
+                            sname = this.replaceTokens(sname, toks);
+                            let svalue = _tag.value;
+                            this.buildTokens(svalue, evt, toks, e, data[0]);
+                            svalue = this.replaceTokens(svalue, toks);
+                            if (typeof sname !== 'undefined' && typeof svalue !== 'undefined' && !sname.includes('@bind') && !svalue.includes('@bind') && svalue !== null) {
+                                point.tag(sname, svalue);
+                                if (typeof _point.storePrevState !== 'undefined' && _point.storePrevState) point2.tag(sname, svalue);
+                            }
+                            else {
+                                logger.error(`InfluxDB tag binding failure on ${evt}:${_tag.name}/${_tag.value} --> ${svalue || 'undefined'}  ${JSON.stringify(data[0])}`);
+                                if (typeof sname === 'undefined') logger.error(`InfluxDB tag name is undefined`);
+                                if (typeof svalue === 'undefined') logger.error(`InfluxDB value is undefined`);
+                                if (svalue.includes('@bind')) logger.error(`InfluxDB value not bound`);
+                                if (svalue === null) logger.error(`InfluxDB value is null`);
+                            }
+                        })
+                        _point.fields.forEach(_field => {
+                            try {
+                                let sname = _field.name;
+                                this.buildTokens(sname, evt, toks, e, data[0]);
+                                //console.log(toks);
+                                sname = this.replaceTokens(sname, toks);
+                                let svalue = _field.value;
+                                this.buildTokens(svalue, evt, toks, e, data[0]);
+                                svalue = this.replaceTokens(svalue, toks);
+                                if (typeof sname !== 'undefined' && typeof svalue !== 'undefined' && !sname.includes('@bind') && !svalue.includes('@bind') && svalue !== null)
+                                    switch (_field.type) {
+                                        case 'int':
+                                        case 'integer':
+                                            let int = parseInt(svalue, 10);
+                                            if (!isNaN(int)) point.intField(sname, int);
+                                            // if (!isNaN(int) && typeof _point.storePrevState !== 'undefined' && _point.storePrevState) point2.intField(sname, int);
+                                            break;
+                                        case 'string':
+                                            point.stringField(sname, svalue);
+                                            // if (typeof _point.storePrevState !== 'undefined' && _point.storePrevState) point2.stringField(sname, svalue);
+                                            break;
+                                        case 'boolean':
+                                            point.booleanField(sname, utils.makeBool(svalue));
+                                            if (typeof _point.storePrevState !== 'undefined' && _point.storePrevState) point2.booleanField(sname, !utils.makeBool(svalue));
+                                            break;
+                                        case 'float':
+                                            let float = parseFloat(svalue);
+                                            if (!isNaN(float)) point.floatField(sname, float);
+                                            // if (!isNaN(float) && typeof _point.storePrevState !== 'undefined' && _point.storePrevState) point2.intField(sname, int);
+                                            break;
+                                        case 'timestamp':
+                                        case 'datetime':
+                                        case 'date':
+                                            //let dt = Date.parse(svalue.replace(/^["'](.+(?=["']$))["']$/, '$1'));
+                                            // RKS: 07-06-21 - I think this is missing the eval function around all of this. The strings still have the quotes around them.  I think
+                                            // maybe we need to create a closure and execute it as a code segment for variable data.
+                                            let sdt = eval(svalue);
+                                            if (sdt !== null && typeof sdt !== 'undefined') {
+                                                let dt = Date.parse(sdt);
+                                                if (!isNaN(dt)) point.intField(sname, dt);
+                                                else if (svalue !== '') logger.warn(`Influx error parsing date from ${sname}: ${svalue}`);
+                                            }
+                                            break;
+                                    }
+                                else {
+                                    logger.error(`InfluxDB point binding failure on ${evt}:${_field.name}/${_field.value} --> ${svalue || 'undefined'}`);
+                                }
+                            } catch (err) { logger.error(`Error binding InfluxDB point fields ${err.message}`); }
+                        });
+                        if (typeof _point.series !== 'undefined') {
+                            try {
+                                this.buildTokens(_point.series.value, evt, toks, e, data[0]);
+                                let ser = eval(this.replaceTokens(_point.series.value, toks));
+                                let ts = Date.parse(ser);
+                                if (isNaN(ts)) {
+                                    logger.error(`Influx series timestamp is invalid ${ser}`);
+                                }
+                                else
+                                    point.timestamp(new Date(ts));
+                            } catch (err) { logger.error(`Error parsing Influx point series for ${evt} - ${_point.series.value}`); }
+                        }
+                        else
+                            point.timestamp(new Date());
+                        try {
+
+                            if (typeof _point.storePrevState !== 'undefined' && _point.storePrevState) {
+                                // copy the point and subtract a second and keep inverse value
+                                let ts = new Date();
+                                let sec = ts.getSeconds() - 1;
+                                ts.setSeconds(sec);
+                                point2.timestamp(ts);
+                                logger.silly(`Batching influx ${e.name} inverse data point ${point2.toString()})`)
+                                this.writeApi.writePoint(point2);
+                            }
+                            if (typeof point.toLineProtocol() !== 'undefined') {
+                                logger.silly(`Batching influx ${e.name} data point ${point.toString()}`)
+                                this.writeApi.writePoint(point);
+                                // this.writeApi.flush()
+                                //     .catch(error => { logger.error(`Error flushing Influx data point ${point.toString()} ${error}`); });
+                                //logger.info(`INFLUX: ${point.toLineProtocol()}`)
+                            }
+                            else {
+                                logger.silly(`Skipping INFLUX write because some data is missing with ${e.name} event on measurement ${_point.measurement}.`)
+                            }
+                        }
+                        catch (err) {
+                            logger.error(`Error writing to Influx: ${err.message}`)
+                        }
+                    }
+                }
+            }
+        }
+    }
+    public close = () => {
+
+    }
+}
+
+class InfluxInterfaceEvent extends InterfaceEvent {
+    public points: IPoint[];
+}
+
+export interface IPoint {
+    measurement: string;
+    series?: ISeries;
+    tags: ITag[];
+    fields: IFields[];
+    storePrevState?: boolean;
+    filter?: any;
+}
+export interface ITag {
+    name: string;
+    value: string;
+}
+export interface IFields {
+    name: string;
+    value: string;
+    type: string;
+}
+export interface ISeries {
+    value: string;
+}