eventmachine 0.9.0 → 0.10.0

data/ext/pipe.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: pipe.cpp 494 2007-08-15 06:23:09Z blackhedd $
+$Id: pipe.cpp 585 2007-11-27 14:29:34Z blackhedd $
 
 File:     pipe.cpp
 Date:     30May07
@@ -71,15 +71,32 @@ PipeDescriptor::~PipeDescriptor()
 	 * Since we want to have a signal processor integrated into the
 	 * client-visible API, let's wait until that is done before cleaning
 	 * this up.
+	 *
+	 * Added a very ugly hack to support passing the subprocess's exit
+	 * status to the user. It only makes logical sense for user code to access
+	 * the subprocess exit status in the unbind callback. But unbind is called
+	 * back during the EventableDescriptor destructor. So by that time there's
+	 * no way to call back this object through an object binding, because it's
+	 * already been cleaned up. We might have added a parameter to the unbind
+	 * callback, but that would probably break a huge amount of existing code.
+	 * So the hack-solution is to define an instance variable in the EventMachine
+	 * object and stick the exit status in there, where it can easily be accessed
+	 * with an accessor visible to user code.
+	 * User code should ONLY access the exit status from within the unbind callback.
+	 * Otherwise there's no guarantee it'll be valid.
+	 * This hack won't make it impossible to run multiple EventMachines in a single
+	 * process, but it will make it impossible to reliably nest unbind calls
+	 * within other unbind calls. (Not sure if that's even possible.)
 	 */
 
 	struct timespec req = {0, 10000000};
 	kill (SubprocessPid, SIGTERM);
 	nanosleep (&req, NULL);
-	if (waitpid (SubprocessPid, NULL, WNOHANG) == 0) {
+	assert (MyEventMachine);
+	if (waitpid (SubprocessPid, &(MyEventMachine->SubprocessExitStatus), WNOHANG) == 0) {
 		kill (SubprocessPid, SIGKILL);
 		nanosleep (&req, NULL);
-		if (waitpid (SubprocessPid, NULL, WNOHANG) == 0)
+		if (waitpid (SubprocessPid, &(MyEventMachine->SubprocessExitStatus), WNOHANG) == 0)
 			throw std::runtime_error ("unable to reap subprocess");
 	}
 }
@@ -302,5 +319,6 @@ bool PipeDescriptor::GetSubprocessPid (pid_t *pid)
 	return ok;
 }
 
+
 #endif // OS_UNIX
 

data/ext/rubymain.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: rubymain.cpp 502 2007-08-24 09:29:53Z blackhedd $
+$Id: rubymain.cpp 584 2007-11-27 07:27:32Z blackhedd $
 
 File:     rubymain.cpp
 Date:     06Apr06
@@ -181,6 +181,20 @@ static VALUE t_get_subprocess_pid (VALUE self, VALUE signature)
 	return Qnil;
 }
 
+/***********************
+t_get_subprocess_status
+***********************/
+
+static VALUE t_get_subprocess_status (VALUE self, VALUE signature)
+{
+	int status;
+	if (evma_get_subprocess_status (StringValuePtr (signature), &status)) {
+		return INT2NUM (status);
+	}
+
+	return Qnil;
+}
+
 /*****************************
 t_get_comm_inactivity_timeout
 *****************************/
@@ -227,6 +241,16 @@ static VALUE t_close_connection (VALUE self, VALUE signature, VALUE after_writin
 	return Qnil;
 }
 
+/********************************
+t_report_connection_error_status
+********************************/
+
+static VALUE t_report_connection_error_status (VALUE self, VALUE signature)
+{
+	int b = evma_report_connection_error_status (StringValuePtr (signature));
+	return INT2NUM (b);
+}
+
 
 
 /****************
@@ -323,6 +347,16 @@ static VALUE t_set_timer_quantum (VALUE self, VALUE interval)
   return Qnil;
 }
 
+/********************
+t_set_max_timer_count
+********************/
+
+static VALUE t_set_max_timer_count (VALUE self, VALUE ct)
+{
+  evma_set_max_timer_count (FIX2INT (ct));
+  return Qnil;
+}
+
 /***************
 t_setuid_string
 ***************/
@@ -485,6 +519,7 @@ extern "C" void Init_rubyeventmachine()
 	rb_define_module_function (EmModule, "send_data", (VALUE(*)(...))t_send_data, 3);
 	rb_define_module_function (EmModule, "send_datagram", (VALUE(*)(...))t_send_datagram, 5);
 	rb_define_module_function (EmModule, "close_connection", (VALUE(*)(...))t_close_connection, 2);
+	rb_define_module_function (EmModule, "report_connection_error_status", (VALUE(*)(...))t_report_connection_error_status, 1);
 	rb_define_module_function (EmModule, "connect_server", (VALUE(*)(...))t_connect_server, 2);
 	rb_define_module_function (EmModule, "connect_unix_server", (VALUE(*)(...))t_connect_unix_server, 1);
 	rb_define_module_function (EmModule, "open_udp_socket", (VALUE(*)(...))t_open_udp_socket, 2);
@@ -494,6 +529,7 @@ extern "C" void Init_rubyeventmachine()
 	rb_define_module_function (EmModule, "signal_loopbreak", (VALUE(*)(...))t_signal_loopbreak, 0);
 	rb_define_module_function (EmModule, "library_type", (VALUE(*)(...))t_library_type, 0);
 	rb_define_module_function (EmModule, "set_timer_quantum", (VALUE(*)(...))t_set_timer_quantum, 1);
+	rb_define_module_function (EmModule, "set_max_timer_count", (VALUE(*)(...))t_set_max_timer_count, 1);
 	rb_define_module_function (EmModule, "setuid_string", (VALUE(*)(...))t_setuid_string, 1);
 	rb_define_module_function (EmModule, "invoke_popen", (VALUE(*)(...))t_invoke_popen, 1);
 	rb_define_module_function (EmModule, "send_file_data", (VALUE(*)(...))t_send_file_data, 2);
@@ -503,6 +539,7 @@ extern "C" void Init_rubyeventmachine()
 
 	rb_define_module_function (EmModule, "get_peername", (VALUE(*)(...))t_get_peername, 1);
 	rb_define_module_function (EmModule, "get_subprocess_pid", (VALUE(*)(...))t_get_subprocess_pid, 1);
+	rb_define_module_function (EmModule, "get_subprocess_status", (VALUE(*)(...))t_get_subprocess_status, 1);
 	rb_define_module_function (EmModule, "get_comm_inactivity_timeout", (VALUE(*)(...))t_get_comm_inactivity_timeout, 1);
 	rb_define_module_function (EmModule, "set_comm_inactivity_timeout", (VALUE(*)(...))t_set_comm_inactivity_timeout, 2);
 	rb_define_module_function (EmModule, "set_rlimit_nofile", (VALUE(*)(...))t_set_rlimit_nofile, 1);

data/ext/ssl.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: ssl.cpp 498 2007-08-15 14:03:32Z blackhedd $
+$Id: ssl.cpp 574 2007-11-19 23:36:04Z blackhedd $
 
 File:     ssl.cpp
 Date:     30Apr06
@@ -155,9 +155,15 @@ SslContext_t::SslContext_t (bool is_server, const string &privkeyfile, const str
 	if (is_server) {
 		// The SSL_CTX calls here do NOT allocate memory.
 		int e;
-		e = SSL_CTX_use_PrivateKey (pCtx, DefaultPrivateKey);
+		if (privkeyfile.length() > 0)
+			e = SSL_CTX_use_PrivateKey_file (pCtx, privkeyfile.c_str(), SSL_FILETYPE_PEM);
+		else
+			e = SSL_CTX_use_PrivateKey (pCtx, DefaultPrivateKey);
 		assert (e > 0);
-		e = SSL_CTX_use_certificate (pCtx, DefaultCertificate);
+		if (certchainfile.length() > 0)
+			e = SSL_CTX_use_certificate_chain_file (pCtx, certchainfile.c_str());
+		else
+			e = SSL_CTX_use_certificate (pCtx, DefaultCertificate);
 		assert (e > 0);
 	}
 

data/lib/em/streamer.rb

@@ -1,4 +1,4 @@
-# $Id: streamer.rb 476 2007-07-27 03:32:51Z blackhedd $
+# $Id: streamer.rb 599 2007-12-05 14:24:11Z blackhedd $
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -49,7 +49,6 @@ module EventMachine
 
 		def stream_without_mapping filename
 			if @http_chunks
-				#@connection.send_data "#{format("%x",@size)}\r\n"
 				@connection.send_data "#{@size.to_s(16)}\r\n"
 				@connection.send_file_data filename
 				@connection.send_data "\r\n0\r\n\r\n"
@@ -79,7 +78,6 @@ module EventMachine
 						len = @size - @position
 						len = ChunkSize if (len > ChunkSize)
 
-						#@connection.send_data( "#{format("%x",len)}\r\n" ) if @http_chunks
 						@connection.send_data( "#{len.to_s(16)}\r\n" ) if @http_chunks
 						@connection.send_data( @mapping.get_chunk( @position, len ))
 						@connection.send_data("\r\n") if @http_chunks

data/lib/eventmachine.rb

@@ -1,4 +1,4 @@
-# $Id: eventmachine.rb 521 2007-09-04 18:22:07Z blackhedd $
+# $Id: eventmachine.rb 594 2007-12-05 11:41:39Z blackhedd $
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -32,6 +32,14 @@
 # till now. The reason I'm disabling it is because the pure-Ruby
 # code will have problems of its own, and it's not nearly as fast
 # anyway. Suggested by a problem report from Moshe Litvin. 05Jun07.
+#
+# 05Dec07: Re-enabled the pure-ruby mechanism, but without the automatic
+# fallback feature that tripped up Moshe Litvin. We shouldn't fail over to
+# the pure Ruby version because it's possible that the user intended to
+# run the extension but failed to do so because of a compilation or
+# similar error. So we require either a global variable or an environment
+# string be set in order to select the pure-Ruby version.
+#
 
 =begin
 $eventmachine_library ||= nil
@@ -56,7 +64,11 @@ if RUBY_PLATFORM =~ /java/
 	require 'java'
 	require 'jeventmachine'
 else
-	require 'rubyeventmachine'
+	if $eventmachine_library == :pure_ruby or ENV['EVENTMACHINE_LIBRARY'] == "pure_ruby"
+		require 'pr_eventmachine'
+	else
+		require 'rubyeventmachine'
+	end
 end
 
 
@@ -153,17 +165,6 @@ require 'shellwords'
 #
 #
 # == Questions and Futures
-# Encryption: EventMachine needs the capability to run SSL/TLS on any
-# of its clients and servers. Coming soon.
-#
-# <tt>epoll(4):</tt> EventMachine currently is based on the <tt>select(2)</tt>
-# system call in order to be compatible with the widest variety of platforms,
-# but it would be interesting to re-base it on <tt>epoll(4).</tt>
-# While requiring a Linux 2.6 kernel, this might possibly give much better
-# performance and scalability. EventMachine's C++ antecedents already work
-# with <tt>kqueue</tt> from the BSD world, but it's not yet clear that this
-# is worth doing. Depends on how many people ask for it.
-#
 # Would it be useful for EventMachine to incorporate the Observer pattern
 # and make use of the corresponding Ruby <tt>observer</tt> package?
 # Interesting thought.
@@ -483,15 +484,21 @@ module EventMachine
   #  }
   #  
   #
-  def EventMachine::start_server server, port, handler=nil, &block
+  def EventMachine::start_server server, port, handler=nil, *args, &block
     klass = if (handler and handler.is_a?(Class))
       handler
     else
       Class.new( Connection ) {handler and include handler}
     end
 
+    arity = klass.instance_method(:initialize).arity
+    expected = arity >= 0 ? arity : -(arity + 1)
+    if (arity >= 0 and args.size != expected) or (arity < 0 and args.size < expected)
+      raise ArgumentError, "wrong number of arguments for #{klass}#initialize (#{args.size} for #{expected})" 
+    end
+
     s = start_tcp_server server, port
-    @acceptors[s] = [klass,block]
+    @acceptors[s] = [klass,args,block]
     s
   end
 
@@ -505,15 +512,21 @@ module EventMachine
 	  EventMachine::stop_tcp_server signature
   end
 
-  def EventMachine::start_unix_domain_server filename, handler=nil, &block
+  def EventMachine::start_unix_domain_server filename, handler=nil, *args, &block
     klass = if (handler and handler.is_a?(Class))
       handler
     else
       Class.new( Connection ) {handler and include handler}
     end
 
+    arity = klass.instance_method(:initialize).arity
+    expected = arity >= 0 ? arity : -(arity + 1)
+    if (arity >= 0 and args.size != expected) or (arity < 0 and args.size < expected)
+      raise ArgumentError, "wrong number of arguments for #{klass}#initialize (#{args.size} for #{expected})" 
+    end
+
     s = start_unix_server filename
-    @acceptors[s] = [klass,block]
+    @acceptors[s] = [klass,args,block]
   end
 
   # EventMachine#connect initiates a TCP connection to a remote
@@ -613,16 +626,21 @@ module EventMachine
   # to have them behave differently with respect to post_init
   # if at all possible.
   #
-  def EventMachine::connect server, port, handler=nil
-
+  def EventMachine::connect server, port, handler=nil, *args
     klass = if (handler and handler.is_a?(Class))
       handler
     else
       Class.new( Connection ) {handler and include handler}
     end
 
+    arity = klass.instance_method(:initialize).arity
+    expected = arity >= 0 ? arity : -(arity + 1)
+    if (arity >= 0 and args.size != expected) or (arity < 0 and args.size < expected)
+      raise ArgumentError, "wrong number of arguments for #{klass}#initialize (#{args.size} for #{expected})"
+    end
+
     s = connect_server server, port
-    c = klass.new s
+    c = klass.new s, *args
     @conns[s] = c
     block_given? and yield c
     c
@@ -668,15 +686,21 @@ module EventMachine
 	# For making connections to Unix-domain sockets.
 	# Eventually this has to get properly documented and unified with the TCP-connect methods.
 	# Note how nearly identical this is to EventMachine#connect
-	def EventMachine::connect_unix_domain socketname, handler=nil
+	def EventMachine::connect_unix_domain socketname, handler=nil, *args
 		klass = if (handler and handler.is_a?(Class))
 			handler
 		else
 			Class.new( Connection ) {handler and include handler}
 		end
 
+    arity = klass.instance_method(:initialize).arity
+    expected = arity >= 0 ? arity : -(arity + 1)
+    if (arity >= 0 and args.size != expected) or (arity < 0 and args.size < expected)
+      raise ArgumentError, "wrong number of arguments for #{klass}#initialize (#{args.size} for #{expected})"
+    end
+
 		s = connect_unix_server socketname
-		c = klass.new s
+		c = klass.new s, *args
 		@conns[s] = c
 		block_given? and yield c
 		c
@@ -746,15 +770,21 @@ module EventMachine
 	# Replaced the implementation on 01Oct06. Thanks to Tobias Gustafsson for pointing
 	# out that this originally did not take a class but only a module.
 	#
-	def self::open_datagram_socket address, port, handler=nil
+	def self::open_datagram_socket address, port, handler=nil, *args
 		klass = if (handler and handler.is_a?(Class))
 			handler
 		else
 			Class.new( Connection ) {handler and include handler}
 		end
 
+    arity = klass.instance_method(:initialize).arity
+    expected = arity >= 0 ? arity : -(arity + 1)
+    if (arity >= 0 and args.size != expected) or (arity < 0 and args.size < expected)
+      raise ArgumentError, "wrong number of arguments for #{klass}#initialize (#{args.size} for #{expected})"
+    end
+
 		s = open_udp_socket address, port
-		c = klass.new s
+		c = klass.new s, *args
 		@conns[s] = c
 		block_given? and yield c
 		c
@@ -777,6 +807,14 @@ module EventMachine
 		set_timer_quantum mills.to_i
 	end
 
+	# Sets the maximum number of timers and periodic timers that may be outstanding at any
+	# given time. You only need to call #set_max_timers if you need more than the default
+	# number of timers, which on most platforms is 1000.
+	# Call this method before calling EventMachine#run.
+	#
+	def self::set_max_timers ct
+		set_max_timer_count ct
+	end
 
 	#--
 	# The is the responder for the loopback-signalled event.
@@ -1007,36 +1045,97 @@ module EventMachine
 
 	private
 	def EventMachine::event_callback conn_binding, opcode, data
+		#
+		# Added 03Oct07: Any code path that invokes user-written code must
+		# wrap itself in a begin/rescue for RuntimeErrors, that calls the
+		# user-overridable class method #handle_runtime_error.
+		#
 		if opcode == ConnectionData
 			c = @conns[conn_binding] or raise ConnectionNotBound
-			c.receive_data data
+			begin
+				c.receive_data data
+			rescue
+				EventMachine.handle_runtime_error
+			end
 		elsif opcode == ConnectionUnbound
 			if c = @conns.delete( conn_binding )
-				c.unbind
+				begin
+					c.unbind
+				rescue
+					EventMachine.handle_runtime_error
+				end
 			elsif c = @acceptors.delete( conn_binding )
 				# no-op
 			else
 				raise ConnectionNotBound
 			end
 		elsif opcode == ConnectionAccepted
-			accep,blk = @acceptors[conn_binding]
+			accep,args,blk = @acceptors[conn_binding]
 			raise NoHandlerForAcceptedConnection unless accep
-			c = accep.new data
+			c = accep.new data, *args
 			@conns[data] = c
-			blk and blk.call(c)
+			begin
+				blk and blk.call(c)
+			rescue
+				EventMachine.handle_runtime_error
+			end
 			c # (needed?)
 		elsif opcode == TimerFired
 			t = @timers.delete( data ) or raise UnknownTimerFired
-			t.call
+			begin
+				t.call
+			rescue
+				EventMachine.handle_runtime_error
+			end
 		elsif opcode == ConnectionCompleted
 			c = @conns[conn_binding] or raise ConnectionNotBound
-			c.connection_completed
+			begin
+				c.connection_completed
+			rescue
+				EventMachine.handle_runtime_error
+			end
 		elsif opcode == LoopbreakSignalled
+			begin
 			run_deferred_callbacks
+			rescue
+				EventMachine.handle_runtime_error
+			end
 		end
 	end
 
 
+	# Default handler for RuntimeErrors that are raised in user code.
+	# The default behavior is to re-raise the error, which ends your program.
+	# To override the default behavior, re-implement this method in your code.
+	# For example:
+	#
+	#  module EventMachine
+	#    def self.handle_runtime_error
+	#      $>.puts $!
+	#    end
+	#  end
+	#
+	#--
+	# We need to ensure that any code path which invokes user code rescues RuntimeError
+	# and calls this method. The obvious place to do that is in #event_callback,
+	# but, scurrilously, it turns out that we need to be finer grained that that.
+	# Periodic timers, in particular, wrap their invocations of user code inside
+	# procs that do other stuff we can't not do, like schedule the next invocation.
+	# This is a potential non-robustness, since we need to remember to hook in the
+	# error handler whenever and wherever we change how user code is invoked.
+	#
+	def EventMachine::handle_runtime_error
+		@runtime_error_hook ? @runtime_error_hook.call : raise
+	end
+
+	# Sets a handler for RuntimeErrors that are raised in user code.
+	# Pass a block with no parameters. You can also call this method without a block,
+	# which restores the default behavior (see #handle_runtime_error).
+	#
+	def EventMachine::set_runtime_error_hook &blk
+		@runtime_error_hook = blk
+	end
+
   # Documentation stub
   #--
   # This is a provisional implementation of a stream-oriented file access object.
@@ -1083,14 +1182,33 @@ module EventMachine
 # only by user code.
 #
 class Connection
-
 	# EXPERIMENTAL. Added the reconnect methods, which may go away.
 	attr_accessor :signature
 
-	def initialize sig #:nodoc:
-		@signature = sig
-		post_init
-	end
+  # Override .new so subclasses don't have to call super and can ignore
+  # connection-specific arguments
+  #
+  def self.new sig, *args #:nodoc:
+    allocate.instance_eval do
+      # Call a superclass's #initialize if it has one
+      initialize *args
+
+      # Store signature and run #post_init
+      @signature = sig
+      begin
+        post_init
+      rescue
+        EventMachine::handle_runtime_error
+      end
+    
+      self
+    end
+  end
+
+  # Stubbed initialize so legacy superclasses can safely call super
+  #
+	def initialize(*args) #:nodoc:
+  end
 
 	# EventMachine::Connection#post_init is called by the event loop
 	# immediately after the network connection has been established,
@@ -1207,6 +1325,17 @@ class Connection
 		EventMachine::send_data @signature, data, data.length
 	end
 
+	# Returns true if the connection is in an error state, false otherwise.
+	# In general, you can detect the occurrence of communication errors or unexpected
+	# disconnection by the remote peer by handing the #unbind method. In some cases, however,
+	# it's useful to check the status of the connection using #error? before attempting to send data.
+	# This function is synchronous: it will return immediately without blocking.
+	#
+	#
+	def error?
+		EventMachine::report_connection_error_status(@signature) != 0
+	end
+
 	# #connection_completed is called by the event loop when a remote TCP connection
 	# attempt completes successfully. You can expect to get this notification after calls
 	# to EventMachine#connect. Remember that EventMachine makes remote connections
@@ -1273,10 +1402,13 @@ class Connection
 	# but to be really safe, send messages smaller than the Ethernet-packet
 	# size (typically about 1400 bytes). Some very restrictive WANs
 	# will either drop or truncate packets larger than about 500 bytes.
+	#--
+	# Added the Integer wrapper around the port parameter per suggestion by
+	# Matthieu Riou, after he passed a String and spent hours tearing his hair out.
 	#
 	def send_datagram data, recipient_address, recipient_port
 		data = data.to_s
-		EventMachine::send_datagram @signature, data, data.length, recipient_address, recipient_port
+		EventMachine::send_datagram @signature, data, data.length, recipient_address, Integer(recipient_port)
 	end
 
 
@@ -1298,6 +1430,13 @@ class Connection
 		EventMachine::get_subprocess_pid @signature
 	end
 
+	# Returns a subprocess exit status. Only useful for #popen. Call it in your
+	# #unbind handler.
+	#
+	def get_status
+		EventMachine::get_subprocess_status @signature
+	end
+
 	# comm_inactivity_timeout returns the current value (in seconds) of the inactivity-timeout
 	# property of network-connection and datagram-socket objects. A nonzero value
 	# indicates that the connection or socket will automatically be closed if no read or write
@@ -1373,7 +1512,11 @@ class Connection
 			EventMachine::add_timer @interval, proc {self.fire}
 		end
 		def fire
-			@code.call
+			begin
+				@code.call
+			rescue
+				EventMachine::handle_runtime_error
+			end
 			schedule unless @cancelled
 		end
 		def cancel
@@ -1398,6 +1541,10 @@ class Connection
 
 end
 
+module Protocols
+	# In this module, we define standard protocol implementations.
+	# They get included from separate source files.
+end
 
 end # module EventMachine
 
@@ -1405,6 +1552,7 @@ end # module EventMachine
 
 # Save everyone some typing.
 EM = EventMachine
+EM::P = EventMachine::Protocols
 
 
 # At the bottom of this module, we load up protocol handlers that depend on some
@@ -1417,7 +1565,11 @@ require 'protocols/httpclient'
 require 'protocols/line_and_text'
 require 'protocols/header_and_content'
 require 'protocols/linetext2'
+require 'protocols/httpcli2'
 require 'protocols/stomp'
 require 'protocols/smtpclient'
 require 'protocols/smtpserver'
+require 'protocols/saslauth'
+
+