static void test() throws Exception {
ServerSocketChannel ssc = null;
SocketChannel sc = null;
SocketChannel peer = null;
try {
ssc = ServerSocketChannel.open().bind(new InetSocketAddress(0));
// loopback connection
InetAddress lh = InetAddress.getLocalHost();
sc = SocketChannel.open(new InetSocketAddress(lh, ssc.socket().getLocalPort()));
peer = ssc.accept();
// peer sends message so that "sc" will be readable
int n = peer.write(ByteBuffer.wrap("Hello".getBytes()));
assert n > 0;
sc.configureBlocking(false);
Selector selector = Selector.open();
SelectionKey key = sc.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE);
boolean done = false;
int failCount = 0;
while (!done) {
int nSelected = selector.select();
if (nSelected > 0) {
if (nSelected > 1) throw new RuntimeException("More than one channel selected");
Set<SelectionKey> keys = selector.selectedKeys();
Iterator<SelectionKey> iterator = keys.iterator();
while (iterator.hasNext()) {
key = iterator.next();
iterator.remove();
if (key.isWritable()) {
failCount++;
if (failCount > 10) throw new RuntimeException("Test failed");
Thread.sleep(250);
}
if (key.isReadable()) {
done = true;
}
}
}
}
} finally {
if (peer != null) peer.close();
if (sc != null) sc.close();
if (ssc != null) ssc.close();
}
}
private void writeMessage(SocketEntry entry, SocketChannel sc) throws IOException {
byte[] message = entry.nextMessage();
if (message != null) {
ByteBuffer buffer = ByteBuffer.wrap(message);
sc.write(buffer);
if (logger.isDebugEnabled()) {
logger.debug(
"Send message with length "
+ message.length
+ " to "
+ entry.getPeerAddress()
+ ": "
+ new OctetString(message).toHexString());
}
sc.register(selector, SelectionKey.OP_READ);
}
}
public void run() {
try {
SocketChannel sc = SocketChannel.open();
InetSocketAddress sinaAddr = new InetSocketAddress("sina.com", 80);
sc.socket().connect(sinaAddr);
// init a selector via helper class selector provider
Selector aSel = SelectorProvider.provider().openSelector();
Socket soc = new Socket("host", 80);
soc.getChannel().register(aSel, SelectionKey.OP_ACCEPT);
// init a channel for server socket. method 1
ServerSocketChannel ssc = ServerSocketChannel.open();
ssc.configureBlocking(true);
// method 2, get server socket first, then init its channel
ServerSocket ss = new ServerSocket();
ServerSocketChannel ssc2 = ss.getChannel();
// set socket channel as non blocking.
ssc.configureBlocking(false);
InetSocketAddress isa = new InetSocketAddress("localhost", 9999);
ssc.socket().bind(isa);
SelectionKey acceptKey = ssc.register(aSel, SelectionKey.OP_ACCEPT);
int keysAdded = 0;
while ((keysAdded = aSel.select()) > 0) {
Set readyKeys = aSel.selectedKeys();
Iterator i = readyKeys.iterator();
while (i.hasNext()) {
SelectionKey sk = (SelectionKey) i.next();
i.remove();
ServerSocketChannel n = (ServerSocketChannel) sk.channel();
// now we got a new socket and its channel after accept in server
Socket s = n.accept().socket();
SocketChannel socketChannel = s.getChannel();
socketChannel.register(aSel, SelectionKey.OP_READ);
}
}
} catch (Exception e) {
}
}
private void go() throws IOException {
// Create a new selector
Selector selector = Selector.open();
// Open a listener on each port, and register each one
// with the selector
for (int i = 0; i < ports.length; ++i) {
ServerSocketChannel ssc = ServerSocketChannel.open();
ssc.configureBlocking(false);
ServerSocket ss = ssc.socket();
InetSocketAddress address = new InetSocketAddress(ports[i]);
ss.bind(address);
SelectionKey key = ssc.register(selector, SelectionKey.OP_ACCEPT);
System.out.println("Going to listen on " + ports[i]);
}
while (true) {
int num = selector.select();
Set selectedKeys = selector.selectedKeys();
Iterator it = selectedKeys.iterator();
while (it.hasNext()) {
SelectionKey key = (SelectionKey) it.next();
if ((key.readyOps() & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT) {
// Accept the new connection
ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
SocketChannel sc = ssc.accept();
sc.configureBlocking(false);
// Add the new connection to the selector
SelectionKey newKey = sc.register(selector, SelectionKey.OP_READ);
it.remove();
System.out.println("Got connection from " + sc);
} else if ((key.readyOps() & SelectionKey.OP_READ) == SelectionKey.OP_READ) {
// Read the data
SocketChannel sc = (SocketChannel) key.channel();
// Echo data
int bytesEchoed = 0;
while (true) {
echoBuffer.clear();
int r = sc.read(echoBuffer);
if (r <= 0) {
break;
}
echoBuffer.flip();
sc.write(echoBuffer);
bytesEchoed += r;
}
System.out.println("Echoed " + bytesEchoed + " from " + sc);
it.remove();
}
}
// System.out.println( "going to clear" );
// selectedKeys.clear();
// System.out.println( "cleared" );
}
}
private void readMessage(SelectionKey sk, SocketChannel readChannel, TcpAddress incomingAddress)
throws IOException {
// note that socket has been used
SocketEntry entry = (SocketEntry) sockets.get(incomingAddress);
if (entry != null) {
entry.used();
ByteBuffer readBuffer = entry.getReadBuffer();
if (readBuffer != null) {
readChannel.read(readBuffer);
if (readBuffer.hasRemaining()) {
readChannel.register(selector, SelectionKey.OP_READ, entry);
} else {
dispatchMessage(incomingAddress, readBuffer, readBuffer.capacity());
}
return;
}
}
ByteBuffer byteBuffer = ByteBuffer.wrap(buf);
byteBuffer.limit(messageLengthDecoder.getMinHeaderLength());
long bytesRead = readChannel.read(byteBuffer);
if (logger.isDebugEnabled()) {
logger.debug("Reading header " + bytesRead + " bytes from " + incomingAddress);
}
MessageLength messageLength = new MessageLength(0, Integer.MIN_VALUE);
if (bytesRead == messageLengthDecoder.getMinHeaderLength()) {
messageLength = messageLengthDecoder.getMessageLength(ByteBuffer.wrap(buf));
if (logger.isDebugEnabled()) {
logger.debug("Message length is " + messageLength);
}
if ((messageLength.getMessageLength() > getMaxInboundMessageSize())
|| (messageLength.getMessageLength() <= 0)) {
logger.error(
"Received message length "
+ messageLength
+ " is greater than inboundBufferSize "
+ getMaxInboundMessageSize());
synchronized (entry) {
entry.getSocket().close();
logger.info("Socket to " + entry.getPeerAddress() + " closed due to an error");
}
} else {
byteBuffer.limit(messageLength.getMessageLength());
bytesRead += readChannel.read(byteBuffer);
if (bytesRead == messageLength.getMessageLength()) {
dispatchMessage(incomingAddress, byteBuffer, bytesRead);
} else {
byte[] message = new byte[byteBuffer.limit()];
byteBuffer.flip();
byteBuffer.get(message, 0, byteBuffer.limit() - byteBuffer.remaining());
entry.setReadBuffer(ByteBuffer.wrap(message));
}
readChannel.register(selector, SelectionKey.OP_READ, entry);
}
} else if (bytesRead < 0) {
logger.debug("Socket closed remotely");
sk.cancel();
readChannel.close();
TransportStateEvent e =
new TransportStateEvent(
DefaultTcpTransportMapping.this,
incomingAddress,
TransportStateEvent.STATE_DISCONNECTED_REMOTELY,
null);
fireConnectionStateChanged(e);
}
}
public void run() {
// Here's where everything happens. The select method will
// return when any operations registered above have occurred, the
// thread has been interrupted, etc.
try {
while (!stop) {
try {
if (selector.select() > 0) {
if (stop) {
break;
}
// Someone is ready for I/O, get the ready keys
Set readyKeys = selector.selectedKeys();
Iterator it = readyKeys.iterator();
// Walk through the ready keys collection and process date requests.
while (it.hasNext()) {
SelectionKey sk = (SelectionKey) it.next();
it.remove();
SocketChannel readChannel = null;
TcpAddress incomingAddress = null;
if (sk.isAcceptable()) {
// The key indexes into the selector so you
// can retrieve the socket that's ready for I/O
ServerSocketChannel nextReady = (ServerSocketChannel) sk.channel();
// Accept the date request and send back the date string
Socket s = nextReady.accept().socket();
readChannel = s.getChannel();
readChannel.configureBlocking(false);
readChannel.register(selector, SelectionKey.OP_READ);
incomingAddress = new TcpAddress(s.getInetAddress(), s.getPort());
SocketEntry entry = new SocketEntry(incomingAddress, s);
sockets.put(incomingAddress, entry);
timeoutSocket(entry);
TransportStateEvent e =
new TransportStateEvent(
DefaultTcpTransportMapping.this,
incomingAddress,
TransportStateEvent.STATE_CONNECTED,
null);
fireConnectionStateChanged(e);
} else if (sk.isReadable()) {
readChannel = (SocketChannel) sk.channel();
incomingAddress =
new TcpAddress(
readChannel.socket().getInetAddress(), readChannel.socket().getPort());
} else if (sk.isWritable()) {
try {
SocketEntry entry = (SocketEntry) sk.attachment();
SocketChannel sc = (SocketChannel) sk.channel();
if (entry != null) {
writeMessage(entry, sc);
}
} catch (IOException iox) {
if (logger.isDebugEnabled()) {
iox.printStackTrace();
}
logger.warn(iox);
TransportStateEvent e =
new TransportStateEvent(
DefaultTcpTransportMapping.this,
incomingAddress,
TransportStateEvent.STATE_DISCONNECTED_REMOTELY,
iox);
fireConnectionStateChanged(e);
sk.cancel();
}
} else if (sk.isConnectable()) {
try {
SocketEntry entry = (SocketEntry) sk.attachment();
SocketChannel sc = (SocketChannel) sk.channel();
if ((!sc.isConnected()) && (sc.finishConnect())) {
sc.configureBlocking(false);
logger.debug("Connected to " + entry.getPeerAddress());
// make sure conncetion is closed if not used for timeout
// micro seconds
timeoutSocket(entry);
sc.register(selector, SelectionKey.OP_WRITE, entry);
}
TransportStateEvent e =
new TransportStateEvent(
DefaultTcpTransportMapping.this,
incomingAddress,
TransportStateEvent.STATE_CONNECTED,
null);
fireConnectionStateChanged(e);
} catch (IOException iox) {
if (logger.isDebugEnabled()) {
iox.printStackTrace();
}
logger.warn(iox);
sk.cancel();
}
}
if (readChannel != null) {
try {
readMessage(sk, readChannel, incomingAddress);
} catch (IOException iox) {
// IO exception -> channel closed remotely
if (logger.isDebugEnabled()) {
iox.printStackTrace();
}
logger.warn(iox);
sk.cancel();
readChannel.close();
TransportStateEvent e =
new TransportStateEvent(
DefaultTcpTransportMapping.this,
incomingAddress,
TransportStateEvent.STATE_DISCONNECTED_REMOTELY,
iox);
fireConnectionStateChanged(e);
}
}
}
}
} catch (NullPointerException npex) {
// There seems to happen a NullPointerException within the select()
npex.printStackTrace();
logger.warn("NullPointerException within select()?");
}
processPending();
}
if (ssc != null) {
ssc.close();
}
} catch (IOException iox) {
logger.error(iox);
lastError = iox;
}
if (!stop) {
stop = true;
synchronized (DefaultTcpTransportMapping.this) {
server = null;
}
}
}