eventmachine 0.8.1 → 0.9.0

data/ext/pipe.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: pipe.cpp 401 2007-07-11 12:54:06Z blackhedd $
+$Id: pipe.cpp 494 2007-08-15 06:23:09Z blackhedd $
 
 File:     pipe.cpp
 Date:     30May07
@@ -27,12 +27,11 @@ See the file COPYING for complete licensing information.
 PipeDescriptor::PipeDescriptor
 ******************************/
 
-PipeDescriptor::PipeDescriptor (FILE *fp, pid_t subpid, EventMachine_t *parent_em):
-	EventableDescriptor (fileno (fp), parent_em),
+PipeDescriptor::PipeDescriptor (int fd, pid_t subpid, EventMachine_t *parent_em):
+	EventableDescriptor (fd, parent_em),
 	bReadAttemptedAfterClose (false),
 	LastIo (gCurrentLoopTime),
 	InactivityTimeout (0),
-	//MyStream (fp),
 	OutboundDataSize (0),
 	SubprocessPid (subpid)
 {

data/ext/rubymain.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: rubymain.cpp 476 2007-07-27 03:32:51Z blackhedd $
+$Id: rubymain.cpp 502 2007-08-24 09:29:53Z blackhedd $
 
 File:     rubymain.cpp
 Date:     06Apr06
@@ -138,6 +138,21 @@ static VALUE t_start_tls (VALUE self, VALUE signature)
 	return Qnil;
 }
 
+/***************
+t_set_tls_parms
+***************/
+
+static VALUE t_set_tls_parms (VALUE self, VALUE signature, VALUE privkeyfile, VALUE certchainfile)
+{
+	/* set_tls_parms takes a series of positional arguments for specifying such things
+	 * as private keys and certificate chains.
+	 * It's expected that the parameter list will grow as we add more supported features.
+	 * ALL of these parameters are optional, and can be specified as empty or NULL strings.
+	 */
+	evma_set_tls_parms (StringValuePtr (signature), StringValuePtr (privkeyfile), StringValuePtr (certchainfile) );
+	return Qnil;
+}
+
 /**************
 t_get_peername
 **************/
@@ -361,6 +376,19 @@ static VALUE t_invoke_popen (VALUE self, VALUE cmd)
 }
 
 
+/***************
+t_read_keyboard
+***************/
+
+static VALUE t_read_keyboard (VALUE self)
+{
+	const char *f = evma_open_keyboard();
+	if (!f || !*f)
+		rb_raise (rb_eRuntimeError, "no keyboard reader");
+	return rb_str_new2 (f);
+}
+
+
 /********
 t__epoll
 ********/
@@ -452,6 +480,7 @@ extern "C" void Init_rubyeventmachine()
 	rb_define_module_function (EmModule, "start_tcp_server", (VALUE(*)(...))t_start_server, 2);
 	rb_define_module_function (EmModule, "stop_tcp_server", (VALUE(*)(...))t_stop_server, 1);
 	rb_define_module_function (EmModule, "start_unix_server", (VALUE(*)(...))t_start_unix_server, 1);
+	rb_define_module_function (EmModule, "set_tls_parms", (VALUE(*)(...))t_set_tls_parms, 3);
 	rb_define_module_function (EmModule, "start_tls", (VALUE(*)(...))t_start_tls, 1);
 	rb_define_module_function (EmModule, "send_data", (VALUE(*)(...))t_send_data, 3);
 	rb_define_module_function (EmModule, "send_datagram", (VALUE(*)(...))t_send_datagram, 5);
@@ -459,6 +488,7 @@ extern "C" void Init_rubyeventmachine()
 	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);
+	rb_define_module_function (EmModule, "read_keyboard", (VALUE(*)(...))t_read_keyboard, 0);
 	rb_define_module_function (EmModule, "release_machine", (VALUE(*)(...))t_release_machine, 0);
 	rb_define_module_function (EmModule, "stop", (VALUE(*)(...))t_stop, 0);
 	rb_define_module_function (EmModule, "signal_loopbreak", (VALUE(*)(...))t_signal_loopbreak, 0);

data/ext/ssl.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: ssl.cpp 318 2007-05-22 22:06:24Z blackhedd $
+$Id: ssl.cpp 498 2007-08-15 14:03:32Z blackhedd $
 
 File:     ssl.cpp
 Date:     30Apr06
@@ -120,11 +120,19 @@ static void InitializeDefaultCredentials()
 SslContext_t::SslContext_t
 **************************/
 
-SslContext_t::SslContext_t (bool is_server):
+SslContext_t::SslContext_t (bool is_server, const string &privkeyfile, const string &certchainfile):
 	pCtx (NULL),
 	PrivateKey (NULL),
 	Certificate (NULL)
 {
+	/* TODO: the usage of the specified private-key and cert-chain filenames only applies to
+	 * client-side connections at this point. Server connections currently use the default materials.
+	 * That needs to be fixed asap.
+	 * Also, in this implementation, server-side connections use statically defined X-509 defaults.
+	 * One thing I'm really not clear on is whether or not you have to explicitly free X509 and EVP_PKEY
+	 * objects when we call our destructor, or whether just calling SSL_CTX_free is enough.
+	 */
+
 	if (!bLibraryInitialized) {
 		bLibraryInitialized = true;
 		SSL_library_init();
@@ -159,9 +167,21 @@ SslContext_t::SslContext_t (bool is_server):
 		SSL_CTX_sess_set_cache_size (pCtx, 128);
 		SSL_CTX_set_session_id_context (pCtx, (unsigned char*)"eventmachine", 12);
 	}
-
+	else {
+		int e;
+		if (privkeyfile.length() > 0) {
+			e = SSL_CTX_use_PrivateKey_file (pCtx, privkeyfile.c_str(), SSL_FILETYPE_PEM);
+			assert (e > 0);
+		}
+		if (certchainfile.length() > 0) {
+			e = SSL_CTX_use_certificate_chain_file (pCtx, certchainfile.c_str());
+			assert (e > 0);
+		}
+	}
 }
 
+
+
 /***************************
 SslContext_t::~SslContext_t
 ***************************/
@@ -182,13 +202,17 @@ SslContext_t::~SslContext_t()
 SslBox_t::SslBox_t
 ******************/
 
-SslBox_t::SslBox_t (bool is_server):
+SslBox_t::SslBox_t (bool is_server, const string &privkeyfile, const string &certchainfile):
 	bIsServer (is_server),
 	pSSL (NULL),
 	pbioRead (NULL),
 	pbioWrite (NULL)
 {
-	Context = new SslContext_t (bIsServer);
+	/* TODO someday: make it possible to re-use SSL contexts so we don't have to create
+	 * a new one every time we come here.
+	 */
+
+	Context = new SslContext_t (bIsServer, privkeyfile, certchainfile);
 	assert (Context);
 
 	pbioRead = BIO_new (BIO_s_mem());

data/ext/ssl.h

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: ssl.h 318 2007-05-22 22:06:24Z blackhedd $
+$Id: ssl.h 498 2007-08-15 14:03:32Z blackhedd $
 
 File:     ssl.h
 Date:     30Apr06
@@ -33,7 +33,7 @@ class SslContext_t
 class SslContext_t
 {
 	public:
-		SslContext_t (bool is_server);
+		SslContext_t (bool is_server, const string &privkeyfile, const string &certchainfile);
 		virtual ~SslContext_t();
 
 	private:
@@ -57,7 +57,7 @@ class SslBox_t
 class SslBox_t
 {
 	public:
-		SslBox_t (bool is_server);
+		SslBox_t (bool is_server, const string &privkeyfile, const string &certchainfile);
 		virtual ~SslBox_t();
 
 		int PutPlaintext (const char*, int);

data/lib/em/deferrable.rb

@@ -1,4 +1,4 @@
-# $Id: deferrable.rb 464 2007-07-22 12:56:27Z blackhedd $
+# $Id: deferrable.rb 534 2007-09-15 23:06:15Z blackhedd $
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -28,26 +28,50 @@ require 'forwardable'
 module EventMachine
 
 module Deferrable
+
+  # Specify a block to be executed if and when the Deferrable object receives
+  # a status of :succeeded. See #set_deferred_status for more information.
+  #
+  # Calling this method on a Deferrable object whose status is not yet known
+  # will cause the callback block to be stored on an internal list.
+  # If you call this method on a Deferrable whose status is :succeeded, the
+  # block will be executed immediately, receiving the parameters given to the
+  # prior #set_deferred_status call.
+  #
+  #--
+  # If there is no status, add a callback to an internal list.
+  # If status is succeeded, execute the callback immediately.
+  # If status is failed, do nothing.
+  #
   def callback &block
     return unless block
     if @deferred_status == :succeeded
       block.call(*@deferred_args)
-    else
+    elsif @deferred_status != :failed
       @callbacks ||= []
       @callbacks.unshift block # << block
     end
   end
 
+  # Specify a block to be executed if and when the Deferrable object receives
+  # a status of :failed. See #set_deferred_status for more information.
+  #--
+  # If there is no status, add an errback to an internal list.
+  # If status is failed, execute the errback immediately.
+  # If status is succeeded, do nothing.
+  #
   def errback &block
     return unless block
     if @deferred_status == :failed
       block.call(*@deferred_args)
-    else
+    elsif @deferred_status != :succeeded
       @errbacks ||= []
       @errbacks.unshift block # << block
     end
   end
 
+  # Sets the "disposition" (status) of the Deferrable object. See also the large set of
+  # sugarings for this method.
   # Note that if you call this method without arguments,
   # no arguments will be passed to the callback/errback.
   # If the user has coded these with arguments, then the
@@ -59,6 +83,23 @@ module Deferrable
   # on the INSIDE of a callback. This is very useful when a previously-registered
   # callback wants to change the parameters that will be passed to subsequently-registered
   # ones.
+  #
+  # You may give either :succeeded or :failed as the status argument.
+  #
+  # If you pass :succeeded, then all of the blocks passed to the object using the #callback
+  # method (if any) will be executed BEFORE the #set_deferred_status method returns. All of the blocks
+  # passed to the object using #errback will be discarded.
+  #
+  # If you pass :failed, then all of the blocks passed to the object using the #errback
+  # method (if any) will be executed BEFORE the #set_deferred_status method returns. All of the blocks
+  # passed to the object using # callback will be discarded.
+  #
+  # If you pass any arguments to #set_deferred_status in addition to the status argument,
+  # they will be passed as arguments to any callbacks or errbacks that are executed.
+  # It's your responsibility to ensure that the argument lists specified in your callbacks and
+  # errbacks match the arguments given in calls to #set_deferred_status, otherwise Ruby will raise
+  # an ArgumentError.
+  #
   # --
   # We're shifting callbacks off and discarding them as we execute them.
   # This is valid because by definition callbacks are executed no more than
@@ -70,25 +111,65 @@ module Deferrable
   # by Kirk Haines, to work around the memory leak bug that still exists in many Ruby
   # versions.
   #
-  def set_deferred_status arg, *args
-    @deferred_status = arg
+  # Changed 15Sep07: after processing callbacks or errbacks, CLEAR the other set of
+  # handlers. This gets us a little closer to the behavior of Twisted's "deferred,"
+  # which only allows status to be set once. Prior to making this change, it was possible
+  # to "succeed" a Deferrable (triggering its callbacks), and then immediately "fail" it,
+  # triggering its errbacks! That is clearly undesirable, but it's just as undesirable
+  # to raise an exception is status is set more than once on a Deferrable. The latter
+  # behavior would invalidate the idiom of resetting arguments by setting status from
+  # within a callback or errback, but more seriously it would cause spurious errors
+  # if a Deferrable was timed out and then an attempt was made to succeed it. See the
+  # comments under the new method #timeout.
+  #
+  def set_deferred_status status, *args
+    cancel_timeout
+    @deferred_status = status
     @deferred_args = args
     case @deferred_status
     when :succeeded
       if @callbacks
-        while cb = @callbacks.pop #shift
+        while cb = @callbacks.pop
           cb.call(*@deferred_args)
         end
       end
+      @errbacks.clear if @errbacks
     when :failed
       if @errbacks
-        while eb = @errbacks.pop #shift
+        while eb = @errbacks.pop
           eb.call(*@deferred_args)
         end
       end
+      @callbacks.clear if @callbacks
     end
   end
 
+
+  # Setting a timeout on a Deferrable causes it to go into the failed state after
+  # the Timeout expires (passing no arguments to the object's errbacks).
+  # Setting the status at any time prior to a call to the expiration of the timeout
+  # will cause the timer to be cancelled.
+  #--
+  #
+  #
+  def timeout seconds
+	  cancel_timeout
+	  me = self
+	  @deferred_timeout = EventMachine::Timer.new(seconds) {me.fail}
+  end
+
+
+  # Cancels an outstanding timeout if any. Undoes the action of #timeout.
+  #
+  #
+  def cancel_timeout
+	  if @deferred_timeout
+		  @deferred_timeout.cancel
+		  @deferred_timeout = nil
+	  end
+  end
+
+
   # Equivalent to set_deferred_status(:succeeded, ...)
   #
   def set_deferred_success *args
@@ -104,13 +185,13 @@ module Deferrable
   # And still more sugar
   #
   def succeed *args
-	  set_deferred_success *args
+	  set_deferred_success(*args)
   end
 
   # Can't get enough sugar
   #
   def fail *args
-	  set_deferred_failure *args
+	  set_deferred_failure(*args)
   end
 end
 

data/lib/em/spawnable.rb

@@ -0,0 +1,88 @@
+# $Id: spawnable.rb 530 2007-09-13 01:11:38Z blackhedd $
+#
+# Author:: Francis Cianfrocca (gmail: blackhedd)
+# Homepage::  http://rubyeventmachine.com
+# Date:: 25 Aug 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.
+#
+#---------------------------------------------------------------------------
+#
+# 
+
+
+# Support for Erlang-style processes.
+#
+
+
+module EventMachine
+	class SpawnedProcess
+		#attr_accessor :receiver
+		def notify *x
+			me = self
+			EM.next_tick {
+				# A notification executes in the context of this
+				# SpawnedProcess object. That makes self and notify
+				# work as one would expect.
+				#
+				y = me.call(*x)
+				if y and y.respond_to?(:pull_out_yield_block)
+					a,b = y.pull_out_yield_block
+					set_receiver a
+					self.notify if b
+				end
+			}
+		end
+		alias_method :resume, :notify
+		alias_method :run, :notify # for formulations like (EM.spawn {xxx}).run
+
+		# I know I'm missing something stupid, but the inside of class << s
+		# can't see locally-bound values. It can see globals, though.
+		def set_receiver blk
+			$em______tmpglobal = blk
+			class << self
+				define_method :call, $em______tmpglobal.dup
+			end
+		end
+
+	end
+
+	class YieldBlockFromSpawnedProcess
+		def initialize block, notify
+			@block = [block,notify]
+		end
+		def pull_out_yield_block
+			@block
+		end
+	end
+
+	def EventMachine.spawn &block
+		s = SpawnedProcess.new
+		s.set_receiver block
+		s
+	end
+
+	def EventMachine.yield &block
+		return YieldBlockFromSpawnedProcess.new( block, false )
+	end
+
+	def EventMachine.yield_and_notify &block
+		return YieldBlockFromSpawnedProcess.new( block, true )
+	end
+end
+
+
+

data/lib/eventmachine.rb

@@ -1,4 +1,4 @@
-# $Id: eventmachine.rb 489 2007-07-30 05:10:15Z blackhedd $
+# $Id: eventmachine.rb 521 2007-09-04 18:22:07Z blackhedd $
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -66,6 +66,7 @@ require 'em/future'
 require 'em/eventable'
 require 'em/messages'
 require 'em/streamer'
+require 'em/spawnable'
 
 require 'shellwords'
 
@@ -216,15 +217,31 @@ module EventMachine
 	@acceptors = {}
 	@timers = {}
 	begin
+	    @reactor_running = true
 	    initialize_event_machine
 	    block and add_timer 0, block
 	    run_machine
 	ensure
 	    release_machine
+	    @reactor_running = false
 	end
     end
 
 
+    # Sugars a common use case. Will pass the given block to #run, but will terminate
+    # the reactor loop and exit the function as soon as the code in the block completes.
+    # (Normally, #run keeps running indefinitely, even after the block supplied to it
+    # finishes running, until user code calls #stop.)
+    #
+    def EventMachine::run_block &block
+	    pr = proc {
+		    block.call
+		    EventMachine::stop
+	    }
+	    run(&pr)
+    end
+
+
   # +deprecated+
   #--
   # EventMachine#run_without_threads is semantically identical
@@ -766,17 +783,27 @@ module EventMachine
 	# It can be fired either by code running on a separate thread (EM#defer) or on
 	# the main thread (EM#next_tick).
 	# It will often happen that a next_tick handler will reschedule itself. We
-	# consume a duplicate of the tick queue so that tick events scheduled by tick events
+	# consume a copy of the tick queue so that tick events scheduled by tick events
 	# have to wait for the next pass through the reactor core.
 	#
 	def self::run_deferred_callbacks # :nodoc:
-		if @resultqueue
-			until @resultqueue.empty?
-				result,cback = @resultqueue.pop
-				cback.call result if cback
-			end
+		until (@resultqueue ||= []).empty?
+			result,cback = @resultqueue.pop
+			cback.call result if cback
 		end
 
+		@next_tick_queue ||= []
+		if (l = @next_tick_queue.length) > 0
+			l.times {|i| @next_tick_queue[i].call}
+			@next_tick_queue.slice!( 0...l )
+		end
+
+=begin
+		(@next_tick_queue ||= []).length.times {
+			cback=@next_tick_queue.pop and cback.call
+		}
+=end
+=begin
 		if (@next_tick_queue ||= []) and @next_tick_queue.length > 0
 			ary = @next_tick_queue.dup
 			@next_tick_queue.clear
@@ -784,6 +811,7 @@ module EventMachine
 				cback=ary.pop and cback.call
 			end
 		end
+=end
 	end
 
 
@@ -810,7 +838,6 @@ module EventMachine
 	# after the operation completes.
 	#
 	# <i>Caveats:</i>
-	# This is a <b>provisional</b> implementation and is subject to change.
 	# Note carefully that the code in your deferred operation will be executed on a separate
 	# thread from the main EventMachine processing and all other Ruby threads that may exist in
 	# your program. Also, multiple deferred operations may be running at once! Therefore, you
@@ -872,7 +899,7 @@ module EventMachine
 	#
 	def self::next_tick pr=nil, &block
 		raise "no argument or block given" unless ((pr && pr.respond_to?(:call)) or block)
-		(@next_tick_queue ||= []) << (pr || block)
+		(@next_tick_queue ||= []) << ( pr || block )
 		EventMachine.signal_loopbreak
 =begin
 		(@next_tick_procs ||= []) << (pr || block)
@@ -944,6 +971,39 @@ module EventMachine
 	end
 
 
+	# Tells you whether the EventMachine reactor loop is currently running. Returns true or
+	# false. Useful when writing libraries that want to run event-driven code, but may
+	# be running in programs that are already event-driven. In such cases, if EventMachine#reactor_running?
+	# returns false, your code can invoke EventMachine#run and run your application code inside
+	# the block passed to that method. If EventMachine#reactor_running? returns true, just
+	# execute your event-aware code.
+	#
+	# This method is necessary because calling EventMachine#run inside of another call to
+	# EventMachine#run generates a fatal error.
+	#
+	def self::reactor_running?
+		(@reactor_running || false)
+	end
+
+
+	# (Experimental)
+	#
+	#
+	def EventMachine::open_keyboard handler=nil
+		klass = if (handler and handler.is_a?(Class))
+			handler
+		else
+			Class.new( Connection ) {handler and include handler}
+		end
+
+		s = read_keyboard
+		c = klass.new s
+		@conns[s] = c
+		block_given? and yield c
+		c
+	end
+
+
 
 	private
 	def EventMachine::event_callback conn_binding, opcode, data
@@ -1163,9 +1223,35 @@ class Connection
 	# Call #start_tls at any point to initiate TLS encryption on connected streams.
 	# The method is smart enough to know whether it should perform a server-side
 	# or a client-side handshake. An appropriate place to call #start_tls is in
-	# your redefined #post_init method.
+	# your redefined #post_init method, or in the #connection_completed handler for
+	# an outbound connection.
+	#
+	# #start_tls takes an optional parameter hash that allows you to specify certificate
+	# and other options to be used with this Connection object. Here are the currently-supported
+	# options:
+	# :cert_chain_file : takes a String, which is interpreted as the name of a readable file in the
+	#   local filesystem. The file is expected to contain a chain of X509 certificates in
+	#   PEM format, with the most-resolved certificate at the top of the file, successive
+	#   intermediate certs in the middle, and the root (or CA) cert at the bottom.
+	#
+	# :private_key_file : tales a String, which is interpreted as the name of a readable file in the
+	#   local filesystem. The file must contain a private key in PEM format.
+	#
+	#--
+	# TODO: support passing an encryption parameter, which can be string or Proc, to get a passphrase
+	# for encrypted private keys.
+	# TODO: support passing key material via raw strings or Procs that return strings instead of
+	# just filenames.
+	# What will get nasty is whether we have to define a location for storing this stuff as files.
+	# In general, the OpenSSL interfaces for dealing with certs and keys in files are much better
+	# behaved than the ones for raw chunks of memory.
 	#
-	def start_tls
+	def start_tls args={}
+		EventMachine::set_tls_parms(
+			@signature,
+			args[:private_key_file] || "",
+			args[:cert_chain_file] || ""
+		)
 		EventMachine::start_tls @signature
 	end
 
@@ -1332,4 +1418,6 @@ require 'protocols/line_and_text'
 require 'protocols/header_and_content'
 require 'protocols/linetext2'
 require 'protocols/stomp'
+require 'protocols/smtpclient'
+require 'protocols/smtpserver'