improved auto-reconnect feature

connectorFactory.js

@@ -30,7 +30,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-import env from "./env";
+import env, {logger} from "./env";
 
 export default class ConnectorFactory {
 
@@ -67,10 +67,35 @@ export default class ConnectorFactory {
                 resolve(Promise.all(connectors
                     .map(connector =>
                         new Promise((resolve, reject) => {
-                            connector.connect()
+                            connector
+                                .connect()
                                 .then(() => {
                                     connector.connected = true;
                                     resolve(true);
+
+                                    connector.onError(error => {
+                                        logger.log({
+                                            level: 'error',
+                                            message: error
+                                        });
+                                    });
+
+                                    connector.onConnect(error => {
+                                        logger.log({
+                                            level: 'info',
+                                            message: error
+                                        });
+                                    });
+
+                                    connector.onDisconnect(error => {
+                                        connector.connected = false;
+
+                                        logger.log({
+                                            level: 'info',
+                                            message: error
+                                        });
+                                    });
+
                                 })
                                 .catch((error) => {
                                     env.logger.log({

connectors/connector.js

@@ -42,30 +42,38 @@ export default class Connector {
         this.messageCallback = null;
         this.connectCallback = null;
         this.errorCallback = null;
-        this.closeCallback = null;
+        this.disconnectCallback = null;
     }
 
     connect = () =>
         new Promise((resolve, reject) => reject(new Error('The method connect MUST be implemented')));
 
 
-    error = (error) => {
+    _error = (error) => {
         this.logger.log({
             level: 'error',
             message: error
         });
+
+        if (this.errorCallback)
+            this.errorCallback(error);
     };
 
     subscribe = (input) => {
         throw new Error('The method subscribe MUST be implemented');
     };
 
-    message = (message) => {
+    _disconnect = (message) => {
-        if (this.messageCallback)
+        if (this.disconnectCallback)
-        this.messageCallback(message);
+            this.disconnectCallback(message);
     };
 
-    connected = (message) => {
+    _message = (message) => {
+        if (this.messageCallback)
+            this.messageCallback(message);
+    };
+
+    _connect = (message) => {
         if (this.connectCallback)
             this.connectCallback(message);
     };
@@ -83,7 +91,11 @@ export default class Connector {
     };
 
     onError = (callback) => {
-        this.closeCallback = callback;
+        this.errorCallback = callback;
+    };
+
+    onDisconnect = (callback) => {
+        this.disconnectCallback = callback;
     };
 
 }

connectors/connectorRIS.js

@@ -45,19 +45,18 @@ export default class ConnectorRIS extends Connector{
     connect = () =>
         new Promise((resolve, reject) => {
             try {
-                delete this.pingTimer;
                 this.ws = new WebSocket(this.params.url);
 
                 this.pingTimer = setInterval(() => {
                     this.ws.ping(() => {})
                 }, 5000);
 
-                this.ws.on('message', this.message);
+                this.ws.on('message', this._message);
                 this.ws.on('close', this.close);
-                this.ws.on('error', this.error);
+                this.ws.on('error', this._error);
                 this.ws.on('open', () => {
                     resolve(true);
-                    this.connected(this.name + ' connector connected');
+                    this._connect(this.name + ' connector connected');
                 });
 
             } catch(error) {
@@ -66,11 +65,17 @@ export default class ConnectorRIS extends Connector{
             }
         });
 
-
     close = (error) => {
-        this.error(error);
+        this._disconnect(error);
         clearInterval(this.pingTimer);
-        setTimeout(() => this.subscribe(this.subscription), 5000);
+        setTimeout(() => {
+            try {
+                this.ws.terminate();
+            } catch(e) {
+            }
+            this.connect()
+                .then(() => this.subscribe(this.subscription));
+        }, 5000);
     };
 
     _subscribeToAll = (input) => {
@@ -106,7 +111,7 @@ export default class ConnectorRIS extends Connector{
 
                 resolve(true);
             } catch(error) {
-                this.error(error);
+                this._error(error);
                 resolve(false);
             }
         });

index.js

@@ -55,19 +55,6 @@ function master(worker) {
                         pubSub.publish("data", connector.name + "-" + message);
                     });
                 }
-
-                connector.onError(error => {
-                    logger.log({
-                        level: 'error',
-                        message: error
-                    });
-                });
-                connector.onConnect(error => {
-                    logger.log({
-                        level: 'info',
-                        message: error
-                    });
-                });
             }
         })
         .then(() => connectorFactory.subscribeConnectors(input))