Application: gvSIG desktop » Library: org.gvsig.tools

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 * 

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 

 * MA  02110-1301, USA.

 * 

 */

package org.gvsig.tools.library;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.tools.exception.BaseRuntimeException;

import org.gvsig.tools.library.AbstractLibrary.Required;

/**

 * Base implementation of an {@link LibrariesInitializer} with the

 * initialization of Libraries already implemented, delegating on child classes

 * the finding of available {@link Library} objects.

 * <p>

 * This class is NOT thread safe.

 * </p>

 * 

 * @author <a href="mailto:cordinyana@gvsig.org">C?sar Ordi?ana</a>

 */

public abstract class AbstractLibrariesInitializer implements

    LibrariesInitializer {

    private static final Logger LOG = LoggerFactory

        .getLogger(AbstractLibrariesInitializer.class);

    private Collection libs;

    private boolean libsLoaded = false;

    private final ClassLoader[] classLoaders;

    public AbstractLibrariesInitializer() {

        classLoaders = null;

    }

    public AbstractLibrariesInitializer(ClassLoader classLoader) {

        this(new ClassLoader[] { classLoader });

    }

    public AbstractLibrariesInitializer(ClassLoader[] classLoaders) {

        this.classLoaders = classLoaders;

    }

    public void initialize() {

        this.initialize(false);

    }

    public void initialize(boolean ignoreerrors) {

        if (!libsLoaded) {

            loadLibraries(classLoaders, ignoreerrors);

            libsLoaded = true;

        }

        if (libs != null && libs.size() > 0) {

            // Call all initialize()

            initializeLibraries(libs, false, ignoreerrors);

        }

    }

    public void postInitialize() {

        this.postInitialize(false);

    }

    public void postInitialize(boolean ignoreerrors) {

        if (!libsLoaded) {

            loadLibraries(classLoaders, ignoreerrors);

            libsLoaded = true;

        }

        if (libs != null && libs.size() > 0) {

            // Call all postInitialize()

            initializeLibraries(libs, true, ignoreerrors);

        }

    }

    public void fullInitialize() {

        initialize();

        postInitialize();

    }

    public void fullInitialize(boolean ignoreerrors) {

        initialize(ignoreerrors);

        postInitialize(ignoreerrors);

    }

    public List getLibraries() {

        if (!libsLoaded) {

            loadLibraries(classLoaders, false);

            libsLoaded = true;

        }

        return new ArrayList(this.libs);

    }

    private void loadLibraries(ClassLoader[] classLoaders, boolean ignoreerrors) {

        // Find the available Library instances

        Set libs = new HashSet();

        LOG.info("Loading libraries of classloaders:");

        if (classLoaders == null) {

            addLibrariesOfClassLoader(libs, null, ignoreerrors);

        } else {

            for (int i = 0; i < classLoaders.length; i++) {

                addLibrariesOfClassLoader(libs, classLoaders[i], ignoreerrors);

            }

        }

        int fullSize = libs.size();

        this.libs = new OrderedLibs(libs);

        if (LOG.isInfoEnabled()) {

            logLibraries(this.libs, fullSize);

        }

    }

    private void addLibrariesOfClassLoader(Set previousFoundLibs,

        ClassLoader classLoader, boolean ignoreerrors) {

        StringBuffer logBuf = new StringBuffer();

        try {

            Set foundLibs = findLibraries(Library.class, classLoader);

            foundLibs.removeAll(previousFoundLibs);

            logBuf

                .append(new Integer(foundLibs.size()))

                .append(" new libraries found in the classloader ")

                .append(

                    classLoader == null ? "DEFAULT" : classLoader.toString())

                .append(":");

            for (Iterator iterator = foundLibs.iterator(); iterator.hasNext();) {

                Library library = (Library) iterator.next();

                try {

                    library.doRegistration();

                } catch (Throwable e) {

                    manageLibraryException(ignoreerrors, "doRegistration",

                        library, e);

                }

                previousFoundLibs.add(library);

                logBuf.append("\n- ").append(library);

            }

            LOG.info(logBuf.toString());

        } catch (Exception e) {

            String msg =

                MessageFormat.format(

                    "Error finding libraries of classloader {0}",

                    new String[] { classLoader.toString() });

            manageLibraryException(ignoreerrors, msg, e);

        }

    }

    protected abstract Set findLibraries(Class libraryClass,

        ClassLoader classLoader);

    private void initializeLibraries(Collection libs, boolean post,

        boolean ignoreerrors) {

        String label;

        if (post) {

            label = "postInitialize";

        } else {

            label = "initialize";

        }

        for (Iterator iterator = libs.iterator(); iterator.hasNext();) {

            Library lib = (Library) iterator.next();

            try {

                if (post) {

                    LOG.trace("Calling {}.postInitialize()", lib.getClass()

                        .getName());

                    lib.postInitialize();

                } else {

                    LOG.trace("Calling {}.initialize()", lib.getClass()

                        .getName());

                    lib.initialize();

                }

            } catch (Throwable e) {

                manageLibraryException(ignoreerrors, label, lib, e);

            }

        }

    }

    private void manageLibraryException(boolean ignoreerrors, String label,

        Library lib, Throwable e) {

        String msg;

        if (e instanceof BaseRuntimeException) {

            msg = ((BaseRuntimeException) e).getLocalizedMessageStack();

        } else {

            msg = e.getLocalizedMessage();

        }

        String formattedMsg =

            MessageFormat.format("Error in {0} of library {1}. {2}",

                new String[] { label, lib.getClass().getName(), msg });

        manageLibraryException(ignoreerrors, formattedMsg, e);

    }

    private void manageLibraryException(boolean ignoreerrors, String message,

        Throwable e) {

        if (ignoreerrors) {

            LOG.error(message, e);

        } else {

            if (e instanceof RuntimeException) {

                throw (RuntimeException) e;

            } else

                if (e instanceof Error) {

                    throw (Error) e;

                }

        }

    }

    private void logLibraries(Collection libs, int fullSize) {

        StringBuffer buffer = new StringBuffer();

        buffer.append("Total libraries to initialize (")

            .append(libs == null ? 0 : libs.size()).append(" of ")

            .append(fullSize).append("):");

        if (libs != null) {

            for (Iterator iterator = libs.iterator(); iterator.hasNext();) {

                buffer.append("\n- ").append(iterator.next());

            }

        }

        LOG.info(buffer.toString());

    }

    private static class OrderedLibs extends LinkedHashSet {

        private static final long serialVersionUID = -8546268624773345053L;

        private Map organizedLibs = new HashMap();

        OrderedLibs(Set libs) {

            Iterator iterator = libs.iterator();

            while (iterator.hasNext()) {

                Library lib = (Library) iterator.next();

                addLibrary(lib);

            }

            iterator = libs.iterator();

            while (iterator.hasNext()) {

                Library lib = (Library) iterator.next();

                if (lib.getLibrary() != null && lib.getType() != null) {

                    // Always add services

                    if (Library.TYPE.SERVICE.equals(lib.getType())) {

                        this.add(lib);

                    } else {

                        String libName = getLibName(lib);

                        if (this.organizedLibs.containsKey(libName)) {

                            Library storeLib =

                                (Library) this.organizedLibs.get(libName);

                            // Only add a library if it has the greatest

                            // priority

                            if (lib.getPriority() >= storeLib.getPriority()) {

                                this.add(lib);

                            }

                        }

                    }

                } else {

                    this.add(lib);

                }

            }

        }

        private String getLibName(Library lib) {

            return lib.getLibrary().getName() + "-" + lib.getType();

        }

        private void addLibrary(Library lib) {

            if (lib.getLibrary() != null && lib.getType() != null) {

                String libName = getLibName(lib);

                if (Library.TYPE.SERVICE.equals(lib.getType())) {

                    Set serviceLibs;

                    if (this.organizedLibs.containsKey(libName)) {

                        serviceLibs = (Set) this.organizedLibs.get(libName);

                    } else {

                        serviceLibs = new HashSet();

                        this.organizedLibs.put(libName, serviceLibs);

                    }

                    serviceLibs.add(lib);

                    // Also add the library as itself of type implementation,

                    // just in case another library depends on it. Only for

                    // libraries whose type is SERVICE.

                    this.organizedLibs.put(lib.getClass().getName() + "-"

                        + Library.TYPE.IMPL, lib);

                } else

                    if (this.organizedLibs.containsKey(libName)) {

                        Library previousLibrary =

                            (Library) this.organizedLibs.get(libName);

                        LOG.warn(

                            "There's already a library initialized with the "

                                + "name '{}': '{}'  with priority '{}'"

                                + ", and '{}' with priority '{}",

                            new Object[] { libName,

                                previousLibrary.getClass().getName(),

                                String.valueOf(previousLibrary.getPriority()),

                                lib.getClass().getName(),

                                String.valueOf(lib.getPriority()) });

                        if (lib.getPriority() < previousLibrary.getPriority()) {

                            LOG.info(

                                "Old library '{}' with priority '{}'  was chosen.",

                                previousLibrary.getClass().getName(),

                                String.valueOf(previousLibrary.getPriority()));

                        } else {

                            this.organizedLibs.put(libName, lib);

                            LOG.info(

                                "New library '{}' with priority '{}'  was chosen.",

                                lib.getClass().getName(),

                                String.valueOf(lib.getPriority()));

                        }

                    } else {

                        this.organizedLibs.put(libName, lib);

                    }

            }

        }

        public void add(Library lib) {

            if (super.contains(lib)) {

                return;

            }

            Set requireds = lib.getRequireds();

            if (requireds != null) {

                Iterator iterator = requireds.iterator();

                while (iterator.hasNext()) {

                    Required req = (Required) iterator.next();

                    if (!req.isAdded()) {

                        req.setAdded(true);

                        addRequiredLibrary(req);

                    }

                }

            }

            if (lib.getLibrary() != null && lib.getType() != null) {

                organizedLibs.remove(getLibName(lib));

            }

            if (!super.contains(lib)) {

                super.add(lib);

            }

            String name = lib.getClass().getName();

            // Add as required all the related types so the library

            // has all implementation and services initialized

            if (Library.TYPE.API.equals(lib.getType())) {

                addRequiredLibrary(name, Library.TYPE.IMPL);

                addRequiredLibrary(name, Library.TYPE.SERVICE);

            }

        }

        private void addRequiredLibrary(Required req) {

            if (req.getLibrary() != null) {

                String name = req.getLibrary().getName();

                addRequiredLibrary(name, req.getType());

            }

        }

        private void addRequiredLibrary(String libraryName, String libraryType) {

            String type = getLibraryType(libraryName, libraryType);

            if (Library.TYPE.SERVICE.equals(type)) {

                Set libSet = (Set) organizedLibs.get(libraryName + "-" + type);

                if (libSet != null) {

                    for (Iterator iterator = libSet.iterator(); iterator

                        .hasNext();) {

                        this.add((Library) iterator.next());

                    }

                }

            } else {

                Library lib =

                    (Library) organizedLibs.get(libraryName + "-" + type);

                if (lib != null) {

                    this.add(lib);

                }

            }

        }

        private String getLibraryType(String libraryName, String libraryType) {

            if (libraryType != null) {

                return libraryType;

            }

            if (organizedLibs.get(libraryName + "-" + Library.TYPE.SERVICE) != null) {

                return Library.TYPE.SERVICE;

            } else

                if (organizedLibs.get(libraryName + "-" + Library.TYPE.IMPL) != null) {

                    return Library.TYPE.IMPL;

                } else {

                    return Library.TYPE.API;

                }

        }

    }

}