Java 类org.apache.commons.io.monitor.FileAlterationObserver 实例源码

@Override
public synchronized void registerDirectory(final Path directory, final FileSystemListener listener) throws IOException {
    log.debug("Registering " + directory);

    final FileAlterationObserver observer = new FileAlterationObserver(directory.toFile(), this.fileNameFilter);
    try {
        // Force the registered directory to be read into memory before we start observing changes,
        // otherwise the first run will generate a 'create' event for each file and directory.
        observer.initialize();
    } catch (Exception e) {
        throw new IOException("Failed to initialize observer for " + directory, e);
    }
    observer.addListener(this);
    listeners.put(directory, listener);
    monitor.addObserver(observer);
}

/**
 * 只监控文件发送变化,如果是子目录的文件改变,则目录会变,由于没有过滤目录发生变化,则目录下的文件改变不会监控到
 * @param dir
 * @throws Exception 
 */
public void check1(String dir) throws Exception
{
    File directory = new File(dir);
    // 轮询间隔 5 秒
    long interval = TimeUnit.SECONDS.toMillis(5);
    // 创建一个文件观察器用于处理文件的格式
    IOFileFilter filter=FileFilterUtils.or(FileFilterUtils.suffixFileFilter(".class"),
            FileFilterUtils.suffixFileFilter(".jar"));
    FileAlterationObserver observer = new FileAlterationObserver(directory,filter);
    //设置文件变化监听器
    observer.addListener(new MyFileListener());
    FileAlterationMonitor monitor = new FileAlterationMonitor(interval);
    monitor.addObserver(observer);//文件观察
    monitor.start();
}

public void check2(String dir) throws Exception
    {
        File directory = new File(dir);
        // 轮询间隔 5 秒
        long interval = TimeUnit.SECONDS.toMillis(5);
        //后缀过滤器
        IOFileFilter filefilter=FileFilterUtils.or(FileFilterUtils.suffixFileFilter(".class"),
                FileFilterUtils.suffixFileFilter(".jar"));
        //子目录的后缀
        IOFileFilter subFilefilter=FileFilterUtils.or(FileFilterUtils.directoryFileFilter(),filefilter);
        //根目录和子目录变化
        IOFileFilter filter = FileFilterUtils.or(filefilter,subFilefilter);
        FileAlterationObserver observer = new FileAlterationObserver(directory,filter);
        //设置文件变化监听器
        observer.addListener(new MyFileListener());
        FileAlterationMonitor monitor = new FileAlterationMonitor(interval);
        monitor.addObserver(observer);//文件观察
        monitor.start();
//      monitor.addObserver(observer);//文件观察,如果在start后面加,则会触发所有文件创建
    }

/**
 * Creates and registers a file listener with the help of the specified build command.
 * 
 * @param command The build command.
 * 
 * @throws Exception If any exception occurs.
 */

private final void registerFileListener(final BuildCommand command) throws Exception {
    final DocsProject project = command.getProject();

    final FileAlterationObserver observer = new FileAlterationObserver(project.getDirectory());
    observer.addListener(new FileAlterationListenerAdaptor() {

        @Override
        public final void onDirectoryChange(final File directory) {
            rebuildIfNeeded(command, directory);
        }

        @Override
        public final void onFileChange(final File file) {
            rebuildIfNeeded(command, file);
        }

    });
    monitor.addObserver(observer);
    monitor.start();
}

public static void azkabanConfigFileMonitor(String[] args, Props props1) {
    try {
        props = props1;
        configFilePath = props.getString(AZKABAN_CONFIG_FILE_PATH);//配置文件路径
        long interval = props.getLong(AZKABAN_CONFIG_FILE_MONIITE_INTERVAL, 5000);//监听间隔
        String dirPath = System.getProperty("user.dir") + configFilePath;
        logger.error("azkabanConfigFileMonitor method, monitor path= " + dirPath);
        //构造观察类:主要提供要观察的文件或目录，当然还有详细信息的filter
        FileAlterationObserver observer = new FileAlterationObserver(new File(dirPath), new FileFilterImpl());
        //构造收听类
        FileListenerAdaptor listener = new FileListenerAdaptor(args);
        //为观察对象添加收听对象
        observer.addListener(listener);
        //配置Monitor，第一个参数单位是毫秒，是监听的间隔；第二个参数就是绑定我们之前的观察对象。
        FileAlterationMonitor fileMonitor = new FileAlterationMonitor(interval, new FileAlterationObserver[]{observer});
        //启动开始监听
        fileMonitor.start();
    } catch (Exception e) {
        logger.error("azkabanConfigFileMonitor method error", e);
    }

}

public void start() {
    String gamePath = Configuration.get().applicationConfiguration().get().getGamePath();

    File folder = new File(gamePath + "logs");
    this.fileHandler = new MessageFileHandler(gamePath + "logs/Client.txt");
    FileAlterationObserver observer = new FileAlterationObserver(folder);
    monitor = new FileAlterationMonitor(POLLING_INTERVAL);
    FileAlterationListener listener = new FileAlterationListenerAdaptor() {
        @Override
        public void onFileChange(File file) {
            fileHandler.parse();
        }
    };

    observer.addListener(listener);
    monitor.addObserver(observer);
    try {
        monitor.start();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public synchronized void activate() throws MojoExecutionException
{   
  IOFileFilter logFilter = FileFilterUtils.and(
          FileFilterUtils.fileFileFilter(),
          FileFilterUtils.nameFileFilter(engineLog.getName()));
  FileAlterationObserver fileObserver = new FileAlterationObserver(engineLog.getParent(), logFilter);
  fileObserver.addListener(new LogModificationListener());
  monitor = new FileAlterationMonitor(100);
  monitor.addObserver(fileObserver);
  try
  {
    monitor.start();
  }
  catch (Exception ex)
  {
    throw new MojoExecutionException("Failed to activate deploy log forwarder", ex);
  }
}

public ReloadableConfig() {
    new Thread(()->{
        long interval = TimeUnit.SECONDS.toMillis(30);
        try {
            ClassPathResource resource = new ClassPathResource(getClassPathFilePath());
            File file = resource.getFile();
            FileAlterationObserver observer = new FileAlterationObserver(file.getParentFile() , new NameFileFilter(file.getName()));
            observer.addListener(this);
            FileAlterationMonitor monitor = new FileAlterationMonitor(interval , observer);
            LOGGER.debug("监听文件:{}" , file.getPath());
            monitor.start();
        } catch (Exception e) {
            LOGGER.error("ClassPathFilePath:{}" , getClassPathFilePath());
            LOGGER.error("" , e);
        }
    }).start();
}

/**
 * Add {@link org.apache.commons.io.monitor.FileAlterationMonitor}s for the given
 * root directory and any nested subdirectories under the root directory to the given
 * {@link org.apache.commons.io.monitor.FileAlterationMonitor}.
 *
 * @param monitor a {@link org.apache.commons.io.monitor.FileAlterationMonitor}
 * @param listener a {@link org.apache.commons.io.monitor.FileAlterationListener}
 * @param rootDir root directory
 */
public static void addFileAlterationObserver(FileAlterationMonitor monitor, FileAlterationListener listener,
    File rootDir) {
  // Add a observer for the current root directory
  FileAlterationObserver observer = new FileAlterationObserver(rootDir);
  observer.addListener(listener);
  monitor.addObserver(observer);

  // List subdirectories under the current root directory
  File[] subDirs = rootDir.listFiles(new FileFilter() {
    @Override
    public boolean accept(File file) {
      return file.isDirectory();
    }
  });

  if (subDirs == null || subDirs.length == 0) {
    return;
  }

  // Recursively add a observer for each subdirectory
  for (File subDir : subDirs) {
    addFileAlterationObserver(monitor, listener, subDir);
  }
}

@Override
public void onStart( final FileAlterationObserver observer ) {

    if( this.alreadyStarted.getAndSet( true ))
        return;

    this.logger.fine("Initial provisioning of templates...");
    final Collection<File> templateFiles = FileUtils.listFiles(
            this.templateDir,

            // Find readable template files.
            FileFilterUtils.and(
                    FileFilterUtils.suffixFileFilter( ".tpl" ),
                    CanReadFileFilter.CAN_READ),

            // Directory filter: go through the root template directory and its direct children.
            new TemplateDirectoryFileFilter( this.templateDir ));

    process( templateFiles );
}

@Override
@SuppressWarnings("PMD.EmptyCatchBlock")
public synchronized void unregisterDirectoryListener(File directory, DirectoryListener directoryListener) {
    SFMF4JFileAlterationListener listener = new SFMF4JFileAlterationListener(directoryListener);
    final FileAlterationObserver observer = directoryObservers.get(directory);
    if (observer != null) {
        boolean shouldDestroy = false;
        observer.removeListener(listener);
        if (!observer.getListeners().iterator().hasNext()) {
            shouldDestroy = true;
            directoryObservers.remove(directory);
            fileMonitor.removeObserver(observer);
        }
        if (shouldDestroy) {
            try {
                observer.destroy();
            } catch (Exception ex) {
                //trap
            }
        }
    }
}

public static void watch(Config cfg) throws Exception {
    logger.info("Starting asset watcher...");
    long interval = 100;
    PipelineEnvironment pe = new PipelineEnvironment(cfg);
    AssetFileObserver fileObserver = new AssetFileObserver(pe);
    FileAlterationObserver jsObserver = fileObserver.observeJs();
    FileAlterationObserver cssObserver = fileObserver.observeCss();
    FileAlterationObserver imageObserver = fileObserver.observeImage();
    FileAlterationObserver templateObserver = fileObserver.observeTemplate();
    FileAlterationObserver serverTemplateObserver = fileObserver.observeServerTemplate();
    FileAlterationObserver staticAssetObserver = fileObserver.observeStaticAsset();
    FileAlterationMonitor monitor = new FileAlterationMonitor(interval);
    monitor.addObserver(jsObserver);
    monitor.addObserver(cssObserver);
    monitor.addObserver(imageObserver);
    monitor.addObserver(templateObserver);
    monitor.addObserver(serverTemplateObserver);
    monitor.addObserver(staticAssetObserver);
    monitor.start();
}

/**
 * Creates a new OpenCmsConfiguration instance, prepares the XML helper for parsing configuration files, starts
 * a FileAlterationObserver used to handle changes to configuration files.
 * @param config the project level plugin configuration data
 */
public OpenCmsConfiguration(OpenCmsPluginConfigurationData config) {
    this.config = config;

    File configurationFolder = new File(config.getWebappRoot() + CONFIGPATH);
    this.moduleConfigurationFile = new File(config.getWebappRoot() + CONFIGPATH + MODULECONFIGFILE);

    // Create an Observer for configuration changes
    FileAlterationObserver configurationChangeObserver = new FileAlterationObserver(configurationFolder);
    configurationChangeObserver.addListener(new ConfigurationAlterationListener());
    configurationChangeMonitor = new FileAlterationMonitor(5000, configurationChangeObserver);

    try {
        xmlHelper = new XmlHelper();
    }
    catch (Exception e) {
        LOG.warn("Exception during initialization of the module configuration: " + e);
    }

    parseConfiguration();
}

public DirectoryMonitor(String directorypath, long polling, String classname) {

        this.directory = new File(directorypath);
        this.trackedClassName = classname;
        this.polling = polling;

        if (!directory.isDirectory()) {
            LOG.info("Monitored directory {} not existing - creating directory", directory.getAbsolutePath());
            if (!this.directory.mkdirs()) {
                throw new IllegalStateException("Monitored directory doesn't exist and cannot be created.");
            }
        }

        // We observes all files.
        FileAlterationObserver observer = new FileAlterationObserver(directory, TrueFileFilter.INSTANCE);
        observer.checkAndNotify();
        observer.addListener(new FileMonitor());
        monitor = new FileAlterationMonitor(polling, observer);

    }

/**
 * 增加监视器
 *
 * @param path     监听的文件夹路径
 * @param listener 事件回调接口
 * @return 监听器的id
 * @throws JNotifyException {@link JNotifyException}
 */
public static int addMonitor(String path, FileAlterationListener listener) throws JNotifyException {
    File file = new File(path);
    FileAlterationObserver observer = new FileAlterationObserver(file);
    observer.checkAndNotify();
    observer.addListener(listener);
    int mask = JNotify.FILE_CREATED | JNotify.FILE_DELETED
            | JNotify.FILE_MODIFIED;
    return JNotify.addWatch(path, mask, false, new FileEventListener(observer));
}

@Override
public void onStart(final FileAlterationObserver observer) {
    final Path observedPath = observer.getDirectory().toPath();
    listenerForCurrentChange = listeners.get(observedPath);
    if (listenerForCurrentChange != null) {
        log.debug("Start collecting changes in {}", observedPath);
        listenerForCurrentChange.fileSystemChangesStarted();
    } else {
        log.warn("Ignoring file system changes in unknown directory: " + observedPath);
    }

}

@Override
public void onStop(final FileAlterationObserver observer) {
    if (listenerForCurrentChange != null) {
        log.debug("Stop collecting changes in {}", observer.getDirectory());
        listenerForCurrentChange.fileSystemChangesStopped();
    }
}

private void checkFileChange()
{
    for (int i=0;i<observers.size();i++) {
         FileAlterationObserver observer =observers.get(i);
         observer.checkAndNotify();
     }
}

/**
 * 监视目录
 * @param directory
 * @param filter
 * @throws Exception 
 */
protected void monitorDir(String directory,IOFileFilter filter) throws Exception
{
    FileAlterationObserver observer=new FileAlterationObserver(directory,filter);
    observer.initialize();
    observer.addListener(fileListener);
    observers.add(observer);
}

protected void init() throws Exception
{
    FileAlterationObserver observer=buildFileAlterationObserver(scriptDir);
    observer.addListener(new FileListener());
    FileAlterationMonitor monitor=new FileAlterationMonitor(updateInterval);
    monitor.addObserver(observer);
    monitor.start();
    scanResources();
}

protected FileAlterationObserver buildFileAlterationObserver(String directory)
{
    //后缀过滤器
    IOFileFilter suffixFileFilter=FileFilterUtils.or(FileFilterUtils.suffixFileFilter(".class"),FileFilterUtils.suffixFileFilter(".jar"));
    //子目录变化
    IOFileFilter rootAndSubFilefilter=FileFilterUtils.or(FileFilterUtils.directoryFileFilter(),suffixFileFilter);
    return new FileAlterationObserver(directory,rootAndSubFilefilter);
}

TorrentFileWatcher(final FileAlterationListener listener, final Path monitoredFolder, final Integer interval) {
    Preconditions.checkNotNull(listener, "listener cannot be null");
    Preconditions.checkNotNull(monitoredFolder, "monitoredFolder cannot be null");
    Preconditions.checkArgument(Files.exists(monitoredFolder), "Folder '" + monitoredFolder.toAbsolutePath() + "' does not exists.");
    Preconditions.checkNotNull(interval, "interval cannot be null");
    Preconditions.checkArgument(interval > 0, "interval cannot be less than 1");
    this.listener = listener;
    this.monitoredFolder = monitoredFolder.toFile();
    this.monitor = new FileAlterationMonitor(interval);
    this.observer = new FileAlterationObserver(this.monitoredFolder, TORRENT_FILE_FILTER);

    this.observer.addListener(this.listener);
    monitor.addObserver(this.observer);
}

public void monitor(String directory, int interval) {
    FileAlterationObserver fileAlterationObserver = new FileAlterationObserver(directory, FileFilterUtils.and(FileFilterUtils.nameFileFilter(SENSITIVE_WORD_FILE_NAME)), null);
    fileAlterationObserver.addListener(this);
    FileAlterationMonitor fileAlterationMonitor = new FileAlterationMonitor(interval, fileAlterationObserver);

    try {
        fileAlterationMonitor.start();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

/**

@method monitorCollection
*/
   private FileAlterationMonitor monitorCollection (String collection) throws Exception {
    // prtln ("monitorCollection() - " + collection);

    AssetCollection assetCollection = this.getCollection(collection);

       if (assetCollection == null) {
           // Test to see if monitored folder exists
           throw new RuntimeException("AssetCollection not found: " + collection);
       }

       File folder = assetCollection.getDirectory();
       if (!folder.exists())
        throw new RuntimeException("Folder not found at: " + folder);

       FileAlterationObserver observer = new FileAlterationObserver(folder);
       FileAlterationMonitor monitor =
               new FileAlterationMonitor(pollingInterval);

    FileAlterationListener listener = new AssetFileListener(collection, this);

       observer.addListener(listener);
       monitor.addObserver(observer);
       monitor.start();
       // prtln (" .. monitoring " + collection);
       return monitor;
   }

@Test
public void should_create_an_observer_that_notify_when_a_file_is_created() throws Exception {

    FileAlterationObserver observer = factory.create(monitoredFolder, listener);
    Path aFile = Files.write(monitoredFolder.resolve("aFile"), "coucou".getBytes());
    observer.checkAndNotify();

    assertThat(listener.getChanged()).containsExactly(aFile);
}

@Test
public void should_create_an_observer_that_notify_when_a_file_is_modified() throws Exception {
    Files.write(monitoredFolder.resolve("aFile"), "coucou".getBytes());

    FileAlterationObserver observer = factory.create(monitoredFolder, listener);
    Files.write(monitoredFolder.resolve("aFile"), "modified content".getBytes());
    observer.checkAndNotify();

    assertThat(listener.getChanged()).containsExactly(monitoredFolder.resolve("aFile"));
}

public Main(@Nullable File path, Map<String, Class> initialKlassPath, Class<? extends Plugin>... plugin) {

        if (path != null)
            path = path.getAbsoluteFile();

        this.path = path;

        klassPath.putAll(initialKlassPath);

        //setup default klasspath
        klassPath.putIfAbsent("log", LogConfigurator.class);

        put(LogConfigurator.class, new LogConfigurator(null));

//        Set<Class<? extends Plugin>> plugins = new Reflections(Main.class.getClassLoader())
//                .getSubTypesOf(Plugin.class);

        for (Class c : plugin) {
            String id = c.getSimpleName().toLowerCase();
            logger.warn("Plugin available: {}", id);
            klassPath.put(id, c);
        }


        if (path != null) {
            fsObserver = new FileAlterationObserver(path);
        } else {
            fsObserver = null;
        }

//            @Override
//            public synchronized void clear(boolean rebuild) {
//                super.clear(rebuild);
//                System.exit(2);
//            }
//        };


    }

public PluginDirectoryWatcher(PluginManagerImpl pluginManager, File directory) {
    this.pluginManager = pluginManager;
    this.directory = directory;
    FileAlterationObserver observer = new FileAlterationObserver(directory);
    observer.addListener(this);
    monitor = new FileAlterationMonitor();
    monitor.addObserver(observer);
}

/**
 * Constructor.
 * @param manager the templating manager, to which event handling is delegated.
 * @param templateDir the templates directory to watch.
 * @param pollInterval the poll interval.
 * @throws IOException if there is a problem watching the template directory.
 */
public TemplateWatcher( final TemplatingManager manager, final File templateDir, final long pollInterval ) {
    this.templateDir = templateDir;

    // Register the custom helpers.
    this.handlebars.registerHelper( AllHelper.NAME, new AllHelper());
    this.handlebars.registerHelper( IsKeyHelper.NAME, new IsKeyHelper());

    // Pretty formatting
    this.handlebars.prettyPrint( true );

    // Create the observer, register this object as the event listener.
    FileFilter fileFilter = FileFilterUtils.or(
            FileFilterUtils.and(
                    FileFilterUtils.fileFileFilter(),
                    FileFilterUtils.suffixFileFilter( ".tpl" ),
                    CanReadFileFilter.CAN_READ,
                    new TemplateFileFilter(templateDir)),
            FileFilterUtils.and(
                    FileFilterUtils.directoryFileFilter(),
                    CanReadFileFilter.CAN_READ,
                    new TemplateSubDirectoryFileFilter(templateDir))
    );

    FileAlterationObserver observer = new FileAlterationObserver( this.templateDir, fileFilter );
    observer.addListener( this );

    // Create the monitor.
    this.monitor = new FileAlterationMonitor( pollInterval, observer );
    this.monitor.setThreadFactory( THREAD_FACTORY );

    this.manager = manager;
    this.logger.fine( "Template watcher is watching "
            + this.templateDir
            + " with an interval of " + pollInterval + " ms." );
}

private void observeConfigChanges() throws Exception
{
    if (watchConfigInterval < 0)
    {
        return;
    }

    FileAlterationListenerAdaptor listener = new FileAlterationListenerAdaptor()
    {
        @Override
        public void onFileChange(File file)
        {
            LOG.info("Config file changed: {}", configPath);
            try
            {
                readConfig(true);
            }
            catch (ConfigException e)
            {
                exitWithError("Failed to refresh config: " + e.getMessage(), false);
                return;
            }
        }
    };

    String filename = configPath.substring(configPath.lastIndexOf('/') + 1);
    String directory = configPath.substring(0, configPath.lastIndexOf('/'));

    FileAlterationObserver observer = new FileAlterationObserver(
            new File(directory),
            FileFilterUtils.nameFileFilter(filename)
    );
    observer.addListener(listener);

    FileAlterationMonitor monitor = new FileAlterationMonitor(watchConfigInterval);
    monitor.addObserver(observer);

    monitor.start();
}

@Override
public void initialize() {
    this.fileAlterationObserver = new FileAlterationObserver(directory, fileFilter);
    this.fileAlterationObserver.addListener(this);
    try {
        this.fileAlterationObserver.initialize();
    } catch (Exception e) {
    }
}

@Override
@SuppressWarnings("PMD.EmptyCatchBlock")
public synchronized void registerDirectoryListener(File directory, DirectoryListener directoryListener) {
    FileAlterationObserver newObserver = new FileAlterationObserver(directory);
    FileAlterationObserver oldObserver = directoryObservers.putIfAbsent(directory, newObserver);
    final FileAlterationObserver observer;
    if (oldObserver == null) {
        observer = newObserver;
    } else {
        observer = oldObserver;
    }
    SFMF4JFileAlterationListener newListener = new SFMF4JFileAlterationListener(directoryListener);
    boolean found = false;
    for (FileAlterationListener fal : observer.getListeners()) {
        if (newListener.equals(fal)) {
            found = true;
            break;
        }
    }
    if (!found) {
        observer.addListener(newListener);
    }
    if (observer == newObserver) {
        try {
            observer.initialize();
            fileMonitor.addObserver(observer);
        } catch (Exception ex) {
            //trap
        }
    }

}

public FileAlterationObserver observeJs() {
    AssetSpec spec = pe.getJsAssetSpec();
    FileAlterationObserver observer = setupObserver(spec);
    BuildJs buildJs = new BuildJs(pe, spec);
    observer.addListener(new BuildListener(spec, buildJs));
    return observer;
}

public FileAlterationObserver observeCss() {
    AssetSpec spec = pe.getCssAssetSpec();
    FileAlterationObserver observer = setupObserver(spec);
    BuildCss buildCss = new BuildCss(spec);
    observer.addListener(new BuildListener(spec, buildCss));
    return observer;
}

public FileAlterationObserver observeImage() {
    AssetSpec spec = pe.getImageAssetSpec();
    FileAlterationObserver observer = setupObserver(spec);
    BuildImage buildImage = new BuildImage(spec);
    observer.addListener(new BuildListener(spec, buildImage));
    return observer;
}

public FileAlterationObserver observeServerTemplate() {
    AssetSpec spec = pe.getServerTemplateAssetSpec();
    FileAlterationObserver observer = setupObserver(spec);
    BuildServerTemplate buildServerTemplate = new BuildServerTemplate(spec);
    observer.addListener(new BuildListener(spec, buildServerTemplate));
    return observer;
}

public FileAlterationObserver observeTemplate() {
    AssetSpec spec = pe.getTemplateAssetSpec();
    FileAlterationObserver observer = setupObserver(spec);
    BuildTemplate buildTemplate = new BuildTemplate(pe, spec);
    observer.addListener(new BuildListener(spec, buildTemplate));
    return observer;
}

public FileAlterationObserver observeStaticAsset() {
    AssetSpec spec = pe.getStaticAssetSpec();
    FileAlterationObserver observer = setupObserver(spec);
    BuildStaticAsset buildStaticAsset = new BuildStaticAsset(spec);
    observer.addListener(new BuildListener(spec, buildStaticAsset));
    return observer;
}

/**
 * Starts the watching.
 *
 * @return the current pipeline.
 */
public Pipeline watch() {
    // Delete all error reports before starting the watcher.
    error = new File(baseDir, "target/pipeline");
    FileUtils.deleteQuietly(error);
    mojo.getLog().debug("Creating the target/pipeline directory : " + error.mkdirs());

    // Start the watching process.
    watcher = new FileAlterationMonitor(Integer.getInteger("watch.period", 2) * 1000);
    watcher.setThreadFactory(new DefensiveThreadFactory("wisdom-pipeline-watcher", mojo));
    FileAlterationObserver srcObserver = new FileAlterationObserver(new File(baseDir, "src"),
            TrueFileFilter.INSTANCE);
    PipelineWatcher listener = new PipelineWatcher(this);
    srcObserver.addListener(listener);
    watcher.addObserver(srcObserver);

    if (pomFileMonitoring) {
        FileAlterationObserver pomObserver = new FileAlterationObserver(baseDir, new FileFilter() {
            @Override
            public boolean accept(File file) {
                return file.equals(new File(baseDir, "pom.xml"));
            }
        });
        pomObserver.addListener(listener);
        watcher.addObserver(pomObserver);
    }

    try {
        mojo.getLog().info("Start watching " + baseDir.getAbsolutePath());
        watcher.start();
    } catch (Exception e) {
        mojo.getLog().error("Cannot start the watcher", e);
    }
    return this;
}

public void addDirectoryToWatch(File directory){
    if (directory.isDirectory()) {
        logger.log("Adding directory: " + directory, Log.DEBUGMSG);
        FileAlterationObserver observer = new FileAlterationObserver(directory);
        directories.add(directory);
        observer.addListener(this);
        observers.add(observer);
        monitor.addObserver(observer);
        this.unwatch();
        this.watch();
    } else {
        logger.log("Invalid directory entry passed: " + directory, Log.DEBUGMSG);
    }
}