eventmachine-eventmachine 0.12.7 → 0.12.8

data/ext/em.cpp

@@ -26,7 +26,7 @@ See the file COPYING for complete licensing information.
 // 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;
+Int64 gCurrentLoopTime;
 
 #ifdef OS_WIN32
 unsigned gTickCountTickover;
@@ -87,7 +87,9 @@ EventMachine_t::EventMachine_t (void (*event_callback)(const char*, int, const c
 	bEpoll (false),
 	bKqueue (false),
 	kqfd (-1),
-	epfd (-1)
+	epfd (-1),
+	inotify (NULL),
+	HeartbeatInterval(2)
 {
 	// Default time-slice is just smaller than one hundred mills.
 	Quantum.tv_sec = 0;
@@ -96,7 +98,7 @@ EventMachine_t::EventMachine_t (void (*event_callback)(const char*, int, const c
 	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);
+	_UpdateTime();
 
 	/* We initialize the network library here (only on Windows of course)
 	 * and initialize "loop breakers." Our destructor also does some network-level
@@ -129,6 +131,10 @@ EventMachine_t::~EventMachine_t()
 	close (LoopBreakerReader);
 	close (LoopBreakerWriter);
 
+	// Remove any file watch descriptors
+	for(map<int, Bindable_t*>::iterator f=Files.begin(); f != Files.end(); f++)
+		UnwatchFile (f->first);
+
 	if (epfd != -1)
 		close (epfd);
 	if (kqfd != -1)
@@ -339,6 +345,28 @@ void EventMachine_t::_InitializeLoopBreaker()
 	#endif
 }
 
+/***************************
+EventMachine_t::_UpdateTime
+***************************/
+
+void EventMachine_t::_UpdateTime()
+{
+	#if defined(OS_UNIX)
+	struct timeval tv;
+	gettimeofday (&tv, NULL);
+	gCurrentLoopTime = (((Int64)(tv.tv_sec)) * 1000000LL) + ((Int64)(tv.tv_usec));
+
+	#elif defined(OS_WIN32)
+	unsigned tick = GetTickCount();
+	if (tick < gLastTickCount)
+		gTickCountTickover += 1;
+	gLastTickCount = tick;
+	gCurrentLoopTime = ((Int64)gTickCountTickover << 32) + (Int64)tick;
+
+	#else
+	gCurrentLoopTime = (Int64)time(NULL) * 1000000LL;
+	#endif
+}
 
 /*******************
 EventMachine_t::Run
@@ -388,7 +416,7 @@ void EventMachine_t::Run()
 	#endif
 
 	while (true) {
-		gCurrentLoopTime = time(NULL);
+		_UpdateTime();
 		if (!_RunTimers())
 			break;
 
@@ -435,26 +463,25 @@ bool EventMachine_t::_RunEpollOnce()
 {
 	#ifdef HAVE_EPOLL
 	assert (epfd != -1);
-	struct epoll_event ev [MaxEpollDescriptors];
 	int s;
 
 	#ifdef BUILD_FOR_RUBY
 	TRAP_BEG;
 	#endif
-	s = epoll_wait (epfd, ev, MaxEpollDescriptors, 50);
+	s = epoll_wait (epfd, epoll_events, MaxEvents, 50);
 	#ifdef BUILD_FOR_RUBY
 	TRAP_END;
 	#endif
 
 	if (s > 0) {
 		for (int i=0; i < s; i++) {
-			EventableDescriptor *ed = (EventableDescriptor*) ev[i].data.ptr;
+			EventableDescriptor *ed = (EventableDescriptor*) epoll_events[i].data.ptr;
 
-			if (ev[i].events & (EPOLLERR | EPOLLHUP))
+			if (epoll_events[i].events & (EPOLLERR | EPOLLHUP))
 				ed->ScheduleClose (false);
-			if (ev[i].events & EPOLLIN)
+			if (epoll_events[i].events & EPOLLIN)
 				ed->Read();
-			if (ev[i].events & EPOLLOUT) {
+			if (epoll_events[i].events & EPOLLOUT) {
 				ed->Write();
 				epoll_ctl (epfd, EPOLL_CTL_MOD, ed->GetSocket(), ed->GetEpollEvent());
 				// Ignoring return value
@@ -551,29 +578,43 @@ bool EventMachine_t::_RunKqueueOnce()
 {
 	#ifdef HAVE_KQUEUE
 	assert (kqfd != -1);
-	const int maxKevents = 2000;
-	struct kevent Karray [maxKevents];
 	struct timespec ts = {0, 10000000}; // Too frequent. Use blocking_region
 
 	int k;
 	#ifdef BUILD_FOR_RUBY
 	TRAP_BEG;
 	#endif
-	k = kevent (kqfd, NULL, 0, Karray, maxKevents, &ts);
+	k = kevent (kqfd, NULL, 0, Karray, MaxEvents, &ts);
 	#ifdef BUILD_FOR_RUBY
 	TRAP_END;
 	#endif
+
 	struct kevent *ke = Karray;
 	while (k > 0) {
-		EventableDescriptor *ed = (EventableDescriptor*) (ke->udata);
-		assert (ed);
+		switch (ke->filter)
+		{
+			case EVFILT_VNODE:
+				_HandleKqueueFileEvent (ke);
+				break;
+
+			case EVFILT_PROC:
+				_HandleKqueuePidEvent (ke);
+				break;
+
+			case EVFILT_READ:
+			case EVFILT_WRITE:
+				EventableDescriptor *ed = (EventableDescriptor*) (ke->udata);
+				assert (ed);
 
-		if (ke->filter == EVFILT_READ)
-			ed->Read();
-		else if (ke->filter == EVFILT_WRITE)
-			ed->Write();
-		else
-			cerr << "Discarding unknown kqueue event " << ke->filter << endl;
+				if (ke->filter == EVFILT_READ)
+					ed->Read();
+				else if (ke->filter == EVFILT_WRITE)
+					ed->Write();
+				else
+					cerr << "Discarding unknown kqueue event " << ke->filter << endl;
+
+				break;
+		}
 
 		--k;
 		++ke;
@@ -875,25 +916,11 @@ 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<Int64,Timer_t>::iterator i = Timers.begin();
 		if (i == Timers.end())
 			break;
-		if (i->first > now)
+		if (i->first > gCurrentLoopTime)
 			break;
 		if (EventCallback)
 			(*EventCallback) ("", EM_TIMER_FIRED, i->second.GetBinding().c_str(), i->second.GetBinding().length());
@@ -946,7 +973,7 @@ const char *EventMachine_t::InstallOneshotTimer (int milliseconds)
 EventMachine_t::ConnectToServer
 *******************************/
 
-const char *EventMachine_t::ConnectToServer (const char *server, int port)
+const char *EventMachine_t::ConnectToServer (const char *bind_addr, int bind_port, 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.
@@ -975,9 +1002,10 @@ const char *EventMachine_t::ConnectToServer (const char *server, int port)
 		return NULL;
 
 	int family, bind_size;
-	struct sockaddr *bind_as = name2address (server, port, &family, &bind_size);
-	if (!bind_as)
+	struct sockaddr bind_as, *bind_as_ptr = name2address (server, port, &family, &bind_size);
+	if (!bind_as_ptr)
 		return NULL;
+	bind_as = *bind_as_ptr; // copy because name2address points to a static
 
 	int sd = socket (family, SOCK_STREAM, 0);
 	if (sd == INVALID_SOCKET)
@@ -1020,12 +1048,27 @@ const char *EventMachine_t::ConnectToServer (const char *server, int port)
 	// Disable slow-start (Nagle algorithm).
 	int one = 1;
 	setsockopt (sd, IPPROTO_TCP, TCP_NODELAY, (char*) &one, sizeof(one));
+	// Set reuseaddr to improve performance on restarts
+	setsockopt (sd, SOL_SOCKET, SO_REUSEADDR, (char*) &one, sizeof(one));
+
+	if (bind_addr) {
+		int bind_to_size, bind_to_family;
+		struct sockaddr *bind_to = name2address (bind_addr, bind_port, &bind_to_family, &bind_to_size);
+		if (!bind_to) {
+			closesocket (sd);
+			throw std::runtime_error ("bad bind address");
+		}
+		if (bind (sd, bind_to, bind_to_size) < 0) {
+			closesocket (sd);
+			throw std::runtime_error ("couldn't bind to address");
+		}
+	}
 
 	const char *out = NULL;
 
 	#ifdef OS_UNIX
 	//if (connect (sd, (sockaddr*)&pin, sizeof pin) == 0) {
-	if (connect (sd, bind_as, bind_size) == 0) {
+	if (connect (sd, &bind_as, bind_size) == 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
@@ -1098,7 +1141,7 @@ const char *EventMachine_t::ConnectToServer (const char *server, int port)
 
 	#ifdef OS_WIN32
 	//if (connect (sd, (sockaddr*)&pin, sizeof pin) == 0) {
-	if (connect (sd, bind_as, bind_size) == 0) {
+	if (connect (sd, &bind_as, bind_size) == 0) {
 		// This is a connect success, which Windows appears
 		// never to give when the socket is nonblocking,
 		// even if the connection is intramachine or to
@@ -1236,6 +1279,8 @@ const char *EventMachine_t::AttachFD (int fd, bool notify_readable, bool notify_
 		}
 	}
 
+	SetSocketNonblocking(fd);
+
 	ConnectionDescriptor *cd = new ConnectionDescriptor (fd, this);
 	if (!cd)
 		throw std::runtime_error ("no connection allocated");
@@ -1929,9 +1974,290 @@ EventMachine_t::GetConnectionCount
 
 int EventMachine_t::GetConnectionCount ()
 {
-	return Descriptors.size();
+	return Descriptors.size() + NewDescriptors.size();
 }
 
 
+/************************
+EventMachine_t::WatchPid
+************************/
+
+const char *EventMachine_t::WatchPid (int pid)
+{
+	#ifdef HAVE_KQUEUE
+	if (!bKqueue)
+		throw std::runtime_error("must enable kqueue");
+
+	struct kevent event;
+	int kqres;
+
+	EV_SET(&event, pid, EVFILT_PROC, EV_ADD, NOTE_EXIT | NOTE_FORK, 0, 0);
+
+	// Attempt to register the event
+	kqres = kevent(kqfd, &event, 1, NULL, 0, NULL);
+	if (kqres == -1) {
+		char errbuf[200];
+		sprintf(errbuf, "failed to register file watch descriptor with kqueue: %s", strerror(errno));
+		throw std::runtime_error(errbuf);
+	}
+	#endif
+
+	#ifdef HAVE_KQUEUE
+	Bindable_t* b = new Bindable_t();
+	Pids.insert(make_pair (pid, b));
+
+	return b->GetBinding().c_str();
+	#endif
+
+	throw std::runtime_error("no pid watching support on this system");
+}
+
+/**************************
+EventMachine_t::UnwatchPid
+**************************/
+
+void EventMachine_t::UnwatchPid (int pid)
+{
+	Bindable_t *b = Pids[pid];
+	assert(b);
+	Pids.erase(pid);
+
+	#ifdef HAVE_KQUEUE
+	struct kevent k;
+
+	EV_SET(&k, pid, EVFILT_PROC, EV_DELETE, 0, 0, 0);
+	int t = kevent (kqfd, &k, 1, NULL, 0, NULL);
+	// t==-1 if the process already exited; ignore this for now
+	#endif
+
+	if (EventCallback)
+		(*EventCallback)(b->GetBinding().c_str(), EM_CONNECTION_UNBOUND, NULL, 0);
+
+	delete b;
+}
+
+void EventMachine_t::UnwatchPid (const char *sig)
+{
+	for(map<int, Bindable_t*>::iterator i=Pids.begin(); i != Pids.end(); i++)
+	{
+		if (strncmp(i->second->GetBinding().c_str(), sig, strlen(sig)) == 0) {
+			UnwatchPid (i->first);
+			return;
+		}
+	}
+
+	throw std::runtime_error("attempted to remove invalid pid signature");
+}
+
+
+/*************************
+EventMachine_t::WatchFile
+*************************/
+
+const char *EventMachine_t::WatchFile (const char *fpath)
+{
+	struct stat sb;
+	int sres;
+	int wd = -1;
+
+	sres = stat(fpath, &sb);
+
+	if (sres == -1) {
+		char errbuf[300];
+		sprintf(errbuf, "error registering file %s for watching: %s", fpath, strerror(errno));
+		throw std::runtime_error(errbuf);
+	}
+
+	#ifdef HAVE_INOTIFY
+	if (!inotify) {
+		inotify = new InotifyDescriptor(this);
+		assert (inotify);
+		Add(inotify);
+	}
+
+	wd = inotify_add_watch(inotify->GetSocket(), fpath, IN_MODIFY | IN_DELETE_SELF | IN_MOVE_SELF);
+	if (wd == -1) {
+		char errbuf[300];
+		sprintf(errbuf, "failed to open file %s for registering with inotify: %s", fpath, strerror(errno));
+		throw std::runtime_error(errbuf);
+	}
+	#endif
+
+	#ifdef HAVE_KQUEUE
+	if (!bKqueue)
+		throw std::runtime_error("must enable kqueue");
+
+	// With kqueue we have to open the file first and use the resulting fd to register for events
+	wd = open(fpath, O_RDONLY);
+	if (wd == -1) {
+		char errbuf[300];
+		sprintf(errbuf, "failed to open file %s for registering with kqueue: %s", fpath, strerror(errno));
+		throw std::runtime_error(errbuf);
+	}
+	_RegisterKqueueFileEvent(wd);
+	#endif
+
+	if (wd != -1) {
+		Bindable_t* b = new Bindable_t();
+		Files.insert(make_pair (wd, b));
+
+		return b->GetBinding().c_str();
+	}
+
+	throw std::runtime_error("no file watching support on this system"); // is this the right thing to do?
+}
+
+
+/***************************
+EventMachine_t::UnwatchFile
+***************************/
+
+void EventMachine_t::UnwatchFile (int wd)
+{
+	Bindable_t *b = Files[wd];
+	assert(b);
+	Files.erase(wd);
+
+	#ifdef HAVE_INOTIFY
+	inotify_rm_watch(inotify->GetSocket(), wd);
+	#elif HAVE_KQUEUE
+	// With kqueue, closing the monitored fd automatically clears all registered events for it
+	close(wd);
+	#endif
+
+	if (EventCallback)
+		(*EventCallback)(b->GetBinding().c_str(), EM_CONNECTION_UNBOUND, NULL, 0);
+
+	delete b;
+}
+
+void EventMachine_t::UnwatchFile (const char *sig)
+{
+	for(map<int, Bindable_t*>::iterator i=Files.begin(); i != Files.end(); i++)
+	{
+		if (strncmp(i->second->GetBinding().c_str(), sig, strlen(sig)) == 0) {
+			UnwatchFile (i->first);
+			return;
+		}
+	}
+	throw std::runtime_error("attempted to remove invalid watch signature");
+}
+
+
+/***********************************
+EventMachine_t::_ReadInotify_Events
+************************************/
+
+void EventMachine_t::_ReadInotifyEvents()
+{
+	#ifdef HAVE_INOTIFY
+	struct inotify_event event;
+
+	assert(EventCallback);
+
+	while (read(inotify->GetSocket(), &event, INOTIFY_EVENT_SIZE) > 0) {
+		assert(event.len == 0);
+		if (event.mask & IN_MODIFY)
+			(*EventCallback)(Files [event.wd]->GetBinding().c_str(), EM_CONNECTION_READ, "modified", 8);
+		if (event.mask & IN_MOVE_SELF)
+			(*EventCallback)(Files [event.wd]->GetBinding().c_str(), EM_CONNECTION_READ, "moved", 5);
+		if (event.mask & IN_DELETE_SELF) {
+			(*EventCallback)(Files [event.wd]->GetBinding().c_str(), EM_CONNECTION_READ, "deleted", 7);
+			UnwatchFile (event.wd);
+		}
+	}
+	#endif
+}
+
+
+/*************************************
+EventMachine_t::_HandleKqueuePidEvent
+*************************************/
+
+#ifdef HAVE_KQUEUE
+void EventMachine_t::_HandleKqueuePidEvent(struct kevent *event)
+{
+	assert(EventCallback);
+
+	if (event->fflags & NOTE_FORK)
+		(*EventCallback)(Pids [(int) event->ident]->GetBinding().c_str(), EM_CONNECTION_READ, "fork", 4);
+	if (event->fflags & NOTE_EXIT) {
+		(*EventCallback)(Pids [(int) event->ident]->GetBinding().c_str(), EM_CONNECTION_READ, "exit", 4);
+		// stop watching the pid if it died
+		UnwatchPid (event->ident);
+	}
+}
+#endif
+
+
+/**************************************
+EventMachine_t::_HandleKqueueFileEvent
+***************************************/
+
+#ifdef HAVE_KQUEUE
+void EventMachine_t::_HandleKqueueFileEvent(struct kevent *event)
+{
+	assert(EventCallback);
+
+	if (event->fflags & NOTE_WRITE)
+		(*EventCallback)(Files [(int) event->ident]->GetBinding().c_str(), EM_CONNECTION_READ, "modified", 8);
+	if (event->fflags & NOTE_RENAME)
+		(*EventCallback)(Files [(int) event->ident]->GetBinding().c_str(), EM_CONNECTION_READ, "moved", 5);
+	if (event->fflags & NOTE_DELETE) {
+		(*EventCallback)(Files [(int) event->ident]->GetBinding().c_str(), EM_CONNECTION_READ, "deleted", 7);
+		UnwatchFile (event->ident);
+	}
+}
+#endif
+
+
+/****************************************
+EventMachine_t::_RegisterKqueueFileEvent
+*****************************************/
+
+#ifdef HAVE_KQUEUE
+void EventMachine_t::_RegisterKqueueFileEvent(int fd)
+{
+	struct kevent newevent;
+	int kqres;
+
+	// Setup the event with our fd and proper flags
+	EV_SET(&newevent, fd, EVFILT_VNODE, EV_ADD | EV_CLEAR, NOTE_DELETE | NOTE_RENAME | NOTE_WRITE, 0, 0);
+
+	// Attempt to register the event
+	kqres = kevent(kqfd, &newevent, 1, NULL, 0, NULL);
+	if (kqres == -1) {
+		char errbuf[200];
+		sprintf(errbuf, "failed to register file watch descriptor with kqueue: %s", strerror(errno));
+		close(fd);
+		throw std::runtime_error(errbuf);
+	}
+}
+#endif
+
+
+/************************************
+EventMachine_t::GetHeartbeatInterval
+*************************************/
+
+float EventMachine_t::GetHeartbeatInterval()
+{
+	return ((float)HeartbeatInterval / 1000000);
+}
+
+
+/************************************
+EventMachine_t::SetHeartbeatInterval
+*************************************/
+
+int EventMachine_t::SetHeartbeatInterval(float interval)
+{
+	int iv = (int)(interval * 1000000);
+	if (iv > 0) {
+		HeartbeatInterval = iv;
+		return 1;
+	}
+	return 0;
+}
 //#endif // OS_UNIX
 

data/ext/em.h

@@ -57,9 +57,10 @@ typedef long long Int64;
 typedef __int64 Int64;
 #endif
 
-extern time_t gCurrentLoopTime;
+extern Int64 gCurrentLoopTime;
 
 class EventableDescriptor;
+class InotifyDescriptor;
 
 
 /********************
@@ -80,9 +81,8 @@ class EventMachine_t
 		void ScheduleHalt();
 		void SignalLoopBreaker();
 		const char *InstallOneshotTimer (int);
-		const char *ConnectToServer (const char *, int);
+		const char *ConnectToServer (const char *, int, const char *, int);
 		const char *ConnectToUnixServer (const char *);
-		const char *AttachFD (int, bool, bool);
 
 		const char *CreateTcpServer (const char *, int);
 		const char *OpenDatagramSocket (const char *, int);
@@ -94,7 +94,10 @@ class EventMachine_t
 
 		void Add (EventableDescriptor*);
 		void Modify (EventableDescriptor*);
+
+		const char *AttachFD (int, bool, bool);
 		int DetachFD (EventableDescriptor*);
+
 		void ArmKqueueWriter (EventableDescriptor*);
 		void ArmKqueueReader (EventableDescriptor*);
 
@@ -106,15 +109,37 @@ class EventMachine_t
 		int SubprocessExitStatus;
 
 		int GetConnectionCount();
+		float GetHeartbeatInterval();
+		int SetHeartbeatInterval(float);
+
+		const char *WatchFile (const char*);
+		void UnwatchFile (int);
+		void UnwatchFile (const char*);
+
+		#ifdef HAVE_KQUEUE
+		void _HandleKqueueFileEvent (struct kevent*);
+		void _RegisterKqueueFileEvent(int);
+		#endif
+
+		const char *WatchPid (int);
+		void UnwatchPid (int);
+		void UnwatchPid (const char *);
+
+		#ifdef HAVE_KQUEUE
+		void _HandleKqueuePidEvent (struct kevent*);
+		#endif
 
 		// Temporary:
 		void _UseEpoll();
 		void _UseKqueue();
 
+		bool UsingKqueue() { return bKqueue; }
+		bool UsingEpoll() { return bEpoll; }
 
 	private:
 		bool _RunOnce();
 		bool _RunTimers();
+		void _UpdateTime();
 		void _AddNewDescriptors();
 		void _ModifyDescriptors();
 		void _InitializeLoopBreaker();
@@ -127,23 +152,27 @@ class EventMachine_t
 
 	public:
 		void _ReadLoopBreaker();
+		void _ReadInotifyEvents();
 
 	private:
 		enum {
-			HeartbeatInterval = 2,
-			MaxEpollDescriptors = 64*1024
+			MaxEpollDescriptors = 64*1024,
+			MaxEvents = 4096
 		};
+		int HeartbeatInterval;
 		void (*EventCallback)(const char*, int, const char*, int);
 
 		class Timer_t: public Bindable_t {
 		};
 
 		multimap<Int64, Timer_t> Timers;
+		map<int, Bindable_t*> Files;
+		map<int, Bindable_t*> Pids;
 		vector<EventableDescriptor*> Descriptors;
 		vector<EventableDescriptor*> NewDescriptors;
 		set<EventableDescriptor*> ModifiedDescriptors;
 
-		time_t NextHeartbeatTime;
+		Int64 NextHeartbeatTime;
 
 		int LoopBreakerReader;
 		int LoopBreakerWriter;
@@ -156,9 +185,17 @@ class EventMachine_t
 	private:
 		bool bEpoll;
 		int epfd; // Epoll file-descriptor
+		#ifdef HAVE_EPOLL
+		struct epoll_event epoll_events [MaxEvents];
+		#endif
 
 		bool bKqueue;
 		int kqfd; // Kqueue file-descriptor
+		#ifdef HAVE_KQUEUE
+		struct kevent Karray [MaxEvents];
+		#endif
+
+		InotifyDescriptor *inotify; // pollable descriptor for our inotify instance
 };