How to get an instance of an existing server in Node.js?

Question

I'd like to get the number of connections of a few servers running on my local machine.

I've successfully used server.getConnections() on a server created via net.createServer(), however I don't know how to use it on an already started server.

I tried obtaining the server instance by connecting to it, using net.connect(). The connection is created successfully and I get a new net.Socket object, however my understanding is that I actually need a net.Server in order to use getConnections().

So my question is, how do I get a net.Server instance of an already running server?

Answer 1

I realize my question is an XY problem, so apologies to all who tried to answer it.

I suspect the answer to the literal question, "how do I get an instance of an existing server", is: "you can't".

I should have added more details to the question, especially what I was trying to achieve.

My application is a load balancer / reverse proxy server. Initially I was able to use getConnections() because I would start the proxy server and a few dummy servers from the same script. However I wanted to make the dummy servers and the proxy separate from each other, so even though I did have complete control over them, I needed to pretend that I didn't actually own the servers.

The solution I found to my specific case, in the end, was to keep a hash list of servers I can connect to (via the reverse proxy), and increment the connection counters every time I connect to a specific server:

let servers = [
  { port: 4000, connectionsCounter: 0 },
  { port: 5000, connectionsCounter: 0 },
  { port: 6000, connectionsCounter: 0 },
];

let myProxyServer = net.createServer((socket) => {
  // Open a connection to the first server in the list
  net.connect(servers[0].port, () => {

    // Once connected, increment the connections counter
    socket.on('connect', () => {
      servers[0].connectionsCounter++;
    });

    // When the connection ends, decrement the counter
    socket.on('close', () => {
      servers[0].connectionsCounter--;
    });
  });
});

I hope this will be helpful to someone.

Answer 2

Your application is a bit unclear.

Only the server socket can report how many connections it has. This is why if you create the net.Server you can access that information from it.

If you want to connect to an application and query the number of clients connected to it, the application that you connect to needs to provide that information to you when you ask. This is not information that the socket provides - the application itself has to provide that information.

If you are writing the application that created the net.Server, you can create another net.Server on a different port that you can then connect to and query it for information about the other clients on its other sockets.

If you are trying to generically find the number of connections to a particular application that has a socket, that application needs to be able to tell you, or, as @root mentioned, you need to ask the OS the application is running on. This function will be OS dependent and will likely require elevated privileges. But consider connecting to a socket on a router or IoT device: that application may not be running on any OS at all.

Answer 3

you can make instance of net.createServer() and then get your number of connections from server.on('connection', <callback>):

server.on('connection', (socket) => {
    // someone connected
    console.log("New active connection");
    server.getConnections((err, count) => {
        if(err){
            console.log(err);
        } else {
            console.log("Currently " + count + " active connection(s)");
        }
    });
});

i hope this complete example code help you:

const net = require('net');
const uuid = require('uuid/v1');

const server = net.createServer((socket) => {

    socket.uuid = uuid();

    socket.on('data', (data) => {
        //const response = JSON.parse(data.toString('utf8'));
    });

    socket.on('error', (err) => {
        console.log('A client has left abruptly !');
        server.getConnections((err, count) => {
            if(err){
                console.log(err);
            } else {
                console.log("Currently " + count + " active connection(s)");
            }
        });
    });

    socket.on('end', () => {
        console.log("A client has left");
        server.getConnections((err, count) => {
            if(err){
                console.log(err);
            } else {
                console.log("Currently " + count + " active connection(s)");
            }
        });
    });
});

server.on('error', (err) => {
  // handle errors here
  console.log("Error:", err);
});


server.on('connection', (socket) => {
    // someone connected
    console.log("New active connection");
    server.getConnections((err, count) => {
        if(err){
            console.log(err);
        } else {
            console.log("Currently " + count + " active connection(s)");
        }
    });
});

// port number.
server.listen(3000, () => {
  console.log('opened server on', server.address());
});

or you can use netstat for get number of connection, https://www.npmjs.com/package/node-netstat nodejs module for this solution:

const netstat = require('node-netstat');

myObject = {
    protocol: 'tcp',
};

setInterval(function () {
    let count = 0;

    netstat({
        filter: {
            local: {port: 3000, address: '192.168.1.1'}
        }
    }, item => {
        // console.log(item);
        count++;
        console.log(count);
    });
}, 1000);

Answer 4

If you want to just use the server, you can probably store it as a variable when you call net.createServer()

const my_server = net.createServer();
// do what you want with it

my_server.getConnections();
my_server.listen();