eventmachine 0.12.4 → 0.12.6

data/ext/kb.cpp

@@ -80,289 +80,3 @@ void KeyboardDescriptor::Read()
 	if (EventCallback)
 		(*EventCallback)(GetBinding().c_str(), EM_CONNECTION_READ, &c, 1);
 }
-
-
-
-
-#if 0
-/******************************
-PipeDescriptor::PipeDescriptor
-******************************/
-
-PipeDescriptor::PipeDescriptor (int fd, pid_t subpid, EventMachine_t *parent_em):
-	EventableDescriptor (fd, parent_em),
-	bReadAttemptedAfterClose (false),
-	LastIo (gCurrentLoopTime),
-	InactivityTimeout (0),
-	OutboundDataSize (0),
-	SubprocessPid (subpid)
-{
-	#ifdef HAVE_EPOLL
-	EpollEvent.events = EPOLLIN;
-	#endif
-}
-
-
-/*******************************
-PipeDescriptor::~PipeDescriptor
-*******************************/
-
-PipeDescriptor::~PipeDescriptor()
-{
-	// Run down any stranded outbound data.
-	for (size_t i=0; i < OutboundPages.size(); i++)
-		OutboundPages[i].Free();
-
-	/* As a virtual destructor, we come here before the base-class
-	 * destructor that closes our file-descriptor.
-	 * We have to make sure the subprocess goes down (if it's not
-	 * already down) and we have to reap the zombie.
-	 *
-	 * This implementation is PROVISIONAL and will surely be improved.
-	 * The intention here is that we never block, hence the highly
-	 * undesirable sleeps. But if we can't reap the subprocess even
-	 * after sending it SIGKILL, then something is wrong and we
-	 * throw a fatal exception, which is also not something we should
-	 * be doing.
-	 *
-	 * Eventually the right thing to do will be to have the reactor
-	 * core respond to SIGCHLD by chaining a handler on top of the
-	 * one Ruby may have installed, and dealing with a list of dead
-	 * children that are pending cleanup.
-	 *
-	 * Since we want to have a signal processor integrated into the
-	 * client-visible API, let's wait until that is done before cleaning
-	 * this up.
-	 */
-
-	struct timespec req = {0, 10000000};
-	kill (SubprocessPid, SIGTERM);
-	nanosleep (&req, NULL);
-	if (waitpid (SubprocessPid, NULL, WNOHANG) == 0) {
-		kill (SubprocessPid, SIGKILL);
-		nanosleep (&req, NULL);
-		if (waitpid (SubprocessPid, NULL, WNOHANG) == 0)
-			throw std::runtime_error ("unable to reap subprocess");
-	}
-}
-
-
-
-/********************
-PipeDescriptor::Read
-********************/
-
-void PipeDescriptor::Read()
-{
-	int sd = GetSocket();
-	if (sd == INVALID_SOCKET) {
-		assert (!bReadAttemptedAfterClose);
-		bReadAttemptedAfterClose = true;
-		return;
-	}
-
-	LastIo = gCurrentLoopTime;
-
-	int total_bytes_read = 0;
-	char readbuffer [16 * 1024];
-
-	for (int i=0; i < 10; i++) {
-		// Don't read just one buffer and then move on. This is faster
-		// if there is a lot of incoming.
-		// But don't read indefinitely. Give other sockets a chance to run.
-		// NOTICE, we're reading one less than the buffer size.
-		// That's so we can put a guard byte at the end of what we send
-		// to user code.
-		// Use read instead of recv, which on Linux gives a "socket operation
-		// on nonsocket" error.
-		
-
-		int r = read (sd, readbuffer, sizeof(readbuffer) - 1);
-		//cerr << "<R:" << r << ">";
-
-		if (r > 0) {
-			total_bytes_read += r;
-			LastRead = gCurrentLoopTime;
-
-			// Add a null-terminator at the the end of the buffer
-			// that we will send to the callback.
-			// DO NOT EVER CHANGE THIS. We want to explicitly allow users
-			// to be able to depend on this behavior, so they will have
-			// the option to do some things faster. Additionally it's
-			// a security guard against buffer overflows.
-			readbuffer [r] = 0;
-			if (EventCallback)
-				(*EventCallback)(GetBinding().c_str(), EM_CONNECTION_READ, readbuffer, r);
-			}
-		else if (r == 0) {
-			break;
-		}
-		else {
-			// Basically a would-block, meaning we've read everything there is to read.
-			break;
-		}
-
-	}
-
-
-	if (total_bytes_read == 0) {
-		// If we read no data on a socket that selected readable,
-		// it generally means the other end closed the connection gracefully.
-		ScheduleClose (false);
-		//bCloseNow = true;
-	}
-
-}
-
-/*********************
-PipeDescriptor::Write
-*********************/
-
-void PipeDescriptor::Write()
-{
-	int sd = GetSocket();
-	assert (sd != INVALID_SOCKET);
-
-	LastIo = gCurrentLoopTime;
-	char output_buffer [16 * 1024];
-	size_t nbytes = 0;
-
-	while ((OutboundPages.size() > 0) && (nbytes < sizeof(output_buffer))) {
-		OutboundPage *op = &(OutboundPages[0]);
-		if ((nbytes + op->Length - op->Offset) < sizeof (output_buffer)) {
-			memcpy (output_buffer + nbytes, op->Buffer + op->Offset, op->Length - op->Offset);
-			nbytes += (op->Length - op->Offset);
-			op->Free();
-			OutboundPages.pop_front();
-		}
-		else {
-			int len = sizeof(output_buffer) - nbytes;
-			memcpy (output_buffer + nbytes, op->Buffer + op->Offset, len);
-			op->Offset += len;
-			nbytes += len;
-		}
-	}
-
-	// We should never have gotten here if there were no data to write,
-	// so assert that as a sanity check.
-	// Don't bother to make sure nbytes is less than output_buffer because
-	// if it were we probably would have crashed already.
-	assert (nbytes > 0);
-
-	assert (GetSocket() != INVALID_SOCKET);
-	int bytes_written = write (GetSocket(), output_buffer, nbytes);
-
-	if (bytes_written > 0) {
-		OutboundDataSize -= bytes_written;
-		if ((size_t)bytes_written < nbytes) {
-			int len = nbytes - bytes_written;
-			char *buffer = (char*) malloc (len + 1);
-			if (!buffer)
-				throw std::runtime_error ("bad alloc throwing back data");
-			memcpy (buffer, output_buffer + bytes_written, len);
-			buffer [len] = 0;
-			OutboundPages.push_front (OutboundPage (buffer, len));
-		}
-		#ifdef HAVE_EPOLL
-		EpollEvent.events = (EPOLLIN | (SelectForWrite() ? EPOLLOUT : 0));
-		assert (MyEventMachine);
-		MyEventMachine->Modify (this);
-		#endif
-	}
-	else {
-		#ifdef OS_UNIX
-		if ((errno != EINPROGRESS) && (errno != EWOULDBLOCK) && (errno != EINTR))
-		#endif
-		#ifdef OS_WIN32
-		if ((errno != WSAEINPROGRESS) && (errno != WSAEWOULDBLOCK))
-		#endif
-			Close();
-	}
-}
-
-
-/*************************
-PipeDescriptor::Heartbeat
-*************************/
-
-void PipeDescriptor::Heartbeat()
-{
-	// If an inactivity timeout is defined, then check for it.
-	if (InactivityTimeout && ((gCurrentLoopTime - LastIo) >= InactivityTimeout))
-		ScheduleClose (false);
-		//bCloseNow = true;
-}
-
-
-/*****************************
-PipeDescriptor::SelectForRead
-*****************************/
-
-bool PipeDescriptor::SelectForRead()
-{
-	/* Pipe descriptors, being local by definition, don't have
-	 * a pending state, so this is simpler than for the
-	 * ConnectionDescriptor object.
-	 */
-	return true;
-}
-
-/******************************
-PipeDescriptor::SelectForWrite
-******************************/
-
-bool PipeDescriptor::SelectForWrite()
-{
-	/* Pipe descriptors, being local by definition, don't have
-	 * a pending state, so this is simpler than for the
-	 * ConnectionDescriptor object.
-	 */
-	return (GetOutboundDataSize() > 0);
-}
-
-
-
-
-/********************************
-PipeDescriptor::SendOutboundData
-********************************/
-
-int PipeDescriptor::SendOutboundData (const char *data, int length)
-{
-	//if (bCloseNow || bCloseAfterWriting)
-	if (IsCloseScheduled())
-		return 0;
-
-	if (!data && (length > 0))
-		throw std::runtime_error ("bad outbound data");
-	char *buffer = (char *) malloc (length + 1);
-	if (!buffer)
-		throw std::runtime_error ("no allocation for outbound data");
-	memcpy (buffer, data, length);
-	buffer [length] = 0;
-	OutboundPages.push_back (OutboundPage (buffer, length));
-	OutboundDataSize += length;
-	#ifdef HAVE_EPOLL
-	EpollEvent.events = (EPOLLIN | EPOLLOUT);
-	assert (MyEventMachine);
-	MyEventMachine->Modify (this);
-	#endif
-	return length;
-}
-
-/********************************
-PipeDescriptor::GetSubprocessPid
-********************************/
-
-bool PipeDescriptor::GetSubprocessPid (pid_t *pid)
-{
-	bool ok = false;
-	if (pid && (SubprocessPid > 0)) {
-		*pid = SubprocessPid;
-		ok = true;
-	}
-	return ok;
-}
-
-#endif 
-

data/ext/pipe.cpp

@@ -94,21 +94,38 @@ PipeDescriptor::~PipeDescriptor()
 
 	assert (MyEventMachine);
 
-	// check if the process is already dead
-	if (waitpid (SubprocessPid, &(MyEventMachine->SubprocessExitStatus), WNOHANG) == 0) {
-		kill (SubprocessPid, SIGTERM);
-		// wait 0.25s for process to die
-		struct timespec req = {0, 250000000};
+	/* Another hack to make the SubprocessPid available to get_subprocess_status */
+	MyEventMachine->SubprocessPid = SubprocessPid;
+
+	/* 01Mar09: Updated to use a small nanosleep in a loop. When nanosleep is interrupted by SIGCHLD,
+	 * it resumes the system call after processing the signal (resulting in unnecessary latency).
+	 * Calling nanosleep in a loop avoids this problem.
+	 */
+	struct timespec req = {0, 50000000}; // 0.05s
+	int n;
+
+	// wait 0.25s for the process to die
+	for (n=0; n<5; n++) {
+		if (waitpid (SubprocessPid, &(MyEventMachine->SubprocessExitStatus), WNOHANG) != 0) return;
 		nanosleep (&req, NULL);
-		if (waitpid (SubprocessPid, &(MyEventMachine->SubprocessExitStatus), WNOHANG) == 0) {
-			kill (SubprocessPid, SIGKILL);
-			// wait 0.5s for process to die
-			struct timespec req = {0, 500000000};
-			nanosleep (&req, NULL);
-			if (waitpid (SubprocessPid, &(MyEventMachine->SubprocessExitStatus), WNOHANG) == 0)
-				throw std::runtime_error ("unable to reap subprocess");
-		}
 	}
+
+	// send SIGTERM and wait another 0.5s
+	kill (SubprocessPid, SIGTERM);
+	for (n=0; n<10; n++) {
+		nanosleep (&req, NULL);
+		if (waitpid (SubprocessPid, &(MyEventMachine->SubprocessExitStatus), WNOHANG) != 0) return;
+	}
+
+	// send SIGKILL and wait another 1s
+	kill (SubprocessPid, SIGKILL);
+	for (n=0; n<20; n++) {
+		nanosleep (&req, NULL);
+		if (waitpid (SubprocessPid, &(MyEventMachine->SubprocessExitStatus), WNOHANG) != 0) return;
+	}
+
+	// still not dead, give up!
+	throw std::runtime_error ("unable to reap subprocess");
 }
 
 

data/ext/rubymain.cpp

@@ -30,43 +30,61 @@ 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;
+static VALUE Intern_at_error_handler;
 static VALUE Intern_event_callback;
 static VALUE Intern_run_deferred_callbacks;
 static VALUE Intern_delete;
 static VALUE Intern_call;
 static VALUE Intern_receive_data;
-
+static VALUE Intern_ssl_handshake_completed;
 static VALUE Intern_notify_readable;
 static VALUE Intern_notify_writable;
 
+static VALUE rb_cProcStatus;
+
+struct em_event {
+	const char *a1;
+	int a2;
+	const char *a3;
+	int a4;
+};
+
 /****************
 t_event_callback
 ****************/
 
-static void event_callback (const char *a1, int a2, const char *a3, int a4)
+static void event_callback (struct em_event* e)
 {
+	const char *a1 = e->a1;
+	int a2 = e->a2;
+	const char *a3 = e->a3;
+	int a4 = e->a4;
+
 	if (a2 == EM_CONNECTION_READ) {
 		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) {
@@ -76,14 +94,47 @@ static void event_callback (const char *a1, int a2, const char *a3, int a4)
 		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 (EM_eConnectionNotBound, "unknown connection: %s", a1);
+		rb_funcall (q, Intern_ssl_handshake_completed, 0);
+	}
 	else
 		rb_funcall (EmModule, Intern_event_callback, 3, rb_str_new2(a1), (a2 << 1) | 1, rb_str_new(a3,a4));
 }
 
+/*******************
+event_error_handler
+*******************/
+
+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);
+}
+
+/**********************
+event_callback_wrapper
+**********************/
 
+static void event_callback_wrapper (const char *a1, int a2, const char *a3, int a4)
+{
+	struct em_event e;
+	e.a1 = a1;
+	e.a2 = a2;
+	e.a3 = a3;
+	e.a4 = a4;
+
+	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, Qnil);
+}
 
 /**************************
 t_initialize_event_machine
@@ -91,7 +142,7 @@ t_initialize_event_machine
 
 static VALUE t_initialize_event_machine (VALUE self)
 {
-	evma_initialize_library (event_callback);
+	evma_initialize_library (event_callback_wrapper);
 	return Qnil;
 }
 
@@ -194,6 +245,34 @@ static VALUE t_set_tls_parms (VALUE self, VALUE signature, VALUE privkeyfile, VA
 	return Qnil;
 }
 
+/***********
+t_get_peer_cert
+***********/
+
+static VALUE t_get_peer_cert (VALUE self, VALUE signature)
+{
+	VALUE ret = Qnil;
+
+	#ifdef WITH_SSL
+	X509 *cert = NULL;
+	BUF_MEM *buf;
+	BIO *out;
+
+	cert = evma_get_peer_cert (StringValuePtr (signature));
+
+	if (cert != NULL) {
+		out = BIO_new(BIO_s_mem());
+		PEM_write_bio_X509(out, cert);
+		BIO_get_mem_ptr(out, &buf);
+		ret = rb_str_new(buf->data, buf->length);
+		X509_free(cert);
+		BUF_MEM_free(buf);
+	}
+	#endif
+
+	return ret;
+}
+
 /**************
 t_get_peername
 **************/
@@ -242,12 +321,29 @@ t_get_subprocess_status
 
 static VALUE t_get_subprocess_status (VALUE self, VALUE signature)
 {
+	VALUE proc_status = Qnil;
+
 	int status;
+	pid_t pid;
+
 	if (evma_get_subprocess_status (StringValuePtr (signature), &status)) {
-		return INT2NUM (status);
+		if (evma_get_subprocess_pid (StringValuePtr (signature), &pid)) {
+			proc_status = rb_obj_alloc(rb_cProcStatus);
+			rb_iv_set(proc_status, "status", INT2FIX(status));
+			rb_iv_set(proc_status, "pid", INT2FIX(pid));
+		}
 	}
 
-	return Qnil;
+	return proc_status;
+}
+
+/**********************
+t_get_connection_count
+**********************/
+
+static VALUE t_get_connection_count (VALUE self)
+{
+	return INT2NUM(evma_get_connection_count());
 }
 
 /*****************************
@@ -423,6 +519,15 @@ static VALUE t_set_timer_quantum (VALUE self, VALUE interval)
   return Qnil;
 }
 
+/********************
+t_get_max_timer_count
+********************/
+
+static VALUE t_get_max_timer_count (VALUE self)
+{
+  return INT2FIX (evma_get_max_timer_count());
+}
+
 /********************
 t_set_max_timer_count
 ********************/
@@ -640,17 +745,22 @@ Init_rubyeventmachine
 
 extern "C" void Init_rubyeventmachine()
 {
+	// Lookup Process::Status for get_subprocess_status
+	VALUE rb_mProcess = rb_const_get(rb_cObject, rb_intern("Process"));
+	rb_cProcStatus = rb_const_get(rb_mProcess, rb_intern("Status"));
+
 	// Tuck away some symbol values so we don't have to look 'em up every time we need 'em.
 	Intern_at_signature = rb_intern ("@signature");
 	Intern_at_timers = rb_intern ("@timers");
 	Intern_at_conns = rb_intern ("@conns");
+	Intern_at_error_handler = rb_intern("@error_handler");
 
 	Intern_event_callback = rb_intern ("event_callback");
 	Intern_run_deferred_callbacks = rb_intern ("run_deferred_callbacks");
 	Intern_delete = rb_intern ("delete");
 	Intern_call = rb_intern ("call");
 	Intern_receive_data = rb_intern ("receive_data");
-
+	Intern_ssl_handshake_completed = rb_intern ("ssl_handshake_completed");
 	Intern_notify_readable = rb_intern ("notify_readable");
 	Intern_notify_writable = rb_intern ("notify_writable");
 
@@ -660,9 +770,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);
@@ -673,6 +783,7 @@ extern "C" void Init_rubyeventmachine()
 	rb_define_module_function (EmModule, "start_unix_server", (VALUE(*)(...))t_start_unix_server, 1);
 	rb_define_module_function (EmModule, "set_tls_parms", (VALUE(*)(...))t_set_tls_parms, 3);
 	rb_define_module_function (EmModule, "start_tls", (VALUE(*)(...))t_start_tls, 1);
+	rb_define_module_function (EmModule, "get_peer_cert", (VALUE(*)(...))t_get_peer_cert, 1);
 	rb_define_module_function (EmModule, "send_data", (VALUE(*)(...))t_send_data, 3);
 	rb_define_module_function (EmModule, "send_datagram", (VALUE(*)(...))t_send_datagram, 5);
 	rb_define_module_function (EmModule, "close_connection", (VALUE(*)(...))t_close_connection, 2);
@@ -692,6 +803,7 @@ extern "C" void Init_rubyeventmachine()
 	rb_define_module_function (EmModule, "signal_loopbreak", (VALUE(*)(...))t_signal_loopbreak, 0);
 	rb_define_module_function (EmModule, "library_type", (VALUE(*)(...))t_library_type, 0);
 	rb_define_module_function (EmModule, "set_timer_quantum", (VALUE(*)(...))t_set_timer_quantum, 1);
+	rb_define_module_function (EmModule, "get_max_timer_count", (VALUE(*)(...))t_get_max_timer_count, 0);
 	rb_define_module_function (EmModule, "set_max_timer_count", (VALUE(*)(...))t_set_max_timer_count, 1);
 	rb_define_module_function (EmModule, "setuid_string", (VALUE(*)(...))t_setuid_string, 1);
 	rb_define_module_function (EmModule, "invoke_popen", (VALUE(*)(...))t_invoke_popen, 1);
@@ -707,6 +819,7 @@ extern "C" void Init_rubyeventmachine()
 	rb_define_module_function (EmModule, "get_comm_inactivity_timeout", (VALUE(*)(...))t_get_comm_inactivity_timeout, 1);
 	rb_define_module_function (EmModule, "set_comm_inactivity_timeout", (VALUE(*)(...))t_set_comm_inactivity_timeout, 2);
 	rb_define_module_function (EmModule, "set_rlimit_nofile", (VALUE(*)(...))t_set_rlimit_nofile, 1);
+	rb_define_module_function (EmModule, "get_connection_count", (VALUE(*)(...))t_get_connection_count, 0);
 
 	// Temporary:
 	rb_define_module_function (EmModule, "epoll", (VALUE(*)(...))t__epoll, 0);
@@ -728,5 +841,7 @@ extern "C" void Init_rubyeventmachine()
 	rb_define_const (EmModule, "ConnectionNotifyReadable", INT2NUM(106));
 	rb_define_const (EmModule, "ConnectionNotifyWritable", INT2NUM(107));
 
+	rb_define_const (EmModule, "SslHandshakeCompleted", INT2NUM(108));
+
 }