JonasDeploymentTool.java

package org.objectweb.jonas.ant;

import java.io.File;
import java.io.IOException;
import java.util.Hashtable;

import javax.xml.parsers.SAXParser;

import org.apache.tools.ant.AntClassLoader;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.taskdefs.Java;
import org.apache.tools.ant.types.Path;
import org.apache.tools.ant.types.Reference;

public class JonasDeploymentTool extends GenericDeploymentTool {

    protected static final String EJB_JAR_1_1_PUBLIC_ID = "-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 1.1//EN";
    protected static final String EJB_JAR_2_0_PUBLIC_ID = "-//Sun Microsystems, Inc.//DTD Enterprise JavaBeans 2.0//EN";

    protected static final String JONAS_EJB_JAR_2_4_PUBLIC_ID = "-//ObjectWeb//DTD JOnAS 2.4//EN";
    protected static final String JONAS_EJB_JAR_2_5_PUBLIC_ID = "-//ObjectWeb//DTD JOnAS 2.5//EN";
    protected static final String JONAS_EJB_JAR_3_0_PUBLIC_ID = "-//ObjectWeb//DTD JOnAS 3.0//EN";
    protected static final String JONAS_EJB_JAR_3_2_PUBLIC_ID = "-//ObjectWeb//DTD JOnAS 3.2//EN";
    protected static final String JONAS_EJB_JAR_3_3_PUBLIC_ID = "-//ObjectWeb//DTD JOnAS 3.3//EN";
    protected static final String JONAS_EJB_JAR_3_3_2_PUBLIC_ID = "-//ObjectWeb//DTD JOnAS 3.3.2//EN";

    protected static final String EJB_JAR_1_1_DTD = "ejb-jar_1_1.dtd";
    protected static final String EJB_JAR_2_0_DTD = "ejb-jar_2_0.dtd";

    protected static final String JONAS_EJB_JAR_2_4_DTD = "jonas-ejb-jar_2_4.dtd";
    protected static final String JONAS_EJB_JAR_2_5_DTD = "jonas-ejb-jar_2_5.dtd";
    protected static final String JONAS_EJB_JAR_3_0_DTD = "jonas-ejb-jar_3_0.dtd";
    protected static final String JONAS_EJB_JAR_3_2_DTD = "jonas-ejb-jar_3_2.dtd";
    protected static final String JONAS_EJB_JAR_3_3_DTD = "jonas-ejb-jar_3_3.dtd";
    protected static final String JONAS_EJB_JAR_3_3_2_DTD = "jonas-ejb-jar_3_3_2.dtd";

    protected static final String JONAS_DD = "jonas-ejb-jar.xml";

    protected static final String BOOTSTRAP_CLASS = "org.objectweb.jonas.server.Bootstrap";

    protected static final String GENIC_CLASS = "org.objectweb.jonas_ejb.genic.GenIC";

    private String descriptorName;

    private String jonasDescriptorName;

    /* ------------- */
    /* GenIC options */
    /* ------------- */

    private File outputdir;

    private boolean keepgenerated = false;

    private boolean nocompil = false;

    private boolean invokeCmd = false;

    private boolean novalidation = false;

    private String javac;

    private String javacopts;

    private String rmicopts;

    private boolean verbose = false;

    private String additionalargs;

    private String jvmopts = null;

    private String protocols = null;

    /* ------------- */
    /* other options */
    /* ------------- */

    private File jonasroot;

    private File jonasbase;

    private boolean keepgeneric = false;

    private String suffix = ".jar";

    private boolean nogenic = false;

    /* -------------------- */
    /* GenIC options setter */
    /* -------------------- */

    public void setKeepgenerated(boolean aBoolean) {
        keepgenerated = aBoolean;
    }

    public void setMappernames(String aString) {
        log("'mappernames' attribute ignored (deprecated)", Project.MSG_WARN);
    }

    public void setProtocols(String aString) {
        protocols = aString;
    }

    public void setClasspathref(Reference r) {
        createClasspath().setRefid(r);
    }
    public void setAdditionalargs(String aString) {
        additionalargs = aString;
    }

    public void setNocompil(boolean aBoolean) {
        nocompil = aBoolean;
    }

    public void setInvokecmd(boolean aBoolean) {
        invokeCmd = aBoolean;
    }

    public void setNovalidation(boolean aBoolean) {
        novalidation = aBoolean;
    }

    public void setJavac(String aString) {
        javac = aString;
    }

    public void setJavacopts(String aString) {
        javacopts = aString;
    }

    public void setRmicopts(String aString) {
        rmicopts = aString;
    }

    public void setVerbose(boolean aBoolean) {
        verbose = aBoolean;
    }

    /* -------------------- */
    /* other options setter */
    /* -------------------- */

    public void setJonasroot(File aFile) {
        jonasroot = aFile;
    }

    public void setJonasbase(File aFile) {
        jonasbase = aFile;
    }

    public void setKeepgeneric(boolean aBoolean) {
        keepgeneric = aBoolean;
    }

    public void setJarsuffix(String aString) {
        suffix = aString;
    }

    public void setNogenic(boolean aBoolean) {
        nogenic = aBoolean;
    }

    public void setJvmopts(String aString) {
        jvmopts = aString;
    }

    /* ------------- */
    /* other methods */
    /* ------------- */

    public void processDescriptor(String aDescriptorName, SAXParser saxParser) {

        descriptorName = aDescriptorName;

        log("JOnAS Deployment Tool processing for JOnAS: " + descriptorName, Project.MSG_VERBOSE);

        super.processDescriptor(descriptorName, saxParser);

        if (outputdir != null) {
            // the method deleteOnExit() do not work because the directory is
            // not empty
            log("Deleting temp output directory '" + outputdir + "'.", Project.MSG_VERBOSE);
            deleteAllFiles(outputdir);
        }
    }

    protected void writeJar(String baseName, File jarfile, Hashtable ejbFiles, String publicId,
            boolean includeInnerClasses) throws BuildException {

        // create the generic jar first
        File genericJarFile = super.getVendorOutputJarFile(baseName);

        super.writeJar(baseName, genericJarFile, ejbFiles, publicId, true);

        // GenIC call on generic jar
        addGenICGeneratedFiles(genericJarFile, ejbFiles);

        // create the real jar
        super.writeJar(baseName, getVendorOutputJarFile(baseName), ejbFiles, publicId, false);

        //log("genericJarFile: " + genericJarFile, Project.MSG_VERBOSE);
        //log("getVendorOutputJarFile(baseName): " +
        // getVendorOutputJarFile(baseName), Project.MSG_VERBOSE);
        //log("baseName: " + baseName, Project.MSG_VERBOSE);

        if (!keepgeneric) {
            log("Deleting generic JAR " + genericJarFile.toString(), Project.MSG_VERBOSE);
            genericJarFile.delete();
        }
    }

    protected void addVendorFiles(Hashtable ejbFiles, String ddPrefix) {

        // JOnAS-specific descriptor deployment
        jonasDescriptorName = getJonasDescriptorName();
        File jonasDD = new File(getConfig().descriptorDir, jonasDescriptorName);

        if (jonasDD.exists()) {
            ejbFiles.put(META_DIR + JONAS_DD, jonasDD);
        } else {
            log("Unable to locate the JOnAS deployment descriptor. It was expected to be in: " + jonasDD.getPath()
                    + ".", Project.MSG_WARN);
        }
    }

    protected File getVendorOutputJarFile(String baseName) {
        return new File(getDestDir(), baseName + suffix);
    }

    private String getJonasDescriptorName() {

        // descriptorName = <path><basename><basenameterminator><remainder>
        // examples = /org/objectweb/fooAppli/foo/Foo-ejb-jar.xml
        // examples = /org/objectweb/fooAppli/foo/Foo.xml (JOnAS convention)

        String jonasDescriptorName; // JOnAS-specific DD
        boolean jonasConvention = false; // true if the JOnAS convention is used
                                         // for the DD
        String path; // Directory path of the EJB descriptor
        String fileName; // EJB descriptor file name
        String baseName; // Filename appearing before name terminator
        String remainder; // Filename appearing after the name terminator

        int startOfFileName = descriptorName.lastIndexOf(File.separatorChar);
        if (startOfFileName != -1) {
            // extract path info
            path = descriptorName.substring(0, startOfFileName + 1);
            fileName = descriptorName.substring(startOfFileName + 1);
        } else {
            // descriptorName is just a file without path
            path = "";
            fileName = descriptorName;
        }

        if (fileName.startsWith(EJB_DD)) {
            return path + JONAS_DD;
        }

        int endOfBaseName = descriptorName.indexOf(getConfig().baseNameTerminator, startOfFileName);

        /*
         * Check for the odd case where the terminator and/or filename extension
         * aren't found. These will ensure "jonas-" appears at the end of the
         * name and before the '.' (if present).
         */
        if (endOfBaseName < 0) {
            // baseNameTerminator not found: the descriptor use the
            // JOnAS naming convention, ie [Foo.xml,jonas-Foo.xml] and
            // not [Foo<baseNameTerminator>-ejb-jar.xml,
            // Foo<baseNameTerminator>-jonas-ejb-jar.xml].
            endOfBaseName = descriptorName.lastIndexOf('.') - 1;
            if (endOfBaseName < 0) {
                // no . found
                endOfBaseName = descriptorName.length() - 1;
            }

            jonasConvention = true;
        }

        baseName = descriptorName.substring(startOfFileName + 1, endOfBaseName + 1);
        remainder = descriptorName.substring(endOfBaseName + 1);

        if (jonasConvention) {
            jonasDescriptorName = path + "jonas-" + baseName + ".xml";
        } else {
            jonasDescriptorName = path + baseName + "jonas-" + remainder;
        }

        log("Standard EJB descriptor name: " + descriptorName, Project.MSG_VERBOSE);
        log("JOnAS-specific descriptor name: " + jonasDescriptorName, Project.MSG_VERBOSE);

        return jonasDescriptorName;
    }

    protected String getJarBaseName(String descriptorFileName) {

        String baseName = null;

        if (getConfig().namingScheme.getValue().equals(EjbJar.NamingScheme.DESCRIPTOR)) {

            // try to find JOnAS specific convention name
            if (descriptorFileName.indexOf(getConfig().baseNameTerminator) == -1) {

                // baseNameTerminator not found: the descriptor use the
                // JOnAS naming convention, ie [Foo.xml,jonas-Foo.xml] and
                // not [Foo<baseNameTerminator>-ejb-jar.xml,
                // Foo<baseNameTerminator>-jonas-ejb-jar.xml].

                String aCanonicalDescriptor = descriptorFileName.replace('\\', '/');
                int lastSeparatorIndex = aCanonicalDescriptor.lastIndexOf('/');
                int endOfBaseName;

                if (lastSeparatorIndex != -1) {
                    endOfBaseName = descriptorFileName.indexOf(".xml", lastSeparatorIndex);
                } else {
                    endOfBaseName = descriptorFileName.indexOf(".xml");
                }

                if (endOfBaseName != -1) {
                    baseName = descriptorFileName.substring(0, endOfBaseName);
                }
            }
        }

        if (baseName == null) {
            // else get standard baseName
            baseName = super.getJarBaseName(descriptorFileName);
        }

        log("JAR base name: " + baseName, Project.MSG_VERBOSE);

        return baseName;
    }

    protected void registerKnownDTDs(DescriptorHandler handler) {

        handler.registerDTD(EJB_JAR_1_1_PUBLIC_ID, jonasroot + File.separator + "xml" + File.separator
                + EJB_JAR_1_1_DTD);
        handler.registerDTD(EJB_JAR_2_0_PUBLIC_ID, jonasroot + File.separator + "xml" + File.separator
                + EJB_JAR_2_0_DTD);

        handler.registerDTD(JONAS_EJB_JAR_2_4_PUBLIC_ID, jonasroot + File.separator + "xml" + File.separator
                + JONAS_EJB_JAR_2_4_DTD);
        handler.registerDTD(JONAS_EJB_JAR_2_5_PUBLIC_ID, jonasroot + File.separator + "xml" + File.separator
                + JONAS_EJB_JAR_2_5_DTD);
        handler.registerDTD(JONAS_EJB_JAR_3_0_PUBLIC_ID, jonasroot + File.separator + "xml" + File.separator
                + JONAS_EJB_JAR_3_0_DTD);
        handler.registerDTD(JONAS_EJB_JAR_3_2_PUBLIC_ID, jonasroot + File.separator + "xml" + File.separator
                + JONAS_EJB_JAR_3_2_DTD);
        handler.registerDTD(JONAS_EJB_JAR_3_3_PUBLIC_ID, jonasroot + File.separator + "xml" + File.separator
                + JONAS_EJB_JAR_3_3_DTD);
        handler.registerDTD(JONAS_EJB_JAR_3_3_2_PUBLIC_ID, jonasroot + File.separator + "xml" + File.separator
                + JONAS_EJB_JAR_3_3_2_DTD);
    }

    private void addGenICGeneratedFiles(File genericJarFile, Hashtable ejbFiles) {

        Java genicTask = null; // GenIC task

        if (nogenic) {
            return;
        }

        genicTask = (Java) getTask().getProject().createTask("java");
        genicTask.setTaskName("genic");
        genicTask.setFork(true);

        // jonas root
        genicTask.createJvmarg().setValue("-Dinstall.root=" + jonasroot);

        // jonas base
        genicTask.createJvmarg().setValue("-Djonas.base=" + jonasbase);

        // Endorsed directory
        File endorsedDir = new File(new File(jonasroot, "lib"), "endorsed");
        genicTask.createJvmarg().setValue("-Djava.endorsed.dirs=" + endorsedDir);

        // java policy file
        String jonasConfigDir = jonasroot + File.separator + "conf";
        File javaPolicyFile = new File(jonasConfigDir, "java.policy");
        if (javaPolicyFile.exists()) {
            genicTask.createJvmarg().setValue("-Djava.security.policy=" + javaPolicyFile.toString());
        }

        // The bootstrap class must launch the GenIC class
        genicTask.createArg().setValue(JonasDeploymentTool.GENIC_CLASS);

        // outputdir
        try {
            outputdir = createTempDir();
        } catch (IOException aIOException) {
            String msg = "Cannot create temp dir: " + aIOException.getMessage();
            throw new BuildException(msg, aIOException);
        }
        log("Using temporary output directory: " + outputdir, Project.MSG_VERBOSE);

        genicTask.createArg().setValue("-d");
        genicTask.createArg().setFile(outputdir);

        // classpath
        Path classpath = getCombinedClasspath();
        if (classpath == null) {
            classpath = new Path(getTask().getProject());
        }
        // add ow_jonas_bootstrap.jar
        String bootJar = jonasroot + File.separator + "lib" + File.separator + "common" + File.separator
                + "ow_jonas_bootstrap.jar";
        Path bootstrap = new Path(getTask().getProject(), bootJar);
        //classpath.append(new Path(classpath.getProject(), bootJar));

        classpath.append(new Path(classpath.getProject(), outputdir.toString()));

        log("Using classpath: " + bootstrap.toString(), Project.MSG_VERBOSE);
        genicTask.setClasspath(bootstrap);

        if (!checkBootstrapClassName(bootstrap)) {
            log("Cannot find bootstrap class in classpath.", Project.MSG_ERR);
            throw new BuildException("Bootstrap class not found, please check the classpath.");
        } else {
            genicTask.setClassname(JonasDeploymentTool.BOOTSTRAP_CLASS);
        }

        // classpath
        genicTask.createArg().setValue("-classpath");
        genicTask.createArg().setPath(classpath);

        // keepgenerated
        if (keepgenerated) {
            genicTask.createArg().setValue("-keepgenerated");
        }

        // nocompil
        if (nocompil) {
            genicTask.createArg().setValue("-nocompil");
        }

        // invokecmd
        if (invokeCmd) {
            genicTask.createArg().setValue("-invokecmd");
        }

        // novalidation
        if (novalidation) {
            genicTask.createArg().setValue("-novalidation");
        }

        // javac
        if (javac != null) {
            genicTask.createArg().setValue("-javac");
            genicTask.createArg().setLine(javac);
        }

        // javacopts
        if (javacopts != null && !javacopts.equals("")) {
            genicTask.createArg().setValue("-javacopts");
            genicTask.createArg().setValue(javacopts);
        }

        // rmicopts
        if (rmicopts != null && !rmicopts.equals("")) {
            genicTask.createArg().setValue("-rmicopts");
            genicTask.createArg().setValue(rmicopts);
        }

        // verbose
        if (verbose) {
            genicTask.createArg().setValue("-verbose");
        }

        // additionalargs
        if (additionalargs != null) {
            genicTask.createArg().setLine(additionalargs);
        }

        // protocols
        if (protocols != null) {
            genicTask.createArg().setValue("-protocols");
            genicTask.createArg().setValue(protocols);
        }

        // the generated classes must not be added in the generic JAR!
        genicTask.createArg().setValue("-noaddinjar");

        // jvmopts
        if (jvmopts != null && !jvmopts.equals("")) {
            genicTask.createJvmarg().setLine(jvmopts);
        }

        // input file to process by GenIC
        genicTask.createArg().setValue(genericJarFile.getPath());

        // calling GenIC task
        log("Calling  GenIC task for " + getConfig().descriptorDir + File.separator + descriptorName + ".",
                Project.MSG_VERBOSE);

        if (genicTask.executeJava() != 0) {
            // Don't delete the temp output directory in case of error:

            //log("Deleting temp output directory '" + outputdir + "'.",
            // Project.MSG_VERBOSE);
            // the method deleteOnExit() do not work because the directory is
            // not empty
            //deleteAllFiles(outputdir);

            if (!keepgeneric) {
                log("Deleting generic JAR " + genericJarFile.toString(), Project.MSG_VERBOSE);
                genericJarFile.delete();
            }

            throw new BuildException("GenIC reported an error.");
        }

        // add the generated files to the ejbFiles
        addAllFiles(outputdir, "", ejbFiles);
    }

    private boolean checkBootstrapClassName(Path classpath) {
        log("Looking for bootstrap class in classpath: " + classpath.toString(), Project.MSG_VERBOSE);
        AntClassLoader cl = new AntClassLoader(classpath.getProject(), classpath);
        try {
            cl.loadClass(JonasDeploymentTool.BOOTSTRAP_CLASS);
            log("Found Bootstrap class '" + JonasDeploymentTool.BOOTSTRAP_CLASS + "' in classpath.",
                    Project.MSG_VERBOSE);
        } catch (ClassNotFoundException cnf1) {
            log("Bootstrap class '" + JonasDeploymentTool.BOOTSTRAP_CLASS + "' not found in classpath.",
                    Project.MSG_VERBOSE);
            return false;
        }
        return true;
    }

    protected void checkConfiguration(String descriptorFileName, SAXParser saxParser) throws BuildException {
        // jonasroot
        if (jonasroot == null) {
            throw new BuildException("The jonasroot attribute is not set.");
        } else if (!jonasroot.isDirectory()) {
            throw new BuildException("The jonasroot attribute '" + jonasroot + "' is not a valid directory.");
        }
        // jonasbase default value is jonasroot
        if (jonasbase == null) {
            jonasbase = jonasroot;
        }

        // additionalargs
        if (additionalargs != null && additionalargs.equals("")) {
            throw new BuildException("Empty additionalargs attribute.");
        }

        // javac
        if (javac != null && javac.equals("")) {
            throw new BuildException("Empty javac attribute.");
        }
    }

    /* ----------------------------------------------------------------------------------- */
    /* utilitary methods */
    /* ----------------------------------------------------------------------------------- */

    private File createTempDir() throws IOException {
        File tmpDir = File.createTempFile("genic", null, null);
        tmpDir.delete();
        if (!tmpDir.mkdir()) {
            throw new IOException("Cannot create the temporary directory '" + tmpDir + "'.");
        }
        return tmpDir;
    }

    private void deleteAllFiles(File aFile) {
        if (aFile.isDirectory()) {
            File someFiles[] = aFile.listFiles();
            for (int i = 0; i < someFiles.length; i++) {
                deleteAllFiles(someFiles[i]);
            }
        }
        aFile.delete();
    }

    private void addAllFiles(File file, String rootDir, Hashtable hashtable) {

        if (!file.exists()) {
            throw new IllegalArgumentException();
        }

        String newRootDir;
        if (file.isDirectory()) {
            File[] files = file.listFiles();
            for (int i = 0; i < files.length; i++) {
                if (rootDir.length() > 0) {
                    newRootDir = rootDir + File.separator + files[i].getName();
                } else {
                    newRootDir = files[i].getName();
                }
                addAllFiles(files[i], newRootDir, hashtable);
            }
        } else {
            hashtable.put(rootDir, file);
        }
    }
}

---