nodejs-poolcontroller 7.6.1 → 8.0.0

package/web/Server.ts

@@ -1,5 +1,6 @@
 /*  nodejs-poolController.  An application to control pool equipment.
-Copyright (C) 2016, 2017, 2018, 2019, 2020.  Russell Goldin, tagyoureit.  russ.goldin@gmail.com
+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
@@ -37,6 +38,7 @@ import { logger } from "../logger/Logger";
 import { HttpInterfaceBindings } from './interfaces/httpInterface';
 import { InfluxInterfaceBindings } from './interfaces/influxInterface';
 import { MqttInterfaceBindings } from './interfaces/mqttInterface';
+import { RuleInterfaceBindings } from "./interfaces/ruleInterface";
 import { ConfigRoute } from "./services/config/Config";
 import { ConfigSocket } from "./services/config/ConfigSocket";
 import { StateRoute } from "./services/state/State";
@@ -44,7 +46,8 @@ import { StateSocket } from "./services/state/StateSocket";
 import { UtilitiesRoute } from "./services/utilities/Utilities";
 import express = require('express');
 import extend = require("extend");
-
+import { setTimeout as setTimeoutSync } from 'timers';
+import { setTimeout } from 'timers/promises';
 
 // This class serves data and pages for
 // external interfaces as well as an internal dashboard.
@@ -54,6 +57,7 @@ export class WebServer {
     private _servers: ProtoServer[] = [];
     private family = 'IPv4';
     private _autoBackupTimer: NodeJS.Timeout;
+    private _httpPort: number;
     constructor() { }
     public async init() {
         try {
@@ -68,12 +72,15 @@ export class WebServer {
                 switch (s) {
                     case 'http':
                         srv = new HttpServer(s, s);
+                        if (c.enabled !== false) this._httpPort = c.port;
                         break;
                     case 'http2':
                         srv = new Http2Server(s, s);
+                        if (c.enabled !== false) this._httpPort = c.port;
                         break;
                     case 'https':
                         srv = new HttpsServer(s, s);
+                        if (c.enabled !== false) this._httpPort = c.port;
                         break;
                     case 'mdns':
                         srv = new MdnsServer(s, s);
@@ -111,7 +118,13 @@ export class WebServer {
                         int.init(c);
                         this._servers.push(int);
                         break;
+                    case 'rule':
+                        int = new RuleInterfaceServer(c.name, type);
+                        int.init(c);
+                        this._servers.push(int);
+                        break;
                     case 'influx':
+                    case 'influxdb2':
                         int = new InfluxInterfaceServer(c.name, type);
                         int.init(c);
                         this._servers.push(int);
@@ -161,6 +174,7 @@ export class WebServer {
         // RKS: We need to get the scope-local nic. This has nothing to do with IP4/6 and is not necessarily named en0 or specific to a particular nic.  We are
         // looking for the first IPv4 interface that has a mac address which will be the scope-local address.  However, in the future we can simply use the IPv6 interface
         // if that is returned on the local scope but I don't know if the node ssdp server supports it on all platforms.
+        let fallback; // Use this for WSL adapters.
         for (let name in networkInterfaces) {
             let nic = networkInterfaces[name];
             for (let ndx in nic) {
@@ -168,17 +182,43 @@ export class WebServer {
                 // All scope-local addresses will have a mac.  In a multi-nic scenario we are simply grabbing
                 // the first one we come across.
                 if (!addr.internal && addr.mac.indexOf('00:00:00:') < 0 && addr.family === this.family) {
-                    return addr;
+                    if (!addr.mac.startsWith('00:'))
+                        return addr;
+                    else if (typeof fallback === 'undefined') fallback = addr;
                 }
             }
         }
+        return fallback;
     }
-    public ip() {
-        return typeof this.getInterface() === 'undefined' ? '0.0.0.0' : this.getInterface().address;
-    }
-    public mac() {
-        return typeof this.getInterface() === 'undefined' ? '00:00:00:00' : this.getInterface().mac;
+    public getNetworkInterfaces() {
+        const networkInterfaces = os.networkInterfaces();
+        // RKS: We need to get the scope-local nics. This has nothing to do with IP4/6 and is not necessarily named en0 or specific to a particular nic.  We are
+        // looking for the first IPv4 interface that has a mac address which will be the scope-local address.  However, in the future we can simply use the IPv6 interface
+        // if that is returned on the local scope but I don't know if the node ssdp server supports it on all platforms.
+        let ips = [];
+        let nics = { physical: [], virtual: [] }
+        for (let name in networkInterfaces) {
+            let nic = networkInterfaces[name];
+            for (let ndx in nic) {
+                let addr = nic[ndx];
+                // All scope-local addresses will have a mac.  In a multi-nic scenario we are simply grabbing
+                // the first one we come across.
+                if (!addr.internal && addr.mac.indexOf('00:00:00:') < 0 && addr.family === this.family) {
+                    if (typeof ips.find((x) => x === addr.address) === 'undefined') {
+                        ips.push(addr.address);
+                        if (!addr.mac.startsWith('00:'))
+                            nics.physical.push(extend(true, { name: name }, addr));
+                        else
+                            nics.virtual.push(extend(true, { name: name }, addr));
+                    }
+                }
+            }
+        }
+        return nics;
     }
+    public ip() { return typeof this.getInterface() === 'undefined' ? '0.0.0.0' : this.getInterface().address; }
+    public mac() { return typeof this.getInterface() === 'undefined' ? '00:00:00:00' : this.getInterface().mac; }
+    public httpPort(): number { return this._httpPort }
     public findServer(name: string): ProtoServer { return this._servers.find(elem => elem.name === name); }
     public findServersByType(type: string) { return this._servers.filter(elem => elem.type === type); }
     public findServerByGuid(uuid: string) { return this._servers.find(elem => elem.uuid === uuid); }
@@ -221,7 +261,7 @@ export class WebServer {
             else
                 logger.info(`Auto-backup initialized Last Backup: ${Timestamp.toISOLocal(new Date(this.lastBackup))}`);
             // Lets wait a good 20 seconds before we auto-backup anything.  Now that we are initialized let the OCP have its way with everything.
-            setTimeout(() => { this.checkAutoBackup(); }, 20000);
+            setTimeoutSync(()=>{this.checkAutoBackup();}, 20000);
         }
         catch (err) { logger.error(`Error initializing auto-backup: ${err.message}`); }
     }
@@ -372,7 +412,7 @@ export class WebServer {
         if (this.autoBackup) {
             await this.pruneAutoBackups(bu.keepCount);
             let nextBackup = this.lastBackup + (bu.interval.days * 86400000) + (bu.interval.hours * 3600000);
-            setTimeout(async () => {
+            setTimeoutSync(async () => {
                 try {
                     await this.checkAutoBackup();
                 } catch (err) { logger.error(`Error checking auto-backup: ${err.message}`); }
@@ -480,7 +520,7 @@ export class WebServer {
                             }
                         }
                         stats.servers.push(ctx);
-                        if (!srv.isConnected) await utils.sleep(6000); // rem server waits to connect 5s before isConnected will be true. Server.ts#1256 = REMInterfaceServer.init();  What's a better way to do this?
+                        if (!srv.isConnected) await setTimeout(6000); // rem server waits to connect 5s before isConnected will be true. Server.ts#1256 = REMInterfaceServer.init();  What's a better way to do this?
                         if (typeof cfg === 'undefined' || typeof cfg.controllerConfig === 'undefined') ctx.server.errors.push(`Server configuration not found in zip file`);
                         else if (typeof srv === 'undefined') ctx.server.errors.push(`Server ${s.name} is not enabled in njsPC cannot restore.`);
                         else if (!srv.isConnected) ctx.server.errors.push(`Server ${s.name} is not connected cannot restore.`);
@@ -605,7 +645,7 @@ export class HttpServer extends ProtoServer {
     private socketHandler(sock: Socket) {
         let self = this;
         // this._sockets.push(sock);
-        setTimeout(async () => {
+        setTimeoutSync(async () => {
             // refresh socket list with every new socket
             self._sockets = await self.sockServer.fetchSockets();
         }, 100)
@@ -618,42 +658,6 @@ export class HttpServer extends ProtoServer {
             self._sockets = await self.sockServer.fetchSockets();
         });
         sock.on('echo', (msg) => { sock.emit('echo', msg); });
-/*         sock.on('receivePacketRaw', function (incomingPacket: any[]) {
-            //var str = 'Add packet(s) to incoming buffer: ';
-            logger.silly('User request (replay.html) to RECEIVE packet: %s', JSON.stringify(incomingPacket));
-            for (var i = 0; i < incomingPacket.length; i++) {
-                conn.buffer.pushIn(Buffer.from(incomingPacket[i]));
-                // str += JSON.stringify(incomingPacket[i]) + ' ';
-            }
-            //logger.info(str);
-        });
-        sock.on('replayPackets', function (inboundPkts: number[][]) {
-            // used for replay
-            logger.debug(`Received replayPackets: ${inboundPkts}`);
-            inboundPkts.forEach(inbound => {
-                conn.buffer.pushIn(Buffer.from([].concat.apply([], inbound)));
-                // conn.queueInboundMessage([].concat.apply([], inbound));
-            });
-        });
-        sock.on('sendPackets', function (bytesToProcessArr: number[][]) {
-            // takes an input of bytes (src/dest/action/payload) and sends
-            if (!bytesToProcessArr.length) return;
-            logger.silly('User request (replay.html) to SEND packet: %s', JSON.stringify(bytesToProcessArr));
-
-            do {
-                let bytesToProcess: number[] = bytesToProcessArr.shift();
-
-                // todo: logic for chlor packets
-                let out = Outbound.create({
-                    source: bytesToProcess.shift(),
-                    dest: bytesToProcess.shift(),
-                    action: bytesToProcess.shift(),
-                    payload: bytesToProcess.splice(1, bytesToProcess[0])
-                });
-                conn.queueSendMessage(out);
-            } while (bytesToProcessArr.length > 0);
-
-        }); */
         sock.on('sendOutboundMessage', (mdata) => {
             let msg: Outbound = Outbound.create({});
             Object.assign(msg, mdata);
@@ -682,11 +686,16 @@ export class HttpServer extends ProtoServer {
             if (!sendMessages) sock.leave('msgLogger');
             else sock.join('msgLogger');
         });
-        sock.on('sendRS485PortStats', function (sendPortStatus: boolean) {
-            console.log(`sendRS485PortStats set to ${sendPortStatus}`);
-            if (!sendPortStatus) sock.leave('rs485PortStats');
+        sock.on('sendRS485PortStats', function (sendPortStats: boolean) {
+            console.log(`sendRS485PortStats set to ${sendPortStats}`);
+            if (!sendPortStats) sock.leave('rs485PortStats');
             else sock.join('rs485PortStats');
         });
+        sock.on('sendScreenlogicStats', function (sendScreenlogicStats: boolean) {
+            console.log(`sendScreenlogicStats set to ${sendScreenlogicStats}`);
+            if (!sendScreenlogicStats) sock.leave('screenlogicStats');
+            else sock.join('screenlogicStats');
+        });
         StateSocket.initSockets(sock);
         ConfigSocket.initSockets(sock);
     }
@@ -733,7 +742,7 @@ export class HttpServer extends ProtoServer {
                     res.header('Access-Control-Allow-Methods', 'OPTIONS, GET, POST, PUT, DELETE');
                     if ('OPTIONS' === req.method) { res.sendStatus(200); }
                     else {
-                        if (req.url !== '/device') {
+                        if (req.url !== '/upnp.xml') {
                             logger.info(`[${new Date().toLocaleTimeString()}] ${req.ip} ${req.method} ${req.url} ${typeof req.body === 'undefined' ? '' : JSON.stringify(req.body)}`);
                             logger.logAPI(`{"dir":"in","proto":"api","requestor":"${req.ip}","method":"${req.method}","path":"${req.url}",${typeof req.body === 'undefined' ? '' : `"body":${JSON.stringify(req.body)},`}"ts":"${Timestamp.toISOLocal(new Date())}"}${os.EOL}`);
                         }
@@ -773,7 +782,7 @@ export class HttpServer extends ProtoServer {
 
                 // start our server on port
                 this.server.listen(cfg.port, cfg.ip, function () {
-                    logger.info('Server is now listening on %s:%s', cfg.ip, cfg.port);
+                    logger.info('Server is now listening on %s:%s - %s:%s', cfg.ip, cfg.port, webApp.ip(), webApp.httpPort());
                 });
                 this.isRunning = true;
             }
@@ -824,7 +833,7 @@ export class HttpsServer extends HttpServer {
                 res.header('Access-Control-Allow-Methods', 'OPTIONS, GET, POST, PUT, DELETE');
                 if ('OPTIONS' === req.method) { res.sendStatus(200); }
                 else {
-                    if (req.url !== '/device') {
+                    if (!req.url.startsWith('/upnp.xml')) {
                         logger.info(`[${new Date().toLocaleString()}] ${req.ip} ${req.method} ${req.url} ${typeof req.body === 'undefined' ? '' : JSON.stringify(req.body)}`);
                         logger.logAPI(`{"dir":"in","proto":"api","requestor":"${req.ip}","method":"${req.method}","path":"${req.url}",${typeof req.body === 'undefined' ? '' : `"body":${JSON.stringify(req.body)},`}"ts":"${Timestamp.toISOLocal(new Date())}"}${os.EOL}`);
                     }
@@ -875,27 +884,57 @@ export class HttpsServer extends HttpServer {
 }
 export class SsdpServer extends ProtoServer {
     // Simple service discovery protocol
-    public server: any; //node-ssdp;
+    public server: ssdp.Server; //node-ssdp;
+    public deviceUUID: string;
+    public upnpPath: string;
+    public modelName: string;
+    public modelNumber: string;
+    public serialNumber: string;
+    public deviceType = 'urn:schemas-tagyoureit-org:device:PoolController:1';
     public async init(cfg) {
         this.uuid = cfg.uuid;
         if (cfg.enabled) {
             let self = this;
-
             logger.info('Starting up SSDP server');
-            var udn = 'uuid:806f52f4-1f35-4e33-9299-' + webApp.mac();
+            let ver = JSON.parse(fs.readFileSync(path.posix.join(process.cwd(), '/package.json'), 'utf8')).version || '0.0.0';
+            this.deviceUUID = 'uuid:806f52f4-1f35-4e33-9299-' + webApp.mac().replace(/:/g, '');
+            this.serialNumber = webApp.mac();
+            this.modelName = `njsPC v${ver}`;
+            this.modelNumber = `njsPC${ver.replace(/\./g, '-')}`;
             // todo: should probably check if http/https is enabled at this point
-            var port = config.getSection('web').servers.http.port || 4200;
-            //console.log(port);
-            let location = 'http://' + webApp.ip() + ':' + port + '/device';
-            var SSDP = ssdp.Server;
-            this.server = new SSDP({
-                logLevel: 'INFO',
-                udn: udn,
-                location: location,
-                sourcePort: 1900
-            });
-            this.server.addUSN('urn:schemas-upnp-org:device:PoolController:1');
+            //let port = config.getSection('web').servers.http.port || 7777;
+            this.upnpPath = 'http://' + webApp.ip() + ':' + webApp.httpPort() + '/upnp.xml';
+            let nics = webApp.getNetworkInterfaces();
+            let SSDP = ssdp.Server;
+            if (nics.physical.length + nics.virtual.length > 1) {
+                // If there are multiple nics (docker...etc) then
+                // this will bind on all of them.
+                this.server = new SSDP({
+                    //customLogger: (...args) => console.log.apply(null, args),
+                    logLevel: 'INFO',
+                    udn: this.deviceUUID,
+                    location: {
+                        protocol: 'http://',
+                        port: webApp.httpPort(),
+                        path: '/upnp.xml'
+                    },
+                    explicitSocketBind: true,
+                    sourcePort: 1900
+                });
+            }
+            else {
+                this.server = new SSDP({
+                    //customLogger: (...args) => console.log.apply(null, args),
+                    logLevel: 'INFO',
+                    udn: this.deviceUUID,
+                    location: this.upnpPath,
+                    sourcePort: 1900
+                });
+
 
+            }
+            this.server.addUSN('upnp:rootdevice'); // This line will make the server show up in windows.
+            this.server.addUSN(this.deviceType);
             // start the server
             this.server.start()
                 .then(function () {
@@ -908,26 +947,39 @@ export class SsdpServer extends ProtoServer {
             });
         }
     }
-    public static deviceXML() {
-        let ver = sys.appVersion;
+    public deviceXML(): string {
+        let ver = sys.appVersion.split('.');
+        let friendlyName = 'njsPC: unknown model';
+        if (typeof sys !== 'undefined' && typeof sys.equipment !== 'undefined' && typeof sys.equipment.model !== 'undefined') friendlyName = `${sys.equipment.model}`
         let XML = `<?xml version="1.0"?>
-                        <root xmlns="urn:schemas-upnp-org:PoolController-1-0">
-                            <specVersion>
-                                <major>${ver.split('.')[0]}</major>
-                                <minor>${ver.split('.')[1]}</minor>
-                                <patch>${ver.split('.')[2]}</patch>
-                            </specVersion>
-                            <device>
-                                <deviceType>urn:echo:device:PoolController:1</deviceType>
-                                <friendlyName>NodeJS Pool Controller</friendlyName> 
-                                <manufacturer>tagyoureit</manufacturer>
-                                <manufacturerURL>https://github.com/tagyoureit/nodejs-poolController</manufacturerURL>
-                                <modelDescription>An application to control pool equipment.</modelDescription>
-                                <serialNumber>0</serialNumber>
-                    			<UDN>uuid:806f52f4-1f35-4e33-9299-${webApp.mac()}</UDN>
-                                <serviceList></serviceList>
-                            </device>
-                        </root>`;
+        <root xmlns="urn:schemas-upnp-org:device-1-0">
+            <specVersion>
+                <major>1</major>
+                <minor>0</minor>
+            </specVersion>
+            <device>
+                <deviceType>${this.deviceType}</deviceType>
+                <friendlyName>${friendlyName}</friendlyName>
+                <manufacturer>tagyoureit</manufacturer>
+                <manufacturerURL>https://github.com/tagyoureit/nodejs-poolController</manufacturerURL>
+                <presentationURL>http://${webApp.ip()}:${webApp.httpPort()}/state/all</presentationURL>
+                <appVersion>
+                   <major>${ver[0] || 1}</major>
+                   <minor>${ver[1] || 0}</minor>
+                   <patch>${ver[2] || 0}</patch>
+                </appVersion>
+                <modelName>${this.modelName}</modelName>
+                <modelNumber>${this.modelNumber}</modelNumber>
+                <modelDescription>An application to control pool equipment.</modelDescription>
+                <serialNumber>${this.serialNumber}</serialNumber>
+                <UDN>${this.deviceUUID}::${this.deviceType}</UDN>
+                <serviceList></serviceList>
+                <deviceList></deviceList>
+            </device>
+        </root>`;
+        //console.log(XML.match(/<device>[\s|\S]+<appVersion>[\s|\S]+<major>(\d+)<\/major>/)[1]);
+        //console.log(XML.match(/<device>[\s|\S]+<appVersion>[\s|\S]+<minor>(\d+)<\/minor>/)[1]);
+        //console.log(XML.match(/<device>[\s|\S]+<appVersion>[\s|\S]+<patch>(\d+)<\/patch>/)[1]);
         return XML;
     }
     public async stopAsync() {
@@ -977,22 +1029,29 @@ export class MdnsServer extends ProtoServer {
                     if (question.name === '_poolcontroller._tcp.local') {
                         logger.info(`received mdns query for nodejs_poolController`);
                         self.server.respond({
-                            answers: [{
-                                name: '_poolcontroller._tcp.local',
-                                type: 'A',
-                                ttl: 300,
-                                data: webApp.ip()
-                            },
-                            {
-                                name: 'api._poolcontroller._tcp.local',
-                                type: 'SRV',
-                                data: {
-                                    port: '4200',
-                                    target: '_poolcontroller._tcp.local',
-                                    weight: 0,
-                                    priority: 10
-                                }
-                            }]
+                            answers: [
+                                {
+                                    name: '_poolcontroller._tcp.local',
+                                    type: 'A',
+                                    ttl: 300,
+                                    data: webApp.ip()
+                                },
+                                {
+                                    name: '_poolcontroller._tcp.local',
+                                    type: 'SRV',
+                                    data: {
+                                        port: webApp.httpPort().toString(),
+                                        target: '_poolcontroller._tcp.local',
+                                        weight: 0,
+                                        priority: 10
+                                    }
+                                },
+                                {
+                                    name: 'model',
+                                    type: 'TXT',
+                                    data: 'njsPC'
+                                },
+                            ]
                         });
                     }
                 });
@@ -1102,6 +1161,86 @@ export class HttpInterfaceServer extends ProtoServer {
         catch (err) { }
     }
 }
+export class RuleInterfaceServer extends ProtoServer {
+    public bindingsPath: string;
+    public bindings: RuleInterfaceBindings;
+    private _fileTime: Date = new Date(0);
+    private _isLoading: boolean = false;
+    public async init(cfg) {
+        this.uuid = cfg.uuid;
+        if (cfg.enabled) {
+            if (cfg.fileName && this.initBindings(cfg)) this.isRunning = true;
+        }
+    }
+    public loadBindings(cfg): boolean {
+        this._isLoading = true;
+        if (fs.existsSync(this.bindingsPath)) {
+            try {
+                let bindings = JSON.parse(fs.readFileSync(this.bindingsPath, 'utf8'));
+                let ext = extend(true, {}, typeof cfg.context !== 'undefined' ? cfg.context.options : {}, bindings);
+                this.bindings = Object.assign<RuleInterfaceBindings, any>(new RuleInterfaceBindings(cfg), ext);
+                this.isRunning = true;
+                this._isLoading = false;
+                const stats = fs.statSync(this.bindingsPath);
+                this._fileTime = stats.mtime;
+                return true;
+            }
+            catch (err) {
+                logger.error(`Error reading interface bindings file: ${this.bindingsPath}. ${err}`);
+                this.isRunning = false;
+                this._isLoading = false;
+            }
+        }
+        return false;
+    }
+    public initBindings(cfg): boolean {
+        let self = this;
+        try {
+            this.bindingsPath = path.posix.join(process.cwd(), "/web/bindings") + '/' + cfg.fileName;
+            let fileTime = new Date(0).valueOf();
+            fs.watch(this.bindingsPath, (event, fileName) => {
+                if (fileName && event === 'change') {
+                    if (self._isLoading) return; // Need a debounce here.  We will use a semaphore to cause it not to load more than once.
+                    const stats = fs.statSync(self.bindingsPath);
+                    if (stats.mtime.valueOf() === self._fileTime.valueOf()) return;
+                    self.loadBindings(cfg);
+                    logger.info(`Reloading ${cfg.name || ''} interface config: ${fileName}`);
+                }
+            });
+            this.loadBindings(cfg);
+            if (this.bindings.context.mdnsDiscovery) {
+                let srv = webApp.mdnsServer;
+                let qry = typeof this.bindings.context.mdnsDiscovery === 'string' ? { name: this.bindings.context.mdnsDiscovery, type: 'A' } : this.bindings.context.mdnsDiscovery;
+                if (typeof srv !== 'undefined') {
+                    srv.queryMdns(qry);
+                    srv.mdnsEmitter.on('mdnsResponse', (response) => {
+                        let url: URL;
+                        url = new URL(response);
+                        this.bindings.context.options.host = url.host;
+                        this.bindings.context.options.port = url.port || 80;
+                    });
+                }
+            }
+            return true;
+        }
+        catch (err) {
+            logger.error(`Error initializing interface bindings: ${err}`);
+        }
+        return false;
+    }
+    public emitToClients(evt: string, ...data: any) {
+        if (this.isRunning) {
+            // Take the bindings and map them to the appropriate http GET, PUT, DELETE, and POST.
+            this.bindings.bindEvent(evt, ...data);
+        }
+    }
+    public async stopAsync() {
+        try {
+            logger.info(`${this.name} Interface Server Shut down`);
+        }
+        catch (err) { }
+    }
+}
 
 export class InfluxInterfaceServer extends ProtoServer {
     public bindingsPath: string;
@@ -1163,10 +1302,9 @@ export class InfluxInterfaceServer extends ProtoServer {
         }
     }
 }
-
 export class MqttInterfaceServer extends ProtoServer {
     public bindingsPath: string;
-    public bindings: HttpInterfaceBindings;
+    public bindings: MqttInterfaceBindings;
     private _fileTime: Date = new Date(0);
     private _isLoading: boolean = false;
     public get isConnected() { return this.isRunning && this.bindings.events.length > 0; }
@@ -1182,7 +1320,20 @@ export class MqttInterfaceServer extends ProtoServer {
             try {
                 let bindings = JSON.parse(fs.readFileSync(this.bindingsPath, 'utf8'));
                 let ext = extend(true, {}, typeof cfg.context !== 'undefined' ? cfg.context.options : {}, bindings);
-                this.bindings = Object.assign<MqttInterfaceBindings, any>(new MqttInterfaceBindings(cfg), ext);
+                if (this.bindings && this.bindings.client) {
+                    // RKS: 05-29-22 - This was actually orphaning the subscriptions and event processors.  Instead of simply doing
+                    // an assign we ned to assign the underlying data and clear the old info out.  The reload method takes care of the
+                    // bindings for us.
+                    (async () => {
+                        await this.bindings.reload(ext);
+                    })();
+                }
+                else {
+                    this.bindings = Object.assign<MqttInterfaceBindings, any>(new MqttInterfaceBindings(cfg), ext);
+                    (async () => {
+                        await this.bindings.initAsync();
+                    })();
+                }
                 this.isRunning = true;
                 this._isLoading = false;
                 const stats = fs.statSync(this.bindingsPath);
@@ -1227,7 +1378,8 @@ export class MqttInterfaceServer extends ProtoServer {
     }
     public async stopAsync() {
         try {
-            if (typeof this.bindings !== 'undefined') await this.bindings.stopAsync();
+            fs.unwatchFile(this.bindingsPath);
+            if (this.bindings) await this.bindings.stopAsync();
         } catch (err) { logger.error(`Error shutting down MQTT Server ${this.name}: ${err.message}`); }
     }
 }
@@ -1253,7 +1405,7 @@ export class REMInterfaceServer extends ProtoServer {
         this.uuid = cfg.uuid;
         if (cfg.enabled) {
             this.initSockets();
-            setTimeout(async () => {
+            setTimeoutSync(async () => {
                 try {
                     await self.initConnection();
                 }
@@ -1267,18 +1419,18 @@ export class REMInterfaceServer extends ProtoServer {
         try {
             let response = await this.sendClientRequest('GET', '/config/backup/controller', undefined, 10000);
             return response;
-        } catch (err) { logger.error(err); }
+        } catch (err) { logger.error(`Error requesting GET /config/backup/controller: ${err.message}`); }
     }
     public async validateRestore(cfg): Promise<InterfaceServerResponse> {
         try {
             let response = await this.sendClientRequest('PUT', '/config/restore/validate', cfg, 10000);
             return response;
-        } catch (err) { logger.error(err); }
+        } catch (err) { logger.error(`Error requesting PUT /config/restore/validate ${err.message}`); }
     }
     public async restoreConfig(cfg): Promise<InterfaceServerResponse> {
         try {
             return await this.sendClientRequest('PUT', '/config/restore/file', cfg, 20000);
-        } catch (err) { logger.error(err); }
+        } catch (err) { logger.error(`Error requesting PUT /config/restore/file ${err.message}`); }
     }
     private async initConnection() {
         try {
@@ -1289,6 +1441,8 @@ export class REMInterfaceServer extends ProtoServer {
                 let url = '/config/checkconnection/';
                 // can & should extend for https/username-password/ssl
                 let data: any = { type: "njspc", isActive: true, id: null, name: "njsPC - automatic", protocol: "http:", ipAddress: webApp.ip(), port: config.getSection('web').servers.http.port || 4200, userName: "", password: "", sslKeyFile: "", sslCertFile: "", hostnames: [] }
+                if (typeof this.cfg.options !== 'undefined' && this.cfg.options.host !== 'undefined' &&
+                    this.cfg.options.host.toLowerCase() === 'localhost' || this.cfg.options.host === '127.0.0.1') data.loopback = true;
                 logger.info(`Checking REM Connection ${data.name} ${data.ipAddress}:${data.port}`);
                 try {
                     data.hostnames = await dns.promises.reverse(data.ipAddress);
@@ -1306,15 +1460,15 @@ export class REMInterfaceServer extends ProtoServer {
                 url = '/config/checkemit'
                 data = { eventName: "checkemit", property: "result", value: 'success', connectionId: result.obj.id }
                 // wait for REM server to finish resetting
-                setTimeout(async () => {
+                setTimeoutSync(async () => {
                     try {
-                        let _tmr = setTimeout(() => { return reject(new Error(`initConnection: No socket response received.  Check REM→njsPC communications.`)) }, 5000);
+                        let _tmr = setTimeoutSync(() => { return reject(new Error(`initConnection: No socket response received.  Check REM→njsPC communications.`)) }, 5000);
                         let srv: HttpServer = webApp.findServer('http') as HttpServer;
                         srv.addListenerOnce('/checkemit', (data: any) => {
                             // if we receive the emit, data will work both ways.
                             // console.log(data);
                             clearTimeout(_tmr);
-                            logger.info(`REM bi-directional communications established.`)
+                            logger.info(`${this.name} bi-directional communications established.`)
                             resolve();
                         });
                         result = await self.putApiService(url, data);
@@ -1446,11 +1600,11 @@ export class REMInterfaceServer extends ProtoServer {
             });
             this.isRunning = true;
         }
-        catch (err) { logger.error(err); }
+        catch (err) { logger.error(`Error Initializing Sockets: ${err.message}`); }
     }
     private isJSONString(s: string): boolean {
         if (typeof s !== 'string') return false;
-        if (typeof s.startsWith('{') || typeof s.startsWith('[')) return true;
+        if (s.startsWith('{') || s.startsWith('[')) return true;
         return false;
     }
     public async getApiService(url: string, data?: any, timeout: number = 3600): Promise<InterfaceServerResponse> {
@@ -1475,7 +1629,11 @@ export class REMInterfaceServer extends ProtoServer {
     }
     public async getDevices() {
         try {
-            let response = await this.sendClientRequest('GET', '/devices/all', undefined, 10000);
+            let response = await this.sendClientRequest('GET', '/devices/all', undefined, 3000);
+            if (response.status.code !== 200) {
+                // Let's try again.  Sometimes the resolver for calls like this are stupid.
+                response = await this.sendClientRequest('GET', '/devices/all', undefined, 10000);
+            }
             return (response.status.code === 200) ? JSON.parse(response.data) : [];
         }
         catch (err) { logger.error(err); }