eventmachine-eventmachine 0.12.7 → 0.12.8

data/java/src/com/rubyeventmachine/EmReactor.java

@@ -340,7 +340,6 @@ public class EmReactor {
 		(Connections.get(sig)).scheduleOutboundDatagram( bb, recipAddress, recipPort);
 	}
 
-	
 	/**
 	 * 
 	 * @param address
@@ -349,11 +348,27 @@ public class EmReactor {
 	 * @throws ClosedChannelException
 	 */
 	public String connectTcpServer (String address, int port) throws ClosedChannelException {
+		return connectTcpServer(null, 0, address, port);
+	}
+
+	/**
+	 *
+	 * @param bindAddr
+	 * @param bindPort
+	 * @param address
+	 * @param port
+	 * @return
+	 * @throws ClosedChannelException
+	 */
+	public String connectTcpServer (String bindAddr, int bindPort, String address, int port) throws ClosedChannelException {
 		String b = createBinding();
 				
 		try {
 			SocketChannel sc = SocketChannel.open();
 			sc.configureBlocking(false);
+			if (bindAddr != null)
+				sc.socket().bind(new InetSocketAddress (bindAddr, bindPort));
+
 			EventableSocketChannel ec = new EventableSocketChannel (sc, b, mySelector);
 
 			if (sc.connect (new InetSocketAddress (address, port))) {

data/java/src/com/rubyeventmachine/tests/ConnectTest.java

@@ -97,9 +97,31 @@ public class ConnectTest {
 		});
 		a.run();
 	}
-	
-	
-	
+
+	public final void testBindConnect() throws IOException {
+		class Server extends Connection {
+			public void postInit() {
+				// TODO: get peername here and check if the port is 33333
+				// doesnt seem like peername is impl yet?
+				System.out.println("post init!");
+			}
+		};
+
+		Application a = new Application();
+		a.addTimer(0, new Timer() {
+			public void fire() {
+				application.startServer(new InetSocketAddress("localhost", 20000), new Server());
+			}
+		});
+		a.addTimer(500, new Timer() {
+			public void fire() {
+				application.bindConnect("localhost", 33333, "localhost", 20000);
+			}
+		});
+
+		a.run();
+	}
+
 	class C1 extends Connection {
 		Application application;
 		public C1 (Application a) {

data/lib/{protocols → em}/buftok.rb

@@ -18,6 +18,16 @@
 # by default.  It allows input to be spoon-fed from some outside source which
 # receives arbitrary length datagrams which may-or-may-not contain the token
 # by which entities are delimited.
+#
+# Commonly used to parse lines out of incoming data:
+#
+#  module LineBufferedConnection
+#    def receive_data(data)
+#      (@buffer ||= BufferedTokenizer.new).extract(data).each do |line|
+#        receive_line(line)
+#      end
+#    end
+#  end
 
 class BufferedTokenizer
   # New BufferedTokenizers will operate on lines delimited by "\n" by default
@@ -76,10 +86,10 @@ class BufferedTokenizer
     entities.unshift @input.join
 
 =begin
-	# Note added by FC, 10Jul07. This paragraph contains a regression. It breaks
-	# empty tokens. Think of the empty line that delimits an HTTP header. It will have
-	# two "\n" delimiters in a row, and this code mishandles the resulting empty token.
-	# It someone figures out how to fix the problem, we can re-enable this code branch.
+    # Note added by FC, 10Jul07. This paragraph contains a regression. It breaks
+    # empty tokens. Think of the empty line that delimits an HTTP header. It will have
+    # two "\n" delimiters in a row, and this code mishandles the resulting empty token.
+    # It someone figures out how to fix the problem, we can re-enable this code branch.
     # Multi-character token support.
     # Split any tokens that were incomplete on the last iteration buf complete now.
     entities.map! do |e|
@@ -121,7 +131,8 @@ class BufferedTokenizer
     buffer
   end
 
+  # Is the buffer empty?
   def empty?
     @input.empty?
   end
-end
+end

data/lib/em/callback.rb

@@ -0,0 +1,26 @@
+module EventMachine
+  # Utility method for coercing arguments to an object that responds to #call
+  # Accepts an object and a method name to send to, or a block, or an object
+  # that responds to call.
+  #
+  #  cb = EM.Callback{ |msg| puts(msg) }
+  #  cb.call('hello world')
+  #
+  #  cb = EM.Callback(Object, :puts)
+  #  cb.call('hello world')
+  #
+  #  cb = EM.Callback(proc{ |msg| puts(msg) })
+  #  cb.call('hello world')
+  #
+  def self.Callback(object = nil, method = nil, &blk)
+    if object && method
+      lambda { |*args| object.send method, *args }
+    else
+      if object.respond_to? :call
+        object
+      else 
+        blk || raise(ArgumentError)
+      end
+    end
+  end
+end

data/lib/em/channel.rb

@@ -0,0 +1,57 @@
+module EventMachine
+  # Provides a simple interface to push items to a number of subscribers. The
+  # channel will schedule all operations on the main reactor thread for thread
+  # safe reactor operations.
+  #
+  # This provides a convenient way for connections to consume messages from 
+  # long running code in defer, without threading issues.
+  #
+  #  channel = EM::Channel.new
+  #  sid = channel.subscribe{ |msg| p [:got, msg] }
+  #  channel.push('hello world')
+  #  channel.unsubscribe(sid)
+  #
+  # See examples/ex_channel.rb for a detailed example.
+  class Channel
+    # Create a new channel
+    def initialize
+      @subs = {}
+      @uid = 0
+    end
+
+    # Takes any arguments suitable for EM::Callback() and returns a subscriber
+    # id for use when unsubscribing.
+    def subscribe(*a, &b)
+      name = gen_id
+      EM.schedule { @subs[name] = EM::Callback(*a, &b) }
+      name
+    end
+
+    # Removes this subscriber from the list.
+    def unsubscribe(name)
+      EM.schedule { @subs.delete name }
+    end
+
+    # Add items to the channel, which are pushed out to all subscribers.
+    def push(*items)
+      items = items.dup
+      EM.schedule { @subs.values.each { |s| items.each { |i| s.call i } } }
+    end
+    alias << push
+
+    # Receive exactly one message from the channel.
+    def pop(*a, &b)
+      EM.schedule {
+        name = subscribe do |*args|
+          unsubscribe(name)
+          EM::Callback(*a, &b).call(*args)
+        end
+      }
+    end
+
+    private
+    def gen_id # :nodoc:
+      @uid += 1
+    end
+  end
+end