eventmachine 1.0.0.beta.3-java → 1.0.0.beta.4-java

data/examples/guides/getting_started/08_simple_chat_server_step_five.rb

@@ -0,0 +1,141 @@
+#!/usr/bin/env ruby
+
+require 'rubygems' # or use Bundler.setup
+require 'eventmachine'
+
+class SimpleChatServer < EM::Connection
+
+  @@connected_clients = Array.new
+  DM_REGEXP           = /^@([a-zA-Z0-9]+)\s*:?\s+(.+)/.freeze
+
+  attr_reader :username
+
+
+  #
+  # EventMachine handlers
+  #
+
+  def post_init
+    @username = nil
+
+    puts "A client has connected..."
+    ask_username
+  end
+
+  def unbind
+    @@connected_clients.delete(self)
+    puts "[info] #{@username} has left" if entered_username?
+  end
+
+  def receive_data(data)
+    if entered_username?
+      handle_chat_message(data.strip)
+    else
+      handle_username(data.strip)
+    end
+  end
+
+
+  #
+  # Username handling
+  #
+
+  def entered_username?
+    !@username.nil? && !@username.empty?
+  end # entered_username?
+
+  def handle_username(input)
+    if input.empty?
+      send_line("Blank usernames are not allowed. Try again.")
+      ask_username
+    else
+      @username = input
+      @@connected_clients.push(self)
+      self.other_peers.each { |c| c.send_data("#{@username} has joined the room\n") }
+      puts "#{@username} has joined"
+
+      self.send_line("[info] Ohai, #{@username}")
+    end
+  end # handle_username(input)
+
+  def ask_username
+    self.send_line("[info] Enter your username:")
+  end # ask_username
+
+
+  #
+  # Message handling
+  #
+
+  def handle_chat_message(msg)
+    if command?(msg)
+      self.handle_command(msg)
+    else
+      if direct_message?(msg)
+        self.handle_direct_message(msg)
+      else
+        self.announce(msg, "#{@username}:")
+      end
+    end
+  end # handle_chat_message(msg)
+
+  def direct_message?(input)
+    input =~ DM_REGEXP
+  end # direct_message?(input)
+
+  def handle_direct_message(input)
+    username, message = parse_direct_message(input)
+
+    if connection = @@connected_clients.find { |c| c.username == username }
+      puts "[dm] @#{@username} => @#{username}"
+      connection.send_line("[dm] @#{@username}: #{message}")
+    else
+      send_line "@#{username} is not in the room. Here's who is: #{usernames.join(', ')}"
+    end
+  end # handle_direct_message(input)
+
+  def parse_direct_message(input)
+    return [$1, $2] if input =~ DM_REGEXP
+  end # parse_direct_message(input)
+
+
+  #
+  # Commands handling
+  #
+
+  def command?(input)
+    input =~ /(exit|status)$/i
+  end # command?(input)
+
+  def handle_command(cmd)
+    case cmd
+    when /exit$/i   then self.close_connection
+    when /status$/i then self.send_line("[chat server] It's #{Time.now.strftime('%H:%M')} and there are #{self.number_of_connected_clients} people in the room")
+    end
+  end # handle_command(cmd)
+
+
+  #
+  # Helpers
+  #
+
+  def announce(msg = nil, prefix = "[chat server]")
+    @@connected_clients.each { |c| c.send_line("#{prefix} #{msg}") } unless msg.empty?
+  end # announce(msg)
+
+  def other_peers
+    @@connected_clients.reject { |c| self == c }
+  end # other_peers
+
+  def send_line(line)
+    self.send_data("#{line}\n")
+  end # send_line(line)
+end
+
+EventMachine.run do
+  # hit Control + C to stop
+  Signal.trap("INT")  { EventMachine.stop }
+  Signal.trap("TERM") { EventMachine.stop }
+
+  EventMachine.start_server("0.0.0.0", 10000, SimpleChatServer)
+end

data/examples/{ex_channel.rb → old/ex_channel.rb}

@@ -33,11 +33,11 @@ EM.run do
     end
   end
 
-  # This part of the example is more fake, but imagine sleep was in fact a 
+  # This part of the example is more fake, but imagine sleep was in fact a
   # long running calculation to achieve the value.
   40.times do
     EM.defer lambda { v = sleep(rand * 2); RandChannel << [Time.now, v] }
   end
-  
+
   EM.add_timer(5) { EM.stop }
-end
+end

data/ext/cmain.cpp

@@ -220,7 +220,7 @@ evma_pause
 
 extern "C" int evma_pause (const unsigned long binding)
 {
-	ConnectionDescriptor *cd = dynamic_cast <ConnectionDescriptor*> (Bindable_t::GetObject (binding));
+	EventableDescriptor *cd = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
 	if (cd)
 		return cd->Pause() ? 1 : 0;
 
@@ -233,7 +233,7 @@ evma_resume
 
 extern "C" int evma_resume (const unsigned long binding)
 {
-	ConnectionDescriptor *cd = dynamic_cast <ConnectionDescriptor*> (Bindable_t::GetObject (binding));
+	EventableDescriptor *cd = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
 	if (cd)
 		return cd->Resume() ? 1 : 0;
 
@@ -246,7 +246,7 @@ evma_is_paused
 
 extern "C" int evma_is_paused (const unsigned long binding)
 {
-	ConnectionDescriptor *cd = dynamic_cast <ConnectionDescriptor*> (Bindable_t::GetObject (binding));
+	EventableDescriptor *cd = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
 	if (cd)
 		return cd->IsPaused() ? 1 : 0;
 

data/ext/ed.cpp

@@ -63,7 +63,8 @@ EventableDescriptor::EventableDescriptor (int sd, EventMachine_t *em):
 	MaxOutboundBufSize(0),
 	MyEventMachine (em),
 	PendingConnectTimeout(20000000),
-	InactivityTimeout (0)
+	InactivityTimeout (0),
+	bPaused (false)
 {
 	/* There are three ways to close a socket, all of which should
 	 * automatically signal to the event machine that this object
@@ -107,7 +108,7 @@ EventableDescriptor::~EventableDescriptor
 EventableDescriptor::~EventableDescriptor()
 {
 	if (NextHeartbeat)
-		MyEventMachine->ClearHeartbeat(NextHeartbeat);
+		MyEventMachine->ClearHeartbeat(NextHeartbeat, this);
 	if (EventCallback && bCallbackUnbind)
 		(*EventCallback)(GetBinding(), EM_CONNECTION_UNBOUND, NULL, UnbindReasonCode);
 	if (ProxiedFrom) {
@@ -135,10 +136,54 @@ EventableDescriptor::Close
 
 void EventableDescriptor::Close()
 {
+	/* EventMachine relies on the fact that when close(fd)
+	 * is called that the fd is removed from any
+	 * epoll event queues.
+	 *
+	 * However, this is not *always* the behavior of close(fd)
+	 *
+	 * See man 4 epoll Q6/A6 and then consider what happens
+	 * when using pipes with eventmachine.
+	 * (As is often done when communicating with a subprocess)
+	 *
+	 * The pipes end up looking like:
+	 *
+	 * ls -l /proc/<pid>/fd
+	 * ...
+	 * lr-x------ 1 root root 64 2011-08-19 21:31 3 -> pipe:[940970]
+	 * l-wx------ 1 root root 64 2011-08-19 21:31 4 -> pipe:[940970]
+	 *
+	 * This meets the critera from man 4 epoll Q6/A4 for not
+	 * removing fds from epoll event queues until all fds
+	 * that reference the underlying file have been removed.
+	 *
+	 * If the EventableDescriptor associated with fd 3 is deleted,
+	 * its dtor will call EventableDescriptor::Close(),
+	 * which will call ::close(int fd).
+	 *
+	 * However, unless the EventableDescriptor associated with fd 4 is
+	 * also deleted before the next call to epoll_wait, events may fire
+	 * for fd 3 that were registered with an already deleted
+	 * EventableDescriptor.
+	 *
+	 * Therefore, it is necessary to notify EventMachine that
+	 * the fd associated with this EventableDescriptor is
+	 * closing.
+	 *
+	 * EventMachine also never closes fds for STDIN, STDOUT and 
+	 * STDERR (0, 1 & 2)
+	 */
+
 	// Close the socket right now. Intended for emergencies.
-	if (MySocket != INVALID_SOCKET && !bWatchOnly) {
-		shutdown (MySocket, 1);
-		close (MySocket);
+	if (MySocket != INVALID_SOCKET) {
+		MyEventMachine->Deregister (this);
+		
+		// Do not close STDIN, STDOUT, STDERR
+		if (MySocket > 2 && !bWatchOnly) {
+			shutdown (MySocket, 1);
+			close (MySocket);
+		}
+		
 		MySocket = INVALID_SOCKET;
 	}
 }
@@ -294,7 +339,7 @@ EventableDescriptor::GetNextHeartbeat
 uint64_t EventableDescriptor::GetNextHeartbeat()
 {
 	if (NextHeartbeat)
-		MyEventMachine->ClearHeartbeat(NextHeartbeat);
+		MyEventMachine->ClearHeartbeat(NextHeartbeat, this);
 
 	NextHeartbeat = 0;
 
@@ -319,7 +364,6 @@ ConnectionDescriptor::ConnectionDescriptor
 
 ConnectionDescriptor::ConnectionDescriptor (int sd, EventMachine_t *em):
 	EventableDescriptor (sd, em),
-	bPaused (false),
 	bConnectPending (false),
 	bNotifyReadable (false),
 	bNotifyWritable (false),
@@ -703,6 +747,7 @@ void ConnectionDescriptor::Read()
 		
 
 		int r = read (sd, readbuffer, sizeof(readbuffer) - 1);
+		int e = errno;
 		//cerr << "<R:" << r << ">";
 
 		if (r > 0) {
@@ -721,8 +766,21 @@ void ConnectionDescriptor::Read()
 			break;
 		}
 		else {
-			// Basically a would-block, meaning we've read everything there is to read.
-			break;
+			#ifdef OS_UNIX
+			if ((e != EINPROGRESS) && (e != EWOULDBLOCK) && (e != EAGAIN) && (e != EINTR)) {
+			#endif
+			#ifdef OS_WIN32
+			if ((e != WSAEINPROGRESS) && (e != WSAEWOULDBLOCK)) {
+			#endif
+				// 26Mar11: Previously, all read errors were assumed to be EWOULDBLOCK and ignored.
+				// Now, instead, we call Close() on errors like ECONNRESET and ENOTCONN.
+				UnbindReasonCode = e;
+				Close();
+				break;
+			} else {
+				// Basically a would-block, meaning we've read everything there is to read.
+				break;
+			}
 		}
 
 	}
@@ -831,9 +889,12 @@ void ConnectionDescriptor::Write()
 			// from EventMachine_t::AttachFD as well.
 			SetConnectPending (false);
 		}
-		else
+		else {
+			if (o == 0)
+				UnbindReasonCode = error;
 			ScheduleClose (false);
 			//bCloseNow = true;
+		}
 	}
 	else {
 
@@ -953,6 +1014,7 @@ void ConnectionDescriptor::_WriteOutboundData()
 	#endif
 
 	bool err = false;
+	int e = errno;
 	if (bytes_written < 0) {
 		err = true;
 		bytes_written = 0;
@@ -1003,12 +1065,14 @@ void ConnectionDescriptor::_WriteOutboundData()
 
 	if (err) {
 		#ifdef OS_UNIX
-		if ((errno != EINPROGRESS) && (errno != EWOULDBLOCK) && (errno != EINTR))
+		if ((e != EINPROGRESS) && (e != EWOULDBLOCK) && (e != EINTR)) {
 		#endif
 		#ifdef OS_WIN32
-		if ((errno != WSAEINPROGRESS) && (errno != WSAEWOULDBLOCK))
+		if ((e != WSAEINPROGRESS) && (e != WSAEWOULDBLOCK)) {
 		#endif
+			UnbindReasonCode = e;
 			Close();
+		}
 	}
 }
 
@@ -1019,6 +1083,10 @@ ConnectionDescriptor::ReportErrorStatus
 
 int ConnectionDescriptor::ReportErrorStatus()
 {
+	if (MySocket == INVALID_SOCKET) {
+		return -1;
+	}
+
 	int error;
 	socklen_t len;
 	len = sizeof(error);
@@ -1030,8 +1098,10 @@ int ConnectionDescriptor::ReportErrorStatus()
 	#endif
 	if ((o == 0) && (error == 0))
 		return 0;
+	else if (o == 0)
+		return error;
 	else
-		return 1;
+		return -1;
 }
 
 
@@ -1198,14 +1268,18 @@ void ConnectionDescriptor::Heartbeat()
 	 */
 
 	if (bConnectPending) {
-		if ((MyEventMachine->GetCurrentLoopTime() - CreatedAt) >= PendingConnectTimeout)
+		if ((MyEventMachine->GetCurrentLoopTime() - CreatedAt) >= PendingConnectTimeout) {
+			UnbindReasonCode = ETIMEDOUT;
 			ScheduleClose (false);
 			//bCloseNow = true;
+    }
 	}
 	else {
-		if (InactivityTimeout && ((MyEventMachine->GetCurrentLoopTime() - LastActivity) >= InactivityTimeout))
+		if (InactivityTimeout && ((MyEventMachine->GetCurrentLoopTime() - LastActivity) >= InactivityTimeout)) {
+			UnbindReasonCode = ETIMEDOUT;
 			ScheduleClose (false);
 			//bCloseNow = true;
+    }
 	}
 }
 
@@ -1582,6 +1656,7 @@ void DatagramDescriptor::Write()
 			#ifdef OS_WIN32
 			if ((e != WSAEINPROGRESS) && (e != WSAEWOULDBLOCK)) {
 			#endif
+				UnbindReasonCode = e;
 				Close();
 				break;
 			}

data/ext/ed.h

@@ -88,10 +88,11 @@ class EventableDescriptor: public Bindable_t
 		virtual void StopProxy();
 		virtual void SetProxiedFrom(EventableDescriptor*, const unsigned long);
 		virtual int SendOutboundData(const char*,int){ return -1; }
-		virtual bool IsPaused(){ return false; }
-		virtual bool Pause(){ return false; }
-		virtual bool Resume(){ return false; }
+		virtual bool IsPaused(){ return bPaused; }
+		virtual bool Pause(){ bPaused = true; return bPaused; }
+		virtual bool Resume(){ bPaused = false; return bPaused; }
 
+		void SetUnbindReasonCode(int code){ UnbindReasonCode = code; }
 		virtual int ReportErrorStatus(){ return 0; }
 		virtual bool IsConnectPending(){ return false; }
 		virtual uint64_t GetNextHeartbeat();
@@ -126,6 +127,7 @@ class EventableDescriptor: public Bindable_t
 		uint64_t InactivityTimeout;
 		uint64_t LastActivity;
 		uint64_t NextHeartbeat;
+		bool bPaused;
 };
 
 
@@ -169,7 +171,6 @@ class ConnectionDescriptor: public EventableDescriptor
 		void SetNotifyWritable (bool);
 		void SetWatchOnly (bool);
 
-		bool IsPaused(){ return bPaused; }
 		bool Pause();
 		bool Resume();
 
@@ -216,7 +217,6 @@ class ConnectionDescriptor: public EventableDescriptor
 		};
 
 	protected:
-		bool bPaused;
 		bool bConnectPending;
 
 		bool bNotifyReadable;

data/ext/em.cpp

@@ -415,9 +415,17 @@ void EventMachine_t::QueueHeartbeat(EventableDescriptor *ed)
 EventMachine_t::ClearHeartbeat
 ******************************/
 
-void EventMachine_t::ClearHeartbeat(uint64_t key)
+void EventMachine_t::ClearHeartbeat(uint64_t key, EventableDescriptor* ed)
 {
-	Heartbeats.erase(key);
+	multimap<uint64_t,EventableDescriptor*>::iterator it;
+	pair<multimap<uint64_t,EventableDescriptor*>::iterator,multimap<uint64_t,EventableDescriptor*>::iterator> ret;
+	ret = Heartbeats.equal_range (key);
+	for (it = ret.first; it != ret.second; ++it) {
+		if (it->second == ed) {
+			Heartbeats.erase (it);
+			break;
+		}
+	}
 }
 
 /*******************
@@ -465,8 +473,7 @@ void EventMachine_t::Run()
 
 	while (true) {
 		_UpdateTime();
-		if (!_RunTimers())
-			break;
+		_RunTimers();
 
 		/* _Add must precede _Modify because the same descriptor might
 		 * be on both lists during the same pass through the machine,
@@ -513,7 +520,8 @@ bool EventMachine_t::_RunEpollOnce()
 	assert (epfd != -1);
 	int s;
 
-	timeval tv = _TimeTilNextEvent();
+	timeval tv;
+	_TimeTilNextEvent(&tv);
 
 	#ifdef BUILD_FOR_RUBY
 	int ret = 0;
@@ -583,7 +591,8 @@ bool EventMachine_t::_RunKqueueOnce()
 	assert (kqfd != -1);
 	int k;
 
-	timeval tv = _TimeTilNextEvent();
+	timeval tv;
+	_TimeTilNextEvent(&tv);
 
 	struct timespec ts;
 	ts.tv_sec = tv.tv_sec;
@@ -664,7 +673,7 @@ bool EventMachine_t::_RunKqueueOnce()
 EventMachine_t::_TimeTilNextEvent
 *********************************/
 
-timeval EventMachine_t::_TimeTilNextEvent()
+timeval *EventMachine_t::_TimeTilNextEvent(timeval *tv)
 {
 	uint64_t next_event = 0;
 
@@ -683,17 +692,17 @@ timeval EventMachine_t::_TimeTilNextEvent()
 		next_event = MyCurrentLoopTime;
 	}
 
-	timeval tv;
-
 	if (next_event == 0) {
-		tv = Quantum;
+		// tv->tv_sec = Quantum->tv_sec;
+		// tv->tv_usec = Quantum->tv_usec;
+		return NULL;
 	} else {
 		if (next_event > MyCurrentLoopTime) {
 			uint64_t duration = next_event - MyCurrentLoopTime;
-			tv.tv_sec = duration / 1000000;
-			tv.tv_usec = duration % 1000000;
+			tv->tv_sec = duration / 1000000;
+			tv->tv_usec = duration % 1000000;
 		} else {
-			tv.tv_sec = tv.tv_usec = 0;
+			tv->tv_sec = tv->tv_usec = 0;
 		}
 	}
 
@@ -899,7 +908,7 @@ bool EventMachine_t::_RunSelectOnce()
 	{ // read and write the sockets
 		//timeval tv = {1, 0}; // Solaris fails if the microseconds member is >= 1000000.
 		//timeval tv = Quantum;
-		SelectData.tv = _TimeTilNextEvent();
+		_TimeTilNextEvent(&SelectData.tv);
 		int s = SelectData._Select();
 		//rb_thread_blocking_region(xxx,(void*)&SelectData,RUBY_UBF_IO,0);
 		//int s = EmSelect (SelectData.maxsocket+1, &(SelectData.fdreads), &(SelectData.fdwrites), NULL, &(SelectData.tv));
@@ -1005,10 +1014,9 @@ void EventMachine_t::_ReadLoopBreaker()
 EventMachine_t::_RunTimers
 **************************/
 
-bool EventMachine_t::_RunTimers()
+void 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
@@ -1024,7 +1032,6 @@ bool EventMachine_t::_RunTimers()
 			(*EventCallback) (0, EM_TIMER_FIRED, NULL, i->second.GetBinding());
 		Timers.erase (i);
 	}
-	return true;
 }
 
 
@@ -1096,34 +1103,6 @@ const unsigned long EventMachine_t::ConnectToServer (const char *bind_addr, int
 		throw std::runtime_error (buf);
 	}
 
-	/*
-	sockaddr_in pin;
-	unsigned long HostAddr;
-
-	HostAddr = inet_addr (server);
-	if (HostAddr == INADDR_NONE) {
-		hostent *hp = gethostbyname ((char*)server); // Windows requires (char*)
-		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;
-	}
-
-	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 == INVALID_SOCKET)
-		return NULL;
-	*/
-
 	// From here on, ALL error returns must close the socket.
 	// Set the new socket nonblocking.
 	if (!SetSocketNonblocking (sd)) {
@@ -1150,6 +1129,7 @@ const unsigned long EventMachine_t::ConnectToServer (const char *bind_addr, int
 	}
 
 	unsigned long out = 0;
+	int e = 0;
 
 	#ifdef OS_UNIX
 	//if (connect (sd, (sockaddr*)&pin, sizeof pin) == 0) {
@@ -1183,7 +1163,7 @@ const unsigned long EventMachine_t::ConnectToServer (const char *bind_addr, int
 	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;
+		int error = 0;
 		socklen_t len;
 		len = sizeof(error);
 		int o = getsockopt (sd, SOL_SOCKET, SO_ERROR, &error, &len);
@@ -1197,11 +1177,15 @@ const unsigned long EventMachine_t::ConnectToServer (const char *bind_addr, int
 			cd->SetConnectPending (true);
 			Add (cd);
 			out = cd->GetBinding();
+		} else {
+			// Fall through to the !out case below.
+			e = error;
 		}
 	}
 	else {
 		// The error from connect was something other then EINPROGRESS (EHOSTDOWN, etc).
 		// Fall through to the !out case below
+		e = errno;
 	}
 
 	if (!out) {
@@ -1220,6 +1204,7 @@ const unsigned long EventMachine_t::ConnectToServer (const char *bind_addr, int
 		ConnectionDescriptor *cd = new ConnectionDescriptor (sd, this);
 		if (!cd)
 			throw std::runtime_error ("no connection allocated");
+		cd->SetUnbindReasonCode(e);
 		cd->ScheduleClose (false);
 		Add (cd);
 		out = cd->GetBinding();
@@ -1526,25 +1511,6 @@ const unsigned long EventMachine_t::CreateTcpServer (const char *server, int por
 		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 == INADDR_NONE) {
-			hostent *hp = gethostbyname ((char*)server); // Windows requires the cast.
-			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) {
@@ -1824,6 +1790,34 @@ void EventMachine_t::Modify (EventableDescriptor *ed)
 }
 
 
+/***********************
+EventMachine_t::Deregister
+***********************/
+
+void EventMachine_t::Deregister (EventableDescriptor *ed)
+{
+	if (!ed)
+		throw std::runtime_error ("modified bad descriptor");
+	#ifdef HAVE_EPOLL
+	// cut/paste from _CleanupSockets().  The error handling could be
+	// refactored out of there, but it is cut/paste all over the
+	// file already.
+	if (bEpoll) {
+		assert (epfd != -1);
+		assert (ed->GetSocket() != INVALID_SOCKET);
+		int e = epoll_ctl (epfd, EPOLL_CTL_DEL, ed->GetSocket(), ed->GetEpollEvent());
+		// ENOENT or EBADF are not errors because the socket may be already closed when we get here.
+		if (e && (errno != ENOENT) && (errno != EBADF) && (errno != EPERM)) {
+			char buf [200];
+			snprintf (buf, sizeof(buf)-1, "unable to delete epoll event: %s", strerror(errno));
+			throw std::runtime_error (buf);
+		}
+		ModifiedDescriptors.erase(ed);
+	}
+	#endif
+}
+
+
 /**************************************
 EventMachine_t::CreateUnixDomainServer
 **************************************/