Rename in JDKBaseWatch: (a) start to open; (b) run to start

Author: sungshik

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

@@ -37,7 +37,6 @@
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
-import engineering.swat.watch.impl.jdk.JDKBaseWatch;
 import engineering.swat.watch.impl.jdk.JDKDirectoryWatch;
 import engineering.swat.watch.impl.jdk.JDKFileWatch;
 import engineering.swat.watch.impl.jdk.JDKRecursiveDirectoryWatch;
@@ -161,26 +160,26 @@ public ActiveWatch start() throws IOException {
         switch (scope) {
             case PATH_AND_CHILDREN: {
                 var result = new JDKDirectoryWatch(path, executor, eventHandler, false);
-                result.start();
+                result.open();
                 return result;
             }
             case PATH_AND_ALL_DESCENDANTS: {
                 try {
                     var result = new JDKDirectoryWatch(path, executor, eventHandler, true);
-                    result.start();
+                    result.open();
                     return result;
                 } catch (Throwable ex) {
                     // no native support, use the simulation
                     logger.debug("Not possible to register the native watcher, using fallback for {}", path);
                     logger.trace(ex);
                     var result = new JDKRecursiveDirectoryWatch(path, executor, eventHandler);
-                    result.start();
+                    result.open();
                     return result;
                 }
             }
             case PATH_ONLY: {
                 var result = new JDKFileWatch(path, executor, eventHandler);
-                result.start();
+                result.open();
                 return result;
             }
             default:

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

@@ -46,17 +46,17 @@ public abstract class JDKBaseWatch implements ActiveWatch {
     protected final Path path;
     protected final Executor exec;
     protected final Consumer<WatchEvent> eventHandler;
-    protected final AtomicBoolean running = new AtomicBoolean();
+    protected final AtomicBoolean started = new AtomicBoolean();
 
     protected JDKBaseWatch(Path path, Executor exec, Consumer<WatchEvent> eventHandler) {
         this.path = path;
         this.exec = exec;
         this.eventHandler = eventHandler;
     }
 
-    public void start() throws IOException {
+    public void open() throws IOException {
         try {
-            if (!runIfFirstTime()) {
+            if (!startIfFirstTime()) {
                 throw new IllegalStateException("Could not restart already-started watch for: " + path);
             }
             logger.debug("Started watch for: {}", path);
@@ -66,23 +66,23 @@ public void start() throws IOException {
     }
 
     /**
-     * Runs this watch.
+     * Starts this watch.
      *
      * @throws IOException When an I/O exception of some sort has occurred
      * (e.g., a nested watch failed to start)
      */
-    protected abstract void run() throws IOException;
+    protected abstract void start() throws IOException;
 
     /**
-     * Runs this watch if it's the first time.
+     * Starts this watch if it's the first time.
      *
      * @return `true` iff it's the first time this method is called
      * @throws IOException When an I/O exception of some sort has occurred
      * (e.g., a nested watch failed to start)
      */
-    protected boolean runIfFirstTime() throws IOException {
-        if (running.compareAndSet(false, true)) {
-            run();
+    protected boolean startIfFirstTime() throws IOException {
+        if (started.compareAndSet(false, true)) {
+            start();
             return true;
         } else {
             return false;

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

@@ -82,7 +82,7 @@ public synchronized void close() throws IOException {
     }
 
     @Override
-    protected synchronized void run() throws IOException {
+    protected synchronized void start() throws IOException {
         assert bundledJDKWatcher == null;
         var key = new SubscriptionKey(path, nativeRecursive);
         bundledJDKWatcher = BUNDLED_JDK_WATCHERS.subscribe(key, this::handleChanges);

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

@@ -81,10 +81,10 @@ public synchronized void close() throws IOException {
     }
 
     @Override
-    protected synchronized void run() throws IOException {
+    protected synchronized void start() throws IOException {
         assert parentWatch == null;
         parentWatch = new JDKDirectoryWatch(parent, exec, this::filter);
-        parentWatch.start();
+        parentWatch.open();
         logger.debug("File watch (for: {}) is in reality a directory watch (for: {}) with a filter (for: {})", path, parent, fileName);
     }
 }

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

@@ -150,7 +150,7 @@ public FileVisitResult postVisitDirectory(Path subdir, IOException exc) throws I
         private void addNewDirectory(Path dir) throws IOException {
             var watch = activeWatches.computeIfAbsent(dir, d -> new JDKDirectoryWatch(d, exec, relocater(dir)));
             try {
-                if (!watch.runIfFirstTime()) {
+                if (!watch.startIfFirstTime()) {
                     logger.debug("We lost the race on starting a nested watch, that shouldn't be a problem, but it's a very busy, so we might have lost a few events in {}", dir);
                 }
             } catch (IOException ex) {
@@ -324,7 +324,7 @@ public void close() throws IOException {
     }
 
     @Override
-    protected void run() throws IOException {
+    protected void start() throws IOException {
         logger.debug("Running recursive watch for: {}", path);
         registerInitialWatches(path);
     }