How do I make a TCP connection between 2 servers if both can start the connection?

I have a defined number of servers that can locally process data in their own way. But after some time I want to synchronize some states that are common on each server. My idea was that establish a TCP connection from each server to开发者_Go百科 the other servers like a mesh network.

My problem is that in what order do I make the connections since there is no "master" server here, so that each server is responsible for creating there own connections to each server.

My idea was that make each server connect and if the server that is getting connected already has a connection to the connecting server, then just drop the connection.

But how do I handle the fact that 2 servers is trying to connect at the same time? Because then I get 2 TCP connections instead of 1.

Any ideas?

You will need to have a handshake protocol when you're connection to a server so you can verify whether it's ok to start sending/receiving data, otherwise you might end up with one of the endpoint connecting and start sending data immediately only to have the other end drop the connection.

For ensuring only one connection is up to a server,you just need something like this pseudocode:

remote_server = accept_connection()
lock mutex;
if(already_connected(remote_server)) {
  drop_connection(remote_server)
}
unlock mutex;

If your server isn't multithreaded you don't need any locks to guard you when you check whether you're already connected - as there won't be any "at the same time" issues.

You will also need to have a retry mechanism to connect to a server based on a small random grace period in the event the remote server closed the connection you just set up.

If the connection got closed, you wait a little while, check if you're already connected (maybe the other end set up a connection to you in the mean time) and try to connect again. This is to avoid the situation where both ends set up the connection at the same time but the other end closes it because of the above logic.

Just as an idea. Each server accept a connection, then find out that it has got two TCP connections between the same servers. Then one connection is chosen to be closed. The way to choose what connection to close you just need to implement. For example both servers should compare their names ( or their IP address or their UID) and connection initiated by the server whose name is less (or UID) should be closed.

While better solution implies making a separate "LoadBalancer" to which all your servers are connected here is the small suggestion to make sure that connections are not created simultaneously.

Your servers can start connections in different times by using

bool CreateConnection = (time() % i == 0)

if (CreateConnection){ ... }

where i is the ID of the particular server. and time() could be in seconds or fractions of a second, depending on your requerements.

This will guarantee that you never get two servers connecting at the same time to each other. If you do not have IDs for servers, you can use a random value.