public void test_setReceiveBufferSizeI() throws Exception {
// now validate case where we try to set to 0
ServerSocket theSocket = new ServerSocket();
try {
theSocket.setReceiveBufferSize(0);
fail("No exception when receive buffer size set to 0");
} catch (IllegalArgumentException ex) {
}
theSocket.close();
// now validate case where we try to set to a negative value
theSocket = new ServerSocket();
try {
theSocket.setReceiveBufferSize(-1000);
fail("No exception when receive buffer size set to -1000");
} catch (IllegalArgumentException ex) {
}
theSocket.close();
// now just try to set a good value to make sure it is set and there
// are not exceptions
theSocket = new ServerSocket();
theSocket.setReceiveBufferSize(1000);
theSocket.close();
}
/** {@inheritDoc} */
@Override
public AsyncServerSocketChannelImpl setOption(SocketOption name, Object value)
throws IOException {
if (!(name instanceof StandardSocketOption)) {
throw new IllegalArgumentException("Unsupported option " + name);
}
if (value == null || !name.type().isAssignableFrom(value.getClass())) {
throw new IllegalArgumentException("Bad parameter for " + name);
}
StandardSocketOption stdOpt = (StandardSocketOption) name;
final ServerSocket socket = channel.socket();
try {
switch (stdOpt) {
case SO_RCVBUF:
socket.setReceiveBufferSize(((Integer) value).intValue());
break;
case SO_REUSEADDR:
socket.setReuseAddress(((Boolean) value).booleanValue());
break;
default:
throw new IllegalArgumentException("Unsupported option " + name);
}
} catch (SocketException e) {
if (socket.isClosed()) {
throw Util.initCause(new ClosedChannelException(), e);
}
throw e;
}
return this;
}
/**
* Constructor
*
* @param port port to listen on
* @param myDefaultListener default listener
* @throws IOException
*/
public TCPServer(int port, ConnectionEventListener myDefaultListener) throws IOException {
// Set the current thread's name to owner:tcp server
super(myDefaultListener.getClass().getSimpleName() + ":" + TCPServer.class.getSimpleName());
LOGGER.log(Level.INFO, "Creating TCP Server on port {0}", port);
this.myDefaultListener = myDefaultListener;
myPort = port;
myServerSocket = new ServerSocket(myPort);
myServerSocket.setReceiveBufferSize(BUFFER_SIZE);
myKeepAliveFlag = true;
}
void applyServerSocketParams(ServerSocket s, boolean reuseAddress) {
try {
s.setReuseAddress(reuseAddress);
} catch (SocketException e) {
logger.error("error setting recvBuffer to " + recvBuffer, e);
}
if (recvBuffer > 0) {
try {
s.setReceiveBufferSize(recvBuffer);
} catch (SocketException e) {
logger.error("error setting recvBuffer to " + recvBuffer, e);
}
}
}
/**
* init the Selector
*
* @param ctx
* @throws java.io.IOException
*/
private final void initSelector(Context ctx) throws IOException {
try {
isShutDown.set(false);
connectorInstanceHandler =
new ConnectorInstanceHandler.ConcurrentQueueDelegateCIH(
getConnectorInstanceHandlerDelegate());
// Create the socket listener
selector = Utils.openSelector();
if (role != Role.CLIENT) {
serverSocketChannel = ServerSocketChannel.open();
serverSocket = serverSocketChannel.socket();
if (receiveBufferSize > 0) {
try {
serverSocket.setReceiveBufferSize(receiveBufferSize);
} catch (SocketException se) {
if (logger.isLoggable(Level.FINE))
logger.log(Level.FINE, "setReceiveBufferSize exception ", se);
} catch (IllegalArgumentException iae) {
if (logger.isLoggable(Level.FINE))
logger.log(Level.FINE, "setReceiveBufferSize exception ", iae);
}
}
if (inet == null) {
portRange.bind(serverSocket, ssBackLog);
} else {
portRange.bind(serverSocket, inet, ssBackLog);
}
serverSocketChannel.configureBlocking(false);
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
serverSocket.setSoTimeout(serverTimeout);
// Ephemeral support
port = serverSocket.getLocalPort();
inet = serverSocket.getInetAddress();
}
ctx.getController().notifyReady();
} catch (SocketException ex) {
throw new BindException(ex.getMessage() + ": " + port + "=" + this);
}
}
@Override
public final void run() {
try {
final TcpPipe enclosing = TcpPipe.this;
Log.log("startup reciever endpoint for %s", enclosing);
ServerSocket server = new ServerSocket(0);
server.setPerformancePreferences(SO_CONNTIME_PREF, SO_LATENCY_PREF, SO_BANDWIDTH_PREF);
server.setReceiveBufferSize(SO_RCV_BUFF_SIZE);
int soport = server.getLocalPort();
Log.log("-- RCV endpoint server socket opened on port %d", soport);
if (!port_ref.compareAndSet(INIT_PORT, soport))
throw new IllegalStateException("portUpdater");
Log.log("-- RCV endpoint port set to %d", port_ref.get());
Log.log("-- RCV endpoint now accepting connection ..");
latch.countDown();
Socket socket = server.accept();
socket.setKeepAlive(true);
socket.setPerformancePreferences(SO_CONNTIME_PREF, SO_LATENCY_PREF, SO_BANDWIDTH_PREF);
socket.setTcpNoDelay(true);
socket.setSendBufferSize(SO_RCV_BUFF_SIZE);
SocketAddress remsoaddr = socket.getRemoteSocketAddress();
Log.log("-- RCV endpoint accepted connection from %s", remsoaddr);
if (!rcvsocket_ref.compareAndSet(null, socket))
throw new IllegalStateException("recvInUpdater");
} catch (IOException e) {
e.printStackTrace();
} finally {
Log.log("server endpoint established");
}
}
private static void initSocket(ServerSocket socket, Configuration conf) throws SocketException {
final int[] performancePreferences = conf.performancePreferences();
if (performancePreferences != null) {
int n = performancePreferences.length;
int connectionTime = 0;
int latency = 0;
int bandWidth = 0;
if (n > 2) {
connectionTime = performancePreferences[0];
latency = performancePreferences[1];
bandWidth = performancePreferences[2];
} else if (n > 1) {
connectionTime = performancePreferences[0];
latency = performancePreferences[1];
} else if (n > 0) connectionTime = performancePreferences[0];
socket.setPerformancePreferences(connectionTime, latency, bandWidth);
}
if (conf.reuseAddr()) socket.setReuseAddress(true);
final Integer recvBufSize = conf.recvBufSize();
if (recvBufSize != null) socket.setReceiveBufferSize(recvBufSize);
}
// Runnable IMPLEMENTATION /////////////////////////////////////////////////
public void run() {
synchronized (this) {
if (selectorthread != null)
throw new IllegalStateException(getClass().getName() + " can only be started once.");
selectorthread = Thread.currentThread();
if (isclosed.get()) {
return;
}
}
selectorthread.setName("WebsocketSelector" + selectorthread.getId());
try {
server = ServerSocketChannel.open();
server.configureBlocking(false);
ServerSocket socket = server.socket();
socket.setReceiveBufferSize(WebSocket.RCVBUF);
socket.bind(address);
selector = Selector.open();
server.register(selector, server.validOps());
} catch (IOException ex) {
handleFatal(null, ex);
return;
}
try {
while (!selectorthread.isInterrupted()) {
SelectionKey key = null;
WebSocketImpl conn = null;
try {
selector.select();
registerWrite();
Set<SelectionKey> keys = selector.selectedKeys();
Iterator<SelectionKey> i = keys.iterator();
while (i.hasNext()) {
key = i.next();
if (!key.isValid()) {
// Object o = key.attachment();
continue;
}
if (key.isAcceptable()) {
if (!onConnect(key)) {
key.cancel();
continue;
}
SocketChannel channel = server.accept();
channel.configureBlocking(false);
WebSocketImpl w = wsf.createWebSocket(this, drafts, channel.socket());
w.key = channel.register(selector, SelectionKey.OP_READ, w);
w.channel = wsf.wrapChannel(channel, w.key);
i.remove();
allocateBuffers(w);
continue;
}
if (key.isReadable()) {
conn = (WebSocketImpl) key.attachment();
ByteBuffer buf = takeBuffer();
try {
if (SocketChannelIOHelper.read(buf, conn, (ByteChannel) conn.channel)) {
conn.inQueue.put(buf);
queue(conn);
i.remove();
if (conn.channel instanceof WrappedByteChannel) {
if (((WrappedByteChannel) conn.channel).isNeedRead()) {
iqueue.add(conn);
}
}
} else {
pushBuffer(buf);
}
} catch (IOException e) {
pushBuffer(buf);
throw e;
} catch (RuntimeException e) {
pushBuffer(buf);
throw e;
}
}
if (key.isWritable()) {
conn = (WebSocketImpl) key.attachment();
if (SocketChannelIOHelper.batch(conn, (ByteChannel) conn.channel)) {
if (key.isValid()) key.interestOps(SelectionKey.OP_READ);
}
}
}
while (!iqueue.isEmpty()) {
conn = iqueue.remove(0);
WrappedByteChannel c = ((WrappedByteChannel) conn.channel);
ByteBuffer buf = takeBuffer();
try {
if (SocketChannelIOHelper.readMore(buf, conn, c)) iqueue.add(conn);
conn.inQueue.put(buf);
queue(conn);
} finally {
pushBuffer(buf);
}
}
} catch (CancelledKeyException e) {
// an other thread may cancel the key
} catch (IOException ex) {
if (key != null) key.cancel();
handleIOException(conn, ex);
} catch (InterruptedException e) {
return; // FIXME controlled shutdown
}
}
} catch (RuntimeException e) {
// should hopefully never occur
handleFatal(null, e);
}
}
public void setReceiveBufferSize(int size) throws SocketException {
serverSocket.setReceiveBufferSize(size);
}
// Runnable IMPLEMENTATION /////////////////////////////////////////////////
public void run() {
if (selectorthread != null)
throw new IllegalStateException(
"This instance of "
+ getClass().getSimpleName()
+ " can only be started once the same time.");
selectorthread = Thread.currentThread();
selectorthread.setName("WebsocketSelector" + selectorthread.getId());
try {
server = ServerSocketChannel.open();
server.configureBlocking(false);
ServerSocket socket = server.socket();
socket.setReceiveBufferSize(WebSocket.RCVBUF);
socket.bind(address);
selector = Selector.open();
server.register(selector, server.validOps());
} catch (IOException ex) {
onWebsocketError(null, ex);
return;
}
try {
while (!selectorthread.isInterrupted()) {
SelectionKey key = null;
WebSocketImpl conn = null;
try {
selector.select();
registerWrite();
Set<SelectionKey> keys = selector.selectedKeys();
Iterator<SelectionKey> i = keys.iterator();
while (i.hasNext()) {
key = i.next();
if (!key.isValid()) {
// Object o = key.attachment();
continue;
}
if (key.isAcceptable()) {
SocketChannel channel = server.accept();
channel.configureBlocking(false);
WebSocketImpl c = wsf.createWebSocket(this, drafts, channel.socket());
c.key = channel.register(selector, SelectionKey.OP_READ, c);
c.ioobject = wsf.wrapChannel(channel);
i.remove();
allocateBuffers(c);
continue;
}
if (key.isReadable()) {
conn = (WebSocketImpl) key.attachment();
ByteBuffer buf = takeBuffer();
try {
if (SocketChannelIOHelper.read(buf, conn, (ByteChannel) conn.ioobject)) {
conn.in.put(buf);
queue(conn);
i.remove();
} else {
pushBuffer(buf);
}
} catch (IOException e) {
pushBuffer(buf);
throw e;
} catch (RuntimeException e) {
pushBuffer(buf);
throw e;
}
}
if (key.isWritable()) {
conn = (WebSocketImpl) key.attachment();
if (SocketChannelIOHelper.batch(conn, (ByteChannel) conn.ioobject)) {
if (key.isValid())
key.channel().register(selector, SelectionKey.OP_READ, key.attachment());
}
}
}
} catch (CancelledKeyException e) {
// an other thread may cancel the key
} catch (IOException ex) {
if (key != null) key.cancel();
handleIOException(conn, ex);
} catch (InterruptedException e) {
return;
}
}
} catch (RuntimeException e) {
// should hopefully never occur
handleFatal(null, e);
}
}
@Signature(@Arg("size"))
public Memory setReceiveBufferSize(Environment env, Memory... args) throws SocketException {
socket.setReceiveBufferSize(args[0].toInteger());
return Memory.NULL;
}