public void run() { if (watchService == null || watchKey == null) { return; } if (DEBUG_LOG_TO_CONSOLE) { System.out.println("" + Thread.currentThread().getId() + " Started run method"); } try { do { WatchKey watchKey = watchService.take(); List<WatchEvent<?>> events = watchKey.pollEvents(); if (events != null && events.size() > 0) { if (DEBUG_LOG_TO_CONSOLE) { System.out.println("" + Thread.currentThread().getId() + " Received change event"); } // fire listener listener.onDirectoryChanged(directory); } } while (watchKey.reset()); } catch (Throwable e) { // terminating if (DEBUG_LOG_TO_CONSOLE) { System.out.println("" + Thread.currentThread().getId() + " Exception: " + e.toString()); } } }
/** Process all events for keys queued to the watcher */ void processEvents() { while (true) { // wait for key to be signalled WatchKey key; try { key = watcher.take(); } catch (InterruptedException x) { return; } Path dir = keys.get(key); if (dir == null) { System.err.println("WatchKey not recognized!!"); continue; } List<WatchEvent<?>> events = key.pollEvents(); for (WatchEvent<?> event : events) { Kind<?> kind = event.kind(); // TBD - provide example of how OVERFLOW event is handled if (kind == OVERFLOW) { continue; } // Context for directory entry event is the file name of entry WatchEvent<Path> ev = cast(event); Path name = ev.context(); Path child = dir.resolve(name); // print out event onEvent.accept(ev, child); // if directory is created, and watching recursively, then // register it and its sub-directories if (recursive && (kind == ENTRY_CREATE)) { try { if (Files.isDirectory(child, NOFOLLOW_LINKS)) { registerAll(child); } } catch (IOException x) { // ignore to keep sample readbale } } } // reset key and remove from set if directory no longer accessible boolean valid = key.reset(); if (!valid) { keys.remove(key); // all directories are inaccessible if (keys.isEmpty()) { break; } } } }
public void startTimer() throws IOException, InterruptedException { Path faxFolder = Paths.get("./plugins"); WatchService watchService = FileSystems.getDefault().newWatchService(); faxFolder.register(watchService, StandardWatchEventKinds.ENTRY_CREATE); boolean valid = true; do { WatchKey watchKey = watchService.take(); for (WatchEvent event : watchKey.pollEvents()) { WatchEvent.Kind kind = event.kind(); if (StandardWatchEventKinds.ENTRY_CREATE.equals(event.kind())) { String fileName = event.context().toString(); System.out.println("Trying to add " + fileName); boolean success = this.server.addPlugin(fileName); System.out.println( success ? "Added " + fileName + "!" : fileName + " was not loaded, JAR was misformed."); } if (StandardWatchEventKinds.ENTRY_DELETE.equals(event.kind())) { String fileName = event.context().toString(); System.out.println("File Removed: " + fileName); this.server.removePlugin(fileName); } } valid = watchKey.reset(); } while (valid); }
/** * In order to implement a file watcher, we loop forever ensuring requesting to take the next * item from the file watchers queue. */ @Override public void run() { try { // get the first event before looping WatchKey key = myWatcher.take(); while (key != null) { // we have a polled event, now we traverse it and // receive all the states from it for (WatchEvent event : key.pollEvents()) { System.out.printf( "Received %s event for file: %s\n", event.kind(), pathToWatch + "/" + event.context()); uploadToS3.upload( "bulk-delivery", event.context().toString(), pathToWatch + "/" + event.context().toString()); } key.reset(); key = myWatcher.take(); } } catch (Exception e) { e.printStackTrace(); } System.out.println("Stopping thread"); }
private void refresh() throws IOException { while (true) { WatchKey watchKey = watchService.poll(); if (watchKey == null) { return; } Path parentDir = (Path) watchKey.watchable(); for (WatchEvent<?> watchEvent : watchKey.pollEvents()) { WatchEvent.Kind<?> eventKind = watchEvent.kind(); if (eventKind == OVERFLOW) { fullRefresh(); return; } Path child = parentDir.resolve((Path) watchEvent.context()); if (eventKind == ENTRY_CREATE) { onNewPath(child); } else if (eventKind == ENTRY_DELETE) { onRemovedPath(child); } } watchKey.reset(); } }
public static void watchDirectoryPath(Path path) { // Sanity check - Check if path is a folder try { Boolean isFolder = (Boolean) Files.getAttribute(path, "basic:isDirectory", NOFOLLOW_LINKS); if (!isFolder) { throw new IllegalArgumentException("Path: " + path + " is not a folder"); } } catch (IOException ioe) { // Folder does not exists ioe.printStackTrace(); } // System.out.println("Watching path: " + path); // We obtain the file system of the Path FileSystem fs = path.getFileSystem(); // We create the new WatchService using the new try() block try (WatchService service = fs.newWatchService()) { // We register the path to the service // We watch for creation events path.register(service, ENTRY_CREATE); // Start the infinite polling loop WatchKey key = null; while (true) { key = service.take(); // Dequeueing events Kind<?> kind = null; for (WatchEvent<?> watchEvent : key.pollEvents()) { // Get the type of the event kind = watchEvent.kind(); if (OVERFLOW == kind) { continue; // loop } else if (ENTRY_CREATE == kind) { // A new Path was created // Path newPath = ((WatchEvent<Path>) // watchEvent).context(); // Output // System.out.println("New path created: " + newPath); } } if (!key.reset()) { break; // loop } } } catch (IOException ioe) { ioe.printStackTrace(); } catch (InterruptedException ie) { ie.printStackTrace(); } }
public void run() { log.debug("ReloadStrategy is starting watching folder: {}", folder); // allow to run while starting Camel while (isStarting() || isRunAllowed()) { running = true; WatchKey key; try { log.trace("ReloadStrategy is polling for file changes in directory: {}", folder); // wait for a key to be available key = watcher.poll(2, TimeUnit.SECONDS); } catch (InterruptedException ex) { break; } if (key != null) { for (WatchEvent<?> event : key.pollEvents()) { WatchEvent<Path> we = (WatchEvent<Path>) event; Path path = we.context(); String name = folder.resolve(path).toAbsolutePath().toFile().getAbsolutePath(); log.trace("Modified/Created file: {}", name); // must be an .xml file if (name.toLowerCase(Locale.US).endsWith(".xml")) { log.debug("Modified/Created XML file: {}", name); try { FileInputStream fis = new FileInputStream(name); onReloadXml(getCamelContext(), name, fis); IOHelper.close(fis); } catch (Exception e) { log.warn( "Error reloading routes from file: " + name + " due " + e.getMessage() + ". This exception is ignored.", e); } } } // the key must be reset after processed boolean valid = key.reset(); if (!valid) { break; } } } running = false; log.info("ReloadStrategy is stopping watching folder: {}", folder); }
private boolean processWatchKey(WatchKey watchKey) { for (WatchEvent<?> event : watchKey.pollEvents()) { if (StandardWatchEventKinds.OVERFLOW == event.kind()) continue; try { session.getBasicRemote().sendObject(((Path) event.context()).toFile()); } catch (Exception e) { e.printStackTrace(); } } return watchKey.reset(); }
/** * Process all events for keys queued to the watcher. * * <p>When the event is a ENTRY_CREATE or ENTRY_MODIFY, the folders will be added to the watcher, * the classes will be loaded by SpringLoaded */ public void run() { while (isStarted) { // wait for key to be signalled WatchKey key; try { key = watcher.take(); } catch (InterruptedException x) { return; } Path dir = keys.get(key); if (dir == null) { continue; } for (WatchEvent<?> event : key.pollEvents()) { WatchEvent.Kind kind = event.kind(); // Context for directory entry event is the file name of entry // noinspection unchecked WatchEvent<Path> ev = (WatchEvent<Path>) event; Path name = ev.context(); Path child = dir.resolve(name); // if directory is created, and watching recursively, then // register it and its sub-directories if (Files.isDirectory(child, NOFOLLOW_LINKS)) { watchDirectory(child); // load the classes that have been copied final File[] classes = child.toFile().listFiles((FileFilter) new SuffixFileFilter(".class")); for (File aFile : classes) { final String parentFolder = aFile.getParent(); callFileWatcherListerners(parentFolder, aFile.toPath(), kind); } } else { callFileWatcherListerners(dir.toString().replace(File.separator, "/"), child, kind); } } // reset key and remove from set if directory no longer accessible boolean valid = key.reset(); if (!valid) { keys.remove(key); // all directories are inaccessible if (keys.isEmpty()) { break; } } } }
public static void main(String[] args) { try { WatchService watcher = FileSystems.getDefault().newWatchService(); Path dir = Paths.get("D:\\take it"); dir.register(watcher, ENTRY_CREATE, ENTRY_MODIFY); System.out.println("Watch Service registered for dir: " + dir.getFileName()); System.out.println("How many files are already there " + folder.getAbsolutePath()); listFilesForFolder(folder); while (true) { WatchKey key; try { key = watcher.take(); } catch (InterruptedException ex) { return; } for (WatchEvent<?> event : key.pollEvents()) { WatchEvent.Kind<?> kind = event.kind(); @SuppressWarnings("unchecked") WatchEvent<Path> ev = (WatchEvent<Path>) event; Path fileName = ev.context(); // String p = folder.getAbsolutePath()+ "\\" +fileName; if ((fileName.toString()).contains(".")) { System.out.println("snadkf"); } else { System.out.println(kind.name() + ": " + fileName); } // System.out.println("New file has been arrived: "+fileName); } /*if (kind == ENTRY_MODIFY && fileName.toString().equals("DirectoryWatchDemo.java")) { System.out.println("My source file has changed!!!"); } }*/ boolean valid = key.reset(); if (!valid) { break; } } } catch (IOException ex) { System.err.println(ex); } }
/** Process all events for the key queued to the watcher. */ void processEvents() { for (; ; ) { // wait for key to be signaled WatchKey key; try { key = watcher.take(); } catch (InterruptedException x) { return; } for (WatchEvent<?> event : key.pollEvents()) { WatchEvent.Kind kind = event.kind(); if (kind == OVERFLOW) { continue; } // The filename is the context of the event. WatchEvent<Path> ev = (WatchEvent<Path>) event; Path filename = ev.context(); // Verify that the new file is a text file. try { Path child = dir.resolve(filename); if (!Files.probeContentType(child).equals("text/plain")) { System.err.format("New file '%s' is not a plain text file.%n", filename); continue; } } catch (IOException x) { System.err.println(x); continue; } // Email the file to the specified email alias. System.out.format("Emailing file %s%n", filename); } // Reset the key -- this step is critical if you want to receive // further watch events. If the key is no longer valid, the directory // is inaccessible so exit the loop. boolean valid = key.reset(); if (!valid) { break; } } }
/** Обработчик всех событий помещенных в очередь */ void processEvents() { for (; ; ) { WatchKey key; try { key = watcher.take(); } catch (InterruptedException x) { LOG.log(Level.SEVERE, x.getMessage()); return; } Path dir = keys.get(key); if (dir == null) { LOG.log(Level.SEVERE, "Входной каталог не найден!"); continue; } for (WatchEvent<?> event : key.pollEvents()) { WatchEvent.Kind kind = event.kind(); // TODO - подумать над обработчиком события OVERFLOW if (kind == OVERFLOW) { continue; } WatchEvent<Path> ev = cast(event); Path name = ev.context(); Path child = dir.resolve(name); // логируем событие if (kind == ENTRY_CREATE) { LOG.log(Level.FINEST, "{0}: {1}", new Object[] {event.kind().name(), child}); Runnable worker = new WorkerThread(child); executor.execute(worker); } } boolean valid = key.reset(); if (!valid) { keys.remove(key); if (keys.isEmpty()) { break; } } } }
@Override public void run() { try { WatchService service = FileSystems.getDefault().newWatchService(); Path path = Paths.get(Settings.AVAILABLE_USERS_PATH); path.register(service, StandardWatchEventKinds.ENTRY_MODIFY); while (true) { // wait until a directory change is detected WatchKey key = service.take(); // remove all pending directory change events key.pollEvents(); // get an up-to-date list of the currently available users Set<String> availableUsers = getAvailableUsers(); // has anyone just come online? Set<String> logOns = new HashSet<String>(availableUsers); logOns.removeAll(users); // has anyone just gone offline? Set<String> logOffs = new HashSet<String>(users); logOffs.removeAll(availableUsers); // update the list of available users users = availableUsers; // notify the delegate of the changes delegate.change(logOns, logOffs); boolean valid = key.reset(); if (!valid) { break; // Exit if directory is deleted } } } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
private void initWatcher() throws IOException, InterruptedException { WatchService watcher = path.getFileSystem().newWatchService(); path.register( watcher, StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_MODIFY, StandardWatchEventKinds.ENTRY_DELETE); LOG.info("Now watching template folder: " + path.toFile().getAbsolutePath()); while (true) { WatchKey key = watcher.take(); List<WatchEvent<?>> events = key.pollEvents(); if (!events.isEmpty()) { updateTemplates(); } key.reset(); } }
/** * @param args * @throws IOException * @throws InterruptedException */ public static void main(String[] args) throws IOException, InterruptedException { final String dir = "C:\\work\\docs\\PHD_Work\\thesis\\"; File folder = new File(dir); File[] listOfFiles = folder.listFiles(); for (int i = 0; i < listOfFiles.length; i++) { if (listOfFiles[i].isFile()) { String file = listOfFiles[i].getName(); if (file.endsWith(".tex")) { latexToHTML(dir + file); } } } // define a folder root Path myDir = Paths.get(dir); WatchService watcher = myDir.getFileSystem().newWatchService(); myDir.register(watcher, ENTRY_MODIFY); do { WatchKey watckKey = watcher.poll(); if (watckKey != null) { List<WatchEvent<?>> events = watckKey.pollEvents(); for (WatchEvent event : events) { String filename = event.context().toString(); if (filename.endsWith(".tex")) { latexToHTML(dir + filename); } } watckKey.reset(); } Thread.sleep(500); } while (true); }
public static void watchDirectoryPath(Path path) { if (path != null) { System.out.println("Watching path: " + path); FileSystem fs = path.getFileSystem(); try (WatchService service = fs.newWatchService()) { path.register(service, ENTRY_CREATE); WatchKey key; while (true) { key = service.take(); // Dequeueing events Kind<?> kind; for (WatchEvent<?> watchEvent : key.pollEvents()) { // Get the type of the event kind = watchEvent.kind(); if (OVERFLOW == kind) { continue; // loop } else if (ENTRY_CREATE == kind) { // A new Path was created Path newPath = ((WatchEvent<Path>) watchEvent).context(); // Output System.out.println("New path created/modified: " + newPath); checkPath(newPath.toString()); } } if (!key.reset()) { break; // resets the key so it continues to look for new creation events. } } } catch (IOException | InterruptedException ioe) { System.out.println("The file watcher was interrupted."); } } }
public static void watchService() { try { WatchService watcher = FileSystems.getDefault().newWatchService(); WatchKey watchKey = Paths.get("/Users/caocao024/Desktop") .register(watcher, StandardWatchEventKinds.ENTRY_MODIFY); while (true) { // watchKey = watcher.take(); for (WatchEvent<?> event : watcher.poll(10, TimeUnit.MILLISECONDS).pollEvents()) { if (event.kind() == StandardWatchEventKinds.ENTRY_MODIFY) { System.out.println("====" + event.context() + " | " + event.count()); } } watchKey.reset(); } } catch (IOException | InterruptedException e) { e .printStackTrace(); // To change body of catch statement use File | Settings | File // Templates. } }
@Override public void run() { try { for (; ; ) { WatchKey key = null; try { key = watchService.take(); } catch (InterruptedException e) { return; } for (WatchEvent<?> event : key.pollEvents()) { WatchEvent.Kind<?> kind = event.kind(); if (kind == OVERFLOW) { continue; } // Context for directory entry event is the file name of // entry WatchEvent<Path> ev = cast(event); Path name = ev.context(); // print out event if (kind == ENTRY_CREATE || kind == ENTRY_MODIFY) { try { processConfigFile( new File(getServiceConfigFolder() + File.separator + name.toString())); } catch (IOException e) { logger.warn("Could not process config file '{}': {}", name, e); } } } key.reset(); } } catch (ClosedWatchServiceException ecx) { logger.debug("Terminated thread {}", Thread.currentThread().getName()); return; } }
/** Creates a WatchService and registers the given directory */ private void setupWatch(String initialText) throws IOException { this.watcher = FileSystems.getDefault().newWatchService(); this.dir = Files.createTempDirectory("jshelltemp"); this.tmpfile = Files.createTempFile(dir, null, ".edit"); Files.write(tmpfile, initialText.getBytes(Charset.forName("UTF-8"))); dir.register(watcher, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY); watchedThread = new Thread( () -> { for (; ; ) { WatchKey key; try { key = watcher.take(); } catch (ClosedWatchServiceException ex) { // The watch service has been closed, we are done break; } catch (InterruptedException ex) { // tolerate an interrupt continue; } if (!key.pollEvents().isEmpty()) { // Changes have occurred in temp edit directory, // transfer the new sources to JShell (unless the editor is // running directly in JShell's window -- don't make a mess) if (!input.terminalEditorRunning()) { saveFile(); } } boolean valid = key.reset(); if (!valid) { // The watch service has been closed, we are done break; } } }); watchedThread.start(); }
/** 监听目录 */ @Test public void testWatchFile() { // 监听目录变化 try { WatchService watcher = FileSystems.getDefault().newWatchService(); Path dir = FileSystems.getDefault().getPath(ParentPath); WatchKey key = dir.register(watcher, StandardWatchEventKinds.ENTRY_MODIFY); boolean shutdown = false; while (!shutdown) { System.out.println(1); key = watcher.take(); for (WatchEvent<?> event : key.pollEvents()) { if (event.kind() == StandardWatchEventKinds.ENTRY_MODIFY) { System.out.println("Home dir changed!"); } } key.reset(); } } catch (IOException | InterruptedException e) { System.out.println(e.getMessage()); } }
/** Check that deleting a registered directory causes the key to be cancelled and queued. */ static void testAutomaticCancel(Path dir) throws IOException { System.out.println("-- Automatic Cancel --"); Path subdir = Files.createDirectory(dir.resolve("bar")); try (WatchService watcher = FileSystems.getDefault().newWatchService()) { System.out.format("register %s for events\n", subdir); WatchKey myKey = subdir.register( watcher, new WatchEvent.Kind<?>[] {ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY}); System.out.format("delete: %s\n", subdir); Files.delete(subdir); takeExpectedKey(watcher, myKey); System.out.println("reset key"); if (myKey.reset()) throw new RuntimeException("Key was not cancelled"); if (myKey.isValid()) throw new RuntimeException("Key is still valid"); System.out.println("OKAY"); } }
private void watchLoop() throws IOException { WatchService watcher = FileSystems.getDefault().newWatchService(); toWatch_.register(watcher, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY); while (running_) { // wait for key to be signaled WatchKey key; try { key = watcher.take(); } catch (InterruptedException x) { return; } if (key != null) { for (WatchEvent<?> event : key.pollEvents()) { if (!running_) { return; } System.out.println("Processing event..."); processEvent(event); } // Reset the key -- this step is critical if you want to // receive further watch events. If the key is no longer valid, // the directory is inaccessible so exit the loop. boolean valid = key.reset(); if (!valid) { break; } } } }
public void watchForNewEdges() { // File file = new File("C:\\Users\\rvanduijnhoven\\Documents\\jsfoutput\\jsfweek14.bin"); // Get the file system // FileSystem fs = path.getFileSystem(); // Create the watchservice try { Path path = Paths.get("C:/Users/rvanduijnhoven/Documents/jsfoutput/"); WatchService service = FileSystems.getDefault().newWatchService(); path.register(service, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY); WatchKey key; while (true) { key = service.take(); for (WatchEvent<?> event : key.pollEvents()) { // Code here that does something when new edges have been generated System.out.println(event.context().toString()); WatchEvent<Path> ev = (WatchEvent<Path>) event; WatchEvent.Kind kind = ev.kind(); if (kind == OVERFLOW) { continue; // just to demonstrate } Path changed = ev.context(); Path child = path.resolve(changed); if (changed.toString().equals("jsfweek14.bin")) { clearKochPanel(); File file = new File("C:\\Users\\rvanduijnhoven\\Documents\\jsfoutput\\jsfweek14.bin"); FileChannel fileChannel = null; MappedByteBuffer map = null; int counter = 0; // Now read every edge from the file and draw it. try { fileChannel = new RandomAccessFile(file, "r").getChannel(); map = fileChannel.map(FileChannel.MapMode.READ_ONLY, 0, 4096 * 128 * 128); double d = map.getDouble(); currentLevel = (int) d; counter = (int) (3 * Math.pow(4, currentLevel - 1)); for (int i = 0; i <= counter; i++) { double X1 = map.getDouble(); double Y1 = map.getDouble(); double X2 = map.getDouble(); double Y2 = map.getDouble(); double red = map.getDouble(); double green = map.getDouble(); double blue = map.getDouble(); Edge e = new Edge(X1, Y1, X2, Y2, new Color(red, green, blue, 1)); drawEdge(e); } key.reset(); } catch (Exception ex) { ex.printStackTrace(); } finally { fileChannel.close(); map.clear(); } } key.reset(); } } } catch (IOException ioe) { ioe.printStackTrace(); } catch (Exception ie) { ie.printStackTrace(); } }
@Override public void run() { while (running) { try { WatchKey key = watcher.take(); sleep(100); for (WatchEvent<?> event : key.pollEvents()) { Kind<?> kind = event.kind(); String dateiname = event.context().toString(); int linie; LineReader lr; switch (kind.name()) { case "ENTRY_CREATE": // HTreff<X>PN<Y>.ctl // HTreff<X>PN<Y>.nrt // HTreff<X>MN<Y>.ctl // HTreff<X>MN<Y>.nrt if (!dateiname.startsWith("HTreff")) break; int endIndex = dateiname.indexOf('N') - 1; linie = Integer.parseUnsignedInt(dateiname.substring(6, endIndex)); lr = getLineReaderByNumber(linie); if (lr != null) { File datei = new File(dateiname); if (dateiname.endsWith(".ctl")) { FileInputStream reader = null; try { reader = new FileInputStream(dateiname); List<String> lines = IOUtils.readLines(reader, Charset.forName("UTF-8")); if (lines.size() > 0) lr.addTreffer(new Hit(lines.get(0))); } catch (IOException e) { e.printStackTrace(); } finally { if (reader != null) IOUtils.closeQuietly(reader); } } if (!datei.delete()) { System.out.println(dateiname + " konnte nicht gelöscht werden."); } } break; case "ENTRY_DELETE": // HServ<X>.ctl if (dateiname.startsWith("HServ") && dateiname.endsWith(".ctl")) { linie = Integer.parseUnsignedInt(dateiname.substring(5, dateiname.length() - 4)); lr = getLineReaderByNumber(linie); if (lr != null) lr.reenable(); } break; default: // OVERFLOW continue; } } key.reset(); } catch (InterruptedException | ClosedWatchServiceException e) { if (running) { e.printStackTrace(); } } } }
@Override public void run() { while (!stopped) { try { final WatchKey key = watchService.take(); if (key != null) { try { PathData pathData = pathDataByKey.get(key); if (pathData != null) { List<WatchEvent<?>> events = new ArrayList<>(key.pollEvents()); final List<FileChangeEvent> results = new ArrayList<>(); List<WatchEvent<?>> latest; do { // we need to wait till nothing has changed in 500ms to make sure we have picked up // all the changes Thread.sleep(WAIT_TIME); latest = key.pollEvents(); events.addAll(latest); } while (!latest.isEmpty()); final Set<File> addedFiles = new HashSet<>(); final Set<File> deletedFiles = new HashSet<>(); for (WatchEvent<?> event : events) { Path eventPath = (Path) event.context(); File targetFile = ((Path) key.watchable()).resolve(eventPath).toFile(); FileChangeEvent.Type type; if (event.kind() == ENTRY_CREATE) { type = FileChangeEvent.Type.ADDED; addedFiles.add(targetFile); if (targetFile.isDirectory()) { try { addWatchedDirectory(pathData, targetFile); } catch (IOException e) { e.printStackTrace(); } } } else if (event.kind() == ENTRY_MODIFY) { type = FileChangeEvent.Type.MODIFIED; } else if (event.kind() == ENTRY_DELETE) { type = FileChangeEvent.Type.REMOVED; deletedFiles.add(targetFile); } else { continue; } results.add(new FileChangeEvent(targetFile, type)); } key.pollEvents().clear(); // now we need to prune the results, to remove duplicates // e.g. if the file is modified after creation we only want to // show the create event final List<FileChangeEvent> newEvents = new ArrayList<>(); Iterator<FileChangeEvent> it = results.iterator(); while (it.hasNext()) { FileChangeEvent event = it.next(); boolean added = addedFiles.contains(event.getFile()); boolean deleted = deletedFiles.contains(event.getFile()); if (event.getType() == FileChangeEvent.Type.MODIFIED) { if (added || deleted) { it.remove(); } } else if (event.getType() == FileChangeEvent.Type.ADDED) { if (deleted) { it.remove(); newEvents.add( new FileChangeEvent( event.getFile(), FileChangeEvent.Type .MODIFIED)); // if it was both deleted and added it was modified } } else if (event.getType() == FileChangeEvent.Type.REMOVED) { if (added) { it.remove(); } } } results.addAll(newEvents); if (!results.isEmpty()) { for (FileChangeCallback callback : pathData.callbacks) { invokeCallback(callback, results); } } } } finally { // if the key is no longer valid remove it from the files list if (!key.reset()) { files.remove(key.watchable()); } } } } catch (InterruptedException e) { // ignore } catch (ClosedWatchServiceException cwse) { // the watcher service is closed, so no more waiting on events // @see https://developer.jboss.org/message/911519 break; } } }
private void processEvents() { while (true) { WatchKey key; try { key = watcher.take(); } catch (InterruptedException e) { return; } Path dir = keys.get(key); if (dir == null) { LOGGER.warn("Could not find key for " + key); continue; } for (WatchEvent<?> event : key.pollEvents()) { WatchEvent.Kind kind = event.kind(); WatchEvent<Path> ev = (WatchEvent<Path>) event; // Context for directory entry event is the file name of entry Path name = ev.context(); Path child = dir.resolve(name); LOGGER.debug("Processing event {} on path {}", kind, child); if (kind == OVERFLOW) { // rescan(); continue; } try { if (kind == ENTRY_CREATE) { if (Files.isDirectory(child, NOFOLLOW_LINKS)) { // if directory is created, and watching recursively, then // register it and its sub-directories Files.walkFileTree(child, new FilteringFileVisitor()); } else if (Files.isRegularFile(child, NOFOLLOW_LINKS)) { scan(child); } } else if (kind == ENTRY_MODIFY) { if (Files.isRegularFile(child, NOFOLLOW_LINKS)) { scan(child); } } else if (kind == ENTRY_DELETE) { unscan(child); } } catch (IOException x) { // ignore to keep sample readbale x.printStackTrace(); } } // reset key and remove from set if directory no longer accessible boolean valid = key.reset(); if (!valid) { LOGGER.debug("Removing key " + key + " and dir " + dir + " from keys"); keys.remove(key); // all directories are inaccessible if (keys.isEmpty()) { break; } } } }
// void processEvents() { public void run() { System.out.println("WatchDir Thread INFO: priority=" + Thread.currentThread().getPriority()); for (; ; ) { // wait for key to be signalled System.out.println("WatchDir INFO: restarting loop...acquiring new key"); WatchKey key; try { key = watcher.take(); } catch (InterruptedException x) { return; } Path dir = keys.get(key); if (dir == null) { System.err.println("WatchKey not recognized!!"); continue; } for (WatchEvent<?> event : key.pollEvents()) { WatchEvent.Kind kind = event.kind(); // TBD - provide example of how OVERFLOW event is handled if (kind == OVERFLOW) { System.out.println("Encountered OVERFLOW Event - " + event); continue; } // Context for directory entry event is the file name of entry WatchEvent<Path> ev = cast(event); Path name = ev.context(); Path child = dir.resolve(name); // print out event System.out.format("[WatchDir] %s: %s\n", event.kind().name(), child); // if directory is created, and watching recursively, then // register it and its sub-directories if (recursive && (kind == ENTRY_CREATE)) { try { if (Files.isDirectory(child, NOFOLLOW_LINKS)) { registerAll(child); } } catch (IOException x) { // ignore to keep sample readbale } } long t = System.currentTimeMillis(); if (!Folder.dontWatch.contains(Folder.getInternalPath(child))) { Thread.currentThread().setPriority(Thread.NORM_PRIORITY); System.out.println( "WatchDir#" + key + " INFO: path=" + child + ", internal=" + Folder.getInternalPath(child) + " is NOT in don't watch list. Forwarding it to other peers. @" + Main.timeToString(t)); // DEBUG forwardToItopic(kind, child); } else { Thread.currentThread().setPriority(Thread.MIN_PRIORITY); System.out.println( "WatchDir#" + key + " INFO: path=" + child + ", internal=" + Folder.getInternalPath(child) + " IS in the don't watch list. NOT forwarding. @" + Main.timeToString(t)); // DEBUG // try{ // Thread.sleep(minDelayBtwnWatchEvents); // } catch(InterruptedException ex) { // System.err.println("Exception:"+ex+" while trying to sleep WatchDir thread"); // ex.printStackTrace(); // } } } // reset key and remove from set if directory no longer accessible boolean valid = key.reset(); if (!valid) { keys.remove(key); // all directories are inaccessible if (keys.isEmpty()) { break; } } } }
@Override public void run() { logger.debug("Register root " + startDir.toString()); try { registerAll(startDir); } catch (IOException ex) { logger.error(ex.getMessage()); return; } if (isInterrupted()) return; VOSync.debug("Sync local db with drive"); DbPool.goSql( "Synching the local db with drive", "select NAME from FILES", new SqlWorker<Boolean>() { @Override public Boolean go(Connection conn, PreparedStatement stmt) throws SQLException { ResultSet resSet = stmt.executeQuery(); while (resSet.next()) { try { String fileName = resSet.getString(1); Path filePath = FileSystems.getDefault().getPath(startDir.toString(), fileName.substring(1)); if (!filePath.toFile().exists()) { logger.debug( "Deleting file " + fileName + " existing in DB and not present on disk"); api.delete(fileName); MetaHandler.delete(fileName); } } catch (DropboxException ex) { } } resSet.close(); return true; } }); if (isInterrupted()) return; VOSync.debug("Sync storage"); syncStorage(); logger.debug("Start watching"); while (!isInterrupted()) { WatchKey key; try { key = watcher.take(); } catch (InterruptedException x) { return; } Path dir = keys.get(key); if (dir == null) { System.err.println("WatchKey " + key.toString() + " not recognized!"); continue; } for (WatchEvent<?> event : key.pollEvents()) { Kind<?> kind = event.kind(); // TBD - provide example of how OVERFLOW event is handled if (kind == OVERFLOW) { continue; } // Context for directory entry event is the file name of entry WatchEvent<Path> ev = cast(event); Path name = ev.context(); Path child = dir.resolve(name); Path relativeDir = startDir.relativize(child); String fileRelPath = "/" + fixPath(relativeDir.toString()); // print out event logger.debug(event.kind().name() + ":" + child + " " + name + " " + key); try { if (Files.exists(child, new LinkOption[] {}) && Files.isHidden(child)) { logger.error( "Skipping hidden file " + child.getFileName()); // skip OS generated catalog files } else { if (event.kind() == ENTRY_CREATE) { if (Files.isRegularFile(child, NOFOLLOW_LINKS)) { // file modified uploadFile(fileRelPath, child); } else if (Files.isDirectory(child, NOFOLLOW_LINKS)) { // directory contents changed registerAll(child); } } else if (event.kind() == ENTRY_DELETE) { logger.debug("Deleting " + fileRelPath); api.delete(fileRelPath); MetaHandler.delete(fileRelPath); logger.debug("Deleted!"); } else if (event.kind() == ENTRY_MODIFY) { if (Files.isRegularFile(child, NOFOLLOW_LINKS)) { // file modified uploadFile(fileRelPath, child); } else if (Files.isDirectory(child, NOFOLLOW_LINKS)) { // directory contents changed // logger.debug("Renewing dir: "+relativeDir.toString()); // TODO update folder date // MetaHandler.setFile(fileRelPath, child, rev); } } } } catch (IOException ex) { ex.printStackTrace(); logger.error(ex.getMessage()); } catch (DropboxException ex) { ex.printStackTrace(); logger.error(ex.getMessage()); } } boolean valid = key.reset(); if (!valid) keys.remove(key); } }
/** * In order to implement a file watcher, we loop forever ensuring requesting to take the next * item from the file watchers queue. */ @Override public void run() { final Path path = Paths.get(spath); try { // We wait until the file we are told to monitor exists. while (!Files.exists(path)) { Thread.sleep(200); } // get the first event before looping WatchKey key = null; while (session.isOpen() && connected && (key = watcher.take()) != null) { try { if (!Files.exists(path)) continue; for (WatchEvent<?> event : key.pollEvents()) { if (!Files.exists(path)) continue; Path epath = (Path) event.context(); if (!Files.isDirectory(path) && !path.endsWith(epath)) continue; try { // Data has changed, read its shape and publish the event using a web socket. final IDataHolder holder = ServiceHolder.getLoaderService().getData(spath, new IMonitor.Stub()); if (holder == null) continue; // We do not stop if the loader got nothing. final ILazyDataset lz = sdataset != null && !"".equals(sdataset) ? holder.getLazyDataset(sdataset) : holder.getLazyDataset(0); if (lz == null) continue; // We do not stop if the loader got nothing. if (lz instanceof IDynamicDataset) { ((IDynamicDataset) lz).refreshShape(); } if (writing) { ServiceHolder.getLoaderService().clearSoftReferenceCache(spath); } final DataEvent evt = new DataEvent(lz.getName(), lz.getShape()); evt.setFilePath(spath); // We manually JSON the object because we // do not want a dependency and object simple String json = evt.encode(); session.getRemote().sendString(json); if (diagInfo != null) diagInfo.record("JSON Send", json); } catch (HDF5FunctionArgumentException h5error) { // This happens sometimes when the file is not ready to read. logger.trace("Path might not be ready to read " + path); continue; } catch (Exception ne) { logger.error("Exception getting data from " + path); continue; } break; } } finally { key.reset(); } } } catch (Exception e) { logger.error("Exception monitoring " + path, e); if (session.isOpen()) session.close(403, e.getMessage()); } finally { if (diagInfo != null) diagInfo.record("Close Thread", Thread.currentThread().getName()); try { watcher.close(); } catch (IOException e) { logger.error("Error closing watcher", e); } } }
void scanDirectory(String path) throws IOException, InterruptedException { watcher = FileSystems.getDefault().newWatchService(); Path directoryName = null; Path dir = Paths.get(path); // dir.register(watcher, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY); registerAll(dir); System.out.println("er i path"); for (; ; ) { WatchKey key; try { key = watcher.take(); } catch (InterruptedException e) { e.printStackTrace(); return; } // System.out.println("er i while"); for (WatchEvent<?> event : key.pollEvents()) { WatchEvent.Kind kind = event.kind(); WatchEvent<Path> ev = (WatchEvent<Path>) event; Path filename = ev.context(); Path directory; if (filename != null) { // System.out.println("filename != null."); directory = dir.resolve(filename); } else { continue; } // System.out.println("filename er "+filename); if (kind == OVERFLOW) { // System.out.println("fikk en overflow. "); continue; } else if (kind == ENTRY_MODIFY) { // System.out.println(kind.name() + " for path/directory " + directory); } else if (kind == ENTRY_CREATE) { System.out.println(kind.name() + " for path/directory " + directory); // System.out.println("suffix length er "+suffix[1]); System.out.println(kind.name() + " for path/directory " + directory); // System.out.println("filnavn er" + filename); String suffix[] = (directory.toString()).split("\\."); if ((suffix.length > 1) && (suffix[1].endsWith("evt"))) { System.out.println("Laget fil."); String adress = (directory.getParent().toAbsolutePath() + "/" + directoryName + "/" + filename); convertToSimpleEvent(adress); } else if (Files.isDirectory(directory, LinkOption.NOFOLLOW_LINKS)) { directoryName = filename; registerAll(directory); // System.out.println("Laget fil og venter i 6 sec."); Thread.sleep(6000); // traverseDirectories(directory.toString()); // System.out.println("Ny mappe er laget på lokajson."+directory); } } else if (kind == ENTRY_DELETE) { System.out.println(kind.name() + " " + directory); } } boolean valid = key.reset(); if (!valid) { System.out.println("ble ikke valid " + valid); keys.remove(key); // all directories are inaccessible if (keys.isEmpty()) { break; } } } }