| /* |
| * The Apache Software License, Version 1.1 |
| * |
| * Copyright (c) 2002 The Apache Software Foundation. All rights |
| * reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in |
| * the documentation and/or other materials provided with the |
| * distribution. |
| * |
| * 3. The end-user documentation included with the redistribution, if |
| * any, must include the following acknowlegement: |
| * "This product includes software developed by the |
| * Apache Software Foundation (http://www.apache.org/)." |
| * Alternately, this acknowlegement may appear in the software itself, |
| * if and wherever such third-party acknowlegements normally appear. |
| * |
| * 4. The names "The Jakarta Project", "Ant", and "Apache Software |
| * Foundation" must not be used to endorse or promote products derived |
| * from this software without prior written permission. For written |
| * permission, please contact apache@apache.org. |
| * |
| * 5. Products derived from this software may not be called "Apache" |
| * nor may "Apache" appear in their names without prior written |
| * permission of the Apache Group. |
| * |
| * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR |
| * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF |
| * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT |
| * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| * ==================================================================== |
| * |
| * This software consists of voluntary contributions made by many |
| * individuals on behalf of the Apache Software Foundation. For more |
| * information on the Apache Software Foundation, please see |
| * <http://www.apache.org/>. |
| */ |
| package org.apache.tools.ant.taskdefs.optional.ejb; |
| |
| import org.apache.tools.ant.BuildException; |
| import org.apache.tools.ant.Project; |
| import org.apache.tools.ant.types.Path; |
| import org.apache.tools.ant.taskdefs.Java; |
| import org.apache.tools.ant.AntClassLoader; |
| import org.apache.tools.ant.taskdefs.Java; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.util.Hashtable; |
| import java.util.Enumeration; |
| |
| import javax.xml.parsers.SAXParser; |
| |
| /** |
| * The deployment tool to add the jonas specific deployment descriptors to the |
| * ejb JAR file. JONAS only requires one additional file jonas-ejb-jar.xml. |
| * |
| * @author <a href="mailto:cmorvan@ingenosya.com">Cyrille Morvan</a> , <a |
| * href="http://www.ingenosya.com">Ingenosya France</a>, <a |
| * href="mailto:mathieu.peltier@inrialpes.fr">Mathieu Peltier</a> |
| * @version 1.0 |
| * @see EjbJar#createJonas |
| */ |
| public class JonasDeploymentTool extends GenericDeploymentTool { |
| |
| /** Public Id of the standard deployment descriptor DTD. */ |
| 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"; |
| |
| /** Public Id of the JOnAS-specific deployment descriptor DTD. */ |
| 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"; |
| |
| /** RMI ORB. */ |
| protected static final String RMI_ORB = "RMI"; |
| |
| /** JEREMIE ORB. */ |
| protected static final String JEREMIE_ORB = "JEREMIE"; |
| |
| /** DAVID ORB. */ |
| protected static final String DAVID_ORB = "DAVID"; |
| |
| /** |
| * Name of the standard deployment descriptor DTD (these files are stored in |
| * the ${JONAS_ROOT}/xml directory). |
| */ |
| 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"; |
| |
| /** |
| * Name of the JOnAS-specific deployment descriptor DTD (these files are |
| * stored in the ${JONAS_ROOT}/xml directory). |
| */ |
| 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"; |
| |
| /** Default JOnAS deployment descriptor name. */ |
| protected static final String JONAS_DD = "jonas-ejb-jar.xml"; |
| |
| /** GenIC class name (JOnAS 2.5) */ |
| protected static final String GENIC_CLASS = |
| "org.objectweb.jonas_ejb.genic.GenIC"; |
| |
| /** Old GenIC class name (JOnAS 2.4.x). */ |
| protected static final String OLD_GENIC_CLASS_1 = |
| "org.objectweb.jonas_ejb.tools.GenWholeIC"; |
| |
| /** Old GenIC class name. */ |
| protected static final String OLD_GENIC_CLASS_2 = |
| "org.objectweb.jonas_ejb.tools.GenIC"; |
| |
| /** |
| * Filename of the standard EJB descriptor (which is passed to this class |
| * from the parent "ejbjar" task). This file is relative to the directory |
| * specified by the "srcdir" attribute in the ejbjar task. |
| */ |
| private String descriptorName; |
| |
| /** |
| * Filename of the JOnAS-specific EJB descriptor (which is passed to this |
| * class from the parent "ejbjar" task). This file is relative to the |
| * directory specified by the "srcdir" attribute in the ejbjar task. |
| */ |
| private String jonasDescriptorName; |
| |
| /* ------------- */ |
| /* GenIC options */ |
| /* ------------- */ |
| |
| /** |
| * Temporary output directory used by GenIC. |
| */ |
| private File outputdir; |
| |
| /** |
| * <code>true</code> if the intermediate Java source files generated by |
| * GenIC must be deleted or not. The default is <code>false</code> |
| */ |
| private boolean keepgenerated = false; |
| |
| /** |
| * <code>true</code> if the generated source files must not be compiled via |
| * the java and rmi compilers. The default is <code>false</code>. |
| */ |
| private boolean nocompil = false; |
| |
| /** |
| * <code>true</code> if the XML deployment descriptors must be parsed |
| * without validation. The default is <code>false</code>. |
| */ |
| private boolean novalidation = false; |
| |
| /** |
| * Java compiler to use. The default is the value of |
| * <code>build.compiler</code> property. |
| */ |
| private String javac; |
| |
| /** Options to pass to the java compiler. */ |
| private String javacopts; |
| |
| /** Options to pass to the rmi compiler. */ |
| private String rmicopts; |
| |
| /** |
| * <code>true</code> if the RMI Skel. and Stub. must be modified to |
| * implement the implicit propagation of the security context (the |
| * transactional context is always provided). The default is |
| * <code>false</code>. |
| */ |
| private boolean secpropag = false; |
| |
| /** |
| * <code>true</code> if the GenIC call must be verbose. The default |
| * is <code>false</code>. |
| */ |
| private boolean verbose = false; |
| |
| /** Additional args to send to GenIC. */ |
| private String additionalargs; |
| |
| /* ------------- */ |
| /* other options */ |
| /* ------------- */ |
| |
| /** JOnAS root directory. */ |
| private File jonasroot; |
| |
| /** |
| * <code>true</code> if the generic JAR file used as input to GenIC must be |
| * retained. The default is <code>false</code>. |
| */ |
| private boolean keepgeneric = false; |
| |
| /** Stores the suffix for the JOnAS JAR file. The default is '.jar'. */ |
| private String suffix = ".jar"; |
| |
| /** |
| * ORB to use (RMI, JEREMIE or DAVID). If omitted, it defaults to the one |
| * present in classpath. If specified, the corresponding JOnAS JAR is |
| * automatically added to the classpath. |
| */ |
| private String orb; |
| |
| /** <code>true</code> if GenIC must not be run on the EJB JAR. The default is <code>false</code>. */ |
| private boolean nogenic = false; |
| |
| /* -------------------- */ |
| /* GenIC options setter */ |
| /* -------------------- */ |
| |
| /** |
| * Set the {@link #keepgenerated} flag. |
| * |
| * @param aBoolean <code>true</code> if the flag must be set. |
| */ |
| public void setKeepgenerated(boolean aBoolean) { |
| keepgenerated = aBoolean; |
| } |
| |
| /** |
| * Set the {@link #additionalargs}. |
| * |
| * @param aString additional args. |
| */ |
| public void setAdditionalargs(String aString) { |
| additionalargs = aString; |
| } |
| |
| /** |
| * Set the {@link #nocompil} flag. |
| * |
| * @param aBoolean <code>true</code> if the flag must be set. |
| */ |
| public void setNocompil(boolean aBoolean) { |
| nocompil = aBoolean; |
| } |
| |
| /** |
| * Set the {@link #novalidation} flag. |
| * |
| * @param aBoolean <code>true</code> if the flag must be set. |
| */ |
| public void setNovalidation(boolean aBoolean) { |
| novalidation = aBoolean; |
| } |
| |
| /** |
| * Set the java compiler {@link #javac} to use. |
| * |
| * @param aString the java compiler. |
| */ |
| public void setJavac(String aString) { |
| javac = aString; |
| } |
| |
| /** |
| * Set the options to pass to the java compiler. |
| * |
| * @param aString the options. |
| */ |
| public void setJavacopts(String aString) { |
| javacopts = aString; |
| } |
| |
| /** |
| * Set the options to pass to the rmi compiler. |
| * |
| * @param aString the options. |
| */ |
| public void setRmicopts(String aString) { |
| rmicopts = aString; |
| } |
| |
| /** |
| * Set the {@link #secpropag} flag. |
| * |
| * @param aBoolean <code>true</code> if the flag must be set. |
| */ |
| public void setSecpropag(boolean aBoolean) { |
| secpropag = aBoolean; |
| } |
| |
| /** |
| * Set the {@link #verbose} flag. |
| * |
| * @param aBoolean <code>true</code> if the flag must be set. |
| */ |
| public void setVerbose(boolean aBoolean) { |
| verbose = aBoolean; |
| } |
| |
| /* -------------------- */ |
| /* other options setter */ |
| /* -------------------- */ |
| |
| /** |
| * Set the JOnAS root directory. |
| * |
| * @param aFile the JOnAS root directory. |
| */ |
| public void setJonasroot(File aFile) { |
| jonasroot = aFile; |
| } |
| |
| /** |
| * Set the {@link #keepgeneric} flag. |
| * |
| * @param aBoolean <code>true</code> if the flag must be set. |
| */ |
| public void setKeepgeneric(boolean aBoolean) { |
| keepgeneric = aBoolean; |
| } |
| |
| /** |
| * Set the {@link #jarsuffix}. |
| * |
| * @param aString the string to use as the suffix. |
| */ |
| public void setJarsuffix(String aString) { |
| suffix = aString; |
| } |
| |
| /** |
| * Set the {@link #orb} to construct classpath. |
| * |
| * @param aString 'RMI', 'JEREMIE', or 'DAVID'. |
| */ |
| public void setOrb(String aString) { |
| orb = aString; |
| } |
| |
| /** |
| * Set the {@link #nogenic} flag. |
| * |
| * @param aBoolean <code>true</code> if the flag must be set. |
| */ |
| public void setNogenic(boolean aBoolean) { |
| nogenic = aBoolean; |
| } |
| |
| /* ------------- */ |
| /* other methods */ |
| /* ------------- */ |
| |
| public void processDescriptor(String aDescriptorName, SAXParser saxParser) { |
| |
| descriptorName = aDescriptorName; |
| |
| log("JOnAS Deployment Tool processing: " + 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) |
| throws BuildException { |
| |
| // create the generic jar first |
| File genericJarFile = super.getVendorOutputJarFile(baseName); |
| super.writeJar(baseName, genericJarFile, ejbFiles, publicId); |
| |
| // GenIC call on generic jar |
| addGenICGeneratedFiles(genericJarFile, ejbFiles); |
| |
| // create the real jar |
| super.writeJar(baseName, getVendorOutputJarFile(baseName), ejbFiles, publicId); |
| |
| 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); |
| } |
| |
| /** |
| * Determines the name of the JOnAS-specific EJB descriptor using the |
| * specified standard EJB descriptor name. In general, the standard |
| * descriptor will be named "[basename]-ejb-jar.xml", and this method will |
| * return "[basename]-jonas-ejb-jar.xml" or "jonas-[basename].xml" |
| * |
| * @return The name of the JOnAS-specific EJB descriptor file. |
| */ |
| 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); |
| } |
| |
| /** |
| * Add to the given hashtable all the file generated by GenIC. |
| * |
| * @param genericJarFile jar file. |
| * @param ejbFiles the hashtable. |
| */ |
| private void addGenICGeneratedFiles(File genericJarFile, Hashtable ejbFiles) { |
| |
| Java genicTask = null; // GenIC task |
| String genicClass = null; // GenIC class (3 GenIC classes for various versions of JOnAS are supported) |
| boolean error = false; // true if an error occurs during the GenIC call |
| |
| if ( nogenic ) { |
| return; |
| } |
| |
| genicTask = (Java) getTask().getProject().createTask("java"); |
| genicTask.setTaskName("genic"); |
| genicTask.setFork(true); |
| |
| // jonasroot |
| genicTask.createJvmarg().setValue("-Dinstall.root=" + jonasroot); |
| |
| // java policy file |
| String jonasConfigDir = jonasroot + File.separator + "config"; |
| File javaPolicyFile = new File(jonasConfigDir, "java.policy"); |
| if ( javaPolicyFile.exists() ) { |
| genicTask.createJvmarg().setValue("-Djava.security.policy=" |
| + javaPolicyFile.toString()); |
| } |
| |
| // 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); |
| |
| // work around a bug of GenIC 2.5 |
| String key; |
| File f; |
| Enumeration keys = ejbFiles.keys(); |
| while ( keys.hasMoreElements() ) { |
| key = (String)keys.nextElement(); |
| f = new File(outputdir + File.separator + key); |
| f.getParentFile().mkdirs(); |
| } |
| log("Worked around a bug of GenIC 2.5.", Project.MSG_VERBOSE); |
| |
| // classpath |
| Path classpath = getCombinedClasspath(); |
| if ( classpath == null ) { |
| classpath = new Path(getTask().getProject()); |
| } |
| classpath.append(new Path(classpath.getProject(), jonasConfigDir)); |
| classpath.append(new Path(classpath.getProject(), outputdir.toString())); |
| |
| // try to create the classpath for the correct ORB |
| if ( orb != null ) { |
| String orbJar = jonasroot + File.separator + "lib" + File.separator + orb + "_jonas.jar"; |
| classpath.append(new Path(classpath.getProject(), orbJar)); |
| } |
| |
| log("Using classpath: " + classpath.toString(), Project.MSG_VERBOSE); |
| genicTask.setClasspath(classpath); |
| |
| // class name (search in the classpath provided for the ejbjar element) |
| genicClass = getGenicClassName(classpath); |
| if ( genicClass == null ) { |
| log("Cannot find GenIC class in classpath.", Project.MSG_ERR); |
| throw new BuildException("GenIC class not found, please check the classpath."); |
| } else { |
| log("Using '" + genicClass + "' GenIC class." , Project.MSG_VERBOSE); |
| genicTask.setClassname(genicClass); |
| } |
| |
| // keepgenerated |
| if ( keepgenerated ) { |
| genicTask.createArg().setValue("-keepgenerated"); |
| } |
| |
| // nocompil |
| if ( nocompil ) { |
| genicTask.createArg().setValue("-nocompil"); |
| } |
| |
| // 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().setLine(javacopts); |
| } |
| |
| // rmicopts |
| if ( rmicopts != null && !rmicopts.equals("") ) { |
| genicTask.createArg().setValue("-rmicopts"); |
| genicTask.createArg().setLine(rmicopts); |
| } |
| |
| // secpropag |
| if ( secpropag ) { |
| genicTask.createArg().setValue("-secpropag"); |
| } |
| |
| // verbose |
| if ( verbose ) { |
| genicTask.createArg().setValue("-verbose"); |
| } |
| |
| // additionalargs |
| if ( additionalargs != null ) { |
| genicTask.createArg().setValue(additionalargs); |
| } |
| |
| // the generated classes must not be added in the generic JAR! |
| // is that buggy on old JOnAS (2.4) ?? |
| genicTask.createArg().setValue("-noaddinjar"); |
| |
| // input file to process by GenIC |
| genicTask.createArg().setValue(genericJarFile.getPath()); |
| |
| // calling GenIC task |
| log("Calling " + genicClass + " for " + getConfig().descriptorDir + File.separator + descriptorName |
| + ".", Project.MSG_VERBOSE); |
| |
| if ( genicTask.executeJava() != 0 ) { |
| |
| // the method deleteOnExit() do not work because the directory is not empty |
| log("Deleting temp output directory '" + outputdir + "'.", Project.MSG_VERBOSE); |
| 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); |
| } |
| |
| /** |
| * Get the GenIC class name to use in the given classpath. |
| * |
| * @param classpath classpath where the GenIC class must be searched. |
| * @return the GenIC class name. Return <code>null</code> if the class name |
| * cannot be found. |
| */ |
| String getGenicClassName(Path classpath) { |
| |
| log("Looking for GenIC class in classpath: " + classpath.toString(), Project.MSG_VERBOSE); |
| |
| AntClassLoader cl = new AntClassLoader(classpath.getProject(), classpath); |
| |
| try { |
| cl.loadClass(JonasDeploymentTool.GENIC_CLASS); |
| log("Found GenIC class '" + JonasDeploymentTool.GENIC_CLASS + "' in classpath.", Project.MSG_VERBOSE); |
| return JonasDeploymentTool.GENIC_CLASS; |
| |
| } catch (ClassNotFoundException cnf1) { |
| log("GenIC class '" + JonasDeploymentTool.GENIC_CLASS + "' not found in classpath.", |
| Project.MSG_VERBOSE); |
| } |
| |
| try { |
| cl.loadClass(JonasDeploymentTool.OLD_GENIC_CLASS_1); |
| log("Found GenIC class '" + JonasDeploymentTool.OLD_GENIC_CLASS_1 + |
| "' in classpath.", Project.MSG_VERBOSE); |
| return JonasDeploymentTool.OLD_GENIC_CLASS_1; |
| |
| } catch (ClassNotFoundException cnf2) { |
| log("GenIC class '" + JonasDeploymentTool.OLD_GENIC_CLASS_1 + |
| "' not found in classpath.", |
| Project.MSG_VERBOSE); |
| } |
| |
| try { |
| cl.loadClass(JonasDeploymentTool.OLD_GENIC_CLASS_2); |
| log("Found GenIC class '" + JonasDeploymentTool.OLD_GENIC_CLASS_2 + |
| "' in classpath.", Project.MSG_VERBOSE); |
| return JonasDeploymentTool.OLD_GENIC_CLASS_2; |
| |
| } catch (ClassNotFoundException cnf3) { |
| log("GenIC class '" + JonasDeploymentTool.OLD_GENIC_CLASS_2 + |
| "' not found in classpath.", |
| Project.MSG_VERBOSE); |
| } |
| return null; |
| } |
| |
| protected void checkConfiguration(String descriptorFileName, |
| SAXParser saxParser) throws BuildException { |
| |
| // jonasroot |
| if ( jonasroot == null ) { |
| throw new BuildException("The jonasroot attribut is not set."); |
| } else if ( !jonasroot.isDirectory() ) { |
| throw new BuildException("The jonasroot attribut '" + jonasroot + |
| "' is not a valid directory."); |
| } |
| |
| // orb |
| if ( orb != null && !orb.equals(RMI_ORB) && !orb.equals(JEREMIE_ORB) && !orb.equals(DAVID_ORB) ) { |
| throw new BuildException("The orb attribut '" + orb + "' is not valid (must be either " + |
| RMI_ORB + ", " + JEREMIE_ORB + " or " + DAVID_ORB + ")."); |
| } |
| |
| // additionalargs |
| if ( additionalargs != null && additionalargs.equals("") ) { |
| throw new BuildException("Empty additionalargs attribut."); |
| } |
| |
| // javac |
| if ( javac != null && javac.equals("") ) { |
| throw new BuildException("Empty javac attribut."); |
| } |
| } |
| |
| /* ----------------------------------------------------------------------------------- */ |
| /* utilitary methods */ |
| /* ----------------------------------------------------------------------------------- */ |
| |
| /** |
| * Create a temporary directory for GenIC output. |
| * |
| * @return the temp directory. |
| * @throws BuildException if a temp directory cannot be created. |
| */ |
| 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; |
| } |
| |
| /** |
| * Delete a file. If the file is a directory, delete recursivly all the |
| * files inside. |
| * |
| * @param aFile file to delete. |
| */ |
| 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(); |
| } |
| |
| /** |
| * Add a file to the a given hashtable. If the file is a directory, add |
| * recursivly all the files inside to the hashtable. |
| * |
| * @param file the file to add. |
| * @param rootDir the current sub-directory to scan. |
| * @param hashtable the hashtable where to add the files. |
| */ |
| 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); |
| } |
| } |
| } |