eventmachine 1.0.0.beta.4-x86-mswin32-60 → 1.0.0.rc.1-x86-mswin32-60

data/Rakefile

@@ -1,10 +1,6 @@
-require 'rubygems' unless defined?(Gem)
-require 'rake'     unless defined?(Rake)
-import  *Dir['tasks/*.rake']
+require 'rubygems'
+GEMSPEC = Gem::Specification.load('eventmachine.gemspec')
 
-GEMSPEC = eval(File.read(File.expand_path('../eventmachine.gemspec', __FILE__)))
-
-require 'yard'
 require 'rake/clean'
 task :clobber => :clean
 
@@ -12,8 +8,13 @@ desc "Build eventmachine, then run tests."
 task :default => [:compile, :test]
 
 desc 'Generate documentation'
-YARD::Rake::YardocTask.new do |t|
-  t.files   = ['lib/**/*.rb', '-', 'docs/*.md']
-  t.options = ['--main', 'README.md', '--no-private']
-  t.options = ['--exclude', 'lib/jeventmachine', '--exclude', 'lib/pr_eventmachine']
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new do |t|
+    t.files   = ['lib/**/*.rb', '-', 'docs/*.md']
+    t.options = ['--main', 'README.md', '--no-private']
+    t.options = ['--exclude', 'lib/jeventmachine', '--exclude', 'lib/pr_eventmachine']
+  end
+rescue LoadError
+  task :yard do puts "Please install yard first!"; end
 end

data/eventmachine.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency 'rake-compiler', '0.7.9'
   s.add_development_dependency 'yard', ">= 0.7.2"
-  s.add_development_dependency 'bluecloth'
+  #s.add_development_dependency 'bluecloth'
 
   s.summary = 'Ruby/EventMachine library'
   s.description = "EventMachine implements a fast, single-threaded engine for arbitrary network

data/ext/cmain.cpp

@@ -253,6 +253,15 @@ extern "C" int evma_is_paused (const unsigned long binding)
 	return 0;
 }
 
+/************************
+evma_num_close_scheduled
+************************/
+
+extern "C" int evma_num_close_scheduled ()
+{
+	return EventMachine->NumCloseScheduled;
+}
+
 /**********************
 evma_create_tcp_server
 **********************/
@@ -804,6 +813,35 @@ extern "C" void evma_stop_proxy (const unsigned long from)
 		ed->StopProxy();
 }
 
+/******************
+evma_proxied_bytes
+*******************/
+
+extern "C" unsigned long evma_proxied_bytes (const unsigned long from)
+{
+	ensure_eventmachine("evma_proxied_bytes");
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (from));
+	if (ed)
+		return ed->GetProxiedBytes();
+	else
+		return 0;
+}
+
+
+/***************************
+evma_get_last_activity_time
+****************************/
+
+extern "C" uint64_t evma_get_last_activity_time(const unsigned long from)
+{
+	ensure_eventmachine("evma_get_last_activity_time");
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (from));
+	if (ed)
+		return ed->GetLastActivity();
+	else
+		return 0;
+}
+
 
 /***************************
 evma_get_heartbeat_interval

data/ext/ed.cpp

@@ -54,12 +54,14 @@ EventableDescriptor::EventableDescriptor (int sd, EventMachine_t *em):
 	bCloseNow (false),
 	bCloseAfterWriting (false),
 	MySocket (sd),
+	bAttached (false),
 	bWatchOnly (false),
 	EventCallback (NULL),
 	bCallbackUnbind (true),
 	UnbindReasonCode (0),
 	ProxyTarget(NULL),
 	ProxiedFrom(NULL),
+	ProxiedBytes(0),
 	MaxOutboundBufSize(0),
 	MyEventMachine (em),
 	PendingConnectTimeout(20000000),
@@ -115,6 +117,7 @@ EventableDescriptor::~EventableDescriptor()
 		(*EventCallback)(ProxiedFrom->GetBinding(), EM_PROXY_TARGET_UNBOUND, NULL, 0);
 		ProxiedFrom->StopProxy();
 	}
+	MyEventMachine->NumCloseScheduled--;
 	StopProxy();
 	Close();
 }
@@ -179,7 +182,7 @@ void EventableDescriptor::Close()
 		MyEventMachine->Deregister (this);
 		
 		// Do not close STDIN, STDOUT, STDERR
-		if (MySocket > 2 && !bWatchOnly) {
+		if (MySocket > 2 && !bAttached) {
 			shutdown (MySocket, 1);
 			close (MySocket);
 		}
@@ -214,6 +217,7 @@ EventableDescriptor::ScheduleClose
 
 void EventableDescriptor::ScheduleClose (bool after_writing)
 {
+	MyEventMachine->NumCloseScheduled++;
 	// KEEP THIS SYNCHRONIZED WITH ::IsCloseScheduled.
 	if (after_writing)
 		bCloseAfterWriting = true;
@@ -244,6 +248,7 @@ void EventableDescriptor::StartProxy(const unsigned long to, const unsigned long
 		StopProxy();
 		ProxyTarget = ed;
 		BytesToProxy = length;
+		ProxiedBytes = 0;
 		ed->SetProxiedFrom(this, bufsize);
 		return;
 	}
@@ -290,6 +295,7 @@ void EventableDescriptor::_GenericInboundDispatch(const char *buf, int size)
 		if (BytesToProxy > 0) {
 			unsigned long proxied = min(BytesToProxy, (unsigned long) size);
 			ProxyTarget->SendOutboundData(buf, proxied);
+			ProxiedBytes += (unsigned long) proxied;
 			BytesToProxy -= proxied;
 			if (BytesToProxy == 0) {
 				StopProxy();
@@ -300,6 +306,7 @@ void EventableDescriptor::_GenericInboundDispatch(const char *buf, int size)
 			}
 		} else {
 			ProxyTarget->SendOutboundData(buf, size);
+			ProxiedBytes += (unsigned long) size;
 		}
 	} else {
 		(*EventCallback)(GetBinding(), EM_CONNECTION_READ, buf, size);
@@ -457,6 +464,16 @@ void ConnectionDescriptor::SetConnectPending(bool f)
 }
 
 
+/**********************************
+ConnectionDescriptor::SetAttached
+***********************************/
+
+void ConnectionDescriptor::SetAttached(bool state)
+{
+   bAttached = state;
+}
+
+
 /**********************************
 ConnectionDescriptor::SetWatchOnly
 ***********************************/

data/ext/ed.h

@@ -79,6 +79,7 @@ class EventableDescriptor: public Bindable_t
 		virtual int SetCommInactivityTimeout (uint64_t value) {return 0;}
 		uint64_t GetPendingConnectTimeout();
 		int SetPendingConnectTimeout (uint64_t value);
+		uint64_t GetLastActivity() { return LastActivity; }
 
 		#ifdef HAVE_EPOLL
 		struct epoll_event *GetEpollEvent() { return &EpollEvent; }
@@ -86,6 +87,7 @@ class EventableDescriptor: public Bindable_t
 
 		virtual void StartProxy(const unsigned long, const unsigned long, const unsigned long);
 		virtual void StopProxy();
+		virtual unsigned long GetProxiedBytes(){ return ProxiedBytes; };
 		virtual void SetProxiedFrom(EventableDescriptor*, const unsigned long);
 		virtual int SendOutboundData(const char*,int){ return -1; }
 		virtual bool IsPaused(){ return bPaused; }
@@ -103,6 +105,7 @@ class EventableDescriptor: public Bindable_t
 
 	protected:
 		int MySocket;
+		bool bAttached;
 		bool bWatchOnly;
 
 		EMCallback EventCallback;
@@ -115,6 +118,7 @@ class EventableDescriptor: public Bindable_t
 		unsigned long BytesToProxy;
 		EventableDescriptor *ProxyTarget;
 		EventableDescriptor *ProxiedFrom;
+		unsigned long ProxiedBytes;
 
 		unsigned long MaxOutboundBufSize;
 
@@ -169,6 +173,7 @@ class ConnectionDescriptor: public EventableDescriptor
 
 		void SetNotifyReadable (bool);
 		void SetNotifyWritable (bool);
+		void SetAttached (bool);
 		void SetWatchOnly (bool);
 
 		bool Pause();

data/ext/em.cpp

@@ -73,6 +73,7 @@ EventMachine_t::EventMachine_t (EMCallback event_callback):
 	NextHeartbeatTime (0),
 	LoopBreakerReader (-1),
 	LoopBreakerWriter (-1),
+	NumCloseScheduled (0),
 	bTerminateSignalReceived (false),
 	bEpoll (false),
 	epfd (-1),
@@ -197,10 +198,9 @@ EventMachine_t::SetTimerQuantum
 void EventMachine_t::SetTimerQuantum (int interval)
 {
 	/* We get a timer-quantum expressed in milliseconds.
-	 * Don't set a quantum smaller than 5 or larger than 2500.
 	 */
 
-	if ((interval < 5) || (interval > 2500))
+	if ((interval < 5) || (interval > 5*60*1000))
 		throw std::runtime_error ("invalid timer-quantum");
 
 	Quantum.tv_sec = interval / 1000;
@@ -673,7 +673,13 @@ EventMachine_t::_TimeTilNextEvent
 
 timeval EventMachine_t::_TimeTilNextEvent()
 {
+	// 29jul11: Changed calculation base from MyCurrentLoopTime to the 
+	// real time. As MyCurrentLoopTime is set at the beginning of an
+	// iteration and this calculation is done at the end, evenmachine
+	// will potentially oversleep by the amount of time the iteration
+	// took to execute.
 	uint64_t next_event = 0;
+	uint64_t current_time = GetRealTime();
 
 	if (!Heartbeats.empty()) {
 		multimap<uint64_t,EventableDescriptor*>::iterator heartbeats = Heartbeats.begin();
@@ -687,16 +693,16 @@ timeval EventMachine_t::_TimeTilNextEvent()
 	}
 
 	if (!NewDescriptors.empty() || !ModifiedDescriptors.empty()) {
-		next_event = MyCurrentLoopTime;
+		next_event = current_time;
 	}
-
+	
 	timeval tv;
 
-	if (next_event == 0) {
+	if (next_event == 0 || NumCloseScheduled > 0) {
 		tv = Quantum;
 	} else {
-		if (next_event > MyCurrentLoopTime) {
-			uint64_t duration = next_event - MyCurrentLoopTime;
+		if (next_event > current_time) {
+			uint64_t duration = next_event - current_time;
 			tv.tv_sec = duration / 1000000;
 			tv.tv_usec = duration % 1000000;
 		} else {
@@ -1356,6 +1362,7 @@ const unsigned long EventMachine_t::AttachFD (int fd, bool watch_mode)
 	if (!cd)
 		throw std::runtime_error ("no connection allocated");
 
+	cd->SetAttached(true);
 	cd->SetWatchOnly(watch_mode);
 	cd->SetConnectPending (false);
 
@@ -1395,7 +1402,11 @@ int EventMachine_t::DetachFD (EventableDescriptor *ed)
 	if (bKqueue) {
 		// remove any read/write events for this fd
 		struct kevent k;
+#ifdef __NetBSD__
+		EV_SET (&k, ed->GetSocket(), EVFILT_READ | EVFILT_WRITE, EV_DELETE, 0, 0, (intptr_t)ed);
+#else
 		EV_SET (&k, ed->GetSocket(), EVFILT_READ | EVFILT_WRITE, EV_DELETE, 0, 0, ed);
+#endif
 		int t = kevent (kqfd, &k, 1, NULL, 0, NULL);
 		if (t < 0 && (errno != ENOENT) && (errno != EBADF)) {
 			char buf [200];
@@ -1651,7 +1662,11 @@ void EventMachine_t::ArmKqueueWriter (EventableDescriptor *ed)
 		if (!ed)
 			throw std::runtime_error ("added bad descriptor");
 		struct kevent k;
+#ifdef __NetBSD__
+		EV_SET (&k, ed->GetSocket(), EVFILT_WRITE, EV_ADD | EV_ONESHOT, 0, 0, (intptr_t)ed);
+#else
 		EV_SET (&k, ed->GetSocket(), EVFILT_WRITE, EV_ADD | EV_ONESHOT, 0, 0, ed);
+#endif
 		int t = kevent (kqfd, &k, 1, NULL, 0, NULL);
 		if (t < 0) {
 			char buf [200];
@@ -1673,7 +1688,11 @@ void EventMachine_t::ArmKqueueReader (EventableDescriptor *ed)
 		if (!ed)
 			throw std::runtime_error ("added bad descriptor");
 		struct kevent k;
+#ifdef __NetBSD__
+		EV_SET (&k, ed->GetSocket(), EVFILT_READ, EV_ADD, 0, 0, (intptr_t)ed);
+#else
 		EV_SET (&k, ed->GetSocket(), EVFILT_READ, EV_ADD, 0, 0, ed);
+#endif
 		int t = kevent (kqfd, &k, 1, NULL, 0, NULL);
 		if (t < 0) {
 			char buf [200];
@@ -1724,7 +1743,11 @@ void EventMachine_t::_AddNewDescriptors()
 			// INCOMPLETE. Some descriptors don't want to be readable.
 			assert (kqfd != -1);
 			struct kevent k;
+#ifdef __NetBSD__
+			EV_SET (&k, ed->GetSocket(), EVFILT_READ, EV_ADD, 0, 0, (intptr_t)ed);
+#else
 			EV_SET (&k, ed->GetSocket(), EVFILT_READ, EV_ADD, 0, 0, ed);
+#endif
 			int t = kevent (kqfd, &k, 1, NULL, 0, NULL);
 			assert (t == 0);
 		}

data/ext/em.h

@@ -44,10 +44,10 @@ See the file COPYING for complete licensing information.
     #define RUBY_UBF_IO RB_UBF_DFL
   #endif
   #ifndef RSTRING_PTR
-    #define RSTRING_PTR(str) RString(str)->ptr
+    #define RSTRING_PTR(str) RSTRING(str)->ptr
   #endif
   #ifndef RSTRING_LEN
-    #define RSTRING_LEN(str) RString(str)->len
+    #define RSTRING_LEN(str) RSTRING(str)->len
   #endif
   #ifndef RSTRING_LENINT
     #define RSTRING_LENINT(str) RSTRING_LEN(str)
@@ -161,6 +161,7 @@ class EventMachine_t
 	public:
 		void _ReadLoopBreaker();
 		void _ReadInotifyEvents();
+        int NumCloseScheduled;
 
 	private:
 		enum {

data/ext/eventmachine.h

@@ -59,6 +59,8 @@ extern "C" {
 	int evma_is_paused(const unsigned long binding);
 	int evma_resume(const unsigned long binding);
 
+    int evma_num_close_scheduled();
+
 	void evma_stop_tcp_server (const unsigned long signature);
 	const unsigned long evma_create_tcp_server (const char *address, int port);
 	const unsigned long evma_create_unix_domain_server (const char *filename);
@@ -84,6 +86,7 @@ extern "C" {
 	float evma_get_pending_connect_timeout (const unsigned long binding);
 	int evma_set_pending_connect_timeout (const unsigned long binding, float value);
 	int evma_get_outbound_data_size (const unsigned long binding);
+	uint64_t evma_get_last_activity_time (const unsigned long);
 	int evma_send_file_data_to_connection (const unsigned long binding, const char *filename);
 
 	void evma_close_connection (const unsigned long binding, int after_writing);
@@ -107,6 +110,7 @@ extern "C" {
 
 	void evma_start_proxy(const unsigned long, const unsigned long, const unsigned long, const unsigned long);
 	void evma_stop_proxy(const unsigned long);
+	unsigned long evma_proxied_bytes(const unsigned long);
 
 	int evma_set_rlimit_nofile (int n_files);
 

data/ext/extconf.rb

@@ -92,7 +92,7 @@ end
 case RUBY_PLATFORM
 when /mswin32/, /mingw32/, /bccwin32/
   check_heads(%w[windows.h winsock.h], true)
-  check_libs(%w[kernel32 rpcrt4 gdi32], true)# unless ENV['CROSS_COMPILING']
+  check_libs(%w[kernel32 rpcrt4 gdi32], true)
 
   if GNU_CHAIN
     CONFIG['LDSHARED'] = "$(CXX) -shared -lstdc++"
@@ -139,6 +139,15 @@ when /linux/
 when /aix/
   CONFIG['LDSHARED'] = "$(CXX) -shared -Wl,-G -Wl,-brtl"
 
+when /cygwin/
+  # For rubies built with Cygwin, CXX may be set to CC, which is just
+  # a wrapper for gcc.
+  # This will compile, but it will not link to the C++ std library.
+  # Explicitly set CXX to use g++.
+  CONFIG['CXX'] = "g++"
+  # on Unix we need a g++ link, not gcc.
+  CONFIG['LDSHARED'] = "$(CXX) -shared"
+
 else
   # on Unix we need a g++ link, not gcc.
   CONFIG['LDSHARED'] = "$(CXX) -shared"
@@ -154,4 +163,4 @@ add_define 'HAVE_MAKE_PAIR' if try_link(<<SRC, '-lstdc++')
 SRC
 TRY_LINK.sub!('$(CXX)', '$(CC)')
 
-create_makefile "rubyeventmachine"
+create_makefile "rubyeventmachine"

data/ext/fastfilereader/extconf.rb

@@ -77,9 +77,18 @@ when /aix/
   # on Unix we need a g++ link, not gcc.
   CONFIG['LDSHARED'] = "$(CXX) -shared -Wl,-G"
 
+when /cygwin/
+  # For rubies built with Cygwin, CXX may be set to CC, which is just
+  # a wrapper for gcc.
+  # This will compile, but it will not link to the C++ std library.
+  # Explicitly set CXX to use g++.
+  CONFIG['CXX'] = "g++"
+  # on Unix we need a g++ link, not gcc.
+  CONFIG['LDSHARED'] = "$(CXX) -shared"
+
 else
   # on Unix we need a g++ link, not gcc.
   CONFIG['LDSHARED'] = "$(CXX) -shared"
 end
 
-create_makefile "fastfilereaderext"
+create_makefile "fastfilereaderext"

data/ext/project.h

@@ -82,7 +82,8 @@ typedef int SOCKET;
 
 #ifdef OS_WIN32
 // 21Sep09: windows limits select() to 64 sockets by default, we increase it to 1024 here (before including winsock2.h)
-#define FD_SETSIZE 1024
+// 18Jun12: fd_setsize must be changed in the ruby binary (not in this extension). redefining it also causes segvs, see eventmachine/eventmachine#333
+//#define FD_SETSIZE 1024
 
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>

data/ext/rubymain.cpp

@@ -507,7 +507,7 @@ static VALUE t_connect_server (VALUE self, VALUE server, VALUE port)
 			rb_raise (EM_eConnectionError, "no connection");
 		return ULONG2NUM (f);
 	} catch (std::runtime_error e) {
-		rb_raise (EM_eConnectionError, e.what());
+		rb_raise (EM_eConnectionError, "%s", e.what());
 	}
 	return Qnil;
 }
@@ -528,7 +528,7 @@ static VALUE t_bind_connect_server (VALUE self, VALUE bind_addr, VALUE bind_port
 			rb_raise (EM_eConnectionError, "no connection");
 		return ULONG2NUM (f);
 	} catch (std::runtime_error e) {
-		rb_raise (EM_eConnectionError, e.what());
+		rb_raise (EM_eConnectionError, "%s", e.what());
 	}
 	return Qnil;
 }
@@ -686,6 +686,15 @@ static VALUE t_paused_p (VALUE self, VALUE signature)
 	return evma_is_paused(NUM2ULONG (signature)) ? Qtrue : Qfalse;
 }
 
+/*********************
+t_num_close_scheduled
+*********************/
+
+static VALUE t_num_close_scheduled (VALUE self)
+{
+	return INT2FIX(evma_num_close_scheduled());
+}
+
 /*****************
 t_open_udp_socket
 *****************/
@@ -839,7 +848,7 @@ static VALUE t_watch_filename (VALUE self, VALUE fname)
 	try {
 		return ULONG2NUM(evma_watch_filename(StringValuePtr(fname)));
 	} catch (std::runtime_error e) {
-		rb_raise (EM_eUnsupported, e.what());
+		rb_raise (EM_eUnsupported, "%s", e.what());
 	}
 	return Qnil;
 }
@@ -865,7 +874,7 @@ static VALUE t_watch_pid (VALUE self, VALUE pid)
 	try {
 		return ULONG2NUM(evma_watch_pid(NUM2INT(pid)));
 	} catch (std::runtime_error e) {
-		rb_raise (EM_eUnsupported, e.what());
+		rb_raise (EM_eUnsupported, "%s", e.what());
 	}
 	return Qnil;
 }
@@ -1065,7 +1074,7 @@ static VALUE t_start_proxy (VALUE self, VALUE from, VALUE to, VALUE bufsize, VAL
 	try {
 		evma_start_proxy(NUM2ULONG (from), NUM2ULONG (to), NUM2ULONG(bufsize), NUM2ULONG(length));
 	} catch (std::runtime_error e) {
-		rb_raise (EM_eConnectionError, e.what());
+		rb_raise (EM_eConnectionError, "%s", e.what());
 	}
 	return Qnil;
 }
@@ -1080,11 +1089,49 @@ static VALUE t_stop_proxy (VALUE self, VALUE from)
 	try{
 		evma_stop_proxy(NUM2ULONG (from));
 	} catch (std::runtime_error e) {
-		rb_raise (EM_eConnectionError, e.what());
+		rb_raise (EM_eConnectionError, "%s", e.what());
 	}
 	return Qnil;
 }
 
+/***************
+t_proxied_bytes
+****************/
+
+static VALUE t_proxied_bytes (VALUE self, VALUE from)
+{
+	try{
+		return ULONG2NUM(evma_proxied_bytes(NUM2ULONG (from)));
+	} catch (std::runtime_error e) {
+		rb_raise (EM_eConnectionError, "%s", e.what());
+	}
+	return Qnil;
+}
+
+/***************
+t_get_idle_time
+****************/
+
+static VALUE t_get_idle_time (VALUE self, VALUE from)
+{
+	try{
+		uint64_t current_time = evma_get_current_loop_time();
+		uint64_t time = evma_get_last_activity_time(NUM2ULONG (from));
+		if (current_time != 0 && time != 0) {
+			if (time >= current_time)
+				return ULONG2NUM(0);
+			else {
+				uint64_t diff = current_time - time;
+				float seconds = diff / (1000.0*1000.0);
+				return rb_float_new(seconds);
+			}
+			return Qnil;
+		}
+	} catch (std::runtime_error e) {
+		rb_raise (EM_eConnectionError, "%s", e.what());
+	}
+	return Qnil;
+}
 
 /************************
 t_get_heartbeat_interval
@@ -1180,9 +1227,11 @@ extern "C" void Init_rubyeventmachine()
 	rb_define_module_function (EmModule, "pause_connection", (VALUE (*)(...))t_pause, 1);
 	rb_define_module_function (EmModule, "resume_connection", (VALUE (*)(...))t_resume, 1);
 	rb_define_module_function (EmModule, "connection_paused?", (VALUE (*)(...))t_paused_p, 1);
+	rb_define_module_function (EmModule, "num_close_scheduled", (VALUE (*)(...))t_num_close_scheduled, 0);
 
 	rb_define_module_function (EmModule, "start_proxy", (VALUE (*)(...))t_start_proxy, 4);
 	rb_define_module_function (EmModule, "stop_proxy", (VALUE (*)(...))t_stop_proxy, 1);
+	rb_define_module_function (EmModule, "get_proxied_bytes", (VALUE (*)(...))t_proxied_bytes, 1);
 
 	rb_define_module_function (EmModule, "watch_filename", (VALUE (*)(...))t_watch_filename, 1);
 	rb_define_module_function (EmModule, "unwatch_filename", (VALUE (*)(...))t_unwatch_filename, 1);
@@ -1206,6 +1255,7 @@ extern "C" void Init_rubyeventmachine()
 	rb_define_module_function (EmModule, "send_file_data", (VALUE(*)(...))t_send_file_data, 2);
 	rb_define_module_function (EmModule, "get_heartbeat_interval", (VALUE(*)(...))t_get_heartbeat_interval, 0);
 	rb_define_module_function (EmModule, "set_heartbeat_interval", (VALUE(*)(...))t_set_heartbeat_interval, 1);
+	rb_define_module_function (EmModule, "get_idle_time", (VALUE(*)(...))t_get_idle_time, 1);
 
 	rb_define_module_function (EmModule, "get_peername", (VALUE(*)(...))t_get_peername, 1);
 	rb_define_module_function (EmModule, "get_sockname", (VALUE(*)(...))t_get_sockname, 1);

data/ext/ssl.cpp

@@ -137,7 +137,7 @@ SslContext_t::SslContext_t (bool is_server, const string &privkeyfile, const str
 		bLibraryInitialized = true;
 		SSL_library_init();
 		OpenSSL_add_ssl_algorithms();
-	        OpenSSL_add_all_algorithms();
+		OpenSSL_add_all_algorithms();
 		SSL_load_error_strings();
 		ERR_load_crypto_strings();
 
@@ -151,6 +151,9 @@ SslContext_t::SslContext_t (bool is_server, const string &privkeyfile, const str
 
 	SSL_CTX_set_options (pCtx, SSL_OP_ALL);
 	//SSL_CTX_set_options (pCtx, (SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3));
+#ifdef SSL_MODE_RELEASE_BUFFERS
+	SSL_CTX_set_mode (pCtx, SSL_MODE_RELEASE_BUFFERS);
+#endif
 
 	if (is_server) {
 		// The SSL_CTX calls here do NOT allocate memory.

data/java/src/com/rubyeventmachine/EmReactor.java

@@ -524,6 +524,10 @@ public class EmReactor {
 		return Connections.get(sig).getPeerName();
 	}
 
+	public Object[] getSockName (long sig) {
+		return Connections.get(sig).getSockName();
+	}
+
 	public long attachChannel (SocketChannel sc, boolean watch_mode) {
 		long b = createBinding();
 

data/java/src/com/rubyeventmachine/EventableChannel.java

@@ -60,6 +60,7 @@ public interface EventableChannel {
 	public void setCommInactivityTimeout (long seconds);
 
 	public Object[] getPeerName();
+	public Object[] getSockName();
 
 	public boolean isWatchOnly();
 

data/java/src/com/rubyeventmachine/EventableDatagramChannel.java

@@ -183,6 +183,12 @@ public class EventableDatagramChannel implements EventableChannel {
 		}
 	}
 
+	public Object[] getSockName () {
+		DatagramSocket socket = channel.socket();
+		return new Object[]{ socket.getLocalPort(),
+							 socket.getLocalAddress().getHostAddress() };
+	}
+
 	public boolean isWatchOnly() { return false; }
 	public boolean isNotifyReadable() { return false; }
 	public boolean isNotifyWritable() { return false; }

data/java/src/com/rubyeventmachine/EventableSocketChannel.java

@@ -302,6 +302,12 @@ public class EventableSocketChannel implements EventableChannel {
 		return new Object[]{ sock.getPort(), sock.getInetAddress().getHostAddress() };
 	}
 
+	public Object[] getSockName () {
+		Socket sock = channel.socket();
+		return new Object[]{ sock.getLocalPort(),
+							 sock.getLocalAddress().getHostAddress() };
+	}
+
 	public void setWatchOnly() {
 		bWatchOnly = true;
 		updateEvents();

data/lib/em/connection.rb

@@ -238,6 +238,12 @@ module EventMachine
       EventMachine::disable_proxy(self)
     end
 
+    # The number of bytes proxied to another connection. Reset to zero when
+    # EventMachine::Connection#proxy_incoming_to is called, and incremented whenever data is proxied.
+    def get_proxied_bytes
+      EventMachine::get_proxied_bytes(@signature)
+    end
+
     # EventMachine::Connection#close_connection is called only by user code, and never
     # by the event loop. You may call this method against a connection object in any
     # callback handler, whether or not the callback was made against the connection
@@ -570,6 +576,11 @@ module EventMachine
       EventMachine::get_subprocess_status @signature
     end
 
+    # The number of seconds since the last send/receive activity on this connection.
+    def get_idle_time
+      EventMachine::get_idle_time @signature
+    end
+
     # comm_inactivity_timeout returns the current value (float 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

data/lib/em/pool.rb

@@ -122,7 +122,10 @@ module EventMachine
 
     def failure resource
       if @on_error
+        @contents.delete resource
         @on_error.call resource
+        # Prevent users from calling a leak.
+        @removed.delete resource
       else
         requeue resource
       end
@@ -140,7 +143,9 @@ module EventMachine
       else
         raise ArgumentError, "deferrable expected from work"
       end
+    rescue Exception
+      failure resource
+      raise
     end
-
   end
-end
+end

data/lib/em/protocols/smtpclient.rb

@@ -31,38 +31,38 @@ module EventMachine
     # Simple SMTP client
     #
     # @example
-    #  email = EM::Protocols::SmtpClient.send(
-    #    :domain=>"example.com",
-    #    :host=>'localhost',
-    #    :port=>25, # optional, defaults 25
-    #    :starttls=>true, # use ssl
-    #    :from=>"sender@example.com",
-    #    :to=> ["to_1@example.com", "to_2@example.com"],
-    #    :header=> {"Subject" => "This is a subject line"},
-    #    :body=> "This is the body of the email"
-    #  )
-    #  email.callback{
-    #    puts 'Email sent!'
-    #  }
-    #  email.errback{ |e|
-    #    puts 'Email failed!'
-    #  }
+    #   email = EM::Protocols::SmtpClient.send(
+    #     :domain=>"example.com",
+    #     :host=>'localhost',
+    #     :port=>25, # optional, defaults 25
+    #     :starttls=>true, # use ssl
+    #     :from=>"sender@example.com",
+    #     :to=> ["to_1@example.com", "to_2@example.com"],
+    #     :header=> {"Subject" => "This is a subject line"},
+    #     :body=> "This is the body of the email"
+    #   )
+    #   email.callback{
+    #     puts 'Email sent!'
+    #   }
+    #   email.errback{ |e|
+    #     puts 'Email failed!'
+    #   }
     #
     # Sending generated emails (using mailfactory)
     #
-    #  mail = MailFactory.new
-    #  mail.to = 'someone@site.co'
-    #  mail.from = 'me@site.com'
-    #  mail.subject = 'hi!'
-    #  mail.text = 'hello world'
-    #  mail.html = '<h1>hello world</h1>'
+    #   mail = MailFactory.new
+    #   mail.to = 'someone@site.co'
+    #   mail.from = 'me@site.com'
+    #   mail.subject = 'hi!'
+    #   mail.text = 'hello world'
+    #   mail.html = '<h1>hello world</h1>'
     #
-    #  email = EM::P::SmtpClient.send(
-    #    :domain=>'site.com',
-    #    :from=>mail.from,
-    #    :to=>mail.to,
-    #    :content=>"#{mail.to_s}\r\n.\r\n"
-    #  )
+    #   email = EM::P::SmtpClient.send(
+    #     :domain=>'site.com',
+    #     :from=>mail.from,
+    #     :to=>mail.to,
+    #     :content=>"#{mail.to_s}\r\n.\r\n"
+    #   )
     #
     class SmtpClient < Connection
       include EventMachine::Deferrable

data/lib/em/threaded_resource.rb

@@ -29,7 +29,7 @@ module EventMachine
   #
   #    # If we don't care about the result:
   #    pool.perform do |dispatcher|
-  #      # The following blcok executes inside a dedicated thread, and should not
+  #      # The following block executes inside a dedicated thread, and should not
   #      # access EventMachine things:
   #      dispatcher.dispatch do |cassandra|
   #        cassandra.insert(:Things, '10', 'stuff' => 'things')

data/lib/em/version.rb

@@ -1,3 +1,3 @@
 module EventMachine
-  VERSION = "1.0.0.beta.4"
+  VERSION = "1.0.0.rc.1"
 end

data/lib/eventmachine.rb

@@ -82,7 +82,8 @@ module EventMachine
   @reactor_running = false
   @next_tick_queue = []
   @tails = []
-  @threadpool = nil
+  @threadpool = @threadqueue = @resultqueue = nil
+  @all_threads_spawned = false
 
   # System errnos
   # @private
@@ -155,7 +156,13 @@ module EventMachine
     # will start without release_machine being called and will immediately throw
 
     #
-
+    if reactor_running? and @reactor_pid != Process.pid
+      # Reactor was started in a different parent, meaning we have forked.
+      # Clean up reactor state so a new reactor boots up in this child.
+      stop_event_loop
+      release_machine
+      @reactor_running = false
+    end
 
     tail and @tails.unshift(tail)
 
@@ -169,6 +176,7 @@ module EventMachine
       @next_tick_queue ||= []
       @tails ||= []
       begin
+        @reactor_pid = Process.pid
         @reactor_running = true
         initialize_event_machine
         (b = blk || block) and add_timer(0, b)
@@ -201,6 +209,7 @@ module EventMachine
             @threadqueue = nil
             @resultqueue = nil
             @threadpool = nil
+            @all_threads_spawned = false
           end
 
           @next_tick_queue = []
@@ -252,7 +261,7 @@ module EventMachine
       if self.reactor_running?
         self.stop_event_loop
         self.release_machine
-        self.instance_variable_set( '@reactor_running', false )
+        @reactor_running = false
       end
       self.run block
     end
@@ -425,7 +434,8 @@ module EventMachine
   # that you must define. When the network server that is started by
   # start_server accepts a new connection, it instantiates a new
   # object of an anonymous class that is inherited from {EventMachine::Connection},
-  # *into which your handler module have been included*.
+  # *into which your handler module have been included*. Arguments passed into start_server
+  # after the class name are passed into the constructor during the instantiation.
   #
   # Your handler module may override any of the methods in {EventMachine::Connection},
   # such as {EventMachine::Connection#receive_data}, in order to implement the specific behavior
@@ -736,6 +746,7 @@ module EventMachine
     c = klass.new s, *args
 
     c.instance_variable_set(:@io, io)
+    c.instance_variable_set(:@watch_mode, watch_mode)
     c.instance_variable_set(:@fd, fd)
 
     @conns[s] = c
@@ -761,7 +772,11 @@ module EventMachine
     #raise "still connected" if @conns.has_key?(handler.signature)
     return handler if @conns.has_key?(handler.signature)
 
-    s = connect_server server, port
+    s = if port
+          connect_server server, port
+        else
+          connect_unix_server server
+        end
     handler.signature = s
     @conns[s] = handler
     block_given? and yield handler
@@ -936,10 +951,21 @@ module EventMachine
       cback.call result if cback
     end
 
-    @next_tick_mutex.synchronize do
-      jobs, @next_tick_queue = @next_tick_queue, []
-      jobs
-    end.each { |j| j.call }
+    # Capture the size at the start of this tick...
+    size = @next_tick_mutex.synchronize { @next_tick_queue.size }
+    size.times do |i|
+      callback = @next_tick_mutex.synchronize { @next_tick_queue.shift }
+      begin
+        callback.call
+      ensure
+        # This is a little nasty. The problem is, if an exception occurs during
+        # the callback, then we need to send a signal to the reactor to actually
+        # do some work during the next_tick. The only mechanism we have from the
+        # ruby side is next_tick itself, although ideally, we'd just drop a byte
+        # on the loopback descriptor.
+        EM.next_tick {} if $!
+      end
+    end
   end
 
 
@@ -991,7 +1017,6 @@ module EventMachine
     # has no constructor.
 
     unless @threadpool
-      require 'thread'
       @threadpool = []
       @threadqueue = ::Queue.new
       @resultqueue = ::Queue.new
@@ -1016,6 +1041,19 @@ module EventMachine
       end
       @threadpool << thread
     end
+    @all_threads_spawned = true
+  end
+
+  ##
+  # Returns +true+ if all deferred actions are done executing and their
+  # callbacks have been fired.
+  #
+  def self.defers_finished?
+    return false if @threadpool and !@all_threads_spawned
+    return false if @threadqueue and not @threadqueue.empty?
+    return false if @resultqueue and not @resultqueue.empty?
+    return false if @threadpool and @threadqueue.num_waiting != @threadpool.size
+    return true
   end
 
   class << self
@@ -1391,11 +1429,19 @@ module EventMachine
     if opcode == ConnectionUnbound
       if c = @conns.delete( conn_binding )
         begin
-          if c.original_method(:unbind).arity == 1
+          if c.original_method(:unbind).arity != 0
             c.unbind(data == 0 ? nil : EventMachine::ERRNOS[data])
           else
             c.unbind
           end
+          # If this is an attached (but not watched) connection, close the underlying io object.
+          if c.instance_variable_defined?(:@io) and !c.instance_variable_get(:@watch_mode)
+            io = c.instance_variable_get(:@io)
+            begin
+              io.close
+            rescue Errno::EBADF, IOError
+            end
+          end
         rescue
           @wrapped_exception = $!
           stop

data/lib/jeventmachine.rb

@@ -203,6 +203,11 @@ module EventMachine
       Socket.pack_sockaddr_in(*peer)
     end
   end
+  def self.get_sockname sig
+    if sockName = @em.getSockName(sig)
+      Socket.pack_sockaddr_in(*sockName)
+    end
+  end
   # @private
   def self.attach_fd fileno, watch_mode
     # 3Aug09: We could pass in the actual SocketChannel, but then it would be modified (set as non-blocking), and

data/tests/test_basic.rb

@@ -224,4 +224,71 @@ class TestBasic < Test::Unit::TestCase
       end
     end
   end
+  
+  def test_schedule_close
+    localhost, port = '127.0.0.1', 9000
+    timer_ran = false
+    num_close_scheduled = nil
+    EM.run do
+      assert_equal 0, EM.num_close_scheduled
+      EM.add_timer(1) { timer_ran = true; EM.stop }
+      EM.start_server localhost, port do |s|
+        s.close_connection
+        num_close_scheduled = EM.num_close_scheduled
+      end
+      EM.connect localhost, port do |c|
+        def c.unbind
+          EM.stop
+        end
+      end
+    end
+    assert !timer_ran
+    assert_equal 1, num_close_scheduled
+  end
+
+  def test_fork_safe
+    return unless cpid = fork { exit! } rescue false
+
+    read, write = IO.pipe
+    EM.run do
+      cpid = fork do
+        write.puts "forked"
+        EM.run do
+          EM.next_tick do
+            write.puts "EM ran"
+            exit!
+          end
+        end
+      end
+      EM.stop
+    end
+    Process.waitall
+    assert_equal "forked\n", read.readline
+    assert_equal "EM ran\n", read.readline
+  ensure
+    read.close rescue nil
+    write.close rescue nil
+  end
+
+  def test_error_handler_idempotent # issue 185
+    errors = []
+    ticks = []
+    EM.error_handler do |e|
+      errors << e
+    end
+
+    EM.run do
+      EM.next_tick do
+        ticks << :first
+        raise
+      end
+      EM.next_tick do
+        ticks << :second
+      end
+      EM.add_timer(0.001) { EM.stop }
+    end
+
+    assert_equal 1, errors.size
+    assert_equal [:first, :second], ticks
+  end
 end

data/tests/test_idle_connection.rb

@@ -0,0 +1,23 @@
+require 'em_test_helper'
+
+class TestIdleConnection < Test::Unit::TestCase
+  if EM.respond_to?(:get_idle_time)
+    def test_idle_time
+      EM.run{
+        conn = EM.connect 'www.google.com', 80
+        EM.add_timer(3){
+          $idle_time = conn.get_idle_time
+          conn.send_data "GET / HTTP/1.0\r\n\r\n"
+          EM.next_tick{
+            $idle_time_after_send = conn.get_idle_time
+            conn.close_connection
+            EM.stop
+          }
+        }
+      }
+
+      assert_in_delta 3, $idle_time, 0.2
+      assert_equal 0, $idle_time_after_send
+    end
+  end
+end

data/tests/test_pool.rb

@@ -115,6 +115,41 @@ class TestPool < Test::Unit::TestCase
     assert_equal [:res], pool.contents
   end
 
+  def test_contents_when_perform_errors_and_on_error_is_not_set
+    pool.add :res
+    assert_equal [:res], pool.contents
+
+    pool.perform do |r|
+      d = EM::DefaultDeferrable.new
+      d.fail
+      d
+    end
+
+    EM.run { EM.next_tick { EM.stop } }
+
+    assert_equal [:res], pool.contents
+  end
+
+  def test_contents_when_perform_errors_and_on_error_is_set
+    pool.add :res
+    res = nil
+    pool.on_error do |r|
+      res = r
+    end
+    assert_equal [:res], pool.contents
+
+    pool.perform do |r|
+      d = EM::DefaultDeferrable.new
+      d.fail 'foo'
+      d
+    end
+
+    EM.run { EM.next_tick { EM.stop } }
+
+    assert_equal :res, res
+    assert_equal [], pool.contents
+  end
+
   def test_num_waiting
     pool.add :res
     assert_equal 0, pool.num_waiting
@@ -125,4 +160,35 @@ class TestPool < Test::Unit::TestCase
     assert_equal 10, pool.num_waiting
   end
 
-end
+  def test_exceptions_in_the_work_block_bubble_up_raise_and_fail_the_resource
+    pool.add :res
+
+    res = nil
+    pool.on_error { |r| res = r }
+    pool.perform { raise 'boom' }
+
+    assert_raises(RuntimeError) do
+      EM.run { EM.next_tick { EM.stop } }
+    end
+
+    assert_equal [], pool.contents
+    assert_equal :res, res
+  end
+
+  def test_removed_list_does_not_leak_on_errors
+    pool.add :res
+
+    pool.on_error do |r|
+      # This is actually the wrong thing to do, and not required, but some users
+      # might do it. When they do, they would find that @removed would cause a
+      # slow leak.
+      pool.remove r
+    end
+
+    pool.perform { d = EM::DefaultDeferrable.new; d.fail; d }
+
+    EM.run { EM.next_tick { EM.stop } }
+    assert_equal [], pool.instance_variable_get(:@removed)
+  end
+
+end

data/tests/test_proxy_connection.rb

@@ -24,6 +24,7 @@ class TestProxyConnection < Test::Unit::TestCase
       end
 
       def unbind
+        $proxied_bytes = self.get_proxied_bytes
         @client.close_connection_after_writing
       end
     end
@@ -94,7 +95,7 @@ class TestProxyConnection < Test::Unit::TestCase
       end
 
       def receive_data(data)
-        EM.connect("127.0.0.1", @port, ProxyConnection, self, data)
+        @proxy = EM.connect("127.0.0.1", @port, ProxyConnection, self, data)
       end
     end
 
@@ -134,6 +135,17 @@ class TestProxyConnection < Test::Unit::TestCase
       assert_equal("I know!", $client_data)
     end
 
+    def test_proxied_bytes
+      EM.run {
+        EM.start_server("127.0.0.1", @port, Server)
+        EM.start_server("127.0.0.1", @proxy_port, ProxyServer, @port)
+        EM.connect("127.0.0.1", @proxy_port, Client)
+      }
+
+      assert_equal("I know!", $client_data)
+      assert_equal("I know!".bytesize, $proxied_bytes)
+    end
+
     def test_partial_proxy_connection
       EM.run {
         EM.start_server("127.0.0.1", @port, Server)

data/tests/test_unbind_reason.rb

@@ -2,6 +2,15 @@ require 'em_test_helper'
 require 'socket'
 
 class TestUnbindReason < Test::Unit::TestCase
+
+  class StubConnection < EM::Connection
+    attr_reader :error
+    def unbind(reason = nil)
+      @error = reason
+      EM.stop
+    end
+  end
+
   def test_connect_timeout
     error = nil
     EM.run {
@@ -13,7 +22,7 @@ class TestUnbindReason < Test::Unit::TestCase
       }
       conn.pending_connect_timeout = 0.1
     }
-    assert_equal error, Errno::ETIMEDOUT
+    assert_equal Errno::ETIMEDOUT, error
   end
 
   def test_connect_refused
@@ -26,6 +35,14 @@ class TestUnbindReason < Test::Unit::TestCase
         end
       }
     }
-    assert_equal error, Errno::ECONNREFUSED
+    assert_equal Errno::ECONNREFUSED, error
+  end
+
+  def test_optional_argument
+    conn = nil
+    EM.run {
+      conn = EM.connect '127.0.0.1', 12388, StubConnection
+    }
+    assert_equal Errno::ECONNREFUSED, conn.error
   end
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: eventmachine
 version: !ruby/object:Gem::Version 
-  hash: 62196363
+  hash: 379161805
   prerelease: 6
   segments: 
   - 1
   - 0
   - 0
-  - beta
-  - 4
-  version: 1.0.0.beta.4
+  - rc
+  - 1
+  version: 1.0.0.rc.1
 platform: x86-mswin32-60
 authors: 
 - Francis Cianfrocca
@@ -18,7 +18,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-15 00:00:00 -07:00
+date: 2012-06-18 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -53,20 +53,6 @@ dependencies:
         version: 0.7.2
   type: :development
   version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: bluecloth
-  prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id003
 description: |-
   EventMachine implements a fast, single-threaded engine for arbitrary network
   communications. It's extremely easy to use in Ruby. EventMachine wraps all
@@ -206,9 +192,9 @@ files:
 - lib/em/version.rb
 - lib/eventmachine.rb
 - lib/jeventmachine.rb
-- tasks/cpp.rake_example
-- tasks/package.rake
-- tasks/test.rake
+- rakelib/cpp.rake_example
+- rakelib/package.rake
+- rakelib/test.rake
 - tests/client.crt
 - tests/client.key
 - tests/em_test_helper.rb
@@ -229,6 +215,7 @@ files:
 - tests/test_hc.rb
 - tests/test_httpclient.rb
 - tests/test_httpclient2.rb
+- tests/test_idle_connection.rb
 - tests/test_inactivity_timeout.rb
 - tests/test_kb.rb
 - tests/test_ltp.rb