Keep track of file name changes

[Marco Zanini]

Hi to all, my programs watches a directory for changes using features provided in Java 7. I am able to keep track of a Directory changing it's name but I'm not able to do it on a File.

This is the code:

 public class WatchDog implements Runnable{
	
	private boolean run;
	private WatchService watcher;
	private Path baseDir;
	//Do we want to keep track of changes?
	private boolean trace;
	private HashMap<WatchKey,Path> keys;
	
	private DingoServer hs;
	
	public WatchDog(DingoServer hs, Path baseDir) throws InstantiationException 
	{
		this.baseDir = baseDir;
		System.out.println("[WD] The base directory is: " + this.baseDir);
		this.keys = new HashMap<WatchKey, Path>();
		
		this.run = true;
	}
	
	public void run() {
		System.out.println("[WD] Starting...");
		this.watchChanges();
		
		while (this.run)
		{
			synchronized(this){
				try {
					this.wait();
				} catch (InterruptedException e) {
					e.printStackTrace(); 
					System.out.println("[WD] Interrupted"); 
					return;
				}
			}
		}	
		System.out.println("[WD] Shutting down.");
	}
	
	//Recursively register baseDir then look for changes
	private void watchChanges(){
		System.out.println("[WD] Watching directory " + this.baseDir + " for changes");
		this.watcher = null;
		System.out.println("[WD] Initializing watcher...");
		try {
			watcher = FileSystems.getDefault().newWatchService();
		} catch (IOException e) {e.printStackTrace();}
		if(watcher==null){
			System.out.println("[WD] Ops something went wrong: watcher is null!");
			return;
		}
		
		try {
			this.registerAll(this.baseDir);
		} catch (IOException e) {e.printStackTrace();}
		
		//Enable trace after initial registration
		this.trace = true;
		
		//Infinite Loop! Must exit manually!
		while (this.run) {
			//wait for key to be signaled
		    WatchKey key;
		    try {
			key = watcher.take();
		    } catch (InterruptedException x) {return;}
		    
		    Path dir = keys.get(key);
            if (dir == null) {
                System.out.println("WatchKey not recognized!!");
                continue;
            }

		    for (WatchEvent<?> event: key.pollEvents()) {
				WatchEvent.Kind<?> kind = event.kind();
				WatchEvent<Path> ev = cast(event);
				Path filename = ev.context();
	
				if (kind == ENTRY_CREATE) {
					if(Files.isDirectory(filename)){
						System.out.println("[WD] New directory created:" + filename.getRoot());
						try {
							this.register(filename);
						} catch (IOException e) { e.printStackTrace(); }
						this.hs.fileChanged(filename, CommandProtocol.MESSAGE_DIRECTORY_ADDED);
					}
					else {
						System.out.println("[WD] New file created:" + filename.toString());
						this.hs.fileChanged(filename, CommandProtocol.MESSAGE_FILE_ADDED);
					}					
				    continue;
				}
				if (kind == ENTRY_DELETE) {
					if(Files.isDirectory(filename)){
						System.out.println("[WD] Directory deleted:" + filename.toString());
						this.hs.fileChanged(filename, CommandProtocol.MESSAGE_DIRECTORY_DELETED);
					}
					else { 
						System.out.println("[WD] File deleted:" + filename.toString());
						this.hs.fileChanged(filename, CommandProtocol.MESSAGE_FILE_DELETED);
					}
				    continue;
				}
				if (kind == ENTRY_MODIFY) {
					if(Files.isDirectory(filename)){
						System.out.println("[WD] Directory modified:" + filename.toString());
						try {
							this.register(filename);
						} catch (IOException e) { e.printStackTrace(); }
						this.hs.fileChanged(filename, CommandProtocol.MESSAGE_DIRECTORY_CHANGED);
					}
					else { 
						System.out.println("[WD] File modified:" + filename.toString());
						this.hs.fileChanged(filename, CommandProtocol.MESSAGE_FILE_CHANGED);
					}
				    continue;
				}
				if (kind == OVERFLOW) {
					System.out.println("[WD] Ops, maybe I lost some events!");
				    continue;
				}
				
		    }
	
		    //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) {
                keys.remove(key);
                // all directories are inaccessible
                if (keys.isEmpty()) {
                    break;
                }
            }
		    
		}
	}
	
	
    /**Register the given directory, and all its sub-directories, with the
     * WatchService.
     * 
     * @param start Root path to start from
     * @throws IOException
     */
    private void registerAll(final Path start) throws IOException {
        // register directory and sub-directories
    	SimpleFileVisitor<Path> directoryRegister = new SimpleFileVisitor<Path>() {
    		@Override
    		public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attr) throws IOException {
    			System.out.println("[WD] Calling register...");
    			register(dir); 
    			return FileVisitResult.CONTINUE; 
    		}
    	};
    	
    	System.out.println("[WD] Calling walkFileTree...");
    	Files.walkFileTree(start, directoryRegister); 
    }

    /**Register the given directory with the WatchService
     * 
     * @param dir Absolute Path of the directory to register
     * @throws IOException
     */
    private void register(Path dir) throws IOException {
    	if(watcher==null) System.out.println("[WD] Ops something went wrong: watcher is null!");
        
    	WatchKey key = dir.register(watcher, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);
        //Code to trace the previous name
        if (trace) {
            Path prev = keys.get(key);
            if (prev == null) {
                System.out.println("[WD] Registering new directory: " + dir);
            } else {
                if (!dir.equals(prev)) {
                    System.out.format("Update registration: from " + prev + " to " + dir);
                }
            }
        }
        keys.put(key, dir);
    }
    
	@SuppressWarnings("unchecked")
	private static WatchEvent<Path> cast(WatchEvent<?> event) {
	    return (WatchEvent<Path>)event;
	}
	
	//Method to stop the thread
    public void shutdown() {
    	this.run = false;
    	
    	synchronized (this){
			this.notifyAll();
		}
    }
    
}

Do you think I simply need to register every single file in addition to every directory?