@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); } }