From 5246593432fa559a1bd5526a26e477e400d63dcd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=B6nke=20Ludwig?= <sludwig@rejectedsoftware.com>
Date: Mon, 20 Nov 2017 23:59:52 +0100
Subject: [PATCH] Fix handling recursive inotify based directory watchers.

---
 source/eventcore/drivers/posix/watchers.d | 61 +++++++++++++++++++----
 1 file changed, 51 insertions(+), 10 deletions(-)

diff --git a/source/eventcore/drivers/posix/watchers.d b/source/eventcore/drivers/posix/watchers.d
index 6dddaf1..ad6c777 100644
--- a/source/eventcore/drivers/posix/watchers.d
+++ b/source/eventcore/drivers/posix/watchers.d
@@ -15,25 +15,42 @@ final class InotifyEventDriverWatchers(Events : EventDriverEvents) : EventDriver
 	private {
 		alias Loop = typeof(Events.init.loop);
 		Loop m_loop;
-		string[int][WatcherID] m_watches; // TODO: use a @nogc (allocator based) map
+
+		struct WatchState {
+			string[int] watcherPaths;
+			string basePath;
+			bool recursive;
+		}
+
+		WatchState[WatcherID] m_watches; // TODO: use a @nogc (allocator based) map
 	}
 
 	this(Events events) { m_loop = events.loop; }
 
 	final override WatcherID watchDirectory(string path, bool recursive, FileChangesCallback callback)
 	{
+		import std.path : buildPath, pathSplitter;
+		import std.range : drop;
+		import std.range.primitives : walkLength;
+
 		enum IN_NONBLOCK = 0x800; // value in core.sys.linux.sys.inotify is incorrect
 		auto handle = () @trusted { return inotify_init1(IN_NONBLOCK); } ();
 		if (handle == -1) return WatcherID.invalid;
 
 		auto ret = WatcherID(handle);
 
-		addWatch(ret, path);
+		m_watches[ret] = WatchState(null, path, recursive);
+
+		addWatch(ret, path, ".");
 		if (recursive) {
 			try {
+				auto base_segements = path.pathSplitter.walkLength;
 				if (path.isDir) () @trusted {
-					foreach (de; path.dirEntries(SpanMode.shallow))
-						if (de.isDir) addWatch(ret, de.name);
+					foreach (de; path.dirEntries(SpanMode.depth))
+						if (de.isDir) {
+							auto subdir = de.name.pathSplitter.drop(base_segements).buildPath;
+							addWatch(ret, path, subdir);
+						}
 				} ();
 			} catch (Exception e) {
 				// TODO: decide if this should be ignored or if the error should be forwarded
@@ -78,6 +95,7 @@ final class InotifyEventDriverWatchers(Events : EventDriverEvents) : EventDriver
 
 	private void processEvents(WatcherID id)
 	{
+		import std.path : buildPath, dirName;
 		import core.stdc.stdio : FILENAME_MAX;
 		import core.stdc.string : strlen;
 
@@ -89,9 +107,16 @@ final class InotifyEventDriverWatchers(Events : EventDriverEvents) : EventDriver
 				break;
 			assert(ret <= buf.length);
 
+			auto w = m_watches[id];
+
 			auto rem = buf[0 .. ret];
 			while (rem.length > 0) {
 				auto ev = () @trusted { return cast(inotify_event*)rem.ptr; } ();
+				rem = rem[inotify_event.sizeof + ev.len .. $];
+
+				// is the watch already deleted?
+				if (ev.mask & IN_IGNORED) continue;
+
 				FileChange ch;
 				if (ev.mask & (IN_CREATE|IN_MOVED_TO))
 					ch.kind = FileChangeKind.added;
@@ -100,28 +125,44 @@ final class InotifyEventDriverWatchers(Events : EventDriverEvents) : EventDriver
 				else if (ev.mask & IN_MODIFY)
 					ch.kind = FileChangeKind.modified;
 
+				if (ev.mask & IN_DELETE_SELF) {
+					() @trusted { inotify_rm_watch(cast(int)id, ev.wd); } ();
+					w.watcherPaths.remove(ev.wd);
+					continue;
+				} else if (ev.mask & IN_MOVE_SELF) {
+					// NOTE: the should have been updated by a previous IN_MOVED_TO
+					continue;
+				}
+
 				auto name = () @trusted { return ev.name.ptr[0 .. strlen(ev.name.ptr)]; } ();
-				ch.directory = m_watches[id][ev.wd];
+				auto subdir = w.watcherPaths[ev.wd];
+
+				if (w.recursive && ev.mask & (IN_CREATE|IN_MOVED_TO) && ev.mask & IN_ISDIR) {
+					addWatch(id, w.basePath, subdir == "." ? name.idup : buildPath(subdir, name));
+				}
+
+				ch.baseDirectory = m_watches[id].basePath;
+				ch.directory = subdir;
 				ch.isDirectory = (ev.mask & IN_ISDIR) != 0;
 				ch.name = name;
 				addRef(id); // assure that the id doesn't get invalidated until after the callback
 				auto cb = m_loop.m_fds[id].watcher.callback;
 				cb(id, ch);
 				if (!releaseRef(id)) return;
-
-				rem = rem[inotify_event.sizeof + ev.len .. $];
 			}
 		}
 	}
 
-	private bool addWatch(WatcherID handle, string path)
+	private bool addWatch(WatcherID handle, string base_path, string path)
 	{
+		import std.path : buildPath;
 		import std.string : toStringz;
+
 		enum EVENTS = IN_CREATE | IN_DELETE | IN_DELETE_SELF | IN_MODIFY |
 			IN_MOVE_SELF | IN_MOVED_FROM | IN_MOVED_TO;
-		immutable wd = () @trusted { return inotify_add_watch(cast(int)handle, path.toStringz, EVENTS); } ();
+		immutable wd = () @trusted { return inotify_add_watch(cast(int)handle, buildPath(base_path, path).toStringz, EVENTS); } ();
 		if (wd == -1) return false;
-		m_watches[handle][wd] = path;
+		m_watches[handle].watcherPaths[wd] = path;
 		return true;
 	}
 }