RAConfig.java

package org.objectweb.jonas_rar.raconfig;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Properties;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipOutputStream;

import org.objectweb.jonas.security.realm.lib.Base64;
import org.objectweb.jonas_rar.deployment.xml.Connector;
import org.objectweb.jonas_rar.deployment.api.ConfigPropertyDesc;
import org.objectweb.jonas_rar.deployment.xml.ConfigProperty;
import org.objectweb.jonas_rar.deployment.api.RarDeploymentDesc;
import org.objectweb.jonas_rar.deployment.lib.RarDeploymentDescManager;
import org.objectweb.jonas_rar.deployment.xml.Activationspec;
import org.objectweb.jonas_rar.deployment.xml.Adminobject;
import org.objectweb.jonas_rar.deployment.xml.ConnectionDefinition;
import org.objectweb.jonas_rar.deployment.xml.InboundResourceadapter;
import org.objectweb.jonas_rar.deployment.xml.JdbcConnParams;
import org.objectweb.jonas_rar.deployment.xml.JonasActivationspec;
import org.objectweb.jonas_rar.deployment.xml.JonasAdminobject;
import org.objectweb.jonas_rar.deployment.xml.JonasConfigProperty;
import org.objectweb.jonas_rar.deployment.xml.JonasConnectionDefinition;
import org.objectweb.jonas_rar.deployment.xml.JonasConnector;
import org.objectweb.jonas_rar.deployment.xml.JonasSecurityMapping;
import org.objectweb.jonas_rar.deployment.xml.Messageadapter;
import org.objectweb.jonas_rar.deployment.xml.Messagelistener;
import org.objectweb.jonas_rar.deployment.xml.OutboundResourceadapter;
import org.objectweb.jonas_rar.deployment.xml.PoolParams;
import org.objectweb.jonas_rar.deployment.xml.RequiredConfigProperty;
import org.objectweb.jonas_rar.deployment.xml.Resourceadapter;
import org.objectweb.jonas_rar.deployment.xml.SecurityEntry;

public class RAConfig {

    private static final int BUFFER_SIZE = 500;

    private static final double JCA_1_5 = 1.5;
    private static final double JCA_1_0 = 1.0;

    RarDeploymentDesc rarDD = null;

    static boolean validation = true;

    static String outputFile = "META-INF/jonas-ra.xml";

    private static final String xmlVers = "<?xml version = \"1.0\" encoding = \"UTF-8\"?>\n";

    // Constructor
    public RAConfig(String fileName) throws RAConfigException {
        ClassLoader curLoader = Thread.currentThread().getContextClassLoader();

        try {
            RarDeploymentDescManager.setParsingWithValidation(validation);
            rarDD = RarDeploymentDescManager.getInstance(fileName, curLoader);
        } catch (Exception e) {
            throw new RAConfigException(e);
        }

    }

    public RarDeploymentDesc getRarDeploymentDesc() {
        return rarDD;
    }

    private static void buildXML(String fileInputName, String jndiname, String rarlink, Properties dbProps,
            boolean encrypt, String securityfile, String path,
            boolean isVerbose) throws RAConfigException {

        RAConfig raxml = new RAConfig(fileInputName);
        Connector conn = raxml.getRarDeploymentDesc().getConnector();
        double specVersion = 0.0;
        ConfigPropertyDesc[] raProps = raxml.getRarDeploymentDesc().getRaConfigPropTags();
        if (raProps == null) {
            throw new RAConfigException("RAR file doesn't contain ra.xml");
        }
        if (conn.getSpecVersion().equals("1.0")) {
            specVersion = JCA_1_0;
        } else if (conn.getSpecVersion().equals("1.5")) {
            specVersion = JCA_1_5;
        } else {
            throw new RAConfigException("ra.xml doesn't correct spec version");
        }

        JonasConnector jConn = new JonasConnector();
        PoolParams jPool = new PoolParams();
        JdbcConnParams jConnParams = new JdbcConnParams();
        JonasConfigProperty jCfg = null;

        String val = "";
        String str = "";
        jPool.setPoolInit("0");

        val = "0";
        if (dbProps.getProperty("jdbc.minconpool") != null && dbProps.getProperty("jdbc.minconpool").length() > 0) {
            val = dbProps.getProperty("jdbc.minconpool").trim();
        }
        jPool.setPoolMin(val);

        val = "-1";
        if (dbProps.getProperty("jdbc.maxconpool") != null && dbProps.getProperty("jdbc.maxconpool").length() > 0) {
            val = dbProps.getProperty("jdbc.maxconpool").trim();
        }
        jPool.setPoolMax(val);

        val = "0";
        if (dbProps.getProperty("jdbc.connmaxage") != null && dbProps.getProperty("jdbc.connmaxage").length() > 0) {
            val = dbProps.getProperty("jdbc.connmaxage").trim();
        }
        jPool.setPoolMaxAgeMinutes(val);

        jPool.setPstmtMax("10");

        val = "0";
        if (dbProps.getProperty("jdbc.maxopentime") != null && dbProps.getProperty("jdbc.maxopentime").length() > 0) {
            val = dbProps.getProperty("jdbc.maxopentime").trim();
        }
        jPool.setPoolMaxOpentime(val);

        val = "0";
        if (dbProps.getProperty("jdbc.maxwaiters") != null && dbProps.getProperty("jdbc.maxwaiters").length() > 0) {
            val = dbProps.getProperty("jdbc.maxwaiters").trim();
        }
        jPool.setPoolMaxWaiters(val);

        val = "0";
        if (dbProps.getProperty("jdbc.maxwaittime") != null && dbProps.getProperty("jdbc.maxwaittime").length() > 0) {
            val = dbProps.getProperty("jdbc.maxwaittime").trim();
        }
        jPool.setPoolMaxWaittime(val);

        val = "30";
        if (dbProps.getProperty("jdbc.samplingperiod") != null && dbProps.getProperty("jdbc.samplingperiod").length() > 0) {
            val = dbProps.getProperty("jdbc.samplingperiod").trim();
        }
        jPool.setPoolSamplingPeriod(val);


        jConn.setLogEnabled("false");
        jConn.setLogTopic("");
        jConn.setNativeLib("");
        if (jndiname.length() == 0) {
            jndiname = dbProps.getProperty("datasource.name", "").trim();
        }

        val = "0";
        if (dbProps.getProperty("jdbc.connchecklevel") != null
                && dbProps.getProperty("jdbc.connchecklevel").length() > 0) {
            val = dbProps.getProperty("jdbc.connchecklevel").trim();
        }
        jConnParams.setJdbcCheckLevel(val);

        val = "";
        if (dbProps.getProperty("jdbc.connteststmt") != null && dbProps.getProperty("jdbc.connteststmt").length() > 0) {
            val = dbProps.getProperty("jdbc.connteststmt").trim();
            jConnParams.setJdbcTestStatement(val);
        }

        if (specVersion == 1.0) {
            jConn.setJndiName(jndiname);
        }
        jConn.setRarlink(rarlink);
        jConn.setPoolParams(jPool);
        jConn.setJdbcConnParams(jConnParams);

        if (specVersion == JCA_1_0) {
            val = "";
            str = "";
            for (int i = 0; i < raProps.length; i++) {
                jCfg = new JonasConfigProperty();
                str = raProps[i].getConfigPropertyName();
                jCfg.setJonasConfigPropertyName(str);
                if (dbProps.size() > 0) {
                    val = getProp(dbProps, str);
                } else {
                    val = "";
                }
                jCfg.setJonasConfigPropertyValue(val);
                jConn.addJonasConfigProperty(jCfg);
            }
        } else if (specVersion == JCA_1_5) {
            Resourceadapter rAdapter = conn.getResourceadapter();
            ConfigProperty cProperty = null;
            // TODO rProperty never used !!!
            RequiredConfigProperty rProperty = null;
            // Process config properties if they exist
            for (Iterator i = rAdapter.getConfigPropertyList().iterator(); i.hasNext();) {
                cProperty = (ConfigProperty) i.next();
                jCfg = new JonasConfigProperty();
                str = cProperty.getConfigPropertyName();
                jCfg.setJonasConfigPropertyName(str);
                if (dbProps.size() > 0) {
                    val = getProp(dbProps, str);
                } else {
                    val = "";
                }
                jCfg.setJonasConfigPropertyValue(val);
                jConn.addJonasConfigProperty(jCfg);
            }
            // Now process the outbound-resourceadapter
            OutboundResourceadapter oRes = rAdapter.getOutboundResourceadapter();
            if (oRes != null) {
                ConnectionDefinition cDef = null;
                JonasConnectionDefinition jcDef = null;
                for (Iterator it = oRes.getConnectionDefinitionList().iterator(); it.hasNext();) {
                    cDef = (ConnectionDefinition) it.next();
                    jcDef = new JonasConnectionDefinition();
                    jcDef.setId(cDef.getId());
                    jcDef.addDescription(cDef.getManagedconnectionfactoryClass());
                    jcDef.setJndiName("");
                    for (Iterator i = cDef.getConfigPropertyList().iterator(); i.hasNext();) {
                        cProperty = (ConfigProperty) i.next();
                        jCfg = new JonasConfigProperty();
                        str = cProperty.getConfigPropertyName();
                        jCfg.setJonasConfigPropertyName(str);
                        jCfg.setJonasConfigPropertyValue("");
                        jcDef.addJonasConfigProperty(jCfg);
                    }
                    jConn.addJonasConnectionDefinition(jcDef);
                }
            }
            // Now process the inbound-resourceadapter
            InboundResourceadapter iRes = rAdapter.getInboundResourceadapter();
            if (iRes != null) {
                Messageadapter mAdapter = iRes.getMessageadapter();
                if (mAdapter != null) {
                    Messagelistener mList = null;
                    JonasActivationspec jaSpec = null;
                    Activationspec aSpec = null;
                    for (Iterator it = mAdapter.getMessagelistenerList().iterator(); it.hasNext();) {
                        mList = (Messagelistener) it.next();
                        aSpec = mList.getActivationspec();
                        if (aSpec != null) {
                            jaSpec = new JonasActivationspec();
                            jaSpec.setId(mList.getId());
                            jaSpec.addDescription(mList.getMessagelistenerType());
                            jaSpec.setJndiName("");
                            jConn.addJonasActivationspec(jaSpec);
                        }
                    }
                }
            }
            // Now process the adminobject
            for (Iterator it = rAdapter.getAdminobjectList().iterator(); it.hasNext();) {
                Adminobject aObj = (Adminobject) it.next();
                JonasAdminobject jaObj = null;
                if (aObj != null) {
                    jaObj = new JonasAdminobject();
                    jaObj.setId(aObj.getId());
                    jaObj.addDescription(aObj.getAdminobjectClass());
                    jaObj.setJndiName("");
                    // Process config properties if they exist
                    for (Iterator i = aObj.getConfigPropertyList().iterator(); i.hasNext();) {
                        cProperty = (ConfigProperty) i.next();
                        jCfg = new JonasConfigProperty();
                        str = cProperty.getConfigPropertyName();
                        jCfg.setJonasConfigPropertyName(str);
                        jCfg.setJonasConfigPropertyValue("");
                        jaObj.addJonasConfigProperty(jCfg);
                    }
                    jConn.addJonasAdminobject(jaObj);
                }
            }
        }

        if (securityfile != null) {
            Properties secProps = new Properties();
            File f = null;
            try {
                f = new File(securityfile);
                FileInputStream is = new FileInputStream(f);
                secProps.load(is);
            } catch (FileNotFoundException e) {
                System.err.println("Cannot find security properties file: " + securityfile);
                System.err.println("Continuing with creation of jonas-ra.xml");
            } catch (IOException e) {
                System.err.println(e);
            }

            JonasSecurityMapping jsMap = new JonasSecurityMapping();
            String pName = null;
            String user = null;
            String pass = null;
            String tmp = null;
            int offset = 0;
            SecurityEntry sEnt = null;
            for (Enumeration e = secProps.propertyNames(); e.hasMoreElements();) {
                pName = (String) e.nextElement();
                tmp = secProps.getProperty(pName);
                offset = tmp.indexOf("::");
                if (offset < 0) {
                    System.err.println("Error in format of file:  principalName = user::password");
                    continue;
                }
                user = tmp.substring(0, offset);
                pass = tmp.substring(offset + 2);

                sEnt = new SecurityEntry();
                sEnt.setPrincipalName(pName);
                sEnt.setUser(user);
                if (encrypt) {
                    try {
                        pass = new String(Base64.encode(pass.getBytes()));
                        sEnt.setEncrypted("" + encrypt);
                    } catch (Exception ex) {
                        System.err.println("Unable to encrypt the password.");
                    }
                }
                sEnt.setPassword(pass);
                jsMap.addSecurityEntry(sEnt);
            }
            jConn.setJonasSecurityMapping(jsMap);
        }

        try {
            String tmpDir = (path.length() > 0 ? path : System.getProperty("java.io.tmpdir"));
            String fileName = tmpDir + File.separator + "jonas-ra.xml";
            FileWriter fw = new FileWriter(fileName);
            fw.write(xmlVers);
            fw.write(jConn.toXML());
            fw.close();
            if (isVerbose) {
                System.out.println("Build Jonas Specific DD File '" + fileName + "' OK");
            }

        } catch (Exception e) {
            throw new RAConfigException("Error writing output", e);
        }
    }

    private static String getProp(Properties prop, String str) {
        String[][] mapping = {{"connCheckLevel", "jdbc.connchecklevel"}, {"connMaxAge", "jdbc.connmaxage"},
                {"connTestStmt", "jdbc.connteststmt"}, {"URL", "datasource.url"}, {"dsClass", "datasource.classname"},
                {"user", "datasource.username"}, {"password", "datasource.password"},
                {"isolationLevel", "datasource.isolationlevel"}, {"mapperName", "datasource.mapper"}, };

        String ret = "";
        for (int i = 0; i < mapping.length; i++) {
            if (mapping[i][0].equalsIgnoreCase(str)) {
                ret = (prop.getProperty(mapping[i][1]) == null ? "" : prop.getProperty(mapping[i][1]).trim());
            }
        }

        return ret;
    }

    private static void updateRAR(String infile, String outfile, String updatename, String rarlink)
            throws RAConfigException {

        ZipOutputStream zipOutput = null;
        ZipFile zipFile = null;
        Enumeration zippedFiles = null;
        ZipEntry currEntry = null;
        ZipEntry entry = null;
        byte[] buffer = new byte[BUFFER_SIZE];
        int num = 0;

        String filename = infile;
        String outfilename = infile;
        boolean outNew = false;
        if (outfile != null && outfile.length() != 0) {
            outfilename = outfile;
            outNew = true;
        }

        try {
            File file = new File(filename);
            if (file.exists()) {
                zipFile = new ZipFile(file.getAbsolutePath());
                //get an enumeration of all existing entries
                zippedFiles = zipFile.entries();
                //create your output zip file
                if (!outNew) {
                    zipOutput = new ZipOutputStream(new FileOutputStream(new File(file.getAbsolutePath() + "NEW")));
                } else {
                    File ofile = new File(outfilename);
                    if (ofile.exists()) {
                        ofile.delete();
                    }

                    zipOutput = new ZipOutputStream(new FileOutputStream(new File(outfilename)));
                }
                //Get all the data out of the previously zipped files and
                // write
                // it to a new ZipEntry to go into a new file archive
                if ((outfile == null || outfile.length() == 0) && rarlink.length() == 0) {
                    while (zippedFiles.hasMoreElements()) {
                        //Retrieve entry of existing files
                        currEntry = (ZipEntry) zippedFiles.nextElement();
                        if (currEntry.getName().equalsIgnoreCase(outputFile)) {
                            continue;
                        }
                        //Read data from existing file
                        zipOutput.putNextEntry(new ZipEntry(currEntry.getName()));
                        InputStream reader = zipFile.getInputStream(currEntry);
                        while ((num = reader.read(buffer)) != -1) {
                            zipOutput.write(buffer, 0, num);
                        }
                        //Commit the data
                        zipOutput.flush();
                        zipOutput.closeEntry();
                    }
                }
                //Close the old zip file
                zipFile.close();

                //Write the 'new' file to the archive, commit, and close
                entry = new ZipEntry(outputFile);
                zipOutput.putNextEntry(entry);

                //Read data from existing file
                try {
                    BufferedReader reader = new BufferedReader(new FileReader(updatename));
                    int ch = 0;
                    while ((ch = reader.read()) != -1) {
                        zipOutput.write(ch);
                    }
                } catch (Exception ex) {
                    System.out.println("Error reading input file: " + updatename + " " + ex);
                    //Commit the data
                    zipOutput.flush();
                    zipOutput.closeEntry();
                    zipOutput.finish();
                    zipOutput.close();
                }
                //Commit the data
                zipOutput.flush();
                zipOutput.closeEntry();
                zipOutput.finish();
                zipOutput.close();

                if (!outNew) {
                    //delete the old file and rename the new one
                    File toBeDeleted = new File(file.getAbsolutePath());
                    toBeDeleted.delete();
                    File toBeRenamed = new File(file.getAbsolutePath() + "NEW");
                    toBeRenamed.renameTo(file);
                }
            } else {
                //create your output zip file
                zipOutput = new ZipOutputStream(new FileOutputStream(new File(outfilename)));

                //Write the file to the archive, commit, and close
                entry = new ZipEntry(outputFile);
                zipOutput.putNextEntry(entry);
                //Read data from existing file
                BufferedReader reader = new BufferedReader(new FileReader(updatename));
                int ch = 0;
                while ((ch = reader.read()) != -1) {
                    zipOutput.write(ch);
                }

                //Commit the data
                zipOutput.flush();
                zipOutput.closeEntry();
                zipOutput.finish();
                zipOutput.close();
            }
            // finally, we delete generated jonas-ra.xml
            new File(updatename).delete();
        } catch (Exception ex) {
            throw new RAConfigException(ex);
        }

    }

    private static String indent(int count) {
        String front = "";
        String indentChars = "    ";
        for (int i = 0; i < count; i++) {
            front += indentChars;
        }
        return front;
    }

    public static void usage() {
        System.out.println("");
        System.out.println("Usage: java org.objectweb.jonas.resource.RAConfig <Options> <Input_File> [Output_File]");
        System.out.println("     to generate the jonas-ra.xml file for a Resource Adapter.");
        System.out.println("");
        System.out.println("       With Options:");
        System.out.println("         -? or -help                print this help message");
        System.out.println("         -DM,-DS,-PC,-XA            DriverManager, Datasource, PooledConnection,");
        System.out.println("                                    XAConnection only used with -p");
        System.out.println("         -Jndiname <jndiname>       specifies the jndiname RA");
        System.out.println("         -Property <property file>  specifies the database property file");
        System.out.println("                                     to process");
        System.out.println("         -Rarlink <rarlink>         specifies the rar file to link to");
        System.out.println("         -Update <input name>       update the input rar with the specified file");
        System.out.println("                                    unless an output_file named is specified");
        System.out.println("         -ENcrypt                   used with -sf to encrypt the passwords ");
        System.out.println("         -SecurityFile              security xml file to add to jonas-ra.xml ");
        System.out.println("         -Verbose                   output the contents of the  deployment descriptor ");
        System.out.println("         -NoValidation              turn off xml dtd/schema validation ");
        System.out.println("         -PATH <path>               path where jonas-ra.xml should be written to ");
        System.out.println("                                     default is System.property('java.io.tmpdir')");
        System.out.println("");
        System.out.println("       Input_File     Resource Adapter RAR file");
        System.out.println("       Output_File    Resource Adapter RAR file only used with ");
        System.out.println("                          -p(required) or -u(optional)");
        System.out.println("");
    }

    // Main Method
    public static void main(String[] args) throws RAConfigException {
        PrintStream out = null;
        boolean isHelp = false;
        boolean isVerbose = false;
        boolean doProperty = false;
        boolean doUpdate = false;
        boolean encrypt = false;
        String fileInputName = null;
        String fileOutputName = null;
        String securityfile = null;
        String jndiname = "";
        String rarlink = "";
        String updatename = "";
        String jdbcRarLink = "";
        String jonasRarStr = "JOnASJDBC_";
        String propertyFile = "";
        String path = "";
        // Get command args

        Properties dbProps = null;

        if (args.length < 1) {
            isHelp = true;
        }
        for (int argn = 0; argn < args.length; argn++) {
            String arg = args[argn].toLowerCase();
            if (arg.equals("-help") || arg.equals("-?")) {
                isHelp = true;
                continue;
            }
            if (arg.equals("-verbose") || arg.equals("-v")) {
                isVerbose = true;
                continue;
            }
            if (arg.equals("-encrypt") || arg.equals("-en")) {
                encrypt = true;
                continue;
            }
            if (arg.equals("-securityfile") || arg.equals("-sf")) {
                if (argn + 1 == args.length || args[++argn].startsWith("-")) {
                    usage();
                    throw new RAConfigException("Error with -sf input");
                }
                securityfile = args[argn];
                continue;
            }
            if (arg.equals("-novalidation") || arg.equals("-nv")) {
                validation = false;
                continue;
            }
            if (arg.equals("-update") || arg.equals("-u")) {
                doUpdate = true;
                if (argn + 1 == args.length || args[++argn].startsWith("-")) {
                    usage();
                    throw new RAConfigException("Error with -u input");
                }
                updatename = args[argn];
                continue;
            }
            if (arg.equals("-jndiname") || arg.equals("-j")) {
                if (argn + 1 == args.length || args[++argn].startsWith("-")) {
                    usage();
                    throw new RAConfigException("Error with -j input");
                }
                jndiname = args[argn];
                continue;
            }
            if (arg.equals("-rarlink") || arg.equals("-r")) {
                if (argn + 1 == args.length || args[++argn].startsWith("-")) {
                    usage();
                    throw new RAConfigException("Error with -r input");
                }
                rarlink = args[argn];
                continue;
            }
            if (arg.equals("-property") || arg.equals("-p")) {
                doProperty = true;
                if (argn + 1 == args.length || args[++argn].startsWith("-")) {
                    usage();
                    throw new RAConfigException("Error with -p input");
                }
                propertyFile = args[argn];
                continue;
            }
            if (arg.equals("-dm")) {
                jdbcRarLink = jonasRarStr + "DM";
                continue;
            }
            if (arg.equals("-ds")) {
                jdbcRarLink = jonasRarStr + "DS";
                continue;
            }
            if (arg.equals("-xa")) {
                jdbcRarLink = jonasRarStr + "XA";
                continue;
            }
            if (arg.equals("-pc")) {
                jdbcRarLink = jonasRarStr + "PC";
                continue;
            }
            if (arg.equals("-path")) {
                if (argn + 1 == args.length || args[++argn].startsWith("-")) {
                    usage();
                    throw new RAConfigException("Error with -path");
                }
                path = args[argn];
                continue;
            }
            if (fileInputName == null) {
                fileInputName = args[argn];
                if (!fileInputName.endsWith(".rar")) {
                    fileInputName += ".rar";
                }
            } else if (doProperty || doUpdate) {
                if (fileOutputName == null) {
                    fileOutputName = args[argn];
                    if (!fileOutputName.endsWith(".rar")) {
                        fileOutputName += ".rar";
                    }
                }
            } else {
                usage();
                throw new RAConfigException("Error multiple input files specified without -property or -update");
            }
        }

        // Usage ?
        if (isHelp) {
            usage();
            System.exit(0);
        }
        if (fileInputName == null) {
            usage();
            throw new RAConfigException("Error missing input file");
        }
        if (doProperty && fileOutputName == null) {
            usage();
            throw new RAConfigException("Error missing output file");
        }
        if (fileInputName.equals(fileOutputName)) {
            throw new RAConfigException("Input and Output filenames cannot be the same");
        }

        dbProps = new Properties();
        if (doProperty) {
            if (jdbcRarLink.length() > 0 && rarlink.length() == 0) {
                rarlink = jdbcRarLink;
            }
            try {
                dbProps.load(new FileInputStream(propertyFile));
            } catch (Exception ex) {
                if (propertyFile.endsWith(".properties")) {
                    System.out.println("Error reading " + propertyFile + " " + ex);
                } else {
                    try {
                        dbProps.load(new FileInputStream(propertyFile + ".properties"));
                    } catch (Exception ex1) {
                        System.out.println("Error reading " + propertyFile + " " + ex);
                    }
                }
            }
            buildXML(fileInputName, jndiname, rarlink, dbProps, encrypt, securityfile, path, isVerbose);
            if (updatename.length() == 0) {
                updatename = System.getProperty("java.io.tmpdir") + File.separator + "jonas-ra.xml";
            }
            updateRAR(fileInputName, fileOutputName, updatename, rarlink);
        } else if (doUpdate) {
            updateRAR(fileInputName, fileOutputName, updatename, rarlink);
        } else {
            buildXML(fileInputName, jndiname, rarlink, dbProps, encrypt, securityfile, path, isVerbose);
        }
    }
}

---