| Methods Summary |
|---|
| java.net.Socket | acceptSocket()
if( !running || serverSocket==null ) return null;
Socket accepted = null;
try {
if(factory==null) {
accepted = serverSocket.accept();
} else {
accepted = factory.acceptSocket(serverSocket);
}
if (null == accepted) {
log.warn("Null socket returned by accept");
} else {
if (!running) {
accepted.close(); // rude, but unlikely!
accepted = null;
} else if (factory != null) {
factory.initSocket( accepted );
}
}
}
catch(InterruptedIOException iioe) {
// normal part -- should happen regularly so
// that the endpoint can release if the server
// is shutdown.
}
catch (AccessControlException ace) {
// When using the Java SecurityManager this exception
// can be thrown if you are restricting access to the
// socket with SocketPermission's.
// Log the unauthorized access and continue
String msg = sm.getString("endpoint.warn.security",
serverSocket,ace);
log.warn(msg);
}
catch (IOException e) {
String msg = null;
if (running) {
msg = sm.getString("endpoint.err.nonfatal",
serverSocket, e);
log.error(msg, e);
}
if (accepted != null) {
try {
accepted.close();
} catch(Throwable ex) {
msg = sm.getString("endpoint.err.nonfatal",
accepted, ex);
log.warn(msg, ex);
}
accepted = null;
}
if( ! running ) return null;
reinitializing = true;
// Restart endpoint when getting an IOException during accept
synchronized (threadSync) {
if (reinitializing) {
reinitializing = false;
// 1) Attempt to close server socket
closeServerSocket();
initialized = false;
// 2) Reinit endpoint (recreate server socket)
try {
msg = sm.getString("endpoint.warn.reinit");
log.warn(msg);
initEndpoint();
} catch (Throwable t) {
msg = sm.getString("endpoint.err.nonfatal",
serverSocket, t);
log.error(msg, t);
}
// 3) If failed, attempt to restart endpoint
if (!initialized) {
msg = sm.getString("endpoint.warn.restart");
log.warn(msg);
try {
stopEndpoint();
initEndpoint();
startEndpoint();
} catch (Throwable t) {
msg = sm.getString("endpoint.err.fatal",
serverSocket, t);
log.error(msg, t);
} finally {
// Current thread is now invalid: kill it
throw new ThreadDeath();
}
}
}
}
}
return accepted;
|
| protected void | closeServerSocket()
Socket s = null;
try {
// Need to create a connection to unlock the accept();
if (inet == null) {
s=new Socket("127.0.0.1", port );
}else{
s=new Socket(inet, port );
// setting soLinger to a small value will help shutdown the
// connection quicker
s.setSoLinger(true, 0);
}
} catch(Exception e) {
log.error("Caught exception trying to unlock accept on " + port
+ " " + e.toString());
} finally {
if (s != null) {
try {
s.close();
} catch (Exception e) {
// Ignore
}
}
}
try {
if( serverSocket!=null)
serverSocket.close();
} catch(Exception e) {
log.error("Caught exception trying to close socket.", e);
}
serverSocket = null;
|
| public java.net.InetAddress | getAddress()
return inet;
|
| public int | getBacklog()
return backlog;
|
| public TcpConnectionHandler | getConnectionHandler()
return handler;
|
| public int | getMaxSpareThreads()
return tp.getMaxSpareThreads();
|
| public int | getMaxThreads()
return tp.getMaxThreads();
|
| public int | getMinSpareThreads()
return tp.getMinSpareThreads();
|
| public int | getPort()
return port;
|
| public int | getServerSoTimeout()
return serverTimeout;
|
| ServerSocketFactory | getServerSocketFactory()
return factory;
|
| public int | getSoLinger()
return linger;
|
| public int | getSoTimeout()
return socketTimeout;
|
| public boolean | getTcpNoDelay()
return tcpNoDelay;
|
| public void | initEndpoint()
try {
if(factory==null)
factory=ServerSocketFactory.getDefault();
if(serverSocket==null) {
try {
if (inet == null) {
serverSocket = factory.createSocket(port, backlog);
} else {
serverSocket = factory.createSocket(port, backlog, inet);
}
} catch ( BindException be ) {
throw new BindException(be.getMessage() + ":" + port);
}
}
if( serverTimeout >= 0 )
serverSocket.setSoTimeout( serverTimeout );
} catch( IOException ex ) {
// log("couldn't start endpoint", ex, Logger.DEBUG);
throw ex;
} catch( InstantiationException ex1 ) {
// log("couldn't start endpoint", ex1, Logger.DEBUG);
throw ex1;
}
initialized = true;
|
| public boolean | isPoolOn()
return isPool;
|
| public boolean | isRunning()
return running;
|
| public void | log(java.lang.String msg)
log.info(msg);
|
| public void | log(java.lang.String msg, java.lang.Throwable t)
log.error( msg, t );
|
| public void | log(java.lang.String msg, int level)
log.info( msg );
|
| public void | log(java.lang.String msg, java.lang.Throwable t, int level)
log.error( msg, t );
|
| public void | setAddress(java.net.InetAddress inet)
this.inet=inet;
|
| public void | setBacklog(int backlog)Allows the server developer to specify the backlog that
should be used for server sockets. By default, this value
is 100.
if( backlog>0)
this.backlog = backlog;
|
| public void | setConnectionHandler(TcpConnectionHandler handler)
this.handler=handler;
|
| public void | setMaxSpareThreads(int maxThreads)
if(maxThreads > 0)
tp.setMaxSpareThreads(maxThreads);
|
| public void | setMaxThreads(int maxThreads)
if( maxThreads > 0)
tp.setMaxThreads(maxThreads);
|
| public void | setMinSpareThreads(int minThreads)
if(minThreads > 0)
tp.setMinSpareThreads(minThreads);
|
| public void | setPoolOn(boolean isPool)
this.isPool = isPool;
|
| public void | setPort(int port)
this.port=port;
|
| public void | setServerSoTimeout(int i)
serverTimeout=i;
|
| public void | setServerSocket(java.net.ServerSocket ss)
serverSocket = ss;
|
| public void | setServerSocketFactory(ServerSocketFactory factory)
this.factory=factory;
|
| public void | setServerTimeout(int timeout)Sets the timeout in ms of the server sockets created by this
server. This method allows the developer to make servers
more or less responsive to having their server sockets
shut down.
By default this value is 1000ms.
this.serverTimeout = timeout;
|
| public void | setSoLinger(int i)
linger=i;
|
| public void | setSoTimeout(int i)
socketTimeout=i;
|
| void | setSocketOptions(java.net.Socket socket)
if(linger >= 0 )
socket.setSoLinger( true, linger);
if( tcpNoDelay )
socket.setTcpNoDelay(tcpNoDelay);
if( socketTimeout > 0 )
socket.setSoTimeout( socketTimeout );
|
| public void | setTcpNoDelay(boolean b)
tcpNoDelay=b;
|
| public void | startEndpoint()
if (!initialized) {
initEndpoint();
}
if(isPool) {
tp.start();
}
running = true;
if(isPool) {
listener = new TcpWorkerThread(this);
tp.runIt(listener);
} else {
log.error("XXX Error - need pool !");
}
|
| public void | stopEndpoint()
if (running) {
tp.shutdown();
running = false;
if (serverSocket != null) {
closeServerSocket();
}
}
|
