Use file names to store child watches (instead of full paths)

Author: sungshik

src/main/java/engineering/swat/watch/WatchEvent.java

@@ -68,14 +68,16 @@ public enum Kind {
     private final Path rootPath;
     private final Path relativePath;
 
+    private static final Path EMPTY_PATH = Path.of("");
+
     public WatchEvent(Kind kind, Path rootPath) {
         this(kind, rootPath, null);
     }
 
     public WatchEvent(Kind kind, Path rootPath, @Nullable Path relativePath) {
         this.kind = kind;
         this.rootPath = rootPath;
-        this.relativePath = relativePath == null ? Path.of("") : relativePath;
+        this.relativePath = relativePath == null ? EMPTY_PATH : relativePath;
     }
 
     public Kind getKind() {
@@ -112,7 +114,11 @@ public Path calculateFullPath() {
      * efficient than, {@code calculateFullPath().getFileName()}.
      */
     public @Nullable Path getFileName() {
-        return relativePath.getParent() == null ? rootPath.getFileName() : relativePath.getFileName();
+        var fileName = relativePath.getFileName();
+        if (fileName == null || fileName.equals(EMPTY_PATH)) {
+            fileName = rootPath.getFileName();
+        }
+        return fileName;
     }
 
     @Override

src/main/java/engineering/swat/watch/impl/jdk/JDKFileTreeWatch.java

@@ -33,6 +33,7 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.Executor;
 import java.util.function.BiConsumer;
+import java.util.function.Consumer;
 import java.util.function.Function;
 
 import org.apache.logging.log4j.LogManager;
@@ -107,33 +108,42 @@ private class ChildWatchesUpdater implements BiConsumer<EventHandlingWatch, Watc
         public void accept(EventHandlingWatch watch, WatchEvent event) {
             switch (event.getKind()) {
                 case OVERFLOW: acceptOverflow(); break;
-                case CREATED: acceptCreated(event.calculateFullPath()); break;
-                case DELETED: acceptDeleted(event.calculateFullPath()); break;
+                case CREATED: getFileNameAndThen(event, this::acceptCreated); break;
+                case DELETED: getFileNameAndThen(event, this::acceptDeleted); break;
                 case MODIFIED: break;
             }
         }
 
+        private void getFileNameAndThen(WatchEvent event, Consumer<Path> consumer) {
+            var child = event.getFileName();
+            if (child != null) {
+                consumer.accept(child);
+            } else {
+                logger.error("Could not get file name of event: {}", event);
+            }
+        }
+
         private void acceptOverflow() {
             for (var childWatch : childWatches.values()) {
                 reportOverflowTo(childWatch);
             }
         }
 
-        private void acceptCreated(Path fullPath) {
-            if (Files.isDirectory(fullPath)) {
-                var childWatch = openChildWatch(fullPath);
+        private void acceptCreated(Path child) {
+            if (Files.isDirectory(path.resolve(child))) {
+                var childWatch = openChildWatch(child);
                 // Events in the newly created directory might have been missed
                 // between its creation and setting up its watch. So, generate
                 // an `OVERFLOW` event for the watch.
                 reportOverflowTo(childWatch);
             }
         }
 
-        private void acceptDeleted(Path fullPath) {
+        private void acceptDeleted(Path child) {
             try {
-                closeChildWatch(fullPath);
+                closeChildWatch(child);
             } catch (IOException e) {
-                logger.error("Could not close (nested) file tree watch for: {} ({})", fullPath, e);
+                logger.error("Could not close (nested) file tree watch for: {} ({})", path.resolve(child), e);
             }
         }
 
@@ -145,9 +155,10 @@ private void reportOverflowTo(JDKFileTreeWatch childWatch) {
     }
 
     private JDKFileTreeWatch openChildWatch(Path child) {
-        Function<Path, JDKFileTreeWatch> newChildWatch = p -> new JDKFileTreeWatch(
-            rootPath, rootPath.relativize(child), exec, eventHandler);
+        assert !child.isAbsolute();
 
+        Function<Path, JDKFileTreeWatch> newChildWatch = p -> new JDKFileTreeWatch(
+            rootPath, relativePathParent.resolve(child), exec, eventHandler);
         var childWatch = childWatches.computeIfAbsent(child, newChildWatch);
         try {
             childWatch.startIfFirstTime();
@@ -158,6 +169,8 @@ private JDKFileTreeWatch openChildWatch(Path child) {
     }
 
     private void closeChildWatch(Path child) throws IOException {
+        assert !child.isAbsolute();
+
         var childWatch = childWatches.remove(child);
         if (childWatch != null) {
             childWatch.close();
@@ -212,7 +225,14 @@ public synchronized void close() throws IOException {
     protected synchronized void start() throws IOException {
         internal.open();
         try (var children = Files.find(path, 1, (p, attrs) -> p != path && attrs.isDirectory())) {
-            children.forEach(this::openChildWatch);
+            children.forEach(p -> {
+                var child = p.getFileName();
+                if (child != null) {
+                    openChildWatch(child);
+                } else {
+                    logger.error("File tree watch (for: {}) could not open a child watch for: {}", path, p);
+                }
+            });
         } catch (IOException e) {
             logger.error("File tree watch (for: {}) could not iterate over its children ({})", path, e);
         }