JNRPEClassLoader.java

/*******************************************************************************
 * Copyright (c) 2007, 2014 Massimiliano Ziccardi
 *
 * Licensed 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 it.jnrpe.server.plugins;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.net.URLClassLoader;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.List;
import java.util.jar.JarFile;

/**
 * A parent-last classloader that will try the child classloader first and then
 * the parent. This takes a fair bit of doing because java really prefers
 * parent-first.
 * 
 * For those not familiar with class loading trickery, be wary
 */
class JNRPEClassLoader extends ClassLoader {
    /**
     * The list of classloader urls.
     */
    private List<URL> classLoaderUrlList;

    /**
     * The child classloader.
     */
    private ChildURLClassLoader childClassLoader;

    /**
     * This class allows me to call findClass on a classloader.
     */
    private static class FindClassClassLoader extends ClassLoader {

        /**
         * Build the object specifing the parent classloader.
         * 
         * @param parent
         *            the parent classloader
         */
        public FindClassClassLoader(final ClassLoader parent) {
            super(parent);
        }

        @Override
        public Class<?> findClass(final String name) throws ClassNotFoundException {
            return super.findClass(name);
        }
    }

    /**
     * This class delegates (child then parent) for the findClass method for a
     * URLClassLoader. We need this because findClass is protected in
     * URLClassLoader
     */
    private static class ChildURLClassLoader extends URLClassLoader {
        /**
         * The parent classLoader.
         */
        private final FindClassClassLoader realParent;

        /**
         * Builds the childclassloader.
         * 
         * @param urls
         *            The list of classloader urls
         * @param parent
         *            The classloader parent
         */
        public ChildURLClassLoader(final URL[] urls, final FindClassClassLoader parent) {
            super(urls, null);

            this.realParent = parent;
        }

        @Override
        public Class<?> findClass(final String name) throws ClassNotFoundException {
            try {
                // first try to use the URLClassLoader findClass
                return super.findClass(name);
            } catch (ClassNotFoundException e) {
                // if that fails, we ask our real parent classloader to load the
                // class (we give up)
                return realParent.loadClass(name);
            }
        }
    }

    /**
     * Constructs the object with a list of classloader urls.
     * 
     * @param classpath
     *            The list of urls
     */
    public JNRPEClassLoader(final List<URL> classpath) {
        super(Thread.currentThread().getContextClassLoader());
        classLoaderUrlList = classpath;

        final URL[] urls = classpath.toArray(new URL[classpath.size()]);

        final ClassLoader parent = getParent();

        childClassLoader = AccessController.doPrivileged(new PrivilegedAction<ChildURLClassLoader>() {
            public ChildURLClassLoader run() {
                return new ChildURLClassLoader(urls, new FindClassClassLoader(parent));
            }

        });
        // childClassLoader = new ChildURLClassLoader(urls,
        // new FindClassClassLoader(this.getParent()));
    }

    @Override
    protected synchronized Class<?> loadClass(final String name, final boolean resolve) throws ClassNotFoundException {
        try {
            // first we try to find a class inside the child classloader
            return childClassLoader.findClass(name);
        } catch (ClassNotFoundException e) {
            // didn't find it, try the parent
            return super.loadClass(name, resolve);
        }
    }

    @Override
    protected URL findResource(final String name) {

        JarFile jf = null;
        try {
            for (URL u : classLoaderUrlList) {
                jf = new JarFile(u.getFile());
                String resourceUrl = "jar:" + new File(u.getFile()).toURI() + "!/" + name;
                if (jf.getEntry("jnrpe_plugins.xml") != null) {
                    return new URL(resourceUrl);
                }

                if (jf.getEntry("plugin.xml") != null) {
                    return new URL(resourceUrl);
                }
            }
            return null;
        } catch (IOException e) {
            throw new RuntimeException(e.getMessage(), e);
        } finally {
            if (jf != null) {
                try {
                    jf.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}