diff options
Diffstat (limited to 'framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/taskdefs/optional/ejb/BorlandDeploymentTool.java')
| -rw-r--r-- | framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/taskdefs/optional/ejb/BorlandDeploymentTool.java | 559 |
1 files changed, 559 insertions, 0 deletions
diff --git a/framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/taskdefs/optional/ejb/BorlandDeploymentTool.java b/framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/taskdefs/optional/ejb/BorlandDeploymentTool.java new file mode 100644 index 00000000..4eefaebf --- /dev/null +++ b/framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/taskdefs/optional/ejb/BorlandDeploymentTool.java @@ -0,0 +1,559 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + + +package org.apache.tools.ant.taskdefs.optional.ejb; + + +import java.io.BufferedReader; +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.OutputStream; +import java.util.Hashtable; +import java.util.Iterator; +import java.util.Vector; + +import org.apache.tools.ant.BuildException; +import org.apache.tools.ant.Project; +import org.apache.tools.ant.taskdefs.ExecTask; +import org.apache.tools.ant.taskdefs.Execute; +import org.apache.tools.ant.taskdefs.ExecuteStreamHandler; +import org.apache.tools.ant.taskdefs.Java; +import org.apache.tools.ant.types.Commandline; +import org.apache.tools.ant.types.Path; + + +/** + * BorlandDeploymentTool is dedicated to the Borland Application Server 4.5 and 4.5.1 + * This task generates and compiles the stubs and skeletons for all ejb described into the + * Deployment Descriptor, builds the jar file including the support files and verify + * whether the produced jar is valid or not. + * The supported options are: + * <ul> + * <li>debug (boolean) : turn on the debug mode for generation of + * stubs and skeletons (default:false)</li> + * <li>verify (boolean) : turn on the verification at the end of the jar + * production (default:true) </li> + * <li>verifyargs (String) : add optional argument to verify command + * (see vbj com.inprise.ejb.util.Verify)</li> + * <li>basdtd (String) : location of the BAS DTD </li> + * <li>generateclient (boolean) : turn on the client jar file generation </li> + * <li>version (int) : tell what is the Borland appserver version 4 or 5 </li> + * </ul> + * + *<PRE> + * + * <ejbjar srcdir="${build.classes}" + * basejarname="vsmp" + * descriptordir="${rsc.dir}/hrmanager"> + * <borland destdir="tstlib"> + * <classpath refid="classpath" /> + * </borland> + * <include name="**\ejb-jar.xml"/> + * <support dir="${build.classes}"> + * <include name="demo\smp\*.class"/> + * <include name="demo\helper\*.class"/> + * </support> + * </ejbjar> + *</PRE> + * + */ +public class BorlandDeploymentTool extends GenericDeploymentTool + implements ExecuteStreamHandler { + /** Borland 1.1 ejb id */ + public static final String PUBLICID_BORLAND_EJB + = "-//Inprise Corporation//DTD Enterprise JavaBeans 1.1//EN"; + + protected static final String DEFAULT_BAS45_EJB11_DTD_LOCATION + = "/com/inprise/j2ee/xml/dtds/ejb-jar.dtd"; + + protected static final String DEFAULT_BAS_DTD_LOCATION + = "/com/inprise/j2ee/xml/dtds/ejb-inprise.dtd"; + + protected static final String BAS_DD = "ejb-inprise.xml"; + protected static final String BES_DD = "ejb-borland.xml"; + + + /** Java2iiop executable **/ + protected static final String JAVA2IIOP = "java2iiop"; + + /** Verify class */ + protected static final String VERIFY = "com.inprise.ejb.util.Verify"; + + /** Instance variable that stores the suffix for the borland jarfile. */ + private String jarSuffix = "-ejb.jar"; + + /** Instance variable that stores the location of the borland DTD file. */ + private String borlandDTD; + + /** Instance variable that determines whether the debug mode is on */ + private boolean java2iiopdebug = false; + + /** store additional param for java2iiop command used to build EJB Stubs */ + private String java2iioparams = null; + + /** Instance variable that determines whether the client jar file is generated */ + private boolean generateclient = false; + + /** Borland Enterprise Server = version 5 */ + static final int BES = 5; + /** Borland Application Server or Inprise Application Server = version 4 */ + static final int BAS = 4; + + /** borland appserver version 4 or 5 */ + private int version = BAS; + + + /** + * Instance variable that determines whether it is necessary to verify the + * produced jar + */ + private boolean verify = true; + private String verifyArgs = ""; + + private Hashtable genfiles = new Hashtable(); + + /** + * set the debug mode for java2iiop (default false) + * @param debug the setting to use. + **/ + public void setDebug(boolean debug) { + this.java2iiopdebug = debug; + } + + /** + * set the verify mode for the produced jar (default true) + * @param verify the setting to use. + **/ + public void setVerify(boolean verify) { + this.verify = verify; + } + + + /** + * Setter used to store the suffix for the generated borland jar file. + * @param inString the string to use as the suffix. + */ + public void setSuffix(String inString) { + this.jarSuffix = inString; + } + + + /** + * sets some additional args to send to verify command + * @param args additional command line parameters + */ + public void setVerifyArgs(String args) { + this.verifyArgs = args; + } + + /** + * Setter used to store the location of the borland 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. + */ + public void setBASdtd(String inString) { + this.borlandDTD = inString; + } + + + /** + * setter used to store whether the task will include the generate client task. + * (see : BorlandGenerateClient task) + * @param b if true generate the client task. + */ + public void setGenerateclient(boolean b) { + this.generateclient = b; + } + + /** + * setter used to store the borland appserver version [4 or 5] + * @param version app server version 4 or 5 + */ + public void setVersion(int version) { + this.version = version; + } + + /** + * If filled, the params are added to the java2iiop command. + * (ex: -no_warn_missing_define) + * @param params additional params for java2iiop + */ + public void setJava2iiopParams(String params) { + this.java2iioparams = params; + } + + + /** + * Get the borland descriptor handler. + * @param srcDir the source directory. + * @return the descriptor. + */ + protected DescriptorHandler getBorlandDescriptorHandler(final File srcDir) { + DescriptorHandler handler = + new DescriptorHandler(getTask(), srcDir) { + protected void processElement() { + if (currentElement.equals("type-storage")) { + // Get the filename of vendor specific descriptor + String fileNameWithMETA = currentText; + //trim the META_INF\ off of the file name + String fileName + = fileNameWithMETA.substring(META_DIR.length(), + fileNameWithMETA.length()); + File descriptorFile = new File(srcDir, fileName); + + ejbFiles.put(fileNameWithMETA, descriptorFile); + } + } + }; + handler.registerDTD(PUBLICID_BORLAND_EJB, + borlandDTD == null ? DEFAULT_BAS_DTD_LOCATION : borlandDTD); + + for (Iterator i = getConfig().dtdLocations.iterator(); i.hasNext();) { + EjbJar.DTDLocation dtdLocation = (EjbJar.DTDLocation) i.next(); + handler.registerDTD(dtdLocation.getPublicId(), dtdLocation.getLocation()); + } + return handler; + } + + /** + * Add any vendor specific files which should be included in the + * EJB Jar. + * @param ejbFiles the map to add the files to. + * @param ddPrefix the prefix to use. + */ + protected void addVendorFiles(Hashtable ejbFiles, String ddPrefix) { + + //choose the right vendor DD + if (!(version == BES || version == BAS)) { + throw new BuildException("version " + version + " is not supported"); + } + + String dd = (version == BES ? BES_DD : BAS_DD); + + log("vendor file : " + ddPrefix + dd, Project.MSG_DEBUG); + + File borlandDD = new File(getConfig().descriptorDir, ddPrefix + dd); + if (borlandDD.exists()) { + log("Borland specific file found " + borlandDD, Project.MSG_VERBOSE); + ejbFiles.put(META_DIR + dd , borlandDD); + } else { + log("Unable to locate borland deployment descriptor. " + + "It was expected to be in " + + borlandDD.getPath(), Project.MSG_WARN); + return; + } + } + + /** + * 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. + */ + File getVendorOutputJarFile(String baseName) { + return new File(getDestDir(), baseName + jarSuffix); + } + + /** + * Verify the produced jar file by invoking the Borland verify tool + * @param sourceJar java.io.File representing the produced jar file + */ + private void verifyBorlandJar(File sourceJar) { + if (version == BAS) { + verifyBorlandJarV4(sourceJar); + return; + } + if (version == BES) { + verifyBorlandJarV5(sourceJar); + return; + } + log("verify jar skipped because the version is invalid [" + + version + "]", Project.MSG_WARN); + } + + /** + * Verify the produced jar file by invoking the Borland iastool tool + * @param sourceJar java.io.File representing the produced jar file + */ + private void verifyBorlandJarV5(File sourceJar) { + log("verify BES " + sourceJar, Project.MSG_INFO); + try { + ExecTask execTask = null; + execTask = new ExecTask(getTask()); + execTask.setDir(new File(".")); + execTask.setExecutable("iastool"); + //classpath + if (getCombinedClasspath() != null) { + execTask.createArg().setValue("-VBJclasspath"); + execTask.createArg().setValue(getCombinedClasspath().toString()); + } + + if (java2iiopdebug) { + execTask.createArg().setValue("-debug"); + } + execTask.createArg().setValue("-verify"); + execTask.createArg().setValue("-src"); + // ejb jar file to verify + execTask.createArg().setValue(sourceJar.getPath()); + log("Calling iastool", Project.MSG_VERBOSE); + execTask.execute(); + } catch (Exception e) { + // Have to catch this because of the semantics of calling main() + String msg = "Exception while calling generateclient Details: " + + e.toString(); + throw new BuildException(msg, e); + } + } + + /** + * Verify the produced jar file by invoking the Borland verify tool + * @param sourceJar java.io.File representing the produced jar file + */ + private void verifyBorlandJarV4(File sourceJar) { + org.apache.tools.ant.taskdefs.Java javaTask = null; + log("verify BAS " + sourceJar, Project.MSG_INFO); + try { + String args = verifyArgs; + args += " " + sourceJar.getPath(); + + javaTask = new Java(getTask()); + javaTask.setTaskName("verify"); + javaTask.setClassname(VERIFY); + Commandline.Argument arguments = javaTask.createArg(); + arguments.setLine(args); + Path classpath = getCombinedClasspath(); + if (classpath != null) { + javaTask.setClasspath(classpath); + javaTask.setFork(true); + } + + log("Calling " + VERIFY + " for " + sourceJar.toString(), + Project.MSG_VERBOSE); + javaTask.execute(); + } catch (Exception e) { + //TO DO : delete the file if it is not a valid file. + String msg = "Exception while calling " + VERIFY + " Details: " + + e.toString(); + throw new BuildException(msg, e); + } + } + + + /** + * Generate the client jar corresponding to the jar file passed as parameter + * the method uses the BorlandGenerateClient task. + * @param sourceJar java.io.File representing the produced jar file + */ + private void generateClient(File sourceJar) { + getTask().getProject().addTaskDefinition("internal_bas_generateclient", + org.apache.tools.ant.taskdefs.optional.ejb.BorlandGenerateClient.class); + + org.apache.tools.ant.taskdefs.optional.ejb.BorlandGenerateClient gentask = null; + log("generate client for " + sourceJar, Project.MSG_INFO); + try { + Project project = getTask().getProject(); + gentask + = (BorlandGenerateClient) project.createTask("internal_bas_generateclient"); + gentask.setEjbjar(sourceJar); + gentask.setDebug(java2iiopdebug); + Path classpath = getCombinedClasspath(); + if (classpath != null) { + gentask.setClasspath(classpath); + } + gentask.setVersion(version); + gentask.setTaskName("generate client"); + gentask.execute(); + } catch (Exception e) { + //TO DO : delete the file if it is not a valid file. + String msg = "Exception while calling " + VERIFY + " Details: " + + e.toString(); + throw new BuildException(msg, e); + } + } + + /** + * Generate stubs & skeleton for each home found into the DD + * Add all the generate class file into the ejb files + * @param ithomes : iterator on home class + */ + private void buildBorlandStubs(Iterator ithomes) { + Execute execTask = null; + + execTask = new Execute(this); + Project project = getTask().getProject(); + execTask.setAntRun(project); + execTask.setWorkingDirectory(project.getBaseDir()); + + Commandline commandline = new Commandline(); + commandline.setExecutable(JAVA2IIOP); + //debug ? + if (java2iiopdebug) { + commandline.createArgument().setValue("-VBJdebug"); + } + //set the classpath + commandline.createArgument().setValue("-VBJclasspath"); + commandline.createArgument().setPath(getCombinedClasspath()); + //list file + commandline.createArgument().setValue("-list_files"); + //no TIE classes + commandline.createArgument().setValue("-no_tie"); + + if (java2iioparams != null) { + log("additional " + java2iioparams + " to java2iiop ", 0); + commandline.createArgument().setLine(java2iioparams); + } + + + //root dir + commandline.createArgument().setValue("-root_dir"); + commandline.createArgument().setValue(getConfig().srcDir.getAbsolutePath()); + //compiling order + commandline.createArgument().setValue("-compile"); + //add the home class + while (ithomes.hasNext()) { + commandline.createArgument().setValue(ithomes.next().toString()); + } + + try { + log("Calling java2iiop", Project.MSG_VERBOSE); + log(commandline.describeCommand(), Project.MSG_DEBUG); + execTask.setCommandline(commandline.getCommandline()); + int result = execTask.execute(); + if (Execute.isFailure(result)) { + String msg = "Failed executing java2iiop (ret code is " + + result + ")"; + throw new BuildException(msg, getTask().getLocation()); + } + } catch (java.io.IOException e) { + log("java2iiop exception :" + e.getMessage(), Project.MSG_ERR); + throw new BuildException(e, getTask().getLocation()); + } + } + + /** + * Method used to encapsulate the writing of the JAR file. Iterates over the + * filenames/java.io.Files in the Hashtable stored on the instance variable + * ejbFiles. + * @param baseName the base name. + * @param jarFile the jar file to write to. + * @param files the files to write to the jar. + * @param publicId the id to use. + * @throws BuildException if there is an error. + */ + protected void writeJar(String baseName, File jarFile, Hashtable files, String publicId) + throws BuildException { + //build the home classes list. + Vector homes = new Vector(); + Iterator it = files.keySet().iterator(); + while (it.hasNext()) { + String clazz = (String) it.next(); + if (clazz.endsWith("Home.class")) { + //remove .class extension + String home = toClass(clazz); + homes.add(home); + log(" Home " + home, Project.MSG_VERBOSE); + } + } + + buildBorlandStubs(homes.iterator()); + + //add the gen files to the collection + files.putAll(genfiles); + + super.writeJar(baseName, jarFile, files, publicId); + + if (verify) { + verifyBorlandJar(jarFile); + } + + if (generateclient) { + generateClient(jarFile); + } + genfiles.clear(); + } + + /** + * convert a class file name : A/B/C/toto.class + * into a class name: A.B.C.toto + */ + private String toClass(String filename) { + //remove the .class + String classname = filename.substring(0, filename.lastIndexOf(".class")); + classname = classname.replace('\\', '.'); + return classname; + } + + /** + * convert a file name : A/B/C/toto.java + * into a class name: A/B/C/toto.class + */ + private String toClassFile(String filename) { + //remove the .class + String classfile = filename.substring(0, filename.lastIndexOf(".java")); + classfile = classfile + ".class"; + return classfile; + } + + // implementation of org.apache.tools.ant.taskdefs.ExecuteStreamHandler interface + + /** {@inheritDoc}. */ + public void start() throws IOException { } + /** {@inheritDoc}. */ + public void stop() { } + /** {@inheritDoc}. */ + public void setProcessInputStream(OutputStream param1) throws IOException { } + + /** + * Set the output stream of the process. + * @param is the input stream. + * @throws IOException if there is an error. + */ + public void setProcessOutputStream(InputStream is) throws IOException { + try { + BufferedReader reader = new BufferedReader(new InputStreamReader(is)); + String javafile; + while ((javafile = reader.readLine()) != null) { + if (javafile.endsWith(".java")) { + String classfile = toClassFile(javafile); + String key = classfile.substring( + getConfig().srcDir.getAbsolutePath().length() + 1); + genfiles.put(key, new File(classfile)); + } + } + reader.close(); + } catch (Exception e) { + String msg = "Exception while parsing java2iiop output. Details: " + e.toString(); + throw new BuildException(msg, e); + } + } + + /** + * Set the error stream of the process. + * @param is the input stream. + * @throws IOException if there is an error. + */ + public void setProcessErrorStream(InputStream is) throws IOException { + BufferedReader reader = new BufferedReader(new InputStreamReader(is)); + String s = reader.readLine(); + if (s != null) { + log("[java2iiop] " + s, Project.MSG_ERR); + } + } +} + |