eventmachine-maglev- 1.0.0.beta.4 → 1.0.0.rc.4

data/ext/rubymain.cpp

@@ -233,7 +233,7 @@ static VALUE t_add_oneshot_timer (VALUE self, VALUE interval)
 {
 	const unsigned long f = evma_install_oneshot_timer (FIX2INT (interval));
 	if (!f)
-		rb_raise (rb_eRuntimeError, "ran out of timers; use #set_max_timers to increase limit");
+		rb_raise (rb_eRuntimeError, "%s", "ran out of timers; use #set_max_timers to increase limit");
 	return ULONG2NUM (f);
 }
 
@@ -246,7 +246,7 @@ static VALUE t_start_server (VALUE self, VALUE server, VALUE port)
 {
 	const unsigned long f = evma_create_tcp_server (StringValuePtr(server), FIX2INT(port));
 	if (!f)
-		rb_raise (rb_eRuntimeError, "no acceptor (port is in use or requires root privileges)");
+		rb_raise (rb_eRuntimeError, "%s", "no acceptor (port is in use or requires root privileges)");
 	return ULONG2NUM (f);
 }
 
@@ -269,7 +269,7 @@ static VALUE t_start_unix_server (VALUE self, VALUE filename)
 {
 	const unsigned long f = evma_create_unix_domain_server (StringValuePtr(filename));
 	if (!f)
-		rb_raise (rb_eRuntimeError, "no unix-domain acceptor");
+		rb_raise (rb_eRuntimeError, "%s", "no unix-domain acceptor");
 	return ULONG2NUM (f);
 }
 
@@ -504,10 +504,10 @@ static VALUE t_connect_server (VALUE self, VALUE server, VALUE port)
 	try {
 		const unsigned long f = evma_connect_to_server (NULL, 0, StringValuePtr(server), NUM2INT(port));
 		if (!f)
-			rb_raise (EM_eConnectionError, "no connection");
+			rb_raise (EM_eConnectionError, "%s", "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;
 }
@@ -525,10 +525,10 @@ static VALUE t_bind_connect_server (VALUE self, VALUE bind_addr, VALUE bind_port
 	try {
 		const unsigned long f = evma_connect_to_server (StringValuePtr(bind_addr), NUM2INT(bind_port), StringValuePtr(server), NUM2INT(port));
 		if (!f)
-			rb_raise (EM_eConnectionError, "no connection");
+			rb_raise (EM_eConnectionError, "%s", "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;
 }
@@ -541,7 +541,7 @@ static VALUE t_connect_unix_server (VALUE self, VALUE serversocket)
 {
 	const unsigned long f = evma_connect_to_unix_server (StringValuePtr(serversocket));
 	if (!f)
-		rb_raise (rb_eRuntimeError, "no connection");
+		rb_raise (rb_eRuntimeError, "%s", "no connection");
 	return ULONG2NUM (f);
 }
 
@@ -553,7 +553,7 @@ static VALUE t_attach_fd (VALUE self, VALUE file_descriptor, VALUE watch_mode)
 {
 	const unsigned long f = evma_attach_fd (NUM2INT(file_descriptor), watch_mode == Qtrue);
 	if (!f)
-		rb_raise (rb_eRuntimeError, "no connection");
+		rb_raise (rb_eRuntimeError, "%s", "no connection");
 	return ULONG2NUM (f);
 }
 
@@ -583,6 +583,44 @@ static VALUE t_get_sock_opt (VALUE self, VALUE signature, VALUE lev, VALUE optna
 	return rb_str_new(buf, len);
 }
 
+/**************
+t_set_sock_opt
+**************/
+
+static VALUE t_set_sock_opt (VALUE self, VALUE signature, VALUE lev, VALUE optname, VALUE optval)
+{
+	int fd = evma_get_file_descriptor (NUM2ULONG (signature));
+	int level = NUM2INT(lev), option = NUM2INT(optname);
+	int i;
+	void *v;
+	socklen_t len;
+
+	switch (TYPE(optval)) {
+	case T_FIXNUM:
+		i = FIX2INT(optval);
+		goto numval;
+	case T_FALSE:
+		i = 0;
+		goto numval;
+	case T_TRUE:
+		i = 1;
+		numval:
+		v = (void*)&i; len = sizeof(i);
+		break;
+	default:
+		StringValue(optval);
+		v = RSTRING_PTR(optval);
+		len = RSTRING_LENINT(optval);
+		break;
+	}
+
+
+	if (setsockopt(fd, level, option, (char *)v, len) < 0)
+		rb_sys_fail("setsockopt");
+
+	return INT2FIX(0);
+}
+
 /********************
 t_is_notify_readable
 ********************/
@@ -648,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
 *****************/
@@ -656,7 +703,7 @@ static VALUE t_open_udp_socket (VALUE self, VALUE server, VALUE port)
 {
 	const unsigned long f = evma_open_datagram_socket (StringValuePtr(server), FIX2INT(port));
 	if (!f)
-		rb_raise (rb_eRuntimeError, "no datagram socket");
+		rb_raise (rb_eRuntimeError, "%s", "no datagram socket");
 	return ULONG2NUM (f);
 }
 
@@ -758,7 +805,7 @@ static VALUE t_invoke_popen (VALUE self, VALUE cmd)
 		int len = RARRAY (cmd)->len;
 	#endif
 	if (len >= 2048)
-		rb_raise (rb_eRuntimeError, "too many arguments to popen");
+		rb_raise (rb_eRuntimeError, "%s", "too many arguments to popen");
 	char *strings [2048];
 	for (int i=0; i < len; i++) {
 		VALUE ix = INT2FIX (i);
@@ -791,7 +838,7 @@ static VALUE t_read_keyboard (VALUE self)
 {
 	const unsigned long f = evma_open_keyboard();
 	if (!f)
-		rb_raise (rb_eRuntimeError, "no keyboard reader");
+		rb_raise (rb_eRuntimeError, "%s", "no keyboard reader");
 	return ULONG2NUM (f);
 }
 
@@ -805,7 +852,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;
 }
@@ -831,7 +878,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;
 }
@@ -878,7 +925,7 @@ t__epoll_set
 static VALUE t__epoll_set (VALUE self, VALUE val)
 {
 	if (t__epoll_p(self) == Qfalse)
-		rb_raise (EM_eUnsupported, "epoll is not supported on this platform");
+		rb_raise (EM_eUnsupported, "%s", "epoll is not supported on this platform");
 
 	evma_set_epoll (val == Qtrue ? 1 : 0);
 	return val;
@@ -915,7 +962,7 @@ t__kqueue_set
 static VALUE t__kqueue_set (VALUE self, VALUE val)
 {
 	if (t__kqueue_p(self) == Qfalse)
-		rb_raise (EM_eUnsupported, "kqueue is not supported on this platform");
+		rb_raise (EM_eUnsupported, "%s", "kqueue is not supported on this platform");
 
 	evma_set_kqueue (val == Qtrue ? 1 : 0);
 	return val;
@@ -953,7 +1000,7 @@ static VALUE t_send_file_data (VALUE self, VALUE signature, VALUE filename)
 
 	int b = evma_send_file_data_to_connection (NUM2ULONG (signature), StringValuePtr(filename));
 	if (b == -1)
-		rb_raise(rb_eRuntimeError, "File too large.  send_file_data() supports files under 32k.");
+		rb_raise(rb_eRuntimeError, "%s", "File too large.  send_file_data() supports files under 32k.");
 	if (b > 0) {
 		char *err = strerror (b);
 		char buf[1024];
@@ -1031,7 +1078,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;
 }
@@ -1046,11 +1093,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
@@ -1137,6 +1222,7 @@ extern "C" void Init_rubyeventmachine()
 	rb_define_module_function (EmModule, "attach_fd", (VALUE (*)(...))t_attach_fd, 2);
 	rb_define_module_function (EmModule, "detach_fd", (VALUE (*)(...))t_detach_fd, 1);
 	rb_define_module_function (EmModule, "get_sock_opt", (VALUE (*)(...))t_get_sock_opt, 3);
+	rb_define_module_function (EmModule, "set_sock_opt", (VALUE (*)(...))t_set_sock_opt, 4);
 	rb_define_module_function (EmModule, "set_notify_readable", (VALUE (*)(...))t_set_notify_readable, 2);
 	rb_define_module_function (EmModule, "set_notify_writable", (VALUE (*)(...))t_set_notify_writable, 2);
 	rb_define_module_function (EmModule, "is_notify_readable", (VALUE (*)(...))t_is_notify_readable, 1);
@@ -1145,9 +1231,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);
@@ -1171,6 +1259,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.
@@ -159,11 +162,14 @@ SslContext_t::SslContext_t (bool is_server, const string &privkeyfile, const str
 			e = SSL_CTX_use_PrivateKey_file (pCtx, privkeyfile.c_str(), SSL_FILETYPE_PEM);
 		else
 			e = SSL_CTX_use_PrivateKey (pCtx, DefaultPrivateKey);
+		if (e <= 0) ERR_print_errors_fp(stderr);
 		assert (e > 0);
+
 		if (certchainfile.length() > 0)
 			e = SSL_CTX_use_certificate_chain_file (pCtx, certchainfile.c_str());
 		else
 			e = SSL_CTX_use_certificate (pCtx, DefaultCertificate);
+		if (e <= 0) ERR_print_errors_fp(stderr);
 		assert (e > 0);
 	}
 
@@ -177,10 +183,12 @@ SslContext_t::SslContext_t (bool is_server, const string &privkeyfile, const str
 		int e;
 		if (privkeyfile.length() > 0) {
 			e = SSL_CTX_use_PrivateKey_file (pCtx, privkeyfile.c_str(), SSL_FILETYPE_PEM);
+			if (e <= 0) ERR_print_errors_fp(stderr);
 			assert (e > 0);
 		}
 		if (certchainfile.length() > 0) {
 			e = SSL_CTX_use_certificate_chain_file (pCtx, certchainfile.c_str());
+			if (e <= 0) ERR_print_errors_fp(stderr);
 			assert (e > 0);
 		}
 	}

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/completion.rb

@@ -16,7 +16,7 @@
 #
 # == Basic Usage
 #
-# As already mentioned, the basic usage of a Completion is simply for it's two
+# As already mentioned, the basic usage of a Completion is simply for its two
 # final states, :succeeded and :failed.
 #
 # An asynchronous operation will complete at some future point in time, and
@@ -24,8 +24,8 @@
 # some common interface to react to these events.
 #
 # In the following example, the user wants to know when a short lived
-# connection has completed it's exchange with the remote server. The simple
-# protocol just waits for an ack to it's message.
+# connection has completed its exchange with the remote server. The simple
+# protocol just waits for an ack to its message.
 #
 #    class Protocol < EM::Connection
 #      include EM::P::LineText2
@@ -199,6 +199,7 @@ module EventMachine
         @callbacks[state] << EM::Callback(*a, &b)
       end
       execute_callbacks
+      self
     end
 
     # Callbacks are called when you enter (or are in) a :succeeded state.

data/lib/em/connection.rb

@@ -121,7 +121,7 @@ module EventMachine
     # 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 **not** reliable
-    # for indicating when an SSL/TLS connection is ready to have it's certificate queried for.
+    # for indicating when an SSL/TLS connection is ready to have its certificate queried for.
     #
     # @see #get_peer_cert
     def ssl_handshake_completed
@@ -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
@@ -270,6 +276,10 @@ module EventMachine
       EventMachine::get_sock_opt @signature, level, option
     end
 
+    def set_sock_opt level, optname, optval
+      EventMachine::set_sock_opt @signature, level, optname, optval
+    end
+
     # A variant of {#close_connection}.
     # All of the descriptive comments given for close_connection also apply to
     # close_connection_after_writing, *with one exception*: if the connection has
@@ -467,7 +477,7 @@ module EventMachine
     #  # -----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.
+    # as a certificate object using the OpenSSL library, and check its fields.
     #
     # @return [String] the remote [X509 certificate](http://en.wikipedia.org/wiki/X.509), in the popular [PEM format](http://en.wikipedia.org/wiki/Privacy_Enhanced_Mail),
     #                  if TLS is active on the connection
@@ -566,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/iterator.rb

@@ -4,46 +4,46 @@ module EventMachine
   # Unlike ruby's built-in iterators, the end of the current iteration cycle is signaled manually,
   # instead of happening automatically after the yielded block finishes executing. For example:
   #
-  #  (0..10).each{ |num| }
+  #   (0..10).each{ |num| }
   #
   # becomes:
   #
-  #  EM::Iterator.new(0..10).each{ |num,iter| iter.next }
+  #   EM::Iterator.new(0..10).each{ |num,iter| iter.next }
   #
   # This is especially useful when doing asynchronous work via reactor libraries and
   # functions. For example, given a sync and async http api:
   #
-  #  response = sync_http_get(url); ...
-  #  async_http_get(url){ |response| ... }
+  #   response = sync_http_get(url); ...
+  #   async_http_get(url){ |response| ... }
   #
   # a synchronous iterator such as:
   #
-  #  responses = urls.map{ |url| sync_http_get(url) }
-  #  ...
-  #  puts 'all done!'
+  #   responses = urls.map{ |url| sync_http_get(url) }
+  #   ...
+  #   puts 'all done!'
   #
   # could be written as:
   #
-  #  EM::Iterator.new(urls).map(proc{ |url,iter|
-  #    async_http_get(url){ |res|
-  #      iter.return(res)
-  #    }
-  #  }, proc{ |responses|
-  #    ...
-  #    puts 'all done!'
-  #  })
+  #   EM::Iterator.new(urls).map(proc{ |url,iter|
+  #     async_http_get(url){ |res|
+  #       iter.return(res)
+  #     }
+  #   }, proc{ |responses|
+  #     ...
+  #     puts 'all done!'
+  #   })
   #
   # Now, you can take advantage of the asynchronous api to issue requests in parallel. For example,
   # to fetch 10 urls at a time, simply pass in a concurrency of 10:
   #
-  #  EM::Iterator.new(urls, 10).each do |url,iter|
-  #    async_http_get(url){ iter.next }
-  #  end
+  #   EM::Iterator.new(urls, 10).each do |url,iter|
+  #     async_http_get(url){ iter.next }
+  #   end
   #
   class Iterator
     # Create a new parallel async iterator with specified concurrency.
     #
-    #  i = EM::Iterator.new(1..100, 10)
+    #   i = EM::Iterator.new(1..100, 10)
     #
     # will create an iterator over the range that processes 10 items at a time. Iteration
     # is started via #each, #map or #inject
@@ -70,17 +70,17 @@ module EventMachine
 
     # Iterate over a set of items using the specified block or proc.
     #
-    #  EM::Iterator.new(1..100).each do |num, iter|
-    #    puts num
-    #    iter.next
-    #  end
+    #   EM::Iterator.new(1..100).each do |num, iter|
+    #     puts num
+    #     iter.next
+    #   end
     #
     # An optional second proc is invoked after the iteration is complete.
     #
-    #  EM::Iterator.new(1..100).each(
-    #    proc{ |num,iter| iter.next },
-    #    proc{ puts 'all done' }
-    #  )
+    #   EM::Iterator.new(1..100).each(
+    #     proc{ |num,iter| iter.next },
+    #     proc{ puts 'all done' }
+    #   )
     #
     def each(foreach=nil, after=nil, &blk)
       raise ArgumentError, 'proc or block required for iteration' unless foreach ||= blk
@@ -136,13 +136,13 @@ module EventMachine
 
     # Collect the results of an asynchronous iteration into an array.
     #
-    #  EM::Iterator.new(%w[ pwd uptime uname date ], 2).map(proc{ |cmd,iter|
-    #    EM.system(cmd){ |output,status|
-    #      iter.return(output)
-    #    }
-    #  }, proc{ |results|
-    #    p results
-    #  })
+    #   EM::Iterator.new(%w[ pwd uptime uname date ], 2).map(proc{ |cmd,iter|
+    #     EM.system(cmd){ |output,status|
+    #       iter.return(output)
+    #     }
+    #   }, proc{ |results|
+    #     p results
+    #   })
     #
     def map(foreach, after)
       index = 0
@@ -174,14 +174,14 @@ module EventMachine
 
     # Inject the results of an asynchronous iteration onto a given object.
     #
-    #  EM::Iterator.new(%w[ pwd uptime uname date ], 2).inject({}, proc{ |hash,cmd,iter|
-    #    EM.system(cmd){ |output,status|
-    #      hash[cmd] = status.exitstatus == 0 ? output.strip : nil
-    #      iter.return(hash)
-    #    }
-    #  }, proc{ |results|
-    #    p results
-    #  })
+    #   EM::Iterator.new(%w[ pwd uptime uname date ], 2).inject({}, proc{ |hash,cmd,iter|
+    #     EM.system(cmd){ |output,status|
+    #       hash[cmd] = status.exitstatus == 0 ? output.strip : nil
+    #       iter.return(hash)
+    #     }
+    #   }, proc{ |results|
+    #     p results
+    #   })
     #
     def inject(obj, foreach, after)
       each(proc{ |item,iter|

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/postgres3.rb

@@ -24,7 +24,6 @@
 # 
 # 
 
-require 'readbytes'
 require 'postgres-pr/message'
 require 'postgres-pr/connection'
 require 'stringio'
@@ -35,15 +34,14 @@ class StringIO
   #
   # If the data read is nil an EOFError is raised.
   #
-  # If the data read is too short a TruncatedDataError is raised and the read
-  # data is obtainable via its #data method.
+  # If the data read is too short an IOError is raised
   def readbytes(n)
     str = read(n)
     if str == nil
       raise EOFError, "End of file reached"
     end
     if str.size < n
-      raise TruncatedDataError.new("data truncated", str) 
+      raise IOError, "data truncated"
     end
     str
   end
@@ -68,15 +66,15 @@ module EventMachine
     # in basically a production-ready state, and the wire protocol isn't that complicated
     # anyway.
     #
-    # We need to monkeypatch StringIO because it lacks the #readbytes method needed
-    # by postgres-pr.
-    #
     # We're tucking in a bunch of require statements that may not be present in garden-variety
     # EM installations. Until we find a good way to only require these if a program
     # requires postgres, this file will need to be required explicitly.
     #
-    # The StringIO monkeypatch is lifted verbatim from the standard library readbytes.rb,
+    # We need to monkeypatch StringIO because it lacks the #readbytes method needed
+    # by postgres-pr.
+    # The StringIO monkeypatch is lifted from the standard library readbytes.rb,
     # which adds method #readbytes directly to class IO. But StringIO is not a subclass of IO.
+    # It is modified to raise an IOError instead of TruncatedDataException since the exception is unused.
     #
     # We cloned the handling of postgres messages from lib/postgres-pr/connection.rb
     # in the postgres-pr library, and modified it for event-handling.