maint-5-2/tapestry-ioc/src/main/java/org/apache/tapestry5/ioc/internal/AbstractReloadableObjectCreator.java

// Copyright 2010 The Apache Software Foundation
//
// 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 org.apache.tapestry5.ioc.internal;

import java.io.File;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Set;

import javassist.CannotCompileException;
import javassist.ClassPath;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.Loader;
import javassist.LoaderClassPath;
import javassist.NotFoundException;
import javassist.Translator;
import javassist.expr.ConstructorCall;
import javassist.expr.ExprEditor;
import javassist.expr.FieldAccess;
import javassist.expr.MethodCall;
import javassist.expr.NewExpr;

import org.apache.tapestry5.ioc.Invokable;
import org.apache.tapestry5.ioc.ObjectCreator;
import org.apache.tapestry5.ioc.OperationTracker;
import org.apache.tapestry5.ioc.ReloadAware;
import org.apache.tapestry5.ioc.internal.services.ClassFactoryClassPool;
import org.apache.tapestry5.ioc.internal.util.CollectionFactory;
import org.apache.tapestry5.ioc.internal.util.InternalUtils;
import org.apache.tapestry5.ioc.internal.util.URLChangeTracker;
import org.apache.tapestry5.ioc.services.ClassFabUtils;
import org.apache.tapestry5.services.UpdateListener;
import org.slf4j.Logger;

@SuppressWarnings("all")
public abstract class AbstractReloadableObjectCreator implements ObjectCreator, UpdateListener, Translator
{
    private class InternalLoader extends Loader
    {
        public InternalLoader(ClassLoader parent, ClassPool pool)
        {
            super(parent, pool);
        }

        @Override
        protected Class findClass(String name) throws ClassNotFoundException
        {
            if (shouldLoadClassNamed(name))
                return super.findClass(name);

            return null; // Force delegation to parent class loader
        }
    }

    private final ClassLoader baseClassLoader;

    private final String implementationClassName;

    private final String classFilePath;

    private final Logger logger;

    private final OperationTracker tracker;

    private final URLChangeTracker changeTracker = new URLChangeTracker();

    /**
     * The set of class names that should be loaded by the class loader. This is necessary to support
     * reloading the class when a base class changes, and to properly support access to protected methods.
     */
    private final Set<String> classesToLoad = CollectionFactory.newSet();

    private Object instance;

    private boolean firstTime = true;

    protected AbstractReloadableObjectCreator(ClassLoader baseClassLoader, String implementationClassName,
            Logger logger, OperationTracker tracker)
    {
        this.baseClassLoader = baseClassLoader;
        this.implementationClassName = implementationClassName;
        this.logger = logger;
        this.tracker = tracker;

        classFilePath = ClassFabUtils.getPathForClassNamed(implementationClassName);
    }

    public synchronized void checkForUpdates()
    {
        if (instance == null)
            return;

        if (!changeTracker.containsChanges())
            return;

        if (logger.isDebugEnabled())
            logger.debug(String.format("Implementation class %s has changed and will be reloaded on next use.",
                    implementationClassName));

        changeTracker.clear();

        boolean reloadNow = informInstanceOfReload();

        instance = reloadNow ? createInstance() : null;
    }

    private boolean informInstanceOfReload()
    {
        if (instance instanceof ReloadAware)
        {
            ReloadAware ra = (ReloadAware) instance;

            return ra.shutdownImplementationForReload();
        }

        return false;
    }

    public synchronized Object createObject()
    {
        if (instance == null)
            instance = createInstance();

        return instance;
    }

    private Object createInstance()
    {
        return tracker.invoke(String.format("Reloading class %s.", implementationClassName), new Invokable<Object>()
        {
            public Object invoke()
            {
                Class reloadedClass = reloadImplementationClass();

                return createInstance(reloadedClass);
            };
        });
    }

    /**
     * Invoked when an instance of the class is needed. It is the responsibility of this method (as implemented in a
     * subclass) to instantiate the class and inject dependencies into the class.
     * 
     * @see InternalUtils#findAutobuildConstructor(Class)
     */
    abstract protected Object createInstance(Class clazz);

    private Class reloadImplementationClass()
    {
        if (logger.isDebugEnabled())
            logger.debug(String.format("%s class %s.", firstTime ? "Loading" : "Reloading", implementationClassName));

        ClassFactoryClassPool pool = new ClassFactoryClassPool(baseClassLoader);

        ClassLoader threadDeadlockBuffer = new URLClassLoader(new URL[0], baseClassLoader);

        Loader loader = new InternalLoader(threadDeadlockBuffer, pool);

        ClassPath path = new LoaderClassPath(loader);

        pool.appendClassPath(path);

        classesToLoad.clear();
        add(implementationClassName);

        try
        {
            loader.addTranslator(pool, this);

            Class result = loader.loadClass(implementationClassName);

            firstTime = false;

            return result;
        }
        catch (Throwable ex)
        {
            throw new RuntimeException(String.format("Unable to %s class %s: %s", firstTime ? "load" : "reload",
                    implementationClassName, InternalUtils.toMessage(ex)), ex);
        }
    }

    private boolean shouldLoadClassNamed(String name)
    {
        return classesToLoad.contains(name);
    }

    private void add(String className)
    {
        if (classesToLoad.contains(className))
            return;

        logger.debug(String.format("Marking class %s to be (re-)loaded", className));

        classesToLoad.add(className);
    }

    public void onLoad(ClassPool pool, String className) throws NotFoundException, CannotCompileException
    {
        logger.debug(String.format("BEGIN Analyzing %s", className));

        analyze(pool, className);

        trackClassFileChanges(className);

        logger.debug(String.format("  END Analyzing %s", className));
    }

    private void analyze(ClassPool pool, String className) throws NotFoundException, CannotCompileException
    {
        CtClass ctClass = pool.get(className);

        CtClass[] nestedClasses = ctClass.getNestedClasses();

        for (CtClass nc : nestedClasses)
        {
            add(nc.getName());
        }

        ctClass.instrument(new ExprEditor()
        {
            public void edit(ConstructorCall c) throws CannotCompileException
            {
                if (c.getMethodName().equals("this"))
                    return;

                String cn = c.getClassName();

                String classFilePath = ClassFabUtils.getPathForClassNamed(cn);

                URL url = baseClassLoader.getResource(classFilePath);

                // If the base class is also a file on the file system then mark
                // that it should be loaded by the same class loader. This serves two
                // purposes: first, if the base class is in the same package then
                // protected access will work properly. Secondly, if the base implementation
                // changes, the service implementation will be reloaded.

                if (url != null && url.getProtocol().equals("file"))
                    add(cn);
            }
        });
    }

    private void trackClassFileChanges(String className)
    {
        if (isInnerClassName(className))
            return;

        String path = ClassFabUtils.getPathForClassNamed(className);

        URL url = baseClassLoader.getResource(path);

        if (url != null && url.getProtocol().equals("file"))
            changeTracker.add(url);
    }

    private boolean isInnerClassName(String className)
    {
        return className.indexOf('$') >= 0;
    }

    /** Does nothing. */
    public void start(ClassPool pool) throws NotFoundException, CannotCompileException
    {

    }

}