org.apache.commons.jci.monitor.FilesystemAlterationObserverImpl Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of commons-jci-fam Show documentation
Show all versions of commons-jci-fam Show documentation
Commons JCI FileAlterationMonitor (FAM) to monitor local filesystems and get notified about changes.
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 org.apache.commons.jci.monitor;
import java.io.File;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* Implementation of a FilesystemAlterationObserver
*
* @author tcurdt
*/
public class FilesystemAlterationObserverImpl implements FilesystemAlterationObserver {
private final Log log = LogFactory.getLog(FilesystemAlterationObserverImpl.class);
private interface MonitorFile {
long lastModified();
MonitorFile[] listFiles();
boolean isDirectory();
boolean exists();
String getName();
}
private final static class MonitorFileImpl implements MonitorFile {
private final File file;
public MonitorFileImpl( final File pFile ) {
file = pFile;
}
public boolean exists() {
return file.exists();
}
public MonitorFile[] listFiles() {
final File[] children = file.listFiles();
if (children == null) { // not a directory or IOError (e.g. protection issue)
return new MonitorFile[0];
}
final MonitorFile[] providers = new MonitorFile[children.length];
for (int i = 0; i < providers.length; i++) {
providers[i] = new MonitorFileImpl(children[i]);
}
return providers;
}
public String getName() {
return file.getName();
}
public boolean isDirectory() {
return file.isDirectory();
}
public long lastModified() {
return file.lastModified();
}
@Override
public String toString() {
return file.toString();
}
}
private final class Entry {
private final static int TYPE_UNKNOWN = 0;
private final static int TYPE_FILE = 1;
private final static int TYPE_DIRECTORY = 2;
private final MonitorFile file;
private long lastModified = -1;
private int lastType = TYPE_UNKNOWN;
private final Map children = new HashMap();
public Entry(final MonitorFile pFile) {
file = pFile;
}
public String getName() {
return file.getName();
}
@Override
public String toString() {
return file.toString();
}
private void compareChildren() {
if (!file.isDirectory()) {
return;
}
final MonitorFile[] files = file.listFiles();
final Set deleted = new HashSet(children.values());
for (MonitorFile f : files) {
final String name = f.getName();
final Entry entry = children.get(name);
if (entry != null) {
// already recognized as child
deleted.remove(entry);
if(entry.needsToBeDeleted()) {
// we have to delete this one
children.remove(name);
}
} else {
// a new child
final Entry newChild = new Entry(f);
children.put(name, newChild);
newChild.needsToBeDeleted();
}
}
// the ones not found on disk anymore
for (Entry entry : deleted) {
entry.deleteChildrenAndNotify();
children.remove(entry.getName());
}
}
private void deleteChildrenAndNotify() {
for (Entry entry : children.values()) {
entry.deleteChildrenAndNotify();
}
children.clear();
if(lastType == TYPE_DIRECTORY) {
notifyOnDirectoryDelete(this);
} else if (lastType == TYPE_FILE) {
notifyOnFileDelete(this);
}
}
public boolean needsToBeDeleted() {
if (!file.exists()) {
// deleted or has never existed yet
// log.debug(file + " does not exist or has been deleted");
deleteChildrenAndNotify();
// mark to be deleted by parent
return true;
} else {
// exists
final long currentModified = file.lastModified();
if (currentModified != lastModified) {
// last modified has changed
lastModified = currentModified;
// log.debug(file + " has new last modified");
// types only changes when also the last modified changes
final int newType = (file.isDirectory()?TYPE_DIRECTORY:TYPE_FILE);
if (lastType != newType) {
// the type has changed
// log.debug(file + " has a new type");
deleteChildrenAndNotify();
lastType = newType;
// and then an add as the new type
if (newType == TYPE_DIRECTORY) {
notifyOnDirectoryCreate(this);
compareChildren();
} else {
notifyOnFileCreate(this);
}
return false;
}
if (newType == TYPE_DIRECTORY) {
notifyOnDirectoryChange(this);
compareChildren();
} else {
notifyOnFileChange(this);
}
return false;
} else {
// so exists and has not changed
// log.debug(file + " does exist and has not changed");
compareChildren();
return false;
}
}
}
public MonitorFile getFile() {
return file;
}
public void markNotChanged() {
lastModified = file.lastModified();
}
}
private final File rootDirectory;
private final Entry rootEntry;
private FilesystemAlterationListener[] listeners = new FilesystemAlterationListener[0];
private final Set listenersSet = new HashSet();
public FilesystemAlterationObserverImpl( final File pRootDirectory ) {
rootDirectory = pRootDirectory;
rootEntry = new Entry(new MonitorFileImpl(pRootDirectory));
}
private void notifyOnStart() {
log.debug("onStart " + rootEntry);
for (FilesystemAlterationListener listener : listeners) {
listener.onStart(this);
}
}
private void notifyOnStop() {
log.debug("onStop " + rootEntry);
for (FilesystemAlterationListener listener : listeners) {
listener.onStop(this);
}
}
private void notifyOnFileCreate( final Entry pEntry ) {
log.debug("onFileCreate " + pEntry);
for (FilesystemAlterationListener listener : listeners) {
listener.onFileCreate(((MonitorFileImpl)pEntry.getFile()).file );
}
}
private void notifyOnFileChange( final Entry pEntry ) {
log.debug("onFileChange " + pEntry);
for (FilesystemAlterationListener listener : listeners) {
listener.onFileChange(((MonitorFileImpl)pEntry.getFile()).file );
}
}
private void notifyOnFileDelete( final Entry pEntry ) {
log.debug("onFileDelete " + pEntry);
for (FilesystemAlterationListener listener : listeners) {
listener.onFileDelete(((MonitorFileImpl)pEntry.getFile()).file );
}
}
private void notifyOnDirectoryCreate( final Entry pEntry ) {
log.debug("onDirectoryCreate " + pEntry);
for (FilesystemAlterationListener listener : listeners) {
listener.onDirectoryCreate(((MonitorFileImpl)pEntry.getFile()).file );
}
}
private void notifyOnDirectoryChange( final Entry pEntry ) {
log.debug("onDirectoryChange " + pEntry);
for (FilesystemAlterationListener listener : listeners) {
listener.onDirectoryChange(((MonitorFileImpl)pEntry.getFile()).file );
}
}
private void notifyOnDirectoryDelete( final Entry pEntry ) {
log.debug("onDirectoryDelete " + pEntry);
for (FilesystemAlterationListener listener : listeners) {
listener.onDirectoryDelete(((MonitorFileImpl)pEntry.getFile()).file );
}
}
private void checkEntries() {
if(rootEntry.needsToBeDeleted()) {
// root not existing
rootEntry.lastType = Entry.TYPE_UNKNOWN;
}
}
public void checkAndNotify() {
synchronized(listenersSet) {
if (listeners.length == 0) {
return;
}
notifyOnStart();
checkEntries();
notifyOnStop();
}
}
public File getRootDirectory() {
return rootDirectory;
}
public void addListener( final FilesystemAlterationListener pListener ) {
synchronized(listenersSet) {
if (listenersSet.add(pListener)) {
listeners = createArrayFromSet();
}
}
}
public void removeListener( final FilesystemAlterationListener pListener ) {
synchronized(listenersSet) {
if (listenersSet.remove(pListener)) {
listeners = createArrayFromSet();
}
}
}
private FilesystemAlterationListener[] createArrayFromSet() {
final FilesystemAlterationListener[] newListeners = new FilesystemAlterationListener[listenersSet.size()];
listenersSet.toArray(newListeners);
return newListeners;
}
public FilesystemAlterationListener[] getListeners() {
synchronized(listenersSet) {
final FilesystemAlterationListener[] res = new FilesystemAlterationListener[listeners.length];
System.arraycopy(listeners, 0, res, 0, res.length);
return res;
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy