JDefinitionWriter.java

package org.objectweb.jonas.ws;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.nio.charset.Charset;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.wsdl.Definition;
import javax.wsdl.Import;
import javax.wsdl.Types;
import javax.wsdl.WSDLException;
import javax.wsdl.extensions.UnknownExtensibilityElement;
import javax.wsdl.factory.WSDLFactory;
import javax.wsdl.xml.WSDLWriter;

import org.w3c.dom.Document;

import org.objectweb.jonas_lib.xml.XMLSerializer;

import org.objectweb.jonas.common.Log;

import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.Logger;

public class JDefinitionWriter {

    private File base;

    private Charset cs;

    private Definition definition;

    private String filename;

    private static Logger logger = Log.getLogger(Log.JONAS_WS_PREFIX);

    public JDefinitionWriter(Definition def, File context, Charset cs, String filename) {
        if (!context.exists()) {
            throw new IllegalArgumentException("Context MUST exists : " + context);
        }
        this.definition = def;
        if (context.isDirectory()) {
            this.base = context;
        } else {
            this.base = context.getParentFile();
        }
        this.cs = cs;
        this.filename = filename;
    }

    public void write() throws IOException, WSDLException {
        writeDefinition(definition, base, filename);
        Map imports = definition.getImports();
        for (Iterator ns = imports.keySet().iterator(); ns.hasNext();) {
            // for each nsURI, we have a List of Import
            String uri = (String) ns.next();
            List importeds = (List) imports.get(uri);
            // for each import related to the given ns
            for (Iterator imp = importeds.iterator(); imp.hasNext();) {
                Import imported = (Import) imp.next();

                // create a resolved URL to know if the import is relative or
                // not to the base
                String locURI = imported.getLocationURI();
                if (!locURI.startsWith("http://")) {
                    // locResolvedURL starts with the base URI, so it's a
                    // relative import
                    // and we should wrote it.
                    Definition impDef = imported.getDefinition();
                    if (locURI.toLowerCase().endsWith("wsdl")) {
                        // if we have another WSDL
                        JDefinitionWriter jdw = new JDefinitionWriter(impDef, new File(base, filename).getCanonicalFile(), cs, locURI);
                        jdw.write();
                    } else {
                        // Assume this is a types import
                        Types types = impDef.getTypes();
                        if (types != null) {
                            List extList = types.getExtensibilityElements();
                            if (!extList.isEmpty()) {
                                UnknownExtensibilityElement e = (UnknownExtensibilityElement) extList.get(0);
                                Document doc = e.getElement().getOwnerDocument();
                                File dir = new File(base, filename).getCanonicalFile().getParentFile();
                                writeDocument(doc, dir, locURI);
                            }
                        }
                    }
                }
            }
        }
    }

    private void writeDocument(Document doc, File base, String locURI) throws IOException {
        XMLSerializer ser = new XMLSerializer(doc);
        File file = new File(base, locURI).getCanonicalFile();
        logger.log(BasicLevel.DEBUG, "Writing XML Document in " + file);
        createParentIfNeeded(file);
        Writer writer = new OutputStreamWriter(new FileOutputStream(file), cs);
        ser.serialize(writer);
        writer.close();
    }

    private void writeDefinition(Definition def, File base, String filename) throws WSDLException, IOException {
        WSDLFactory factory = WSDLFactory.newInstance();
        WSDLWriter writer = factory.newWSDLWriter();
        File wsdl = new File(base, filename).getCanonicalFile();
        logger.log(BasicLevel.DEBUG, "Writing WSDL Definition in " + wsdl);
        createParentIfNeeded(wsdl);
        Writer w = new OutputStreamWriter(new FileOutputStream(wsdl), cs);
        writer.writeWSDL(def, w);
        w.close();
    }

    private void createParentIfNeeded(File file) throws IOException {
        File parent = file.getParentFile();
        if (!parent.exists()) {
            if (!parent.mkdirs()) {
                // cannot create directory
                throw new IOException("Cannot create directory " + parent.getCanonicalPath());
            }
        } else if (!parent.isDirectory()) {
            // parent exists but is not a directory
            throw new IOException("Parent " + parent.getCanonicalPath() + " already exists but is not a directory.");
        }
    }
}

---