eventmachine 0.3.1 → 0.4.0

data/ext/ed.h

@@ -0,0 +1,152 @@
+/*****************************************************************************
+
+$Id: ed.h 2291 2006-04-14 03:56:18Z francis $
+
+File:     ed.h
+Date:     06Apr06
+
+Copyright (C) 2006 by Francis Cianfrocca. All Rights Reserved.
+Gmail: garbagecat20
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of 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.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+*****************************************************************************/
+
+#ifndef __EventableDescriptor__H_
+#define __EventableDescriptor__H_
+
+
+class EventMachine_t; // forward reference
+
+
+/*************************
+class EventableDescriptor
+*************************/
+
+class EventableDescriptor: public Bindable_t
+{
+	public:
+		EventableDescriptor (int);
+		virtual ~EventableDescriptor();
+
+    int GetSocket() {return MySocket;}
+    void Close();
+
+		virtual void Read() = 0;
+		virtual void Write() = 0;
+		virtual void Heartbeat() = 0;
+
+    // These methods tell us whether the descriptor
+    // should be selected or polled for read/write.
+    virtual bool SelectForRead() = 0;
+    virtual bool SelectForWrite() = 0;
+
+    // are we scheduled for a close, or in an error state, or already closed?
+		bool ShouldDelete();
+	// Do we have any data to write? This is used by ShouldDelete.
+	virtual int GetOutboundDataSize() {return 0;}
+
+    void SetEventCallback (void (*cb)(const char*, int, const char*, int));
+
+  protected:
+    enum {
+      PendingConnectTimeout = 4 // can easily be made an instance variable
+    };
+
+    void (*EventCallback)(const char*, int, const char*, int);
+    
+    time_t CreatedAt;
+    time_t LastRead;
+    time_t LastWritten;
+    int MySocket;
+    bool bCloseNow;
+    bool bCloseAfterWriting;
+};
+
+
+
+/**************************
+class ConnectionDescriptor
+**************************/
+
+class ConnectionDescriptor: public EventableDescriptor
+{
+  public:
+    ConnectionDescriptor (int);
+    virtual ~ConnectionDescriptor();
+
+    static int SendDataToConnection (const char*, const char*, int);
+    static void CloseConnection (const char*, bool);
+
+    int SendOutboundData (const char*, int);
+
+    void SetConnectPending (bool f) { bConnectPending = f; }
+
+		virtual void Read();
+		virtual void Write();
+		virtual void Heartbeat();
+
+    virtual bool SelectForRead();
+    virtual bool SelectForWrite();
+
+	// Do we have any data to write? This is used by ShouldDelete.
+	virtual int GetOutboundDataSize() {return OutboundDataSize;}
+
+  protected:
+    struct OutboundPage {
+      OutboundPage (const char *b, int l, int o=0): Buffer(b), Length(l), Offset(o) {}
+		void Free() {if (Buffer) free ((char*)Buffer); }
+      const char *Buffer;
+      int Length;
+		int Offset;
+    };
+
+  protected:
+    bool bConnectPending;
+
+    deque<OutboundPage> OutboundPages;
+    int OutboundDataSize;
+
+	private:
+		void _WriteOutboundData();
+};
+
+
+/************************
+class AcceptorDescriptor
+************************/
+
+class AcceptorDescriptor: public EventableDescriptor
+{
+  public:
+    AcceptorDescriptor (EventMachine_t*, int);
+    virtual ~AcceptorDescriptor();
+
+		virtual void Read();
+		virtual void Write();
+		virtual void Heartbeat();
+
+    virtual bool SelectForRead() {return true;}
+    virtual bool SelectForWrite() {return false;}
+
+  protected:
+    EventMachine_t *MyEventMachine;
+};
+
+
+
+#endif // __EventableDescriptor__H_
+
+

data/ext/em.cpp

@@ -0,0 +1,475 @@
+/*****************************************************************************
+
+$Id: em.cpp 2291 2006-04-14 03:56:18Z francis $
+
+File:     ed.cpp
+Date:     06Apr06
+
+Copyright (C) 2006 by Francis Cianfrocca. All Rights Reserved.
+Gmail: garbagecat20
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of 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.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+*****************************************************************************/
+
+#include "project.h"
+
+// Keep a global variable floating around
+// with the current loop time as set by the Event Machine.
+// This avoids the need for frequent expensive calls to time(NULL);
+time_t gCurrentLoopTime;
+
+
+/******************************
+EventMachine_t::EventMachine_t
+******************************/
+
+EventMachine_t::EventMachine_t (void (*event_callback)(const char*, int, const char*, int)):
+	EventCallback (event_callback),
+	NextHeartbeatTime (0)
+{
+	gTerminateSignalReceived = false;
+}
+
+
+/*******************************
+EventMachine_t::~EventMachine_t
+*******************************/
+
+EventMachine_t::~EventMachine_t()
+{
+	// Run down descriptors
+	size_t i;
+	for (i = 0; i < NewDescriptors.size(); i++)
+		delete NewDescriptors[i];
+	for (i = 0; i < Descriptors.size(); i++)
+		delete Descriptors[i];
+}
+
+
+
+/****************************
+EventMachine_t::ScheduleHalt
+****************************/
+
+void EventMachine_t::ScheduleHalt()
+{
+  /* This is how we stop the machine.
+   * 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.
+   */
+	gTerminateSignalReceived = true;
+}
+
+
+
+/*******************
+EventMachine_t::Run
+*******************/
+
+void EventMachine_t::Run()
+{
+	while (true) {
+		gCurrentLoopTime = time(NULL);
+		if (!_RunTimers())
+			break;
+		_AddNewDescriptors();
+		if (!_RunOnce())
+			break;
+		if (gTerminateSignalReceived)
+			break;
+	}
+}
+
+
+
+/************************
+EventMachine_t::_RunOnce
+************************/
+
+bool EventMachine_t::_RunOnce()
+{
+	// Crank the event machine once.
+	// If there are no descriptors to process, then sleep
+	// for a few hundred mills to avoid busy-looping.
+	// 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.
+
+	//cerr << "X";
+	if (Descriptors.size() == 0) {
+		timeval tv = {0, 200 * 1000};
+		select (0, NULL, NULL, NULL, &tv);
+		return true;
+	}
+
+	fd_set fdreads, fdwrites;
+	FD_ZERO (&fdreads);
+	FD_ZERO (&fdwrites);
+
+	int maxsocket = 0;
+
+	// prepare the sockets for reading and writing
+	size_t i;
+	for (i = 0; i < Descriptors.size(); i++) {
+		EventableDescriptor *ed = Descriptors[i];
+		assert (ed);
+		int sd = ed->GetSocket();
+		assert (sd != -1);
+
+		if (ed->SelectForRead())
+			FD_SET (sd, &fdreads);
+		if (ed->SelectForWrite())
+			FD_SET (sd, &fdwrites);
+
+		if (maxsocket < sd)
+			maxsocket = sd;
+	}
+
+
+	{ // read and write the sockets
+		timeval tv = {1, 0}; // Solaris fails if the microseconds member is >= 1000000.
+		int s = select (maxsocket+1, &fdreads, &fdwrites, NULL, &tv);
+		if (s > 0) {
+			for (i=0; i < Descriptors.size(); i++) {
+				EventableDescriptor *ed = Descriptors[i];
+				assert (ed);
+				int sd = ed->GetSocket();
+				assert (sd != -1);
+
+				if (FD_ISSET (sd, &fdwrites))
+					ed->Write();
+				if (FD_ISSET (sd, &fdreads))
+					ed->Read();
+			}
+		}
+		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,
+			// so keep the wait short.
+			timeval tv = {0, ((errno == EINTR) ? 5 : 50) * 1000};
+			select (0, NULL, NULL, NULL, &tv);
+		}
+	}
+
+
+	{ // dispatch heartbeats
+		if (gCurrentLoopTime >= NextHeartbeatTime) {
+			NextHeartbeatTime = gCurrentLoopTime + HeartbeatInterval;
+
+			for (i=0; i < Descriptors.size(); i++) {
+				EventableDescriptor *ed = Descriptors[i];
+				assert (ed);
+				ed->Heartbeat();
+			}
+		}
+	}
+
+	{ // cleanup dying sockets
+		// vector::pop_back works in constant time.
+		int i, j;
+		int nSockets = Descriptors.size();
+		for (i=0, j=0; i < nSockets; i++) {
+			EventableDescriptor *ed = Descriptors[i];
+			assert (ed);
+			if (ed->ShouldDelete())
+				delete ed;
+			else
+				Descriptors [j++] = ed;
+		}
+		while ((size_t)j < Descriptors.size())
+			Descriptors.pop_back();
+
+	}
+
+	return true;
+}
+
+
+/**************************
+EventMachine_t::_RunTimers
+**************************/
+
+bool EventMachine_t::_RunTimers()
+{
+	// These are caller-defined timer handlers.
+	// Return T/F to indicate whether we should continue the main loop.
+	// We rely on the fact that multimaps sort by their keys to avoid
+	// inspecting the whole list every time we come here.
+	// Just keep inspecting and processing the list head until we hit
+	// one that hasn't expired yet.
+
+	while (true) {
+		multimap<time_t,Timer_t>::iterator i = Timers.begin();
+		if (i == Timers.end())
+			break;
+		if (i->first > gCurrentLoopTime)
+			break;
+		if (EventCallback)
+			(*EventCallback) ("", TIMER_FIRED, i->second.GetBinding().c_str(), i->second.GetBinding().length());
+		Timers.erase (i);
+	}
+	return true;
+}
+
+
+
+/***********************************
+EventMachine_t::InstallOneshotTimer
+***********************************/
+
+const char *EventMachine_t::InstallOneshotTimer (int seconds)
+{
+	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.
+
+	Timer_t t;
+	Timers.insert (make_pair (time(NULL) + seconds, t));
+	return t.GetBinding().c_str();
+}
+
+
+/*******************************
+EventMachine_t::ConnectToServer
+*******************************/
+
+const char *EventMachine_t::ConnectToServer (const char *server, int port)
+{
+	/* We want to spend no more than a few seconds waiting for a connection
+	 * to a remote host. So we use a nonblocking connect.
+	 * Linux disobeys the usual rules for nonblocking connects.
+	 * Per Stevens (UNP p.410), you expect a nonblocking connect to select
+	 * both readable and writable on error, and not to return EINPROGRESS
+	 * if the connect can be fulfilled immediately. Linux violates both
+	 * of these expectations.
+	 * Any kind of nonblocking connect on Linux returns EINPROGRESS.
+	 * The socket will then return writable when the disposition of the
+	 * connect is known, but it will not also be readable in case of
+	 * error! Weirdly, it will be readable in case there is data to read!!!
+	 * (Which can happen with protocols like SSH and SMTP.)
+	 * I suppose if you were so inclined you could consider this logical,
+	 * but it's not the way Unix has historically done it.
+	 * So we ignore the readable flag and read getsockopt to see if there
+	 * was an error connecting. A select timeout works as expected.
+	 * In regard to getsockopt: Linux does the Berkeley-style thing,
+	 * not the Solaris-style, and returns zero with the error code in
+	 * the error parameter.
+	 * Return the binding-text of the newly-created pending connection,
+   * or NULL if there was a problem.
+	 */
+
+	if (!server || !*server || !port)
+		return NULL;
+
+	sockaddr_in pin;
+	unsigned long HostAddr;
+
+	HostAddr = inet_addr (server);
+	if (HostAddr == -1) {
+		hostent *hp = gethostbyname (server);
+		if (!hp)
+			return NULL;
+		HostAddr = ((in_addr*)(hp->h_addr))->s_addr;
+	}
+
+	memset (&pin, 0, sizeof(pin));
+	pin.sin_family = AF_INET;
+	pin.sin_addr.s_addr = HostAddr;
+	pin.sin_port = htons (port);
+
+	int sd = socket (AF_INET, SOCK_STREAM, 0);
+	if (sd == -1)
+		return NULL;
+
+	// From here on, ALL error returns must close the socket.
+	// Set the new socket nonblocking.
+	int val = fcntl (sd, F_GETFL, 0);
+	if (fcntl (sd, F_SETFL, val | O_NONBLOCK) == -1) {
+		close (sd);
+		return NULL;
+	}
+
+	const char *out = NULL;
+	if (connect (sd, (sockaddr*)&pin, sizeof pin) == 0) {
+		// This is a connect success, which Linux appears
+		// never to give when the socket is nonblocking,
+		// even if the connection is intramachine or to
+		// localhost.
+		throw std::runtime_error ("unimplemented");
+	}
+	else if (errno == EINPROGRESS) {
+		// Errno will generally always be EINPROGRESS, but on Linux
+		// we have to look at getsockopt to be sure what really happened.
+		int error;
+		socklen_t len;
+		len = sizeof(error);
+		int o = getsockopt (sd, SOL_SOCKET, SO_ERROR, &error, &len);
+		if ((o == 0) && (error == 0)) {
+			// Here, there's no disposition.
+			// Put the connection on the stack and wait for it to complete
+			// or time out.
+			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 {
+			// This could be connection refused or something such thing.
+		}
+	}
+	else {
+		// The error from connect was something other then EINPROGRESS.
+	}
+
+	if (out == NULL)
+		close (sd);
+	return out;
+}
+
+
+/*******************************
+EventMachine_t::CreateTcpServer
+*******************************/
+
+const char *EventMachine_t::CreateTcpServer (const char *server, int port)
+{
+  /* Create a TCP-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.
+   */
+
+  const char *output_binding = NULL;
+
+	struct sockaddr_in sin;
+
+	int sd_accept = socket (AF_INET, SOCK_STREAM, 0);
+	if (sd_accept == -1) {
+		goto fail;
+	}
+
+	memset (&sin, 0, sizeof(sin));
+	sin.sin_family = AF_INET;
+	sin.sin_addr.s_addr = INADDR_ANY;
+	sin.sin_port = htons (port);
+
+	if (server && *server) {
+		sin.sin_addr.s_addr = inet_addr (server);
+		if (sin.sin_addr.s_addr == -1) {
+			hostent *hp = gethostbyname (server);
+			if (hp == NULL) {
+				//__warning ("hostname not resolved: ", server);
+				goto fail;
+			}
+			sin.sin_addr.s_addr = ((in_addr*)(hp->h_addr))->s_addr;
+		}
+	}
+
+	{ // set reuseaddr to improve performance on restarts.
+		int oval = 1;
+		if (setsockopt (sd_accept, SOL_SOCKET, SO_REUSEADDR, (char*)&oval, sizeof(oval)) < 0) {
+			//__warning ("setsockopt failed while creating listener","");
+			goto fail;
+		}
+	}
+
+	{ // set CLOEXEC.
+		int cloexec = fcntl (sd_accept, F_GETFD, 0);
+		assert (cloexec >= 0);
+		cloexec |= FD_CLOEXEC;
+		fcntl (sd_accept, F_SETFD, cloexec);
+	}
+
+
+	if (bind (sd_accept, (struct sockaddr*)&sin, sizeof(sin))) {
+		//__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.
+		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 != -1)
+		close (sd_accept);
+	return NULL;
+}
+
+
+
+
+/*******************
+EventMachine_t::Add
+*******************/
+
+void EventMachine_t::Add (EventableDescriptor *ed)
+{
+	if (!ed)
+		throw std::runtime_error ("added bad descriptor");
+  ed->SetEventCallback (EventCallback);
+	NewDescriptors.push_back (ed);
+}
+
+
+/**********************************
+EventMachine_t::_AddNewDescriptors
+**********************************/
+
+void EventMachine_t::_AddNewDescriptors()
+{
+	/* Avoid adding descriptors to the main descriptor list
+	 * while we're actually traversing the list.
+	 * 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.
+	 */
+
+	for (size_t i = 0; i < NewDescriptors.size(); i++) {
+		EventableDescriptor *ed = NewDescriptors[i];
+		if (ed == NULL)
+			throw std::runtime_error ("adding bad descriptor");
+		Descriptors.push_back (ed);
+	}
+	NewDescriptors.clear();
+}
+
+