update: add socket timeout

client/scripts/TCPConnection.as

@@ -21,6 +21,7 @@ public class TCPConnection
     private var pingTimeout:int = 10000;
     private var connecting:Boolean = false;
     private var userID:String;
+    private var instanceID:String;
 
     private var pingTimer:Timer;
     private var checkConnectionTimer:Timer;
@@ -41,7 +42,8 @@ public class TCPConnection
         socket.addEventListener(ProgressEvent.SOCKET_DATA, onData);
         socket.addEventListener(IOErrorEvent.IO_ERROR, onError);
         socket.addEventListener(Event.CLOSE, onClose);
-        socket.addEventListener(SecurityErrorEvent.SECURITY_ERROR, onSecurityError)
+        socket.addEventListener(SecurityErrorEvent.SECURITY_ERROR, onSecurityError);
+        instanceID = generateRandomString(32);
 
         pingTimer = new Timer(pingTimeout);
         pingTimer.addEventListener(TimerEvent.TIMER, sendPing);
@@ -100,17 +102,21 @@ public class TCPConnection
     {
         trace("Connected to the server");
         connecting = false;
-        sendMessage("login:" + userID)
+        sendMessage("login:" + userID + ":" + instanceID)
         RETRY_COUNT = 0; // Reset retry count
         pingTimer.start();
         PLEASEWAIT.Hide()
     }
 
     private function onData(event:ProgressEvent):void
     {
-        var jsonString:String = socket.readUTFBytes(socket.bytesAvailable);
-        var responseData:Object = JSON.decode(jsonString);
-        trace("Received data from the server: " + responseData.message);
+        var sameInstance:String = socket.readUTFBytes(socket.bytesAvailable);
+        if(sameInstance === "false") {
+            GLOBAL.ErrorMessage("Instance Error");
+            disconnect();
+        }
+
+        trace("Received data from the server: " + sameInstance);
     }
 
     private function onError(event:IOErrorEvent):void
@@ -150,7 +156,7 @@ public class TCPConnection
 
     private function sendPing(event:TimerEvent):void
     {
-        sendMessage("ping:" + userID)
+        sendMessage("ping:" + userID + ":" + instanceID)
     }
 
     private function sendMessage(message: String): void
@@ -174,5 +180,17 @@ public class TCPConnection
             connectToServer();
         }
     }
+
+    function generateRandomString(length:uint):String {
+        var chars:String = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+        var result:String = "";
+
+        for (var i:uint = 0; i < length; i++) {
+            var randomIndex:uint = Math.floor(Math.random() * chars.length);
+            result += chars.charAt(randomIndex);
+        }
+
+        return result;
+    }
 }
 }

server/src/socket-server.ts

@@ -1,23 +1,28 @@
 import * as net from "net";
 import { logging } from "./utils/logger";
 import { Socket } from "node:net";
-import { createClient, RedisClientType } from "redis";
-import { redisClient, setUserIDCache } from "./utils/redis";
+import { getUserIDCache, redisClient, setUserIDCache } from "./utils/redis";
 
 const policyFile = '<?xml version="1.0"?><cross-domain-policy><site-control permitted-cross-domain-policies="all" /><allow-access-from domain="*" to-ports="*" /></cross-domain-policy>';
 
+
+interface SocketData {
+    userID: string;
+    instanceID: string;
+}
+
 export const newSocketServer = (host: string, port: number) => {
 
-    const sockets: Map<Socket, string> = new Map<Socket, string>();
+    const sockets: Map<Socket, SocketData> = new Map<Socket, SocketData>();
     const server = net.createServer()
     server.listen(port, host, () => {
-        console.log(`TCP Server running on: ${host}:${port}`)
+        logging(`TCP Server running on: ${host}:${port}`)
     })
 
     server.on("connection", function (socket) {
         logging(`Socket connected: ${socket.remoteAddress}:${socket.remotePort}`)
 
-        sockets.set(socket, "");
+        sockets.set(socket, { userID: "", instanceID: "" });
         let requestData = '';
         socket.on("data", async (data) => {
             if (process.env.ENV === "local") {
@@ -31,15 +36,19 @@ export const newSocketServer = (host: string, port: number) => {
             }
 
             const message = data.toString();
-            if (message.includes("login")) {
-                const [action, id] = message.split(":");
-                sockets.set(socket, id)
-                await setUserIDCache(id)
-            }
-
-            if (message.includes("ping")) {
-                const [action, id] = message.split(":");
-                await setUserIDCache(id)
+            if (message.includes("login") || message.includes("ping")) {
+                const [action, id, instanceID] = message.split(":");
+                if (action === "login") {
+                    sockets.set(socket, { userID: id, instanceID: instanceID })
+                }
+                let sameInstance = await checkUserInstance(id, instanceID);
+                if (!sameInstance) {
+                    socket.write(sameInstance.toString())
+                    return;
+                } else {
+                    await setUserIDCache(id, instanceID)
+                    socket.write(sameInstance.toString())
+                }
             }
         })
 
@@ -52,5 +61,26 @@ export const newSocketServer = (host: string, port: number) => {
             sockets.delete(socket);
             logging(`Socket disconnected: ${socket.remoteAddress}:${socket.remotePort}`)
         })
+
+        socket.setTimeout(10000, async () => {
+            logging(`Socket timeout ${socket.remoteAddress}:${socket.remotePort} `)
+            const data = sockets.get(socket);
+            if (data) {
+                const sameInstance = await checkUserInstance(data.userID, data.instanceID);
+                if (sameInstance) {
+                    await redisClient.del(`bymr:user:${data.userID}`)
+                }
+            }
+        })
     })
+}
+
+const checkUserInstance = async (id: string, instanceID: string): Promise<boolean> => {
+    const uid = await getUserIDCache(id);
+    if (uid) {
+        if (uid === id || uid === instanceID) {
+            return true;
+        }
+    }
+    return false;
 }

server/src/utils/redis.ts

@@ -36,8 +36,8 @@ export const createRedisClient = async (): Promise<RedisClientType> => {
     return redisClient
 }
 
-export const setUserIDCache = async (id: string | number) => {
-    redisClient.set(`bymr:user:${id}`, id, {
+export const setUserIDCache = async (id: string | number, instanceID?: string)=> {
+    redisClient.set(`bymr:user:${id}`, instanceID || id, {
         EX: REDIS_USER_ID_TTL,
     }).catch((err) => {
         if (process.env.ENV === "local") {