eventmachine 0.7.2 → 0.8.0

data/ext/em.h

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: em.h 318 2007-05-22 22:06:24Z blackhedd $
+$Id: em.h 377 2007-06-13 01:05:56Z blackhedd $
 
 File:     em.h
 Date:     06Apr06
@@ -70,12 +70,20 @@ class EventMachine_t
 		const char *OpenDatagramSocket (const char *, int);
 		const char *CreateUnixDomainServer (const char*);
 		const char *_OpenFileForWriting (const char*);
+		//const char *Popen (const char*, const char*);
+		const char *Socketpair (char* const*);
 
 		void Add (EventableDescriptor*);
+		void Modify (EventableDescriptor*);
 
 		void SetTimerQuantum (int);
 		static void SetuidString (const char*);
+		static int SetRlimitNofile (int);
 
+		// Temporary:
+		void _UseEpoll();
+
+		/*
 	public:
 		enum { // Event names
 			TIMER_FIRED = 100,
@@ -85,19 +93,29 @@ class EventMachine_t
 			CONNECTION_COMPLETED = 104,
 			LOOPBREAK_SIGNAL = 105
 		};
+		*/
 
 
 	private:
 		bool _RunOnce();
 		bool _RunTimers();
 		void _AddNewDescriptors();
+		void _ModifyDescriptors();
 		void _InitializeLoopBreaker();
+
+		bool _RunSelectOnce();
+		bool _RunEpollOnce();
+
+		void _ModifyEpollEvent (EventableDescriptor*);
+
+	public:
 		void _ReadLoopBreaker();
 
 	private:
 		enum {
 			MaxOutstandingTimers = 1000,
-			HeartbeatInterval = 2
+			HeartbeatInterval = 2,
+			MaxEpollDescriptors = 64*1024
 		};
 		void (*EventCallback)(const char*, int, const char*, int);
 
@@ -107,6 +125,7 @@ class EventMachine_t
 		multimap<Int64, Timer_t> Timers;
 		vector<EventableDescriptor*> Descriptors;
 		vector<EventableDescriptor*> NewDescriptors;
+		set<EventableDescriptor*> ModifiedDescriptors;
 
 		time_t NextHeartbeatTime;
 
@@ -117,6 +136,10 @@ class EventMachine_t
 		#endif
 
 		timeval Quantum;
+
+	private:
+		bool bEpoll;
+		int epfd; // Epoll file-descriptor
 };
 
 

data/ext/emwin.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: emwin.cpp 318 2007-05-22 22:06:24Z blackhedd $
+$Id: emwin.cpp 327 2007-05-26 11:10:45Z blackhedd $
 
 File:     emwin.cpp
 Date:     05May06
@@ -138,7 +138,7 @@ bool EventMachine_t::_RunTimers()
 		if (i->first > gCurrentLoopTime)
 			break;
 		if (EventCallback)
-			(*EventCallback) ("", TIMER_FIRED, i->second.GetBinding().c_str(), i->second.GetBinding().length());
+			(*EventCallback) ("", EM_TIMER_FIRED, i->second.GetBinding().c_str(), i->second.GetBinding().length());
 		Timers.erase (i);
 	}
 	return true;

data/ext/epoll.cpp

@@ -0,0 +1,26 @@
+/*****************************************************************************
+
+$Id: epoll.cpp 352 2007-06-06 20:24:11Z blackhedd $
+
+File:     epoll.cpp
+Date:     06Jun07
+
+Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+Gmail: blackhedd
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of either: 1) the GNU General Public License
+as published by the Free Software Foundation; either version 2 of the
+License, or (at your option) any later version; or 2) Ruby's License.
+
+See the file COPYING for complete licensing information.
+
+*****************************************************************************/
+
+
+#ifdef HAVE_EPOLL
+
+#include "project.h"
+
+#endif // HAVE_EPOLL
+

data/ext/epoll.h

@@ -0,0 +1,25 @@
+/*****************************************************************************
+
+$Id: epoll.h 352 2007-06-06 20:24:11Z blackhedd $
+
+File:     epoll.h
+Date:     06Jun07
+
+Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+Gmail: blackhedd
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of either: 1) the GNU General Public License
+as published by the Free Software Foundation; either version 2 of the
+License, or (at your option) any later version; or 2) Ruby's License.
+
+See the file COPYING for complete licensing information.
+
+*****************************************************************************/
+
+
+#ifdef HAVE_EPOLL
+
+
+#endif // HAVE_EPOLL
+

data/ext/eventmachine.h

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: eventmachine.h 318 2007-05-22 22:06:24Z blackhedd $
+$Id: eventmachine.h 377 2007-06-13 01:05:56Z blackhedd $
 
 File:     eventmachine.h
 Date:     15Apr06
@@ -24,6 +24,15 @@ See the file COPYING for complete licensing information.
 extern "C" {
 #endif
 
+	enum { // Event names
+		EM_TIMER_FIRED = 100,
+		EM_CONNECTION_READ = 101,
+		EM_CONNECTION_UNBOUND = 102,
+		EM_CONNECTION_ACCEPTED = 103,
+		EM_CONNECTION_COMPLETED = 104,
+		EM_LOOPBREAK_SIGNAL = 105
+	};
+
 	void evma_initialize_library (void(*)(const char*, int, const char*, int));
 	void evma_run_machine();
 	void evma_release_library();
@@ -35,10 +44,13 @@ extern "C" {
 	const char *evma_open_datagram_socket (const char *server, int port);
 	void evma_start_tls (const char *binding);
 	int evma_get_peername (const char *binding, struct sockaddr*);
+	int evma_get_subprocess_pid (const char *binding, pid_t*);
 	int evma_send_data_to_connection (const char *binding, const char *data, int data_length);
 	int evma_send_datagram (const char *binding, const char *data, int data_length, const char *address, int port);
 	int evma_get_comm_inactivity_timeout (const char *binding, /*out*/int *value);
 	int evma_set_comm_inactivity_timeout (const char *binding, /*in,out*/int *value);
+	int evma_get_outbound_data_size (const char *binding);
+
 	void evma_close_connection (const char *binding, int after_writing);
 	void evma_signal_loopbreak();
 	void evma_set_timer_quantum (int);
@@ -46,6 +58,12 @@ extern "C" {
 	void evma_stop_machine();
 
 	const char *evma__write_file (const char *filename);
+	const char *evma_popen (char * const*cmd_strings);
+
+	int evma_set_rlimit_nofile (int n_files);
+
+	// Temporary:
+	void evma__epoll();
 
 #if __cplusplus
 }

data/ext/extconf.rb

@@ -1,4 +1,4 @@
-# $Id: extconf.rb 318 2007-05-22 22:06:24Z blackhedd $
+# $Id: extconf.rb 385 2007-06-16 11:38:59Z blackhedd $
 #
 #----------------------------------------------------------------------------
 #
@@ -89,6 +89,46 @@ when /darwin/
   # Ff line contributed by Daniel Harple.
   CONFIG['LDSHARED'] = "$(CXX) " + CONFIG['LDSHARED'].split[1..-1].join(' ')
 
+when /linux/
+  unless have_library('pthread')
+	  exit
+  end
+
+  flags << '-DOS_UNIX'
+  flags << '-DBUILD_FOR_RUBY'
+
+  # Original epoll test is inadequate because 2.4 kernels have the header
+  # but not the code.
+  #flags << '-DHAVE_EPOLL' if have_header('sys/epoll.h')
+  if have_header('sys/epoll.h')
+	  File.open("hasEpollTest.c", "w") {|f|
+		  f.puts "#include <sys/epoll.h>"
+		  f.puts "int main() { epoll_create(1024); return 0;}"
+	  }
+	  (e = system( "gcc hasEpollTest.c -o hasEpollTest " )) and (e = $?.to_i)
+	  `rm -f hasEpollTest.c hasEpollTest`
+	  flags << '-DHAVE_EPOLL' if e == 0
+  end
+
+  dir_config('ssl')
+  if have_library('ssl') and
+	  have_library('crypto') and
+	  have_header('openssl/ssl.h') and
+	  have_header('openssl/err.h')
+    flags << '-DWITH_SSL'
+  else
+    flags << '-DWITHOUT_SSL'
+  end
+  # on Unix we need a g++ link, not gcc.
+  CONFIG['LDSHARED'] = "$(CXX) -shared"
+
+  # Modify the mkmf constant LINK_SO so the generated shared object is stripped.
+  # You might think modifying CONFIG['LINK_SO'] would be a better way to do this,
+  # but it doesn't work because mkmf doesn't look at CONFIG['LINK_SO'] again after
+  # it initializes.
+  linkso = Object.send :remove_const, "LINK_SO"
+  LINK_SO = linkso + "; strip $@"
+
 else
   unless have_library('pthread')
 	  exit
@@ -108,6 +148,7 @@ else
   end
   # on Unix we need a g++ link, not gcc.
   CONFIG['LDSHARED'] = "$(CXX) -shared"
+
 end
 
 if $CPPFLAGS

data/ext/files.cpp

@@ -24,8 +24,8 @@ See the file COPYING for complete licensing information.
 FileStreamDescriptor::FileStreamDescriptor
 ******************************************/
 
-FileStreamDescriptor::FileStreamDescriptor (int fd):
-	EventableDescriptor (fd),
+FileStreamDescriptor::FileStreamDescriptor (int fd, EventMachine_t *em):
+	EventableDescriptor (fd, em),
 	OutboundDataSize (0)
 {
 cerr << "#####";

data/ext/files.h

@@ -30,7 +30,7 @@ class FileStreamDescriptor
 class FileStreamDescriptor: public EventableDescriptor
 {
 	public:
-		FileStreamDescriptor (int);
+		FileStreamDescriptor (int, EventMachine_t*);
 		virtual ~FileStreamDescriptor();
 
 		virtual void Read();

data/ext/pipe.cpp

@@ -0,0 +1,307 @@
+/*****************************************************************************
+
+$Id: pipe.cpp 401 2007-07-11 12:54:06Z blackhedd $
+
+File:     pipe.cpp
+Date:     30May07
+
+Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+Gmail: blackhedd
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of either: 1) the GNU General Public License
+as published by the Free Software Foundation; either version 2 of the
+License, or (at your option) any later version; or 2) Ruby's License.
+
+See the file COPYING for complete licensing information.
+
+*****************************************************************************/
+
+#include "project.h"
+
+
+#ifdef OS_UNIX
+// THIS ENTIRE FILE IS ONLY COMPILED ON UNIX-LIKE SYSTEMS.
+
+/******************************
+PipeDescriptor::PipeDescriptor
+******************************/
+
+PipeDescriptor::PipeDescriptor (FILE *fp, pid_t subpid, EventMachine_t *parent_em):
+	EventableDescriptor (fileno (fp), parent_em),
+	bReadAttemptedAfterClose (false),
+	LastIo (gCurrentLoopTime),
+	InactivityTimeout (0),
+	//MyStream (fp),
+	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 // OS_UNIX
+