sonixlabs-eventmachine-java 1.0.0.rc.7-java → 1.0.3.1-java

data/java/src/com/rubyeventmachine/EventCallback.java

@@ -0,0 +1,7 @@
+package com.rubyeventmachine;
+
+import java.nio.ByteBuffer;
+
+public interface EventCallback {
+	void trigger(long sig, EventCode eventType, ByteBuffer data, long data2);
+}

data/java/src/com/rubyeventmachine/EventCode.java

@@ -0,0 +1,26 @@
+package com.rubyeventmachine;
+
+public enum EventCode {
+	EM_TIMER_FIRED(100),
+	EM_CONNECTION_READ(101),
+	EM_CONNECTION_UNBOUND(102),
+	EM_CONNECTION_ACCEPTED(103),
+	EM_CONNECTION_COMPLETED(104),
+	EM_LOOPBREAK_SIGNAL(105),
+	EM_CONNECTION_NOTIFY_READABLE(106),
+	EM_CONNECTION_NOTIFY_WRITABLE(107),
+	EM_SSL_HANDSHAKE_COMPLETED(108),
+	EM_SSL_VERIFY(109),
+	EM_PROXY_TARGET_UNBOUND(110),
+	EM_PROXY_COMPLETED(111);
+
+	private final int intValue;
+
+	EventCode(int intValue) {
+		this.intValue = intValue;
+	}
+
+	public int intValue() {
+		return intValue;
+	}
+}

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

@@ -1,70 +1,130 @@
 /**
  * $Id$
- *
+ * 
  * Author:: Francis Cianfrocca (gmail: blackhedd)
  * Homepage::  http://rubyeventmachine.com
  * Date:: 15 Jul 2007
- *
+ * 
  * See EventMachine and EventMachine::Connection for documentation and
  * usage examples.
- *
+ * 
  *
  *----------------------------------------------------------------------------
  *
  * Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
  * Gmail: blackhedd
- *
+ * 
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of either: 1) the GNU General Public License
  * as published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version; or 2) Ruby's License.
- *
+ * 
  * See the file COPYING for complete licensing information.
  *
  *---------------------------------------------------------------------------
  *
- *
+ * 
  */
 
-
 package com.rubyeventmachine;
 
 import java.nio.ByteBuffer;
 import java.io.IOException;
 import java.nio.channels.ClosedChannelException;
-
-public interface EventableChannel {
-
-  public void scheduleOutboundData (ByteBuffer bb);
-
-  public void scheduleOutboundDatagram (ByteBuffer bb, String recipAddress, int recipPort);
-
-  public boolean scheduleClose (boolean afterWriting);
-
-  public void startTls();
-
-  public long getBinding();
-
-  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() throws IOException;
-
-  public void setCommInactivityTimeout (long seconds);
-
-  public Object[] getPeerName();
-  public Object[] getSockName();
-
-  public boolean isWatchOnly();
-
-  public boolean isNotifyReadable();
-  public boolean isNotifyWritable();
-
+import java.nio.channels.Selector;
+import java.util.LinkedList;
+
+public abstract class EventableChannel<OutboundPacketType> {
+	protected final long binding;
+	protected final Selector selector;
+	protected final LinkedList<OutboundPacketType> outboundQ;
+	protected final EventCallback callback;
+	private final ByteBuffer readBuffer;
+
+	public EventableChannel(long binding, Selector selector,
+			EventCallback callback) {
+		this.binding = binding;
+		this.selector = selector;
+		this.callback = callback;
+		this.outboundQ = new LinkedList<OutboundPacketType>();
+		this.readBuffer = ByteBuffer.allocate(32*1024); // don't use a direct buffer. Ruby doesn't seem to like them.
+	}
+
+	public abstract void scheduleOutboundData(ByteBuffer bb);
+
+	public abstract void scheduleOutboundDatagram(ByteBuffer bb,
+			String recipAddress, int recipPort);
+
+	public abstract boolean scheduleClose(boolean afterWriting);
+
+	public abstract void startTls();
+
+	public long getBinding() {
+		return binding;
+	}
+
+	public abstract void register() throws ClosedChannelException;
+
+	/**
+	 * This is called by the reactor after it finishes running. The idea is to
+	 * free network resources.
+	 */
+	public abstract void close();
+
+	public void setCommInactivityTimeout (long seconds) {
+		// TODO
+		System.out.println ("SET COMM INACTIVITY UNIMPLEMENTED IN JRUBY" + seconds);
+	}
+
+	public abstract Object[] getPeerName();
+
+	public abstract Object[] getSockName();
+
+	public abstract boolean isWatchOnly();
+
+	public abstract boolean isNotifyReadable();
+
+	public abstract boolean isNotifyWritable();
+	
+	protected abstract boolean handshakeNeeded();
+	protected abstract boolean performHandshake();
+	
+	protected abstract void readInboundData(ByteBuffer dst) throws IOException;
+
+	public boolean read() {
+		if (handshakeNeeded()) {
+			return performHandshake();
+		} else if (isWatchOnly() && isNotifyReadable()) {
+			callback.trigger(binding, EventCode.EM_CONNECTION_NOTIFY_READABLE, null, 0);
+		} else {
+			readBuffer.clear();
+
+			try {
+				readInboundData(readBuffer);
+				readBuffer.flip();
+				if (readBuffer.limit() > 0)
+					callback.trigger(binding, EventCode.EM_CONNECTION_READ,	readBuffer, 0);
+			} catch (IOException e) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	protected abstract boolean writeOutboundData() throws IOException;
+
+	public boolean write() {
+		if (handshakeNeeded()) {
+			return performHandshake();
+		} else if (isWatchOnly() || isNotifyWritable()) {
+			callback.trigger(binding, EventCode.EM_CONNECTION_NOTIFY_WRITABLE, null, 0);
+		} else {
+			try {
+				return writeOutboundData();
+			} catch (IOException e) {
+				return false;
+			}
+		}
+		return true;
+	}
 }

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

@@ -1,29 +1,29 @@
 /**
  * $Id$
- *
+ * 
  * Author:: Francis Cianfrocca (gmail: blackhedd)
  * Homepage::  http://rubyeventmachine.com
  * Date:: 15 Jul 2007
- *
+ * 
  * See EventMachine and EventMachine::Connection for documentation and
  * usage examples.
- *
+ * 
  *
  *----------------------------------------------------------------------------
  *
  * Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
  * Gmail: blackhedd
- *
+ * 
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of either: 1) the GNU General Public License
  * as published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version; or 2) Ruby's License.
- *
+ * 
  * See the file COPYING for complete licensing information.
  *
  *---------------------------------------------------------------------------
  *
- *
+ * 
  */
 
 
@@ -34,162 +34,147 @@ import java.nio.channels.ClosedChannelException;
 import java.nio.channels.SelectionKey;
 import java.nio.channels.Selector;
 import java.nio.channels.DatagramChannel;
-import java.util.LinkedList;
 import java.io.*;
 import java.net.*;
 
-public class EventableDatagramChannel implements EventableChannel {
-
-  class Packet {
-    public ByteBuffer bb;
-    public SocketAddress recipient;
-    public Packet (ByteBuffer _bb, SocketAddress _recipient) {
-      bb = _bb;
-      recipient = _recipient;
-    }
-  }
-
-  DatagramChannel channel;
-  long binding;
-  Selector selector;
-  boolean bCloseScheduled;
-  LinkedList<Packet> outboundQ;
-  SocketAddress returnAddress;
-
-
-  public EventableDatagramChannel (DatagramChannel dc, long _binding, Selector sel) throws ClosedChannelException {
-    channel = dc;
-    binding = _binding;
-    selector = sel;
-    bCloseScheduled = false;
-    outboundQ = new LinkedList<Packet>();
-
-    dc.register(selector, SelectionKey.OP_READ, this);
-  }
-
-  public void scheduleOutboundData (ByteBuffer bb) {
-     try {
-      if ((!bCloseScheduled) && (bb.remaining() > 0)) {
-        outboundQ.addLast(new Packet(bb, returnAddress));
-         channel.register(selector, SelectionKey.OP_WRITE | SelectionKey.OP_READ, this);
-      }
-    } catch (ClosedChannelException e) {
-      throw new RuntimeException ("no outbound data");
-    }
-  }
-
-  public void scheduleOutboundDatagram (ByteBuffer bb, String recipAddress, int recipPort) {
-     try {
-      if ((!bCloseScheduled) && (bb.remaining() > 0)) {
-        outboundQ.addLast(new Packet (bb, new InetSocketAddress (recipAddress, recipPort)));
-         channel.register(selector, SelectionKey.OP_WRITE | SelectionKey.OP_READ, this);
-      }
-    } catch (ClosedChannelException e) {
-      throw new RuntimeException ("no outbound data");
-    }
-  }
-
-  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 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.
-   */
-  public void close() {
-    try {
-      channel.close();
-    } catch (IOException e) {
-    }
-  }
-
-  public void readInboundData (ByteBuffer dst) {
-    returnAddress = null;
-    try {
-      // If there is no datagram available (we're nonblocking after all),
-      // then channel.receive returns null.
-      returnAddress = channel.receive(dst);
-    } catch (IOException e) {
-      // probably a no-op. The caller will see the empty (or even partial) buffer
-      // and presumably do the right thing.
-    }
-  }
-
-  public boolean writeOutboundData() {
-    while (!outboundQ.isEmpty()) {
-      Packet p = outboundQ.getFirst();
-      int written = 0;
-      try {
-        // With a datagram socket, it's ok to send an empty buffer.
-        written = channel.send(p.bb, p.recipient);
-      }
-      catch (IOException e) {
-        return false;
-      }
-
-      /* Did we consume the whole outbound buffer? If yes, pop it off and
-       * keep looping. If no, the outbound network buffers are full, so break
-       * out of here. There's a flaw that affects outbound buffers that are intentionally
-       * empty. We can tell whether they got sent or not. So we assume they were.
-       * TODO: As implemented, this ALWAYS discards packets if they were at least
-       * partially written. This matches the behavior of the C++ EM. My judgment
-       * is that this is less surprising than fragmenting the data and sending multiple
-       * packets would be. I could be wrong, so this is subject to change.
-       */
-
-      if ((written > 0) || (p.bb.remaining() == 0))
-        outboundQ.removeFirst();
-      else
-        break;
-    }
-
-    if (outboundQ.isEmpty()) {
-      try {
-        channel.register(selector, SelectionKey.OP_READ, this);
-      } catch (ClosedChannelException e) {}
-    }
-
-    // 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 setCommInactivityTimeout (long seconds) {
-    // 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 Object[] getSockName () {
-    DatagramSocket socket = channel.socket();
-    return new Object[]{ socket.getLocalPort(),
-               socket.getLocalAddress().getHostAddress() };
-  }
-
-  public boolean isWatchOnly() { return false; }
-  public boolean isNotifyReadable() { return false; }
-  public boolean isNotifyWritable() { return false; }
+public class EventableDatagramChannel extends EventableChannel<DatagramPacket> {
+	
+	DatagramChannel channel;
+	boolean bCloseScheduled;
+	SocketAddress returnAddress;
+
+	public EventableDatagramChannel (DatagramChannel dc, long _binding, Selector sel, EventCallback callback) throws ClosedChannelException {
+		super(_binding, sel, callback);
+		channel = dc;
+		bCloseScheduled = false;
+		
+		dc.register(selector, SelectionKey.OP_READ, this);
+	}
+
+	public void scheduleOutboundData (ByteBuffer bb) {
+ 		try {
+			if ((!bCloseScheduled) && (bb.remaining() > 0)) {
+				outboundQ.addLast(new DatagramPacket(bb, returnAddress));
+ 				channel.register(selector, SelectionKey.OP_WRITE | SelectionKey.OP_READ, this);
+			}
+		} catch (ClosedChannelException e) {
+			throw new RuntimeException ("no outbound data");			
+		}
+	}
+	
+	public void scheduleOutboundDatagram (ByteBuffer bb, String recipAddress, int recipPort) {
+ 		try {
+			if ((!bCloseScheduled) && (bb.remaining() > 0)) {
+				outboundQ.addLast(new DatagramPacket (bb, new InetSocketAddress (recipAddress, recipPort)));
+ 				channel.register(selector, SelectionKey.OP_WRITE | SelectionKey.OP_READ, this);
+			}
+		} catch (ClosedChannelException e) {
+			throw new RuntimeException ("no outbound data");			
+		}
+	}
+	
+	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 void register() throws ClosedChannelException {
+		// TODO
+	}
+
+	/**
+	 * Terminate with extreme prejudice. Don't assume there will be another pass through
+	 * the reactor core.
+	 */
+	public void close() {
+		try {
+			channel.close();
+		} catch (IOException e) {
+		}
+	}
+	
+	public void readInboundData (ByteBuffer dst) {
+		returnAddress = null;
+		try {
+			// If there is no datagram available (we're nonblocking after all),
+			// then channel.receive returns null.
+			returnAddress = channel.receive(dst);
+		} catch (IOException e) {
+			// probably a no-op. The caller will see the empty (or even partial) buffer
+			// and presumably do the right thing.
+		}
+	}
+	
+	protected boolean writeOutboundData() {
+		while (!outboundQ.isEmpty()) {
+			DatagramPacket p = outboundQ.getFirst();
+			int written = 0;
+			try {
+				// With a datagram socket, it's ok to send an empty buffer.
+				written = channel.send(p.bb, p.recipient);
+			}
+			catch (IOException e) {
+				return false;
+			}
+
+			/* Did we consume the whole outbound buffer? If yes, pop it off and
+			 * keep looping. If no, the outbound network buffers are full, so break
+			 * out of here. There's a flaw that affects outbound buffers that are intentionally
+			 * empty. We can tell whether they got sent or not. So we assume they were.
+			 * TODO: As implemented, this ALWAYS discards packets if they were at least
+			 * partially written. This matches the behavior of the C++ EM. My judgment
+			 * is that this is less surprising than fragmenting the data and sending multiple
+			 * packets would be. I could be wrong, so this is subject to change.
+			 */
+
+			if ((written > 0) || (p.bb.remaining() == 0))
+				outboundQ.removeFirst();
+			else
+				break;
+		}
+
+		if (outboundQ.isEmpty()) {
+			try {
+				channel.register(selector, SelectionKey.OP_READ, this);
+			} catch (ClosedChannelException e) {}
+		}
+		
+		// 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 Object[] getPeerName () {
+		if (returnAddress != null) {
+			InetSocketAddress inetAddr = (InetSocketAddress) returnAddress;
+			return new Object[]{ inetAddr.getPort(), inetAddr.getHostName() };
+		} else {
+			return null;
+		}
+	}
+
+	public Object[] getSockName () {
+		DatagramSocket socket = channel.socket();
+		return new Object[]{ socket.getLocalPort(),
+							 socket.getLocalAddress().getHostAddress() };
+	}
+
+	public boolean isWatchOnly() { return false; }
+	public boolean isNotifyReadable() { return false; }
+	public boolean isNotifyWritable() { return false; }
+
+	@Override
+	protected boolean handshakeNeeded() {
+		return false;
+	}
+
+	@Override
+	protected boolean performHandshake() {
+		return true;
+	}
 }