boolean initiateConnection(Connection conn_, Peer peer) {
TCPConnection conn = (TCPConnection) conn_;
try {
SocketChannel channel = SocketChannel.open();
InetSocketAddress localAddress = new InetSocketAddress(conn.host_id, 0);
channel.socket().bind(localAddress);
channel.configureBlocking(false);
try {
InetSocketAddress remoteAddress = new InetSocketAddress(peer.host(), peer.port());
if (channel.connect(remoteAddress)) {
// This only happens on Solaris when connecting locally
logger.log(Level.FINEST, "Connected!");
conn.state = Connection.State.connected_out;
conn.channel = channel;
selector.wakeup();
channel.register(selector, SelectionKey.OP_READ, conn);
initiateCER(conn);
return true;
}
} catch (java.nio.channels.UnresolvedAddressException ex) {
channel.close();
return false;
}
conn.state = Connection.State.connecting;
conn.channel = channel;
selector.wakeup();
channel.register(selector, SelectionKey.OP_CONNECT, conn);
} catch (java.io.IOException ex) {
logger.log(
Level.WARNING,
"java.io.IOException caught while initiating connection to '" + peer.host() + "'.",
ex);
}
return true;
}
public static void main(String[] argv) throws Exception {
Pipe[] pipes = new Pipe[PIPES_COUNT];
Pipe pipe = Pipe.open();
Pipe.SinkChannel sink = pipe.sink();
Pipe.SourceChannel source = pipe.source();
Selector sel = Selector.open();
source.configureBlocking(false);
source.register(sel, SelectionKey.OP_READ);
for (int i = 0; i < PIPES_COUNT; i++) {
pipes[i] = Pipe.open();
Pipe.SourceChannel sc = pipes[i].source();
sc.configureBlocking(false);
sc.register(sel, SelectionKey.OP_READ);
Pipe.SinkChannel sc2 = pipes[i].sink();
sc2.configureBlocking(false);
sc2.register(sel, SelectionKey.OP_WRITE);
}
for (int i = 0; i < LOOPS; i++) {
sink.write(ByteBuffer.allocate(BUF_SIZE));
int x = sel.selectNow();
sel.selectedKeys().clear();
source.read(ByteBuffer.allocate(BUF_SIZE));
}
for (int i = 0; i < PIPES_COUNT; i++) {
pipes[i].sink().close();
pipes[i].source().close();
}
pipe.sink().close();
pipe.source().close();
sel.close();
}
/*
* CancelledKeyException is the failure symptom of 4729342
* NOTE: The failure is timing dependent and is not always
* seen immediately when the bug is present.
*/
public static void main(String[] args) throws Exception {
InetAddress lh = InetAddress.getLocalHost();
isa = new InetSocketAddress(lh, TEST_PORT);
selector = Selector.open();
ssc = ServerSocketChannel.open();
// Create and start a selector in a separate thread.
new Thread(
new Runnable() {
public void run() {
try {
ssc.configureBlocking(false);
ssc.socket().bind(isa);
sk = ssc.register(selector, SelectionKey.OP_ACCEPT);
selector.select();
} catch (IOException e) {
System.err.println("error in selecting thread");
e.printStackTrace();
}
}
})
.start();
// Wait for above thread to get to select() before we call close.
Thread.sleep(3000);
// Try to close. This should wakeup select.
new Thread(
new Runnable() {
public void run() {
try {
SocketChannel sc = SocketChannel.open();
sc.connect(isa);
ssc.close();
sk.cancel();
sc.close();
} catch (IOException e) {
System.err.println("error in closing thread");
System.err.println(e);
}
}
})
.start();
// Wait for select() to be awakened, which should be done by close.
Thread.sleep(3000);
selector.wakeup();
selector.close();
}
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();
}
}
public void run() {
for (; ; ) {
try {
int n = sel.select();
if (n > 0) processSelectedKeys();
processPendingTargets();
if (shutdown) {
sel.close();
return;
}
} catch (IOException x) {
x.printStackTrace();
}
}
}
void add(Target t) {
SocketChannel sc = null;
try {
sc = SocketChannel.open();
sc.configureBlocking(false);
boolean connected = sc.connect(t.address);
t.channel = sc;
t.connectStart = System.currentTimeMillis();
if (connected) {
t.connectFinish = t.connectStart;
sc.close();
printer.add(t);
} else {
synchronized (pending) {
pending.add(t);
}
sel.wakeup();
}
} catch (IOException x) {
if (sc != null) {
try {
sc.close();
} catch (IOException xx) {
}
}
t.failure = x;
printer.add(t);
}
}
public void addTarget(Target target) {
// 向targets队列中加入一个任务
SocketChannel socketChannel = null;
try {
socketChannel = SocketChannel.open();
socketChannel.configureBlocking(false);
socketChannel.connect(target.address);
target.channel = socketChannel;
target.connectStart = System.currentTimeMillis();
synchronized (targets) {
targets.add(target);
}
selector.wakeup();
} catch (Exception x) {
if (socketChannel != null) {
try {
socketChannel.close();
} catch (IOException xx) {
}
}
target.failure = x;
addFinishedTarget(target);
}
}
public PingClient() throws IOException {
selector = Selector.open();
Connector connector = new Connector();
Printer printer = new Printer();
connector.start();
printer.start();
receiveTarget();
}
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) {
}
}
public void sendMessage(Address address, byte[] message) throws java.io.IOException {
Socket s = null;
SocketEntry entry = (SocketEntry) sockets.get(address);
if (logger.isDebugEnabled()) {
logger.debug("Looking up connection for destination '" + address + "' returned: " + entry);
logger.debug(sockets.toString());
}
if (entry != null) {
s = entry.getSocket();
}
if ((s == null) || (s.isClosed())) {
if (logger.isDebugEnabled()) {
logger.debug("Socket for address '" + address + "' is closed, opening it...");
}
SocketChannel sc = null;
try {
// Open the channel, set it to non-blocking, initiate connect
sc = SocketChannel.open();
sc.configureBlocking(false);
sc.connect(
new InetSocketAddress(
((TcpAddress) address).getInetAddress(), ((TcpAddress) address).getPort()));
s = sc.socket();
entry = new SocketEntry((TcpAddress) address, s);
entry.addMessage(message);
sockets.put(address, entry);
synchronized (pending) {
pending.add(entry);
}
selector.wakeup();
logger.debug("Trying to connect to " + address);
} catch (IOException iox) {
logger.error(iox);
throw iox;
}
} else {
entry.addMessage(message);
synchronized (pending) {
pending.add(entry);
}
selector.wakeup();
}
}
void openIO() throws java.io.IOException {
// create a new Selector for use below
selector = Selector.open();
if (settings.port() != 0) {
// allocate an unbound server socket channel
serverChannel = ServerSocketChannel.open();
// set the (host,port) into the server channel will listen to
serverChannel.socket().bind(new InetSocketAddress(settings.hostId(), settings.port()));
}
}
/** Close. */
public void close() {
if (selector != null) {
selector.wakeup();
try {
selector.close();
} catch (IOException e1) {
log.warn("close selector fails", e1);
} finally {
selector = null;
}
}
if (server != null) {
try {
server.socket().close();
server.close();
} catch (IOException e) {
log.warn("close socket server fails", e);
} finally {
server = null;
}
}
}
void checkIO() {
long timeout;
if (NewConnections.size() > 0) {
timeout = -1;
} else if (!Timers.isEmpty()) {
long now = new Date().getTime();
long k = Timers.firstKey();
long diff = k - now;
if (diff <= 0) timeout = -1; // don't wait, just poll once
else timeout = diff;
} else {
timeout = 0; // wait indefinitely
}
try {
if (timeout == -1) mySelector.selectNow();
else mySelector.select(timeout);
} catch (IOException e) {
e.printStackTrace();
}
}
void processIO() {
Iterator<SelectionKey> it = mySelector.selectedKeys().iterator();
while (it.hasNext()) {
SelectionKey k = it.next();
it.remove();
if (k.isConnectable()) isConnectable(k);
else if (k.isAcceptable()) isAcceptable(k);
else {
if (k.isWritable()) isWritable(k);
if (k.isReadable()) isReadable(k);
}
}
}
void close() {
try {
if (mySelector != null) mySelector.close();
} catch (IOException e) {
}
mySelector = null;
// run down open connections and sockets.
Iterator<ServerSocketChannel> i = Acceptors.values().iterator();
while (i.hasNext()) {
try {
i.next().close();
} catch (IOException e) {
}
}
// 29Sep09: We create an ArrayList of the existing connections, then iterate over
// that to call unbind on them. This is because an unbind can trigger a reconnect,
// which will add to the Connections HashMap, causing a ConcurrentModificationException.
// XXX: The correct behavior here would be to latch the various reactor methods to return
// immediately if the reactor is shutting down.
ArrayList<EventableChannel> conns = new ArrayList<EventableChannel>();
Iterator<EventableChannel> i2 = Connections.values().iterator();
while (i2.hasNext()) {
EventableChannel ec = i2.next();
if (ec != null) {
conns.add(ec);
}
}
Connections.clear();
ListIterator<EventableChannel> i3 = conns.listIterator(0);
while (i3.hasNext()) {
EventableChannel ec = i3.next();
eventCallback(ec.getBinding(), EM_CONNECTION_UNBOUND, null);
ec.close();
EventableSocketChannel sc = (EventableSocketChannel) ec;
if (sc != null && sc.isAttached()) DetachedConnections.add(sc);
}
ListIterator<EventableSocketChannel> i4 = DetachedConnections.listIterator(0);
while (i4.hasNext()) {
EventableSocketChannel ec = i4.next();
ec.cleanup();
}
DetachedConnections.clear();
}
void closeIO() {
logger.log(Level.FINEST, "Closing server channel, etc.");
if (serverChannel != null) {
try {
serverChannel.close();
} catch (java.io.IOException ex) {
}
}
serverChannel = null;
try {
selector.close();
} catch (java.io.IOException ex) {
}
selector = null;
logger.log(Level.FINEST, "Closed selector, etc.");
}
public void receiveTarget() {
// 接收用户输入的地址，向targets队列中加入任务
try {
BufferedReader localReader = new BufferedReader(new InputStreamReader(System.in));
String msg = null;
while ((msg = localReader.readLine()) != null) {
if (!msg.equals("bye")) {
Target target = new Target(msg);
addTarget(target);
} else {
shutdown = true;
selector.wakeup();
break;
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void startRDPServer() {
if (rdpServerStarted) return;
rdpServerStarted = true;
rdpServerThread = new Thread(rdpServer, "RDPServer");
retryThread = new Thread(new RetryThread(), "RDPRetry");
packetCallbackThread = new Thread(new PacketCallbackThread(), "RDPCallback");
if (Log.loggingNet) Log.net("static - starting rdpserver thread");
try {
selector = Selector.open();
} catch (Exception e) {
Log.exception("RDPServer caught exception opening selector", e);
System.exit(1);
}
rdpServerThread.setPriority(rdpServerThread.getPriority() + 2);
if (Log.loggingDebug)
Log.debug(
"RDPServer: starting rdpServerThread with priority " + rdpServerThread.getPriority());
rdpServerThread.start();
retryThread.start();
packetCallbackThread.start();
}
public ServerThread() throws IOException {
setName("DefaultTCPTransportMapping_" + getAddress());
buf = new byte[getMaxInboundMessageSize()];
// Selector for incoming requests
selector = Selector.open();
if (serverEnabled) {
// Create a new server socket and set to non blocking mode
ssc = ServerSocketChannel.open();
ssc.configureBlocking(false);
// Bind the server socket
InetSocketAddress isa =
new InetSocketAddress(tcpAddress.getInetAddress(), tcpAddress.getPort());
ssc.socket().bind(isa);
// Register accepts on the server socket with the selector. This
// step tells the selector that the socket wants to be put on the
// ready list when accept operations occur, so allowing multiplexed
// non-blocking I/O to take place.
ssc.register(selector, SelectionKey.OP_ACCEPT);
}
}
public void run() {
try {
mySelector = Selector.open();
bRunReactor = true;
} catch (IOException e) {
throw new RuntimeException("Could not open selector", e);
}
while (bRunReactor) {
runLoopbreaks();
if (!bRunReactor) break;
runTimers();
if (!bRunReactor) break;
removeUnboundConnections();
checkIO();
addNewConnections();
processIO();
}
close();
}
void processSelectedKeys() throws IOException {
for (Iterator i = sel.selectedKeys().iterator(); i.hasNext(); ) {
SelectionKey sk = (SelectionKey) i.next();
i.remove();
Target t = (Target) sk.attachment();
SocketChannel sc = (SocketChannel) sk.channel();
try {
if (sc.finishConnect()) {
sk.cancel();
t.connectFinish = System.currentTimeMillis();
sc.close();
printer.add(t);
}
} catch (IOException x) {
sc.close();
t.failure = x;
printer.add(t);
}
}
}
public void processSelectedKeys() throws IOException {
// 处理连接就绪事件
for (Iterator it = selector.selectedKeys().iterator(); it.hasNext(); ) {
SelectionKey selectionKey = (SelectionKey) it.next();
it.remove();
Target target = (Target) selectionKey.attachment();
SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
try {
if (socketChannel.finishConnect()) {
selectionKey.cancel();
target.connectFinish = System.currentTimeMillis();
socketChannel.close();
addFinishedTarget(target);
}
} catch (IOException x) {
socketChannel.close();
target.failure = x;
addFinishedTarget(target);
}
}
}
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" );
}
}
public void signalLoopbreak() {
loopBreaker.set(true);
if (mySelector != null) mySelector.wakeup();
}
void wakeup() {
logger.log(Level.FINEST, "Waking up selector thread");
selector.wakeup();
}
Connector(Printer pr) throws IOException {
printer = pr;
sel = Selector.open();
setName("Connector");
}
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;
}
}
}
void shutdown() {
shutdown = true;
sel.wakeup();
}