nodejs-poolcontroller 7.6.1 → 8.0.0

package/anslq25/boards/MockSystemBoard.ts

@@ -0,0 +1,217 @@
+/*  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 { logger } from "../../logger/Logger";
+import { setTimeout as setTimeoutSync } from 'timers';
+import { Inbound, Outbound, Protocol } from "../../controller/comms/messages/Messages";
+import { byteValueMap, byteValueMaps, SystemBoard } from "../../controller/boards/SystemBoard";
+import { Anslq25, PoolSystem, sys } from "../../controller/Equipment";
+import { ControllerType, utils } from "../../controller/Constants";
+import { conn } from "../../controller/comms/Comms";
+import { MockEasyTouch } from "./MockEasyTouchBoard";
+
+export class MockSystemBoard {
+  public valueMaps: byteValueMaps = new byteValueMaps();
+  protected _statusTimer: NodeJS.Timeout;
+  protected _statusCheckRef: number = 0;
+  protected _statusInterval: number = 5000;
+  constructor(system: PoolSystem) {
+    // sys.anslq25.portId = 0; // pass this in.
+    setTimeout(() => {
+      this.processStatusAsync().then(() => { });
+    }, 5000);
+  }
+  public expansionBoards: byteValueMap = new byteValueMap();
+  public get statusInterval(): number { return this._statusInterval };
+  public system: MockSystemCommands = new MockSystemCommands(this);
+  public circuits: MockCircuitCommands = new MockCircuitCommands(this);
+  public schedules: MockScheduleCommands = new MockScheduleCommands(this);
+  public heaters: MockHeaterCommands = new MockHeaterCommands(this);
+  public valves: MockValveCommands = new MockValveCommands(this);
+  public remotes: MockRemoteCommands = new MockRemoteCommands(this);
+  public pumps: MockPumpCommands = new MockPumpCommands(this);
+  public static convertOutbound(outboundMsg: Outbound) { };
+  public async sendAsync(msg: Outbound){
+    return await msg.sendAsync();
+    // is the controller on a real/physical port or a mock port?
+/*     let port = conn.findPortById(sys.anslq25.portId);
+    if (port.mockPort) {
+      let inbound = new Inbound();
+      inbound.protocol = msg.protocol;
+      inbound.header = msg.header;
+      inbound.payload = msg.payload;
+      inbound.term = msg.term;
+      inbound.portId = msg.portId;
+      // don't need to wait for packet to process
+      setTimeout(()=>{conn.sendMockPacket(inbound)}, 10);
+      return Promise.resolve();
+    }
+    else {
+      return await msg.sendAsync();
+    } */
+  }
+  public process(msg: Inbound): Outbound { return new Outbound(Protocol.Broadcast,0,0,0,[]); }
+  protected killStatusCheck() {
+    if (typeof this._statusTimer !== 'undefined' && this._statusTimer) clearTimeout(this._statusTimer);
+    this._statusTimer = undefined;
+    this._statusCheckRef = 0;
+  }
+  public suspendStatus(bSuspend: boolean) {
+    // The way status suspension works is by using a reference value that is incremented and decremented
+    // the status check is only performed when the reference value is 0.  So suspending the status check 3 times and un-suspending
+    // it 2 times will still result in the status check being suspended.  This method also ensures the reference never falls below 0.
+    if (bSuspend) this._statusCheckRef++;
+    else this._statusCheckRef = Math.max(0, this._statusCheckRef - 1);
+    if (this._statusCheckRef > 1) logger.verbose(`Suspending ANSLQ25 status check: ${bSuspend} -- ${this._statusCheckRef}`);
+  }
+  public async setAnslq25Async(data: any): Promise<Anslq25> {
+    let self = this;
+    try {
+      this.suspendStatus(true);
+      // if (typeof data.isActive === 'undefined') return Promise.reject(`Mock System Board: No isActive flag provided.`);
+      if (typeof data.anslq25portId === 'undefined') return Promise.reject(new Error(`Mock System Board: No portId provided.`));
+      if (typeof data.anslq25ControllerType === 'undefined') return Promise.reject(new Error(`Mock System Board: No controller type provided.`));
+      if (typeof data.anslq25model === 'undefined') return Promise.reject(new Error(`Mock System Board: No model provided.`));
+      //for (let i = 1; i <= )
+      let isActive = true; // utils.makeBool(data.isActive);
+      let portId = parseInt(data.anslq25portId, 10);
+      let port = conn.findPortById(portId);
+      if (typeof port === 'undefined') return Promise.reject(new Error(`Mock System Board: Invalid portId provided.`));
+      if (portId === 0) return Promise.reject(new Error(`Please choose a port other than the primary port.`));
+      let mockControllerType = data.anslq25ControllerType;
+      let model = parseInt(data.anslq25model, 10);
+      let broadcastComms = data.broadcastComms;
+      if (typeof broadcastComms === 'undefined') return Promise.reject(new Error(`A value for broadcast comms must be provided.`));
+      sys.anslq25.portId = portId;
+      sys.anslq25.broadcastComms = broadcastComms;
+      switch (mockControllerType) {
+        case ControllerType.EasyTouch:{
+          sys.anslq25ControllerType = ControllerType.EasyTouch;
+          // (sys.anslq25Board as MockEasyTouch).initExpansionModules(model);
+          break;
+        }
+        default: {
+          logger.warn(`No ANSLQ25 Mock Board definiton yet for: ${mockControllerType}`);
+          return Promise.reject(new Error(`No ANSLQ25 Mock Board definiton yet for: ${mockControllerType}`));
+        }
+      }
+      sys.anslq25.isActive = isActive;
+      sys.anslq25.model = model;
+
+    } catch (err) {
+      logger.error(`Error changing port id: ${err.message}`);
+    }
+    finally {
+      this.suspendStatus(false);
+      this._statusTimer = setTimeoutSync(async () => await self.processStatusAsync(), this.statusInterval);
+    }
+  }
+  public async deleteAnslq25Async(data: any)  {
+    try {
+
+      this.killStatusCheck();
+      this.closeAsync();
+      sys.anslq25.isActive = false;
+      sys.anslq25.portId = undefined;
+      sys.anslq25.model = undefined;
+      sys.anslq25ControllerType = ControllerType.None;
+    }
+    catch (err){
+
+    }
+    finally {
+      this.suspendStatus(false);
+    }
+
+  }
+
+  public async processStatusAsync() {
+    let self = this;
+    try {
+      if (this._statusCheckRef > 0) return;
+      this.suspendStatus(true);
+     
+      await sys.anslq25Board.system.sendStatusAsync();
+    }
+    catch (err) {
+      logger.error(`Error running mock processStatusAsync: ${err}`);
+    }
+    finally {
+      this.suspendStatus(false);
+      if (sys.anslq25.isActive){
+        if (this.statusInterval > 0) this._statusTimer = setTimeoutSync(async () => await self.processStatusAsync(), this.statusInterval);
+      }
+
+    }
+  }
+  // public async setPortId(portId: number) {
+  //   let self = this;
+  //   try {
+  //     this.suspendStatus(true);
+  //     sys.anslq25.portId = portId;
+
+  //   } catch (err) {
+  //     logger.error(`Error changing port id: ${err.message}`);
+  //   }
+  //   finally {
+  //     this.suspendStatus(false);
+  //     this._statusTimer = setTimeoutSync(async () => await self.processStatusAsync(), this.statusInterval);
+  //   }
+  // }
+  public async closeAsync() {
+    try {
+    }
+    catch (err) { logger.error(err); }
+  }
+}
+export class MockBoardCommands {
+  protected mockBoard: MockSystemBoard = null;
+  constructor(parent: MockSystemBoard) { this.mockBoard = parent; }
+}
+export class MockSystemCommands extends MockBoardCommands {
+  public sendAck(msg:Inbound) {  };
+  public async processDateTimeAsync(msg: Inbound){  };
+  public async processCustomNameAsync(msg: Inbound){  };
+  public async processSettingsAsync(msg: Inbound){  };
+  public async sendStatusAsync() { };
+}
+
+export class MockCircuitCommands extends MockBoardCommands {
+  public async processCircuitAsync( msg: Inbound) { };
+  public async processLightGroupAsync( msg: Inbound) { };
+}
+export class MockScheduleCommands extends MockBoardCommands {
+  public async processScheduleAsync( msg: Inbound) { };
+}
+export class MockHeaterCommands extends MockBoardCommands {
+  public async processHeatModesAsync(msg: Inbound) { };
+  public async processHeaterConfigAsync(msg: Inbound) { };
+}
+export class MockValveCommands extends MockBoardCommands {
+  public async processValveOptionsAsync(msg: Inbound) { };
+  public async processValveAssignmentsAsync(msg: Inbound) { };
+}
+export class MockRemoteCommands extends MockBoardCommands {
+  public async processIS4IS10RemoteAsync(msg: Inbound) { };
+  public async processQuickTouchRemoteAsync(msg: Inbound) { };
+  public async processSpaCommandRemoteAsync(msg: Inbound) { };
+}
+export class MockPumpCommands extends MockBoardCommands {
+  public async processPumpConfigAsync(msg: Inbound) { };
+  public async processHighSpeedCircuitsAsync(msg: Inbound) { };
+}

package/anslq25/chemistry/MockChlorinator.ts

@@ -0,0 +1,75 @@
+import { logger } from "../../logger/Logger";
+import { Inbound, Outbound } from "../../controller/comms/messages/Messages";
+import { conn } from "../../controller/comms/Comms";
+
+export class MockChlorinator {
+  constructor(){}
+
+  public process(inbound: Inbound){
+    let response: Outbound = Outbound.create({
+      portId: inbound.portId,
+      protocol: inbound.protocol,
+      dest: 0
+    });
+
+    switch (inbound.action){
+      case 0: // Set control OCP->Chlorinator: [16,2,80,0][0][98,16,3]
+        this.chlorSetControl(inbound, response);
+      case 17: // OCP->Chlorinator set output. [16,2,80,17][15][130,16,3]
+        this.chlorSetOutput(inbound, response);
+        case 19: // iChlor keep alive(?) [16, 2, 80, 19][117, 16, 3]
+        // need response   
+        break;
+      case 20: // OCP->Chlorinator Get model [16,2,80,20][0][118,16,3]
+        this.chlorGetModel(inbound, response);
+      default:
+        logger.info(`No mock chlorinator response for ${inbound.toShortPacket()} `);
+    }
+  }
+
+   public async chlorSetControl(inbound: Inbound, response: Outbound){
+    /*     
+    {"port":0,"id":42633,"valid":true,"dir":"out","proto":"chlorinator","pkt":[[],[], [16,2,80,0], [0],[98,16,3]],"ts":"2022-07-19T21:45:59.959-0700"}
+    {"port":0,"id":42634,"valid":true,"dir":"in","proto":"chlorinator","for":[42633],"pkt":[[],[],[16,2,0,1],[0,0],[19,16,3]],"ts": "2022-07-19T21:45:59.999-0700"} */
+    try {
+
+      response.action = 1;
+      response.appendPayloadBytes(0, 2);
+      await response.sendAsync()
+    }
+    catch (err){
+      logger.error(`Error sending mock chlor packet ${response.toPacket}`);
+    }
+  }
+  public  chlorSetOutput(inbound: Inbound, response: Outbound){
+    /*     
+    {"port":0,"id":42639,"valid":true,"dir":"out","proto":"chlorinator","pkt":[[],[], [16,2,80,17], [100],[215,16,3]],"ts":"2022-07-19T21:46:00.302-0700"}
+    {"port":0,"id":42640,"valid":true,"dir":"in","proto":"chlorinator","for":[42639],"pkt":[[],[],[16,2,0,18],[78,128],[242,16,3]],"ts": "2022-07-19T21:46:00.341-0700"} */
+      response.action = 18;
+      response.appendPayloadBytes(0, 2);
+      // ideal high = 4500 = 90 * 50; ideal low = 2800 = 56 * 50
+      response.setPayloadByte(0, this.random(90-56, true)+56, 75)
+      response.setPayloadByte(1, 128); 
+      conn.queueSendMessage(response);
+  }
+  public chlorGetModel(inbound: Inbound, response: Outbound){
+    /*  
+    {"port":0,"id":42645,"valid":true,"dir":"out","proto":"chlorinator","pkt":[[],[], [16,2,80,20], [0],[118,16,3]],"ts":"2022-07-19T21:46:00.645-0700"}   
+    {"port":0,"id":42646,"valid":true,"dir":"in","proto":"chlorinator","for":[42645],"pkt":[[],[],[16,2,0,3],[0,73,110,116,101,108,108,105,99,104,108,111,114,45,45,54,48],[190,16,3]],"ts": "2022-07-19T21:46:00.700-0700"}   */
+    response.action = 3;
+    response.appendPayloadBytes(0, 17);
+    response.insertPayloadString(1, 'INTELLICHLOR--60');
+    conn.queueSendMessage(response);
+  }
+
+  private random(bounds: number, onlyPositive: boolean = false){
+    let rand = Math.random() * bounds;
+    if (!onlyPositive) {
+      if (Math.random()<=.5) rand = rand * -1;
+    }
+    return rand;
+  }
+
+}
+
+export var mockChlor: MockChlorinator = new MockChlorinator();

package/anslq25/pumps/MockPump.ts

@@ -0,0 +1,84 @@
+import { sys } from "../../controller/Equipment";
+import { PumpState, state } from "../../controller/State";
+import { Outbound } from "../../controller/comms/messages/Messages";
+import { conn } from "controller/comms/Comms";
+
+export class MockPump {
+  constructor(){}
+
+  public process(outboundMsg: Outbound){
+    let response: Outbound = Outbound.create({
+      portId: outboundMsg.portId,
+      protocol: outboundMsg.protocol
+    });
+
+    switch (outboundMsg.action){
+      case 7:
+        this.pumpStatus(outboundMsg, response);
+      default:
+        this.pumpAck(outboundMsg, response);
+    }
+  }
+
+  public pumpStatus(outboundMsg: Outbound, response: Outbound){
+    let pState:PumpState = state.pumps.getItemById(outboundMsg.dest - 96);
+    let pt = sys.board.valueMaps.pumpTypes.get(pState.type);
+    response.action = 7;
+    response.source = outboundMsg.dest;
+    response.dest = outboundMsg.source;
+    response.appendPayloadBytes(0, 15);
+    response.setPayloadByte(0, pState.command, 2);
+    response.setPayloadByte(1, pState.mode, 0);
+    response.setPayloadByte(2, pState.driveState, 2);
+    let watts = 0;
+    if (Math.max(pState.rpm, pState.flow) > 0){
+      if (pState.rpm > 0) watts = pState.rpm/pt.maxSpeed * 2000 + this.random(100);
+      else if (pState.flow > 0) watts = pState.flow/pt.maxFlow * 2000 + this.random(100);
+      else //ss, ds, etc
+      watts = 2000 + this.random(250);
+    }
+    response.setPayloadByte(3, Math.floor(watts / 256), 0);
+    response.setPayloadByte(4, watts % 256, 0);
+    response.setPayloadByte(5, Math.floor(pState.rpm / 256), 0);
+    response.setPayloadByte(6, pState.rpm % 256, 0);
+    response.setPayloadByte(7, pState.flow, 0);
+    response.setPayloadByte(8, pState.ppc, 0);
+    // 9, 10 = unknown
+    // 11, 12 = Status code; 
+    response.setPayloadByte(11, Math.floor(pState.status / 256), 0);
+    response.setPayloadByte(12, pState.status % 256, 1);
+    let time = new Date();
+    response.setPayloadByte(13, time.getHours() * 60);
+    response.setPayloadByte(14, time.getMinutes());
+    
+    conn.queueSendMessage(response);
+  }
+
+  public pumpAck(outboundMsg: Outbound, response: Outbound){
+    response.action = outboundMsg.action;
+    response.source = outboundMsg.dest;
+    response.dest = outboundMsg.source;
+    switch (outboundMsg.action){
+      case 1:
+      case 10: {
+        response.appendPayloadByte(outboundMsg.payload[2]);
+        response.appendPayloadByte(outboundMsg.payload[3]);
+        break;
+      }
+      default:    
+        response.appendPayloadByte(outboundMsg.payload[0]);
+      }
+    conn.queueSendMessage(response);
+  }
+
+  private random(bounds: number, onlyPositive: boolean = false){
+    let rand = Math.random() * bounds;
+    if (!onlyPositive) {
+      if (Math.random()<=.5) rand = rand * -1;
+    }
+    return rand;
+  }
+
+}
+
+export var mockPump: MockPump = new MockPump();

package/app.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
@@ -15,36 +16,31 @@ 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/>.
 */
 // add source map support for .js to .ts files
-require('source-map-support').install();
+//require('source-map-support').install();
+import 'source-map-support/register';
 
 import { logger } from "./logger/Logger";
 import { config } from "./config/Config";
 import { conn } from "./controller/comms/Comms";
-import { sys, ControllerType } from "./controller/Equipment";
+import { sys } from "./controller/Equipment";
 
 import { state } from "./controller/State";
 import { webApp } from "./web/Server";
 import * as readline from 'readline';
+import { sl } from './controller/comms/ScreenLogic'
 
 export async function initAsync() {
     try {
         await config.init();
         await logger.init();
-        await conn.init();
         await sys.init();
         await state.init();
         await webApp.init();
+        await conn.initAsync();
         await sys.start();
         await webApp.initAutoBackup();
+        await sl.openAsync();
     } catch (err) { console.log(`Error Initializing nodejs-PoolController ${err.message}`);  }
-    //return Promise.resolve()
-    //    .then(function () { config.init(); })
-    //    .then(function () { logger.init(); })
-    //    .then(function () { conn.init(); })
-    //    .then(function () { sys.init(); })
-    //    .then(function () { state.init(); })
-    //    .then(function () { webApp.init(); })
-    //    .then(function () { sys.start(); });
 }
 
 export async function startPacketCapture(bResetLogs: boolean) {
@@ -70,13 +66,13 @@ export async function stopPacketCaptureAsync() {
 export async function stopAsync(): Promise<void> {
     try {
         console.log('Shutting down open processes');
-        // await sys.board.virtualPumpControllers.stopAsync();
         await webApp.stopAutoBackup();
         await sys.stopAsync();
         await state.stopAsync();
         await conn.stopAsync();
+        await sl.closeAsync();
         await webApp.stopAsync();
-        config.update();
+        await config.updateAsync();
         await logger.stopAsync();
         // RKS: Uncomment below to see the shutdown process
         //await new Promise<void>((resolve, reject) => { setTimeout(() => { resolve(); }, 20000); });

package/config/Config.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
@@ -20,6 +21,7 @@ import { EventEmitter } from 'events';
 const extend = require("extend");
 import { logger } from "../logger/Logger";
 import { utils } from "../controller/Constants";
+import { setTimeout } from 'timers/promises';
 class Config {
     private cfgPath: string;
     private _cfg: any;
@@ -39,7 +41,7 @@ class Config {
             const packageJson = JSON.parse(fs.readFileSync(path.join(process.cwd(), "/package.json"), "utf8").trim());
             this._cfg = extend(true, {}, def, this._cfg, { appVersion: packageJson.version });
             this._isInitialized = true;
-            this.update((err) => {
+            this.updateAsync((err) => {
                 if (typeof err === 'undefined') {
                     fs.watch(this.cfgPath, (event, fileName) => {
                         if (fileName && event === 'change') {
@@ -55,7 +57,7 @@ class Config {
                         }
                     });
                 }
-                else throw err;
+                else return Promise.reject(err);
             });
             this._isLoading = false;
             this.getEnvVariables();
@@ -65,7 +67,7 @@ class Config {
             throw err;
         }
     }
-    public update(callback?: (err?) => void) {
+    public async updateAsync(callback?: (err?) => void) {
         // Don't overwrite the configuration if we failed during the initialization.
         try {
             if (!this._isInitialized) {
@@ -78,7 +80,8 @@ class Config {
                 JSON.stringify(this._cfg, undefined, 2)
             );
             if (typeof callback === 'function') callback();
-            setTimeout(()=>{this._isLoading = false;}, 2000);
+            await setTimeout(2000);
+            this._isLoading = false;
         }
         catch (err) {
             logger.error("Error writing configuration file %s", err);
@@ -86,6 +89,20 @@ class Config {
 
         }
     }
+    public removeSection(section: string) {
+        let c = this._cfg;
+        if (section.indexOf('.') !== -1) {
+            let arr = section.split('.');
+            for (let i = 0; i < arr.length - 1; i++) {
+                if (typeof c[arr[i]] === 'undefined')
+                    c[arr[i]] = {};
+                c = c[arr[i]];
+            }
+            section = arr[arr.length - 1];
+        }
+        if(typeof c[section] !== 'undefined') delete c[section];
+        this.updateAsync();
+    }
     public setSection(section: string, val) {
         let c = this._cfg;
         if (section.indexOf('.') !== -1) {
@@ -98,7 +115,7 @@ class Config {
             section = arr[arr.length - 1];
         }
         c[section] = val;
-        this.update();
+        this.updateAsync();
     }
     // RKS: 09-21-21 - We are counting on the return from this being immutable.  A copy of the data
     // should always be returned here.
@@ -121,6 +138,7 @@ class Config {
         this.ensurePath(baseDir + '/logs/');
         this.ensurePath(baseDir + '/data/');
         this.ensurePath(baseDir + '/backups/');
+        this.ensurePath(baseDir + '/web/bindings/custom/')
         // this.ensurePath(baseDir + '/replay/');
         //setTimeout(() => { config.update(); }, 100);
     }
@@ -138,7 +156,7 @@ class Config {
         for (var i in interfaces) {
             if (interfaces[i].uuid === obj.uuid) {
                 interfaces[i] = obj;
-                this.update();
+                this.updateAsync();
                 return {[i]: interfaces[i]};
             }
         }
@@ -171,7 +189,7 @@ class Config {
             this._cfg.controller.comms.netPort = env.POOL_NET_PORT;
             bUpdate = true;
         }
-        if (bUpdate) this.update();
+        if (bUpdate) this.updateAsync();
     }
 }
 export const config: Config = new Config();

package/config/VersionCheck.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
@@ -45,7 +46,7 @@ class VersionCheck {
             let out: string;
             if (typeof env.SOURCE_BRANCH !== 'undefined') 
             {
-                out = `${env.SOURCE_BRANCH} - From environment variable`; // check for docker variable
+                out = env.SOURCE_BRANCH // check for docker variable
             }
             else {
                 let res = execSync('git rev-parse --abbrev-ref HEAD', { stdio: 'pipe' });
@@ -69,7 +70,7 @@ class VersionCheck {
             let out: string;
             if (typeof env.SOURCE_COMMIT !== 'undefined') 
             {
-                out = `${env.SOURCE_COMMIT} - From environment variable`; // check for docker variable
+                out = env.SOURCE_COMMIT; // check for docker variable
             }
             else {
                 let res = execSync('git rev-parse HEAD', { stdio: 'pipe' });
@@ -124,7 +125,7 @@ class VersionCheck {
         if (this.redirects >= 20) return Promise.reject(`Too many redirects.`)
         return new Promise<string>((resolve, reject) => {
             try {
-                https.request(url, options, async res => {
+                let req = https.request(url, options, async res => {
                     if (res.statusCode > 300 && res.statusCode < 400 && res.headers.location) await this.getLatestRelease(res.headers.location);
                     let data = '';
                     res.on('data', d => { data += d; });
@@ -137,6 +138,9 @@ class VersionCheck {
                     })
                 })
                     .end();
+                req.on('error', (err) => {
+                    logger.error(`Error getting Github API latest release.  ${err.message}`)
+                })
             }
             catch (err) {
                 logger.error('Error contacting Github for latest published release: ' + err);