source: src/main/java/geniusweb/partiesserver/AvailablePartiesUpdater.java@ 44

package geniusweb.partiesserver;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URISyntaxException;
import java.net.URL;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Collection;
import java.util.LinkedList;
import java.util.logging.Level;

import geniusweb.partiesserver.repository.AvailableJavaParty;
import geniusweb.partiesserver.repository.AvailablePartiesRepo;
import geniusweb.partiesserver.repository.AvailableParty;
import geniusweb.party.Party;
import tudelft.utilities.files.FileInfo;
import tudelft.utilities.files.FileWatcher;
import tudelft.utilities.immutablelist.Tuple;
import tudelft.utilities.listener.Listenable;
import tudelft.utilities.logging.ReportToLogger;
import tudelft.utilities.logging.Reporter;
import tudelft.utilities.repository.Repository;

/**
 * 
 * This object keeps the {@link AvailablePartiesRepo} in sync with the file
 * system. To work, this must be started in a global background thread,
 * independent of current sessions etc. This thread is created when the
 * constructor is called.
 * <p>
 * The {@link #PARTIESREPO} points to a directory that must exist. All the jar
 * files in there are collected and tested if they can be loaded and are then
 * added to the list of available parties.
 * <p>
 * Please make only 1 instance of this class. Double updates on the
 * {@link AvailablePartiesRepo} is not useful
 */
public class AvailablePartiesUpdater {
        private static final String PARTIESREPO = "partiesrepo";
        private final Path rootdir;
        private final Reporter log = new ReportToLogger("partiesserver");
        private final Listenable<Tuple<FileInfo, FileInfo>> watcher;
        private final Repository<String, AvailableParty> repository;

        /**
         * 
         * @param repo the repo to be automatically updated.
         */
        public AvailablePartiesUpdater(Repository<String, AvailableParty> repo) {
                this.repository = repo;
                this.rootdir = getRootDir();
                log.log(Level.INFO, "Repository located at " + this.rootdir);
                watcher = getFileWatcher(rootdir.toFile());
                watcher.addListener(info -> update(info));
                // manually trigger the first event.
                update(new Tuple<FileInfo, FileInfo>(null,
                                new FileInfo(rootdir.toFile(), 2)));
        }

        /**
         * Called when some file that may be relevant has changed. Synchronized to
         * avoid weird states if filesystem changes rapidly. We ignore everything
         * but jar files.
         */
        private synchronized void update(Tuple<FileInfo, FileInfo> info) {
                log.log(Level.INFO, "change: " + info);
                File oldfile = info.get1() == null ? null : info.get1().getFile();
                File newfile = info.get2() == null ? null : info.get2().getFile();

                File file = oldfile != null ? oldfile : newfile;

                Path relpath = file.toPath().relativize(rootdir);
                // workaround: root gives "" with depth 1 instead of 0.
                if (relpath.toString().isEmpty()) {
                        reset();
                        return;
                }

                // it's file or dir inside the root directory
                if (newfile == null) {
                        // file removed
                        repository.remove(getShortName(file));
                } else {
                        tryLoad(file);
                }

        }

        /**
         * @param jarfile a jarfile
         * @return the filename only, without extension
         * 
         */
        private String getShortName(File jarfile) {
                String partyname = jarfile.getName();
                return partyname.substring(0, partyname.length() - 4);

        }

        /**
         * Try to load a file. Report to logger if it fails to load.
         * 
         * @param file the file to load. Supposedly a jar file but we will report if
         *             not.
         */
        private void tryLoad(File file) {
                try {
                        repository.put(
                                        new AvailableJavaParty(getShortName(file), load(file)));
                } catch (Throwable e) {
                        log.log(Level.WARNING, "Can not load class from file " + file, e);
                }
        }

        /**
         * Try to load jarfile, check that it contains required info and that the
         * class can be instantiated.
         * 
         * @param jarfile the jarfile to load the class from
         * @return the loaded Class file from the jarfile (the class that is
         *         assigned as 'main class' in the manifest).
         * @throws IOException
         * @throws IllegalAccessException
         * @throws InstantiationException
         * @throws ClassNotFoundException
         * @throws IllegalArgumentException if the given file is not a jar file or
         *                                  can't be read. Or if the file has no
         *                                  manifest containing a main class.
         * @throws RuntimeException         if party throws something during
         *                                  construction or while handling calls to
         *                                  it.
         */
        @SuppressWarnings("unchecked")
        private Class<? extends Party> load(File jarfile)
                        throws IOException, InstantiationException, IllegalAccessException,
                        ClassNotFoundException {
                /**
                 * We can not call loader.close() as instances of this class may need to
                 * load more later on when they start running. Only when all instances
                 * are dead and gone we could close but it's not clear how to track the
                 * number of active instances nor how to get a callback on that here.
                 */
                JarClassLoader1 loader = new JarClassLoader1(toURL(jarfile),
                                getClass().getClassLoader());
                String mainclass = loader.getMainClassName();
                if (mainclass == null) {
                        throw new IllegalArgumentException(
                                        "jar file does not contain manifest with main class");
                }
                Class<? extends Party> partyclass = (Class<? extends Party>) loader
                                .loadClass(mainclass);
                partyclass.newInstance();
                return partyclass;
        }

        private URL toURL(File file) throws MalformedURLException {
                return new URL("jar:" + file.toURI().toURL() + "!/");
        }

        /**
         * Remove all parties and reload them all from scratch
         */
        private void reset() {
                Collection<AvailableParty> toremove = new LinkedList<>(
                                repository.list());
                for (AvailableParty party : toremove) {
                        repository.remove(party.getID());
                }
                File rootfile = rootdir.toFile();
                if (rootfile.exists() && rootfile.canRead() && rootfile.isDirectory()) {
                        for (File file : rootfile.listFiles()) {
                                tryLoad(file);
                        }
                } else {
                        log.log(Level.SEVERE, "Can not read repository root directory "
                                        + rootdir
                                        + ": it does not exist, can not be read or is not a directory.");
                }
        }

        /**
         * Search from location of this class upwards till we find a directory
         * called "domainsrepo".
         * 
         * @return the root dir of the repo. This is the 'database' where all known
         *         profiles are stored.
         */
        protected Path getRootDir() {
                // If you run this normal from tomcat we are somewhere inside
                // projectroot/WEB_INF/classes/....
                // Search back upwards to projectroot.
                Path dir;
                try {
                        dir = Paths.get(getClass().getProtectionDomain().getCodeSource()
                                        .getLocation().toURI()).getParent();
                } catch (URISyntaxException e) {
                        throw new RuntimeException("problem with path uri", e);
                }
                log.log(Level.INFO,
                                "searching for " + PARTIESREPO + " upwards from " + dir);
                while (dir.getNameCount() > 1) {
                        Path repo = dir.resolve(PARTIESREPO);
                        if (repo.toFile().exists())
                                return repo;
                        log.log(Level.INFO, "Directory did not contain repo:" + dir);
                        dir = dir.getParent();
                }
                return Paths.get(PARTIESREPO); // bit silly, it's not there, but we need
                                                                                // to do something.
        }

        /**
         * Factory method that gives a watcher for file changes. See
         * {@link FileWatcher}.
         * 
         * @param directory the directory to watch
         * @return a class that watches for file changes in the given directory.
         *         Should ignore changes in sub-directories
         */
        protected Listenable<Tuple<FileInfo, FileInfo>> getFileWatcher(
                        File directory) {
                return new FileWatcher(directory, 3000, 1);
        }
}