java.nio.file.WatchService Java Examples

public WatchServiceHolder(TaskServiceImpl taskServiceImpl){
	logger = LoggerFactory.getLogger(getClass());
	taskService = taskServiceImpl;
	
	incurredTasks = Collections.synchronizedMap(new HashMap<WatchKey, ITaskDescriptor>());
	
	WatchService initWatchService;
	try {
		initWatchService = FileSystems.getDefault().newWatchService();
	} catch (IOException ioe) {
		initWatchService = null;
		logger.error(
			"Error instantiating WatchService, filesystem events will not be picked up.", ioe);
	}
	watchService = initWatchService;
	
	pollerThread = new WatchServicePoller();
}
 

/**
 * Wait until a PubSub emulator configuration file is updated.
 * Fail if the file does not update after 1 second.
 * @param watchService the watch-service to poll
 * @throws InterruptedException which should interrupt the peaceful slumber and bubble up
 * to fail the test.
 */
private void updateConfig(WatchService watchService) throws InterruptedException {
	int attempts = 10;
	while (--attempts >= 0) {
		WatchKey key = watchService.poll(100, TimeUnit.MILLISECONDS);

		if (key != null) {
			Optional<Path> configFilePath = key.pollEvents().stream()
					.map((event) -> (Path) event.context())
					.filter((path) -> ENV_FILE_NAME.equals(path.toString()))
					.findAny();
			if (configFilePath.isPresent()) {
				return;
			}
		}
	}

	fail("Configuration file update could not be detected");
}
 

/**
 * Ensures that a modified or deleted cached files does not stay in the cache
 */
private void processFolderEvents(final WatchService watchService) {
    WatchKey key = watchService.poll();
    if (key != null) {
        for (WatchEvent<?> e : key.pollEvents()) {
            if (e.kind() == OVERFLOW) {
                continue;
            }

            // Context for directory entry event is the file name of entry
            @SuppressWarnings("unchecked")
            WatchEvent<Path> ev = (WatchEvent<Path>) e;
            Path path = ev.context();

            logger.debug("Refreshing transformation file '{}'", path);

            for (String fileEntry : cachedFiles.keySet()) {
                if (fileEntry.endsWith(path.toString())) {
                    cachedFiles.remove(fileEntry);
                }
            }
        }
        key.reset();
    }
}
 

/**
 * Stress the given WatchService, specifically the cancel method, in
 * the given directory. Closes the WatchService when done.
 */
static void handle(Path dir, WatchService watcher) {
    try {
        try {
            Path file = dir.resolve("anyfile");
            for (int i=0; i<2000; i++) {
                WatchKey key = dir.register(watcher, ENTRY_CREATE, ENTRY_DELETE);
                Files.createFile(file);
                Files.delete(file);
                key.cancel();
            }
        } finally {
            watcher.close();
        }
    } catch (Exception e) {
        e.printStackTrace();
        failed = true;
    }
}
 

/**
 * Stress the given WatchService, specifically the cancel method, in
 * the given directory. Closes the WatchService when done.
 */
static void handle(Path dir, WatchService watcher) {
    try {
        try {
            Path file = dir.resolve("anyfile");
            for (int i=0; i<2000; i++) {
                WatchKey key = dir.register(watcher, ENTRY_CREATE, ENTRY_DELETE);
                Files.createFile(file);
                Files.delete(file);
                key.cancel();
            }
        } finally {
            watcher.close();
        }
    } catch (Exception e) {
        e.printStackTrace();
        failed = true;
    }
}
 

public static void main(String[] args) throws IOException, InterruptedException {
	Path tmpDir = Paths.get("tmp");
	WatchService watchService = FileSystems.getDefault().newWatchService();
	Path monitoredFolder = tmpDir;
	monitoredFolder.register(watchService, StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_DELETE);
	
	tmpDir.toFile().mkdirs();
	new FileChanger(tmpDir).start();
	while (true) {
		System.out.println("Waiting for event");
		WatchKey watchKey = watchService.take();
		for (WatchEvent<?> event : watchKey.pollEvents()) {
			System.out.println("Detected event " + event.kind().name() + " on file " + event.context().toString());
		}
		watchKey.reset();
	}
}
 

/**
 * Stress the given WatchService, specifically the cancel method, in
 * the given directory. Closes the WatchService when done.
 */
static void handle(Path dir, WatchService watcher) {
    try {
        try {
            Path file = dir.resolve("anyfile");
            for (int i=0; i<2000; i++) {
                WatchKey key = dir.register(watcher, ENTRY_CREATE, ENTRY_DELETE);
                Files.createFile(file);
                Files.delete(file);
                key.cancel();
            }
        } finally {
            watcher.close();
        }
    } catch (Exception e) {
        e.printStackTrace();
        failed = true;
    }
}
 

/**
 * Stress the given WatchService, specifically the cancel method, in
 * the given directory. Closes the WatchService when done.
 */
static void handle(Path dir, WatchService watcher) {
    try {
        try {
            Path file = dir.resolve("anyfile");
            for (int i=0; i<2000; i++) {
                WatchKey key = dir.register(watcher, ENTRY_CREATE, ENTRY_DELETE);
                Files.createFile(file);
                Files.delete(file);
                key.cancel();
            }
        } finally {
            watcher.close();
        }
    } catch (Exception e) {
        e.printStackTrace();
        failed = true;
    }
}
 

public void start() throws IOException {
    if (existsAndReadyCheck()) {
        return;
    }

    WatchService watcher = FileSystems.getDefault().newWatchService();
    Path pathToWatch = FileSystems.getDefault().getPath(fileToWatch.getParent());
    register(watcher, pathToWatch);

    try {
        LOG.info(String.format("Migration File Watcher: Watching: %s", fileToWatch.toString()));
        startWatching(watcher);
    } catch (InterruptedException ex) {
        LOG.error("Migration File Watcher: Interrupted!");
    } finally {
        watcher.close();
    }
}
 

@Override
public void run() {
    WatchService watchService = WatchServiceUtil.watchModify(pluginDir);
    WatchKey key;
    while (watchService != null){
        try {
            key = watchService.take();
            for (WatchEvent<?> watchEvent : key.pollEvents()) {
                if(watchEvent.kind() == ENTRY_MODIFY){
                    String fileName = watchEvent.context() == null ? "" : watchEvent.context().toString();
                    Plugin plugin = PluginLibraryHelper.getPluginByConfigFileName(fileName);
                    if(plugin != null){
                        plugin.init(PluginLibraryHelper.getPluginConfig(plugin));
                        log.info("已完成插件{}的配置重新加载",plugin.pluginName());
                    }
                }
            }
            key.reset();
        } catch (Exception e) {
            log.error("插件配置文件监听异常",e);
            break;
        }
    }
}
 

/**
 * Stress the given WatchService, specifically the cancel method, in
 * the given directory. Closes the WatchService when done.
 */
static void handle(Path dir, WatchService watcher) {
    try {
        try {
            Path file = dir.resolve("anyfile");
            for (int i=0; i<2000; i++) {
                WatchKey key = dir.register(watcher, ENTRY_CREATE, ENTRY_DELETE);
                Files.createFile(file);
                Files.delete(file);
                key.cancel();
            }
        } finally {
            watcher.close();
        }
    } catch (Exception e) {
        e.printStackTrace();
        failed = true;
    }
}
 

private void createWatchService() {
    try {
        WatchService watchService = FileSystems.getDefault().newWatchService();

        WatchKey trustedKey = trustedDir.toPath().register(
                watchService,
                StandardWatchEventKinds.ENTRY_CREATE,
                StandardWatchEventKinds.ENTRY_DELETE,
                StandardWatchEventKinds.ENTRY_MODIFY
        );

        Thread thread = new Thread(new Watcher(watchService, trustedKey));
        thread.setName("ua-certificate-directory-watcher");
        thread.setDaemon(true);
        thread.start();
    } catch (IOException e) {
        logger.error("Error creating WatchService.", e);
    }
}
 

private synchronized WatchService getWatchService() throws TransformationException {
    WatchService watchService = this.watchService;
    if (watchService != null) {
        return watchService;
    }

    try {
        watchService = this.watchService = FileSystems.getDefault().newWatchService();
    } catch (IOException e) {
        logger.error("Unable to start transformation directory monitoring");
        throw new TransformationException("Cannot get a new watch service.");
    }

    watchSubDirectory("", watchService);
    return watchService;
}
 

public PhotatoFilesManager(Path rootFolder, FileSystem fileSystem, IMetadataAggregator metadataGetter, IThumbnailGenerator thumbnailGenerator, IFullScreenImageGetter fullScreenImageGetter, boolean prefixOnlyMode, boolean indexFolderName, boolean useParallelPicturesGeneration) throws IOException {
    this.fileSystem = fileSystem;
    this.metadataAggregator = metadataGetter;
    this.thumbnailGenerator = thumbnailGenerator;
    this.fullScreenImageGetter = fullScreenImageGetter;
    this.rootFolder = new PhotatoFolder(rootFolder, rootFolder);
    this.searchManager = new SearchManager(prefixOnlyMode, indexFolderName);
    this.albumsManager = new AlbumsManager();
    this.prefixOnlyMode = prefixOnlyMode;
    this.useParallelPicturesGeneration = useParallelPicturesGeneration;

    WatchService watcher = this.fileSystem.newWatchService();
    this.watchedDirectoriesKeys = new HashMap<>();
    this.watchedDirectoriesPaths = new HashMap<>();
    this.runInitialFolderExploration(watcher, this.rootFolder);
    this.watchServiceThread = new WatchServiceThread(watcher);
    this.watchServiceThread.start();
}
 

@Before
public void setUp() throws Exception {
    mockWatchService = Mockito.mock(WatchService.class);
    notifierSpy = Mockito.spy(new FileChangeIngestor());
    mockDifferentiator = Mockito.mock(Differentiator.class);
    testNotifier = Mockito.mock(ConfigurationChangeNotifier.class);

    notifierSpy.setConfigFilePath(Paths.get(TEST_CONFIG_PATH));
    notifierSpy.setWatchService(mockWatchService);
    notifierSpy.setDifferentiator(mockDifferentiator);
    notifierSpy.setConfigurationChangeNotifier(testNotifier);

    testProperties = new Properties();
    testProperties.put(FileChangeIngestor.CONFIG_FILE_PATH_KEY, TEST_CONFIG_PATH);
    testProperties.put(FileChangeIngestor.POLLING_PERIOD_INTERVAL_KEY, FileChangeIngestor.DEFAULT_POLLING_PERIOD_INTERVAL);
}
 

public void watch() throws InterruptedException, IOException {
    try {
        final Path directoryPath = file.toPath().getParent();
        final WatchService watchService = FileSystems.getDefault().newWatchService();
        directoryPath.register(watchService, StandardWatchEventKinds.ENTRY_MODIFY);
        while (true) {
            final WatchKey wk = watchService.take();
            for (WatchEvent<?> event : wk.pollEvents()) {
                final Path fileChangedPath = (Path) event.context();
                if (fileChangedPath.endsWith(file.getName())) {
                    onModified();
                }
            }
            wk.reset();
        }
    } catch (Exception e) {
        logger.error("exception when handling change of mock file: {}", e.getMessage());
    }
}
 

public void simpleTest(Path path) throws Exception
{
	WatchService watchService=FileSystems.getDefault().newWatchService();  
	path.register(watchService,   
            StandardWatchEventKinds.ENTRY_CREATE,  
            StandardWatchEventKinds.ENTRY_DELETE,  
            StandardWatchEventKinds.ENTRY_MODIFY);  
    while(true)  
    {  
        WatchKey watchKey=watchService.take();  
           List<WatchEvent<?>> watchEvents = watchKey.pollEvents();  
           for(WatchEvent<?> event : watchEvents){  
               //TODO 根据事件类型采取不同的操作。。。。。。。  
               System.out.println("["+event.context()+"]文件发生了["+event.kind()+"]事件");    
           }  
           watchKey.reset(); 
    } 
}
 

/** {@inheritDoc} */
@Override
public WatchKey register( WatchService watcher, Kind<?>[] events, Modifier... modifiers ) throws IOException {
    if ( watcher == null ) {
        throw new NullPointerException();
    }
    if ( !(watcher instanceof UnixSshFileSystemWatchService) ) {
        throw new ProviderMismatchException();
    }
    if ( !getFileSystem().provider().readAttributes( this, BasicFileAttributes.class ).isDirectory() ) {
        throw new NotDirectoryException( this.toString() );
    }
    getFileSystem().provider().checkAccess( this, AccessMode.READ );
    return ((UnixSshFileSystemWatchService) watcher).register( this, events, modifiers );
}
 

public void run() {

        log.info("Running configuration updater..");
        String configFilePath = CellStsUtils.getConfigFilePath();
        Path directoryPath = Paths.get(configFilePath.substring(0, configFilePath.lastIndexOf("/")));
        try {
            while (true) {
                WatchService watcher = directoryPath.getFileSystem().newWatchService();
                directoryPath.register(watcher, StandardWatchEventKinds.ENTRY_CREATE,
                        StandardWatchEventKinds.ENTRY_DELETE, StandardWatchEventKinds.ENTRY_MODIFY);

                log.debug("Waiting for config file change");
                WatchKey watckKey = watcher.take();

                List<WatchEvent<?>> events = watckKey.pollEvents();
                log.debug("Received events: ....");
                for (WatchEvent event : events) {
                    if (event.kind() == StandardWatchEventKinds.ENTRY_CREATE) {
                        log.info("Updating file on {} event", StandardWatchEventKinds.ENTRY_CREATE);
                        CellStsUtils.buildCellStsConfiguration();
                        CellStsUtils.readUnsecuredContexts();
                    }
                    if (event.kind() == StandardWatchEventKinds.ENTRY_MODIFY) {
                        log.info("Updating file on {} event", StandardWatchEventKinds.ENTRY_MODIFY);
                        CellStsUtils.buildCellStsConfiguration();
                        CellStsUtils.readUnsecuredContexts();
                    }
                }

            }
        } catch (IOException | InterruptedException | CelleryCellSTSException e) {
            log.error("Error while updating configurations on file change ", e);
        }
    }
 

protected void watcherPid(final File pidFile) throws IOException {
    final WatchService watcher = FileSystems.getDefault().newWatchService();
    final Path path = Paths.get(".");
    path.register(watcher, StandardWatchEventKinds.ENTRY_DELETE);

    Executors.newFixedThreadPool(1, (runnable) -> {
        final Thread tomcat = new Thread(runnable);
        tomcat.setName("Tomcat PID Watcher: " + System.currentTimeMillis());
        return tomcat;
    }).execute(() -> {
        try {
            for (;;) {
                final WatchKey watchKey = watcher.take();
                final List<WatchEvent<?>> events = watchKey.pollEvents();
                for (WatchEvent<?> event : events) {
                    final String fileName = ((Path) event.context()).toFile().getAbsolutePath();
                    if (pidFile.getAbsolutePath().equals(fileName)) {
                        LOGGER.info("tomcat.pid已被删除，应用进入退出流程");
                        System.exit(0);
                    }
                }

                watchKey.reset();
            }
        } catch (final InterruptedException e) {
            LOGGER.info("Stoped File Watcher");
        }
    });
}
 

@Test
@Ignore
public void newWatchService() throws IOException {
  Path pathToTest = Paths.get(clusterUri);
  WatchService ws = pathToTest.getFileSystem().newWatchService();
  Assert.assertNotNull(ws);
}
 

private void awaitLatchFile(final WatchService watchService) throws InterruptedException {
	while (true) {
		WatchKey watchKey = watchService.take();
		if (isReleasedOrReleasable()) {
			break;
		}
		watchKey.reset();
	}
}
 

private static void openAndCloseWatcher(Path dir) {
    FileSystem fs = FileSystems.getDefault();
    for (int i = 0; i < ITERATIONS_COUNT; i++) {
        try (WatchService watcher = fs.newWatchService()) {
            dir.register(watcher, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);
        } catch (IOException ioe) {
            // ignore
        }
    }
}
 

private void watchSubDirectory(String subDirectory, final WatchService watchService) {
    if (watchedDirectories.indexOf(subDirectory) == -1) {
        String watchedDirectory = getSourcePath() + subDirectory;
        Path transformFilePath = Paths.get(watchedDirectory);
        try {
            transformFilePath.register(watchService, ENTRY_DELETE, ENTRY_MODIFY);
            logger.debug("Watching directory {}", transformFilePath);
            watchedDirectories.add(subDirectory);
        } catch (IOException e) {
            logger.warn("Unable to watch transformation directory : {}", watchedDirectory);
            cachedFiles.clear();
        }
    }
}
 

@Test
public void testPollingConfig() {
  WatchServiceConfiguration polling = WatchServiceConfiguration.polling(50, MILLISECONDS);
  WatchService watchService = polling.newWatchService(fs.getDefaultView(), fs.getPathService());
  assertThat(watchService).isInstanceOf(PollingWatchService.class);

  PollingWatchService pollingWatchService = (PollingWatchService) watchService;
  assertThat(pollingWatchService.interval).isEqualTo(50);
  assertThat(pollingWatchService.timeUnit).isEqualTo(MILLISECONDS);
}
 

private static WatchService createWatchService(final Path parentDir) {
	try {
		return parentDir.getFileSystem().newWatchService();
	} catch (IOException e) {
		throw new RuntimeException(e);
	}
}
 

public void watch() {
   final WatchService watcher; 
   if (watchDir == null) {
      return;
   }
   try {
      watcher = FileSystems.getDefault().newWatchService();
      watchDir.register(watcher, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);
      logger.trace("Watching driver directory [{}]", watchDir);
   } catch (IOException ex) {
      logger.error("Could not register watcher for driver directory [{}]", watchDir);
      return;
   }
   
   executor.submit(new Runnable() {
      @Override
      public void run() {
         while (true) {
            WatchKey key = null;
            try {
               key = watcher.take();
            } catch (InterruptedException e) {
               logger.error("Interrupted Exception encountered [{}]", e);
            }
            if (key != null) {
               if (key.pollEvents().size() > 0) {
                  // Something has changed. That's all we need to know.
                  for (DriverWatcherListener listener : listeners) {
                     listener.onChange();
                  }
               }
               boolean isValid = key.reset();
               if (!isValid) {
                  logger.error("Unable to watch driver directory. Watcher key invalid.");
               }
            }
         }
      }
   });
}
 

private static void openAndCloseWatcher(Path dir) {
    FileSystem fs = FileSystems.getDefault();
    for (int i = 0; i < ITERATIONS_COUNT; i++) {
        try (WatchService watcher = fs.newWatchService()) {
            dir.register(watcher, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);
        } catch (IOException ioe) {
            // ignore
        }
    }
}
 

public LogSearchConfigLocalUpdater(final Path path, final WatchService watchService,
                                   final InputConfigMonitor inputConfigMonitor, final Map<String, String> inputFileContentsMap,
                                   final JsonParser parser, final JsonArray globalConfigNode, final Pattern serviceNamePattern) {
  this.path = path;
  this.watchService = watchService;
  this.inputConfigMonitor = inputConfigMonitor;
  this.inputFileContentsMap = inputFileContentsMap;
  this.parser = parser;
  this.globalConfigNode = globalConfigNode;
  this.serviceNamePattern = serviceNamePattern;
}
 

private void process () throws IOException
{
    logger.warn ( "Start watching: {}", this.path );

    try ( final WatchService watcher = this.path.getFileSystem ().newWatchService () )
    {
        this.path.register ( watcher, ENTRY_CREATE, ENTRY_MODIFY, ENTRY_DELETE );

        processExisting ( this.path );

        for ( ;; )
        {
            WatchKey key;
            try
            {
                key = watcher.take ();
            }
            catch ( final InterruptedException e )
            {
                return;
            }

            for ( final WatchEvent<?> event : key.pollEvents () )
            {
                logger.debug ( "Handle event: {} - {}", event.kind (), event.context () );
                handleEvent ( event );
            }

            if ( !key.reset () )
            {
                throw new RuntimeException ( "Key got cancelled" );
            }
        }
    }
}