Class PathWatcher

  • All Implemented Interfaces:
    java.lang.Runnable, LifeCycle

    public class PathWatcher
    extends AbstractLifeCycle
    implements java.lang.Runnable
    Watch a Path (and sub directories) for Path changes.

    Suitable replacement for the old Scanner implementation.

    Allows for configured Excludes and Includes using FileSystem.getPathMatcher(String) syntax.

    Reports activity via registered PathWatcher.Listeners

    • Constructor Detail

      • PathWatcher

        public PathWatcher()
        Construct new PathWatcher
    • Method Detail

      • cast

        protected static <T> java.nio.file.WatchEvent<T> cast​(java.nio.file.WatchEvent<?> event)
      • watch

        public void watch​(java.nio.file.Path file)
        Request watch on a the given path (either file or dir) using all Config defaults. In the case of a dir, the default is not to recurse into subdirs for watching.
        Parameters:
        file - the path to watch
      • watch

        public void watch​(PathWatcher.Config config)
        Request watch on a path with custom Config provided.
        Parameters:
        config - the configuration to watch
      • addListener

        public void addListener​(java.util.EventListener listener)
        Add a listener for changes the watcher notices.
        Parameters:
        listener - change listener
      • doStart

        protected void doStart()
                        throws java.lang.Exception
        Description copied from class: AbstractLifeCycle
        Method to override to start the lifecycle
        Overrides:
        doStart in class AbstractLifeCycle
        Throws:
        AbstractLifeCycle.StopException - If thrown, the lifecycle will immediately be stopped.
        java.lang.Exception - If there was a problem starting. Will cause a transition to FAILED state
      • doStop

        protected void doStop()
                       throws java.lang.Exception
        Description copied from class: AbstractLifeCycle
        Method to override to stop the lifecycle
        Overrides:
        doStop in class AbstractLifeCycle
        Throws:
        java.lang.Exception - If there was a problem stopping. Will cause a transition to FAILED state
      • reset

        public void reset()
        Remove all current configs and listeners.
      • isNotifiable

        protected boolean isNotifiable()
        Check to see if the watcher is in a state where it should generate watch events to the listeners. Used to determine if watcher should generate events for existing files and dirs on startup.
        Returns:
        true if the watcher should generate events to the listeners.
      • getListeners

        public java.util.Iterator<java.util.EventListener> getListeners()
        Get an iterator over the listeners.
        Returns:
        iterator over the listeners.
      • getUpdateQuietTimeMillis

        public long getUpdateQuietTimeMillis()
        Change the quiet time.
        Returns:
        the quiet time in millis
      • register

        protected void register​(java.nio.file.Path path,
                                PathWatcher.Config config)
                         throws java.io.IOException
        Throws:
        java.io.IOException
      • removeListener

        public boolean removeListener​(PathWatcher.Listener listener)
        Delete a listener
        Parameters:
        listener - the listener to remove
        Returns:
        true if the listener existed and was removed
      • run

        public void run()
        Forever loop. Wait for the WatchService to report some filesystem events for the watched paths. When an event for a path first occurs, it is subjected to a quiet time. Subsequent events that arrive for the same path during this quiet time are accumulated and the timer reset. Only when the quiet time has expired are the accumulated events sent. MODIFY events are handled slightly differently - multiple MODIFY events arriving within a quiet time are coalesced into a single MODIFY event. Both the accumulation of events and coalescing of MODIFY events reduce the number and frequency of event reporting for "noisy" files (ie those that are undergoing rapid change).
        Specified by:
        run in interface java.lang.Runnable
        See Also:
        Runnable.run()
      • handleWatchEvent

        public void handleWatchEvent​(java.nio.file.Path path,
                                     PathWatcher.PathWatchEvent event)
        Add an event reported by the WatchService to list of pending events that will be sent after their quiet time has expired.
        Parameters:
        path - the path to add to the pending list
        event - the pending event
      • setNotifyExistingOnStart

        public void setNotifyExistingOnStart​(boolean notify)
        Whether or not to issue notifications for directories and files that already exist when the watcher starts.
        Parameters:
        notify - true if existing paths should be notified or not
      • isNotifyExistingOnStart

        public boolean isNotifyExistingOnStart()
      • setUpdateQuietTime

        public void setUpdateQuietTime​(long duration,
                                       java.util.concurrent.TimeUnit unit)
        Set the quiet time.
        Parameters:
        duration - the quiet time duration
        unit - the quite time unit