eventmachine 0.12.0 → 0.12.2

data/lib/protocols/stomp.rb

@@ -1,4 +1,4 @@
-# $Id: stomp.rb 668 2008-01-04 23:00:34Z blackhedd $
+# $Id: stomp.rb 738 2008-07-06 01:01:04Z francis $
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -120,6 +120,9 @@ module EventMachine
 			def subscribe dest, ack=false
 				send_frame "SUBSCRIBE", {:destination=>dest, :ack=>(ack ? "client" : "auto")}
 			end
+			def ack msgid
+				send_frame "ACK", { :'message-id'=> msgid }
+			end
 
 		end
 	end

data/tests/test_attach.rb

@@ -0,0 +1,66 @@
+# $Id: test_attach.rb 785 2008-09-15 09:46:23Z francis $
+#
+#----------------------------------------------------------------------------
+#
+# 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.
+#
+#---------------------------------------------------------------------------
+#
+
+$:.unshift "../lib"
+require 'eventmachine'
+require 'socket'
+require 'test/unit'
+
+
+class TestAttach < Test::Unit::TestCase
+
+  Host = "127.0.0.1"
+  Port = 9550
+
+  class EchoServer < EM::Connection
+    def receive_data data
+      send_data data
+    end
+  end
+
+  class EchoClient < EM::Connection
+    def connection_completed
+      $sock.write("abc\n")
+    end
+
+    def notify_readable
+      $read = $sock.readline
+      $fd = detach
+    end
+
+    def unbind
+      EM.next_tick do
+        $sock.write("def\n")
+        EM.add_timer(0.5){ EM.stop }
+      end
+    end
+  end
+
+  def test_attach
+    EM.run{
+      EM.start_server Host, Port, EchoServer
+      $sock = TCPSocket.new Host, Port
+      EM.attach $sock, EchoClient
+    }
+
+    assert_equal $read, "abc\n"
+    assert_equal $fd, $sock.fileno
+    assert_equal false, $sock.closed?
+    assert_equal $sock.readline, "def\n"
+  end
+
+end

data/tests/test_basic.rb

@@ -1,4 +1,4 @@
-# $Id: test_basic.rb 668 2008-01-04 23:00:34Z blackhedd $
+# $Id: test_basic.rb 735 2008-07-05 18:18:49Z francis $
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -137,6 +137,42 @@ class TestBasic < Test::Unit::TestCase
 	  }
   end
 
-end
 
+  #------------------------------------
+  #
+  # TODO. This is an unfinished bug fix.
+  # This case was originally reported by Dan Aquino. If you throw a Ruby exception
+  # in a post_init handler, it gets rethrown as a confusing reactor exception.
+  # The problem is in eventmachine.rb, which calls post_init within the private
+  # initialize method of the EM::Connection class. This happens in both the EM::connect
+  # method and in the code that responds to connection-accepted events.
+  # What happens is that we instantiate the new connection object, which calls
+  # initialize, and then after initialize returns, we stick the new connection object
+  # into EM's @conns hashtable.
+  # But the problem is that Connection::initialize calls #post_init before it returns,
+  # and this may be user-written code that may throw an uncaught Ruby exception.
+  # If that happens, the reactor will abort, and it will then try to run down open
+  # connections. Because @conns never got a chance to properly reflect the new connection
+  # (because initialize never returned), we throw a ConnectionNotBound error
+  # (eventmachine.rb line 1080).
+  # When the bug is fixed, activate this test case.
+  #
+
+  class PostInitError < EM::Connection
+	  def post_init
+		  aaa bbb # should produce a Ruby exception
+	  end
+  end
+  def test_post_init_error
+	  assert_raise( NameError ) {
+		  EM.run {
+		  	EM::Timer.new(1) {EM.stop}
+			EM.start_server TestHost, TestPort
+			EM.connect TestHost, TestPort, PostInitError
+		  }
+	  }
+  end
+
+
+end
 

data/tests/test_hc.rb

@@ -1,4 +1,4 @@
-# $Id: test_hc.rb 668 2008-01-04 23:00:34Z blackhedd $
+# $Id: test_hc.rb 721 2008-06-21 00:45:57Z francis $
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -33,119 +33,157 @@ require 'test/unit'
 # Part of it is thread race conditions. I added some sleeps to make these
 # tests work. Native threads do strange things when you do I/O on them.
 #
+# And it's even worse in Java, where I/O on native threads doesn't seem
+# to be reliable at all.
+#
 
 
 class TestHeaderAndContentProtocol < Test::Unit::TestCase
 
-    TestHost = "127.0.0.1"
-    TestPort = 8905
+	TestHost = "127.0.0.1"
+	TestPort = 8905
 
 
-    #--------------------------------------------------------------------
+	#--------------------------------------------------------------------
 
-    class SimpleTest < EventMachine::Protocols::HeaderAndContentProtocol
-	attr_reader :first_header, :my_headers, :request
+	class SimpleTest < EventMachine::Protocols::HeaderAndContentProtocol
+		attr_reader :first_header, :my_headers, :request
 
-	def receive_first_header_line hdr
-	    @first_header ||= []
-	    @first_header << hdr
+		def receive_first_header_line hdr
+			@first_header ||= []
+			@first_header << hdr
+		end
+		def receive_headers hdrs
+			@my_headers ||= []
+			@my_headers << hdrs
+		end
+		def receive_request hdrs, content
+			@request ||= []
+			@request << [hdrs, content]
+		end
 	end
-	def receive_headers hdrs
-	    @my_headers ||= []
-	    @my_headers << hdrs
+
+
+	def test_no_content
+		Thread.abort_on_exception = true
+		the_connection = nil
+		EventMachine.run {
+			EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
+				the_connection = conn
+			end
+			EventMachine.add_timer(4) {raise "test timed out"}
+
+			pr = proc {
+				t = TCPSocket.new TestHost, TestPort
+				t.write [ "aaa\n", "bbb\r\n", "ccc\n", "\n" ].join
+				t.close
+			}
+
+			if RUBY_PLATFORM =~ /java/i
+				pr.call
+				EM.add_timer(0.5) {EM.stop}
+			else
+				EventMachine.defer proc {
+					pr.call
+					if RUBY_VERSION =~ /\A1\.9\./
+						sleep 0.1
+						STDERR.puts "Introducing extraneous sleep for Ruby 1.9"
+					end
+				}, proc {
+					EventMachine.stop
+				}
+			end
+		}
+		assert_equal( ["aaa"], the_connection.first_header )
+		assert_equal( [%w(aaa bbb ccc)], the_connection.my_headers )
+		assert_equal( [[%w(aaa bbb ccc), ""]], the_connection.request )
 	end
-	def receive_request hdrs, content
-	    @request ||= []
-	    @request << [hdrs, content]
+
+
+
+
+	def test_content
+		Thread.abort_on_exception = true
+		the_connection = nil
+		content = "A" * 50
+		headers = ["aaa", "bbb", "Content-length: #{content.length}", "ccc"]
+		EventMachine.run {
+			EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
+				the_connection = conn
+			end
+			EventMachine.add_timer(4) {raise "test timed out"}
+
+			pr = proc {
+				t = TCPSocket.new TestHost, TestPort
+				headers.each {|h| t.write "#{h}\r\n" }
+				t.write "\n"
+				t.write content
+				t.close
+			}
+
+			if RUBY_PLATFORM =~ /java/i
+				# I/O on threads seems completely unreliable in Java.
+				pr.call
+				EM.add_timer(0.5) {EM.stop}
+			else
+				EventMachine.defer proc {
+					pr.call
+					if RUBY_VERSION =~ /\A1\.9\./
+						sleep 0.1
+						STDERR.puts "Introducing extraneous sleep for Ruby 1.9"
+					end
+				}, proc {
+					EM.stop
+				}
+			end
+		}
+		assert_equal( ["aaa"], the_connection.first_header )
+		assert_equal( [headers], the_connection.my_headers )
+		assert_equal( [[headers, content]], the_connection.request )
 	end
-    end
 
-    def test_no_content
-	Thread.abort_on_exception = true
-	the_connection = nil
-	EventMachine.run {
-	    EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
-		the_connection = conn
-	    end
-	    EventMachine.add_timer(4) {raise "test timed out"}
-	    EventMachine.defer proc {
-		t = TCPSocket.new TestHost, TestPort
-		t.write [
-		    "aaa\n", "bbb\r\n", "ccc\n", "\n"
-		].join
-		t.close
-		if RUBY_VERSION =~ /\A1\.9\./
-			sleep 0.1
-			STDERR.puts "Introducing extraneous sleep for Ruby 1.9"
-		end
-	    }, proc {
-		EventMachine.stop
-	    }
-	}
-	assert_equal( ["aaa"], the_connection.first_header )
-	assert_equal( [%w(aaa bbb ccc)], the_connection.my_headers )
-	assert_equal( [[%w(aaa bbb ccc), ""]], the_connection.request )
-    end
 
-    def test_content
-	Thread.abort_on_exception = true
-	the_connection = nil
-	content = "A" * 50
-	headers = ["aaa", "bbb", "Content-length: #{content.length}", "ccc"]
-	EventMachine.run {
-	    EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
-		the_connection = conn
-	    end
-	    EventMachine.add_timer(4) {raise "test timed out"}
-	    EventMachine.defer proc {
-		t = TCPSocket.new TestHost, TestPort
-		headers.each {|h| t.write "#{h}\r\n" }
-		t.write "\n"
-		t.write content
-		t.close
-		if RUBY_VERSION =~ /\A1\.9\./
-			sleep 0.1
-			STDERR.puts "Introducing extraneous sleep for Ruby 1.9"
-		end
-	    }, proc {
-		EM.stop
-	    }
-	}
-	assert_equal( ["aaa"], the_connection.first_header )
-	assert_equal( [headers], the_connection.my_headers )
-	assert_equal( [[headers, content]], the_connection.request )
-    end
 
-    def test_several_requests
-	Thread.abort_on_exception = true
-	the_connection = nil
-	content = "A" * 50
-	headers = ["aaa", "bbb", "Content-length: #{content.length}", "ccc"]
-	EventMachine.run {
-	    EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
-		the_connection = conn
-	    end
-	    EventMachine.add_timer(4) {raise "test timed out"}
-	    EventMachine.defer proc {
-		t = TCPSocket.new TestHost, TestPort
-		5.times {
-		    headers.each {|h| t.write "#{h}\r\n" }
-		    t.write "\n"
-		    t.write content
+	def test_several_requests
+		Thread.abort_on_exception = true
+		the_connection = nil
+		content = "A" * 50
+		headers = ["aaa", "bbb", "Content-length: #{content.length}", "ccc"]
+		EventMachine.run {
+			EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
+				the_connection = conn
+			end
+			EventMachine.add_timer(4) {raise "test timed out"}
+
+			pr = proc {
+				t = TCPSocket.new TestHost, TestPort
+				5.times {
+					headers.each {|h| t.write "#{h}\r\n" }
+					t.write "\n"
+					t.write content
+				}
+				t.close
+			}
+
+			if RUBY_PLATFORM =~ /java/i
+				pr.call
+				EM.add_timer(1) {EM.stop}
+			else
+				EventMachine.defer proc {
+					pr.call
+					if RUBY_VERSION =~ /\A1\.9\./
+						sleep 0.1
+						STDERR.puts "Introducing extraneous sleep for Ruby 1.9"
+					end
+				}, proc {
+					EventMachine.stop
+				}
+			end
 		}
-		t.close
-		if RUBY_VERSION =~ /\A1\.9\./
-			sleep 0.1
-			STDERR.puts "Introducing extraneous sleep for Ruby 1.9"
-		end
-	    }, proc {
-		EventMachine.stop
-	    }
-	}
-	assert_equal( ["aaa"] * 5, the_connection.first_header )
-	assert_equal( [headers] * 5, the_connection.my_headers )
-	assert_equal( [[headers, content]] * 5, the_connection.request )
-    end
+		assert_equal( ["aaa"] * 5, the_connection.first_header )
+		assert_equal( [headers] * 5, the_connection.my_headers )
+		assert_equal( [[headers, content]] * 5, the_connection.request )
+	end
 
 
     def x_test_multiple_content_length_headers
@@ -171,50 +209,60 @@ class TestHeaderAndContentProtocol < Test::Unit::TestCase
 	}
     end
 
-    def test_interpret_headers
-	Thread.abort_on_exception = true
-	the_connection = nil
-	content = "A" * 50
-	headers = [
-	    "GET / HTTP/1.0",
-	    "Accept: aaa",
-	    "User-Agent: bbb",
-	    "Host:	    ccc",
-	    "x-tempest-header:ddd"
-	]
-	EventMachine.run {
-	    EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
-		the_connection = conn
-	    end
-	    EventMachine.add_timer(4) {raise "test timed out"}
-	    EventMachine.defer proc {
-		t = TCPSocket.new TestHost, TestPort
-		headers.each {|h| t.write "#{h}\r\n" }
-		t.write "\n"
-		t.write content
-		t.close
-		if RUBY_VERSION =~ /\A1\.9\./
-			sleep 0.1
-			STDERR.puts "Introducing extraneous sleep for Ruby 1.9"
-		end
-	    }, proc {
-		EventMachine.stop
-	    }
-	}
+	def test_interpret_headers
+		Thread.abort_on_exception = true
+		the_connection = nil
+		content = "A" * 50
+		headers = [
+			"GET / HTTP/1.0",
+			"Accept: aaa",
+			"User-Agent: bbb",
+			"Host:	    ccc",
+			"x-tempest-header:ddd"
+		]
 
-	hsh = the_connection.headers_2_hash( the_connection.my_headers.shift )
-	assert_equal(
-	    {
-		:accept => "aaa",
-		:user_agent => "bbb",
-		:host => "ccc",
-		:x_tempest_header => "ddd"
-	    },
-	    hsh
-	 )
-    end
+		EventMachine.run {
+			EventMachine.start_server( TestHost, TestPort, SimpleTest ) do |conn|
+				the_connection = conn
+			end
+			EventMachine.add_timer(4) {raise "test timed out"}
+
+			pr = proc {
+				t = TCPSocket.new TestHost, TestPort
+				headers.each {|h| t.write "#{h}\r\n" }
+				t.write "\n"
+				t.write content
+				t.close
+			}
+
+			if RUBY_PLATFORM =~ /java/i
+				pr.call
+				EM.add_timer(0.5) {EM.stop}
+			else
+				EventMachine.defer proc {
+					pr.call
+					if RUBY_VERSION =~ /\A1\.9\./
+						sleep 0.1
+						STDERR.puts "Introducing extraneous sleep for Ruby 1.9"
+					end
+				}, proc {
+					EventMachine.stop
+				}
+			end
+		}
+
+		hsh = the_connection.headers_2_hash( the_connection.my_headers.shift )
+		assert_equal(
+			{
+				:accept => "aaa",
+				:user_agent => "bbb",
+				:host => "ccc",
+				:x_tempest_header => "ddd"
+			},
+			hsh
+		)
+	end
 
-    #--------------------------------------------------------------------
 
 end