eventmachine 0.12.8-java → 0.12.10-java

data/java/src/com/rubyeventmachine/EventableChannel.java

@@ -30,6 +30,8 @@
 package com.rubyeventmachine;
 
 import java.nio.ByteBuffer;
+import java.io.IOException;
+import java.nio.channels.ClosedChannelException;
 
 public interface EventableChannel {
 	
@@ -37,21 +39,31 @@ public interface EventableChannel {
 	
 	public void scheduleOutboundDatagram (ByteBuffer bb, String recipAddress, int recipPort);
 	
-	public void scheduleClose (boolean afterWriting);
+	public boolean scheduleClose (boolean afterWriting);
 	
 	public void startTls();
 	
-	public String getBinding();
+	public long getBinding();
 	
-	public void readInboundData (ByteBuffer dst);
+	public void readInboundData (ByteBuffer dst) throws IOException;
 	
+	public void register() throws ClosedChannelException;
+
 	/**
 	 * This is called by the reactor after it finishes running.
 	 * The idea is to free network resources.
 	 */
 	public void close();
 	
-	public boolean writeOutboundData();
+	public boolean writeOutboundData() throws IOException;
 
 	public void setCommInactivityTimeout (long seconds);
+
+	public Object[] getPeerName();
+
+	public boolean isWatchOnly();
+
+	public boolean isNotifyReadable();
+	public boolean isNotifyWritable();
+
 }

data/java/src/com/rubyeventmachine/EventableDatagramChannel.java

@@ -50,14 +50,14 @@ public class EventableDatagramChannel implements EventableChannel {
 	}
 	
 	DatagramChannel channel;
-	String binding;
+	long binding;
 	Selector selector;
 	boolean bCloseScheduled;
 	LinkedList<Packet> outboundQ;
 	SocketAddress returnAddress;
 	
 
-	public EventableDatagramChannel (DatagramChannel dc, String _binding, Selector sel) throws ClosedChannelException {
+	public EventableDatagramChannel (DatagramChannel dc, long _binding, Selector sel) throws ClosedChannelException {
 		channel = dc;
 		binding = _binding;
 		selector = sel;
@@ -89,18 +89,23 @@ public class EventableDatagramChannel implements EventableChannel {
 		}
 	}
 	
-	public void scheduleClose (boolean afterWriting) {
+	public boolean scheduleClose (boolean afterWriting) {
 		System.out.println ("NOT SCHEDULING CLOSE ON DATAGRAM");
+		return false;
 	}
 	
 	public void startTls() {
 		throw new RuntimeException ("TLS is unimplemented on this Channel");
 	}
 	
-	public String getBinding() {
+	public long getBinding() {
 		return binding;
 	}
-	
+
+	public void register() throws ClosedChannelException {
+		// TODO
+	}
+
 	/**
 	 * Terminate with extreme prejudice. Don't assume there will be another pass through
 	 * the reactor core.
@@ -168,4 +173,17 @@ public class EventableDatagramChannel implements EventableChannel {
 		// TODO
 		System.out.println ("DATAGRAM: SET COMM INACTIVITY UNIMPLEMENTED " + seconds);
 	}
+
+	public Object[] getPeerName () {
+		if (returnAddress != null) {
+			InetSocketAddress inetAddr = (InetSocketAddress) returnAddress;
+			return new Object[]{ inetAddr.getPort(), inetAddr.getHostName() };
+		} else {
+			return null;
+		}
+	}
+
+	public boolean isWatchOnly() { return false; }
+	public boolean isNotifyReadable() { return false; }
+	public boolean isNotifyWritable() { return false; }
 }

data/java/src/com/rubyeventmachine/EventableSocketChannel.java

@@ -40,71 +40,139 @@ import java.nio.channels.*;
 import java.nio.*;
 import java.util.*;
 import java.io.*;
+import java.net.Socket;
 import javax.net.ssl.*;
 import javax.net.ssl.SSLEngineResult.*;
+import java.lang.reflect.Field;
 
 import java.security.*;
 
 public class EventableSocketChannel implements EventableChannel {
-	
-	// TODO, must refactor this to permit channels that aren't sockets.
-	SocketChannel channel;
-	String binding;
 	Selector selector;
+	SelectionKey channelKey;
+	SocketChannel channel;
+
+	long binding;
 	LinkedList<ByteBuffer> outboundQ;
+
 	boolean bCloseScheduled;
 	boolean bConnectPending;
+	boolean bWatchOnly;
+	boolean bAttached;
+	boolean bNotifyReadable;
+	boolean bNotifyWritable;
 	
 	SSLEngine sslEngine;
-	
-	
 	SSLContext sslContext;
 
-
-	public EventableSocketChannel (SocketChannel sc, String _binding, Selector sel) throws ClosedChannelException {
+	public EventableSocketChannel (SocketChannel sc, long _binding, Selector sel) {
 		channel = sc;
 		binding = _binding;
 		selector = sel;
 		bCloseScheduled = false;
 		bConnectPending = false;
+		bWatchOnly = false;
+		bAttached = false;
+		bNotifyReadable = false;
+		bNotifyWritable = false;
 		outboundQ = new LinkedList<ByteBuffer>();
-		
-		sc.register(selector, SelectionKey.OP_READ, this);
 	}
 	
-	public String getBinding() {
+	public long getBinding() {
 		return binding;
 	}
-	
+
+	public SocketChannel getChannel() {
+		return channel;
+	}
+
+	public void register() throws ClosedChannelException {
+		if (channelKey == null) {
+			int events = currentEvents();
+			channelKey = channel.register(selector, events, this);
+		}
+	}
+
 	/**
 	 * Terminate with extreme prejudice. Don't assume there will be another pass through
 	 * the reactor core.
 	 */
 	public void close() {
+		if (channelKey != null) {
+			channelKey.cancel();
+			channelKey = null;
+		}
+
+		if (bAttached) {
+			// attached channels are copies, so reset the file descriptor to prevent java from close()ing it
+			Field f;
+			FileDescriptor fd;
+
+			try {
+				/* do _NOT_ clobber fdVal here, it will break epoll/kqueue on jdk6!
+				 * channelKey.cancel() above does not occur until the next call to select
+				 * and if fdVal is gone, we will continue to get events for this fd.
+				 *
+				 * instead, remove fdVal in cleanup(), which is processed via DetachedConnections,
+				 * after UnboundConnections but before NewConnections.
+				 */
+
+				f = channel.getClass().getDeclaredField("fd");
+				f.setAccessible(true);
+				fd = (FileDescriptor) f.get(channel);
+
+				f = fd.getClass().getDeclaredField("fd");
+				f.setAccessible(true);
+				f.set(fd, -1);
+			} catch (java.lang.NoSuchFieldException e) {
+				e.printStackTrace();
+			} catch (java.lang.IllegalAccessException e) {
+				e.printStackTrace();
+			}
+
+			return;
+		}
+
 		try {
 			channel.close();
 		} catch (IOException e) {
 		}
 	}
+
+	public void cleanup() {
+		if (bAttached) {
+			Field f;
+			try {
+				f = channel.getClass().getDeclaredField("fdVal");
+				f.setAccessible(true);
+				f.set(channel, -1);
+			} catch (java.lang.NoSuchFieldException e) {
+				e.printStackTrace();
+			} catch (java.lang.IllegalAccessException e) {
+				e.printStackTrace();
+			}
+		}
+
+		channel = null;
+	}
 	
 	public void scheduleOutboundData (ByteBuffer bb) {
-		try {
-			if ((!bCloseScheduled) && (bb.remaining() > 0)) {
-				if (sslEngine != null) {
+		if (!bCloseScheduled && bb.remaining() > 0) {
+			if (sslEngine != null) {
+				try {
 					ByteBuffer b = ByteBuffer.allocate(32*1024); // TODO, preallocate this buffer.
 					sslEngine.wrap(bb, b);
 					b.flip();
 					outboundQ.addLast(b);
+				} catch (SSLException e) {
+					throw new RuntimeException ("ssl error");
 				}
-				else {
-					outboundQ.addLast(bb);
-				}
-				channel.register(selector, SelectionKey.OP_WRITE | SelectionKey.OP_READ | (bConnectPending ? SelectionKey.OP_CONNECT : 0), this);
 			}
-		} catch (ClosedChannelException e) {
-			throw new RuntimeException ("no outbound data");			
-		} catch (SSLException e) {
-			throw new RuntimeException ("no outbound data");
+			else {
+				outboundQ.addLast(bb);
+			}
+
+			updateEvents();
 		}
 	}
 	
@@ -115,17 +183,14 @@ public class EventableSocketChannel implements EventableChannel {
 	/**
 	 * Called by the reactor when we have selected readable.
 	 */
-	public void readInboundData (ByteBuffer bb) {
-		try {
-			channel.read(bb);
-		} catch (IOException e) {
-			throw new RuntimeException ("i/o error");
-		}
+	public void readInboundData (ByteBuffer bb) throws IOException {
+		if (channel.read(bb) == -1)
+			throw new IOException ("eof");
 	}
+
 	/**
 	 * Called by the reactor when we have selected writable.
 	 * Return false to indicate an error that should cause the connection to close.
-	 * We can get here with an empty outbound buffer if bCloseScheduled is true.
 	 * TODO, VERY IMPORTANT: we're here because we selected writable, but it's always
 	 * possible to become unwritable between the poll and when we get here. The way
 	 * this code is written, we're depending on a nonblocking write NOT TO CONSUME
@@ -135,16 +200,11 @@ public class EventableSocketChannel implements EventableChannel {
 	 * Ought to be a big performance enhancer.
 	 * @return
 	 */
-	public boolean writeOutboundData(){
+	public boolean writeOutboundData() throws IOException {
 		while (!outboundQ.isEmpty()) {
 			ByteBuffer b = outboundQ.getFirst();
-			try {
-				if (b.remaining() > 0)
-					channel.write(b);
-			}
-			catch (IOException e) {
-				return false;
-			}
+			if (b.remaining() > 0)
+				channel.write(b);
 
 			// Did we consume the whole outbound buffer? If yes,
 			// pop it off and keep looping. If no, the outbound network
@@ -155,52 +215,47 @@ public class EventableSocketChannel implements EventableChannel {
 				break;
 		}
 
-		if (outboundQ.isEmpty()) {
-			try {
-				channel.register(selector, SelectionKey.OP_READ, this);
-			} catch (ClosedChannelException e) {
-			}
+		if (outboundQ.isEmpty() && !bCloseScheduled) {
+			updateEvents();
 		}
-		
+
 		// ALWAYS drain the outbound queue before triggering a connection close.
 		// If anyone wants to close immediately, they're responsible for clearing
 		// the outbound queue.
 		return (bCloseScheduled && outboundQ.isEmpty()) ? false : true;
  	}
 	
-	public void setConnectPending() throws ClosedChannelException {
-		channel.register(selector, SelectionKey.OP_CONNECT, this);
+	public void setConnectPending() {
 		bConnectPending = true;
+		updateEvents();
 	}
 	
 	/**
 	 * Called by the reactor when we have selected connectable.
 	 * Return false to indicate an error that should cause the connection to close.
-	 * @throws ClosedChannelException
 	 */
-	public boolean finishConnecting() throws ClosedChannelException {
-		try {
-			channel.finishConnect();
-		}
-		catch (IOException e) {
-			return false;
-		}
+	public boolean finishConnecting() throws IOException {
+		channel.finishConnect();
+
 		bConnectPending = false;
-		channel.register(selector, SelectionKey.OP_READ | (outboundQ.isEmpty() ? 0 : SelectionKey.OP_WRITE), this);
+		updateEvents();
 		return true;
 	}
 	
-	public void scheduleClose (boolean afterWriting) {
+	public boolean scheduleClose (boolean afterWriting) {
 		// TODO: What the hell happens here if bConnectPending is set?
 		if (!afterWriting)
 			outboundQ.clear();
-		try {
-			channel.register(selector, SelectionKey.OP_READ|SelectionKey.OP_WRITE, this);
-		} catch (ClosedChannelException e) {
-			throw new RuntimeException ("unable to schedule close"); // TODO, get rid of this.
+
+		if (outboundQ.isEmpty())
+			return true;
+		else {
+			updateEvents();
+			bCloseScheduled = true;
+			return false;
 		}
-		bCloseScheduled = true;
 	}
+
 	public void startTls() {
 		if (sslEngine == null) {
 			try {
@@ -241,4 +296,69 @@ public class EventableSocketChannel implements EventableChannel {
 		// TODO
 		System.out.println ("SOCKET: SET COMM INACTIVITY UNIMPLEMENTED " + seconds);
 	}
+
+	public Object[] getPeerName () {
+		Socket sock = channel.socket();
+		return new Object[]{ sock.getPort(), sock.getInetAddress().getHostAddress() };
+	}
+
+	public void setWatchOnly() {
+		bWatchOnly = true;
+		updateEvents();
+	}
+	public boolean isWatchOnly() { return bWatchOnly; }
+
+	public void setAttached() {
+		bAttached = true;
+	}
+	public boolean isAttached() { return bAttached; }
+
+	public void setNotifyReadable (boolean mode) {
+		bNotifyReadable = mode;
+		updateEvents();
+	}
+	public boolean isNotifyReadable() { return bNotifyReadable; }
+
+	public void setNotifyWritable (boolean mode) {
+		bNotifyWritable = mode;
+		updateEvents();
+	}
+	public boolean isNotifyWritable() { return bNotifyWritable; }
+
+	private void updateEvents() {
+		if (channelKey == null)
+			return;
+
+		int events = currentEvents();
+
+		if (channelKey.interestOps() != events) {
+			channelKey.interestOps(events);
+		}
+	}
+
+	private int currentEvents() {
+		int events = 0;
+
+		if (bWatchOnly)
+		{
+			if (bNotifyReadable)
+				events |= SelectionKey.OP_READ;
+
+			if (bNotifyWritable)
+				events |= SelectionKey.OP_WRITE;
+		}
+		else
+		{
+			if (bConnectPending)
+				events |= SelectionKey.OP_CONNECT;
+			else {
+				events |= SelectionKey.OP_READ;
+
+				if (!outboundQ.isEmpty())
+					events |= SelectionKey.OP_WRITE;
+			}
+		}
+
+		return events;
+	}
 }

data/java/src/com/rubyeventmachine/{Application.java → application/Application.java}

@@ -29,7 +29,7 @@
 /**
  * 
  */
-package com.rubyeventmachine;
+package com.rubyeventmachine.application;
 
 import java.nio.ByteBuffer;
 import java.nio.channels.*;
@@ -38,6 +38,8 @@ import java.io.*;
 import java.net.*;
 import java.net.SocketAddress;
 
+import com.rubyeventmachine.*;
+
 /**
  * @author francis
  *
@@ -48,25 +50,23 @@ public class Application {
 	public class Reactor extends EmReactor {
 
 		private Application application;
-		private TreeMap<String, Timer> timers;
-		private TreeMap<String, Connection> connections;
-		private TreeMap<String, ConnectionFactory> acceptors;
+		private TreeMap<Long, Timer> timers;
+		private TreeMap<Long, Connection> connections;
+		private TreeMap<Long, ConnectionFactory> acceptors;
 		/**
 		 * 
 		 */
 		public Reactor (Application app) {
 			application = app;
-			timers = new TreeMap<String, Timer>();
-			connections = new TreeMap<String, Connection>();
-			acceptors = new TreeMap<String, ConnectionFactory>();
+			timers = new TreeMap<Long, Timer>();
+			connections = new TreeMap<Long, Connection>();
+			acceptors = new TreeMap<Long, ConnectionFactory>();
 		}
 
 
-		public void eventCallback (String sig, int eventType, ByteBuffer data) {
+		public void eventCallback (long sig, int eventType, ByteBuffer data, long data2) {
 			if (eventType == EM_TIMER_FIRED) {
-				String timersig = new String (data.array());
-				//System.out.println ("EVSIG "+sig + "..."+new String(data.array()));
-				Timer r = timers.remove(timersig);
+				Timer r = timers.remove(data2);
 				if (r != null)
 					r._fire();
 				else
@@ -93,7 +93,7 @@ public class Application {
 				ConnectionFactory f = acceptors.get(sig);
 				if (f != null) {
 					Connection c = f.connection();
-					c.signature = new String (data.array());
+					c.signature = data2;
 					c.application = application;
 					connections.put(c.signature, c);
 					c.postInit();
@@ -124,19 +124,17 @@ public class Application {
 	public void addTimer (double seconds, Timer t) {
 		t.application = this;
 		t.interval = seconds;
-		String s = reactor.installOneshotTimer ((int)(seconds * 1000));
+		long s = reactor.installOneshotTimer ((int)(seconds * 1000));
 		reactor.timers.put(s, t);
 		
 	}
 
 	public void bindConnect (String bindAddr, int bindPort, String host, int port, Connection c) {
-		try {
-			String s = reactor.connectTcpServer(bindAddr, bindPort, host, port);
-			c.application = this;
-			c.signature = s;
-			reactor.connections.put(s, c);
-			c.postInit();
-		} catch (ClosedChannelException e) {}
+		long s = reactor.connectTcpServer(bindAddr, bindPort, host, port);
+		c.application = this;
+		c.signature = s;
+		reactor.connections.put(s, c);
+		c.postInit();
 	}
 
 	public void connect (String host, int port, Connection c) {
@@ -144,7 +142,7 @@ public class Application {
 	}
 	
 	public void startServer (SocketAddress sa, ConnectionFactory f) throws EmReactorException {
-		String s = reactor.startTcpServer(sa);
+		long s = reactor.startTcpServer(sa);
 		reactor.acceptors.put(s, f);
 	}
 	
@@ -152,9 +150,7 @@ public class Application {
 		reactor.stop();
 	}
 	public void run() {
-		try {
-			reactor.run();
-		} catch (IOException e) {}
+		reactor.run();
 	}
 	public void run (final Runnable r) {
 		addTimer(0, new Timer() {
@@ -165,20 +161,18 @@ public class Application {
 		run();
 	}
 	
-	public void sendData (String sig, ByteBuffer bb) {
+	public void sendData (long sig, ByteBuffer bb) {
 		try {
 			reactor.sendData(sig, bb);
 		} catch (IOException e) {}
 	}
 	
-	public void sendDatagram (String sig, ByteBuffer bb, InetSocketAddress target) {
+	public void sendDatagram (long sig, ByteBuffer bb, InetSocketAddress target) {
 		reactor.sendDatagram(sig, bb, target.getHostName(), target.getPort());
 	}
 	
-	public void closeConnection (String sig, boolean afterWriting) {
-		try {
-			reactor.closeConnection(sig, afterWriting);
-		} catch (ClosedChannelException e) {}
+	public void closeConnection (long sig, boolean afterWriting) {
+		reactor.closeConnection(sig, afterWriting);
 	}
 	
 	public void openDatagramSocket (Connection c) {
@@ -186,7 +180,7 @@ public class Application {
 	}
 	public void openDatagramSocket (InetSocketAddress addr, Connection c) {
 		try {
-			String s = reactor.openUdpSocket(addr);
+			long s = reactor.openUdpSocket(addr);
 			c.application = this;
 			c.signature = s;
 			reactor.connections.put(s, c);