@mixd-id/web-scaffold 0.1.240411094 → 0.1.240411095

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mixd-id/web-scaffold",
   "private": false,
-  "version": "0.1.240411094",
+  "version": "0.1.240411095",
   "scripts": {
     "dev": "vite serve",
     "build": "vite build",

package/src/utils/wss.js

@@ -72,8 +72,6 @@ class WSS extends EventEmitter2{
 
   _authFn = []
   _reqFn = []
-  _retryCount = 0
-
   _connectionId = 0
   _debugIds = {}
 
@@ -110,6 +108,7 @@ class WSS extends EventEmitter2{
 
     this._instance.on('connection', async (socket, req) => {
       socket.id = `${++this._connectionId}`
+      socket._retryCount = 0
 
       if(`${req.url}`.indexOf('debug-ws') > 0){
         this._debugIds[socket.id] = {}
@@ -167,7 +166,7 @@ class WSS extends EventEmitter2{
 
         if(pong){
           delete socket.pinging
-          this._retryCount = 0
+          socket._retryCount = 0
         }
         else if(ping){
           socket.send(await this.toBinaryData({ pong: 1 }, !!this._debugIds[socket.id]))
@@ -217,6 +216,9 @@ class WSS extends EventEmitter2{
         if(subscriber){
           subscriber.disconnect()
         }
+        if(this._debugIds[socket.id]){
+          delete this._debugIds[socket.id]
+        }
         this.emit('close', e, socket)
       });
 
@@ -230,46 +232,117 @@ class WSS extends EventEmitter2{
           await fn(token, socket)
         }
 
-        socket.isAuth = true
-        socket.send(await this.toBinaryData({ auth:true }, !!this._debugIds[socket.id]))
-
         subscriber = this._client.duplicate()
         await subscriber.connect()
+
+        socket.isAuth = true
+        socket.send(await this.toBinaryData({ auth:true }, !!this._debugIds[socket.id]))
       }
       catch(e){
         return socket.close(1002, (e.message ?? '').substring(0, 123));
       }
 
       if(this._opt.ping !== false){
+        let pingTimer
 
         const ping = async() => {
+          if(socket.readyState !== WebSocket.OPEN) return
+
           socket.send(await this.toBinaryData({ ping:1 }, !!this._debugIds[socket.id]))
           socket.pinging = true
 
-          setTimeout(() => {
+          pingTimer = setTimeout(() => {
             if(socket.pinging){
-              this._retryCount++
+              socket._retryCount++
 
-              if(this._retryCount > 10){
+              if(socket._retryCount > 10){
                 socket.close(1002, 'ping timeout')
                 if(subscriber){
                   subscriber.disconnect()
                 }
-                else{
-                  console.log('CLOSE SOCKET#2', token.substring(0, 10) + '...')
-                }
+              }
+              else{
+                pingTimer = setTimeout(ping, 3000)
               }
             }
             else{
-              setTimeout(ping, (Math.round(Math.random() * 10) % 5) * 5000)
+              pingTimer = setTimeout(ping, (Math.round(Math.random() * 10) % 5) * 5000)
             }
           }, 3000)
         }
-        setTimeout(ping, (Math.round(Math.random() * 10) % 5) * 5000)
+        pingTimer = setTimeout(ping, (Math.round(Math.random() * 10) % 5) * 5000)
+
+        socket.on('close', () => {
+          clearTimeout(pingTimer)
+        })
       }
     })
   }
 
+  stats(){
+    let authenticated = 0
+    this._instance.clients.forEach(socket => {
+      if(socket.isAuth) authenticated++
+    })
+
+    return {
+      pid: process.pid,
+      connections: this._instance.clients.size,
+      authenticated,
+      totalConnections: this._connectionId,
+      debugConnections: Object.keys(this._debugIds).length,
+    }
+  }
+
+  clusterStats(){
+    return new Promise((resolve) => {
+      const workers = {}
+      const timeout = setTimeout(() => resolve(this._aggregateStats(workers)), 3000)
+
+      process.on('message', (packet) => {
+        if(packet.type === 'process:msg' && packet.data?.type === 'wss:stats:response'){
+          workers[packet.data.pid] = packet.data.stats
+        }
+
+        const expected = parseInt(process.env.instances || '0', 10)
+        if(expected > 0 && Object.keys(workers).length >= expected){
+          clearTimeout(timeout)
+          resolve(this._aggregateStats(workers))
+        }
+      })
+
+      process.send({ type: 'process:msg', data: { type: 'wss:stats:request' } })
+
+      // Include own stats
+      workers[process.pid] = this.stats()
+    })
+  }
+
+  _aggregateStats(workers){
+    const pids = Object.keys(workers)
+    return {
+      workers: pids.length,
+      connections: pids.reduce((sum, pid) => sum + workers[pid].connections, 0),
+      authenticated: pids.reduce((sum, pid) => sum + workers[pid].authenticated, 0),
+      totalConnections: pids.reduce((sum, pid) => sum + workers[pid].totalConnections, 0),
+      debugConnections: pids.reduce((sum, pid) => sum + workers[pid].debugConnections, 0),
+      perWorker: workers,
+    }
+  }
+
+  initClusterStats(){
+    if(process.send){
+      process.on('message', (packet) => {
+        if(packet.type === 'process:msg' && packet.data?.type === 'wss:stats:request'){
+          process.send({
+            type: 'process:msg',
+            data: { type: 'wss:stats:response', pid: process.pid, stats: this.stats() }
+          })
+        }
+      })
+    }
+  }
+
   auth(fn){
     this._authFn.push(fn)
   }