podasync-ws-only 2.7.9 → 2.7.10-snapshot.10

package/README.md

@@ -7,7 +7,7 @@
 First you have to require PodAsync in your project.
 
 ```javascript
-var Async = require('podasync');
+var Async = require('podasync-ws-only');
 ```
 
 To be able to connect to async server, you should set some parameters. `Websockets`protocol is currently supported.

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "podasync-ws-only",
-  "version": "2.7.9",
+  "version": "2.7.10-snapshot.10",
   "description": "Fanap's POD Async service (DIRANA) - Websocket only",
   "main": "./src/network/async.js",
   "scripts": {
-    "test": "mocha --reporter spec --exit"
+    "test": "mocha --reporter spec --exit",
+    "publish:snapshot": "npm run version:snapshot && npm publish --tag snapshot",
+    "version:snapshot": "npm version prerelease --preid snapshot",
+    "publish:release": "npm run version:release && npm publish",
+    "version:release": "npm version 2.7.8"
   },
   "repository": {
     "type": "git",

package/src/network/async.js

@@ -13,15 +13,17 @@
          *******************************************************/
 
         var PodSocketClass,
-            PodUtility;
-
+            PodUtility,
+            LogLevel
         if (typeof(require) !== 'undefined' && typeof(exports) !== 'undefined') {
             PodSocketClass = require('./socket.js');
             PodUtility = require('../utility/utility.js');
+            LogLevel = require('../utility/logger.js');
         }
         else {
             PodSocketClass = POD.Socket;
             PodUtility = POD.AsyncUtility;
+            LogLevel = POD.LogLevel;
         }
 
         var Utility = new PodUtility();
@@ -60,6 +62,7 @@
                 CLOSING: 2, // The connection is in the process of closing.
                 CLOSED: 3 // The connection is closed or couldn't be opened.
             },
+            logLevel = LogLevel(params.logLevel),
             isNode = Utility.isNode(),
             isSocketOpen = false,
             isDeviceRegister = false,
@@ -80,7 +83,7 @@
             connectionRetryInterval = params.connectionRetryInterval || 5000,
             socketReconnectRetryInterval,
             socketReconnectCheck,
-            retryStep = 4,
+            // retryStep = 4,
             reconnectOnClose = (typeof params.reconnectOnClose === 'boolean') ? params.reconnectOnClose : true,
             asyncLogging = (params.asyncLogging && typeof params.asyncLogging.onFunction === 'boolean') ? params.asyncLogging.onFunction : false,
             onReceiveLogging = (params.asyncLogging && typeof params.asyncLogging.onMessageReceive === 'boolean')
@@ -89,6 +92,27 @@
             onSendLogging = (params.asyncLogging && typeof params.asyncLogging.onMessageSend === 'boolean') ? params.asyncLogging.onMessageSend : false,
             workerId = (params.asyncLogging && typeof parseInt(params.asyncLogging.workerId) === 'number') ? params.asyncLogging.workerId : 0;
 
+        // function setRetryStep(val){
+        //     console.log("new retryStep value:", val);
+        //     retryStep = val;
+        // }
+        //
+        // function getRetryStep() {
+        //     return retryStep;
+        // }
+
+        const retryStep = {
+            value: 4,
+            get() {
+                return retryStep.value;
+            },
+            set(val) {
+                // logLevel.debug && console.debug("[Async][async.js] retryStep new value:", val);
+                console.debug("[Async][async.js] retryStep new value:", val);
+                retryStep.value = val;
+            }
+        };
+
         /*******************************************************
          *            P R I V A T E   M E T H O D S            *
          *******************************************************/
@@ -122,7 +146,8 @@
                     socketAddress: params.socketAddress,
                     wsConnectionWaitTime: params.wsConnectionWaitTime,
                     connectionCheckTimeout: params.connectionCheckTimeout,
-                    connectionCheckTimeoutThreshold: params.connectionCheckTimeoutThreshold
+                    connectionCheckTimeoutThreshold: params.connectionCheckTimeoutThreshold,
+                    logLevel: logLevel
                 });
 
                 checkIfSocketHasOpennedTimeoutId = setTimeout(function () {
@@ -140,7 +165,8 @@
                     socketReconnectCheck && clearTimeout(socketReconnectCheck);
 
                     isSocketOpen = true;
-                    retryStep = 4;
+                    // retryStep = 4;
+                    retryStep.set(4);
 
                     socketState = socketStateType.OPEN;
                     fireEvent('stateChange', {
@@ -164,32 +190,32 @@
                     isDeviceRegister = false;
                     oldPeerId = peerId;
 
-                    socketState = socketStateType.CLOSED;
-
-                    fireEvent('stateChange', {
-                        socketState: socketState,
-                        timeUntilReconnect: 0,
-                        deviceRegister: isDeviceRegister,
-                        serverRegister: isServerRegister,
-                        peerId: peerId
-                    });
+                    // socketState = socketStateType.CLOSED;
+                    //
+                    // fireEvent('stateChange', {
+                    //     socketState: socketState,
+                    //     timeUntilReconnect: 0,
+                    //     deviceRegister: isDeviceRegister,
+                    //     serverRegister: isServerRegister,
+                    //     peerId: peerId
+                    // });
 
                     fireEvent('disconnect', event);
 
                     if (reconnectOnClose) {
                         if (asyncLogging) {
                             if (workerId > 0) {
-                                Utility.asyncStepLogger(workerId + '\t Reconnecting after ' + retryStep + 's');
+                                Utility.asyncStepLogger(workerId + '\t Reconnecting after ' + retryStep.get() + 's');
                             }
                             else {
-                                Utility.asyncStepLogger('Reconnecting after ' + retryStep + 's');
+                                Utility.asyncStepLogger('Reconnecting after ' + retryStep.get() + 's');
                             }
                         }
 
                         socketState = socketStateType.CLOSED;
                         fireEvent('stateChange', {
                             socketState: socketState,
-                            timeUntilReconnect: 1000 * retryStep,
+                            timeUntilReconnect: 1000 * retryStep.get(),
                             deviceRegister: isDeviceRegister,
                             serverRegister: isServerRegister,
                             peerId: peerId
@@ -199,10 +225,11 @@
 
                         socketReconnectRetryInterval = setTimeout(function () {
                             socket.connect();
-                        }, 1000 * retryStep);
+                        }, 1000 * retryStep.get());
 
-                        if (retryStep < 64) {
-                            retryStep *= 2;
+                        if (retryStep.get() < 64) {
+                            // retryStep += 3;
+                            retryStep.set(retryStep.get() + 3)
                         }
 
                         // socketReconnectCheck && clearTimeout(socketReconnectCheck);
@@ -356,9 +383,12 @@
 
                 if (peerId !== undefined) {
                     content.refresh = true;
+                    content.renew = false;
+
                 }
                 else {
                     content.renew = true;
+                    content.refresh = false;
                 }
 
                 pushSendData({
@@ -689,7 +719,8 @@
             socket.close();
 
             socketReconnectRetryInterval = setTimeout(function () {
-                retryStep = 4;
+                // retryStep = 4;
+                retryStep.set(4);
                 socket.connect();
             }, 2000);
         };

package/src/network/socket.js

@@ -22,12 +22,53 @@
       eventCallback = {},
       socket,
       waitForSocketToConnectTimeoutId,
-      forceCloseSocket = false,
-      forceCloseSocketTimeout,
       socketRealTimeStatusInterval,
-      sendPingTimeout,
-      socketCloseTimeout,
-      forceCloseTimeout;
+      logLevel = params.logLevel,
+      pingController = new PingManager({waitTime: connectionCheckTimeout}),
+      socketWatchTimeout;
+
+
+    function PingManager(params) {
+      const config = {
+        normalWaitTime: params.waitTime,
+
+        lastRequestTimeoutId: null,
+        lastReceivedMessageTime: 0,
+        totalNoMessageCount: 0,
+        timeoutIds: {
+          first: null,
+          second: null,
+          third: null,
+          fourth: null
+        }
+      }
+
+      return {
+        resetPingLoop() {
+          this.stopPingLoop();
+          this.setPingTimeout();
+        },
+        setPingTimeout() {
+          config.timeoutIds.first = setTimeout(()=>{
+            ping();
+            config.timeoutIds.first = setTimeout(()=>{
+              ping();
+                config.timeoutIds.fourth = setTimeout(()=>{
+                  logLevel.debug && console.debug("[Async][Socket.js] Force closing socket.");
+                  onCloseHandler(null);
+                  socket.close();
+                }, 2000);
+            }, 2000);
+          }, 8000);
+        },
+        stopPingLoop(){
+          clearTimeout(config.timeoutIds.first);
+          clearTimeout(config.timeoutIds.second);
+          clearTimeout(config.timeoutIds.third);
+          clearTimeout(config.timeoutIds.fourth);
+        },
+      }
+    }
 
     /*******************************************************
      *            P R I V A T E   M E T H O D S            *
@@ -45,74 +86,57 @@
 
           socket = new WebSocket(address, []);
 
-          socketRealTimeStatusInterval && clearInterval(socketRealTimeStatusInterval);
-          socketRealTimeStatusInterval = setInterval(function() {
-            switch (socket.readyState) {
-              case 2:
-                onCloseHandler(null);
-                break;
-              case 3:
-                socketRealTimeStatusInterval && clearInterval(socketRealTimeStatusInterval);
-                break;
-            }
+          // socketRealTimeStatusInterval && clearInterval(socketRealTimeStatusInterval);
+          // socketRealTimeStatusInterval = setInterval(function() {
+          //   switch (socket.readyState) {
+          //     case 2:
+          //       onCloseHandler(null);
+          //       socketRealTimeStatusInterval && clearInterval(socketRealTimeStatusInterval);
+          //       break;
+          //     case 3:
+          //
+          //       break;
+          //   }
+          // }, 5000);
+
+          /**
+           * Watches the socket to make sure it's state changes to 1 in 5 seconds
+           */
+          socketWatchTimeout && clearTimeout(socketWatchTimeout);
+          socketWatchTimeout = setTimeout(() => {
+            // if(socket.readyState !== 1) {
+            logLevel.debug && console.debug("[Async][Socket.js] socketWatchTimeout triggered.");
+            onCloseHandler(null);
+            socket.close();
+            // }
           }, 5000);
 
           socket.onopen = function(event) {
             waitForSocketToConnect(function() {
+              pingController.resetPingLoop();
               eventCallback["open"]();
+              socketWatchTimeout && clearTimeout(socketWatchTimeout);
             });
           }
 
           socket.onmessage = function(event) {
+            pingController.resetPingLoop();
+
             var messageData = JSON.parse(event.data);
             eventCallback["message"](messageData);
-
-            /**
-             * To avoid manually closing socket's connection
-             */
-            forceCloseSocket = false;
-
-            socketCloseTimeout && clearTimeout(socketCloseTimeout);
-            forceCloseTimeout && clearTimeout(forceCloseTimeout);
-
-            socketCloseTimeout = setTimeout(function() {
-              /**
-               * If message's type is not 5, socket won't get any acknowledge packet,therefore
-               * you may think that connection has been closed and you would force socket
-               * to close, but before that you should make sure that connection is actually closed!
-               * for that, you must send a ping message and if that message don't get any
-               * responses too, you are allowed to manually kill socket connection.
-               */
-              ping();
-
-              /**
-               * We set forceCloseSocket as true so that if your ping's response don't make it
-               * you close your socket
-               */
-              forceCloseSocket = true;
-
-              /**
-               * If type of messages are not 5, you won't get ant ACK packets
-               * for that being said, we send a ping message to be sure of
-               * socket connection's state. The ping message should have an
-               * ACK, if not, you're allowed to close your socket after
-               * 4 * [connectionCheckTimeout] seconds
-               */
-              forceCloseTimeout = setTimeout(function() {
-                if (forceCloseSocket) {
-                  socket.close();
-                }
-              }, connectionCheckTimeout);
-
-            }, connectionCheckTimeout * 1.5);
           }
 
           socket.onclose = function(event) {
+            pingController.stopPingLoop();
+            logLevel.debug && console.debug("[Async][Socket.js] socket.onclose happened. EventData:", event);
             onCloseHandler(event);
+            socketWatchTimeout && clearTimeout(socketWatchTimeout);
           }
 
           socket.onerror = function(event) {
+            logLevel.debug && console.debug("[Async][Socket.js] socket.onerror happened. EventData:", event);
             eventCallback["error"](event);
+            socketWatchTimeout && clearTimeout(socketWatchTimeout);
           }
         } catch (error) {
           eventCallback["customError"]({
@@ -124,9 +148,7 @@
       },
 
       onCloseHandler = function(event) {
-        sendPingTimeout && clearTimeout(sendPingTimeout);
-        socketCloseTimeout && clearTimeout(socketCloseTimeout);
-        forceCloseTimeout && clearTimeout(forceCloseTimeout);
+        pingController.stopPingLoop();
         eventCallback["close"](event);
       },
 
@@ -161,11 +183,6 @@
           data.trackerId = params.trackerId;
         }
 
-        sendPingTimeout && clearTimeout(sendPingTimeout);
-        sendPingTimeout = setTimeout(function() {
-          ping();
-        }, connectionCheckTimeout);
-
         try {
           if (params.content) {
             data.content = JSON.stringify(params.content);
@@ -198,10 +215,9 @@
     }
 
     this.close = function() {
-      sendPingTimeout && clearTimeout(sendPingTimeout);
-      socketCloseTimeout && clearTimeout(socketCloseTimeout);
-      forceCloseTimeout && clearTimeout(forceCloseTimeout);
+      logLevel.debug && console.debug("[Async][Socket.js] Closing socket by call to this.close");
       socket.close();
+      socketWatchTimeout && clearTimeout(socketWatchTimeout);
     }
 
     init();

package/src/utility/logger.js

@@ -0,0 +1,34 @@
+function LogLevel(logLevel){
+    let ll = logLevel || 2;
+    switch (ll) {
+        case 1:
+            return {
+                error: true,
+                debug: false,
+                info: false,
+            }
+        case 2:
+            return {
+                error: true,
+                debug: true,
+                info: false,
+            }
+        case 3:
+            return {
+                error: true,
+                debug: true,
+                info: true,
+            }
+    }
+}
+
+
+if (typeof module !== 'undefined' && typeof module.exports != 'undefined') {
+    module.exports = LogLevel;
+}
+else {
+    if (!window.POD) {
+        window.POD = {};
+    }
+    window.POD.LogLevel = LogLevel;
+}