GenIC.java

package org.objectweb.jonas_ejb.genic;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.StringTokenizer;
import java.util.Properties;
import java.util.TreeSet;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.jar.JarOutputStream;

import org.objectweb.common.Cmd;
import org.objectweb.common.Env;

import org.objectweb.jonas_ejb.deployment.api.BeanDesc;
import org.objectweb.jonas_ejb.deployment.api.DeploymentDesc;
import org.objectweb.jonas_ejb.deployment.api.DeploymentDescEjb2;
import org.objectweb.jonas_ejb.deployment.api.EntityCmp2Desc;
import org.objectweb.jonas_ejb.deployment.api.MessageDrivenDesc;
import org.objectweb.jonas_ejb.deployment.lib.EjbDeploymentDescManager;
import org.objectweb.jonas_ejb.lib.BeanNaming;

import org.objectweb.jonas_lib.deployment.api.DeploymentDescException;
import org.objectweb.jonas_lib.version.Version;

import org.objectweb.jonas.common.Log;
import org.objectweb.jonas.server.JClassLoader;

import org.objectweb.jorm.api.PException;
import org.objectweb.jorm.compiler.api.JormCompilerConfigurator;
import org.objectweb.jorm.compiler.lib.JormCompiler;
import org.objectweb.jorm.metainfo.api.Manager;

import org.objectweb.medor.api.MedorException;

import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.Logger;
import org.objectweb.util.monolog.wrapper.velocity.VelocityLogger;

import org.apache.velocity.app.VelocityEngine;
import org.apache.velocity.runtime.RuntimeConstants;

public class GenIC {

    public static final String RMI_JRMP = "jrmp";

    public static final String RMI_IIOP = "iiop";

    public static final String JEREMIE = "jeremie";

    public static final String CMI_RMI = "cmi";

    private static final String INSTALL_ROOT_PROPERTY = "install.root";

    private static String javaHomeBin = null;

    private boolean verbose = false;

    private String outputdir = null;

    private boolean generatedIC;

    private ArrayList filesToDelete = null;

    private ArrayList remoteJavas = null;

    private ArrayList noRemoteJavas = null;

    private ArrayList remoteClasses = null;

    private ArrayList clusterConfs = null;

    private ArrayList clusteredClasses = null;

    private static Logger logger = null;

    private static final int BUFFER_SIZE = 1024;

    public static void main(String[] args) {
        boolean error = false;

        boolean isHelp = false;
        boolean isVerbose = false;
        boolean isKeepGenerated = false;
        boolean isCompil = true;
        boolean isAddInJar = true;
        boolean parseWithValidation = true;
        boolean invokeCmd = false;

        String fileInputName = null;
        String dirOutputName = null;
        String nameJavac = null;
        ArrayList optionsJavaC = new ArrayList();
        ArrayList optionsRmiC = new ArrayList();
        String protocols = RMI_JRMP; // Default: generate for jrmp
        ProtocolNames protocolsNames = null;
        String classpathParam = null;

        // Init logger
        Log.configure("trace");
        logger = Log.getLogger(Log.JONAS_GENIC_PREFIX);

        // Get args
        for (int argn = 0; argn < args.length; argn++) {
            String arg = args[argn];
            if (arg.equals("-help") || arg.equals("-?")) {
                isHelp = true;
                continue;
            }
            if (arg.equals("-verbose")) {
                isVerbose = true;
                continue;
            }
            if (arg.equals("-debug")) {
                // deprecated
                continue;
            }
            if (arg.equals("-mappernames")) {
                argn++;
                // deprecated
                warning("The -mappernames option is ignored (deprecated)");
            }
            if (arg.equals("-protocols")) {
                argn++;
                if (argn < args.length) {
                    protocols = args[argn];
                    continue;
                } else {
                    error = true;
                }

            }
            if (arg.equals("-keepgenerated")) {
                isKeepGenerated = true;
                optionsRmiC.add(args[argn]);
                continue;
            }
            if (arg.equals("-nocompil")) {
                isCompil = false;
                isKeepGenerated = true;
                continue;
            }
            if (arg.equals("-noaddinjar")) {
                isAddInJar = false;
                continue;
            }
            if (arg.equals("-novalidation")) {
                parseWithValidation = false;
                continue;
            }
            if (arg.equals("-classpath")) {
                classpathParam = args[++argn];
                continue;
            }
            if (arg.equals("-javac")) {
                argn++;
                if (argn < args.length) {
                    nameJavac = args[argn];
                } else {
                    error = true;
                }
                continue;
            }
            if (arg.equals("-javacopts")) {
                argn++;
                if (argn < args.length) {
                    StringTokenizer st = new StringTokenizer(args[argn]);
                    while (st.hasMoreTokens()) {
                        optionsJavaC.add(st.nextToken());
                    }
                } else {
                    error = true;
                }
                continue;
            }
            if (arg.equals("-rmicopts")) {
                argn++;
                if (argn < args.length) {
                    StringTokenizer st = new StringTokenizer(args[argn]);
                    while (st.hasMoreTokens()) {
                        optionsRmiC.add(st.nextToken());
                    }
                } else {
                    error = true;
                }
                continue;
            }
            if (arg.equals("-d")) {
                argn++;
                if (argn < args.length) {
                    dirOutputName = args[argn];
                } else {
                    error = true;
                }
                continue;
            }
            if (arg.equals("-invokecmd")) {
                invokeCmd = true;
                continue;
            }
            fileInputName = args[argn];
        }

        // Usage ?
        if (isHelp) {
            usage();
            return;
        }

        // Check args
        if (error || (fileInputName == null)) {
            usage();
            throw new RuntimeException();
        }
        // The -d option is deprecated since JOnAS 3.0.7 when the file input is an ejb-jar
        // Instead, the output directory must be a temporary directory to make easier
        // the ejb-jar updated.
        if ((dirOutputName != null) && isAddInJar && fileInputName.endsWith(".jar")) {
            warning("The -d '" + dirOutputName + "' option is ignored" + " (deprecated with an ejb-jar as input file)");
        }

        if (dirOutputName == null) {
            dirOutputName = new String("");
        }

        // Build the array of protocols name
        protocolsNames = new ProtocolNames(protocols);

        // In case of ejb-jar file, the dirOutputName must be initialized with a
        // tempo. directory.
        if (fileInputName.endsWith(".jar") && isAddInJar) {
            try {
                dirOutputName = GenIC.createTempDir();
            } catch (IOException ioe) {
                GenIC.fatalError(ioe);
            }
        }

        // Init the classpath used for javac, rmic, JRMICompiler
        JClassLoader pcl = (JClassLoader) Thread.currentThread().getContextClassLoader();

        String classpath = pcl.getClassPath();
        if (fileInputName.endsWith(".jar")) {
            classpath = fileInputName + File.pathSeparator + classpath;
        }
        if (!"".equals(dirOutputName)) {
            classpath = dirOutputName + File.pathSeparator + classpath;
        }
        // add -classpath value
        if (classpathParam != null) {
            classpath = classpathParam + File.pathSeparator + classpath;
        }

        // Set the parsing mode (with or without validation)
        if (!parseWithValidation) {
            EjbDeploymentDescManager.setParsingWithValidation(false);
        }

        // Generates the classes for the set of the beans
        try {
            DeploymentDesc ejbJarDD = null;
            if (fileInputName.endsWith(".jar")) {
                // ejb-jar file
                URL[] url = new URL[1];
                url[0] = (new File(fileInputName)).toURL();
                JClassLoader cl = new JClassLoader("GenIC-" + fileInputName, url, pcl);
                if (classpathParam != null) {
                    // add -classpath value inside ClassLoader
                    addClasspath(cl, classpathParam);
                }
                ejbJarDD = EjbDeploymentDescManager.getDeploymentDesc(fileInputName, cl);
            } else {
                // xml file
                ejbJarDD = EjbDeploymentDescManager.getDeploymentDesc(fileInputName, BeanNaming
                        .getJonasXmlName(fileInputName), BeanNaming.getParentName(fileInputName));
            }

            GenIC gwc = new GenIC(ejbJarDD, dirOutputName, isVerbose);

            // Reset the beans deployment descriptors to unload the beans
            // classes
            // (loaded from the ejb-jar when creating the
            // jonas_ejb.deployment.api.BeanDesc),
            // to be able to update the ejb-jar file on Windows.
            // See Bug #270
            ejbJarDD = null;
            System.gc();

            if (isCompil) {
                gwc.compilClasses(nameJavac, optionsJavaC, optionsRmiC, classpath, protocolsNames, isKeepGenerated,
                        invokeCmd);
                if (protocolsNames.isSupported(CMI_RMI)) {
                    gwc.genClusterFiles(classpath, isKeepGenerated, invokeCmd);
                }
                if (fileInputName.endsWith(".jar") && isAddInJar) {
                    gwc.addClassesInJar(fileInputName, isKeepGenerated);
                }
                if (!isKeepGenerated) {
                    gwc.clean();
                }
            }

        } catch (MalformedURLException e) {
            GenIC.fatalError("Invalid ejb-jar file name : ", e);
        } catch (GenICException e) {
            GenIC.fatalError(e);
        } catch (DeploymentDescException e) {
            GenIC.fatalError("Cannot read the Deployment Descriptors from " + fileInputName + ": ", e);
        }
        // End
    }

    private static void addClasspath(JClassLoader cl, String classpath) throws GenICException {
        String[] elems = classpath.split(File.pathSeparator);
        for (int i = 0; i < elems.length; i++) {
            try {
                cl.addURL(new File(elems[i]).toURL());
            } catch (MalformedURLException e) {
                throw new GenICException("Cannot create URL from '" + elems[i] + "'", e);
            }
        }
    }

    public GenIC(DeploymentDesc ejbJarDesc, String dirOutputName, boolean isVerbose) throws GenICException {

        // A BeanSources for each bean
        ArrayList beanList = null;

        verbose = isVerbose;

        if (javaHomeBin == null) {
            javaHomeBin = System.getProperty("java.home", "");
            if (!("".equals(javaHomeBin))) {
                if (Env.isOsMacOsX()) {
                    javaHomeBin = javaHomeBin + File.separator + "bin" + File.separator;
                } else {
                    javaHomeBin = javaHomeBin + File.separator + ".." + File.separator + "bin" + File.separator;
                }
            }
        }
        outputdir = dirOutputName;
        filesToDelete = new ArrayList();
        remoteJavas = new ArrayList();
        noRemoteJavas = new ArrayList();
        remoteClasses = new ArrayList();
        clusterConfs = new ArrayList();
        clusteredClasses = new ArrayList();
        beanList = new ArrayList();
        BeanDesc[] beansDD = ejbJarDesc.getBeanDesc();
        JormCompiler jormCompiler = null;
        VelocityEngine ve = allocateVelocityEngine();
        // Display the bean's names
        StringBuffer message = new StringBuffer();
        message.append("GenIC for JOnAS " + Version.NUMBER + ": ");
        String sep = "";
        for (int i = 0; i < beansDD.length; i++) {
            BeanSources bs = null;
            if ((beansDD[i] instanceof MessageDrivenDesc)) {
                //Nothing to generate in case of MessageDriven Bean
                continue;
            }
            if (beansDD[i] instanceof EntityCmp2Desc) {
                if (jormCompiler == null) {
                    // Load the jorm meta information of the class
                    try {
                        jormCompiler = allocateJormCompiler(((DeploymentDescEjb2) ejbJarDesc).getJormManager());
                    } catch (DeploymentDescException e) {
                        throw new GenICException("Impossible to load jorm meta information", e);
                    }
                }
                bs = new BeanSources(beansDD[i], outputdir, ve, jormCompiler);
            } else {
                bs = new BeanSources(beansDD[i], outputdir, ve);
            }
            beanList.add(bs);
            //compute message
            message.append(sep);
            sep = ", ";
            message.append("'");
            message.append(bs.getEjbName());
            message.append("'");
        }
        generatedIC = !beanList.isEmpty();
        if (generatedIC) {
            message.append(" generation ...");
        } else {
            message.append("No generation to do (only message driven beans)");
        }
        GenIC.info(message.toString());

        // Generates the sources of the container classes of the beans
        // and Init the lists of the remote/non-remote java sources and the
        // remote classes
        for (Iterator it = beanList.iterator(); it.hasNext();) {
            BeanSources ics = (BeanSources) it.next();
            ics.generate();
            String ccfn = ics.getWrpHomeClusterConfFileName();
            if (ccfn != null) {
                filesToDelete.add(ccfn);
            }
            trace("Sources classes successfully generated" + " for '" + ics.getEjbName() + "'");
            noRemoteJavas.addAll(ics.getNoRemoteJavas());
            if (ics.getWrpHomeFileName() != null) {
                remoteJavas.add(ics.getWrpHomeFileName());
                remoteClasses.add(ics.getWrpHomeClassName());
            }
            if (ics.getWrpRemoteFileName() != null) {
                remoteJavas.add(ics.getWrpRemoteFileName());
                remoteClasses.add(ics.getWrpRemoteClassName());
            }
            if (ics.getWrpServiceEndpointFileName() != null) {
                remoteJavas.add(ics.getWrpServiceEndpointFileName());
                remoteClasses.add(ics.getWrpServiceEndpointClassName());
            }
            if (ics.getWrpHomeClusterConfFileName() != null) {
                clusterConfs.add(ics.getWrpHomeClusterConfFileName());
                clusteredClasses.add(ics.getWrpHomeClassName());
            }
        }
        jormCompiler = null;

    }

    private JormCompiler allocateJormCompiler(Manager miManager) {
        // Allocate and configure a Jorm Compiler
        JormCompiler jormCompiler = new JormCompiler();
        JormCompilerConfigurator jcc = jormCompiler.getCompilerConfigurator();
        Properties prop = new Properties();
        prop.put("jorm.generator", "org.objectweb.jorm.generator.lib.JormGenerator");
        prop.put("jorm.mimanager", "org.objectweb.jorm.metainfo.lib.JormManager");
        prop.put("jorm.writer", "org.objectweb.jorm.mi2xml.lib.BasicDomWriter");
        prop.put("jorm.mapper.list", "rdb");
        prop.put("jorm.mapper.mifactory.rdb", "org.objectweb.jorm.mapper.rdb.metainfo.RdbMappingFactory");
        prop.put("jorm.mapper.mopfactory.rdb", "org.objectweb.jorm.mapper.rdb.generator.RdbMOPFactory");
        prop.put("jorm.mapper.gcmapping.rdb", "org.objectweb.jorm.mapper.rdb.genclass.RdbGenClassMapping");
        prop.put("jorm.mapper.schmgr.rdb", "org.objectweb.jorm.mapper.rdb.lib.RdbPMappingStructuresManager");
        prop.put("jorm.mapper.writer.rdb", "org.objectweb.jorm.mapper.rdb.mi2xml.RdbDomtreeBuilder");
        prop.put("use.context.classloader", "true");
        prop.put("jorm.mapper.submappers.rdb", "generic");
        jcc.configure(prop);
        jcc.setLoggerFactory(Log.getLoggerFactory());
        jormCompiler.setMIManager(miManager);
        return jormCompiler;
    }

    private VelocityEngine allocateVelocityEngine() throws GenICException {
        VelocityEngine ve = new VelocityEngine();
        ve.setProperty(RuntimeConstants.VM_LIBRARY, "GenICMacros.vm");
        ve.setProperty(RuntimeConstants.RESOURCE_LOADER, "file");

        String jonasRoot = System.getProperty(INSTALL_ROOT_PROPERTY);
        if (jonasRoot == null) {
            throw new GenICException("System property '" + INSTALL_ROOT_PROPERTY + "' not set");
        }
        String path2Tmpl = new String(jonasRoot + File.separatorChar + "templates" + File.separatorChar + "genic");
        ve.setProperty(RuntimeConstants.FILE_RESOURCE_LOADER_PATH, path2Tmpl);
        // Velocity logs
        Logger vLogger = Log.getLogger(Log.JONAS_GENIC_VELOCITY_PREFIX);
        if (vLogger.isLoggable(BasicLevel.DEBUG)) {
            // No more velocity logs to avoid the creation of an empty file
            // "velocity.log"
            ve.setProperty(RuntimeConstants.RUNTIME_LOG_LOGSYSTEM_CLASS, "org.apache.velocity.runtime.log.NullLogSystem");
        } else {
            // Connect the velocity log system to monolog
            ve.setProperty(RuntimeConstants.RUNTIME_LOG_LOGSYSTEM, new VelocityLogger(vLogger));
        }
        try {
            ve.init();
        } catch (Exception e) {
            throw new GenICException("Cannot initialize the Velocity engine", e);
        }
        return ve;
    }

    public void compilClasses(String nameJavac, List optionsJavaC, List optionsRmiC, String classpath,
            ProtocolNames protocols, boolean keepGenerated, boolean invkCmd) throws GenICException {

        Cmd jrmpCmd;
        Cmd iiopCmd;
        Cmd jeremieCmd;
        Cmd cmd;

        String cmdJava;
        String cmdJavac;
        String cmdRmic;

        if (!generatedIC) {
            return;
        }

        /*
         * Init the command names
         */
        cmdJava = javaHomeBin + "java";
        if (nameJavac == null) {
            cmdJavac = javaHomeBin + "javac";
        } else {
            cmdJavac = nameJavac;
        }
        cmdRmic = javaHomeBin + "rmic";

        /*
         * Compile the generated sources
         */
        if (!new File(cmdJavac).exists()) {
            // Maybe this is on windows
            if (!new File(cmdJavac + ".exe").exists()) {
                logger.log(BasicLevel.INFO, "No javac command was found at '" + cmdJavac
                    + "'. Check that you are using a JDK and not a JRE.");
            }
        }
        cmd = new Cmd(cmdJavac, invkCmd);
        cmd.addArgument("-classpath");
        cmd.addArgument(classpath);
        cmd.addArgument("-d");
        if ((outputdir.length() == 0)) {
            cmd.addArgument(".");
        } else {
            cmd.addArgument(outputdir);
        }
        cmd.addArguments(optionsJavaC);

        for (Iterator it = remoteJavas.iterator(); it.hasNext();) {
            String srcName = (String) it.next();
            cmd.addArgument(srcName);
            filesToDelete.add(srcName);
        }
        for (Iterator it = noRemoteJavas.iterator(); it.hasNext();) {
            String srcName = (String) it.next();
            cmd.addArgument(srcName);
            filesToDelete.add(srcName);
        }

        trace("Running '" + cmd.toString() + "'");
        if (cmd.run()) {
            trace("Sources classes successfully compiled via java compiler.");
        } else {
            throw new GenICException("Failed when compiling the generated classes via java compiler");
        }

        if (remoteJavas.size() == 0) {
            return;
        }

        /*
         * Generate the stub and skeletons of the home and remote implementations
         */

        if (!new File(cmdRmic).exists()) {
            // Maybe this is on windows
            if (!new File(cmdRmic + ".exe").exists()) {
                logger.log(BasicLevel.INFO, "No rmic command was found at '" + cmdRmic
                    + "'. Check that you are using a JDK and not a JRE.");
            }
        }
        jrmpCmd = new Cmd(cmdRmic);
        jrmpCmd.addArgument("-classpath");
        jrmpCmd.addArgument(classpath);

        iiopCmd = new Cmd(cmdRmic);
        iiopCmd.addArgument("-classpath");
        iiopCmd.addArgument(classpath);
        iiopCmd.addArgument("-iiop");
        iiopCmd.addArgument("-poa");
        iiopCmd.addArgument("-always");

        jeremieCmd = new Cmd(cmdJava);
        jeremieCmd.addArgument("-classpath");
        jeremieCmd.addArgument(classpath);
        jeremieCmd.addArgument("org.objectweb.jeremie.tools.jrmic.JRMICompiler");
        jeremieCmd.addArgument("-opt");
        jeremieCmd.addArgument("-owext");
        if (nameJavac != null) {
            jeremieCmd.addArgument("-c");
            jeremieCmd.addArgument(nameJavac);
        }

        if (!"".equals(outputdir)) {
            jrmpCmd.addArgument("-d");
            jrmpCmd.addArgument(outputdir);
            iiopCmd.addArgument("-d");
            iiopCmd.addArgument(outputdir);
            jeremieCmd.addArgument("-d");
            jeremieCmd.addArgument(outputdir);
        }

        jrmpCmd.addArguments(optionsRmiC);
        iiopCmd.addArguments(optionsRmiC);
        jeremieCmd.addArguments(optionsRmiC);

        for (Iterator it = remoteClasses.iterator(); it.hasNext();) {
            String className = (String) it.next();
            jrmpCmd.addArgument(className);
            iiopCmd.addArgument(className);
            jeremieCmd.addArgument(className);
        }

        if (protocols.isSupported(RMI_JRMP)) {
            trace("Running '" + jrmpCmd.toString() + "'");
            if (jrmpCmd.run()) {
                info("Stubs and Skels successfully generated for rmi/jrmp");
            } else {
                throw new GenICException("Failed when generating the Stubs and Skels with rmic jrmp");
            }
        }

        if (protocols.isSupported(RMI_IIOP)) {
            trace("Running '" + iiopCmd.toString() + "'");
            if (iiopCmd.run()) {
                info("Stubs and Skels successfully generated for rmi/iiop");
            } else {
                throw new GenICException("Failed when generating the Stubs and Skels with rmic iiop");
            }

        }

        if (protocols.isSupported(JEREMIE)) {
            trace("Running '" + jeremieCmd.toString() + "'");
            if (jeremieCmd.run()) {
                info("Stubs and Skels successfully generated with rmi/jeremie");
            } else {
                throw new GenICException("Failed when generating the Stubs and Skels with jeremie jrmic");
            }
        }
    }

    private static Class clusterCompilerClass = null;

    private static Method clusterCompilerGenerateMethod = null;

    public static void callClusterCompiler(String[] args) throws ClassNotFoundException, InstantiationException,
            SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException,
            InvocationTargetException {
        if (clusterCompilerClass == null) {
            clusterCompilerClass = Class.forName("org.objectweb.carol.cmi.compiler.Compiler");
            clusterCompilerGenerateMethod = clusterCompilerClass.getMethod("generate", new Class[] {String[].class});
        }
        Object cc = clusterCompilerClass.newInstance();
        clusterCompilerGenerateMethod.invoke(cc, new Object[] {args});
    }

    public void genClusterFiles(String classpath, boolean isKeepGenerated, boolean isInvokeCmd) throws GenICException {
        Iterator cf = clusterConfs.iterator();
        Iterator cl = clusteredClasses.iterator();
        while (cf.hasNext()) {
            String ccfn = (String) cf.next();
            String cn = (String) cl.next();

            try {
                ArrayList args = new ArrayList();
                if (isKeepGenerated) {
                    args.add("-keep");
                }
                if (isInvokeCmd) {
                    args.add("-invokecmd");
                }
                args.add("-conf");
                args.add(ccfn);
                args.add("-classpath");
                args.add(classpath);
                if (!"".equals(outputdir)) {
                    args.add("-d");
                    args.add(outputdir);
                }
                args.add(cn);

                String[] c = new String[args.size()];
                c = (String[]) args.toArray(c);
                callClusterCompiler(c);

            } catch (Exception ex) {
                throw new GenICException("Failed when generating the cluster stubs", ex);
            }
        }
        info("Cluster stubs successfully generated");
    }

    public void addClassesInJar(String jarFileName, boolean keepGenerated) throws GenICException {

        if (!generatedIC) {
            return;
        }

        filesToDelete.add(outputdir);

        ArrayList lf = new ArrayList();
        getFilesList(outputdir, lf, !keepGenerated);

        updateJar(jarFileName, outputdir, lf);

    }

    protected String convertName(String name) {
        return name.replace('\\', '/');
    }

    private void updateJar(String jfn, String od, List lfn)
        throws GenICException {

        File jarFile = null;
        File tempJarFile = null;
        JarFile jarArchive = null;
        JarOutputStream tempJarArchive = null;

        try {
            jarFile = new File(jfn);
            tempJarFile = new File(jfn + ".tmp");

            // open existing jar file
            jarArchive = new JarFile(jarFile);

            // create temporary jar
            tempJarArchive = new JarOutputStream(
                    new FileOutputStream(tempJarFile));

            byte[] buffer = new byte[BUFFER_SIZE];
            int read = 0;

            // Add all generated files to temporary jar
            FileInputStream file = null;
            int is = od.length() + 1;
            Iterator iterFiles = lfn.iterator();
            while (iterFiles.hasNext()) {
                try {
                    String fileName = (String) iterFiles.next();

                    file = new FileInputStream(fileName);
                    JarEntry entry = new JarEntry(convertName(fileName.substring(is)));
                    tempJarArchive.putNextEntry(entry);
                    // contents
                    while ((read = file.read(buffer)) != -1) {
                        tempJarArchive.write(buffer, 0, read);
                    }
                } finally {
                    file.close();
                }
            }

            // Add the rest of files (except if already included)
            Enumeration ents = jarArchive.entries();
            while (ents.hasMoreElements()) {
                JarEntry entry = (JarEntry) ents.nextElement();
                // add only if there is not a newer version
                // already included
                if (!lfn.contains(od + File.separator + entry.getName())) {
                    InputStream enStream = jarArchive.getInputStream(
                            entry);
                    tempJarArchive.putNextEntry(entry);
                    // contents
                    while ((read = enStream.read(buffer)) != -1) {
                        tempJarArchive.write(buffer, 0, read);
                    }
                }
            }

        } catch (Exception e) {
            throw new GenICException("Failed when adding the generated classes " + "in the given ejb-jar file '" + jfn
                    + "': " + e);
        } finally {
            // close jar archives
            try {
                jarArchive.close();
            } catch (IOException e1) {
                warning("Failed to close jar archive file '"
                        + jarArchive.getName());
            }
            try {
                tempJarArchive.close();
            } catch (IOException e1) {
                warning("Failed to close temporary jar archive file '"
                        + jarArchive.getName() + "'");
            }
        }

        // Copy temporary jar file -> original jar
        boolean deleted = jarFile.delete();
        boolean rename = tempJarFile.renameTo(jarFile);
        if (!deleted || !rename) {
            error("Failed to update jar archive file '"
                    + jarArchive.getName() + "'");
        }
    }

    public void clean() {
        trace("Deleting " + filesToDelete.toString());
        for (Iterator it = filesToDelete.iterator(); it.hasNext();) {
            String name = (String) it.next();
            File f = new File(name);
            f.delete();
        }
    }

    static void usage() {
        StringBuffer msg = new StringBuffer();
        msg.append("Usage: java org.objectweb.jonas_ejb.genic.GenIC -help \n");
        msg.append("         to print this help message \n");
        msg.append(" or    java org.objectweb.jonas_ejb.genic.GenIC <Options> <Input_File> \n");
        msg.append("         to generate the container-specific classes for given EJB(s). \n");
        msg.append(" \n");
        msg.append("Options include: \n");
        msg.append("       -d <output_dir>  specify where to place the generated files \n");
        msg.append("       -noaddinjar      do not add the generated classes in the given \n");
        msg.append("                        ejb-jar file \n");
        msg.append("       -nocompil        do not compile the generated source files via \n");
        msg.append("                        the java and rmi compilers \n");
        msg.append("       -novalidation    parse the XML deployment descriptors without \n");
        msg.append("                        validation \n");
        msg.append("       -classpath <path> define the classpath to be used to compile classes \n");
        msg.append("       -javac     <opt> specify the java compiler to use \n");
        msg.append("       -javacopts <opt> specify the options to pass to the java compiler \n");
        msg.append("       -rmicopts  <opt> specify the options to pass to the rmi compiler \n");
        msg.append("       -protocols       list of protocol, separated by comma \n");
        msg.append("                        (default is jrmp) \n");
        msg.append("       -invokecmd       invoke, in some case, directly the method of the java class\n");
        msg.append("                        corresponding to the command \n");
        msg.append("       -keepgenerated   do not delete intermediate generated source files \n");
        msg.append("       -verbose \n");
        msg.append("       -debug           deprecated (use the JOnAS trace properties file)\n");
        msg.append(" \n");
        msg.append("       Input_File       standard deployment descriptor file's name or \n");
        msg.append("                        ejb-jar file's name \n");
        GenIC.info(msg.toString());
    }

    void trace(String msg) {
        int level = BasicLevel.DEBUG;
        if (verbose) {
            level = BasicLevel.INFO;
        }
        logger.log(level, msg);
    }

    static void info(String msg) {
        logger.log(BasicLevel.INFO, msg);
    }

    static void warning(String msg) {
        logger.log(BasicLevel.WARN, msg);
    }

    static void error(String msg) {
        logger.log(BasicLevel.ERROR, msg);
    }

    static void fatalError(String msg, Exception e) {
        error("GenIC fatal error: " + msg + e.getMessage());
        throw new RuntimeException(msg);
    }

    static void fatalError(Exception e) {
        System.err.println("GenIC fatal error: ");
        printException(e, System.err);
        throw new RuntimeException(e.getMessage());
    }

    static void printException(Exception e, PrintStream out) {
        Exception inner = null;
        if (e instanceof GenICException && (inner = ((GenICException) e).inner) != null) {
            out.println(e.getMessage());
            printException(inner, out);
        } else if (e instanceof PException && (inner = ((PException) e).getNestedException()) != null) {
            out.println(e.getMessage());
            printException(inner, out);
        } else if (e instanceof MedorException && (inner = ((MedorException) e).getNestedException()) != null) {
            out.println(e.getMessage());
            printException(inner, out);
        } else {
            e.printStackTrace();
        }
    }

    static String 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.getAbsolutePath();
    }

    static void getFilesList(String dir, ArrayList list, boolean onlyClass) {
        File df = new File(dir);
        if (df.exists() && df.isDirectory()) {
            File[] ls = df.listFiles();
            for (int i = 0; i < ls.length; i++) {
                File f = ls[i];
                String fn = f.getAbsolutePath();
                if (f.isDirectory()) {
                    getFilesList(fn, list, onlyClass);
                } else {
                    if (!onlyClass || fn.endsWith(".class")) {
                        if (!fn.endsWith(".save")) {
                            list.add(fn);
                        }
                    }
                }
            }
        }
    }
}

class ProtocolNames {

    private TreeSet protocolNames = new TreeSet();

    ProtocolNames(String pns) {
        if (pns != null && pns.length() > 0) {
            StringTokenizer st = new StringTokenizer(pns, ",", false);
            while (st.hasMoreTokens()) {
                protocolNames.add(st.nextToken().trim());
            }
        } else {
            protocolNames.add("jrmp");
            protocolNames.add("jeremie");
        }
        if (protocolNames.contains(GenIC.CMI_RMI)) {
            protocolNames.add(GenIC.RMI_JRMP);
        }
    }

    boolean isSupported(String pn) {
        return protocolNames.contains(pn);
    }
}

---