ResourceServiceImpl.java

package org.objectweb.jonas.resource;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.rmi.RemoteException;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.Vector;

import javax.management.InstanceAlreadyExistsException;
import javax.management.InstanceNotFoundException;
import javax.management.MBeanRegistrationException;
import javax.management.MBeanServer;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

import javax.resource.spi.XATerminator;

import org.objectweb.transaction.jta.TransactionManager;

import org.objectweb.jonas_rar.deployment.lib.wrapper.RarManagerWrapper;

import org.objectweb.jonas.common.JModule;
import org.objectweb.jonas.common.JProp;
import org.objectweb.jonas.common.Log;
import org.objectweb.jonas.jmx.JmxService;
import org.objectweb.jonas.jmx.JonasObjectName;
import org.objectweb.jonas.jtm.TransactionService;
import org.objectweb.jonas.naming.CompNamingContext;
import org.objectweb.jonas.server.LoaderManager;
//import org.objectweb.jonas.server.JClassLoader;
import org.objectweb.jonas.service.AbsServiceImpl;
import org.objectweb.jonas.service.ServiceException;
import org.objectweb.jonas.service.ServiceManager;

import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.Logger;

public class ResourceServiceImpl extends AbsServiceImpl implements
    ResourceService,
    ResourceServiceImplMBean {

    // Loggers used in the ResourceService
    private static Logger logger = null;
    private static Logger poolLogger = null;
    private static Logger setterLogger = null;
    private static Logger manageLogger = null;

    // Properties for inits

    // JCA resource service configuration parameters
    public static final String AUTOLOADDIR = "jonas.service.resource.autoloaddir";
    public static final String CLASS = "jonas.service.resource.class";
    public static final String JNDI_NAME = "jndiname";
    public static final String RAR_OBJNAME = "rarobjname";
    public static final String FACTORY_OFFSET = "factoryoffset";
    public static final String FACTORY_TYPE = "factorytype";
    public static final String RAR_FILENAME = "rarfilename";
    public static final String LNK_JNDI_NAME = "lnkjndiname";
    public static final String LNK_RAR_FILENAME = "lnkrarfilename";
    public static final String JONAS_RA_XML = "jonasraxml";
    public static final String RA_XML = "raxml";
    public static final String PARSINGWITHVALIDATION = "jonas.service.resource.parsingwithvalidation";
    public static final String RESOURCE_LIST = "jonas.service.resource.resources";
    public static final String THREADWAITTIMEOUT = "jonas.service.resource.threadwaittimeout";
    public static final String MINWORKTHREADS = "jonas.service.resource.minworkthreads";
    public static final String MAXWORKTHREADS = "jonas.service.resource.maxworkthreads";
    public static final String EXECTIMEOUT = "jonas.service.resource.worktimeout";

    public static final int DEF_WRK_THREADWAITTIMEOUT = 60;
    public static final int DEF_WRK_THREADS = 5;
    public static final int DEF_MAX_WRK_THREADS = 80;
    public static final int DEF_EXEC_TIME = 0;

//    private static Hashtable jndiName2RA = new Hashtable();
//    private static Hashtable fileName2RA = new Hashtable();
//    private static Hashtable jndiName2Factory = new Hashtable();

    private Vector delayedRAs = new Vector();
    private boolean processingDelayed = false;

    private TransactionService ts = null;
    private TransactionManager tm = null;

    private MBeanServer mbeanServer = null;

    private Context ictx = null;

    private Vector autoNames = null;
    private Vector resourceNames = null;


    // J2EE CA 1.5 objects
    private ResourceWorkManager workMgr = null;
    private ResourceBootstrapContext bootCtx = null;

    public static final String JONAS_BASE = JProp.getJonasBase();

    public static final String WORK_RARS_DIR = JProp.getWorkDir() + File.separator + "rars";

    public static final String RARSDIR = JProp.getJonasBase() + File.separator + "rars";

    private ClassLoader appsClassLoader;

    public ResourceServiceImpl() {
    }

    //IMPLEMENTATION OF 'AbsServiceImpl' ABSTRACT CLASS
    public void doInit(Context ctx) {
        if (logger == null) {
            logger = Log.getLogger(Log.JONAS_JCA_PREFIX + ".process");
        }
        if (poolLogger == null) {
            poolLogger = Log.getLogger(Log.JONAS_JCA_PREFIX + ".pool");
        }
        if (setterLogger == null) {
            setterLogger = Log.getLogger(Log.JONAS_JCA_PREFIX + ".setters");
        }
        if (manageLogger == null) {
            manageLogger = Log.getLogger(Log.JONAS_JCA_PREFIX + ".management");
        }

        try {
            LoaderManager lm = LoaderManager.getInstance();
            appsClassLoader = lm.getAppsLoader();
        } catch (Exception e) {
            logger.log(BasicLevel.ERROR, "Cannot get the Applications ClassLoader from RAR Container Service: " + e);
            throw new ServiceException("Cannot get the Applications ClassLoader from RAR Container Service", e);
        }

        resourceNames = new Vector();
        autoNames = new Vector();

        // Avoid using NamingManager here: performance is not a goal here.
        try {
            ictx = new InitialContext();
        } catch (NamingException e) {
            logger.log(BasicLevel.ERROR, "Cannot create initial context when Resource service initializing");
            throw new ServiceException("Cannot create initial context when Resource service initializing", e);
        }

        // Add the rars of the jonas.service.resource.autoloaddir property
        String dirValue = null;
        try {
            dirValue = (String) ctx.lookup(AUTOLOADDIR);
            logger.log(BasicLevel.DEBUG, "autoloaddir= " + dirValue);
        } catch (NamingException e) {
            logger.log(BasicLevel.DEBUG, "No autoloaddir value specified in context, usually for client container");
        }
        if (dirValue != null) {
            StringTokenizer st = new StringTokenizer(dirValue, ",");
            String dirName = null;
            while (st.hasMoreTokens()) {
                dirName = normalizePath(st.nextToken().trim());
                addRars(dirName);
            }
        }

        // Get the list of the resource adapter names
        try {
            String rs = (String) ctx.lookup(RESOURCE_LIST);
            logger.log(BasicLevel.DEBUG, "resource list= " + rs);
            if (rs != null) {
                StringTokenizer st = new StringTokenizer(rs, ",");
                String resFilename = null;
                while (st.hasMoreTokens()) {
                    resFilename = normalizePath(st.nextToken().trim());
                    resourceNames.add(resFilename);
                }
            }
        } catch (NamingException e) {
            logger.log(BasicLevel.ERROR, "Cannot lookup the configuration context at Resource service starting");
        }

        // Get a reference to the Transaction service
        try {
            ServiceManager sm = ServiceManager.getInstance();
            ts = (TransactionService) sm.getTransactionService();
            tm = ts.getTransactionManager();
        } catch (Exception e) {
            logger.log(BasicLevel.ERROR, "Cannot get the Transaction service: " + e);
            throw new ServiceException("Cannot get the Transaction service: ", e);
        }

        // Get the JMX Server via JMX Service
        try {
            mbeanServer =
                ((JmxService) ServiceManager.getInstance().getJmxService()).getJmxServer();
        } catch (Exception e) {
            // the JMX service may not be started
            mbeanServer = null;
        }

        // Init the XML parsing mode to no validation
        String parsingMode = "false";
        try {
            parsingMode = (String) ctx.lookup(PARSINGWITHVALIDATION);
        } catch (NamingException e) {
            // No problem if there is no value for 'parsingwithvalidation' (false by default)
            logger.log(BasicLevel.DEBUG, "No parsingwithvalidation value specified in context");
        }
        if ("false".equalsIgnoreCase(parsingMode)) {
            RarManagerWrapper.setParsingWithValidation(false);
            logger.log(BasicLevel.DEBUG, "XML parsing without validation");
        } else {
            logger.log(BasicLevel.DEBUG, "XML parsing with validation");
        }

        // Get the parameters for the WorkManager
        int execTime = 0;
        try {
            String etime = (String) ctx.lookup(EXECTIMEOUT);
            execTime = (new Integer(etime)).intValue();
        } catch (NamingException e) {
            // No problem if there is no value --> default value
            logger.log(BasicLevel.DEBUG, "No exectimeout value specified in context, usually for client container");
        }

        // Thread wait timeout
        int threadWaitTimeout = DEF_WRK_THREADWAITTIMEOUT;
        try {
            String tTimeout = (String) ctx.lookup(THREADWAITTIMEOUT);
            threadWaitTimeout = (new Integer(tTimeout)).intValue();
            if (threadWaitTimeout <= 0) {
                threadWaitTimeout = DEF_WRK_THREADWAITTIMEOUT;
                logger.log(BasicLevel.DEBUG, "Resetting thread wait timeout to " + DEF_WRK_THREADWAITTIMEOUT);
            }
        } catch (Exception e) {
            // default value will be used.
            logger.log(BasicLevel.DEBUG, "No workthread wait timeout value specified in context");
        }

        // MIN thread pool size
        int minWorkThreads = DEF_WRK_THREADS;
        try {
            String wThreads = (String) ctx.lookup(MINWORKTHREADS);
            minWorkThreads = (new Integer(wThreads)).intValue();
            if (minWorkThreads <= 0) {
                minWorkThreads = DEF_WRK_THREADS;
                logger.log(BasicLevel.DEBUG, "Resetting min threads to " + DEF_WRK_THREADS);
            }
        } catch (Exception e) {
            // default value will be used.
            logger.log(BasicLevel.DEBUG, "No min workthreads value specified in context");
        }

        // MAX thread pool size
        int maxWorkThreads = DEF_MAX_WRK_THREADS;
        try {
            String wThreads = (String) ctx.lookup(MAXWORKTHREADS);
            maxWorkThreads = (new Integer(wThreads)).intValue();
            if (maxWorkThreads <= 0) {
                maxWorkThreads = DEF_MAX_WRK_THREADS;
                logger.log(BasicLevel.DEBUG, "Resetting max threads to " + DEF_WRK_THREADS);
            }
        } catch (Exception e) {
            // default value will be used.
            logger.log(BasicLevel.DEBUG, "No max workthreads value specified in context");
        }

        // Create WorkManager and BootstrapContext
        workMgr = new ResourceWorkManager(tm, minWorkThreads, maxWorkThreads, threadWaitTimeout, execTime, logger);
        XATerminator xat = null;
        try {
            xat = ts.getCurrent().getXATerminator();
        } catch (Exception ex) {
            logger.log(BasicLevel.ERROR, "Unable to get an XATerminator from the TransactionService");
            throw new ServiceException("Unable to get an XATerminator from the TransactionService", ex);
        }
        bootCtx = new ResourceBootstrapContext(workMgr, xat);

        logger.log(BasicLevel.DEBUG, "ResourceService initialized");
    }

    public void doStart() throws ServiceException {
        // creates each resource
        String rarFileName = null;
        CompNamingContext ctx = null;
        for (int i = 0; i < resourceNames.size(); i++) {
            rarFileName = (String) resourceNames.elementAt(i);
            logger.log(BasicLevel.DEBUG, "rarFileName=" + rarFileName);
            try {
                ctx = new CompNamingContext(rarFileName);
                ctx.rebind("rarFileName", rarFileName);
                ctx.rebind("isInEar", new Boolean(false));
                ctx.rebind("classloader", appsClassLoader);
                createResourceAdapter(ctx);
            } catch (Exception e) {
                logger.log(BasicLevel.ERROR, "JOnAS: Cannot create resource: " + rarFileName + " exception: " + e);
                e.printStackTrace();
            }
        }

        // process any delayed rars
        if (!delayedRAs.isEmpty()) {
          try {
            processingDelayed = true;
            Object [] rList = null;
            rList = delayedRAs.toArray();
            for (int i = 0; i < rList.length; i++) {
                try {
                    createResourceAdapter((CompNamingContext) rList[i]);
                } catch (Exception e) {
                    e.printStackTrace();
                    String rFile = (String) ((CompNamingContext) rList[i]).lookup("rarFileName");
                    logger.log(BasicLevel.ERROR, "JOnAS: Cannot create resource: " + rFile + " exception: " + e);
                    logger.log(BasicLevel.ERROR, "Please verify that the rarlink is correct/deployed");
                }
            }
          } catch (Exception e) {
             e.printStackTrace();
             logger.log(BasicLevel.ERROR, "ResourceService: Error with delayed RAR file deployment\n" + e);
             throw new ServiceException("ResourceService: Error with delayed RAR file deployment", e);
          }
        }

        // Create and register the Resource Service MBean
        if (mbeanServer != null) {
            try {
                mbeanServer.registerMBean(this, JonasObjectName.resourceService());
            } catch (InstanceAlreadyExistsException iae) {
                logger.log(BasicLevel.ERROR, "Cannot start the Resource Service Already Exists:\n" + iae);
                throw new ServiceException("Cannot start the Resource Service Already Exists", iae);
            } catch (Exception e) {
                logger.log(BasicLevel.ERROR, "ResourceService: Cannot start the Resource service:\n" + e);
                throw new ServiceException("ResourceService: Cannot start the Resource service", e);
            }
        }

    }

    public void doStop() throws ServiceException {

        ServiceException se = null;
        synchronized (Rar.fileName2RA) {
            Enumeration keys = Rar.fileName2RA.elements();
            while (keys.hasMoreElements()) {
                Rar ra = (Rar) keys.nextElement();
                try {
                    ra.unRegister();
                    Rar.fileName2RA.remove(ra);
                } catch (Exception ex) {
                    logger.log(BasicLevel.ERROR, "ResourceService: Received the following:" + ex);
                    ex.printStackTrace();
                    if (se == null) {
                        se = new ServiceException(ex.getMessage());
                    }
                }
            }
        }
        // unregister resource MBeans
        if (mbeanServer != null) {
            try {
                // unregister resource Service MBean
                mbeanServer.unregisterMBean(JonasObjectName.resourceService());
            } catch  (MBeanRegistrationException mr) {
                logger.log(BasicLevel.ERROR, "Cannot cleanly stop the ResourceService: "
                                             + mr.getMessage());
            } catch  (InstanceNotFoundException infe) {
                logger.log(BasicLevel.ERROR, "Cannot cleanly stop the ResourceService: "
                                             + infe.getMessage());
            } catch (Exception e) {
                logger.log(BasicLevel.ERROR, "ResourceService: Cannot stop the Resource service:\n" + e);
                throw new ServiceException("ResourceService: Cannot stop the Resource service", e);
            }
        }

        if (se != null) {
            throw se;
        }
        logger.log(BasicLevel.DEBUG, "ResourceService stopped");
    }


    // IMPLEMENTATION OF 'ResourceService' INTERFACE //

    public String createResourceAdapter(Context ctx) throws Exception {

        // Parameters :
        // rarFileName, isInEar, classloader and possible AltDD and earUrl
        String rarFileName;
        try {
            rarFileName = (String) ctx.lookup("rarFileName");
            ctx.rebind("deployed", new Boolean(false));
        } catch (Exception ex) {
            String err = "Error while getting parameter from context param.";
            logger.log(BasicLevel.ERROR, err + ex.getMessage());
            throw new ResourceServiceException(err, ex);
        }

        logger.log(BasicLevel.DEBUG, rarFileName);
        if (!rarFileName.endsWith(".rar")) {
            rarFileName += ".rar";
            ctx.rebind("rarFileName", rarFileName);
        }

        // Determine if the RAR file exists
        File f = new File(rarFileName);
        if (!f.exists()) {
            boolean found = false;
            String resFileName = null;
            // In case of the name is a rar file name, check also in
            // the JONAS_BASE/rars directory
            resFileName = RARSDIR + File.separator + rarFileName;
            f = new File(resFileName);
            found = f.exists();
            if (found) {
                rarFileName = resFileName;
                ctx.rebind("rarFileName", rarFileName);
            } else {
                logger.log(BasicLevel.ERROR, "createResourceAdapter: " + resFileName + " not found");
                Exception e = new NamingException(resFileName + " not found");
                throw e;
            }
        }

        URL rarUrl = f.toURL();

        Rar rar = new Rar(ctx, getDomainName(), getJonasServerName(), workMgr, bootCtx);

        Context ctxRar = rar.processRar();

        boolean isDeployed = false;
        try {
            isDeployed = ((Boolean) ctx.lookup("deployed")).booleanValue();
        } catch (Exception ex) {
            String err = "Error while getting parameter(isDeployed) from context param.";
            logger.log(BasicLevel.ERROR, err + ex.getMessage());
            throw new ResourceServiceException(err, ex);
        }

        if (!isDeployed) {
            // If isDeployed in not set, then an rar-link was specified that is not deployed and if
            // we are already processing the delayed rar files, then throw an exception otherwise
            // update the delayedRAs vector and process it again later.
            if (processingDelayed) {
                logger.log(BasicLevel.ERROR, "ResourceService.createRA: Resource (" + rarFileName + ") contains an invalid rarlink.");
                throw new ResourceServiceException("resource input file incorrect: invalid rarlink");
            }
            delayedRAs.add(ctx);
            return null;
        }

        Vector jNames = rar.getJndinames();
        if (jNames != null) {
            for (int i = 0; i < jNames.size(); i++) {
                Rar.jndiName2RA.put(jNames.get(i), rar);
            }
        }

        // Processed and deployed rar, so add it to our lists
        Rar.fileName2RA.put(rarUrl.getPath(), rar);

        String onRar = null;
        try {
            onRar = (String) ctx.lookup("onRar");
        } catch (Exception ex) {
            String err = "Error while getting parameter(onRar) from context param.";
            logger.log(BasicLevel.ERROR, err + ex.getMessage());
            throw new ResourceServiceException(err, ex);
        }

        return onRar.toString();
    }


    public void deployRars(Context ctx) throws ResourceServiceException {

        // Gets the parameters from the context :
        //    - urls the list of the urls of the rars to deploy.
        //    - earRootURL the URL of the ear application file.
        //    - earClassLoader the ear classLoader of the j2ee app.
        //    - altDDs the optional URI of deployment descriptor.
        URL[] urls = null;
        URL earUrl = null;
        ClassLoader earClassLoader = null;
        URL[] altDDs = null;
        try {
            urls = (URL[]) ctx.lookup("urls");
            earUrl = (URL) ctx.lookup("earUrl");
            earClassLoader = (ClassLoader) ctx.lookup("earClassLoader");
            altDDs = (URL[]) ctx.lookup("altDDs");
        } catch (NamingException e) {
            String err = "Error while getting parameter from context param ";
            logger.log(BasicLevel.ERROR, err + e.getMessage());
            throw new ResourceServiceException(err, e);
        }

        delayedRAs.clear(); // reset the delayed RAs
        // Deploy all the rars of the ear application.
        for (int i = 0; i < urls.length; i++) {
            // Get the name of a rar to deploy.
            String fileName = urls[i].getFile();
            logger.log(BasicLevel.DEBUG, "Deploy rar '" + fileName + "' for the ear service");

            // The context to give for the creation of the container
            // associated to the ejb-jar.
            Context contctx = null;
            try {
                contctx = new CompNamingContext(fileName);
                contctx.rebind("rarFileName", fileName);
                contctx.rebind("isInEar", new Boolean(true));
                contctx.rebind("earUrl", earUrl);
                if (altDDs[i] != null) {
                    contctx.rebind("altDD", altDDs[i]);
                }
                contctx.rebind("classloader", earClassLoader);
                createResourceAdapter(contctx);
            } catch (Exception e) {
                // A rar is corrupted so undeploy all the deployed rar
                // of the ear application.
                logger.log(BasicLevel.ERROR, "Error when deploying '" + fileName + "'");
                logger.log(BasicLevel.ERROR, e.getMessage());
                logger.log(BasicLevel.ERROR, "Undeploy rar of the ear application");

                for (int j = 0; j < i; j++) {
                    String rarFileName = urls[j].getFile();
                    try {
                        // Try to undeploy a rar of the ear application.
                        CompNamingContext compctx = new CompNamingContext(rarFileName);
                        compctx.rebind("rarFileName", rarFileName);
                        compctx.rebind("isInEar", new Boolean(true));
                        contctx.rebind("earUrl", earUrl);
                        unRegisterRar(compctx);
                    } catch (Exception ex) {
                        // Cannot undeploy a rar of the ear application
                        // So there is an error message.
                        logger.log(BasicLevel.ERROR, "Error when undeploying '" + rarFileName + "'");
                        logger.log(BasicLevel.ERROR, ex.getMessage());
                        logger.log(BasicLevel.ERROR, "Cannot undeploy rar of the ear application");
                    }

                }
                throw new ResourceServiceException("Error during the deployment", e);
            }
        }
        // process any delayed rars
        if (!delayedRAs.isEmpty()) {
          try {
            processingDelayed = true;
            Object [] rList = null;
            rList = delayedRAs.toArray();
            for (int i = 0; i < rList.length; i++) {
                try {
                    createResourceAdapter((CompNamingContext) rList[i]);
                } catch (Exception e) {
                    logger.log(BasicLevel.ERROR, "JOnAS: Cannot create resource: " + (String) rList[i] + " exception: " + e);
                    logger.log(BasicLevel.ERROR, "Please verify that the rarlink is correct");
                    e.printStackTrace();
                }
            }
          } catch (Exception e) {
            logger.log(BasicLevel.ERROR, "ResourceService: Error with delayed RAR file deployment\n" + e);
            throw new ServiceException("ResourceService: Error with delayed RAR file deployment", e);
          }
        }
    }


    public void unDeployRars(URL[] urls, URL earUrl) {
        for (int i = 0; i < urls.length; i++) {
            String fileName = urls[i].getFile();
            if (Rar.fileName2RA.containsKey(fileName)) {
                try {
                    // Try to undeploy a rar of the ear application.
                    CompNamingContext compctx = new CompNamingContext(fileName);
                    compctx.rebind("rarFileName", fileName);
                    compctx.rebind("isInEar", new Boolean(true));
                    compctx.rebind("earUrl", earUrl);
                    unRegisterRar(compctx);
                } catch (Exception ex) {
                    logger.log(BasicLevel.ERROR, "Cannot undeploy resource: " + fileName + " " + ex);
                }
            } else {
                logger.log(BasicLevel.ERROR, "Cannot remove the non-existant rar '" + fileName + "'");
            }
        }
    }


    public void unRegisterRar(Context ctx) throws Exception {
        String rarFileName;
        try {
            rarFileName = (String) ctx.lookup("rarFileName");
        } catch (NamingException e) {
            String err = "Error while getting parameter from context param.";
            logger.log(BasicLevel.ERROR, err + e.getMessage());
            throw new ResourceServiceException(err, e);
        } catch (Exception ex) {
            String err = "Error while getting parameter from context param.";
            logger.log(BasicLevel.ERROR, err + ex.getMessage());
            throw new ResourceServiceException(err, ex);
        }

        if (manageLogger.isLoggable(BasicLevel.DEBUG)) {
            manageLogger.log(BasicLevel.DEBUG, "TEST Unregister MBeans for RAR in file: " + rarFileName);
        }

        String rarPath = (new File(rarFileName)).toURL().getPath();
        Rar rar = (Rar) Rar.fileName2RA.get(rarPath);
        Vector jNames = rar.getJndinames();
        rar.unRegister();

        // Remove rars from hashtables
        for (int i = 0; i < jNames.size(); i++) {
            Rar.jndiName2RA.remove((String) jNames.get(i));
        }
        Rar.fileName2RA.remove(rarPath);
        resourceNames.remove(normalizePath(rarFileName));

        logger.log(BasicLevel.INFO,
                    "ResourceService: unRegisterRar: " + rarFileName);
    }

    //--------------------------------------------------------------
    //           MBean Methods
    //--------------------------------------------------------------

    public Integer getCurrentNumberOfResource() {
        return getCurrentNumberOfRars();
    }


    public Integer getCurrentNumberOfRars() {
        return new Integer(Rar.fileName2RA.size());
    }


    public List getDeployedRars() {
        ArrayList al = new ArrayList();
        String rarFileName = null;
        Enumeration keys = Rar.fileName2RA.keys();
        while (keys.hasMoreElements()) {
            rarFileName = keys.nextElement().toString();
            try {
                al.add((new File(rarFileName)).toURL().getPath());
            } catch (Exception e) {
                logger.log(BasicLevel.DEBUG, "Unable to add rarfile " + rarFileName + " to arraylist");
            }
        }
        return al;
    }

    public List getInstalledRars() throws Exception {
        // get JAR files found in JONAS_BASE/rars
        ArrayList al = JModule.getInstalledContainersInDir(RARSDIR, JModule.RAR_EXTENSION
            , JModule.RAR_CHILD_DIR, JModule.RAR_CONFIRM_FILE);
        // get RAR files found in all autoload directories
        for (int i = 0; i < autoNames.size(); i++) {
            al.addAll(JModule.getInstalledContainersInDir(autoNames.get(i).toString(),
                JModule.RAR_EXTENSION, JModule.RAR_CHILD_DIR, JModule.RAR_CONFIRM_FILE));
        }
        return al;
    }

    public Set getRarNames() {
        HashSet names = new HashSet();
        String rarFileName = null;
        for (int i = 0; i < resourceNames.size(); i++) {
            rarFileName = (String) resourceNames.elementAt(i);
            names.add(rarFileName);
        }
        return names;
    }


    public String deployRarMBean(String fileName) throws RemoteException, ResourceServiceException {
        Context ctx = null;
        String onRar = null;
        try {
            ctx = new CompNamingContext(fileName);
            ctx.rebind("rarFileName", fileName);
            ctx.rebind("isInEar", new Boolean(false));
            ctx.rebind("classloader", appsClassLoader);
            onRar = createResourceAdapter(ctx);
        } catch (Exception e) {
            String err = "Error when deploying the rar file: " + fileName;
            logger.log(BasicLevel.ERROR, err + e.getMessage());
            e.printStackTrace();
            throw new ResourceServiceException(err, e);
        }

        return onRar;
    }

    public String deployRar(String fileName) throws Exception {
        return deployRarMBean(fileName);
    }

    public Boolean isRarDeployed(String fileName) {
        return new Boolean(isRarLoaded(fileName));
    }

    public boolean isRarDeployedByUnpackName(String unpackName) {
        logger.log(BasicLevel.DEBUG, "entering for unpackName= " + unpackName);
/*        // for each rar loaded
        Enumeration lc = ears.elements();
        while (lc.hasMoreElements()) {
            Ear ear = (Ear) lc.nextElement();

            // get unpack name of the ear
            String deployedUnpackName = new File(ear.getUnpackName()).getName() ;
            logger.log(BasicLevel.DEBUG, "deployedUnpackName=" + deployedUnpackName);

            if (deployedUnpackName.equals(unpackName)) {
                return true;
            }
            // else, go to the next loop
        }
        // not found
*/
        return false;
    }

    public void unDeployRarMBean(String fileName) throws RemoteException, ResourceServiceException {
        /* We have only the name of the file, not its associated path, so we look in
           the current directory and in the rar applications directory
        */

        boolean found = true;
        logger.log(BasicLevel.DEBUG, "Trying to undeploy: " + fileName
                                     + " with the following deployed:" + Rar.fileName2RA);

        try {
            // Determine if the RAR is in list
            File f = new File(fileName);
            if (!Rar.fileName2RA.containsKey(f.toURL().getPath())) {
                found = false;
                // Check also in the JONAS_BASE/rars directory
                String resFileName = RARSDIR + File.separator + fileName;
                f = new File(resFileName);
                if (Rar.fileName2RA.containsKey(f.toURL().getPath())) {
                    fileName = resFileName;
                    found = true;
                }
            }

            if (!found) {
                String err = "Cannot undeploy the rar '" + fileName + "', it is not deployed.";
                logger.log(BasicLevel.ERROR, err);
                throw new ResourceServiceException(err);
            }
        } catch (Exception ex) {
            String err = "Error trying to undeployRarMBean " + fileName;
            logger.log(BasicLevel.ERROR, err + ex.getMessage());
            throw new ResourceServiceException(err, ex);
        }

        //We've got the file, now we bind the params
        CompNamingContext compctx = null;
        try {
            compctx = new CompNamingContext(fileName);
            compctx.rebind("rarFileName", fileName);
            compctx.rebind("isInEar", new Boolean(false));
            //Call the function
            unRegisterRar(compctx);
        } catch (NamingException e) {
            String err = "Error when binding parameters";
            logger.log(BasicLevel.ERROR, err + e.getMessage());
            throw new ResourceServiceException(err, e);
        } catch (Exception ex) {
            String err = "Error when unRegistering rar " + fileName;
            logger.log(BasicLevel.ERROR, err + ex.getMessage());
            ex.printStackTrace();
            throw new ResourceServiceException(err, ex);
        }

    }

    public void unDeployRar(String fileName) throws Exception {
        unDeployRarMBean(fileName);
    }

    public boolean isRarLoaded(String fileName) {

        String updateName = null;
        boolean isLoaded = false;
        try {
            if (Rar.fileName2RA.containsKey(fileName)) {
                isLoaded = true;
            }
            // If not found check the exact filename
            if (!isLoaded) {
                // construct name for rars in JONAS_BASE/rars directory
                updateName = RARSDIR + File.separator + fileName;

                //Check if the rar is already deployed or not
                if (Rar.fileName2RA.containsKey(updateName)) {
                    isLoaded = true;
                }
            }
        } catch (Exception e) {
            String err = "Cannot determine if the rar is deployed or not";
            logger.log(BasicLevel.ERROR, err);
            return false;
        }

        return isLoaded;
    }


    public List getDeployableRars() throws Exception {
        List al = getInstalledRars();
        al.removeAll(getDeployedRars());
        return al;
    }

    public List getAutoloadDirectories() {
        ArrayList al = new ArrayList();
        for (int i = 0; i < autoNames.size(); i++) {
            try {
                al.add((new File(autoNames.get(i).toString())).toURL().getPath());
            } catch (Exception e) {
                logger.log(BasicLevel.DEBUG, "Can't get autoload directories : " + e.getMessage());
            }
        }
        return al;
    }

    public String getRarsDirectory() {
        String sRet = null;
        try {
            sRet = (new File(RARSDIR)).toURL().getPath();
        } catch (Exception e) {
            throw new RuntimeException("Cannot get the RARS directory", e);
        }
        return sRet;
    }

    //--------------------------------------------------------------
    //           Private Methods
    //--------------------------------------------------------------

    private void addRars(String dirPath) {
        boolean found = false;

        // Look the directory relative to where the JOnAS server is launch or
        // if the path is absolute.
        File dir = new File(dirPath);
        found = dir.isDirectory();

        if (!found) {
            // Look the directory relative to the $JONAS_BASE/rars directory
            dir = new File(RARSDIR + File.separator + dirPath);
            found = dir.isDirectory();
        }

        if (found) {
            autoNames.add(dir);
            addRarsFrom(dir);
        } else {
            String err = "Warning: Cannot load dir: '" + dirPath + "' ";
            err += "is not a directory or directory doesn't exist";
            logger.log(BasicLevel.WARN, err);
        }
    }

    private void addRarsFrom(File dir) throws ResourceServiceException {
        try {
            if (dir.isDirectory()) {
                File[] files = dir.listFiles();
                for (int i = 0; i < files.length; i++) {
                    if (files[i].isFile()) {
                        if (files[i].getPath().toLowerCase().endsWith(".rar")) {
                            resourceNames.add(files[i].getCanonicalPath());
                        }
                    } else {
                        autoNames.add(files[i]);
                        addRarsFrom(files[i]);
                    }
                }
            } else {
                String err = "Cannot load dir: '" + dir.getPath();
                err += "' is not a directory";
                logger.log(BasicLevel.ERROR, err);
                throw new ResourceServiceException(err);
            }
        } catch (IOException e) {
            String err = "Invalid file name '" + dir.getPath();
            logger.log(BasicLevel.ERROR, err);
            throw new ResourceServiceException(err, e);
        }
    }

    private String normalizePath(String path) {
        String ret = null;
        if (File.separatorChar == '/') {
            ret = path.replace('\\', File.separatorChar);
        } else {
            ret = path.replace('/', File.separatorChar);
        }
        return ret;
    }
}

---