How to make client socket wait for server socket

Question

If client socket opens before the server socket, Java will generate a ConnectionException. So I have to check whether the server is available and keep waiting before executing

socketChannel.open(hostname, port)

in client thread. I've found an related API:

InetAddress.getByName(hostname).isReachable()

However, this still can't tell whether the socket on a specific port is open. I think this problem should be common but I didn't get very useful information from Google and other places.

Answer 1

boolean scanning=true;
while(scanning) {
    try {
        socketChannel.open(hostname, port);
        scanning=false;
    } catch(ConnectionException e) {
        System.out.println("Connect failed, waiting and trying again");
        try {
            Thread.sleep(2000);//2 seconds
        } catch(InterruptedException ie){
            ie.printStackTrace();
        }
    } 
}

This is the code for sonics comment

Answer 2

I Will give this kind of handler for your client, I am using it in my little game.

It will also give up after few times.

private static int MAX_CONNECTION = 10;
private int reconnections = 0;

public void connect() {

            try {
                    this.socket = new Socket();
                    InetSocketAddress sa = new InetSocketAddress(this.server, this.port);
                    this.socket.connect(sa,500);
                    this.connected = true;

                    this.in = new InputStreamReader(this.socket.getInputStream());
                    this.out = new OutputStreamWriter(this.socket.getOutputStream());
            } catch (ConnectException e) {
                    System.out.println("Error while connecting. " + e.getMessage());
                    this.tryToReconnect();
            } catch (SocketTimeoutException e) {
                    System.out.println("Connection: " + e.getMessage() + ".");
                    this.tryToReconnect();
            } catch (IOException e) {
                    e.printStackTrace();
            }

    }
private void tryToReconnect() {
            this.disconnect();

            System.out.println("I will try to reconnect in 10 seconds... (" + this.reconnections + "/10)");
            try {
                    Thread.sleep(10000); //milliseconds
            } catch (InterruptedException e) {
            }

            if (this.reconnections < MAX_RECONNECTIONS) {
                    this.reconnections++;
                    this.connect();

            } else {
                    System.out.println("Reconnection failed, exeeded max reconnection tries. Shutting down.");
                    this.disconnect();
                    System.exit(0);
                    return;
            }

    }

Here is the explanation of the code:

private static final int MAX_CONNECTION = 10;
private int reconnections = 0;

First I declare two vars, one is fixed and cannot be changed at runtime, it's the maximum number of attempt I want the client to do before shutting down. The second is the current reconnection attempt.

public method connect() is used to connect the socket. I will skip to the exception handling:

} catch (ConnectException e) {
    System.out.println("Error while connecting. " + e.getMessage());
    this.tryToReconnect();
} catch (SocketTimeoutException e) {
    System.out.println("Connection: " + e.getMessage() + ".");
    this.tryToReconnect();
}

When a connection exception is thrown the catcher call the reconnection method.

The reconnection method wait 10 second between each attempt and is called each time by connect() if this fail.

If the connection is established connect() will not call tryToReconnect() again. If is impossible to connect within 100 seconds 10 attempts one every 10 second, the program exit.

Answer 3

I came to this convo in search of an answer, then I made a "how about this way" comment. Now, it seems fair and community minded to share my own answer, copy & pasted unchanged from my own working (green unit tested) code:

private void makeSocketWithRetries(long maxWaitMS) throws IOException {
    Stopwatch retryWatch = new Stopwatch().reset();
    final long retryWaitMS = 500;

    do {
        try {
            socket = new Socket(host, port);
        }
        catch (ConnectException e) {
            logger.info("failed to connect tp [" + host + ":" + port + "]: retrying in " + retryWaitMS + "(ms)");
            try {
                Thread.sleep(retryWaitMS);
            } catch (InterruptedException interruptedException) {
                // swallow this exception
            }
        }
    }
    while ((socket == null) && (retryWatch.mark().deltaMS() <= maxWaitMS));

    if (socket == null) {
        String msg = "failed to connect tp [" + host + ":" + port + "] total wait time exceeded: " + retryWatch.deltaMS() + "(ms)";
        logger.info(msg);
        throw new ConnectException(msg);
    }
}

That being "said," here are a few notes:

1. The logging is a bit much, but it shows what's going on. Trace logging makes more sense for the retries and maybe also for the "time exceeded" exception. Or just trash the logging altogether.
2. retryWait should be a class constant (or a parameter with validations / range caps / log.warning if very large / etc.) At least it's a local final #8-)__
3. My Stopwatch utility class is not shown, but it should be hopfefully is self-evident.
4. No parameter checking, although a negative maxWaitMS wait will still make at least a single attempt.

ALSO, I don't count (nor limit) the number of retries. As per my comment to @Cruncher's solution, I don't believe it's generally a helpful feature.