libc-eventmachine 0.12.5.42 → 0.12.7.42

data/.gitignore

@@ -0,0 +1,13 @@
+pkg
+rdoc
+Makefile
+
+*.bundle
+*.dll
+*.so
+*.jar
+*.class
+*.o
+*.log
+*.def
+*.pdb

data/README

@@ -0,0 +1,3 @@
+Do not use this repository please. It exists only for sake of EM::connect2 method, that I badly need. I'm too lazy to install custom gem server, so I'll use github's ;-)
+
+If you know better interface for this functionality (bind before connect call), please write me! 

data/Rakefile

@@ -90,7 +90,7 @@ Spec = Gem::Specification.new do |s|
   s.rdoc_options      = %w(--title EventMachine --main docs/README --line-numbers)
   s.extra_rdoc_files  = Dir['docs/*']
 
-  s.files             = %w(Rakefile) + Dir["{bin,tests,lib,ext,java,tasks}/**/*"]
+  s.files             = `git ls-files`.split("\n")
 
   s.require_path      = 'lib'
 
@@ -128,6 +128,65 @@ using TCP/IP, especially if custom protocols are required.
   s.version = EventMachine::VERSION
 end
 
+if RUBY_PLATFORM =~ /mswin/
+  Spec.platform = 'x86-mswin32-60'
+  Spec.files += %w[ lib/rubyeventmachine.so lib/fastfilereaderext.so ]
+  Spec.extensions = nil
+end
+
+# this is a hack right now, it requires installing msysgit in the global path so it can use tar/curl/etc.
+namespace :win32 do
+  task :check_git do
+    unless `git` =~ /rebase/
+      raise 'git not found, install msys git into the GLOBAL PATH: http://msysgit.googlecode.com/files/Git-1.6.2-preview20090308.exe'
+    end
+  end
+
+  task :check_vc6 do
+    begin
+      raise unless `nmake 2>&1` =~ /Microsoft/
+    rescue
+      raise 'VC6 not found, please run c:\vc\setvc.bat vc6'
+    end
+  end
+
+  task :check_perl do
+    unless `perl --version` =~ /ActiveState/
+      raise 'ActiveState perl required to build OpenSSL: http://downloads.activestate.com/ActivePerl/Windows/5.10/ActivePerl-5.10.0.1004-MSWin32-x86-287188.msi'
+    end
+  end
+
+  task :build_openssl => [:check_git, :check_perl, :check_vc6] do
+    mkdir_p 'build'
+    chdir 'build' do
+      unless File.exists?('openssl-0.9.8j')
+        sh 'curl http://www.openssl.org/source/openssl-0.9.8j.tar.gz > openssl.tar.gz'
+        sh 'tar zxvf openssl.tar.gz' rescue nil # fails because of symlinks
+      end
+
+      mkdir_p 'local'
+      chdir 'openssl-0.9.8j' do
+        sh "perl Configure VC-WIN32 --prefix=\"../local/\""
+        sh 'ms\do_ms.bat'
+        sh 'nmake -f ms\nt.mak install'
+      end
+
+      chdir '../ext' do
+        sh 'git clean -fd .'
+      end
+
+      mv 'local/include/openssl', '../ext/'
+      mv 'local/lib/ssleay32.lib', '../ext/'
+      mv 'local/lib/libeay32.lib', '../ext/'
+    end
+  end
+
+  task :gem => :build_openssl do
+    Rake::Task['build'].invoke
+    Rake::Task['gem'].invoke
+  end
+end
+
 namespace :ext do
   ext_sources = FileList['ext/*.{h,cpp,rb,c}']
   ffr_sources = FileList['ext/fastfilereader/*.{h,cpp,rb}']

data/eventmachine.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{eventmachine}
+  s.version = "0.12.7.42"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Francis Cianfrocca"]
+  s.date = %q{2009-03-10}
+  s.description = %q{EventMachine implements a fast, single-threaded engine for arbitrary network communications. It's extremely easy to use in Ruby. EventMachine wraps all interactions with IP sockets, allowing programs to concentrate on the implementation of network protocols. It can be used to create both network servers and clients. To create a server or client, a Ruby program only needs to specify the IP address and port, and provide a Module that implements the communications protocol. Implementations of several standard network protocols are provided with the package, primarily to serve as examples. The real goal of EventMachine is to enable programs to easily interface with other programs using TCP/IP, especially if custom protocols are required.}
+  s.email = %q{garbagecat10@gmail.com}
+  s.extensions = ["ext/extconf.rb", "ext/fastfilereader/extconf.rb"]
+  s.extra_rdoc_files = ["docs/COPYING", "docs/ChangeLog", "docs/DEFERRABLES", "docs/EPOLL", "docs/GNU", "docs/INSTALL", "docs/KEYBOARD", "docs/LEGAL", "docs/LIGHTWEIGHT_CONCURRENCY", "docs/PURE_RUBY", "docs/README", "docs/RELEASE_NOTES", "docs/SMTP", "docs/SPAWNED_PROCESSES", "docs/TODO"]
+  s.files = [".gitignore", "README", "Rakefile", "docs/COPYING", "docs/ChangeLog", "docs/DEFERRABLES", "docs/EPOLL", "docs/GNU", "docs/INSTALL", "docs/KEYBOARD", "docs/LEGAL", "docs/LIGHTWEIGHT_CONCURRENCY", "docs/PURE_RUBY", "docs/README", "docs/RELEASE_NOTES", "docs/SMTP", "docs/SPAWNED_PROCESSES", "docs/TODO", "eventmachine.gemspec", "ext/binder.cpp", "ext/binder.h", "ext/cmain.cpp", "ext/cplusplus.cpp", "ext/ed.cpp", "ext/ed.h", "ext/em.cpp", "ext/em.h", "ext/emwin.cpp", "ext/emwin.h", "ext/epoll.cpp", "ext/epoll.h", "ext/eventmachine.h", "ext/eventmachine_cpp.h", "ext/extconf.rb", "ext/fastfilereader/extconf.rb", "ext/fastfilereader/mapper.cpp", "ext/fastfilereader/mapper.h", "ext/fastfilereader/rubymain.cpp", "ext/files.cpp", "ext/files.h", "ext/kb.cpp", "ext/page.cpp", "ext/page.h", "ext/pipe.cpp", "ext/project.h", "ext/rubymain.cpp", "ext/sigs.cpp", "ext/sigs.h", "ext/ssl.cpp", "ext/ssl.h", "java/.classpath", "java/.project", "java/src/com/rubyeventmachine/Application.java", "java/src/com/rubyeventmachine/Connection.java", "java/src/com/rubyeventmachine/ConnectionFactory.java", "java/src/com/rubyeventmachine/DefaultConnectionFactory.java", "java/src/com/rubyeventmachine/EmReactor.java", "java/src/com/rubyeventmachine/EmReactorException.java", "java/src/com/rubyeventmachine/EventableChannel.java", "java/src/com/rubyeventmachine/EventableDatagramChannel.java", "java/src/com/rubyeventmachine/EventableSocketChannel.java", "java/src/com/rubyeventmachine/PeriodicTimer.java", "java/src/com/rubyeventmachine/Timer.java", "java/src/com/rubyeventmachine/tests/ApplicationTest.java", "java/src/com/rubyeventmachine/tests/ConnectTest.java", "java/src/com/rubyeventmachine/tests/EMTest.java", "java/src/com/rubyeventmachine/tests/TestDatagrams.java", "java/src/com/rubyeventmachine/tests/TestServers.java", "java/src/com/rubyeventmachine/tests/TestTimers.java", "lib/em/deferrable.rb", "lib/em/eventable.rb", "lib/em/future.rb", "lib/em/messages.rb", "lib/em/processes.rb", "lib/em/spawnable.rb", "lib/em/streamer.rb", "lib/eventmachine.rb", "lib/eventmachine_version.rb", "lib/evma.rb", "lib/evma/callback.rb", "lib/evma/container.rb", "lib/evma/factory.rb", "lib/evma/protocol.rb", "lib/evma/reactor.rb", "lib/jeventmachine.rb", "lib/pr_eventmachine.rb", "lib/protocols/buftok.rb", "lib/protocols/header_and_content.rb", "lib/protocols/httpcli2.rb", "lib/protocols/httpclient.rb", "lib/protocols/line_and_text.rb", "lib/protocols/linetext2.rb", "lib/protocols/memcache.rb", "lib/protocols/postgres.rb", "lib/protocols/saslauth.rb", "lib/protocols/smtpclient.rb", "lib/protocols/smtpserver.rb", "lib/protocols/stomp.rb", "lib/protocols/tcptest.rb", "setup.rb", "tasks/cpp.rake", "tasks/project.rake", "tasks/tests.rake", "tests/test_attach.rb", "tests/test_basic.rb", "tests/test_bind.rb", "tests/test_connection_count.rb", "tests/test_defer.rb", "tests/test_epoll.rb", "tests/test_error_handler.rb", "tests/test_errors.rb", "tests/test_eventables.rb", "tests/test_exc.rb", "tests/test_futures.rb", "tests/test_handler_check.rb", "tests/test_hc.rb", "tests/test_httpclient.rb", "tests/test_httpclient2.rb", "tests/test_kb.rb", "tests/test_ltp.rb", "tests/test_ltp2.rb", "tests/test_next_tick.rb", "tests/test_processes.rb", "tests/test_pure.rb", "tests/test_running.rb", "tests/test_sasl.rb", "tests/test_send_file.rb", "tests/test_servers.rb", "tests/test_smtpclient.rb", "tests/test_smtpserver.rb", "tests/test_spawn.rb", "tests/test_ssl_args.rb", "tests/test_ssl_methods.rb", "tests/test_timers.rb", "tests/test_ud.rb", "tests/testem.rb", "web/whatis"]
+  s.has_rdoc = true
+  s.homepage = %q{http://rubyeventmachine.com}
+  s.rdoc_options = ["--title", "EventMachine", "--main", "docs/README", "--line-numbers"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{eventmachine}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Ruby/EventMachine library}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/ext/cmain.cpp

@@ -324,6 +324,7 @@ evma_get_subprocess_pid
 extern "C" int evma_get_subprocess_pid (const char *binding, pid_t *pid)
 {
 	ensure_eventmachine("evma_get_subprocess_pid");
+	#ifdef OS_UNIX
 	PipeDescriptor *pd = dynamic_cast <PipeDescriptor*> (Bindable_t::GetObject (binding));
 	if (pd) {
 		return pd->GetSubprocessPid (pid) ? 1 : 0;
@@ -334,6 +335,9 @@ extern "C" int evma_get_subprocess_pid (const char *binding, pid_t *pid)
 	}
 	else
 		return 0;
+	#else
+	return 0;
+	#endif
 }
 
 /**************************

data/ext/cplusplus.cpp

@@ -49,7 +49,11 @@ void EM::AddTimer (int milliseconds, void (*func)())
 {
 	if (func) {
 		const char *sig = evma_install_oneshot_timer (milliseconds);
+		#ifdef OS_SOLARIS8
+		Timers.insert (map<string, void(*)()>::value_type (sig, func));
+		#else
 		Timers.insert (make_pair (sig, func));
+		#endif
 	}
 }
 
@@ -72,7 +76,11 @@ void EM::Acceptor::Accept (const char *signature)
 {
 	Connection *c = MakeConnection();
 	c->Signature = signature;
+	#ifdef OS_SOLARIS8
+	Eventables.insert (std::map<std::string,EM::Eventable*>::value_type (c->Signature, c));
+	#else
 	Eventables.insert (make_pair (c->Signature, c));
+	#endif
 	c->PostInit();
 }
 
@@ -114,7 +122,11 @@ EM::Connection::Connect
 void EM::Connection::Connect (const char *host, int port, const char * bind_host)
 {
 	Signature = evma_connect_to_server (host, port, bind_host);
+	#ifdef OS_SOLARIS8
+	Eventables.insert( std::map<std::string,EM::Eventable*>::value_type (Signature, this));
+	#else
 	Eventables.insert( make_pair (Signature, this));
+	#endif
 }
 
 /*******************
@@ -124,7 +136,11 @@ EM::Acceptor::Start
 void EM::Acceptor::Start (const char *host, int port)
 {
 	Signature = evma_create_tcp_server (host, port);
+	#ifdef OS_SOLARIS8
+	Eventables.insert( std::map<std::string,EM::Eventable*>::value_type (Signature, this));
+	#else
 	Eventables.insert( make_pair (Signature, this));
+	#endif
 }
 
 

data/ext/em.cpp

@@ -86,6 +86,7 @@ EventMachine_t::EventMachine_t (void (*event_callback)(const char*, int, const c
 	LoopBreakerWriter (-1),
 	bEpoll (false),
 	bKqueue (false),
+	kqfd (-1),
 	epfd (-1)
 {
 	// Default time-slice is just smaller than one hundred mills.
@@ -932,8 +933,11 @@ const char *EventMachine_t::InstallOneshotTimer (int milliseconds)
 	#endif
 
 	Timer_t t;
-	multimap<Int64,Timer_t>::iterator i =
-		Timers.insert (make_pair (fire_at, t));
+	#ifdef OS_SOLARIS8
+	multimap<Int64,Timer_t>::iterator i = Timers.insert (multimap<Int64,Timer_t>::value_type (fire_at, t));
+	#else
+	multimap<Int64,Timer_t>::iterator i = Timers.insert (make_pair (fire_at, t));
+	#endif
 	return i->second.GetBindingChars();
 }
 

data/ext/rubymain.cpp

@@ -30,6 +30,9 @@ Statics
 static VALUE EmModule;
 static VALUE EmConnection;
 
+static VALUE EM_eUnknownTimerFired;
+static VALUE EM_eConnectionNotBound;
+
 static VALUE Intern_at_signature;
 static VALUE Intern_at_timers;
 static VALUE Intern_at_conns;
@@ -67,21 +70,21 @@ static void event_callback (struct em_event* e)
 		VALUE t = rb_ivar_get (EmModule, Intern_at_conns);
 		VALUE q = rb_hash_aref (t, rb_str_new2(a1));
 		if (q == Qnil)
-			rb_raise (rb_eRuntimeError, "no connection");
+			rb_raise (EM_eConnectionNotBound, "received %d bytes of data for unknown signature: %s", a4, a1);
 		rb_funcall (q, Intern_receive_data, 1, rb_str_new (a3, a4));
 	}
 	else if (a2 == EM_CONNECTION_NOTIFY_READABLE) {
 		VALUE t = rb_ivar_get (EmModule, Intern_at_conns);
 		VALUE q = rb_hash_aref (t, rb_str_new2(a1));
 		if (q == Qnil)
-			rb_raise (rb_eRuntimeError, "no connection");
+			rb_raise (EM_eConnectionNotBound, "unknown connection: %s", a1);
 		rb_funcall (q, Intern_notify_readable, 0);
 	}
 	else if (a2 == EM_CONNECTION_NOTIFY_WRITABLE) {
 		VALUE t = rb_ivar_get (EmModule, Intern_at_conns);
 		VALUE q = rb_hash_aref (t, rb_str_new2(a1));
 		if (q == Qnil)
-			rb_raise (rb_eRuntimeError, "no connection");
+			rb_raise (EM_eConnectionNotBound, "unknown connection: %s", a1);
 		rb_funcall (q, Intern_notify_writable, 0);
 	}
 	else if (a2 == EM_LOOPBREAK_SIGNAL) {
@@ -91,14 +94,14 @@ static void event_callback (struct em_event* e)
 		VALUE t = rb_ivar_get (EmModule, Intern_at_timers);
 		VALUE q = rb_funcall (t, Intern_delete, 1, rb_str_new(a3, a4));
 		if (q == Qnil)
-			rb_raise (rb_eRuntimeError, "no timer");
+			rb_raise (EM_eUnknownTimerFired, "no such timer: %s", a1);
 		rb_funcall (q, Intern_call, 0);
 	}
 	else if (a2 == EM_SSL_HANDSHAKE_COMPLETED) {
 		VALUE t = rb_ivar_get (EmModule, Intern_at_conns);
 		VALUE q = rb_hash_aref (t, rb_str_new2(a1));
 		if (q == Qnil)
-			rb_raise (rb_eRuntimeError, "no connection");
+			rb_raise (EM_eConnectionNotBound, "unknown connection: %s", a1);
 		rb_funcall (q, Intern_ssl_handshake_completed, 0);
 	}
 	else
@@ -109,7 +112,7 @@ static void event_callback (struct em_event* e)
 event_error_handler
 *******************/
 
-static void event_error_handler(void *, VALUE err)
+static void event_error_handler(VALUE unused, VALUE err)
 {
 	VALUE error_handler = rb_ivar_get(EmModule, Intern_at_error_handler);
 	rb_funcall (error_handler, Intern_call, 1, err);
@@ -130,7 +133,7 @@ static void event_callback_wrapper (const char *a1, int a2, const char *a3, int
 	if (!rb_ivar_defined(EmModule, Intern_at_error_handler))
 		event_callback(&e);
 	else
-		rb_rescue((VALUE (*)(ANYARGS))event_callback, (VALUE)&e, (VALUE (*)(ANYARGS))event_error_handler, NULL);
+		rb_rescue((VALUE (*)(ANYARGS))event_callback, (VALUE)&e, (VALUE (*)(ANYARGS))event_error_handler, Qnil);
 }
 
 /**************************
@@ -779,9 +782,9 @@ extern "C" void Init_rubyeventmachine()
 	EmModule = rb_define_module ("EventMachine");
 	EmConnection = rb_define_class_under (EmModule, "Connection", rb_cObject);
 
-	rb_define_class_under (EmModule, "ConnectionNotBound", rb_eException);
 	rb_define_class_under (EmModule, "NoHandlerForAcceptedConnection", rb_eException);
-	rb_define_class_under (EmModule, "UnknownTimerFired", rb_eException);
+	EM_eConnectionNotBound = rb_define_class_under (EmModule, "ConnectionNotBound", rb_eRuntimeError);
+	EM_eUnknownTimerFired = rb_define_class_under (EmModule, "UnknownTimerFired", rb_eRuntimeError);
 
 	rb_define_module_function (EmModule, "initialize_event_machine", (VALUE(*)(...))t_initialize_event_machine, 0);
 	rb_define_module_function (EmModule, "run_machine", (VALUE(*)(...))t_run_machine_without_threads, 0);

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

@@ -538,6 +538,8 @@ 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
@@ -684,6 +686,8 @@ 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
@@ -1250,10 +1254,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
@@ -1273,12 +1274,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
@@ -1290,98 +1296,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
   #--

data/lib/eventmachine_version.rb

@@ -25,7 +25,7 @@
 
 module EventMachine
 
-  VERSION = "0.12.5.42"
+  VERSION = "0.12.7.42"
 
 end
 

data/lib/pr_eventmachine.rb

@@ -628,7 +628,7 @@ module EventMachine
     end
 
     def heartbeat
-      if @inactivity_timeout and (@last_activity + @inactivity_timeout) < Reactor.instance.current_loop_time
+      if @inactivity_timeout and @inactivity_timeout > 0 and (@last_activity + @inactivity_timeout) < Reactor.instance.current_loop_time
         schedule_close true
       end
     end