FileDocCategorySizeDatePackage
WebsphereDeploymentTool.javaAPI DocApache Ant 1.7031341Wed Dec 13 06:16:20 GMT 2006org.apache.tools.ant.taskdefs.optional.ejb

WebsphereDeploymentTool

public class WebsphereDeploymentTool extends GenericDeploymentTool
Websphere deployment tool that augments the ejbjar task. Searches for the websphere specific deployment descriptors and adds them to the final ejb jar file. Websphere has two specific descriptors for session beans:
  • ibm-ejb-jar-bnd.xmi
  • ibm-ejb-jar-ext.xmi
and another two for container managed entity beans:
  • Map.mapxmi
  • Schema.dbxmi
In terms of WebSphere, the generation of container code and stubs is called deployment. This step can be performed by the websphere element as part of the jar generation process. If the switch ejbdeploy is on, the ejbdeploy tool from the websphere toolset is called for every ejb-jar. Unfortunately, this step only works, if you use the ibm jdk. Otherwise, the rmic (called by ejbdeploy) throws a ClassFormatError. Be sure to switch ejbdeploy off, if run ant with sun jdk.

Fields Summary
public static final String
PUBLICID_EJB11
ID for ejb 1.1
public static final String
PUBLICID_EJB20
ID for ejb 2.0
protected static final String
SCHEMA_DIR
Schema directory
protected static final String
WAS_EXT
protected static final String
WAS_BND
protected static final String
WAS_CMP_MAP
protected static final String
WAS_CMP_SCHEMA
private static final org.apache.tools.ant.util.FileUtils
FILE_UTILS
private String
jarSuffix
Instance variable that stores the suffix for the websphere jarfile.
private String
ejb11DTD
Instance variable that stores the location of the ejb 1.1 DTD file.
private boolean
keepGeneric
Instance variable that determines whether generic ejb jars are kept.
private boolean
alwaysRebuild
private boolean
ejbdeploy
private boolean
newCMP
Indicates if the old CMP location convention is to be used.
private org.apache.tools.ant.types.Path
wasClasspath
The classpath to the websphere classes.
private String
dbVendor
The DB Vendor name, the EJB is persisted against
private String
dbName
The name of the database to create. (For top-down mapping only)
private String
dbSchema
The name of the schema to create. (For top-down mappings only)
private boolean
codegen
true - Only generate the deployment code, do not run RMIC or Javac
private boolean
quiet
true - Only output error messages, suppress informational messages
private boolean
novalidate
true - Disable the validation steps
private boolean
nowarn
true - Disable warning and informational messages
private boolean
noinform
true - Disable informational messages
private boolean
trace
true - Enable internal tracing
private String
rmicOptions
Additional options for RMIC
private boolean
use35MappingRules
true- Use the WebSphere 3.5 compatible mapping rules
private String
tempdir
the scratchdir for the ejbdeploy operation
private File
websphereHome
the home directory for websphere
Constructors Summary
Methods Summary
protected voidaddVendorFiles(java.util.Hashtable ejbFiles, java.lang.String baseName)
Add any vendor specific files which should be included in the EJB Jar.

param
ejbFiles a hashtable entryname -> file.
param
baseName a prefix to use.


        String ddPrefix = (usingBaseJarName() ? "" : baseName);
        String dbPrefix = (dbVendor == null) ? "" : dbVendor + "-";

        // Get the Extensions document
        File websphereEXT = new File(getConfig().descriptorDir, ddPrefix + WAS_EXT);

        if (websphereEXT.exists()) {
            ejbFiles.put(META_DIR + WAS_EXT,
                websphereEXT);
        } else {
            log("Unable to locate websphere extensions. "
                + "It was expected to be in "
                + websphereEXT.getPath(), Project.MSG_VERBOSE);
        }

        File websphereBND = new File(getConfig().descriptorDir, ddPrefix + WAS_BND);

        if (websphereBND.exists()) {
            ejbFiles.put(META_DIR + WAS_BND,
                websphereBND);
        } else {
            log("Unable to locate websphere bindings. "
                + "It was expected to be in "
                + websphereBND.getPath(), Project.MSG_VERBOSE);
        }

        if (!newCMP) {
            log("The old method for locating CMP files has been DEPRECATED.",
                Project.MSG_VERBOSE);
            log("Please adjust your websphere descriptor and set "
                + "newCMP=\"true\" to use the new CMP descriptor "
                + "inclusion mechanism. ", Project.MSG_VERBOSE);
        } else {
            // We attempt to put in the MAP and Schema files of CMP beans
            try {
                // Add the Map file
                File websphereMAP = new File(getConfig().descriptorDir,
                    ddPrefix + dbPrefix + WAS_CMP_MAP);

                if (websphereMAP.exists()) {
                    ejbFiles.put(META_DIR + WAS_CMP_MAP,
                        websphereMAP);
                } else {
                    log("Unable to locate the websphere Map: "
                        + websphereMAP.getPath(), Project.MSG_VERBOSE);
                }

                File websphereSchema = new File(getConfig().descriptorDir,
                    ddPrefix + dbPrefix + WAS_CMP_SCHEMA);

                if (websphereSchema.exists()) {
                    ejbFiles.put(META_DIR + SCHEMA_DIR + WAS_CMP_SCHEMA,
                        websphereSchema);
                } else {
                    log("Unable to locate the websphere Schema: "
                        + websphereSchema.getPath(), Project.MSG_VERBOSE);
                }
                // Theres nothing else to see here...keep moving sonny
            } catch (Exception e) {
                String msg = "Exception while adding Vendor specific files: "
                    + e.toString();

                throw new BuildException(msg, e);
            }
        }
private voidbuildWebsphereJar(java.io.File sourceJar, java.io.File destJar)
Helper method invoked by execute() for each websphere jar to be built. Encapsulates the logic of constructing a java task for calling websphere.ejbdeploy and executing it.

param
sourceJar java.io.File representing the source (EJB1.1) jarfile.
param
destJar java.io.File representing the destination, websphere jarfile.

        try {
            if (ejbdeploy) {
                Java javaTask = new Java(getTask());
                // Set the JvmArgs
                javaTask.createJvmarg().setValue("-Xms64m");
                javaTask.createJvmarg().setValue("-Xmx128m");

                // Set the Environment variable
                Environment.Variable var = new Environment.Variable();

                var.setKey("websphere.lib.dir");
                File libdir = new File(websphereHome, "lib");
                var.setValue(libdir.getAbsolutePath());
                javaTask.addSysproperty(var);

                // Set the working directory
                javaTask.setDir(websphereHome);

                // Set the Java class name
                javaTask.setTaskName("ejbdeploy");
                javaTask.setClassname("com.ibm.etools.ejbdeploy.EJBDeploy");

                javaTask.createArg().setValue(sourceJar.getPath());
                javaTask.createArg().setValue(tempdir);
                javaTask.createArg().setValue(destJar.getPath());
                javaTask.createArg().setLine(getOptions());
                if (getCombinedClasspath() != null
                    && getCombinedClasspath().toString().length() > 0) {
                    javaTask.createArg().setValue("-cp");
                    javaTask.createArg().setValue(getCombinedClasspath().toString());
                }

                Path classpath = wasClasspath;

                if (classpath == null) {
                    classpath = getCombinedClasspath();
                }

                if (classpath != null) {
                    javaTask.setClasspath(classpath);
                    javaTask.setFork(true);
                } else {
                    javaTask.setFork(true);
                }

                log("Calling websphere.ejbdeploy for " + sourceJar.toString(),
                    Project.MSG_VERBOSE);

                javaTask.execute();
            }
        } catch (Exception e) {
            // Have to catch this because of the semantics of calling main()
            String msg = "Exception while calling ejbdeploy. Details: " + e.toString();

            throw new BuildException(msg, e);
        }
public org.apache.tools.ant.types.PathcreateWASClasspath()
Get the classpath to the websphere classpaths.

return
the websphere classpath.


                    
       
        if (wasClasspath == null) {
            wasClasspath = new Path(getTask().getProject());
        }
        return wasClasspath.createPath();
protected java.lang.ClassLoadergetClassLoaderFromJar(java.io.File classjar)
Helper method invoked by isRebuildRequired to get a ClassLoader for a Jar File passed to it.

param
classjar java.io.File representing jar file to get classes from.
return
a classloader for the jar file.
throws
IOException if there is an error.

        Path lookupPath = new Path(getTask().getProject());

        lookupPath.setLocation(classjar);

        Path classpath = getCombinedClasspath();

        if (classpath != null) {
            lookupPath.append(classpath);
        }

        return getTask().getProject().createClassLoader(lookupPath);
protected DescriptorHandlergetDescriptorHandler(java.io.File srcDir)
{@inheritDoc}.

        DescriptorHandler handler = new DescriptorHandler(getTask(), srcDir);
        // register all the DTDs, both the ones that are known and
        // any supplied by the user
        handler.registerDTD(PUBLICID_EJB11, ejb11DTD);

        for (Iterator i = getConfig().dtdLocations.iterator(); i.hasNext();) {
            EjbJar.DTDLocation dtdLocation = (EjbJar.DTDLocation) i.next();

            handler.registerDTD(dtdLocation.getPublicId(), dtdLocation.getLocation());
        }

        return handler;
protected java.lang.StringgetOptions()
Gets the options for the EJB Deploy operation

return
String

        // Set the options
        StringBuffer options = new StringBuffer();

        if (dbVendor != null) {
            options.append(" -dbvendor ").append(dbVendor);
        }
        if (dbName != null) {
            options.append(" -dbname \"").append(dbName).append("\"");
        }

        if (dbSchema != null) {
            options.append(" -dbschema \"").append(dbSchema).append("\"");
        }

        if (codegen) {
            options.append(" -codegen");
        }

        if (quiet) {
            options.append(" -quiet");
        }

        if (novalidate) {
            options.append(" -novalidate");
        }

        if (nowarn) {
            options.append(" -nowarn");
        }

        if (noinform) {
            options.append(" -noinform");
        }

        if (trace) {
            options.append(" -trace");
        }

        if (use35MappingRules) {
            options.append(" -35");
        }

        if (rmicOptions != null) {
            options.append(" -rmic \"").append(rmicOptions).append("\"");
        }

        return options.toString();
java.io.FilegetVendorOutputJarFile(java.lang.String baseName)
Get the vendor specific name of the Jar that will be output. The modification date of this jar will be checked against the dependent bean classes.

        return new File(getDestDir(), baseName + jarSuffix);
protected DescriptorHandlergetWebsphereDescriptorHandler(java.io.File srcDir)
Get a description handler.

param
srcDir the source directory.
return
the handler.

        DescriptorHandler handler =
            new DescriptorHandler(getTask(), srcDir) {
                protected void processElement() {
                }
            };

        for (Iterator i = getConfig().dtdLocations.iterator(); i.hasNext();) {
            EjbJar.DTDLocation dtdLocation = (EjbJar.DTDLocation) i.next();

            handler.registerDTD(dtdLocation.getPublicId(), dtdLocation.getLocation());
        }
        return handler;
protected booleanisRebuildRequired(java.io.File genericJarFile, java.io.File websphereJarFile)
Helper method to check to see if a websphere EBJ1.1 jar needs to be rebuilt using ejbdeploy. Called from writeJar it sees if the "Bean" classes are the only thing that needs to be updated and either updates the Jar with the Bean classfile or returns true, saying that the whole websphere jar needs to be regened with ejbdeploy. This allows faster build times for working developers.

The way websphere ejbdeploy works is it creates wrappers for the publicly defined methods as they are exposed in the remote interface. If the actual bean changes without changing the the method signatures then only the bean classfile needs to be updated and the rest of the websphere jar file can remain the same. If the Interfaces, ie. the method signatures change or if the xml deployment descriptors changed, the whole jar needs to be rebuilt with ejbdeploy. This is not strictly true for the xml files. If the JNDI name changes then the jar doesnt have to be rebuild, but if the resources references change then it does. At this point the websphere jar gets rebuilt if the xml files change at all.

param
genericJarFile java.io.File The generic jar file.
param
websphereJarFile java.io.File The websphere jar file to check to see if it needs to be rebuilt.
return
true if a rebuild is required.

        boolean rebuild = false;

        JarFile genericJar = null;
        JarFile wasJar = null;
        File newwasJarFile = null;
        JarOutputStream newJarStream = null;

        try {
            log("Checking if websphere Jar needs to be rebuilt for jar "
                + websphereJarFile.getName(), Project.MSG_VERBOSE);
            // Only go forward if the generic and the websphere file both exist
            if (genericJarFile.exists() && genericJarFile.isFile()
                 && websphereJarFile.exists() && websphereJarFile.isFile()) {
                //open jar files
                genericJar = new JarFile(genericJarFile);
                wasJar = new JarFile(websphereJarFile);

                Hashtable genericEntries = new Hashtable();
                Hashtable wasEntries = new Hashtable();
                Hashtable replaceEntries = new Hashtable();

                //get the list of generic jar entries
                for (Enumeration e = genericJar.entries(); e.hasMoreElements();) {
                    JarEntry je = (JarEntry) e.nextElement();

                    genericEntries.put(je.getName().replace('\\", '/"), je);
                }
                //get the list of websphere jar entries
                for (Enumeration e = wasJar.entries(); e.hasMoreElements();) {
                    JarEntry je = (JarEntry) e.nextElement();

                    wasEntries.put(je.getName(), je);
                }

                //Cycle Through generic and make sure its in websphere
                ClassLoader genericLoader = getClassLoaderFromJar(genericJarFile);

                for (Enumeration e = genericEntries.keys(); e.hasMoreElements();) {
                    String filepath = (String) e.nextElement();

                    if (wasEntries.containsKey(filepath)) {
                        // File name/path match
                        // Check files see if same
                        JarEntry genericEntry = (JarEntry) genericEntries.get(filepath);
                        JarEntry wasEntry = (JarEntry) wasEntries.get(filepath);

                        if ((genericEntry.getCrc() != wasEntry.getCrc())
                            || (genericEntry.getSize() != wasEntry.getSize())) {

                            if (genericEntry.getName().endsWith(".class")) {
                                //File are different see if its an object or an interface
                                String classname
                                    = genericEntry.getName().replace(File.separatorChar, '.");

                                classname = classname.substring(0, classname.lastIndexOf(".class"));

                                Class genclass = genericLoader.loadClass(classname);

                                if (genclass.isInterface()) {
                                    //Interface changed   rebuild jar.
                                    log("Interface " + genclass.getName()
                                        + " has changed", Project.MSG_VERBOSE);
                                    rebuild = true;
                                    break;
                                } else {
                                    //Object class Changed   update it.
                                    replaceEntries.put(filepath, genericEntry);
                                }
                            } else {
                                // is it the manifest. If so ignore it
                                if (!genericEntry.getName().equals("META-INF/MANIFEST.MF")) {
                                    //File other then class changed   rebuild
                                    log("Non class file " + genericEntry.getName()
                                        + " has changed", Project.MSG_VERBOSE);
                                    rebuild = true;
                                }
                                break;
                            }
                        }
                    } else {
                        // a file doesn't exist rebuild

                        log("File " + filepath + " not present in websphere jar",
                            Project.MSG_VERBOSE);
                        rebuild = true;
                        break;
                    }
                }

                if (!rebuild) {
                    log("No rebuild needed - updating jar", Project.MSG_VERBOSE);
                    newwasJarFile = new File(websphereJarFile.getAbsolutePath() + ".temp");
                    if (newwasJarFile.exists()) {
                        newwasJarFile.delete();
                    }

                    newJarStream = new JarOutputStream(new FileOutputStream(newwasJarFile));
                    newJarStream.setLevel(0);

                    //Copy files from old websphere jar
                    for (Enumeration e = wasEntries.elements(); e.hasMoreElements();) {
                        byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
                        int bytesRead;
                        InputStream is;
                        JarEntry je = (JarEntry) e.nextElement();

                        if (je.getCompressedSize() == -1
                            || je.getCompressedSize() == je.getSize()) {
                            newJarStream.setLevel(0);
                        } else {
                            newJarStream.setLevel(JAR_COMPRESS_LEVEL);
                        }

                        // Update with changed Bean class
                        if (replaceEntries.containsKey(je.getName())) {
                            log("Updating Bean class from generic Jar " + je.getName(),
                                Project.MSG_VERBOSE);
                            // Use the entry from the generic jar
                            je = (JarEntry) replaceEntries.get(je.getName());
                            is = genericJar.getInputStream(je);
                        } else {
                            //use fle from original websphere jar

                            is = wasJar.getInputStream(je);
                        }
                        newJarStream.putNextEntry(new JarEntry(je.getName()));

                        while ((bytesRead = is.read(buffer)) != -1) {
                            newJarStream.write(buffer, 0, bytesRead);
                        }
                        is.close();
                    }
                } else {
                    log("websphere Jar rebuild needed due to changed "
                        + "interface or XML", Project.MSG_VERBOSE);
                }
            } else {
                rebuild = true;
            }
        } catch (ClassNotFoundException cnfe) {
            String cnfmsg = "ClassNotFoundException while processing ejb-jar file"
                 + ". Details: "
                 + cnfe.getMessage();

            throw new BuildException(cnfmsg, cnfe);
        } catch (IOException ioe) {
            String msg = "IOException while processing ejb-jar file "
                 + ". Details: "
                 + ioe.getMessage();

            throw new BuildException(msg, ioe);
        } finally {
            // need to close files and perhaps rename output
            if (genericJar != null) {
                try {
                    genericJar.close();
                } catch (IOException closeException) {
                    // Ignore
                }
            }

            if (wasJar != null) {
                try {
                    wasJar.close();
                } catch (IOException closeException) {
                    // Ignore
                }
            }

            if (newJarStream != null) {
                try {
                    newJarStream.close();
                } catch (IOException closeException) {
                    // Ignore
                }

                try {
                    FILE_UTILS.rename(newwasJarFile, websphereJarFile);
                } catch (IOException renameException) {
                    log(renameException.getMessage(), Project.MSG_WARN);
                    rebuild = true;
                }
            }
        }

        return rebuild;
public voidsetCodegen(boolean codegen)
Flag, default false, to only generate the deployment code, do not run RMIC or Javac

param
codegen option

        this.codegen = codegen;
public voidsetDbname(java.lang.String dbName)
Sets the name of the Database to create; optional.

param
dbName name of the database

        this.dbName = dbName;
public voidsetDbschema(java.lang.String dbSchema)
Sets the name of the schema to create; optional.

param
dbSchema name of the schema

        this.dbSchema = dbSchema;
public voidsetDbvendor(java.lang.String dbvendor)
Sets the DB Vendor for the Entity Bean mapping ; optional.

Valid options can be obtained by running the following command: <WAS_HOME>/bin/EJBDeploy.[sh/bat] -help

This is also used to determine the name of the Map.mapxmi and Schema.dbxmi files, for example Account-DB2UDB_V81-Map.mapxmi and Account-DB2UDB_V81-Schema.dbxmi.

param
dbvendor database vendor type

        this.dbVendor = dbvendor;
public voidsetEJBdtd(java.lang.String inString)
Setter used to store the location of the Sun's Generic EJB DTD. This can be a file on the system or a resource on the classpath.

param
inString the string to use as the DTD location.

        this.ejb11DTD = inString;
public voidsetEjbdeploy(boolean ejbdeploy)
Decide, wether ejbdeploy should be called or not; optional, default true.

param
ejbdeploy a boolean value.

        this.ejbdeploy = ejbdeploy;
public voidsetKeepgeneric(boolean inValue)
This controls whether the generic file used as input to ejbdeploy is retained; optional, default false.

param
inValue either 'true' or 'false'.

        this.keepGeneric = inValue;
public voidsetNewCMP(boolean newCMP)
Set the value of the newCMP scheme. The old CMP scheme locates the websphere CMP descriptor based on the naming convention where the websphere CMP file is expected to be named with the bean name as the prefix. Under this scheme the name of the CMP descriptor does not match the name actually used in the main websphere EJB descriptor. Also, descriptors which contain multiple CMP references could not be used.

param
newCMP a boolean value.

        this.newCMP = newCMP;
public voidsetNoinform(boolean noinform)
Flag to disable informational messages; optional, default false.

param
noinform if true disables informational messages

        this.noinform = noinform;
public voidsetNovalidate(boolean novalidate)
Flag to disable the validation steps; optional, default false.

param
novalidate option

        this.novalidate = novalidate;
public voidsetNowarn(boolean nowarn)
Flag to disable warning and informational messages; optional, default false.

param
nowarn option

        this.nowarn = nowarn;
public voidsetOldCMP(boolean oldCMP)
Set the value of the oldCMP scheme. This is an antonym for newCMP

ant.attribute
ignore="true"
param
oldCMP a boolean value.

        this.newCMP = !oldCMP;
public voidsetQuiet(boolean quiet)
Flag, default true, to only output error messages.

param
quiet option

        this.quiet = quiet;
public voidsetRebuild(boolean rebuild)
Set the rebuild flag to false to only update changes in the jar rather than rerunning ejbdeploy; optional, default true.

param
rebuild a boolean value.

        this.alwaysRebuild = rebuild;
public voidsetRmicoptions(java.lang.String options)
Set the rmic options.

param
options the options to use.

        this.rmicOptions = options;
public voidsetSuffix(java.lang.String inString)
String value appended to the basename of the deployment descriptor to create the filename of the WebLogic EJB jar file. Optional, default '.jar'.

param
inString the string to use as the suffix.

        this.jarSuffix = inString;
public voidsetTempdir(java.lang.String tempdir)
The directory, where ejbdeploy will write temporary files; optional, defaults to '_ejbdeploy_temp'.

param
tempdir the directory name to use.

        this.tempdir = tempdir;
public voidsetTrace(boolean trace)
Flag to enable internal tracing when set, optional, default false.

param
trace a boolean vaule.

        this.trace = trace;
public voidsetUse35(boolean attr)
Flag to use the WebSphere 3.5 compatible mapping rules ; optional, default false.

param
attr a boolean value.

        use35MappingRules = attr;
public voidsetWASClasspath(org.apache.tools.ant.types.Path wasClasspath)
Set the websphere classpath.

param
wasClasspath the websphere classpath.

        this.wasClasspath = wasClasspath;
public voidvalidateConfigured()
Called to validate that the tool parameters have been configured.

throws
BuildException if there is an error.

        super.validateConfigured();
        if (ejbdeploy) {
            String home = getTask().getProject().getProperty("websphere.home");
            if (home == null) {
                throw new BuildException("The 'websphere.home' property must "
                    + "be set when 'ejbdeploy=true'");
            }
            websphereHome = getTask().getProject().resolveFile(home);
        }
protected voidwriteJar(java.lang.String baseName, java.io.File jarFile, java.util.Hashtable files, java.lang.String publicId)
{@inheritDoc}.

        if (ejbdeploy) {
            // create the -generic.jar, if required
            File genericJarFile = super.getVendorOutputJarFile(baseName);

            super.writeJar(baseName, genericJarFile, files, publicId);

            // create the output .jar, if required
            if (alwaysRebuild || isRebuildRequired(genericJarFile, jarFile)) {
                buildWebsphereJar(genericJarFile, jarFile);
            }
            if (!keepGeneric) {
                log("deleting generic jar " + genericJarFile.toString(),
                    Project.MSG_VERBOSE);
                genericJarFile.delete();
            }
        } else {
            // create the "undeployed" output .jar, if required
            super.writeJar(baseName, jarFile, files, publicId);
        }