eventmachine 0.12.4 → 0.12.6

data/ext/ssl.cpp

@@ -210,6 +210,7 @@ SslBox_t::SslBox_t
 
 SslBox_t::SslBox_t (bool is_server, const string &privkeyfile, const string &certchainfile):
 	bIsServer (is_server),
+	bHandshakeCompleted (false),
 	pSSL (NULL),
 	pbioRead (NULL),
 	pbioWrite (NULL)
@@ -289,6 +290,7 @@ int SslBox_t::GetPlaintext (char *buf, int bufsize)
 			else
 				return 0;
 		}
+		bHandshakeCompleted = true;
 		// If handshake finished, FALL THROUGH and return the available plaintext.
 	}
 
@@ -403,6 +405,19 @@ int SslBox_t::PutPlaintext (const char *buf, int bufsize)
 		return 0;
 }
 
+/**********************
+SslBox_t::GetPeerCert
+**********************/
+
+X509 *SslBox_t::GetPeerCert()
+{
+	X509 *cert = NULL;
+
+	if (pSSL)
+		cert = SSL_get_peer_certificate(pSSL);
+
+	return cert;
+}
 
 #endif // WITH_SSL
 

data/ext/ssl.h

@@ -66,6 +66,9 @@ class SslBox_t
 		bool PutCiphertext (const char*, int);
 		bool CanGetCiphertext();
 		int GetCiphertext (char*, int);
+		bool IsHandshakeCompleted() {return bHandshakeCompleted;}
+
+		X509 *GetPeerCert();
 
 		void Shutdown();
 
@@ -73,6 +76,7 @@ class SslBox_t
 		SslContext_t *Context;
 
 		bool bIsServer;
+		bool bHandshakeCompleted;
 		SSL *pSSL;
 		BIO *pbioRead;
 		BIO *pbioWrite;

data/java/.classpath

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry excluding="src/" kind="src" path=""/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
+	<classpathentry kind="output" path="src"/>
+</classpath>

data/java/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>em_reactor</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

data/lib/em/processes.rb

@@ -63,6 +63,51 @@ module EventMachine
 			succeed( @data.join )
 		end
 	end
+
+  class SystemCmd < EventMachine::Connection # :nodoc:
+    def initialize cb
+      @cb = cb
+      @output = []
+    end
+    def receive_data data
+      @output << data
+    end
+    def unbind
+      @cb.call @output.join(''), get_status if @cb
+    end
+  end
+
+  # EM::system is a simple wrapper for EM::popen. It is similar to Kernel::system, but requires a
+  # single string argument for the command and performs no shell expansion.
+  #
+  # The block or proc passed to EM::system is called with two arguments: the output generated by the command,
+  # and a Process::Status that contains information about the command's execution.
+  #
+  #   EM.run{
+  #     EM.system('ls'){ |output,status| puts output if status.exitstatus == 0 }
+  #   }
+  #
+  # You can also supply an additional proc to send some data to the process:
+  #
+  #   EM.run{
+  #     EM.system('sh', proc{ |process|
+  #       process.send_data("echo hello\n")
+  #       process.send_data("exit\n")
+  #     }, proc{ |out,status|
+  #       puts(out)
+  #     })
+  #   }
+  #
+  # Like EM::popen, EM::system currently does not work on windows.
+  #
+  def EventMachine::system cmd, *args, &cb
+    cb ||= args.pop if args.last.is_a? Proc
+    init = args.pop if args.last.is_a? Proc
+
+    EM.popen(cmd, SystemCmd, cb) do |c|
+      init[c] if init
+    end
+  end
 end
 
 

data/lib/eventmachine.rb

@@ -234,6 +234,9 @@ module EventMachine
 				@reactor_running = true
 				initialize_event_machine
 				(b = blk || block) and add_timer(0, b)
+				if @next_tick_queue && !@next_tick_queue.empty?
+					add_timer(0) { signal_loopbreak }
+				end
 				run_machine
 			ensure
 			  begin
@@ -535,12 +538,15 @@ module EventMachine
     begin
       port = Integer(port)
     rescue ArgumentError, TypeError
+      # there was no port, so server must be a unix domain socket
+      # the port argument is actually the handler, and the handler is one of the args
       args.unshift handler if handler
       handler = port
       port = nil
     end if port
     
     klass = if (handler and handler.is_a?(Class))
+      raise ArgumentError, 'must provide module or subclass of EventMachine::Connection' unless Connection > handler
       handler
     else
       Class.new( Connection ) {handler and include handler}
@@ -676,12 +682,15 @@ module EventMachine
     begin
       port = Integer(port)
     rescue ArgumentError, TypeError
+      # there was no port, so server must be a unix domain socket
+      # the port argument is actually the handler, and the handler is one of the args
       args.unshift handler if handler
       handler = port
       port = nil
     end if port
 
     klass = if (handler and handler.is_a?(Class))
+      raise ArgumentError, 'must provide module or subclass of EventMachine::Connection' unless Connection > handler
       handler
     else
       Class.new( Connection ) {handler and include handler}
@@ -749,6 +758,7 @@ module EventMachine
   # Thanks to Riham Aldakkak (eSpace Technologies) for the initial patch
   def  EventMachine::attach io, handler=nil, *args
     klass = if (handler and handler.is_a?(Class))
+      raise ArgumentError, 'must provide module or subclass of EventMachine::Connection' unless Connection > handler
       handler
     else
       Class.new( Connection ) {handler and include handler}
@@ -880,6 +890,7 @@ module EventMachine
 	#
 	def self::open_datagram_socket address, port, handler=nil, *args
 		klass = if (handler and handler.is_a?(Class))
+		  raise ArgumentError, 'must provide module or subclass of EventMachine::Connection' unless Connection > handler
 			handler
 		else
 			Class.new( Connection ) {handler and include handler}
@@ -924,6 +935,35 @@ module EventMachine
 		set_max_timer_count ct
 	end
 
+	# Gets the current maximum number of allowed timers
+	#
+	def self::get_max_timers
+		get_max_timer_count
+	end
+
+	# Returns the total number of connections (file descriptors) currently held by the reactor.
+	# Note that a tick must pass after the 'initiation' of a connection for this number to increment.
+	#
+	# For example, $count will be 0 in this case:
+	#
+	# EM.run {
+	#   EM.connect("rubyeventmachine.com", 80)
+	#   $count = EM.connection_count
+	# }
+	#
+	# In this example, $count will be 1 since the connection has been established in the next loop of the reactor.
+	#
+	# EM.run {
+	#   EM.connect("rubyeventmachine.com", 80)
+	#   EM.next_tick {
+	#     $count = EM.connection_count
+	#   }
+	# }
+	#
+	def self::connection_count
+	  self::get_connection_count
+	end
+
 	#--
 	# The is the responder for the loopback-signalled event.
 	# It can be fired either by code running on a separate thread (EM#defer) or on
@@ -1050,7 +1090,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 )
-		EventMachine.signal_loopbreak
+		signal_loopbreak if reactor_running?
 =begin
 		(@next_tick_procs ||= []) << (pr || block)
 		if @next_tick_procs.length == 1
@@ -1099,13 +1139,33 @@ module EventMachine
 
 
 
-	# TODO, must document popen. At this moment, it's only available on Unix.
-	# This limitation is expected to go away.
+	# Run an external process. This does not currently work on Windows.
+	#
+	#   module RubyCounter
+	#     def post_init
+	#       # count up to 5
+	#       send_data "5\n"
+	#     end
+	#     def receive_data data
+	#       puts "ruby sent me: #{data}"
+	#     end
+	#     def unbind
+	#       puts "ruby died with exit status: #{get_status.exitstatus}"
+	#     end
+	#   end
+	#
+	#   EM.run{
+	#     EM.popen("ruby -e' $stdout.sync = true; gets.to_i.times{ |i| puts i+1; sleep 1 } '", RubyCounter)
+	#   }
+	#
+	# Also see EM::DeferrableChildProcess and EM::system
 	#--
+	# At this moment, it's only available on Unix.
 	# Perhaps misnamed since the underlying function uses socketpair and is full-duplex.
 	#
 	def self::popen cmd, handler=nil, *args
 		klass = if (handler and handler.is_a?(Class))
+		  raise ArgumentError, 'must provide module or subclass of EventMachine::Connection' unless Connection > handler
 			handler
 		else
 			Class.new( Connection ) {handler and include handler}
@@ -1141,6 +1201,7 @@ module EventMachine
 	#
 	def EventMachine::open_keyboard handler=nil, *args
 		klass = if (handler and handler.is_a?(Class))
+		  raise ArgumentError, 'must provide module or subclass of EventMachine::Connection' unless Connection > handler
 			handler
 		else
 			Class.new( Connection ) {handler and include handler}
@@ -1159,7 +1220,19 @@ module EventMachine
 		c
 	end
 
-
+	# Catch-all for errors raised during event loop callbacks.
+	#
+	# EM.error_handler{ |e|
+	#   puts "Error raised during event loop: #{e.message}"
+	# }
+	#
+	def EventMachine::error_handler cb = nil, &blk
+		if cb or blk
+			@error_handler = cb || blk
+		elsif instance_variable_defined? :@error_handler
+			remove_instance_variable :@error_handler
+		end
+	end
 
 	private
 	def EventMachine::event_callback conn_binding, opcode, data
@@ -1177,10 +1250,7 @@ module EventMachine
 		# runs down open connections). It should go on the other calls to user
 		# code, but the performance impact may be too large.
 		#
-		if opcode == ConnectionData
-			c = @conns[conn_binding] or raise ConnectionNotBound, "received data #{data} for unknown signature: #{conn_binding}"
-			c.receive_data data
-		elsif opcode == ConnectionUnbound
+		if opcode == ConnectionUnbound
 			if c = @conns.delete( conn_binding )
 				begin
 					c.unbind
@@ -1200,12 +1270,17 @@ module EventMachine
 			@conns[data] = c
 			blk and blk.call(c)
 			c # (needed?)
-		elsif opcode == TimerFired
-			t = @timers.delete( data ) or raise UnknownTimerFired, "timer data: #{data}"
-			t.call
 		elsif opcode == ConnectionCompleted
 			c = @conns[conn_binding] or raise ConnectionNotBound, "received ConnectionCompleted for unknown signature: #{conn_binding}"
 			c.connection_completed
+		##
+		# The remaining code is a fallback for the pure ruby reactor. Usually these events are handled in the C event_callback() in rubymain.cpp
+		elsif opcode == TimerFired
+			t = @timers.delete( data ) or raise UnknownTimerFired, "timer data: #{data}"
+			t.call
+		elsif opcode == ConnectionData
+			c = @conns[conn_binding] or raise ConnectionNotBound, "received data #{data} for unknown signature: #{conn_binding}"
+			c.receive_data data
 		elsif opcode == LoopbreakSignalled
 			run_deferred_callbacks
 		elsif opcode == ConnectionNotifyReadable
@@ -1217,98 +1292,102 @@ module EventMachine
 		end
 	end
 
-	private
-	def EventMachine::original_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
-			begin
-				c.receive_data data
-			rescue
-				EventMachine.handle_runtime_error
-			end
-		elsif opcode == ConnectionUnbound
-			if c = @conns.delete( conn_binding )
-				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,args,blk = @acceptors[conn_binding]
-			raise NoHandlerForAcceptedConnection unless accep
-			c = accep.new data, *args
-			@conns[data] = 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
-			begin
-				t.call
-			rescue
-				EventMachine.handle_runtime_error
-			end
-		elsif opcode == ConnectionCompleted
-			c = @conns[conn_binding] or raise ConnectionNotBound
-			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
+	# The original event_callback below handled runtime errors in ruby and degraded performance significantly.
+	# An optional C-based error handler is now available via EM::error_handler
+	#
+	# private
+	# def EventMachine::original_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
+	#     begin
+	#       c.receive_data data
+	#     rescue
+	#       EventMachine.handle_runtime_error
+	#     end
+	#   elsif opcode == ConnectionUnbound
+	#     if c = @conns.delete( conn_binding )
+	#       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,args,blk = @acceptors[conn_binding]
+	#     raise NoHandlerForAcceptedConnection unless accep
+	#     c = accep.new data, *args
+	#     @conns[data] = 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
+	#     begin
+	#       t.call
+	#     rescue
+	#       EventMachine.handle_runtime_error
+	#     end
+	#   elsif opcode == ConnectionCompleted
+	#     c = @conns[conn_binding] or raise ConnectionNotBound
+	#     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
   #--
@@ -1317,6 +1396,7 @@ module EventMachine
   class << self
     def _open_file_for_writing filename, handler=nil
       klass = if (handler and handler.is_a?(Class))
+        raise ArgumentError, 'must provide module or subclass of EventMachine::Connection' unless Connection > handler
         handler
       else
         Class.new( Connection ) {handler and include handler}
@@ -1426,6 +1506,16 @@ class Connection
 		puts "............>>>#{data.length}"
 	end
 
+	# #ssl_handshake_completed is called by EventMachine when the SSL/TLS handshake has
+	# been completed, as a result of calling #start_tls to initiate SSL/TLS on the connection.
+	#
+	# This callback exists because #post_init and #connection_completed are <b>not</b> reliable
+	# for indicating when an SSL/TLS connection is ready to have it's certificate queried for.
+	#
+	# See #get_peer_cert for application and example.
+	def ssl_handshake_completed
+	end
+
 	# EventMachine::Connection#unbind is called by the framework whenever a connection
 	# (either a server or client connection) is closed. The close can occur because
 	# your code intentionally closes it (see close_connection and close_connection_after_writing),
@@ -1572,6 +1662,73 @@ class Connection
 		EventMachine::start_tls @signature
 	end
 
+  # If SSL/TLS is active on the connection, #get_peer_cert returns the remote X509 certificate
+  # as a String, in the popular PEM format. This can then be used for arbitrary validation
+  # of a peer's certificate in your code.
+  #
+  # This should be called in/after the #ssl_handshake_completed callback, which indicates
+  # that SSL/TLS is active. Using this callback is important, because the certificate may not
+  # be available until the time it is executed. Using #post_init or #connection_completed is
+  # not adequate, because the SSL handshake may still be taking place.
+  #
+  # #get_peer_cert will return <b>nil</b> if:
+  #
+  # * EventMachine is not built with OpenSSL support
+  # * SSL/TLS is not active on the connection
+  # * SSL/TLS handshake is not yet complete
+  # * Remote peer for any other reason has not presented a certificate
+  #
+  # === Example:
+  #
+  #  module Handler
+  #
+  #   def post_init
+  #     puts "Starting TLS"
+  #     start_tls
+  #   end
+  #
+  #   def ssl_handshake_completed
+  #     puts get_peer_cert
+  #     close_connection
+  #   end
+  #
+  #   def unbind
+  #     EventMachine::stop_event_loop
+  #   end
+  #
+  #  end
+  #
+  #  EM.run {
+  #   EventMachine::connect "mail.google.com", 443, Handler
+  #  }
+  #
+  # Output:
+  #  -----BEGIN CERTIFICATE-----
+  #  MIIDIjCCAougAwIBAgIQbldpChBPqv+BdPg4iwgN8TANBgkqhkiG9w0BAQUFADBM
+  #  MQswCQYDVQQGEwJaQTElMCMGA1UEChMcVGhhd3RlIENvbnN1bHRpbmcgKFB0eSkg
+  #  THRkLjEWMBQGA1UEAxMNVGhhd3RlIFNHQyBDQTAeFw0wODA1MDIxNjMyNTRaFw0w
+  #  OTA1MDIxNjMyNTRaMGkxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpDYWxpZm9ybmlh
+  #  MRYwFAYDVQQHEw1Nb3VudGFpbiBWaWV3MRMwEQYDVQQKEwpHb29nbGUgSW5jMRgw
+  #  FgYDVQQDEw9tYWlsLmdvb2dsZS5jb20wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJ
+  #  AoGBALlkxdh2QXegdElukCSOV2+8PKiONIS+8Tu9K7MQsYpqtLNC860zwOPQ2NLI
+  #  3Zp4jwuXVTrtzGuiqf5Jioh35Ig3CqDXtLyZoypjZUQcq4mlLzHlhIQ4EhSjDmA7
+  #  Ffw9y3ckSOQgdBQWNLbquHh9AbEUjmhkrYxIqKXeCnRKhv6nAgMBAAGjgecwgeQw
+  #  KAYDVR0lBCEwHwYIKwYBBQUHAwEGCCsGAQUFBwMCBglghkgBhvhCBAEwNgYDVR0f
+  #  BC8wLTAroCmgJ4YlaHR0cDovL2NybC50aGF3dGUuY29tL1RoYXd0ZVNHQ0NBLmNy
+  #  bDByBggrBgEFBQcBAQRmMGQwIgYIKwYBBQUHMAGGFmh0dHA6Ly9vY3NwLnRoYXd0
+  #  ZS5jb20wPgYIKwYBBQUHMAKGMmh0dHA6Ly93d3cudGhhd3RlLmNvbS9yZXBvc2l0
+  #  b3J5L1RoYXd0ZV9TR0NfQ0EuY3J0MAwGA1UdEwEB/wQCMAAwDQYJKoZIhvcNAQEF
+  #  BQADgYEAsRwpLg1dgCR1gYDK185MFGukXMeQFUvhGqF8eT/CjpdvezyKVuz84gSu
+  #  6ccMXgcPQZGQN/F4Xug+Q01eccJjRSVfdvR5qwpqCj+6BFl5oiKDBsveSkrmL5dz
+  #  s2bn7TdTSYKcLeBkjXxDLHGBqLJ6TNCJ3c4/cbbG5JhGvoema94=
+  #  -----END CERTIFICATE-----
+  #
+  # You can do whatever you want with the certificate String, such as load it
+  # as a certificate object using the OpenSSL library, and check it's fields.
+	def get_peer_cert
+	  EventMachine::get_peer_cert @signature
+	end
+
 
 	# send_datagram is for sending UDP messages.
 	# This method may be called from any Connection object that refers
@@ -1755,6 +1912,7 @@ module Protocols
 	autoload :SmtpClient, 'protocols/smtpclient'
 	autoload :SmtpServer, 'protocols/smtpserver'
 	autoload :SASLauth, 'protocols/saslauth'
+	autoload :Memcache, 'protocols/memcache'
 	
 	#require 'protocols/postgres' UNCOMMENT THIS LINE WHEN THE POSTGRES CODE IS READY FOR PRIME TIME.
 end