The ULTIMATE! From the creator of FileMonitor comes DirectoryMonitor :)

[Ivan Jouikov]

Hey everyone!

I just finished working on the greatest thing of all times: DirectoryMonitor. This bad boy can monitor your entire file system (all you have to do is set it on your "/" or "C:/" (with my 35GB full of stuff and 1.7 ghz Java runs at 80% CPU (using 1 second checks that is) )...

Check out these bad boys:

This file demonstrates how you would use directory monitoring:

 /*
 * Created on 22.06.2004 at 15:25:21
 * Author: Ivan Jouikov ([e-mail])
 * Project: abLogic
 */
package org.ablogic.misc;
 
import java.io.File;
 

/**
 * 
 * @author Ivan Jouikov ([e-mail])
 */
public class FileReloaderTest implements FileChangeListener
{
 
public FileReloaderTest() throws Exception
{
FileMonitor.getInstance().addFileChangeListener(this, new File("C:/Documents and Settings/SysOp/My Documents/AB LOGIC/Eclipse Workspace/ivan1/"));
while(true)Thread.sleep(1000);
}

public static void main( String args[] ) throws Exception
{
new FileReloaderTest();
}

public void fileModified(FileChangeEvent event)
{
System.out.println("FILERELOADERTEST:\n" + event + "\n");
}
 
}
 

This file is the FileMonitor - Directory Monitor itself, all 418 lines of it ...

 /*
 * Created on 21.06.2004 at 13:27:31
 * Author: Ivan Jouikov ([e-mail])
 * Project: abLogic
 */
package org.ablogic.misc;
 
import java.io.*;
import java.util.*;
 
/**
 * This class will be used to monitor files, and notify their listeners
 * if those files were modified.
 * 
 * It will run as a daemon (taking advantage of {@link java.util.Timer Timer} class,
 * and watch specified files at specified (or default) intervals, notifiying the 
 * listener whenever a change has been made.
 * 
 * 22.06.2004: Converted it into a singleton, so you could extend it.
 * FileChangeListeners should now implement equals() and hashCode(), because
 * FileInfo has been modified to do comparison using equals(), rather than 
 * compare by reference.  Also, FileInfo now uses a Set rather than List to 
 * store all the FileChangeListeners.  Also, fixed a whole bunch of bugs
 * 
 * 23.06.2004: Now when you add listeners to listen to a file, which is a directory, 
 * you will be updated of changes made to the entire directory, such as: file added,
 * file removed, file modified (not the directory itself, some file in it).
 * 
 * @author Ivan Jouikov ([e-mail])
 */
public class FileMonitor
{
/** Determines if we are debugging or not. */
public static boolean DEBUG = false;

/** This determines how often files will be checked to see if they have been
 * modified or not.  This applies to ALL files.  In milliseconds.
 */
public static long checkInterval = 1000;

// Method used for debugging
void debug( String text )
{
if ( DEBUG )
{
// Get the stack element from the PREVIOUS method, not this one.
StackTraceElement where = new Exception().getStackTrace()[1];
System.out.println("[DEBUG " + where.getFileName() + "#" + where.getLineNumber() + "]: " + text);
}
}

// This is the one and only instance of the FileMonitor which will handle everything
static protected FileMonitor instance;

// This is the bckg thread that will be watching over everything.
protected Timer daemon;

// This is where all the fileInfos will be stored.
// Keys will be files themselves; values will be FileInfo's
protected Map fileMap;

protected FileMonitor()
{
fileMap = Collections.synchronizedMap( new HashMap() );
daemon = new Timer(true); // run as daemon
debug("Starting up the daemon...");
daemon.schedule( new FileListenerTask(), new Date( System.currentTimeMillis() + 1000 ), checkInterval );
}

/**
 * Returns the one and only instance of the FileMonitor.
 * @return Static instance that will watch ALL (specified) files.
 */
public static FileMonitor getInstance()
{
if ( instance == null ) instance = new FileMonitor();
return instance;
}

/**
 * Whenever one of the given files has been modified, the given FileChangeListener 
 * will be notified.
 * @param listener Class that will be notified of any changes.
 * @param files List of files to be monitored.
 * @throws FileNotFoundException If any of the files don't exist or can't be found.
 */
public void addFileChangeListener( FileChangeListener listener, File [] files ) throws FileNotFoundException
{
for ( int i = 0; i < files.length; i++ )
{
if ( files[i] == null )
throw new NullPointerException("Specified file #" + (i+1) + " is null!");
addFileChangeListener( listener, files[i] );
}
}

/**
 * Whenever one the given file has been modified, the given FileChangeListener 
 * will be notified.
 * @param listener Class that will be notified of any changes.
 * @param file File that will be monitored.
 * @throws FileNotFoundException If the given file cannot be found or does not exist.
 */
public void addFileChangeListener( FileChangeListener listener, File file ) throws FileNotFoundException
{
// Make sure this debug line stays here, for it saves you from having a null 
debug("Trying to add NEW file \"" + file + "\" from class \"" + listener.getClass().getName() + "\" to the monitor.");

// Make sure the file exists
debug("Verifying integrity of file \"" + file.getName() + "\"...");
if ( !file.exists() )
throw new FileNotFoundException("File \"" + file + "\" was not found!");

// Let's see if this file is monitored already
Object mapObject = fileMap.get(file);
if ( mapObject == null )
{
debug("File \"" + file.getName() + "\" is NOT monitored yet.  Adding to the list.");
// If no one is monitoring this file - let's create a new FileInfo

// 23.06.2004 If it's directory - let's use DirectoryInfo instead
FileInfo fi;
if ( file.isDirectory() )
fi = new DirectoryInfo(file,listener);
// If it's a simple file - stick to the old ways - make a file info.
else
fi = new FileInfo(file, listener);

// And add it to the list
instance.fileMap.put(file, fi);
}
else
{
debug("File \"" + file.getName() + "\" is already being monitored.  Checking if listener " + listener.getClass().getName() + " is watching it...");
// If we are already monitoring it, let's add our listener.
FileInfo fi = (FileInfo)mapObject;
// Make sure our listener isn't already in the list
if ( fi.hasListener(listener) )
{
debug("Listener " + listener.getClass().getName() + " already exists!  Disregarding request.");
return; // disregard request - we are already watching the file
}

// If listener is not on the list - add it.
debug("Adding listener " + listener.getClass().getName() + " for file \"" + file.getName() + "\"!");
fi.addListener(listener);
}
// We are done.  From now on, FileListenerTask takes over.
}

/**
 * Removes this listener from a specific file.
 * @param listener Listener to remove.
 * @param file File to remove from.
 */
public void removeFileChangeListener( FileChangeListener listener, File file )
{
debug("Removing listener " + listener.getClass().getName() + " from file \"" + file + "\"...");
Object mapObject = fileMap.get(file);
if ( mapObject == null ) // file isn't being watched
return;
else
{
FileInfo fi = (FileInfo)mapObject;
fi.removeListener(listener);
}
}

/**
 * Removes this listener from ALL files.
 * @param listener Listener to remove.
 */
public void removeFileChangeListener( FileChangeListener listener )
{
// Cycle through every FileInfo and ask it to remove the listener
debug("Removing listener " + listener.getClass().getName() + " from all files...");
for ( Iterator i = fileMap.values().iterator(); i.hasNext(); )
{
FileInfo fi = (FileInfo) i.next();
debug("Removing listener from file \"" + fi.file + "\"...");
fi.removeListener(listener);
}
}

class FileListenerTask extends TimerTask
{
 
// In this method we'll check every single file if they have been reloaded
// or not, and if they have, we'll notify their listeners.
public void run()
{
debug("!!! Daemon is checking ALL " + fileMap.size() + " files!");

Object [] values;
synchronized(fileMap)
{
// The reason we put values into an array, is because we don't want 
// To iterate over them, because in case something gets removed
// Or added during the iteration, the structural integrity
// Of the fileMap will be violated and an exception will be thrown.
values = fileMap.values().toArray();
}

// Iterate over the values
for ( int i = 0; i < values.length; i++ )
{
FileInfo fi = (FileInfo)values[i];
fi.checkFile();
}
}

}
}
 
/*
 * Basically, this class will contain a list of listeners watching one particular
 * file, and the last time this file has been accessed.
 * @author Ivan Jouikov ([e-mail])
 */
class FileInfo
{
protected File file; // File we're watching
protected long lastAccessed; // Last time we did something to the file
protected Set fileChangeListeners; // Who are watching this file

// Creates a new file monitor with one listener attached to it.
public FileInfo( File file, FileChangeListener listener )
{
FileMonitor.instance.debug("Instantiating NEW FileInfo on file \"" + file + "\" for listener \"" + listener.getClass().getName() + "\"...");
this.file = file;
fileChangeListeners = new HashSet();
fileChangeListeners.add(listener);
lastAccessed = System.currentTimeMillis() + 500; // give daemon some time to recover, so that the file doesn't get reloaded in the beginning
}

// Returns true if the given listener is watching this file
public boolean hasListener( FileChangeListener listener )
{
return fileChangeListeners.contains(listener);
}

// Adds a listener to watch this file
public void addListener( FileChangeListener listener )
{
FileMonitor.instance.debug("Adding listener \"" + listener.getClass().getName() + "\" to file \"" + file + "\"...");
fileChangeListeners.add(listener);
}

// Remove listener from the list
public void removeListener( FileChangeListener listener )
{
FileMonitor.instance.debug("Removing listener \"" + listener.getClass().getName() + "\" from file \"" + file + "\"...");
fileChangeListeners.remove(listener);
// If this was the only (or the last) listener on this 
// file - remove it from the fileMap
if ( fileChangeListeners.isEmpty() )
{
FileMonitor.instance.debug("It was the last listener, so we're removing that file from FileMonitor.fileMap as well...");
FileMonitor.getInstance().fileMap.remove(file);
}
}

// Notifies all listeners that the file has been modified.
public void notifyListenersOfChange( FileChangeEvent event )
{
FileMonitor.instance.debug("Notifying all " + fileChangeListeners.size() + " FileChangeListener's that file \"" + file.getName() + "\" has been modified or deleted...");
for ( Iterator i = fileChangeListeners.iterator(); i.hasNext(); )
{
FileChangeListener e = (FileChangeListener) i.next();
FileMonitor.instance.debug("Notifying " + e.getClass().getName() + "...");
e.fileModified(event);
}
lastAccessed = System.currentTimeMillis();
}

// Checks to see if the file has been modified, and if it has, 
// it signals the listeners
public void checkFile()
{
FileMonitor.getInstance().debug("Checking file \"" + file + "\"...");

// See if the file has been deleted
if ( !file.exists() )
{
// Notify everyone that file's been deleted
FileMonitor.getInstance().debug("File \"" + file.getName() + "\" has been DELETED!  Notifying all listeners and removing them!");
notifyListenersOfChange( new FileChangeEvent(file, FileChangeEvent.EVENT_FILE_DELETED) );

// Now lets remove that file (and all its listeners) from the list
FileMonitor.getInstance().fileMap.remove(file);
}
// See if it's been modified AFTER we accessed it
else if ( lastAccessed < file.lastModified() )
{
// Notify everyone that file's been modified
FileMonitor.getInstance().debug("File \"" + file.getName() + "\" has been modified!  Notifying all listeners!");
notifyListenersOfChange( new FileChangeEvent(file, FileChangeEvent.EVENT_FILE_MODIFIED) );
}
else
{
// If not, then skip it
FileMonitor.getInstance().debug("File \"" + file.getName() + "\" has not been modified yet.  Skipping...");
}
}
}
 
/*
 * This class will perform a similar function to a FileInfo, with the difference
 * that it will monitor an entire directory, not just one file.
 * 
 * The reason this class implements FileChangeListener, is because it will add 
 * all of the files of the given directory to the FileMonitor, which is how it will 
 * notify it of any changes.
 *
 * This will allow for advanced nested structures.
 * 
 * @author Ivan Jouikov ([e-mail])
 */
class DirectoryInfo extends FileInfo implements FileChangeListener
{
// This will contain the old files of the directory (the last time we went
// through it).  This should be in sync with the directory structure.
protected Set oldFiles;

public DirectoryInfo( File directory, FileChangeListener listener )
{
super(directory,listener);

// Make sure its a directory
if ( !directory.isDirectory() )
throw new IllegalArgumentException("Given file \"" + directory + "\" is NOT a directory!");

FileMonitor.instance.debug("Instantiating NEW DirectoryInfo on directory \"" + file + "\" for listener \"" + listener.getClass().getName() + "\"...");

// Using hash set (should be efficient)
oldFiles = new HashSet();

// We DONT WANT to register all the files within this directory with 
// oldFiles, this way, they will be considered NEW, the next time daemon
// executes, so we'll be able to signal all the listeners about every 
// single file.
}
 
// This method allows us to create complicated nested Directory monitoring
// Structures.  All we have to do, is notify all the listeners of any 
// changes in files...
public void fileModified(FileChangeEvent event)
{
FileMonitor.instance.debug("File \"" + event.getFile() + "\" has been modified:\n" + event);
// If file was deleted - remove it from the oldFiles set.
if ( event.fileDeleted() )
oldFiles.remove(event.getFile());

// Let the listeners know
notifyListenersOfChange(event);
}

// Overiding this method so we can perform a directory inspection.
// We are not going to check for the last time the file was accessed or 
// Anything; we are simply going to see if any new files were added, or this 
// directory has been deleted.
// The rest ( file modified, file removed ) will be taken care of by FileMonitor
// and FileInfo
public void checkFile()
{
FileMonitor.instance.debug("Checking directory \"" + file.getName() + "\"...");

// See if the directory has been deleted
if ( !file.exists() )
{
FileMonitor.instance.debug("Directory \"" + file.getName() + "\" has been DELETED!");

// Notify everyone that we have been deleted...
notifyListenersOfChange( new FileChangeEvent(file, FileChangeEvent.EVENT_FILE_DELETED) );

// Now lets remove that file (and all its listeners) from the list
FileMonitor.getInstance().fileMap.remove(file);

return;
}

// All the files in that directory
File [] allFiles = file.listFiles();

FileMonitor.instance.debug("Checking all " + allFiles.length + " files in directory \"" + file + "\"...");

// See if there are any new files
for ( int i = 0; i < allFiles.length; i++ )
{
FileMonitor.instance.debug("\tChecking \"" + allFiles[i].getName() + "\"...");

// If this is a new file
if ( !oldFiles.contains(allFiles[i]) )
{
FileMonitor.instance.debug("NEW FILE \"" + allFiles[i].getName() + "\" found in directory \"" + file.getName() + "\"!");

// Add it to the list, of course...
oldFiles.add(allFiles[i]);
try
{
// Register it with FileMonitor
FileMonitor.getInstance().addFileChangeListener(this,allFiles[i]);
}
catch ( FileNotFoundException e )
{
// Should not occur since we just found the file
e.printStackTrace();
}

// Notify listeners that there's a new file...
FileChangeEvent event = new FileChangeEvent(allFiles[i], FileChangeEvent.EVENT_NEW_FILE);
notifyListenersOfChange(event);

// That's it!  :) 
}
}
}
} 

Here's the FileChangeListener:

 /*
 * Created on 21.06.2004 at 13:34:18
 * Author: Ivan Jouikov ([e-mail])
 * Project: abLogic
 */
package org.ablogic.misc;
 
/**
 * This interface should be implemented for those files that wish to take
 * advantage of {@link org.ablogic.misc.FileMonitor FileMonitor}.
 * @author Ivan Jouikov ([e-mail])
 */
public interface FileChangeListener
{
/**
 * This will be called whenever the specified file is modified.
 */
public void fileModified( FileChangeEvent event );
}
 

And the FileChangeEvent:

 /*
 * Created on 22.06.2004 at 15:33:45
 * Author: Ivan Jouikov ([e-mail])
 * Project: abLogic
 */
package org.ablogic.misc;
 
import java.util.EventObject;
import java.io.*;
 
/**
 * This class contains some information about changes that ocurred to a given file
 * (or directory).
 * This is used by {@link FileChangeListener FileChangeListener} interface.
 * @author Ivan Jouikov ([e-mail])
 */
public class FileChangeEvent extends EventObject
{
/** Integer presentation of the event that ocurred */
protected int eventCode;

/**
 * Constructs new event.
 * @param file File that the event occurred with.
 * @param eventCode Integer code of the event.
 */
public FileChangeEvent(File file, int eventCode)
{
super( file );
this.eventCode = eventCode;
}
 
/**
 * Returns the file that the event ocurred to.
 */
public File getFile()
{
return (File)getSource();
}

/**
 * Returns the event code of this event.  You can use it and compare it against 
 * the existing event codes, OR you can use the boolean methods.
 */
public int getEventCode()
{
return eventCode;
}

/** Returns true if the file has been modified. */
public boolean fileModified()
{
return eventCode == EVENT_FILE_MODIFIED;
}

/** Returns true if the file has been deleted. */
public boolean fileDeleted()
{
return eventCode == EVENT_FILE_DELETED;
}

/** Returns true if this file was just created. */
public boolean fileCreated()
{
return eventCode == EVENT_NEW_FILE;
}

/** Explains what happened. */
public String toString()
{
StringBuffer out = new StringBuffer("File \"" + getFile() + "\" has been ");
if ( fileModified() ) out.append("modified");
else if ( fileDeleted() ) out.append("deleted");
else if ( fileCreated() ) out.append("created");
else out.append("WARNING: UNKNOWN CODE " + eventCode);
out.append(".");
return out.toString();
}

// Here are some codes

/** File has been modified. */
public static final int EVENT_FILE_MODIFIED = 1;

/** File has been deleted. */
public static final int EVENT_FILE_DELETED = EVENT_FILE_MODIFIED + 1;

/** File has been added (to a directory). */
public static final int EVENT_NEW_FILE = EVENT_FILE_DELETED + 1;
}
 

Also, I wanna know what you guys think of my coding style and my "ability" in general. Please be as critical as possible

BTW, for those who don't know, I wrote this thing because I couldn't find any FileMonitors out there, so I thought, what the hell, I'll just write my own one. This thing simply let's you know if there are any changes inside a file/directory that you're monitoring, such as stuff getting modified, deleted added. 1-line use

[Ivan Jouikov]

QUICK FIX ALREADY!!!

I've been debugging it extensively, but just now I noticed 1 more bug. And fixed it

Here's the new version:

 /*
 * Created on 21.06.2004 at 13:27:31
 * Author: Ivan Jouikov ([e-mail])
 * Project: abLogic
 */
package org.ablogic.misc;
 
import java.io.*;
import java.util.*;
 
/**
 * This class will be used to monitor files, and notify their listeners
 * if those files were modified.
 * 
 * It will run as a daemon (taking advantage of {@link java.util.Timer Timer} class,
 * and watch specified files at specified (or default) intervals, notifiying the 
 * listener whenever a change has been made.
 * 
 * 22.06.2004: Converted it into a singleton, so you could extend it.
 * FileChangeListeners should now implement equals() and hashCode(), because
 * FileInfo has been modified to do comparison using equals(), rather than 
 * compare by reference.  Also, FileInfo now uses a Set rather than List to 
 * store all the FileChangeListeners.  Also, fixed a whole bunch of bugs
 * 
 * 23.06.2004: Now when you add listeners to listen to a file, which is a directory, 
 * you will be updated of changes made to the entire directory, such as: file added,
 * file removed, file modified (not the directory itself, some file in it).
 * 
 * @author Ivan Jouikov ([e-mail])
 */
public class FileMonitor
{
/** Determines if we are debugging or not. */
public static boolean DEBUG = false;

/** This determines how often files will be checked to see if they have been
 * modified or not.  This applies to ALL files.  In milliseconds.
 */
public static long checkInterval = 1000;

// Method used for debugging
void debug( String text )
{
if ( DEBUG )
{
// Get the stack element from the PREVIOUS method, not this one.
StackTraceElement where = new Exception().getStackTrace()[1];
System.out.println("[DEBUG " + where.getFileName() + "#" + where.getLineNumber() + "]: " + text);
}
}

// This is the one and only instance of the FileMonitor which will handle everything
static protected FileMonitor instance;

// This is the bckg thread that will be watching over everything.
protected Timer daemon;

// This is where all the fileInfos will be stored.
// Keys will be files themselves; values will be FileInfo's
protected Map fileMap;

protected FileMonitor()
{
fileMap = Collections.synchronizedMap( new HashMap() );
daemon = new Timer(true); // run as daemon
debug("Starting up the daemon...");
daemon.schedule( new FileListenerTask(), new Date( System.currentTimeMillis() + 1000 ), checkInterval );
}

/**
 * Returns the one and only instance of the FileMonitor.
 * @return Static instance that will watch ALL (specified) files.
 */
public static FileMonitor getInstance()
{
if ( instance == null ) instance = new FileMonitor();
return instance;
}

/**
 * Whenever one of the given files has been modified, the given FileChangeListener 
 * will be notified.
 * @param listener Class that will be notified of any changes.
 * @param files List of files to be monitored.
 * @throws FileNotFoundException If any of the files don't exist or can't be found.
 */
public void addFileChangeListener( FileChangeListener listener, File [] files ) throws FileNotFoundException
{
for ( int i = 0; i < files.length; i++ )
{
if ( files[i] == null )
throw new NullPointerException("Specified file #" + (i+1) + " is null!");
addFileChangeListener( listener, files[i] );
}
}

/**
 * Whenever one the given file has been modified, the given FileChangeListener 
 * will be notified.
 * @param listener Class that will be notified of any changes.
 * @param file File that will be monitored.
 * @throws FileNotFoundException If the given file cannot be found or does not exist.
 */
public void addFileChangeListener( FileChangeListener listener, File file ) throws FileNotFoundException
{
// Make sure this debug line stays here, for it saves you from having a null 
debug("Trying to add NEW file \"" + file + "\" from class \"" + listener.getClass().getName() + "\" to the monitor.");

// Make sure the file exists
debug("Verifying integrity of file \"" + file.getName() + "\"...");
if ( !file.exists() )
throw new FileNotFoundException("File \"" + file + "\" was not found!");

// Let's see if this file is monitored already
Object mapObject = fileMap.get(file);
if ( mapObject == null )
{
debug("File \"" + file.getName() + "\" is NOT monitored yet.  Adding to the list.");
// If no one is monitoring this file - let's create a new FileInfo

// 23.06.2004 If it's directory - let's use DirectoryInfo instead
FileInfo fi;
if ( file.isDirectory() )
fi = new DirectoryInfo(file,listener);
// If it's a simple file - stick to the old ways - make a file info.
else
fi = new FileInfo(file, listener);

// And add it to the list
instance.fileMap.put(file, fi);
}
else
{
debug("File \"" + file.getName() + "\" is already being monitored.  Checking if listener " + listener.getClass().getName() + " is watching it...");
// If we are already monitoring it, let's add our listener.
FileInfo fi = (FileInfo)mapObject;
// Make sure our listener isn't already in the list
if ( fi.hasListener(listener) )
{
debug("Listener " + listener.getClass().getName() + " already exists!  Disregarding request.");
return; // disregard request - we are already watching the file
}

// If listener is not on the list - add it.
debug("Adding listener " + listener.getClass().getName() + " for file \"" + file.getName() + "\"!");
fi.addListener(listener);
}
// We are done.  From now on, FileListenerTask takes over.
}

/**
 * Removes this listener from a specific file.
 * @param listener Listener to remove.
 * @param file File to remove from.
 */
public void removeFileChangeListener( FileChangeListener listener, File file )
{
debug("Removing listener " + listener.getClass().getName() + " from file \"" + file + "\"...");
Object mapObject = fileMap.get(file);
if ( mapObject == null ) // file isn't being watched
return;
else
{
FileInfo fi = (FileInfo)mapObject;
fi.removeListener(listener);
}
}

/**
 * Removes this listener from ALL files.
 * @param listener Listener to remove.
 */
public void removeFileChangeListener( FileChangeListener listener )
{
// Cycle through every FileInfo and ask it to remove the listener
debug("Removing listener " + listener.getClass().getName() + " from all files...");
for ( Iterator i = fileMap.values().iterator(); i.hasNext(); )
{
FileInfo fi = (FileInfo) i.next();
debug("Removing listener from file \"" + fi.file + "\"...");
fi.removeListener(listener);
}
}

class FileListenerTask extends TimerTask
{
 
// In this method we'll check every single file if they have been reloaded
// or not, and if they have, we'll notify their listeners.
public void run()
{
debug("!!! Daemon is checking ALL " + fileMap.size() + " files!");

Object [] values;
synchronized(fileMap)
{
// The reason we put values into an array, is because we don't want 
// To iterate over them, because in case something gets removed
// Or added during the iteration, the structural integrity
// Of the fileMap will be violated and an exception will be thrown.
values = fileMap.values().toArray();
}

// Iterate over the values
for ( int i = 0; i < values.length; i++ )
{
FileInfo fi = (FileInfo)values[i];
fi.checkFile();
}
}

}
}
 
/*
 * Basically, this class will contain a list of listeners watching one particular
 * file, and the last time this file has been accessed.
 * @author Ivan Jouikov ([e-mail])
 */
class FileInfo
{
protected File file; // File we're watching
protected long lastAccessed; // Last time we did something to the file
protected Set fileChangeListeners; // Who are watching this file

// Creates a new file monitor with one listener attached to it.
public FileInfo( File file, FileChangeListener listener )
{
FileMonitor.instance.debug("Instantiating NEW FileInfo on file \"" + file + "\" for listener \"" + listener.getClass().getName() + "\"...");
this.file = file;
fileChangeListeners = new HashSet();
fileChangeListeners.add(listener);
lastAccessed = System.currentTimeMillis() + 500; // give daemon some time to recover, so that the file doesn't get reloaded in the beginning
}

// Returns true if the given listener is watching this file
public boolean hasListener( FileChangeListener listener )
{
return fileChangeListeners.contains(listener);
}

// Adds a listener to watch this file
public void addListener( FileChangeListener listener )
{
FileMonitor.instance.debug("Adding listener \"" + listener.getClass().getName() + "\" to file \"" + file + "\"...");
fileChangeListeners.add(listener);
}

// Remove listener from the list
public void removeListener( FileChangeListener listener )
{
FileMonitor.instance.debug("Removing listener \"" + listener.getClass().getName() + "\" from file \"" + file + "\"...");
fileChangeListeners.remove(listener);
// If this was the only (or the last) listener on this 
// file - remove it from the fileMap
if ( fileChangeListeners.isEmpty() )
{
FileMonitor.instance.debug("It was the last listener, so we're removing that file from FileMonitor.fileMap as well...");
FileMonitor.getInstance().fileMap.remove(file);
}
}

// Notifies all listeners that the file has been modified.
public void notifyListenersOfChange( FileChangeEvent event )
{
FileMonitor.instance.debug("Notifying all " + fileChangeListeners.size() + " FileChangeListener's that file \"" + file.getName() + "\" has been modified or deleted...");
for ( Iterator i = fileChangeListeners.iterator(); i.hasNext(); )
{
FileChangeListener e = (FileChangeListener) i.next();
FileMonitor.instance.debug("Notifying " + e.getClass().getName() + "...");
e.fileModified(event);
}
lastAccessed = System.currentTimeMillis();
}

// Checks to see if the file has been modified, and if it has, 
// it signals the listeners
public void checkFile()
{
FileMonitor.getInstance().debug("Checking file \"" + file + "\"...");

// See if the file has been deleted
if ( !file.exists() )
{
// Notify everyone that file's been deleted
FileMonitor.getInstance().debug("File \"" + file.getName() + "\" has been DELETED!  Notifying all listeners and removing them!");
notifyListenersOfChange( new FileChangeEvent(file, FileChangeEvent.EVENT_FILE_DELETED) );

// Now lets remove that file (and all its listeners) from the list
FileMonitor.getInstance().fileMap.remove(file);
}
// See if it's been modified AFTER we accessed it
else if ( lastAccessed < file.lastModified() )
{
// Notify everyone that file's been modified
FileMonitor.getInstance().debug("File \"" + file.getName() + "\" has been modified!  Notifying all listeners!");
notifyListenersOfChange( new FileChangeEvent(file, FileChangeEvent.EVENT_FILE_MODIFIED) );
}
else
{
// If not, then skip it
FileMonitor.getInstance().debug("File \"" + file.getName() + "\" has not been modified yet.  Skipping...");
}
}
}
 
/*
 * This class will perform a similar function to a FileInfo, with the difference
 * that it will monitor an entire directory, not just one file.
 * 
 * The reason this class implements FileChangeListener, is because it will add 
 * all of the files of the given directory to the FileMonitor, which is how it will 
 * notify it of any changes.
 *
 * This will allow for advanced nested structures.
 * 
 * @author Ivan Jouikov ([e-mail])
 */
class DirectoryInfo extends FileInfo implements FileChangeListener
{
// This will contain the old files of the directory (the last time we went
// through it).  This should be in sync with the directory structure.
protected Set oldFiles;

public DirectoryInfo( File directory, FileChangeListener listener )
{
super(directory,listener);

// Make sure its a directory
if ( !directory.isDirectory() )
throw new IllegalArgumentException("Given file \"" + directory + "\" is NOT a directory!");

FileMonitor.instance.debug("Instantiating NEW DirectoryInfo on directory \"" + file + "\" for listener \"" + listener.getClass().getName() + "\"...");

// Using hash set (should be efficient)
oldFiles = new HashSet();

// We DONT WANT to register all the files within this directory with 
// oldFiles, this way, they will be considered NEW, the next time daemon
// executes, so we'll be able to signal all the listeners about every 
// single file.
}
 
// This method allows us to create complicated nested Directory monitoring
// Structures.  All we have to do, is notify all the listeners of any 
// changes in files...
public void fileModified(FileChangeEvent event)
{
FileMonitor.instance.debug("File \"" + event.getFile() + "\" has been modified:\n" + event);
// If file was deleted - remove it from the oldFiles set.
if ( event.fileDeleted() )
oldFiles.remove(event.getFile());

// Let the listeners know
notifyListenersOfChange(event);
}

// Overiding this method so we can perform a directory inspection.
// We are not going to check for the last time the file was accessed or 
// Anything; we are simply going to see if any new files were added, or this 
// directory has been deleted.
// The rest ( file modified, file removed ) will be taken care of by FileMonitor
// and FileInfo
public void checkFile()
{
FileMonitor.instance.debug("Checking directory \"" + file.getName() + "\"...");

// See if the directory has been deleted
if ( !file.exists() )
{
FileMonitor.instance.debug("Directory \"" + file.getName() + "\" has been DELETED!");

// Notify everyone that we have been deleted...
notifyListenersOfChange( new FileChangeEvent(file, FileChangeEvent.EVENT_FILE_DELETED) );

// Will remove this listener from ALL the files under this directory.
FileMonitor.getInstance().removeFileChangeListener(this);

return;
}

// All the files in that directory
File [] allFiles = file.listFiles();

FileMonitor.instance.debug("Checking all " + allFiles.length + " files in directory \"" + file + "\"...");

// See if there are any new files
for ( int i = 0; i < allFiles.length; i++ )
{
FileMonitor.instance.debug("\tChecking \"" + allFiles[i].getName() + "\"...");

// If this is a new file
if ( !oldFiles.contains(allFiles[i]) )
{
FileMonitor.instance.debug("NEW FILE \"" + allFiles[i].getName() + "\" found in directory \"" + file.getName() + "\"!");

// Add it to the list, of course...
oldFiles.add(allFiles[i]);
try
{
// Register it with FileMonitor
FileMonitor.getInstance().addFileChangeListener(this,allFiles[i]);
}
catch ( FileNotFoundException e )
{
// Should not occur since we just found the file
e.printStackTrace();
}

// Notify listeners that there's a new file...
FileChangeEvent event = new FileChangeEvent(allFiles[i], FileChangeEvent.EVENT_NEW_FILE);
notifyListenersOfChange(event);

// That's it!  :) 
}
}
}
} 

[John Smith]

Also, I wanna know what you guys think of my coding style and my "ability" in general. Please be as critical as possible

OK, you asked for it. First, do not use all caps, especially in the subject line. This is not a forrest in Russia, we can all hear you well.

public FileReloaderTest() throws Exception

Throwing a general Exception is not a good idea. Instead, list all of them explicitely. That will allow the caller to do some meaningful processing.

while(true)Thread.sleep(1000);

That's not a very thrilling solution to whatever it is that you are trying to do. Did you look into wait()/notify()?

public static long checkInterval = 1000;

"public static final long CHECK_INTERVAL = 1000;"
is more expressive and is in line with the Sun's Java Coding conventions.

protected Timer daemon;

I am not happy about the name "daemon". That's the implementation detail. What are you going to do when you want to change it to non-daemon? I suggest "timer", "monitor", or something of that sort, to indicate what it does, not how it does it.

protected FileMonitor()

You indicated that FileMonitor is a singleton, yet it has a protected constructor, so nothing stops the classes in the same package from creating 200 instances of this class. The constructor should be private. More generally, the abundance of the protected fields and methods is somewhat unsettling.

for ( Iterator i = fileMap.values().iterator(); i.hasNext();

Although your fileMap is a synchronized collection, it doesn't mean that you have thread safety when iterating through it. If another thread modifies your fileMap while you are iterating, you are in trouble.


FileMonitor.instance.debug("..");
FileMonitor.getInstance().fileMap.remove(file);


So is it instance or getInstance()?

        try
        {
            FileMonitor.getInstance().addFileChangeListener(this, allFiles[i]);
        }
        catch (FileNotFoundException e)
        {
            // Should not occur since we just found the file
            e.printStackTrace();
        }
        
        // Notify listeners that there's a new file...
        FileChangeEvent event = new FileChangeEvent(allFiles[i], FileChangeEvent.EVENT_NEW_FILE);

This doesn't look very solid. If the exception is thrown and caught, your code proceeds to notify the listeners, which will probably confuse the hell out of them.
[ June 23, 2004: Message edited by: Eugene Kononov ]

[Ivan Jouikov]

First, do not use all caps, especially in the subject line. This is not a forrest in Russia, we can all hear you well.

I only used caps cuz I was really thrilled about my achievements I rarely USE THEM LIKE AN IDIOT


Throwing a general Exception is not a good idea. Instead, list all of them explicitely. That will allow the caller to do some meaningful processing

Hmm, every time I was doing throws Exception, this was on the top of my head... It's just that often you have same exception travleing through all of your methods, and you have to write the same stuff for javadoc comment over and over. How do you deal with it? You just tought it out and write it?

That's not a very thrilling solution to whatever it is that you are trying to do. Did you look into wait()/notify()?

That's just the tester class, it doesn't server any purpose other than demonstrate how you would register a file with FileMonitor. I expect the user to terminate it using "Ctrl+Z" (on Linux) or using their IDE...

is more expressive and is in line with the Sun's Java Coding conventions.

The reason I didn't use final is because i wanted the user to be able to change the interval. But now, come to think about it, changing that INT won't change the interval on the timer, so might as well make it final. Thanks!

I am not happy about the name "daemon". That's the implementation detail. What are you going to do when you want to change it to non-daemon? I suggest "timer", "monitor", or something of that sort, to indicate what it does, not how it does it.

Good point. Thanks.

You indicated that FileMonitor is a singleton, yet it has a protected constructor, so nothing stops the classes in the same package from creating 200 instances of this class. The constructor should be private. More generally, the abundance of the protected fields and methods is somewhat unsettling.

Well, when I was designing it, I was thinking that people could extend it. But now come to think about it, you can't really extend a singleton can you? I'd have to use a factory pattern if I wanted it to be extendable, I guess...

Although your fileMap is a synchronized collection, it doesn't mean that you have thread safety when iterating through it. If another thread modifies your fileMap while you are iterating, you are in trouble.

So you're saying I'd have to use "synchronized"? Then what's the point of making a synchronized map in the first place, if it doesn't synchronize it?

So is it instance or getInstance()?

I wanna say that I am 100% sure that using instance would be safe in that case, but my 100% insurance failed many times, so I'll change that to getInstance()

This doesn't look very solid. If the exception is thrown and caught, your code proceeds to notify the listeners, which will probably confuse the hell out of them.

How would you propose to solve that exception? Basically, what's happening there, is we JUST FOUND THE FILE, and there's NO WAY I could get a FileNotFoundException... It's like doing

MyObject b = new MyObject();

void blah(){ // do nothing }

try{ b.blah() }
catch( NullPointerException e ) {...}

I have NO idea how to approach this kind of "problem". Suggestions would be useful.

Thanks for your criticizm, it's very useful. Hope I get more.

[Ivan Jouikov]

Wow already found another bug thanks to ur advices