eventmachine-maglev- 0.12.10

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

@@ -0,0 +1,80 @@
+/**
+ * $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.tests;
+
+//import static org.junit.Assert.*;
+
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import com.rubyeventmachine.EmReactor;
+
+import java.io.*;
+import java.nio.*;
+
+
+public class EMTest {
+
+	class ShortTimer extends EmReactor {
+		public void eventCallback (String sig, int eventCode, ByteBuffer data) {
+			System.out.println ("Short Callback "+sig+" "+eventCode+" "+data);
+			this.stop();
+		}
+	}
+	
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+	}
+
+	@AfterClass
+	public static void tearDownAfterClass() throws Exception {
+	}
+
+	@Before
+	public void setUp() throws Exception {
+	}
+
+	@After
+	public void tearDown() throws Exception {
+	}
+ 
+
+	@Test
+	public final void testOneShort() throws IOException {
+		EmReactor em = new ShortTimer();
+		em.installOneshotTimer(1050);
+		em.run();
+	}
+	
+
+}

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

@@ -0,0 +1,53 @@
+package com.rubyeventmachine.tests;
+
+import com.rubyeventmachine.application.*;
+import java.net.*;
+import java.nio.*;
+
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+
+public class TestDatagrams {
+
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+	}
+
+	@AfterClass
+	public static void tearDownAfterClass() throws Exception {
+	}
+
+	@Before
+	public void setUp() throws Exception {
+	}
+
+	@After
+	public void tearDown() throws Exception {
+	}
+
+	class A extends Connection {
+		public void receiveData (ByteBuffer bb) {
+			application.stop();
+		}
+	}
+	class B extends Connection {
+		public void postInit() {
+			this.sendDatagram(ByteBuffer.wrap(new String("ABC").getBytes()), new InetSocketAddress ("127.0.0.1", 9550));
+		}
+		
+	}
+	@Test
+	public final void testA() {
+		final Application a = new Application();
+		a.run (new Runnable() {
+			public void run() {
+				a.openDatagramSocket( new InetSocketAddress ("0.0.0.0", 9550), new A() );
+				a.openDatagramSocket( new B() );
+			}
+		});
+	}
+}

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

@@ -0,0 +1,75 @@
+/**
+ * $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.tests;
+
+
+import com.rubyeventmachine.*;
+import com.rubyeventmachine.application.*;
+import java.net.*;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.Assert;
+
+public class TestServers {
+
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+	}
+
+	@AfterClass
+	public static void tearDownAfterClass() throws Exception {
+	}
+
+	@Before
+	public void setUp() throws Exception {
+	}
+
+	@After
+	public void tearDown() throws Exception {
+	}
+
+	
+ 	@Test
+	public void testBadServerAddress() {
+		final Application a = new Application();
+		a.run (new Runnable() {
+			public void run() {
+				try {
+					a.startServer(new InetSocketAddress ("100.100.100.100", 100), new DefaultConnectionFactory());
+					Assert.fail ("was supposed to throw a reactor exception");
+				} catch (EmReactorException e) {}
+				a.stop();
+			}
+		});
+	}
+}

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

@@ -0,0 +1,90 @@
+/**
+ * $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.tests;
+
+import com.rubyeventmachine.*;
+import com.rubyeventmachine.application.*;
+import java.io.*;
+
+import org.junit.Assert;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+
+public class TestTimers {
+
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+	}
+
+	@AfterClass
+	public static void tearDownAfterClass() throws Exception {
+	}
+
+	@Before
+	public void setUp() throws Exception {
+	}
+
+	@After
+	public void tearDown() throws Exception {
+	}
+
+
+	
+	@Test
+	public final void test2() throws IOException {
+		Application a = new Application();
+		a.addTimer(0, new Timer() {
+			public void fire() {
+				application.stop();
+			}
+		});
+		a.run();
+		Assert.assertEquals (1, 1); // just to make sure the reactor halts.
+	}
+	
+	@Test
+	public final void test3() throws IOException {
+		Application a = new Application();
+		a.addTimer (0.1, new PeriodicTimer() {
+			int n = 0;
+			public void fire() {
+				n++;
+				if (n == 5)
+					application.stop();
+			}
+		});
+		a.run();
+		Assert.assertEquals(1, 1);
+	}
+}

data/lib/em/buftok.rb

@@ -0,0 +1,138 @@
+# BufferedTokenizer - Statefully split input data by a specifiable token
+#
+# Authors:: Tony Arcieri, Martin Emde
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006-07 by Tony Arcieri and Martin Emde
+# 
+# Distributed under the Ruby license (http://www.ruby-lang.org/en/LICENSE.txt)
+#
+#---------------------------------------------------------------------------
+#
+
+# (C)2006 Tony Arcieri, Martin Emde
+# Distributed under the Ruby license (http://www.ruby-lang.org/en/LICENSE.txt)
+
+# BufferedTokenizer takes a delimiter upon instantiation, or acts line-based
+# 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
+  # or allow you to specify any delimiter token you so choose, which will then
+  # be used by String#split to tokenize the input data
+  def initialize(delimiter = "\n", size_limit = nil)
+    # Store the specified delimiter
+    @delimiter = delimiter
+
+    # Store the specified size limitation
+    @size_limit = size_limit
+
+    # The input buffer is stored as an array.  This is by far the most efficient
+    # approach given language constraints (in C a linked list would be a more
+    # appropriate data structure).  Segments of input data are stored in a list
+    # which is only joined when a token is reached, substantially reducing the
+    # number of objects required for the operation.
+    @input = []
+
+    # Size of the input buffer
+    @input_size = 0
+  end
+
+  # Extract takes an arbitrary string of input data and returns an array of
+  # tokenized entities, provided there were any available to extract.  This
+  # makes for easy processing of datagrams using a pattern like:
+  #
+  #   tokenizer.extract(data).map { |entity| Decode(entity) }.each do ...
+  def extract(data)
+    # Extract token-delimited entities from the input string with the split command.
+    # There's a bit of craftiness here with the -1 parameter.  Normally split would
+    # behave no differently regardless of if the token lies at the very end of the 
+    # input buffer or not (i.e. a literal edge case)  Specifying -1 forces split to
+    # return "" in this case, meaning that the last entry in the list represents a
+    # new segment of data where the token has not been encountered
+    entities = data.split @delimiter, -1
+
+    # Check to see if the buffer has exceeded capacity, if we're imposing a limit
+    if @size_limit
+      raise 'input buffer full' if @input_size + entities.first.size > @size_limit
+      @input_size += entities.first.size
+    end
+    
+    # Move the first entry in the resulting array into the input buffer.  It represents
+    # the last segment of a token-delimited entity unless it's the only entry in the list.
+    @input << entities.shift
+
+    # If the resulting array from the split is empty, the token was not encountered
+    # (not even at the end of the buffer).  Since we've encountered no token-delimited
+    # entities this go-around, return an empty array.
+    return [] if entities.empty?
+
+    # At this point, we've hit a token, or potentially multiple tokens.  Now we can bring
+    # together all the data we've buffered from earlier calls without hitting a token,
+    # and add it to our list of discovered entities.
+    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.
+    # Multi-character token support.
+    # Split any tokens that were incomplete on the last iteration buf complete now.
+    entities.map! do |e|
+      e.split @delimiter, -1
+    end
+    # Flatten the resulting array.  This has the side effect of removing the empty
+    # entry at the end that was produced by passing -1 to split.  Add it again if
+    # necessary.
+    if (entities[-1] == [])
+      entities.flatten! << []
+    else
+      entities.flatten!
+    end
+=end
+
+    # Now that we've hit a token, joined the input buffer and added it to the entities
+    # list, we can go ahead and clear the input buffer.  All of the segments that were
+    # stored before the join can now be garbage collected.
+    @input.clear
+    
+    # The last entity in the list is not token delimited, however, thanks to the -1
+    # passed to split.  It represents the beginning of a new list of as-yet-untokenized  
+    # data, so we add it to the start of the list.
+    @input << entities.pop
+    
+    # Set the new input buffer size, provided we're keeping track
+    @input_size = @input.first.size if @size_limit
+
+    # Now we're left with the list of extracted token-delimited entities we wanted
+    # in the first place.  Hooray!
+    entities
+  end
+  
+  # Flush the contents of the input buffer, i.e. return the input buffer even though
+  # a token has not yet been encountered
+  def flush
+    buffer = @input.join
+    @input.clear
+    buffer
+  end
+
+  # Is the buffer empty?
+  def empty?
+    @input.empty?
+  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