Application: gvSIG desktop » gvSIG scripting

package org.gvsig.scripting.swing.impl;

import java.io.File;

import java.io.IOException;

import java.lang.ref.WeakReference;

import java.nio.file.FileSystem;

import java.nio.file.FileSystems;

import java.nio.file.Path;

import static java.nio.file.StandardWatchEventKinds.ENTRY_CREATE;

import static java.nio.file.StandardWatchEventKinds.ENTRY_DELETE;

import static java.nio.file.StandardWatchEventKinds.ENTRY_MODIFY;

import static java.nio.file.StandardWatchEventKinds.OVERFLOW;

import java.nio.file.WatchEvent;

import java.nio.file.WatchKey;

import java.nio.file.WatchService;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public class FileChangesObserver {

    private static final Logger LOGGER = LoggerFactory.getLogger(FileChangesObserver.class);

    private static FileChangesObserver INSTANCE = null;

    public static FileChangesObserver getInstance() {

        if (INSTANCE == null) {

            INSTANCE = new FileChangesObserver();

        }

        return INSTANCE;

    }

    private class FileObserver implements Observable {

        private final Path folder;

        private final WeakReference<Observer> observer;

        @SuppressWarnings("FieldMayBeFinal")

        private File file;

        public FileObserver(File file, Observer observer) {

            try {

                this.file = file.getCanonicalFile();

            } catch (IOException ex) {

                this.file = file.getAbsoluteFile();

            }

            this.observer = new WeakReference<>(observer);

            FileSystem fs = FileSystems.getDefault();

            if( file.isDirectory() ) {

                this.folder = fs.getPath(file.getAbsolutePath());

            } else {

                this.folder = fs.getPath(file.getParentFile().getAbsolutePath());

            }

        }

        public Path getFolder() {

            return this.folder;

        }

        public File getFile() {

            return this.file;

        }

        public void notifyObserver() {

//            LOGGER.info("notifyObserver(): enter, ("+file.toString()+").");

            Observer obs = this.observer.get();

            if( obs == null ) {

//                LOGGER.info("notifyObserver(): exit, obs=null ("+file.toString()+").");

                return;

            }

//            LOGGER.info("notifyObserver(): obs="+obs.hashCode()+" ("+file.toString()+").");

            obs.update(this, this.file);

//            LOGGER.info("notifyObserver(): exit, obs="+obs.hashCode()+" ("+file.toString()+").");

        }

        private boolean is(Observer observer) {

            Observer obs = this.observer.get();

            if( obs == null ) {

                return false;

            }

            return obs == observer; // Queremos comparar los punteros.

        }

        private boolean is(Observer observer, File file) {

            Observer obs = this.observer.get();

            if( obs == null || obs != observer) { // Queremos comparar los punteros.

                return false;

            }

            return this.file.equals(file);

        }

        private boolean is(Path file) {

            File f = file.toAbsolutePath().toFile();

            try {

                f = f.getCanonicalFile();

            } catch (IOException ex) {

                f = f.getAbsoluteFile();

            }

            return this.file.equals(f);

        }

        private boolean isDead() {

            Observer obs = this.observer.get();

            return obs == null;

        }

        @Override

        public void addObserver(Observer obsrvr) {

            FileChangesObserver.this.addObserver(obsrvr, this.file);

        }

        @Override

        public void deleteObserver(Observer obsrvr) {

            FileChangesObserver.this.deleteObserver(obsrvr);

        }

        @Override

        public void deleteObservers() {

            FileChangesObserver.this.deleteObservers();

        }

    }

    private class Process extends Thread {

        private WatchService watcher;

        private final Map<String,WatchKey> folders;

        public Process() {

            try {

                this.watcher = FileSystems.getDefault().newWatchService();

            } catch (Throwable ex) {

                LOGGER.warn("Can't create WatchService.", ex);

                this.watcher = null;

            }

            this.folders = new HashMap<>();

            this.setName("ScriptingFilesChangesObserver");

        }

        @Override

        public void run() {

            if( this.watcher == null ) {

                return;

            }

            for (;;) {

                // wait for key to be signaled

                WatchKey key;

                try {

                    key = watcher.take();

                } catch (InterruptedException x) {

                    return;

                }

                if( key == null ) {

                    continue;

                }

                Path folder = (Path) key.watchable();                

                if( !key.isValid() ) {

                    String pathname = folder.toFile().getAbsolutePath();

                    synchronized(folders) {

                        this.folders.remove(pathname);

                    }

                    try {

                        key.cancel();

                    } catch(Throwable th) {

                        LOGGER.debug("Cat cancel watch on '"+pathname+"'.",th);

                    }

                    continue;

                }

                try {

                    for (WatchEvent<?> event : key.pollEvents()) {

                        WatchEvent.Kind<?> kind = event.kind();

                        // This key is registered only

                        // for ENTRY_CREATE events,

                        // but an OVERFLOW event can

                        // occur regardless if events

                        // are lost or discarded.

                        if (kind == OVERFLOW) {

                            continue;

                        }

                        // The filename is the context of the event.

                        WatchEvent<Path> ev = (WatchEvent<Path>) event;

                        Path filename = ev.context();

                        Path child = folder.resolve(filename);

                        List<FileObserver>toNotify = new ArrayList<>();

                        synchronized(fileObservers) {

                            for (FileObserver fileObserver : fileObservers) {

                                if( fileObserver.is(child) ) {

                                    toNotify.add(fileObserver);

                                }

                            }

                        }

                        for (FileObserver fileObserver : toNotify) {

                            fileObserver.notifyObserver();

                        }

                    }

                } catch(Exception ex) {

                    LOGGER.warn("Can't process watch event.", ex);

                } finally {

                    // Reset the key -- this step is critical if you want to

                    // receive further watch events.

                    key.reset();

                }

            }

        }

        public void reqisterWatch(Path folder) {

//            LOGGER.info("reqisterWatch(): enter, folder="+folder.hashCode()+", "+folder.toString()+".");

            synchronized(folders) {

                String pathname = folder.toFile().getAbsolutePath();

                WatchKey watchkey = this.folders.get(pathname);

                if( watchkey != null ) {

                    return;

                }

                try {

                    watchkey = folder.register(watcher, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);

                    this.folders.put(pathname, watchkey);

                } catch (IOException x) {

                    LOGGER.warn("Can't add watch on path '"+Objects.toString(folder), x);

                }

            }

//            LOGGER.info("reqisterWatch(): exit, folder="+folder.hashCode()+", "+folder.toString()+".");

        }

        public void cancelWatch(final Path folder) {

//            LOGGER.info("cancelWatch(): enter, folder="+folder.hashCode()+", "+folder.toString()+".");

            synchronized(folders) {

                String pathname = folder.toFile().getAbsolutePath();

                WatchKey watchkey = this.folders.get(pathname);

                if( watchkey == null ) {

                    return;

                }

                this.folders.remove(pathname);

                try {

                    watchkey.cancel();

                } catch(Throwable th) {

                    LOGGER.debug("Cat cancel watch on '"+pathname+"'.",th);

                }

            }

//            LOGGER.info("cancelWatch(): exit, folder="+folder.hashCode()+", "+folder.toString()+".");

        }

    }

    private final List<FileObserver> fileObservers;

    private final Process process;

    private FileChangesObserver() {

        this.fileObservers = new ArrayList<>();

        this.process = new Process();

        this.process.start();

    }

    private int getWatchCounts(Path folder) {

        int count = 0;

        for (FileObserver fo : fileObservers) {

            if( folder.equals(fo.getFolder()) ) {

                count++;

            }

        }

        return count;

    }

    public void addObserver(final Observer observer, final File file) {

//        LOGGER.info("addObserver(): enter, observer="+observer.hashCode()+", f="+(file==null?"null":file.getAbsolutePath())+".");

        synchronized(fileObservers) {

            for (FileObserver fileObserver : fileObservers) {

                if( fileObserver.is(observer,file) ) {

//                    LOGGER.info("addObserver(): exit, already registered, observer="+observer.hashCode()+", f="+(file==null?"null":file.getAbsolutePath())+".");

                    return;

                }

            }

            removeDeads();

            FileObserver fobserver = new FileObserver(file, observer);        

            this.process.reqisterWatch(fobserver.getFolder());

            this.fileObservers.add(fobserver);

        }

//        LOGGER.info("addObserver(): exit, observer="+observer.hashCode()+", f="+(file==null?"null":file.getAbsolutePath())+".");

    }

    public void deleteObserver(final Observer observer) {

//        LOGGER.info("deleteObserver(): enter, observer="+observer.hashCode());

        synchronized(fileObservers) {

            for (FileObserver fileObserver : this.fileObservers) {

                if( fileObserver.is(observer) ) {

                    this.fileObservers.remove(fileObserver);

                    if( this.getWatchCounts(fileObserver.getFolder())<1 ) {

                        this.process.cancelWatch(fileObserver.getFolder());

                    }

                    return;

                }

            }

            removeDeads();

        }

//        LOGGER.info("deleteObserver(): exit, observer="+observer.hashCode());

    }

    public synchronized void removeDeads() {

//        LOGGER.info("removeDeads(): enter");

        synchronized(fileObservers) {

            int deads = 0;

            for (FileObserver fileObserver : this.fileObservers) {

                if( fileObserver.isDead() ) {

                    deads++;

                }

            }

            if( deads == 0 ) {

                return;

            }

            if( deads >= this.fileObservers.size() ) {

                this.fileObservers.clear();

                return;

            }

            List<FileObserver> lives = new ArrayList<>(this.fileObservers.size()-deads);

            for (FileObserver fileObserver : this.fileObservers) {

                if( fileObserver.isDead() ) {

                    if( this.getWatchCounts(fileObserver.getFolder())<1 ) {

                        this.process.cancelWatch(fileObserver.getFolder());

                    }

                } else {

                    lives.add(fileObserver);

                }

            }

            this.fileObservers.clear();

            this.fileObservers.addAll(lives);

        }

//        LOGGER.info("removeDeads(): exit");

    }

    public void deleteObservers() {

//        LOGGER.info("deleteObservers(): enter");

        List<FileObserver> x;

        synchronized(fileObservers) {

            x = this.fileObservers;

            this.fileObservers.clear();

        }

        for (FileObserver fileObserver : x) {

            this.process.cancelWatch(fileObserver.getFolder());

        }

//        LOGGER.info("deleteObservers(): exit");

    }

}