nodejs-poolcontroller 7.7.0 → 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.
@@ -115,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);
@@ -165,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) {
@@ -172,10 +182,39 @@ 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 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; }
@@ -222,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}`); }
     }
@@ -373,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}`); }
@@ -481,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.`);
@@ -606,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)
@@ -647,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);
     }
@@ -738,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;
             }
@@ -789,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 !== '/upnp.xml') {
+                    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}`);
                     }
@@ -840,7 +884,7 @@ 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;
@@ -858,16 +902,37 @@ export class SsdpServer extends ProtoServer {
             this.modelName = `njsPC v${ver}`;
             this.modelNumber = `njsPC${ver.replace(/\./g, '-')}`;
             // todo: should probably check if http/https is enabled at this point
-            let port = config.getSection('web').servers.http.port || 7777;
-            this.upnpPath = 'http://' + webApp.ip() + ':' + port + '/upnp.xml';
+            //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;
-            this.server = new SSDP({
-                //customLogger: (...args) => console.log.apply(null, args),
-                logLevel: 'INFO',
-                udn: this.deviceUUID,
-                location: this.upnpPath,
-                sourcePort: 1900
-            });
+            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
@@ -883,6 +948,9 @@ export class SsdpServer extends ProtoServer {
         }
     }
     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:device-1-0">
             <specVersion>
@@ -891,10 +959,15 @@ export class SsdpServer extends ProtoServer {
             </specVersion>
             <device>
                 <deviceType>${this.deviceType}</deviceType>
-                <friendlyName>NodeJS Pool Controller</friendlyName> 
+                <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>
@@ -904,6 +977,9 @@ export class SsdpServer extends ProtoServer {
                 <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() {
@@ -915,77 +991,6 @@ export class SsdpServer extends ProtoServer {
         } catch (err) { logger.error(`Error stopping SSDP server ${err.message}`); }
     }
 }
-/* RKS DEPRECATED: 05-07-22 - This did not follow the upnp rules so it was not detecting properly.  The entire class above emits the proper xml layout.
-export class SsdpServer1 extends ProtoServer {
-    // Simple service discovery protocol
-    public server: any; //node-ssdp;
-    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();
-            // 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');
-
-            // start the server
-            this.server.start()
-                .then(function () {
-                    logger.silly('SSDP/UPnP Server started.');
-                    self.isRunning = true;
-                });
-
-            this.server.on('error', function (e) {
-                logger.error('error from SSDP:', e);
-            });
-        }
-    }
-    public static deviceXML() {
-        let ver = sys.appVersion;
-        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>`;
-        return XML;
-    }
-    public async stopAsync() {
-        try {
-            if (typeof this.server !== 'undefined') {
-                this.server.stop();
-                logger.info(`Stopped SSDP server: ${this.name}`);
-            }
-        } catch (err) { logger.error(`Error stopping SSDP server ${err.message}`); }
-    }
-}
-*/
-
-
-
 export class MdnsServer extends ProtoServer {
     // Multi-cast DNS server
     public server;
@@ -1024,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'
+                                },
+                            ]
                         });
                     }
                 });
@@ -1149,6 +1161,87 @@ 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;
     public bindings: InfluxInterfaceBindings;
@@ -1211,7 +1304,7 @@ 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; }
@@ -1227,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);
@@ -1272,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}`); }
     }
 }
@@ -1298,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();
                 }
@@ -1312,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 {
@@ -1334,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);
@@ -1351,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);
@@ -1491,7 +1600,7 @@ 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;
@@ -1520,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); }