{
// if (bailOut)
// return null;
semaphore.release();
if (trace) log.trace(this + " released semaphore: " + semaphore.permits(), e);
sockEx = new CannotConnectException(
"Can not get connection to server. Problem establishing " +
"socket connection for " + locator, e);
continue;
}
if (tempTimeout >= 0)
{
timeLeft = (int) (tempTimeout - (System.currentTimeMillis() - start));
if (timeLeft <= 0)
break;
savedTimeout = socketWrapper.getTimeout();
socketWrapper.setTimeout(timeLeft);
}
try
{
int version = getVersion();
boolean performVersioning = Version.performVersioning(version);
OutputStream outputStream = socketWrapper.getOutputStream();
if (performVersioning)
{
writeVersion(outputStream, version);
}
//TODO: -TME so this is messed up as now ties remoting versioning to using a marshaller type
versionedWrite(outputStream, marshaller, invocation, version);
if (serverSideOneway)
{
if(trace) { log.trace(this + " sent oneway invocation, so not waiting for response, returning null"); }
}
else if (oneway)
{
if (performVersioning && useOnewayConnectionTimeout)
{
int onewaySavedTimeout = socketWrapper.getTimeout();
socketWrapper.setTimeout(onewayConnectionTimeout);
InputStream inputStream = socketWrapper.getInputStream();
version = readVersion(inputStream);
if (version == -1)
{
throw new EOFException("end of file");
}
if (version == SocketWrapper.CLOSING)
{
log.trace(this + " received version 254: treating as end of file");
throw new EOFException("end of file");
}
// Note that if an exception is thrown, the socket is thrown away,
// so there's no need to reset the timeout value.
socketWrapper.setTimeout(onewaySavedTimeout);
}
}
else
{
InputStream inputStream = socketWrapper.getInputStream();
if (performVersioning)
{
version = readVersion(inputStream);
if (version == -1)
{
throw new EOFException("end of file");
}
if (version == SocketWrapper.CLOSING)
{
log.trace(this + " received version 254: treating as end of file");
throw new EOFException("end of file");
}
}
response = versionedRead(inputStream, unmarshaller, version);
}
// Note that resetting the timeout value after closing the socket results
// in an exception, so the reset is not done in a finally clause. However,
// if a catch clause is ever added that does not close the socket, care
// must be taken to reset the timeout in that case.
if (tempTimeout >= 0)
{
socketWrapper.setTimeout(savedTimeout);
}
}
catch (SocketException sex)
{
handleRetriableException(socketWrapper, sex, retryCount);
sockEx = sex;
continue;
}
catch (EOFException ex)
{
handleRetriableException(socketWrapper, ex, retryCount);
sockEx = ex;
continue;
}
catch (Exception ex)
{
log.debug(this + " got exception: " + socketWrapper, ex);
try
{
semaphore.release();
if (trace) log.trace(this + " released semaphore: " + semaphore.permits());
socketWrapper.close();
}
catch (Exception ignored)
{
}
if (oneway)
return null;
else
return handleException(ex, socketWrapper);
}
// call worked, so no need to retry
break;
}
// need to check if ran out of retries
if (retryCount >= numberOfCallRetries)
{
handleException(sockEx, socketWrapper);
}
if (response == null && tempTimeout > 0 && timeLeft <= 0)
{
if (sockEx == null)
{
sockEx = new CannotConnectException(
"Can not get connection to server. Timed out establishing " +
"socket connection for " + locator);
}
handleException(sockEx, socketWrapper);
}