/** Asynchronous close of watcher causes blocked threads to wakeup */ static void testWakeup(Path dir) throws IOException { System.out.println("-- Wakeup Tests --"); final WatchService watcher = FileSystems.getDefault().newWatchService(); Runnable r = new Runnable() { public void run() { try { Thread.sleep(5000); System.out.println("close WatchService..."); watcher.close(); } catch (InterruptedException x) { x.printStackTrace(); } catch (IOException x) { x.printStackTrace(); } } }; // start thread to close watch service after delay new Thread(r).start(); try { System.out.println("take..."); watcher.take(); throw new RuntimeException("ClosedWatchServiceException not thrown"); } catch (InterruptedException x) { throw new RuntimeException(x); } catch (ClosedWatchServiceException x) { System.out.println("ClosedWatchServiceException thrown"); } System.out.println("OKAY"); }
/** Check that a cancelled key will never be queued */ static void testCancel(Path dir) throws IOException { System.out.println("-- Cancel --"); try (WatchService watcher = FileSystems.getDefault().newWatchService()) { System.out.format("register %s for events\n", dir); WatchKey myKey = dir.register(watcher, new WatchEvent.Kind<?>[] {ENTRY_CREATE}); checkKey(myKey, dir); System.out.println("cancel key"); myKey.cancel(); // create a file in the directory Path file = dir.resolve("mars"); System.out.format("create: %s\n", file); Files.createFile(file); // poll for keys - there will be none System.out.println("poll..."); try { WatchKey key = watcher.poll(3000, TimeUnit.MILLISECONDS); if (key != null) throw new RuntimeException("key should not be queued"); } catch (InterruptedException x) { throw new RuntimeException(x); } // done Files.delete(file); System.out.println("OKAY"); } }
static void takeExpectedKey(WatchService watcher, WatchKey expected) { System.out.println("take events..."); WatchKey key; try { key = watcher.take(); } catch (InterruptedException x) { // not expected throw new RuntimeException(x); } if (key != expected) throw new RuntimeException("removed unexpected key"); }
/** 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() { 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); } }
// 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; } } } }
/** Process all events for keys queued to the watcher */ void processEvents() { for (; ; ) { // 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; } for (WatchEvent<?> event : key.pollEvents()) { WatchEvent.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 System.out.format("%s: %s\n", event.kind().name(), child); // Printing manager if (event.kind().name().equals("ENTRY_MODIFY") && (child.endsWith("baseFerremundoPointer.csv") || child.endsWith("baseFerremundoPointer2.csv"))) { File file = new File(child.toString()); file.renameTo(new File("/home/dios/FERREMUNDO/BD/baseFerremundoPointer_.csv")); InvoicePrintingManager manager = new InvoicePrintingManager(); manager.manage(); } // 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; } } } }
/** * Test that directory can be registered with more than one watch service and that events don't * interfere with each other */ static void testTwoWatchers(Path dir) throws IOException { System.out.println("-- Two watchers test --"); FileSystem fs = FileSystems.getDefault(); WatchService watcher1 = fs.newWatchService(); WatchService watcher2 = fs.newWatchService(); try { Path name1 = fs.getPath("gus1"); Path name2 = fs.getPath("gus2"); // create gus1 Path file1 = dir.resolve(name1); System.out.format("create %s\n", file1); Files.createFile(file1); // register with both watch services (different events) System.out.println("register for different events"); WatchKey key1 = dir.register(watcher1, new WatchEvent.Kind<?>[] {ENTRY_CREATE}); WatchKey key2 = dir.register(watcher2, new WatchEvent.Kind<?>[] {ENTRY_DELETE}); if (key1 == key2) throw new RuntimeException("keys should be different"); // create gus2 Path file2 = dir.resolve(name2); System.out.format("create %s\n", file2); Files.createFile(file2); // check that key1 got ENTRY_CREATE takeExpectedKey(watcher1, key1); checkExpectedEvent(key1.pollEvents(), StandardWatchEventKinds.ENTRY_CREATE, name2); // check that key2 got zero events WatchKey key = watcher2.poll(); if (key != null) throw new RuntimeException("key not expected"); // delete gus1 Files.delete(file1); // check that key2 got ENTRY_DELETE takeExpectedKey(watcher2, key2); checkExpectedEvent(key2.pollEvents(), StandardWatchEventKinds.ENTRY_DELETE, name1); // check that key1 got zero events key = watcher1.poll(); if (key != null) throw new RuntimeException("key not expected"); // reset for next test key1.reset(); key2.reset(); // change registration with watcher2 so that they are both // registered for the same event System.out.println("register for same event"); key2 = dir.register(watcher2, new WatchEvent.Kind<?>[] {ENTRY_CREATE}); // create file and key2 should be queued System.out.format("create %s\n", file1); Files.createFile(file1); takeExpectedKey(watcher2, key2); checkExpectedEvent(key2.pollEvents(), StandardWatchEventKinds.ENTRY_CREATE, name1); System.out.println("OKAY"); } finally { watcher2.close(); watcher1.close(); } }
/** Simple test to check exceptions and other cases */ @SuppressWarnings("unchecked") static void testExceptions(Path dir) throws IOException { System.out.println("-- Exceptions and other simple tests --"); WatchService watcher = FileSystems.getDefault().newWatchService(); try { // Poll tests WatchKey key; System.out.println("poll..."); key = watcher.poll(); if (key != null) throw new RuntimeException("no keys registered"); System.out.println("poll with timeout..."); try { long start = System.currentTimeMillis(); key = watcher.poll(3000, TimeUnit.MILLISECONDS); if (key != null) throw new RuntimeException("no keys registered"); long waited = System.currentTimeMillis() - start; if (waited < 2900) throw new RuntimeException("poll was too short"); } catch (InterruptedException x) { throw new RuntimeException(x); } // IllegalArgumentException System.out.println("IllegalArgumentException tests..."); try { dir.register(watcher, new WatchEvent.Kind<?>[] {}); throw new RuntimeException("IllegalArgumentException not thrown"); } catch (IllegalArgumentException x) { } try { // OVERFLOW is ignored so this is equivalent to the empty set dir.register(watcher, new WatchEvent.Kind<?>[] {OVERFLOW}); throw new RuntimeException("IllegalArgumentException not thrown"); } catch (IllegalArgumentException x) { } // UnsupportedOperationException try { dir.register( watcher, new WatchEvent.Kind<?>[] { new WatchEvent.Kind<Object>() { @Override public String name() { return "custom"; } @Override public Class<Object> type() { return Object.class; } } }); } catch (UnsupportedOperationException x) { } try { dir.register( watcher, new WatchEvent.Kind<?>[] {ENTRY_CREATE}, new WatchEvent.Modifier() { @Override public String name() { return "custom"; } }); throw new RuntimeException("UnsupportedOperationException not thrown"); } catch (UnsupportedOperationException x) { } // NullPointerException System.out.println("NullPointerException tests..."); try { dir.register(null, new WatchEvent.Kind<?>[] {ENTRY_CREATE}); throw new RuntimeException("NullPointerException not thrown"); } catch (NullPointerException x) { } try { dir.register(watcher, new WatchEvent.Kind<?>[] {null}); throw new RuntimeException("NullPointerException not thrown"); } catch (NullPointerException x) { } try { dir.register(watcher, new WatchEvent.Kind<?>[] {ENTRY_CREATE}, (WatchEvent.Modifier) null); throw new RuntimeException("NullPointerException not thrown"); } catch (NullPointerException x) { } } finally { watcher.close(); } // -- ClosedWatchServiceException -- System.out.println("ClosedWatchServiceException tests..."); try { watcher.poll(); throw new RuntimeException("ClosedWatchServiceException not thrown"); } catch (ClosedWatchServiceException x) { } // assume that poll throws exception immediately long start = System.currentTimeMillis(); try { watcher.poll(10000, TimeUnit.MILLISECONDS); throw new RuntimeException("ClosedWatchServiceException not thrown"); } catch (InterruptedException x) { throw new RuntimeException(x); } catch (ClosedWatchServiceException x) { long waited = System.currentTimeMillis() - start; if (waited > 5000) throw new RuntimeException("poll was too long"); } try { watcher.take(); throw new RuntimeException("ClosedWatchServiceException not thrown"); } catch (InterruptedException x) { throw new RuntimeException(x); } catch (ClosedWatchServiceException x) { } try { dir.register(watcher, new WatchEvent.Kind<?>[] {ENTRY_CREATE}); throw new RuntimeException("ClosedWatchServiceException not thrown"); } catch (ClosedWatchServiceException x) { } System.out.println("OKAY"); }