eventmachine 0.5.3 → 0.7.0

data/ext/em.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: em.cpp 61 2006-05-17 04:58:31Z blackhedd $
+$Id: em.cpp 267 2006-10-25 02:02:02Z blackhedd $
 
 File:     ed.cpp
 Date:     06Apr06
@@ -35,6 +35,11 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 // This avoids the need for frequent expensive calls to time(NULL);
 time_t gCurrentLoopTime;
 
+#ifdef OS_WIN32
+unsigned gTickCountTickover;
+unsigned gLastTickCount;
+#endif
+
 
 /******************************
 EventMachine_t::EventMachine_t
@@ -42,9 +47,20 @@ EventMachine_t::EventMachine_t
 
 EventMachine_t::EventMachine_t (void (*event_callback)(const char*, int, const char*, int)):
 	EventCallback (event_callback),
-	NextHeartbeatTime (0)
+	NextHeartbeatTime (0),
+	LoopBreakerReader (-1),
+	LoopBreakerWriter (-1)
 {
+	// Default time-slice is just smaller than one hundred mills.
+	Quantum.tv_sec = 0;
+	Quantum.tv_usec = 90000;
+
 	gTerminateSignalReceived = false;
+	// Make sure the current loop time is sane, in case we do any initializations of
+	// objects before we start running.
+	gCurrentLoopTime = time(NULL);
+
+	_InitializeLoopBreaker();
 }
 
 
@@ -60,6 +76,9 @@ EventMachine_t::~EventMachine_t()
 		delete NewDescriptors[i];
 	for (i = 0; i < Descriptors.size(); i++)
 		delete Descriptors[i];
+
+	close (LoopBreakerReader);
+	close (LoopBreakerWriter);
 }
 
 
@@ -74,12 +93,103 @@ void EventMachine_t::ScheduleHalt()
    * This can be called by clients. Signal handlers will probably
    * set the global flag.
    * For now this means there can only be one EventMachine ever running at a time.
+   *
+   * IMPORTANT: keep this light, fast, and async-safe. Don't do anything frisky in here,
+   * because it may be called from signal handlers invoked from code that we don't
+   * control. At this writing (20Sep06), EM does NOT install any signal handlers of
+   * its own.
+   *
+   * We need a FAQ. And one of the questions is: how do I stop EM when Ctrl-C happens?
+   * The answer is to call evma_stop_machine, which calls here, from a SIGINT handler.
    */
 	gTerminateSignalReceived = true;
 }
 
 
 
+/*******************************
+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))
+		throw std::runtime_error ("invalid timer-quantum");
+
+	Quantum.tv_sec = interval / 1000;
+	Quantum.tv_usec = (interval % 1000) * 1000;
+}
+
+
+
+/*********************************
+EventMachine_t::SignalLoopBreaker
+*********************************/
+
+void EventMachine_t::SignalLoopBreaker()
+{
+	#ifdef OS_UNIX
+	write (LoopBreakerWriter, "", 1);
+	#endif
+	#ifdef OS_WIN32
+	sendto (LoopBreakerReader, "", 0, 0, (struct sockaddr*)&(LoopBreakerTarget), sizeof(LoopBreakerTarget));
+	#endif
+}
+
+
+/**************************************
+EventMachine_t::_InitializeLoopBreaker
+**************************************/
+
+void EventMachine_t::_InitializeLoopBreaker()
+{
+	/* A "loop-breaker" is a socket-descriptor that we can write to in order
+	 * to break the main select loop. Primarily useful for things running on
+	 * threads other than the main EM thread, so they can trigger processing
+	 * of events that arise exogenously to the EM.
+	 * Keep the loop-breaker pipe out of the main descriptor set, otherwise
+	 * its events will get passed on to user code.
+	 */
+
+	#ifdef OS_UNIX
+	int fd[2];
+	if (pipe (fd))
+		throw std::runtime_error ("no loop breaker");
+
+	LoopBreakerWriter = fd[1];
+	LoopBreakerReader = fd[0];
+	#endif
+
+	#ifdef OS_WIN32
+	int sd = socket (AF_INET, SOCK_DGRAM, 0);
+	if (sd == INVALID_SOCKET)
+		throw std::runtime_error ("no loop breaker socket");
+	SetSocketNonblocking (sd);
+
+	memset (&LoopBreakerTarget, 0, sizeof(LoopBreakerTarget));
+	LoopBreakerTarget.sin_family = AF_INET;
+	LoopBreakerTarget.sin_addr.s_addr = inet_addr ("127.0.0.1");
+
+	srand ((int)time(NULL));
+	int i;
+	for (i=0; i < 100; i++) {
+		int r = (rand() % 10000) + 20000;
+		LoopBreakerTarget.sin_port = htons (r);
+		if (bind (sd, (struct sockaddr*)&LoopBreakerTarget, sizeof(LoopBreakerTarget)) == 0)
+			break;
+	}
+
+	if (i == 100)
+		throw std::runtime_error ("no loop breaker");
+	LoopBreakerReader = sd;
+	#endif
+}
+
+
 /*******************
 EventMachine_t::Run
 *******************/
@@ -122,18 +232,28 @@ bool EventMachine_t::_RunOnce()
 	// Return T/F to indicate whether we should continue.
 	// This is based on a select loop. Alternately provide epoll
 	// if we know we're running on a 2.6 kernel.
+	// epoll will be effective if we provide it as an alternative,
+	// however it has the same problem interoperating with Ruby
+	// threads that selct does.
 
 	//cerr << "X";
+
+	/* This protection is now obsolete, because we will ALWAYS
+	 * have at least one descriptor (the loop-breaker) to read.
+	 */
+	/*
 	if (Descriptors.size() == 0) {
 		#ifdef OS_UNIX
 		timeval tv = {0, 200 * 1000};
 		EmSelect (0, NULL, NULL, NULL, &tv);
+		return true;
 		#endif
 		#ifdef OS_WIN32
 		Sleep (200);
-		#endif
 		return true;
+		#endif
 	}
+	*/
 
 	fd_set fdreads, fdwrites;
 	FD_ZERO (&fdreads);
@@ -141,6 +261,15 @@ bool EventMachine_t::_RunOnce()
 
 	int maxsocket = 0;
 
+	// Always read the loop-breaker reader.
+	// Changed 23Aug06, provisionally implemented for Windows with a UDP socket
+	// running on localhost with a randomly-chosen port. (*Puke*)
+	// Windows has a version of the Unix pipe() library function, but it doesn't
+	// give you back descriptors that are selectable.
+	FD_SET (LoopBreakerReader, &fdreads);
+	if (maxsocket < LoopBreakerReader)
+		maxsocket = LoopBreakerReader;
+
 	// prepare the sockets for reading and writing
 	size_t i;
 	for (i = 0; i < Descriptors.size(); i++) {
@@ -160,9 +289,13 @@ bool EventMachine_t::_RunOnce()
 
 
 	{ // read and write the sockets
-		timeval tv = {1, 0}; // Solaris fails if the microseconds member is >= 1000000.
+		//timeval tv = {1, 0}; // Solaris fails if the microseconds member is >= 1000000.
+		timeval tv = Quantum;
 		int s = EmSelect (maxsocket+1, &fdreads, &fdwrites, NULL, &tv);
 		if (s > 0) {
+			if (FD_ISSET (LoopBreakerReader, &fdreads))
+				_ReadLoopBreaker();
+
 			for (i=0; i < Descriptors.size(); i++) {
 				EventableDescriptor *ed = Descriptors[i];
 				assert (ed);
@@ -178,7 +311,7 @@ bool EventMachine_t::_RunOnce()
 		else if (s < 0) {
 			// select can fail on error in a handful of ways.
 			// If this happens, then wait for a little while to avoid busy-looping.
-			// If the error was EINTR, we probaby caught SIGCHLD or something,
+			// If the error was EINTR, we probably caught SIGCHLD or something,
 			// so keep the wait short.
 			timeval tv = {0, ((errno == EINTR) ? 5 : 50) * 1000};
 			EmSelect (0, NULL, NULL, NULL, &tv);
@@ -219,6 +352,23 @@ bool EventMachine_t::_RunOnce()
 }
 
 
+/********************************
+EventMachine_t::_ReadLoopBreaker
+********************************/
+
+void EventMachine_t::_ReadLoopBreaker()
+{
+	/* The loop breaker has selected readable.
+	 * Read it ONCE (it may block if we try to read it twice)
+	 * and send a loop-break event back to user code.
+	 */
+	char buffer [1024];
+	read (LoopBreakerReader, buffer, sizeof(buffer));
+	if (EventCallback)
+		(*EventCallback)("", EventMachine_t::LOOPBREAK_SIGNAL, "", 0);
+}
+
+
 /**************************
 EventMachine_t::_RunTimers
 **************************/
@@ -232,11 +382,25 @@ bool EventMachine_t::_RunTimers()
 	// Just keep inspecting and processing the list head until we hit
 	// one that hasn't expired yet.
 
+	#ifdef OS_UNIX
+	struct timeval tv;
+	gettimeofday (&tv, NULL);
+	Int64 now = (((Int64)(tv.tv_sec)) * 1000000LL) + ((Int64)(tv.tv_usec));
+	#endif
+
+	#ifdef OS_WIN32
+	unsigned tick = GetTickCount();
+	if (tick < gLastTickCount)
+		gTickCountTickover += 1;
+	gLastTickCount = tick;
+	Int64 now = ((Int64)gTickCountTickover << 32) + (Int64)tick;
+	#endif
+
 	while (true) {
-		multimap<time_t,Timer_t>::iterator i = Timers.begin();
+		multimap<Int64,Timer_t>::iterator i = Timers.begin();
 		if (i == Timers.end())
 			break;
-		if (i->first > gCurrentLoopTime)
+		if (i->first > now)
 			break;
 		if (EventCallback)
 			(*EventCallback) ("", TIMER_FIRED, i->second.GetBinding().c_str(), i->second.GetBinding().length());
@@ -251,17 +415,33 @@ bool EventMachine_t::_RunTimers()
 EventMachine_t::InstallOneshotTimer
 ***********************************/
 
-const char *EventMachine_t::InstallOneshotTimer (int seconds)
+const char *EventMachine_t::InstallOneshotTimer (int milliseconds)
 {
 	if (Timers.size() > MaxOutstandingTimers)
 		return false;
 	// Don't use the global loop-time variable here, because we might
 	// get called before the main event machine is running.
 
+	#ifdef OS_UNIX
+	struct timeval tv;
+	gettimeofday (&tv, NULL);
+	Int64 fire_at = (((Int64)(tv.tv_sec)) * 1000000LL) + ((Int64)(tv.tv_usec));
+	fire_at += ((Int64)milliseconds) * 1000LL;
+	#endif
+
+	#ifdef OS_WIN32
+	unsigned tick = GetTickCount();
+	if (tick < gLastTickCount)
+		gTickCountTickover += 1;
+	gLastTickCount = tick;
+
+	Int64 fire_at = ((Int64)gTickCountTickover << 32) + (Int64)tick;
+	fire_at += (Int64)milliseconds;
+	#endif
+
 	Timer_t t;
-	multimap<time_t,Timer_t>::iterator i =
-		Timers.insert (make_pair (time(NULL) + seconds, t));
-	//return t.GetBinding().c_str();
+	multimap<Int64,Timer_t>::iterator i =
+		Timers.insert (make_pair (fire_at, t));
 	return i->second.GetBindingChars();
 }
 
@@ -304,8 +484,14 @@ const char *EventMachine_t::ConnectToServer (const char *server, int port)
 	HostAddr = inet_addr (server);
 	if (HostAddr == INADDR_NONE) {
 		hostent *hp = gethostbyname ((char*)server); // Windows requires (char*)
-		if (!hp)
+		if (!hp) {
+			// TODO: This gives the caller a fatal error. Not good.
+			// They can respond by catching RuntimeError (blecch).
+			// Possibly we need to fire an unbind event and provide
+			// a status code so user code can detect the cause of the
+			// failure.
 			return NULL;
+		}
 		HostAddr = ((in_addr*)(hp->h_addr))->s_addr;
 	}
 
@@ -333,7 +519,27 @@ const char *EventMachine_t::ConnectToServer (const char *server, int port)
 		// never to give when the socket is nonblocking,
 		// even if the connection is intramachine or to
 		// localhost.
-		throw std::runtime_error ("unimplemented");
+
+		/* Changed this branch 08Aug06. Evidently some kernels
+		 * (FreeBSD for example) will actually return success from
+		 * a nonblocking connect. This is a pretty simple case,
+		 * just set up the new connection and clear the pending flag.
+		 * Thanks to Chris Ochs for helping track this down.
+		 * This branch never gets taken on Linux or (oddly) OSX.
+		 * The original behavior was to throw an unimplemented,
+		 * which the user saw as a fatal exception. Very unfriendly.
+		 *
+		 * Tweaked 10Aug06. Even though the connect disposition is
+		 * known, we still set the connect-pending flag. That way
+		 * some needed initialization will happen in the ConnectionDescriptor.
+		 * (To wit, the ConnectionCompleted event gets sent to the client.)
+		 */
+		ConnectionDescriptor *cd = new ConnectionDescriptor (sd);
+		if (!cd)
+			throw std::runtime_error ("no connection allocated");
+		cd->SetConnectPending (true);
+		Add (cd);
+		out = cd->GetBinding().c_str();
 	}
 	else if (errno == EINPROGRESS) {
 		// Errno will generally always be EINPROGRESS, but on Linux
@@ -354,7 +560,24 @@ const char *EventMachine_t::ConnectToServer (const char *server, int port)
 			out = cd->GetBinding().c_str();
 		}
 		else {
-			// This could be connection refused or something such thing.
+			/* This could be connection refused or some such thing.
+			 * We will come here on Linux if a localhost connection fails.
+			 * Changed 16Jul06: Originally this branch was a no-op, and
+			 * we'd drop down to the end of the method, close the socket,
+			 * and return NULL, which would cause the caller to GET A
+			 * FATAL EXCEPTION. Now we keep the socket around but schedule an
+			 * immediate close on it, so the caller will get a close-event
+			 * scheduled on it. This was only an issue for localhost connections
+			 * to non-listening ports. We may eventually need to revise this
+			 * revised behavior, in case it causes problems like making it hard
+			 * for people to know that a failure occurred.
+			 */
+			ConnectionDescriptor *cd = new ConnectionDescriptor (sd);
+			if (!cd)
+				throw std::runtime_error ("no connection allocated");
+			cd->ScheduleClose (false);
+			Add (cd);
+			out = cd->GetBinding().c_str();
 		}
 	}
 	else {
@@ -574,6 +797,10 @@ void EventMachine_t::_AddNewDescriptors()
 	 * Any descriptors that are added as a result of processing timers
 	 * or acceptors should go on a temporary queue and then added
 	 * while we're not traversing the main list.
+	 * Also, it (rarely) happens that a newly-created descriptor
+	 * is immediately scheduled to close. It might be a good
+	 * idea not to bother scheduling these for I/O but if
+	 * we do that, we might bypass some important processing.
 	 */
 
 	for (size_t i = 0; i < NewDescriptors.size(); i++) {
@@ -586,5 +813,115 @@ void EventMachine_t::_AddNewDescriptors()
 }
 
 
+/***********************************
+EventMachine_t::_OpenFileForWriting
+***********************************/
+
+const char *EventMachine_t::_OpenFileForWriting (const char *filename)
+{
+  /*
+	 * Return the binding-text of the newly-opened file,
+	 * or NULL if there was a problem.
+	 */
+
+	if (!filename || !*filename)
+		return NULL;
+
+  int fd = open (filename, O_CREAT|O_TRUNC|O_WRONLY|O_NONBLOCK, 0644);
+  
+	FileStreamDescriptor *fsd = new FileStreamDescriptor (fd);
+  if (!fsd)
+  	throw std::runtime_error ("no file-stream allocated");
+  Add (fsd);
+  return fsd->GetBinding().c_str();
+
+}
+
+
+/**************************************
+EventMachine_t::CreateUnixDomainServer
+**************************************/
+
+const char *EventMachine_t::CreateUnixDomainServer (const char *filename)
+{
+	/* Create a UNIX-domain acceptor (server) socket and add it to the event machine.
+	 * Return the binding of the new acceptor to the caller.
+	 * This binding will be referenced when the new acceptor sends events
+	 * to indicate accepted connections.
+	 * THERE IS NO MEANINGFUL IMPLEMENTATION ON WINDOWS.
+	 */
+
+	#ifdef OS_WIN32
+	throw std::runtime_error ("unix-domain server unavailable on this platform");
+	#endif
+
+	// The whole rest of this function is only compiled on Unix systems.
+	#ifdef OS_UNIX
+	const char *output_binding = NULL;
+
+	struct sockaddr_un sun;
+
+	int sd_accept = socket (AF_LOCAL, SOCK_STREAM, 0);
+	if (sd_accept == INVALID_SOCKET) {
+		goto fail;
+	}
+
+	if (!filename || !*filename)
+		goto fail;
+	unlink (filename);
+
+	bzero (&sun, sizeof(sun));
+	sun.sun_family = AF_LOCAL;
+	strncpy (sun.sun_path, filename, sizeof(sun.sun_path)-1);
+
+	// don't bother with reuseaddr for a local socket.
+
+	{ // set CLOEXEC. Only makes sense on Unix
+		#ifdef OS_UNIX
+		int cloexec = fcntl (sd_accept, F_GETFD, 0);
+		assert (cloexec >= 0);
+		cloexec |= FD_CLOEXEC;
+		fcntl (sd_accept, F_SETFD, cloexec);
+		#endif
+	}
+
+	if (bind (sd_accept, (struct sockaddr*)&sun, sizeof(sun))) {
+		//__warning ("binding failed");
+		goto fail;
+	}
+
+	if (listen (sd_accept, 100)) {
+		//__warning ("listen failed");
+		goto fail;
+	}
+
+	{
+		// Set the acceptor non-blocking.
+		// THIS IS CRUCIALLY IMPORTANT because we read it in a select loop.
+		if (!SetSocketNonblocking (sd_accept)) {
+		//int val = fcntl (sd_accept, F_GETFL, 0);
+		//if (fcntl (sd_accept, F_SETFL, val | O_NONBLOCK) == -1) {
+			goto fail;
+		}
+	}
+
+	{ // Looking good.
+		AcceptorDescriptor *ad = new AcceptorDescriptor (this, sd_accept);
+		if (!ad)
+			throw std::runtime_error ("unable to allocate acceptor");
+		Add (ad);
+		output_binding = ad->GetBinding().c_str();
+	}
+
+	return output_binding;
+
+	fail:
+	if (sd_accept != INVALID_SOCKET)
+		closesocket (sd_accept);
+	return NULL;
+	#endif // OS_UNIX
+}
+
+
 //#endif // OS_UNIX
 

data/ext/em.h

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: em.h 47 2006-05-15 21:42:38Z blackhedd $
+$Id: em.h 264 2006-10-05 16:33:22Z blackhedd $
 
 File:     ed.h
 Date:     06Apr06
@@ -44,6 +44,14 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
   #define EmSelect select
 #endif
 
+
+#ifdef OS_UNIX
+typedef long long Int64;
+#endif
+#ifdef OS_WIN32
+typedef __int64 Int64;
+#endif
+
 extern time_t gCurrentLoopTime;
 
 class EventableDescriptor;
@@ -60,20 +68,27 @@ class EventMachine_t
 		virtual ~EventMachine_t();
 
 		void Run();
-    void ScheduleHalt();
+		void ScheduleHalt();
+		void SignalLoopBreaker();
 		const char *InstallOneshotTimer (int);
 		const char *ConnectToServer (const char *, int);
 		const char *CreateTcpServer (const char *, int);
 		const char *OpenDatagramSocket (const char *, int);
+		const char *CreateUnixDomainServer (const char*);
+		const char *_OpenFileForWriting (const char*);
 
-    void Add (EventableDescriptor*);
+		void Add (EventableDescriptor*);
 
-  public:
+		void SetTimerQuantum (int);
+
+	public:
 		enum { // Event names
 			TIMER_FIRED = 100,
-      CONNECTION_READ = 101,
-    CONNECTION_UNBOUND = 102,
-    CONNECTION_ACCEPTED = 103
+			CONNECTION_READ = 101,
+			CONNECTION_UNBOUND = 102,
+			CONNECTION_ACCEPTED = 103,
+			CONNECTION_COMPLETED = 104,
+			LOOPBREAK_SIGNAL = 105
 		};
 
 
@@ -81,6 +96,8 @@ class EventMachine_t
 		bool _RunOnce();
 		bool _RunTimers();
 		void _AddNewDescriptors();
+		void _InitializeLoopBreaker();
+		void _ReadLoopBreaker();
 
 	private:
 		enum {
@@ -92,11 +109,19 @@ class EventMachine_t
 		class Timer_t: public Bindable_t {
 		};
 
-		multimap<time_t, Timer_t> Timers;
+		multimap<Int64, Timer_t> Timers;
 		vector<EventableDescriptor*> Descriptors;
 		vector<EventableDescriptor*> NewDescriptors;
 
 		time_t NextHeartbeatTime;
+
+		int LoopBreakerReader;
+		int LoopBreakerWriter;
+		#ifdef OS_WIN32
+		struct sockaddr_in LoopBreakerTarget;
+		#endif
+
+		timeval Quantum;
 };
 
 

data/ext/emwin.h

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: emwin.h 47 2006-05-15 21:42:38Z blackhedd $
+$Id: emwin.h 209 2006-07-16 23:32:16Z blackhedd $
 
 File:     edwin.h
 Date:     05May06
@@ -62,7 +62,9 @@ class EventMachine_t
 			TIMER_FIRED = 100,
 			CONNECTION_READ = 101,
 			CONNECTION_UNBOUND = 102,
-			CONNECTION_ACCEPTED = 103
+			CONNECTION_ACCEPTED = 103,
+			CONNECTION_COMPLETED = 104,
+			LOOPBREAK_SIGNAL = 105
 		};
 
 	private:

data/ext/eventmachine.h

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: eventmachine.h 47 2006-05-15 21:42:38Z blackhedd $
+$Id: eventmachine.h 265 2006-10-05 19:07:45Z blackhedd $
 
 File:     eventmachine.h
 Date:     15Apr06
@@ -37,13 +37,21 @@ extern "C" {
 	const char *evma_install_oneshot_timer (int seconds);
 	const char *evma_connect_to_server (const char *server, int port);
 	const char *evma_create_tcp_server (const char *address, int port);
+	const char *evma_create_unix_domain_server (const char *filename);
 	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_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);
 	void evma_close_connection (const char *binding, int after_writing);
+	void evma_signal_loopbreak();
+	void evma_set_timer_quantum (int);
 	void evma_stop_machine();
 
+	const char *evma__write_file (const char *filename);
+
 #if __cplusplus
 }
 #endif