CODEWITHSUNDEEP
node.jssockets
Salah Eddine Bentayeb
Salah Eddine Bentayeb

Reputation: 754

Persiste NodeJS Sockets

Hello community, Since the morning I am faced with an idea not to say a problem I want to store clients (sockets) in order to re-invoke them later, I know that it is not too clear I will explain in detail:

First I have a server interface (ServerSocket) net.Server() which will receive clients (sockets) net.Socket() and this one will be stored in a Map() with a unique ID for each client, and each time I want to communicate with one of them I call map.get(id).write ... or other function,

Everything works fine until I close the server, automatically the sockets will be killed ... saying that I have found a solution to store the clients for my case (vuex) or localStorage to simplify what I want is when I restart the server and I invoke one of the client it will always be active. So my main questions:

 var net = require("net");
 var server = new net.Server();
 var sockets = new Map();
    
    /**
     * This events is called when server is successfully listened.
     */
    server.on("listening", () => {
      console.log("Server Listen in port 4444");
    });
    
    /**
     * This events is called when error occur in server
     */
    server.on("error", (e) => {
      if (e.code === "EADDRINUSE") {
        console.log("Address in use, retrying...");
      }
    });
    
    /**
     * This events is called when a new client is connected to server.
     */
    server.on("connection", (socket) => {
      var alreadyExist = false;
      sockets.forEach((soc) => {
        if (soc.remoteAddress === socket.remoteAddress) {
          alreadyExist = true;
        }
      });
      if (alreadyExist) {
        socket.end();
      } else {
        socket.setKeepAlive(true, Infinity);
        socket.setDefaultEncoding("utf8");
        socket.id = nanoid(10);
        sockets.set(socket.id, socket);
    
        socket.on("error", (e) => {
          console.log(e);
          if (e.code === "ECONNRESET") {
            console.log("Socket end shell with CTRL+C");
            console.log("DEL[ERROR]: " + socket.id);
          }
        });
    
        socket.on("close", () => {
          console.log("DEL[CLOSE]: " + socket.id);
        });
    
        socket.on("end", () => {
          console.log("DEL[END]: " + socket.id);
        });
    
        socket.on("timeout", () => {
          console.log("timeout !");
        });
    
        var child = sockets.get(res.id);
        child.write(/* HERE I SEND COMMAND NOT IMPORTANT ! */);
    
        socket.on("data", (data) => {
          console.log("Received data from socket " + data);
        });
      }
    });

Upvotes: 0

Views: 43

Answers (1)

jfriend00
jfriend00

Reputation: 707986

How can I keep clients still active after the server is closed?

A client can't maintain a connection to a server that is not running. The client is free to do whatever it wants on its own when the server shuts down, but it cannot maintain a connection to that server that is down. The whole definition of a "connection" is between two live endpoints.

How can I Store sockets and check if they are active after restarting server?

You can't store sockets when the server goes down. A socket is an OS representation of a live connection, TCP state, etc... When the server goes down and then restarts, that previous socket is gone. If it wasn't closed by the server before it shut-down, then it was cleaned up by the OS when the server process closed. It's gone.

I would make a suggestion that you're asking for the wrong thing here. Sockets don't outlive their process and don't stay alive when one end of the connection goes down.

Instead, the usual architecture for this is automatic reconnection. When the client gets notified that the server is no longer there, the client attempts to reconnect on some time interval. When, at some future time, the server starts up again, the client can then connect back to it and re-establish the connection.

If part of your connection initiation is an exchange of some sort of clientID, then a client can reconnect, present it's identifier and the server can know exactly which client it is and things can then continue as before with a new socket connection, but everything else proceeding as if the previous socket connection shut-down never happened. You just rebuild your Map object on the server as the clients reconnect.

For scalability reasons, your clients would generally implement some sort of back-off (often with some random jitter added) so that when your server comes back online, it doesn't get immediately hammered by hundreds of clients all trying to connect at the exact same moment.

Upvotes: 1

Related Questions