WsGenTask.java

package org.objectweb.jonas.ant;

import java.io.File;

import org.apache.tools.ant.AntClassLoader;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.DirectoryScanner;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.taskdefs.Java;
import org.apache.tools.ant.taskdefs.MatchingTask;
import org.apache.tools.ant.types.Path;

public class WsGenTask extends MatchingTask {

    private static final String BOOTSTRAP_CLASS = "org.objectweb.jonas.server.Bootstrap";

    private static final String WSGEN_CLASS = "org.objectweb.jonas_ws.wsgen.WsGen";

    private File destination   = null;

    private File source        = null;

    private boolean validation = true;

    private String javac       = null;

    private String javac_opts  = null;

    private boolean keep_gen   = false;

    private boolean no_config  = false;

    private boolean verbose    = false;

    private boolean debug      = false;

    private File jonas_root    = null;

    private File jonas_base    = null;

    public void setDestdir(File d) {
        destination = d;
    }

    public void setSrcdir(File s) {
        source = s;
    }

    public void setValidation(boolean v) {
        validation = v;
    }

    public void setJavac(String j) {
        javac = j;
    }

    public void setJavacopts(String opts) {
        javac_opts = opts;
    }

    public void setKeepgen(boolean k) {
        keep_gen = k;
    }

    public void setNoconfig(boolean c) {
        no_config = c;
    }

    public void setVerbose(boolean v) {
        verbose = v;
    }

    public void setDebug(boolean b) {
        debug = b;
    }

    public void setJonasroot(File jr) {
        jonas_root = jr;
    }

    public void setJonasbase(File jb) {
        jonas_base = jb;
    }

    public void execute() throws BuildException {

        // init the wsgen task
        initWsGenTask();

        // execute
        DirectoryScanner ds = getDirectoryScanner(source);
        ds.scan();
        String[] files = ds.getIncludedFiles();

        for (int i = 0; i < files.length; i++) {
            
            Java wsgen = createWsGen(source + File.separator + files[i]);
            
            // calling WsGen task
            log("Calling  WsGen task for '" + source + File.separator + files[i] + "'.", Project.MSG_VERBOSE);
            
            if (wsgen.executeJava() != 0) {
                throw new BuildException("WsGen reported an error.");
            }
        }

    }

    private Java createWsGen(String filename) throws BuildException {

        Java wsgenTask = null;  // WsGen task 
        boolean error = false;  // true if an error occurs during the GenIC call

        wsgenTask = (Java) getProject().createTask("java");
        wsgenTask.setTaskName("wsgen");
        wsgenTask.setFork(true);

        // jonas root
        wsgenTask.createJvmarg().setValue("-Dinstall.root=" + jonas_root);

        // jonas base
        wsgenTask.createJvmarg().setValue("-Djonas.base=" + jonas_base);

        // Endorsed directory
        File endorsedDir = new File(new File(jonas_root, "lib"), "endorsed");
        wsgenTask.createJvmarg().setValue("-Djava.endorsed.dirs=" + endorsedDir);

        // java policy file
        String jonasConfigDir = jonas_root + File.separator + "conf";
        File javaPolicyFile = new File(jonasConfigDir, "java.policy");
        if (javaPolicyFile.exists()) {
            wsgenTask.createJvmarg().setValue("-Djava.security.policy="
                                              + javaPolicyFile.toString());
        }

        // The bootstrap class must launch the GenIC class
        wsgenTask.createArg().setValue(WSGEN_CLASS);

        wsgenTask.createArg().setValue("-d");
        wsgenTask.createArg().setFile(destination);

        // add ow_jonas_bootstrap.jar
        String bootJar = jonas_root + File.separator + "lib" + File.separator + "common"
            + File.separator + "ow_jonas_bootstrap.jar";
        Path classpath = new Path(getProject(), bootJar);
      
        log("Using classpath: " + classpath.toString(), Project.MSG_VERBOSE);
        wsgenTask.setClasspath(classpath);

        if (!checkBootstrapClassName(classpath)) {
            log("Cannot find bootstrap class in classpath.", Project.MSG_ERR);
            throw new BuildException("Bootstrap class not found, please check the classpath.");
        } else {
            wsgenTask.setClassname(BOOTSTRAP_CLASS);
        }

        // keepgenerated
        if (keep_gen) {
            wsgenTask.createArg().setValue("-keepgenerated");
        }

        // noconfig
        if (no_config) {
            wsgenTask.createArg().setValue("-noconfig");
        }

        // novalidation
        if (!validation) {
            wsgenTask.createArg().setValue("-novalidation");
        }

        // javac
        if (javac != null) {
            wsgenTask.createArg().setValue("-javac");
            wsgenTask.createArg().setLine(javac);
        }

        // javacopts
        if (javac_opts != null && !javac_opts.equals("")) {
            wsgenTask.createArg().setValue("-javacopts");
            wsgenTask.createArg().setLine(javac_opts);
        }

        // verbose
        if (verbose) {
            wsgenTask.createArg().setValue("-verbose");
        }

        // debug
        if (debug) {
            wsgenTask.createArg().setValue("-debug");
        }

        // input file to process by GenIC
        wsgenTask.createArg().setValue(filename);

        return wsgenTask;
        
    }

    private void initWsGenTask() throws BuildException {
        // try to define jonas_root if not set
        if (jonas_root == null ) {
            // get ant property
            String jr = getProject().getProperty("jonas.root");
            jonas_root = new File(jr);
            
            if (jr == null) {
                throw new BuildException("attribute jonasroot is necessary.");
            }
        }

        // use jonas_root as jonas_base if not set
        if (jonas_base == null) {
            String jb = getProject().getProperty("jonas.base");
            if (jb == null) {
                jonas_base = jonas_root;
            } else {
                jonas_base = new File(jb);
            }
            
        }

        // default destination : project directory
        if (destination == null) {
            destination = getProject().getBaseDir();
        }

        // javac javac_opts
        // by default WsGen already handle them

    }
    private boolean checkBootstrapClassName(Path classpath) {
        log("Looking for bootstrap class in classpath: " + classpath.toString(), Project.MSG_VERBOSE);
        AntClassLoader cl = new AntClassLoader(classpath.getProject(), classpath);
        try {
            cl.loadClass(BOOTSTRAP_CLASS);
            log("Found Bootstrap class '" + BOOTSTRAP_CLASS
                + "' in classpath.", Project.MSG_VERBOSE);
        } catch (ClassNotFoundException cnf1) {
            log("Bootstrap class '" + BOOTSTRAP_CLASS
                + "' not found in classpath.", Project.MSG_VERBOSE);
            return false;
        }
        return true;
    }

}

---