A very confusing problem about sending message to an irreachable IP

[billdavidcn]

I find a very confusing problem during testing my application:
I will send some notification message to a URL provided by user in my
web service. If user has provided a right URL (with an IP in using and
a right port and context), everything goes well. But if user has
provided an IP that is not reachable, the waiting time may be very long
(40 ~ 300 seconds). Especially when the IP is of the same subnet but
not in use, the waiting time may be more than 5 minutes.

To shorten the waiting time, I have added the following code to check
if the URL is accessible before sending notification:

int REQUEST_TIMEOUT = 15000; // 15 seconds

// Check if url is accessible or not
URL url = new URL(endPoint);
HttpURLConnection connection = (HttpURLConnection)
url.openConnection();

connection.setConnectTimeout(REQUEST_TIMEOUT);
connection.setReadTimeout(REQUEST_TIMEOUT);
connection.connect();
connection.disconnect();

But the result is not very good, we still need wait 40~70 seconds to
get the socket connection failed exception.

Is there any method to check if a URL is accessible in a shorter time?

 

[bjeremy]

I find a very confusing problem during testing my application:
I will send some notification message to a URL provided by user in my
web service. If user has provided a right URL (with an IP in using and
a right port and context), everything goes well. But if user has
provided an IP that is not reachable, the waiting time may be very long
(40 ~ 300 seconds). Especially when the IP is of the same subnet but
not in use, the waiting time may be more than 5 minutes.

To shorten the waiting time, I have added the following code to check
if the URL is accessible before sending notification:

int REQUEST_TIMEOUT = 15000; // 15 seconds

// Check if url is accessible or not
URL url = new URL(endPoint);
HttpURLConnection connection = (HttpURLConnection)
url.openConnection();

connection.setConnectTimeout(REQUEST_TIMEOUT);
connection.setReadTimeout(REQUEST_TIMEOUT);
connection.connect();
connection.disconnect();

But the result is not very good, we still need wait 40~70 seconds to
get the socket connection failed exception.

Is there any method to check if a URL is accessible in a shorter time?

This is off topic and has little to do with JAVA.. but I'll throw you a
bone. A TCP connecntion establishment sequence consists of a three-way
handshake between the client and server. The client will send a SYN,
the Server will respond with a SYN-ACK , and the Client will end the
handshake with and ACK of the server's syn/ack. The connection goes
into established state and data can pass.

Now, if the client misses the SYN/ACK from the server, it will go into
an exponential backoff-paced retranmission mode. Meaning it will
re-tranmit the SYN in exponential time until it either receives a
SYN-ACK from the server or the connection establishment timer expires,
This can be a long time. (The retransmit time is usually derived from
the round trip time between the packets of the TCP handshake... but in
your case, since only the SYN goes out, it is some default time)

So, for you to change anything, you would need to change your TCP stack
implementation, probably the connection establishment timer. but
actually 40 to 70 seconds for this isn't really all that bad..

However... and this actually is pertinent to this newsgroup. Java has a
non-blocking i/o socket API... So instead of Streams, You use
channels.If you are familiar with Select and Poll it is basically JAVAs
library to implement select on sockets, so instead of an Indiviual
thread per connection (which is a resource hog), you can multiplex on
your connections.You can use this library, java.nio, so that your
connection establishments do not block and you can do other processing
while you wait.. or you could just wait for the connection for a length
of time and then kill the connection yourself.

// Create client SocketChannel
SocketChannel client = SocketChannel.open();

// nonblocking I/O
client.configureBlocking(false);

// Connection to host port 80
client.connect(new InetSocketAddress(host,80));

// Create selector
Selector selector = Selector.open();

// Record to selector (OP_CONNECT type) you are interested in when the
// socket connect
SelectionKey clientKey = client.register(selector,
SelectionKey.OP_CONNECT);

// Waiting for the connection for 1000 ms (1 second)... after 1 second
the select times out
// You can loop through this any number of times you want, and break
out of here
// after a suitable number of iterations.. for example... if we only go
through 5 iterations, we
// will end up waiting 5 seconds for connection establishment

while (selector.select(1000)> 0) {

// Get keys
Set keys = selector.selectedKeys();
Iterator i = keys.iterator();

// For each key...
while (i.hasNext()) {
SelectionKey key = (SelectionKey)i.next();

// Remove the current key
i.remove();

// Get the socket channel held by the key
SocketChannel channel = (SocketChannel)key.channel();

// Attempt a connection
if (key.isConnectable()) {

// Connection OK
System.out.println("Server Found");

// Close pendent connections
if (channel.isConnectionPending())
channel.finishConnect();

// do whatever you want to do
}
}
}