RarDeploymentDescManager.java

package org.objectweb.jonas_rar.deployment.lib;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.util.jar.JarFile;
import java.util.zip.ZipEntry;

import javax.naming.Context;
import javax.naming.NamingException;

import org.objectweb.jonas_lib.deployment.api.DeploymentDescException;
import org.objectweb.jonas_lib.deployment.digester.JDigester;
import org.objectweb.jonas_lib.deployment.lib.AbsDeploymentDescManager;

import org.objectweb.jonas_rar.deployment.api.RarDeploymentDesc;
import org.objectweb.jonas_rar.deployment.api.RarDeploymentDescException;
import org.objectweb.jonas_rar.deployment.rules.ConnectorRuleSet;
import org.objectweb.jonas_rar.deployment.rules.JonasConnectorRuleSet;
import org.objectweb.jonas_rar.deployment.xml.Connector;
import org.objectweb.jonas_rar.deployment.xml.JonasConnector;

import org.objectweb.jonas.common.Log;
import org.objectweb.jonas.naming.CompNamingContext;

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

public class RarDeploymentDescManager extends AbsDeploymentDescManager {

    public static final String RA_FILE_NAME = "META-INF/ra.xml";

    public static final String JONAS_RA_FILE_NAME = "META-INF/jonas-ra.xml";

    private static boolean parsingWithValidation = true;

    private static JDigester connectorDigester = null;

    private static JDigester jonasConnectorDigester = null;

    private static ConnectorRuleSet connectorRuleSet = new ConnectorRuleSet();

    private static JonasConnectorRuleSet jonasConnectorRuleSet = new JonasConnectorRuleSet();

    private static Logger logger = Log.getLogger(Log.JONAS_DBM_PREFIX);

    private RarDeploymentDescManager() {
    }

    public static RarDeploymentDesc getInstance(String rarFileName, ClassLoader classLoader)
            throws DeploymentDescException {

        // The context to give for the creation of an instance
        // of RarDeploymentDesc
        Context contctx = null;
        try {
            contctx = new CompNamingContext(rarFileName);
            contctx.rebind("rarFileName", rarFileName);
            contctx.rebind("classloader", classLoader);
        } catch (Exception e) {
            // An exception occurred trying to bind context
            //            logger.log(BasicLevel.ERROR, "Error when binding context for
            // RarDeploymentDesc for '" + rarFileName + "'");
            //            logger.log(BasicLevel.ERROR, e.getMessage());

            throw new RarDeploymentDescException("Error during the deployment", e);
        }
        // want both ra.xml & jonas-ra.xml
        return getInstance(contctx);
    }

    public static RarDeploymentDesc getInstance(Context ctx) throws DeploymentDescException {

        // init xml contents values;
        String xmlContent = "";
        String jonasXmlContent = "";
        boolean altDD = false;

       String rarFileName = null;
        ClassLoader classLoader = null;
        try {
            rarFileName = (String) ctx.lookup("rarFileName");
            classLoader = (ClassLoader) ctx.lookup("classloader");
        } catch (NamingException e) {
            String err = "Error while getting parameter from context param ";
            throw new RarDeploymentDescException(err, e);
        }

        // optional parameter
        String raDeployDesc;
        try {
            raDeployDesc = (String) ctx.lookup("altDD");
            altDD = true;
        } catch (NamingException e) {
            // no alt DD
            raDeployDesc = "";
        }

        //rar file
        JarFile rarFile = null;

        //Input Stream
        InputStream raInputStream = null;
        InputStream jonasRaInputStream = null;

        //ZipEntry
        ZipEntry raZipEntry = null;
        ZipEntry jonasRaZipEntry = null;

        Connector connector = null;
        JonasConnector jonasConnector = null;

        //Build the file
        File fRar = new File(rarFileName);

        //Check if the file exists.
        if (!(fRar.exists())) {
            throw new RarDeploymentDescException("The file '" + rarFileName + "' was not found.");
        }

        // load deployment descriptor data (META-INF/ra.xml)
        boolean setupRa = true;
        boolean setupJonasRa = true;
        try {
            if (!altDD) {
                
                // If rar is a directory, there is no jar, just read the file from 
                // the directory
                if (fRar.isDirectory()) {
                    File rarXmlF = new File(rarFileName, RA_FILE_NAME);
                    if (!rarXmlF.exists()) {
                        connector = null;
                        setupRa = false;
                    } else {
                        raInputStream = new FileInputStream(rarXmlF);
                        xmlContent = xmlContent(raInputStream);
                        raInputStream = new FileInputStream(rarXmlF);
                    }
                } else {
                    rarFile = new JarFile(rarFileName);

                    //Check the ra entry
                    raZipEntry = rarFile.getEntry(RA_FILE_NAME);
                    if (raZipEntry == null) {
                        connector = null;
                        setupRa = false;
                    } else {
                        //Get the stream
                        raInputStream = rarFile.getInputStream(raZipEntry);
                        xmlContent = xmlContent(raInputStream);
                        raInputStream = rarFile.getInputStream(raZipEntry);
                    }
                }
            } else {
                raInputStream = new FileInputStream(raDeployDesc);
                xmlContent = xmlContent(raInputStream);
                raInputStream = new FileInputStream(raDeployDesc);
            }

            if (fRar.isDirectory()) {
                //lookup a WEB-INF/jonas-web.xml file
                File rarJXmlF = new File(rarFileName, JONAS_RA_FILE_NAME);
                if (rarJXmlF.exists()) {
                    jonasRaInputStream = new FileInputStream(rarJXmlF);
                    jonasXmlContent = xmlContent(jonasRaInputStream);
                    jonasRaInputStream = new FileInputStream(rarJXmlF);
                }
            } else {
                //Check the jonas-ra entry
                rarFile = new JarFile(rarFileName);
                jonasRaZipEntry = rarFile.getEntry(JONAS_RA_FILE_NAME);
                if (jonasRaZipEntry == null) {
                    jonasConnector = null;
                    setupJonasRa = false;
                } else {
                    //Get the stream
                    jonasRaInputStream = rarFile.getInputStream(jonasRaZipEntry);
                    jonasXmlContent = xmlContent(jonasRaInputStream);
                    jonasRaInputStream = rarFile.getInputStream(jonasRaZipEntry);
                }
            }
        } catch (Exception e) {
            if (rarFile != null) {
                try {
                    rarFile.close();
                } catch (IOException ioe) {
                    // Can't close the file
                    logger.log(BasicLevel.WARN, "Can't close '" + rarFileName + "'");
                }
            }
            throw new RarDeploymentDescException("Cannot read the XML deployment descriptors of the rar file '"
                    + rarFileName + "'.", e);
        }

        if (setupRa) {
            connector = loadConnector(new InputStreamReader(raInputStream), raDeployDesc);
            try {
                raInputStream.close();
            } catch (IOException e) {
                // can't close
                logger.log(BasicLevel.WARN, "Can't close META-INF/ra.xml of '" + rarFileName + "'");
            }
        }

        if (setupJonasRa) {
            jonasConnector = loadJonasConnector(new InputStreamReader(jonasRaInputStream), JONAS_RA_FILE_NAME);
            try {
                jonasRaInputStream.close();
            } catch (IOException e) {
                // can't close
                logger.log(BasicLevel.WARN, "Can't close META-INF/jonas-ra.xml of '" + rarFileName + "'");
            }
        }

        // instantiate deployment descriptor
        RarDeploymentDesc rdd = new RarDeploymentDesc(classLoader, connector, jonasConnector);
        rdd.setXmlContent(xmlContent);
        rdd.setJOnASXmlContent(jonasXmlContent);
        return rdd;
    }

    public static Connector loadConnector(Reader reader, String fileName) throws DeploymentDescException {

        Connector connector = new Connector();

        // Create if null
        if (connectorDigester == null) {
            connectorDigester = new JDigester(connectorRuleSet, parsingWithValidation, true, new ConnectorDTDs(),
                    new ConnectorSchemas());
        }

        try {
            connectorDigester.parse(reader, fileName, connector);
        } catch (DeploymentDescException e) {
            throw e;
        } finally {
            connectorDigester.push(null);
        }
        return connector;
    }

    public static JonasConnector loadJonasConnector(Reader reader, String fileName) throws DeploymentDescException {

        JonasConnector jonasConnector = new JonasConnector();

        // Create if null
        if (jonasConnectorDigester == null) {
            jonasConnectorDigester = new JDigester(jonasConnectorRuleSet, parsingWithValidation, true,
                    new JonasConnectorDTDs(), new JonasConnectorSchemas());
        }

        try {
            jonasConnectorDigester.parse(reader, fileName, jonasConnector);
        } catch (DeploymentDescException e) {
            throw e;
        } finally {
            jonasConnectorDigester.push(null);
        }
        return jonasConnector;
    }

    public static boolean getParsingWithValidation() {
        return RarDeploymentDescManager.parsingWithValidation;
    }

    public static void setParsingWithValidation(boolean validation) {
        RarDeploymentDescManager.parsingWithValidation = validation;
    }

}

---