leap.lang.io.FileChangeObserver Maven / Gradle / Ivy
The newest version!
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package leap.lang.io;
import java.io.File;
import java.io.FileFilter;
import java.io.Serializable;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import leap.lang.Strings;
import leap.lang.logging.Log;
import leap.lang.logging.LogFactory;
/**
* {@link FileChangeObserver} represents the state of files below a root directory,
* checking the filesystem and notifying listeners of create, change or
* delete events.
*
* To use this implementation:
*
* - Create {@link FileChangeListener} implementation(s) that process
* the file/directory create, change and delete events
* - Register the listener(s) with a {@link FileChangeObserver} for
* the appropriate directory.
* - Either register the observer(s) with a {@link FileChangeMonitor} or
* run manually.
*
*
* Basic Usage
* Create a {@link FileChangeObserver} for the directory and register the listeners:
*
* File directory = new File(new File("."), "src");
* FileChangeObserver observer = new FileChangeObserver(directory);
* observer.addListener(...);
* observer.addListener(...);
*
* To manually observe a directory, initialize the observer and invoked the
* {@link #checkAndNotify()} method as required:
*
* // intialize
* observer.init();
* ...
* // invoke as required
* observer.checkAndNotify();
* ...
* observer.checkAndNotify();
* ...
* // finished
* observer.finish();
*
* Alternatively, register the oberver(s) with a {@link FileChangeMonitor},
* which creates a new thread, invoking the observer at the specified interval:
*
* long interval = ...
* FileChangeMonitor monitor = new FileChangeMonitor(interval);
* monitor.addObserver(observer);
* monitor.start();
* ...
* monitor.stop();
*
*
* File Filters
* This implementation can monitor portions of the file system
* by using {@link FileFilter}s to observe only the files and/or directories
* that are of interest. This makes it more efficient and reduces the
* noise from unwanted file system events.
*
* Commons IO has a good range of
* useful, ready made
* File Filter
* implementations for this purpose.
*
* For example, to only observe 1) visible directories and 2) files with a ".java" suffix
* in a root directory called "src" you could set up a {@link FileChangeObserver} in the following
* way:
*
* // Create a FileFilter
* Filter directories = Filters.and(
* Filters.isDirectory(),
* Filters.isVisible());
* Filter files = Filters.and(
* Filters.isFile(),
* Filters.endsWith(".java"));
* Filter filter = Filters.or(directories, files);
*
* // Create the File system observer and register File Listeners
* FileChangeObserver observer = new FileChangeObserver(new File("src"), filter);
* observer.addListener(...);
* observer.addListener(...);
*
*
* FileEntry
* {@link FileInfo} represents the state of a file or directory, capturing
* {@link File} attributes at a point in time. Custom implementations of
* {@link FileInfo} can be used to capture additional properties that the
* basic implementation does not support. The {@link FileInfo#refresh(File)}
* method is used to determine if a file or directory has changed since the last
* check and stores the current state of the {@link File}'s properties.
*
* @see FileChangeListener
* @see FileChangeMonitor
*/
public class FileChangeObserver implements Serializable {
private static final long serialVersionUID = -8746490040819712555L;
private static final Log log = LogFactory.get(FileChangeObserver.class);
private final List listeners = new CopyOnWriteArrayList();
private final FileInfo rootEntry;
private final FileFilter fileFilter;
private final Comparator comparator;
private boolean _initialized = false;
/**
* Construct an observer for the specified directory.
*
* @param directoryName the name of the directory to observe
*/
public FileChangeObserver(String directoryName) {
this(new File(directoryName));
}
/**
* Construct an observer for the specified directory and file filter.
*
* @param directoryName the name of the directory to observe
* @param fileFilter The file filter or null if none
*/
public FileChangeObserver(String directoryName, FileFilter fileFilter) {
this(new File(directoryName), fileFilter);
}
/**
* Construct an observer for the specified directory, file filter and
* file comparator.
*
* @param directoryName the name of the directory to observe
* @param fileFilter The file filter or null if none
* @param caseSensitivity what case sensitivity to use comparing file names, null means system sensitive
*/
public FileChangeObserver(String directoryName, FileFilter fileFilter, IOCase caseSensitivity) {
this(new File(directoryName), fileFilter, caseSensitivity);
}
/**
* Construct an observer for the specified directory.
*
* @param directory the directory to observe
*/
public FileChangeObserver(File directory) {
this(directory, (FileFilter)null);
}
public FileChangeObserver(File directory, FileChangeListener listener) {
this(directory, (FileFilter)null);
this.addListener(listener);
}
/**
* Construct an observer for the specified directory and file filter.
*
* @param directory the directory to observe
* @param fileFilter The file filter or null if none
*/
public FileChangeObserver(File directory, FileFilter fileFilter) {
this(directory, fileFilter, (IOCase)null);
}
/**
* Construct an observer for the specified directory, file filter and
* file comparator.
*
* @param directory the directory to observe
* @param fileFilter The file filter or null if none
* @param caseSensitivity what case sensitivity to use comparing file names, null means system sensitive
*/
public FileChangeObserver(File directory, FileFilter fileFilter, IOCase caseSensitivity) {
this(new FileInfo(directory), fileFilter, caseSensitivity);
}
/**
* Construct an observer for the specified directory, file filter and
* file comparator.
*
* @param rootEntry the root directory to observe
* @param fileFilter The file filter or null if none
* @param caseSensitivity what case sensitivity to use comparing file names, null means system sensitive
*/
protected FileChangeObserver(FileInfo rootEntry, FileFilter fileFilter, IOCase caseSensitivity) {
if (rootEntry == null) {
throw new IllegalArgumentException("Root entry is missing");
}
if (rootEntry.getFile() == null) {
throw new IllegalArgumentException("Root directory is missing");
}
this.rootEntry = rootEntry;
this.fileFilter = fileFilter;
if (caseSensitivity == null || caseSensitivity.equals(IOCase.SYSTEM)) {
this.comparator = IOComparators.nameSystem();
} else if (caseSensitivity.equals(IOCase.INSENSITIVE)) {
this.comparator = IOComparators.nameInsensitive();
} else {
this.comparator = IOComparators.nameSensitive();
}
}
/**
* Return the directory being observed.
*
* @return the directory being observed
*/
public File getDirectory() {
return rootEntry.getFile();
}
/**
* Return the fileFilter.
*
* @return the fileFilter
* @since 2.1
*/
public FileFilter getFilter() {
return fileFilter;
}
/**
* Add a file system listener.
*
* @param listener The file system listener
*/
public FileChangeObserver addListener(final FileChangeListener listener) {
if (listener != null) {
listeners.add(listener);
}
return this;
}
/**
* Remove a file system listener.
*
* @param listener The file system listener
*/
public FileChangeObserver removeListener(final FileChangeListener listener) {
if (listener != null) {
while (listeners.remove(listener)) {
}
}
return this;
}
/**
* Returns the set of registered file system listeners.
*
* @return The file system listeners
*/
public Iterable getListeners() {
return listeners;
}
/**
* Final processing.
*
* @throws Exception if an error occurs
*/
public void destroy() throws Exception {
}
/**
* Check whether the file and its chlidren have been created, modified or deleted.
*/
public void checkAndNotify() {
if(!_initialized){
initialize();
}
try {
/* fire onStart() */
for (FileChangeListener listener : listeners) {
listener.onStart(this);
}
/* fire directory/file events */
File rootFile = rootEntry.getFile();
if (rootFile.exists()) {
checkAndNotify(rootEntry, rootEntry.getChildren(), listFiles(rootFile));
} else if (rootEntry.isExists()) {
checkAndNotify(rootEntry, rootEntry.getChildren(), Files.EMPTY_FILE_ARRAY);
} else {
// Didn't exist and still doesn't
}
/* fire onStop() */
for (FileChangeListener listener : listeners) {
listener.onStop(this);
}
} catch (Throwable e) {
log.info("Error on checkAndNotify : {}",e.getMessage(),e);
boolean handled = false;
for (FileChangeListener listener : listeners) {
if(listener.onError(this, e)){
handled = true;
}
}
if(!handled){
throw new RuntimeException(Strings.format("Error on checkAndNotify : {0}",e.getMessage()),e);
}
}
}
/**
* Compare two file lists for files which have been created, modified or deleted.
*
* @param parent The parent entry
* @param previous The original list of files
* @param files The current list of files
*/
private void checkAndNotify(FileInfo parent, FileInfo[] previous, File[] files) {
int c = 0;
FileInfo[] current = files.length > 0 ? new FileInfo[files.length] : FileInfo.EMPTY_FILE_INFOS;
for (FileInfo entry : previous) {
while (c < files.length && comparator.compare(entry.getFile(), files[c]) > 0) {
current[c] = createFileEntry(parent, files[c]);
doCreate(current[c]);
c++;
}
if (c < files.length && comparator.compare(entry.getFile(), files[c]) == 0) {
doMatch(entry, files[c]);
checkAndNotify(entry, entry.getChildren(), listFiles(files[c]));
current[c] = entry;
c++;
} else {
checkAndNotify(entry, entry.getChildren(), Files.EMPTY_FILE_ARRAY);
doDelete(entry);
}
}
for (; c < files.length; c++) {
current[c] = createFileEntry(parent, files[c]);
doCreate(current[c]);
}
parent.setChildren(current);
}
/**
* Initialize the observer.
*
* @throws Exception if an error occurs
*/
protected synchronized void initialize() {
rootEntry.refresh(rootEntry.getFile());
File[] files = listFiles(rootEntry.getFile());
FileInfo[] children = files.length > 0 ? new FileInfo[files.length] : FileInfo.EMPTY_FILE_INFOS;
for (int i = 0; i < files.length; i++) {
children[i] = createFileEntry(rootEntry, files[i]);
}
rootEntry.setChildren(children);
_initialized = true;
}
/**
* Create a new file entry for the specified file.
*
* @param parent The parent file entry
* @param file The file to create an entry for
* @return A new file entry
*/
private FileInfo createFileEntry(FileInfo parent, File file) {
FileInfo entry = parent.newChildInstance(file);
entry.refresh(file);
File[] files = listFiles(file);
FileInfo[] children = files.length > 0 ? new FileInfo[files.length] : FileInfo.EMPTY_FILE_INFOS;
for (int i = 0; i < files.length; i++) {
children[i] = createFileEntry(entry, files[i]);
}
entry.setChildren(children);
return entry;
}
/**
* Fire directory/file created events to the registered listeners.
*
* @param entry The file entry
*/
private void doCreate(FileInfo entry) {
for (FileChangeListener listener : listeners) {
if (entry.isDirectory()) {
listener.onDirectoryCreate(this,entry.getFile());
} else {
listener.onFileCreate(this,entry.getFile());
}
}
FileInfo[] children = entry.getChildren();
for (FileInfo aChildren : children) {
doCreate(aChildren);
}
}
/**
* Fire directory/file change events to the registered listeners.
*
* @param entry The previous file system entry
* @param file The current file
*/
private void doMatch(FileInfo entry, File file) {
if (entry.refresh(file)) {
for (FileChangeListener listener : listeners) {
if (entry.isDirectory()) {
listener.onDirectoryChange(this,file);
} else {
listener.onFileChange(this,file);
}
}
}
}
/**
* Fire directory/file delete events to the registered listeners.
*
* @param entry The file entry
*/
private void doDelete(FileInfo entry) {
for (FileChangeListener listener : listeners) {
if (entry.isDirectory()) {
listener.onDirectoryDelete(this,entry.getFile());
} else {
listener.onFileDelete(this,entry.getFile());
}
}
}
/**
* List the contents of a directory
*
* @param file The file to list the contents of
* @return the directory contents or a zero length array if
* the empty or the file is not a directory
*/
private File[] listFiles(File file) {
File[] children = null;
if (file.isDirectory()) {
children = fileFilter == null ? file.listFiles() : file.listFiles(fileFilter);
}
if (children == null) {
children = Files.EMPTY_FILE_ARRAY;
}
if (comparator != null && children.length > 1) {
Arrays.sort(children, comparator);
}
return children;
}
/**
* Provide a String representation of this observer.
*
* @return a String representation of this observer
*/
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append(getClass().getSimpleName());
builder.append("[file='");
builder.append(getDirectory().getPath());
builder.append('\'');
if (fileFilter != null) {
builder.append(", ");
builder.append(fileFilter.toString());
}
builder.append(", listeners=");
builder.append(listeners.size());
builder.append("]");
return builder.toString();
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy