CatalinaJWebContainerServiceWrapper.java

package org.objectweb.jonas.web.wrapper;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.rmi.RemoteException;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.naming.Context;

import org.objectweb.jonas.server.LoaderManager;
import org.objectweb.jonas.service.ServiceException;
import org.objectweb.jonas.web.AbsJWebContainerServiceImplMBean;
import org.objectweb.jonas.web.JWebContainerServiceException;
import org.objectweb.jonas.web.War;


public class CatalinaJWebContainerServiceWrapper implements CatalinaJWebContainerService, AbsJWebContainerServiceImplMBean {

    private ClassLoader catalinaLoader = null;

    private Object catalinaService = null;

    private Map methods = null;

    private static final String CATALINA_SERVICE_CLASSNAME = "org.objectweb.jonas.web.catalina50.CatalinaJWebContainerServiceImpl";

    public CatalinaJWebContainerServiceWrapper() throws ServiceException {
        LoaderManager lm = LoaderManager.getInstance();
        try {
            catalinaLoader = lm.getCatalinaLoader();
        } catch (Exception e) {
            // TODO add i18n error message
            throw new ServiceException("Cannot get Catalina ClassLoader", e);
        }
        methods = new Hashtable();

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }

    }

    public void deployWars(Context ctx) throws JWebContainerServiceException {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }

        // method invokation
        Method m = (Method) methods.get("deployWars");
        if (m == null) {
            m = getMethod("deployWars", new Class[] {Context.class});
        }

        invoke(m, new Object[] {ctx});
    }

    public War getWar(URL url) {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }

        // method invokation
        Method m = (Method) methods.get("getWar");
        if (m == null) {
            m = getMethod("getWar", new Class[] {URL.class});
        }

        return (War) invoke(m, new Object[] {url});

    }
    private Object invoke(Method m, Object[] params) {
        ClassLoader old = null;
        try {
            old = Thread.currentThread().getContextClassLoader();
            Thread.currentThread().setContextClassLoader(catalinaLoader);
            return m.invoke(catalinaService, params);
        } catch (InvocationTargetException e) {
            if (e.getTargetException() instanceof Error) {
                throw (Error) e.getTargetException();
            } else if (e.getTargetException() instanceof ServiceException) {
                throw (ServiceException) e.getTargetException();
            } else {
//              TODO add i18n error message
                throw new ServiceException("Problems when invoking " + m.getName(), e.getTargetException());
            }
        } catch (Exception e) {
//          TODO add i18n error message
            throw new ServiceException("Problems when invoking " + m.getName(), e);
        } finally {
            if (old != null) {
                Thread.currentThread().setContextClassLoader(old);
            }
        }
    }

    private Method getMethod(String methodName, Class[] paramTypes) throws ServiceException {
        try {
            Method m = catalinaService.getClass().getMethod(methodName, paramTypes);
            methods.put(methodName, m);
            return m;
        } catch (Exception e) {
            throw new ServiceException("Problems when retrieving " + methodName + " method", e);
        }
    }

    private Object getCatalinaServiceInstance() throws ServiceException {
        try {
            Class service = catalinaLoader.loadClass(CATALINA_SERVICE_CLASSNAME);
            return service.newInstance();
        } catch (Exception e) {
            throw new JWebContainerServiceException("Problems when loading " + CATALINA_SERVICE_CLASSNAME, e);
        }
    }

    public void unDeployWars(URL[] urls) {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }
        // method invokation
        Method m = (Method) methods.get("unDeployWars");
        if (m == null) {
            m = getMethod("unDeployWars", new Class[] {URL[].class});
        }

        invoke(m, new Object[] {urls});

    }

    public void removeCache(ClassLoader earClassLoader) {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }
        // method invokation
        Method m = (Method) methods.get("removeCache");
        if (m == null) {
            m = getMethod("removeCache", new Class[] {ClassLoader.class});
        }

        invoke(m, new Object[] {earClassLoader});

    }

    public void registerWarMBean(String fileName) throws RemoteException, JWebContainerServiceException {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }
        // method invokation
        Method m = (Method) methods.get("registerWarMBean");
        if (m == null) {
            m = getMethod("registerWarMBean", new Class[] {String.class});
        }

        invoke(m, new Object[] {fileName});

    }

    public void unRegisterWarMBean(String fileName) throws RemoteException, JWebContainerServiceException {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }
        // method invokation
        Method m = (Method) methods.get("unRegisterWarMBean");
        if (m == null) {
            m = getMethod("unRegisterWarMBean", new Class[] {String.class});
        }

        invoke(m, new Object[] {fileName});

    }

    public List getInstalledWars() throws Exception {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }
        // method invokation
        Method m = (Method) methods.get("getInstalledWars");
        if (m == null) {
            m = getMethod("getInstalledWars", new Class[] {});
        }

        return (List) invoke(m, new Object[] {});

    }

    public Integer getCurrentNumberOfWars() {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }
        // method invokation
        Method m = (Method) methods.get("getCurrentNumberOfWars");
        if (m == null) {
            m = getMethod("getCurrentNumberOfWars", new Class[] {});
        }

        return (Integer) invoke(m, new Object[] {});

    }

    public Set getWarNames() {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }
        // method invokation
        Method m = (Method) methods.get("getWarNames");
        if (m == null) {
            m = getMethod("getWarNames", new Class[] {});
        }

        return (Set) invoke(m, new Object[] {});

    }

    public boolean isWarLoaded(String fileName) {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }
        // method invokation
        Method m = (Method) methods.get("isWarLoaded");
        if (m == null) {
            m = getMethod("isWarLoaded", new Class[] {String.class});
        }

        return ((Boolean) invoke(m, new Object[] {fileName})).booleanValue();

    }

    public String getServerName() {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }
        // method invokation
        Method m = (Method) methods.get("getServerName");
        if (m == null) {
            m = getMethod("getServerName", new Class[] {});
        }

        return (String) invoke(m, new Object[] {});

    }

    public String getServerVersion() {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }
        // method invokation
        Method m = (Method) methods.get("getServerVersion");
        if (m == null) {
            m = getMethod("getServerVersion", new Class[] {});
        }

        return (String) invoke(m, new Object[] {});

    }

    public List getDeployedWars() {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }
        // method invokation
        Method m = (Method) methods.get("getDeployedWars");
        if (m == null) {
            m = getMethod("getDeployedWars", new Class[] {});
        }

        return (List) invoke(m, new Object[] {});

    }

    public List getDeployableWars() throws Exception {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }
        // method invokation
        Method m = (Method) methods.get("getDeployableWars");
        if (m == null) {
            m = getMethod("getDeployableWars", new Class[] {});
        }

        return (List) invoke(m, new Object[] {});

    }

    public List getAutoloadDirectories() {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }
        // method invokation
        Method m = (Method) methods.get("getAutoloadDirectories");
        if (m == null) {
            m = getMethod("getAutoloadDirectories", new Class[] {});
        }

        return (List) invoke(m, new Object[] {});

    }

    public String getWebappsDirectory() {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }
        // method invokation
        Method m = (Method) methods.get("getWebappsDirectory");
        if (m == null) {
            m = getMethod("getWebappsDirectory", new Class[] {});
        }

        return (String) invoke(m, new Object[] {});

    }

    public void init(Context ctx) throws ServiceException {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }
        // method invokation
        Method m = (Method) methods.get("init");
        if (m == null) {
            m = getMethod("init", new Class[] {Context.class});
        }

        invoke(m, new Object[] {ctx});

    }

    public void start() throws ServiceException {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }
        // method invokation
        Method m = (Method) methods.get("start");
        if (m == null) {
            m = getMethod("start", new Class[] {});
        }

        invoke(m, new Object[] {});
    }

    public void stop() throws ServiceException {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }
        // method invokation
        Method m = (Method) methods.get("stop");
        if (m == null) {
            m = getMethod("stop", new Class[] {});
        }

        invoke(m, new Object[] {});

    }

    public boolean isStarted() {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }
        // method invokation
        Method m = (Method) methods.get("isStarted");
        if (m == null) {
            m = getMethod("isStarted", new Class[] {});
        }

        return ((Boolean) invoke(m, new Object[] {})).booleanValue();

    }

    public void setName(String name) {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }
        // method invokation
        Method m = (Method) methods.get("setName");
        if (m == null) {
            m = getMethod("setName", new Class[] {String.class});
        }

        invoke(m, new Object[] {name});

    }

    public String getName() {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }
        // method invokation
        Method m = (Method) methods.get("getName");
        if (m == null) {
            m = getMethod("getName", new Class[] {});
        }

        return (String) invoke(m, new Object[] {});

    }

    public String getDefaultHost() throws JWebContainerServiceException {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }
        // method invokation
        Method m = (Method) methods.get("getDefaultHost");
        if (m == null) {
            m = getMethod("getDefaultHost", new Class[] {});
        }

        return (String) invoke(m, new Object[] {});

    }

    public String getDefaultHttpPort() throws JWebContainerServiceException {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }
        // method invokation
        Method m = (Method) methods.get("getDefaultHttpPort");
        if (m == null) {
            m = getMethod("getDefaultHttpPort", new Class[] {});
        }

        return (String) invoke(m, new Object[] {});

    }

    public String getDefaultHttpsPort() throws JWebContainerServiceException {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }
        // method invokation
        Method m = (Method) methods.get("getDefaultHttpsPort");
        if (m == null) {
            m = getMethod("getDefaultHttpsPort", new Class[] {});
        }

        return (String) invoke(m, new Object[] {});

    }

    public URLClassLoader getClassLoader(URL warURL, String earAppName, ClassLoader parentLoader) throws JWebContainerServiceException {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }
        // method invokation
        Method m = (Method) methods.get("getClassLoader");
        if (m == null) {
            m = getMethod("getClassLoader", new Class[] {URL.class, String.class, ClassLoader.class});
        }

        return (URLClassLoader) invoke(m, new Object[] {warURL, earAppName, parentLoader});

    }

    public boolean isTomcatStarted() {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }
        // method invokation
        Method m = (Method) methods.get("isTomcatStarted");
        if (m == null) {
            m = getMethod("isTomcatStarted", new Class[] {});
        }

        return ((Boolean) invoke(m, new Object[] {})).booleanValue();

    }

    public ClassLoader getContextLinkedClassLoader(URL url) {

        if (catalinaService == null) {
            catalinaService = getCatalinaServiceInstance();
        }
        // method invokation
        Method m = (Method) methods.get("getContextLinkedClassLoader");
        if (m == null) {
            m = getMethod("getContextLinkedClassLoader", new Class[] {URL.class});
        }

        return (ClassLoader) invoke(m, new Object[] {url});

    }

}

---