com.sun.nio.file.SensitivityWatchEventModifier Java Examples

public void monitor(Path directory, Path sourceFile, Runnable action) {
    if (watchService != null) {
        logger(PathsWatcher.class).info("registering action %d for monitoring %s in %s", System.identityHashCode(action), sourceFile, directory);
        Map<String, List<Runnable>> fileAction = filesActions.computeIfAbsent(
                directory.toString(), (p) -> {
                    try {
                        directory.register(watchService, new WatchEvent.Kind[]{ StandardWatchEventKinds.ENTRY_MODIFY, StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_DELETE}, SensitivityWatchEventModifier.HIGH);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    return new HashMap<>();
                });

        List<Runnable> actions = fileAction.computeIfAbsent(sourceFile.toString(), k -> new LinkedList<>());
        actions.add(action);
        logger(PathsWatcher.class).debug("%d CSS modification actions registered for file %s", actions.size(), sourceFile);
    } else {
        logger(PathsWatcher.class).warn("no WatchService active, CSS monitoring cannot occur");
    }
}
 

public JavaWatchObserver(File fileToWatch) throws IOException {
    if (fileToWatch == null || !fileToWatch.exists()) {
        throw new RuntimeException("fileToWatch must not be null and must already exist.");
    }
    this.fileToWatch = fileToWatch;
    lastModified = fileToWatch.lastModified();
    length = fileToWatch.length();

    watchService = FileSystems.getDefault().newWatchService();
    // Note that poll depends on us only registering events that are of type path
    if (OsData.getOsType() != OsData.OsType.MAC) {
        key = fileToWatch.getParentFile().toPath().register(watchService, StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_DELETE,
                StandardWatchEventKinds.ENTRY_MODIFY);
    } else {
        // Unfortunately the default watch service on Mac is broken, it uses a separate thread and really slow polling to detect file changes
        // rather than integrating with the OS. There is a hack to make it poll faster which we can use for now. See
        // http://stackoverflow.com/questions/9588737/is-java-7-watchservice-slow-for-anyone-else
        key = fileToWatch.getParentFile().toPath().register(watchService, new WatchEvent.Kind[]
                {StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_DELETE,
                StandardWatchEventKinds.ENTRY_MODIFY}, SensitivityWatchEventModifier.HIGH);
    }
}
 

public JavaWatchObserver(File fileToWatch) throws IOException {
    if (fileToWatch == null || !fileToWatch.exists()) {
        throw new RuntimeException("fileToWatch must not be null and must already exist.");
    }
    this.fileToWatch = fileToWatch;
    lastModified = fileToWatch.lastModified();
    length = fileToWatch.length();

    watchService = FileSystems.getDefault().newWatchService();
    // Note that poll depends on us only registering events that are of type path
    if (OsData.getOsType() != OsData.OsType.MAC) {
        key = fileToWatch.getParentFile().toPath().register(watchService, StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_DELETE,
                StandardWatchEventKinds.ENTRY_MODIFY);
    } else {
        // Unfortunately the default watch service on Mac is broken, it uses a separate thread and really slow polling to detect file changes
        // rather than integrating with the OS. There is a hack to make it poll faster which we can use for now. See
        // http://stackoverflow.com/questions/9588737/is-java-7-watchservice-slow-for-anyone-else
        key = fileToWatch.getParentFile().toPath().register(watchService, new WatchEvent.Kind[]
                {StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_DELETE,
                StandardWatchEventKinds.ENTRY_MODIFY}, SensitivityWatchEventModifier.HIGH);
    }
}
 

private PollingWatchKey doPrivilegedRegister(Path path,
                                             Set<? extends WatchEvent.Kind<?>> events,
                                             SensitivityWatchEventModifier sensivity)
    throws IOException
{
    // check file is a directory and get its file key if possible
    BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
    if (!attrs.isDirectory()) {
        throw new NotDirectoryException(path.toString());
    }
    Object fileKey = attrs.fileKey();
    if (fileKey == null)
        throw new AssertionError("File keys must be supported");

    // grab close lock to ensure that watch service cannot be closed
    synchronized (closeLock()) {
        if (!isOpen())
            throw new ClosedWatchServiceException();

        PollingWatchKey watchKey;
        synchronized (map) {
            watchKey = map.get(fileKey);
            if (watchKey == null) {
                // new registration
                watchKey = new PollingWatchKey(path, this, fileKey);
                map.put(fileKey, watchKey);
            } else {
                // update to existing registration
                watchKey.disable();
            }
        }
        watchKey.enable(events, sensivity.sensitivityValueInSeconds());
        return watchKey;
    }

}
 

private PollingWatchKey doPrivilegedRegister(Path path,
                                             Set<? extends WatchEvent.Kind<?>> events,
                                             SensitivityWatchEventModifier sensivity)
    throws IOException
{
    // check file is a directory and get its file key if possible
    BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
    if (!attrs.isDirectory()) {
        throw new NotDirectoryException(path.toString());
    }
    Object fileKey = attrs.fileKey();
    if (fileKey == null)
        throw new AssertionError("File keys must be supported");

    // grab close lock to ensure that watch service cannot be closed
    synchronized (closeLock()) {
        if (!isOpen())
            throw new ClosedWatchServiceException();

        PollingWatchKey watchKey;
        synchronized (map) {
            watchKey = map.get(fileKey);
            if (watchKey == null) {
                // new registration
                watchKey = new PollingWatchKey(path, this, fileKey);
                map.put(fileKey, watchKey);
            } else {
                // update to existing registration
                watchKey.disable();
            }
        }
        watchKey.enable(events, sensivity.sensitivityValueInSeconds());
        return watchKey;
    }

}
 

static void register(Path[] dirs, WatchService watcher) throws IOException {
    SensitivityWatchEventModifier[] sensitivtives =
        SensitivityWatchEventModifier.values();
    for (int i=0; i<dirs.length; i++) {
        SensitivityWatchEventModifier sensivity =
            sensitivtives[ rand.nextInt(sensitivtives.length) ];
        Path dir = dirs[i];
        dir.register(watcher, new WatchEvent.Kind<?>[]{ ENTRY_MODIFY }, sensivity);
    }
}
 

private void register(Path cacheDir) throws IOException
{
  WatchKey cacheDirKey = cacheDir.register(
      watcher,
      new WatchEvent.Kind[]{ENTRY_CREATE, ENTRY_MODIFY, ENTRY_DELETE, OVERFLOW},
      SensitivityWatchEventModifier.HIGH);

  watchKeys.put(cacheDirKey, cacheDir);
  log.debug("* Registered " + cacheDir);
}
 

private PollingWatchKey doPrivilegedRegister(Path path,
                                             Set<? extends WatchEvent.Kind<?>> events,
                                             SensitivityWatchEventModifier sensivity)
    throws IOException
{
    // check file is a directory and get its file key if possible
    BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
    if (!attrs.isDirectory()) {
        throw new NotDirectoryException(path.toString());
    }
    Object fileKey = attrs.fileKey();
    if (fileKey == null)
        throw new AssertionError("File keys must be supported");

    // grab close lock to ensure that watch service cannot be closed
    synchronized (closeLock()) {
        if (!isOpen())
            throw new ClosedWatchServiceException();

        PollingWatchKey watchKey;
        synchronized (map) {
            watchKey = map.get(fileKey);
            if (watchKey == null) {
                // new registration
                watchKey = new PollingWatchKey(path, this, fileKey);
                map.put(fileKey, watchKey);
            } else {
                // update to existing registration
                watchKey.disable();
            }
        }
        watchKey.enable(events, sensivity.sensitivityValueInSeconds());
        return watchKey;
    }

}
 

static void register(Path[] dirs, WatchService watcher) throws IOException {
    SensitivityWatchEventModifier[] sensitivtives =
        SensitivityWatchEventModifier.values();
    for (int i=0; i<dirs.length; i++) {
        SensitivityWatchEventModifier sensivity =
            sensitivtives[ rand.nextInt(sensitivtives.length) ];
        Path dir = dirs[i];
        dir.register(watcher, new WatchEvent.Kind<?>[]{ ENTRY_MODIFY }, sensivity);
    }
}
 

private PollingWatchKey doPrivilegedRegister(Path path,
                                             Set<? extends WatchEvent.Kind<?>> events,
                                             SensitivityWatchEventModifier sensivity)
    throws IOException
{
    // check file is a directory and get its file key if possible
    BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
    if (!attrs.isDirectory()) {
        throw new NotDirectoryException(path.toString());
    }
    Object fileKey = attrs.fileKey();
    if (fileKey == null)
        throw new AssertionError("File keys must be supported");

    // grab close lock to ensure that watch service cannot be closed
    synchronized (closeLock()) {
        if (!isOpen())
            throw new ClosedWatchServiceException();

        PollingWatchKey watchKey;
        synchronized (map) {
            watchKey = map.get(fileKey);
            if (watchKey == null) {
                // new registration
                watchKey = new PollingWatchKey(path, this, fileKey);
                map.put(fileKey, watchKey);
            } else {
                // update to existing registration
                watchKey.disable();
            }
        }
        watchKey.enable(events, sensivity.sensitivityValueInSeconds());
        return watchKey;
    }

}
 

static void register(Path[] dirs, WatchService watcher) throws IOException {
    SensitivityWatchEventModifier[] sensitivtives =
        SensitivityWatchEventModifier.values();
    for (int i=0; i<dirs.length; i++) {
        SensitivityWatchEventModifier sensivity =
            sensitivtives[ rand.nextInt(sensitivtives.length) ];
        Path dir = dirs[i];
        dir.register(watcher, new WatchEvent.Kind<?>[]{ ENTRY_MODIFY }, sensivity);
    }
}
 

/**
 * Constructor for DirectoryChangeProcessor
 * @param datastreamTask The datastream task this processor is responsible for
 * @param producer The event producer this connector uses to send change events
 *                 to the underlying {@link com.linkedin.datastream.server.api.transport.TransportProvider}.
 * @throws IOException if an I/O error occurs
 */
public DirectoryChangeProcessor(DatastreamTask datastreamTask, DatastreamEventProducer producer) throws IOException {
  Validate.notNull(datastreamTask);
  Validate.notNull(producer);

  final String path = datastreamTask.getDatastreamSource().getConnectionString();
  Validate.isTrue(isDirectory(path), "path does not refer to a valid directory");

  _task = datastreamTask;
  _producer = producer;
  _dirPath = Paths.get(path);
  _watchService = FileSystems.getDefault().newWatchService();
  _watchKey = _dirPath.register(_watchService, new WatchEvent.Kind<?>[] {ENTRY_CREATE, ENTRY_MODIFY, ENTRY_DELETE},
      SensitivityWatchEventModifier.HIGH);
}
 

private PollingWatchKey doPrivilegedRegister(Path path,
                                             Set<? extends WatchEvent.Kind<?>> events,
                                             SensitivityWatchEventModifier sensivity)
    throws IOException
{
    // check file is a directory and get its file key if possible
    BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
    if (!attrs.isDirectory()) {
        throw new NotDirectoryException(path.toString());
    }
    Object fileKey = attrs.fileKey();
    if (fileKey == null)
        throw new AssertionError("File keys must be supported");

    // grab close lock to ensure that watch service cannot be closed
    synchronized (closeLock()) {
        if (!isOpen())
            throw new ClosedWatchServiceException();

        PollingWatchKey watchKey;
        synchronized (map) {
            watchKey = map.get(fileKey);
            if (watchKey == null) {
                // new registration
                watchKey = new PollingWatchKey(path, this, fileKey);
                map.put(fileKey, watchKey);
            } else {
                // update to existing registration
                watchKey.disable();
            }
        }
        watchKey.enable(events, sensivity.sensitivityValueInSeconds());
        return watchKey;
    }

}
 

static void register(Path[] dirs, WatchService watcher) throws IOException {
    SensitivityWatchEventModifier[] sensitivtives =
        SensitivityWatchEventModifier.values();
    for (int i=0; i<dirs.length; i++) {
        SensitivityWatchEventModifier sensivity =
            sensitivtives[ rand.nextInt(sensitivtives.length) ];
        Path dir = dirs[i];
        dir.register(watcher, new WatchEvent.Kind<?>[]{ ENTRY_MODIFY }, sensivity);
    }
}
 

private PollingWatchKey doPrivilegedRegister(Path path,
                                             Set<? extends WatchEvent.Kind<?>> events,
                                             SensitivityWatchEventModifier sensivity)
    throws IOException
{
    // check file is a directory and get its file key if possible
    BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
    if (!attrs.isDirectory()) {
        throw new NotDirectoryException(path.toString());
    }
    Object fileKey = attrs.fileKey();
    if (fileKey == null)
        throw new AssertionError("File keys must be supported");

    // grab close lock to ensure that watch service cannot be closed
    synchronized (closeLock()) {
        if (!isOpen())
            throw new ClosedWatchServiceException();

        PollingWatchKey watchKey;
        synchronized (map) {
            watchKey = map.get(fileKey);
            if (watchKey == null) {
                // new registration
                watchKey = new PollingWatchKey(path, this, fileKey);
                map.put(fileKey, watchKey);
            } else {
                // update to existing registration
                watchKey.disable();
            }
        }
        watchKey.enable(events, sensivity.sensitivityValueInSeconds());
        return watchKey;
    }

}
 

static void register(Path[] dirs, WatchService watcher) throws IOException {
    SensitivityWatchEventModifier[] sensitivtives =
        SensitivityWatchEventModifier.values();
    for (int i=0; i<dirs.length; i++) {
        SensitivityWatchEventModifier sensivity =
            sensitivtives[ rand.nextInt(sensitivtives.length) ];
        Path dir = dirs[i];
        dir.register(watcher, new WatchEvent.Kind<?>[]{ ENTRY_MODIFY }, sensivity);
    }
}
 

private static void watchForLatchFile(final WatchService watchService, final Path parentDir) {
	try {
		parentDir.register(
			watchService,
			new WatchEvent.Kind[]{StandardWatchEventKinds.ENTRY_CREATE},
			SensitivityWatchEventModifier.HIGH);
	} catch (IOException e) {
		throw new RuntimeException(e);
	}
}
 

@Override
public FileVisitResult postVisitDirectory(Path dir, IOException exc) {
  try {
    //todo investigate BarbaryWatchService for osx... even with the sun package modifier this takes 2 seconds :(
    dir.register(watchers.get(dir.toFile()), new WatchEvent.Kind[]{ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY}, SensitivityWatchEventModifier.HIGH);
  } catch (IOException e) {
    log.error("Failed to register watcher for:" + dir, e);
  }
  return FileVisitResult.CONTINUE;
}
 

private PollingWatchKey doPrivilegedRegister(Path path,
                                             Set<? extends WatchEvent.Kind<?>> events,
                                             SensitivityWatchEventModifier sensivity)
    throws IOException
{
    // check file is a directory and get its file key if possible
    BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
    if (!attrs.isDirectory()) {
        throw new NotDirectoryException(path.toString());
    }
    Object fileKey = attrs.fileKey();
    if (fileKey == null)
        throw new AssertionError("File keys must be supported");

    // grab close lock to ensure that watch service cannot be closed
    synchronized (closeLock()) {
        if (!isOpen())
            throw new ClosedWatchServiceException();

        PollingWatchKey watchKey;
        synchronized (map) {
            watchKey = map.get(fileKey);
            if (watchKey == null) {
                // new registration
                watchKey = new PollingWatchKey(path, this, fileKey);
                map.put(fileKey, watchKey);
            } else {
                // update to existing registration
                watchKey.disable();
            }
        }
        watchKey.enable(events, sensivity.sensitivityValueInSeconds());
        return watchKey;
    }

}
 

private static void watchForLatchFile(final WatchService watchService, final Path parentDir) {
	try {
		parentDir.register(
			watchService,
			new WatchEvent.Kind[]{StandardWatchEventKinds.ENTRY_CREATE},
			SensitivityWatchEventModifier.HIGH);
	} catch (IOException e) {
		throw new RuntimeException(e);
	}
}
 

private PollingWatchKey doPrivilegedRegister(Path path,
                                             Set<? extends WatchEvent.Kind<?>> events,
                                             SensitivityWatchEventModifier sensivity)
    throws IOException
{
    // check file is a directory and get its file key if possible
    BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
    if (!attrs.isDirectory()) {
        throw new NotDirectoryException(path.toString());
    }
    Object fileKey = attrs.fileKey();
    if (fileKey == null)
        throw new AssertionError("File keys must be supported");

    // grab close lock to ensure that watch service cannot be closed
    synchronized (closeLock()) {
        if (!isOpen())
            throw new ClosedWatchServiceException();

        PollingWatchKey watchKey;
        synchronized (map) {
            watchKey = map.get(fileKey);
            if (watchKey == null) {
                // new registration
                watchKey = new PollingWatchKey(path, this, fileKey);
                map.put(fileKey, watchKey);
            } else {
                // update to existing registration
                watchKey.disable();
            }
        }
        watchKey.enable(events, sensivity.sensitivityValueInSeconds());
        return watchKey;
    }

}
 

static void register(Path[] dirs, WatchService watcher) throws IOException {
    SensitivityWatchEventModifier[] sensitivtives =
        SensitivityWatchEventModifier.values();
    for (int i=0; i<dirs.length; i++) {
        SensitivityWatchEventModifier sensivity =
            sensitivtives[ rand.nextInt(sensitivtives.length) ];
        Path dir = dirs[i];
        dir.register(watcher, new WatchEvent.Kind<?>[]{ ENTRY_MODIFY }, sensivity);
    }
}
 

private PollingWatchKey doPrivilegedRegister(Path path,
                                             Set<? extends WatchEvent.Kind<?>> events,
                                             SensitivityWatchEventModifier sensivity)
    throws IOException
{
    // check file is a directory and get its file key if possible
    BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
    if (!attrs.isDirectory()) {
        throw new NotDirectoryException(path.toString());
    }
    Object fileKey = attrs.fileKey();
    if (fileKey == null)
        throw new AssertionError("File keys must be supported");

    // grab close lock to ensure that watch service cannot be closed
    synchronized (closeLock()) {
        if (!isOpen())
            throw new ClosedWatchServiceException();

        PollingWatchKey watchKey;
        synchronized (map) {
            watchKey = map.get(fileKey);
            if (watchKey == null) {
                // new registration
                watchKey = new PollingWatchKey(path, this, fileKey);
                map.put(fileKey, watchKey);
            } else {
                // update to existing registration
                watchKey.disable();
            }
        }
        watchKey.enable(events, sensivity.sensitivityValueInSeconds());
        return watchKey;
    }

}
 

static void register(Path[] dirs, WatchService watcher) throws IOException {
    SensitivityWatchEventModifier[] sensitivtives =
        SensitivityWatchEventModifier.values();
    for (int i=0; i<dirs.length; i++) {
        SensitivityWatchEventModifier sensivity =
            sensitivtives[ rand.nextInt(sensitivtives.length) ];
        Path dir = dirs[i];
        dir.register(watcher, new WatchEvent.Kind<?>[]{ ENTRY_MODIFY }, sensivity);
    }
}
 

private PollingWatchKey doPrivilegedRegister(Path path,
                                             Set<? extends WatchEvent.Kind<?>> events,
                                             SensitivityWatchEventModifier sensivity)
    throws IOException
{
    // check file is a directory and get its file key if possible
    BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
    if (!attrs.isDirectory()) {
        throw new NotDirectoryException(path.toString());
    }
    Object fileKey = attrs.fileKey();
    if (fileKey == null)
        throw new AssertionError("File keys must be supported");

    // grab close lock to ensure that watch service cannot be closed
    synchronized (closeLock()) {
        if (!isOpen())
            throw new ClosedWatchServiceException();

        PollingWatchKey watchKey;
        synchronized (map) {
            watchKey = map.get(fileKey);
            if (watchKey == null) {
                // new registration
                watchKey = new PollingWatchKey(path, this, fileKey);
                map.put(fileKey, watchKey);
            } else {
                // update to existing registration
                watchKey.disable();
            }
        }
        watchKey.enable(events, sensivity.sensitivityValueInSeconds());
        return watchKey;
    }

}
 

static void register(Path[] dirs, WatchService watcher) throws IOException {
    SensitivityWatchEventModifier[] sensitivtives =
        SensitivityWatchEventModifier.values();
    for (int i=0; i<dirs.length; i++) {
        SensitivityWatchEventModifier sensivity =
            sensitivtives[ rand.nextInt(sensitivtives.length) ];
        Path dir = dirs[i];
        dir.register(watcher, new WatchEvent.Kind<?>[]{ ENTRY_MODIFY }, sensivity);
    }
}
 

public void run(){
    isRunning.set(true);

    clearErroredFiles();

    try (final WatchService watchService = FileSystems.getDefault().newWatchService()) {
        final WatchKey watchKey = FileSystems.getDefault().getPath(serverConfiguration.getParentDirectoryPath()).register(watchService, new WatchEvent.Kind[]{StandardWatchEventKinds.ENTRY_CREATE}, SensitivityWatchEventModifier.HIGH);

        while (isRunning.get()) {
            final WatchKey wk = watchService.take();

            for (WatchEvent<?> event : wk.pollEvents()) {
                final Path changed = (Path) event.context();

                if (changed.toFile().getName().startsWith(SCRIPT_ERROR_FILE_PREFIX)) {
                    processError(ErrorFileType.SCRIPT, changed.toFile());
                }
            }
            boolean valid = wk.reset();
            if (!valid) {
                ServerLogger.log(ServerLogger.Level.INFO, TAG, "The watcher key has been unregistered");
            }
        }
    }catch(Exception ex){
        if (isRunning.get()) {
            ServerLogger.error(TAG, "An error occurred while watching for errors. Shutting down!", ex);
            messageServer.shutdown(-1, false);
        }
    }
}
 

static void register(Path[] dirs, WatchService watcher) throws IOException {
    SensitivityWatchEventModifier[] sensitivtives =
        SensitivityWatchEventModifier.values();
    for (int i=0; i<dirs.length; i++) {
        SensitivityWatchEventModifier sensivity =
            sensitivtives[ rand.nextInt(sensitivtives.length) ];
        Path dir = dirs[i];
        dir.register(watcher, new WatchEvent.Kind<?>[]{ ENTRY_MODIFY }, sensivity);
    }
}
 

static void register(Path[] dirs, WatchService watcher) throws IOException {
    SensitivityWatchEventModifier[] sensitivtives =
        SensitivityWatchEventModifier.values();
    for (int i=0; i<dirs.length; i++) {
        SensitivityWatchEventModifier sensivity =
            sensitivtives[ rand.nextInt(sensitivtives.length) ];
        Path dir = dirs[i];
        dir.register(watcher, new WatchEvent.Kind<?>[]{ ENTRY_MODIFY }, sensivity);
    }
}
 

private PollingWatchKey doPrivilegedRegister(Path path,
                                             Set<? extends WatchEvent.Kind<?>> events,
                                             SensitivityWatchEventModifier sensivity)
    throws IOException
{
    // check file is a directory and get its file key if possible
    BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
    if (!attrs.isDirectory()) {
        throw new NotDirectoryException(path.toString());
    }
    Object fileKey = attrs.fileKey();
    if (fileKey == null)
        throw new AssertionError("File keys must be supported");

    // grab close lock to ensure that watch service cannot be closed
    synchronized (closeLock()) {
        if (!isOpen())
            throw new ClosedWatchServiceException();

        PollingWatchKey watchKey;
        synchronized (map) {
            watchKey = map.get(fileKey);
            if (watchKey == null) {
                // new registration
                watchKey = new PollingWatchKey(path, this, fileKey);
                map.put(fileKey, watchKey);
            } else {
                // update to existing registration
                watchKey.disable();
            }
        }
        watchKey.enable(events, sensivity.sensitivityValueInSeconds());
        return watchKey;
    }

}