eventmachine 0.12.6 → 0.12.8

data/ext/ed.h

@@ -67,27 +67,28 @@ class EventableDescriptor: public Bindable_t
 		virtual bool GetSubprocessPid (pid_t*) {return false;}
 
 		virtual void StartTls() {}
-		virtual void SetTlsParms (const char *privkey_filename, const char *certchain_filename) {}
+		virtual void SetTlsParms (const char *privkey_filename, const char *certchain_filename, bool verify_peer) {}
 
 		#ifdef WITH_SSL
 		virtual X509 *GetPeerCert() {return NULL;}
 		#endif
 
-		// Properties: return 0/1 to signify T/F, and handle the values
-		// through arguments.
-		virtual int GetCommInactivityTimeout (int *value) {return 0;}
-		virtual int SetCommInactivityTimeout (int *value) {return 0;}
+		virtual float GetCommInactivityTimeout() {return 0.0;}
+		virtual int SetCommInactivityTimeout (float value) {return 0;}
 
 		#ifdef HAVE_EPOLL
 		struct epoll_event *GetEpollEvent() { return &EpollEvent; }
 		#endif
 
+		virtual void StartProxy(const char*);
+		virtual void StopProxy();
+
 	private:
 		bool bCloseNow;
 		bool bCloseAfterWriting;
-		int MySocket;
 
 	protected:
+		int MySocket;
 		enum {
 			// 4 seconds is too short, most other libraries default to OS settings
 			// which in 2.6 kernel defaults to a 60 second connect timeout. 
@@ -96,16 +97,17 @@ class EventableDescriptor: public Bindable_t
 			//
 			// updating to 50 seconds, so we catch it before the OS does
 
-			PendingConnectTimeout = 50 // can easily be made an instance variable
+			// can easily be made an instance variable
+			PendingConnectTimeout = 50000000 // now in usec
 		};
 
 		void (*EventCallback)(const char*, int, const char*, int);
-    
-		time_t CreatedAt;
-		time_t LastRead;
-		time_t LastWritten;
+		void _GenericInboundDispatch(const char*, int);
+
+		Int64 CreatedAt;
 		bool bCallbackUnbind;
 		int UnbindReasonCode;
+		char *ProxyTarget;
 
 		#ifdef HAVE_EPOLL
 		struct epoll_event EpollEvent;
@@ -153,8 +155,8 @@ class ConnectionDescriptor: public EventableDescriptor
 
 		void SetConnectPending (bool f);
 
-		void SetNotifyReadable (bool readable) { bNotifyReadable = readable; }
-		void SetNotifyWritable (bool writable) { bNotifyWritable = writable; }
+		void SetNotifyReadable (bool);
+		void SetNotifyWritable (bool);
 
 		virtual void Read();
 		virtual void Write();
@@ -167,10 +169,12 @@ class ConnectionDescriptor: public EventableDescriptor
 		virtual int GetOutboundDataSize() {return OutboundDataSize;}
 
 		virtual void StartTls();
-		virtual void SetTlsParms (const char *privkey_filename, const char *certchain_filename);
+		virtual void SetTlsParms (const char *privkey_filename, const char *certchain_filename, bool verify_peer);
 
 		#ifdef WITH_SSL
 		virtual X509 *GetPeerCert();
+		virtual bool VerifySslPeer(const char*);
+		virtual void AcceptSslPeer();
 		#endif
 
 		void SetServerMode() {bIsServer = true;}
@@ -178,8 +182,8 @@ class ConnectionDescriptor: public EventableDescriptor
 		virtual bool GetPeername (struct sockaddr*);
 		virtual bool GetSockname (struct sockaddr*);
 
-		virtual int GetCommInactivityTimeout (int *value);
-		virtual int SetCommInactivityTimeout (int *value);
+		virtual float GetCommInactivityTimeout();
+		virtual int SetCommInactivityTimeout (float value);
 
 
 	protected:
@@ -208,10 +212,16 @@ class ConnectionDescriptor: public EventableDescriptor
 		std::string CertChainFilename;
 		std::string PrivateKeyFilename;
 		bool bHandshakeSignaled;
+		bool bSslVerifyPeer;
+		bool bSslPeerAccepted;
 		#endif
 		bool bIsServer;
 
-		time_t LastIo;
+		#ifdef HAVE_KQUEUE
+		bool bGotExtraKqueueEvent;
+		#endif
+
+		Int64 LastIo;
 		int InactivityTimeout;
 
 	private:
@@ -251,8 +261,8 @@ class DatagramDescriptor: public EventableDescriptor
 		virtual bool GetPeername (struct sockaddr*);
 		virtual bool GetSockname (struct sockaddr*);
 
-    virtual int GetCommInactivityTimeout (int *value);
-    virtual int SetCommInactivityTimeout (int *value);
+    virtual float GetCommInactivityTimeout();
+    virtual int SetCommInactivityTimeout (float value);
 
 		static int SendDatagram (const char*, const char*, int, const char*, int);
 
@@ -272,7 +282,7 @@ class DatagramDescriptor: public EventableDescriptor
 
 		struct sockaddr_in ReturnAddress;
 
-		time_t LastIo;
+		Int64 LastIo;
 		int InactivityTimeout;
 };
 
@@ -333,7 +343,7 @@ class PipeDescriptor: public EventableDescriptor
 
 	protected:
 		bool bReadAttemptedAfterClose;
-		time_t LastIo;
+		Int64 LastIo;
 		int InactivityTimeout;
 
 		deque<OutboundPage> OutboundPages;
@@ -366,7 +376,7 @@ class KeyboardDescriptor: public EventableDescriptor
 
 	protected:
 		bool bReadAttemptedAfterClose;
-		time_t LastIo;
+		Int64 LastIo;
 		int InactivityTimeout;
 
 	private:
@@ -374,6 +384,23 @@ class KeyboardDescriptor: public EventableDescriptor
 };
 
 
+/***********************
+class InotifyDescriptor
+************************/
+
+class InotifyDescriptor: public EventableDescriptor
+{
+	public:
+		InotifyDescriptor (EventMachine_t*);
+		virtual ~InotifyDescriptor();
+
+		void Read();
+		void Write();
+
+		virtual void Heartbeat() {}
+		virtual bool SelectForRead() {return true;}
+		virtual bool SelectForWrite() {return false;}
+};
 
 #endif // __EventableDescriptor__H_
 

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