1 /*
   2  * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package com.sun.tools.internal.ws.wscompile;
  27 
  28 import com.oracle.webservices.internal.api.databinding.WSDLResolver;
  29 import com.sun.istack.internal.tools.ParallelWorldClassLoader;
  30 import com.sun.tools.internal.ws.ToolVersion;
  31 import com.sun.tools.internal.ws.processor.modeler.annotation.WebServiceAp;
  32 import com.sun.tools.internal.ws.processor.modeler.wsdl.ConsoleErrorReporter;
  33 import com.sun.tools.internal.ws.resources.WscompileMessages;
  34 import com.sun.tools.internal.xjc.util.NullStream;
  35 import com.sun.xml.internal.txw2.TXW;
  36 import com.sun.xml.internal.txw2.TypedXmlWriter;
  37 import com.sun.xml.internal.txw2.annotation.XmlAttribute;
  38 import com.sun.xml.internal.txw2.annotation.XmlElement;
  39 import com.sun.xml.internal.txw2.output.StreamSerializer;
  40 import com.sun.xml.internal.ws.api.BindingID;
  41 import com.sun.xml.internal.ws.api.databinding.DatabindingConfig;
  42 import com.sun.xml.internal.ws.api.databinding.DatabindingFactory;
  43 import com.sun.xml.internal.ws.api.databinding.WSDLGenInfo;
  44 import com.sun.xml.internal.ws.api.server.Container;
  45 import com.sun.xml.internal.ws.api.wsdl.writer.WSDLGeneratorExtension;
  46 import com.sun.xml.internal.ws.binding.WebServiceFeatureList;
  47 import com.sun.xml.internal.ws.model.ExternalMetadataReader;
  48 import com.sun.xml.internal.ws.model.AbstractSEIModelImpl;
  49 import com.sun.xml.internal.ws.util.ServiceFinder;
  50 import org.xml.sax.SAXParseException;
  51 
  52 import javax.tools.DiagnosticCollector;
  53 import javax.tools.JavaCompiler;
  54 import javax.tools.JavaFileObject;
  55 import javax.tools.StandardJavaFileManager;
  56 import javax.tools.ToolProvider;
  57 import javax.xml.bind.annotation.XmlSeeAlso;
  58 import javax.xml.namespace.QName;
  59 import javax.xml.transform.Result;
  60 import javax.xml.transform.stream.StreamResult;
  61 import javax.xml.ws.EndpointReference;
  62 import javax.xml.ws.Holder;
  63 import java.io.BufferedOutputStream;
  64 import java.io.File;
  65 import java.io.FileNotFoundException;
  66 import java.io.FileOutputStream;
  67 import java.io.IOException;
  68 import java.io.OutputStream;
  69 import java.io.PrintStream;
  70 import java.net.URLClassLoader;
  71 import java.util.ArrayList;
  72 import java.util.Collections;
  73 import java.util.HashMap;
  74 import java.util.List;
  75 import java.util.Map;
  76 
  77 /**
  78  * @author Vivek Pandey
  79  */
  80 
  81 /*
  82  * All annotation types are supported.
  83  */
  84 public class WsgenTool {
  85     private final PrintStream out;
  86     private final WsgenOptions options = new WsgenOptions();
  87 
  88 
  89     public WsgenTool(OutputStream out, Container container) {
  90         this.out = (out instanceof PrintStream) ? (PrintStream) out : new PrintStream(out);
  91         this.container = container;
  92     }
  93 
  94 
  95     public WsgenTool(OutputStream out) {
  96         this(out, null);
  97     }
  98 
  99     public boolean run(String[] args) {
 100         final Listener listener = new Listener();
 101         for (String arg : args) {
 102             if (arg.equals("-version")) {
 103                 listener.message(
 104                         WscompileMessages.WSGEN_VERSION(ToolVersion.VERSION.MAJOR_VERSION));
 105                 return true;
 106             }
 107             if (arg.equals("-fullversion")) {
 108                 listener.message(
 109                         WscompileMessages.WSGEN_FULLVERSION(ToolVersion.VERSION.toString()));
 110                 return true;
 111             }
 112         }
 113         try {
 114             options.parseArguments(args);
 115             options.validate();
 116             if (!buildModel(options.endpoint.getName(), listener)) {
 117                 return false;
 118             }
 119         } catch (Options.WeAreDone done) {
 120             usage(done.getOptions());
 121         } catch (BadCommandLineException e) {
 122             if (e.getMessage() != null) {
 123                 System.out.println(e.getMessage());
 124                 System.out.println();
 125             }
 126             usage(e.getOptions());
 127             return false;
 128         } catch (AbortException e) {
 129             //error might have been reported
 130         } finally {
 131             if (!options.keep) {
 132                 options.removeGeneratedFiles();
 133             }
 134         }
 135         return true;
 136     }
 137 
 138     private final Container container;
 139 
 140     /*
 141      * To take care of JDK6-JDK6u3, where 2.1 API classes are not there
 142      */
 143     private static boolean useBootClasspath(Class clazz) {
 144         try {
 145             ParallelWorldClassLoader.toJarUrl(clazz.getResource('/' + clazz.getName().replace('.', '/') + ".class"));
 146             return true;
 147         } catch (Exception e) {
 148             return false;
 149         }
 150     }
 151 
 152     /**
 153      *
 154      * @param endpoint
 155      * @param listener
 156      * @return
 157      * @throws BadCommandLineException
 158      */
 159     public boolean buildModel(String endpoint, Listener listener) throws BadCommandLineException {
 160         final ErrorReceiverFilter errReceiver = new ErrorReceiverFilter(listener);
 161 
 162         boolean bootCP = useBootClasspath(EndpointReference.class) || useBootClasspath(XmlSeeAlso.class);
 163         List<String> args = new ArrayList<String>(6 + (bootCP ? 1 : 0) + (options.nocompile ? 1 : 0)
 164                 + (options.encoding != null ? 2 : 0));
 165         args.add("-d");
 166         args.add(options.destDir.getAbsolutePath());
 167         args.add("-classpath");
 168         args.add(options.classpath);
 169         args.add("-s");
 170         args.add(options.sourceDir.getAbsolutePath());
 171         if (options.nocompile) {
 172             args.add("-proc:only");
 173         }
 174         if (options.encoding != null) {
 175             args.add("-encoding");
 176             args.add(options.encoding);
 177         }
 178         if (bootCP) {
 179             args.add(new StringBuilder()
 180                     .append("-Xbootclasspath/p:")
 181                     .append(JavaCompilerHelper.getJarFile(EndpointReference.class))
 182                     .append(File.pathSeparator)
 183                     .append(JavaCompilerHelper.getJarFile(XmlSeeAlso.class)).toString());
 184         }
 185         if (options.javacOptions != null) {
 186             args.addAll(options.getJavacOptions(args, listener));
 187         }
 188 
 189         JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
 190         if (compiler == null) {
 191             out.println(WscompileMessages.WSCOMPILE_CANT_GET_COMPILER(property("java.home"), property("java.version"), property("java.vendor")));
 192             return false;
 193         }
 194         DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<JavaFileObject>();
 195         StandardJavaFileManager fileManager = compiler.getStandardFileManager(diagnostics, null, null);
 196         JavaCompiler.CompilationTask task = compiler.getTask(
 197                 null,
 198                 fileManager,
 199                 diagnostics,
 200                 args,
 201                 Collections.singleton(endpoint.replaceAll("\\$", ".")),
 202                 null);
 203         task.setProcessors(Collections.singleton(new WebServiceAp(options, out)));
 204         boolean result = task.call();
 205 
 206         if (!result) {
 207             out.println(WscompileMessages.WSCOMPILE_ERROR(WscompileMessages.WSCOMPILE_COMPILATION_FAILED()));
 208             return false;
 209         }
 210         if (options.genWsdl) {
 211             DatabindingConfig config = new DatabindingConfig();
 212 
 213             List<String> externalMetadataFileNames = options.externalMetadataFiles;
 214             boolean disableXmlSecurity = options.disableXmlSecurity;
 215             if (externalMetadataFileNames != null && externalMetadataFileNames.size() > 0) {
 216                 config.setMetadataReader(new ExternalMetadataReader(getExternalFiles(externalMetadataFileNames), null, null, true, disableXmlSecurity));
 217             }
 218 
 219             String tmpPath = options.destDir.getAbsolutePath() + File.pathSeparator + options.classpath;
 220             ClassLoader classLoader = new URLClassLoader(Options.pathToURLs(tmpPath),
 221                     this.getClass().getClassLoader());
 222             Class<?> endpointClass;
 223             try {
 224                 endpointClass = classLoader.loadClass(endpoint);
 225             } catch (ClassNotFoundException e) {
 226                 throw new BadCommandLineException(WscompileMessages.WSGEN_CLASS_NOT_FOUND(endpoint));
 227             }
 228 
 229             BindingID bindingID = options.getBindingID(options.protocol);
 230             if (!options.protocolSet) {
 231                 bindingID = BindingID.parse(endpointClass);
 232             }
 233             WebServiceFeatureList wsfeatures = new WebServiceFeatureList(endpointClass);
 234 //            RuntimeModeler rtModeler = new RuntimeModeler(endpointClass, options.serviceName, bindingID, wsfeatures.toArray());
 235 //            rtModeler.setClassLoader(classLoader);
 236             if (options.portName != null)
 237                 config.getMappingInfo().setPortName(options.portName);//rtModeler.setPortName(options.portName);
 238 //            AbstractSEIModelImpl rtModel = rtModeler.buildRuntimeModel();
 239 
 240             DatabindingFactory fac = DatabindingFactory.newInstance();
 241             config.setEndpointClass(endpointClass);
 242             config.getMappingInfo().setServiceName(options.serviceName);
 243             config.setFeatures(wsfeatures.toArray());
 244             config.setClassLoader(classLoader);
 245             config.getMappingInfo().setBindingID(bindingID);
 246             com.sun.xml.internal.ws.db.DatabindingImpl rt = (com.sun.xml.internal.ws.db.DatabindingImpl) fac.createRuntime(config);
 247 
 248             final File[] wsdlFileName = new File[1]; // used to capture the generated WSDL file.
 249             final Map<String, File> schemaFiles = new HashMap<String, File>();
 250 
 251             WSDLGenInfo wsdlGenInfo = new WSDLGenInfo();
 252             wsdlGenInfo.setSecureXmlProcessingDisabled(disableXmlSecurity);
 253 
 254             wsdlGenInfo.setWsdlResolver(
 255                     new WSDLResolver() {
 256                         private File toFile(String suggestedFilename) {
 257                             return new File(options.nonclassDestDir, suggestedFilename);
 258                         }
 259 
 260                         private Result toResult(File file) {
 261                             Result result;
 262                             try {
 263                                 result = new StreamResult(new FileOutputStream(file));
 264                                 result.setSystemId(file.getPath().replace('\\', '/'));
 265                             } catch (FileNotFoundException e) {
 266                                 errReceiver.error(e);
 267                                 return null;
 268                             }
 269                             return result;
 270                         }
 271 
 272                         @Override
 273                         public Result getWSDL(String suggestedFilename) {
 274                             File f = toFile(suggestedFilename);
 275                             wsdlFileName[0] = f;
 276                             return toResult(f);
 277                         }
 278 
 279                         public Result getSchemaOutput(String namespace, String suggestedFilename) {
 280                             if (namespace == null)
 281                                 return null;
 282                             File f = toFile(suggestedFilename);
 283                             schemaFiles.put(namespace, f);
 284                             return toResult(f);
 285                         }
 286 
 287                         @Override
 288                         public Result getAbstractWSDL(Holder<String> filename) {
 289                             return toResult(toFile(filename.value));
 290                         }
 291 
 292                         @Override
 293                         public Result getSchemaOutput(String namespace, Holder<String> filename) {
 294                             return getSchemaOutput(namespace, filename.value);
 295                         }
 296                         // TODO pass correct impl's class name
 297                     });
 298 
 299             wsdlGenInfo.setContainer(container);
 300             wsdlGenInfo.setExtensions(ServiceFinder.find(WSDLGeneratorExtension.class).toArray());
 301             wsdlGenInfo.setInlineSchemas(options.inlineSchemas);
 302             rt.generateWSDL(wsdlGenInfo);
 303 
 304 
 305             if (options.wsgenReport != null)
 306                 generateWsgenReport(endpointClass, (AbstractSEIModelImpl) rt.getModel(), wsdlFileName[0], schemaFiles);
 307         }
 308         return true;
 309     }
 310 
 311     private String property(String key) {
 312         try {
 313             String property = System.getProperty(key);
 314             return property != null ? property : "UNKNOWN";
 315         } catch (SecurityException ignored) {
 316             return "UNKNOWN";
 317         }
 318     }
 319 
 320     private List<File> getExternalFiles(List<String> exts) {
 321         List<File> files = new ArrayList<File>();
 322         for (String ext : exts) {
 323             // first try absolute path ...
 324             File file = new File(ext);
 325             if (!file.exists()) {
 326                 // then relative path ...
 327                 file = new File(options.sourceDir.getAbsolutePath() + File.separator + ext);
 328             }
 329             files.add(file);
 330         }
 331         return files;
 332     }
 333 
 334     /**
 335      * Generates a small XML file that captures the key activity of wsgen,
 336      * so that test harness can pick up artifacts.
 337      */
 338     private void generateWsgenReport(Class<?> endpointClass, AbstractSEIModelImpl rtModel, File wsdlFile, Map<String, File> schemaFiles) {
 339         try {
 340             ReportOutput.Report report = TXW.create(ReportOutput.Report.class,
 341                     new StreamSerializer(new BufferedOutputStream(new FileOutputStream(options.wsgenReport))));
 342 
 343             report.wsdl(wsdlFile.getAbsolutePath());
 344             ReportOutput.writeQName(rtModel.getServiceQName(), report.service());
 345             ReportOutput.writeQName(rtModel.getPortName(), report.port());
 346             ReportOutput.writeQName(rtModel.getPortTypeName(), report.portType());
 347 
 348             report.implClass(endpointClass.getName());
 349 
 350             for (Map.Entry<String, File> e : schemaFiles.entrySet()) {
 351                 ReportOutput.Schema s = report.schema();
 352                 s.ns(e.getKey());
 353                 s.location(e.getValue().getAbsolutePath());
 354             }
 355 
 356             report.commit();
 357         } catch (IOException e) {
 358             // this is code for the test, so we can be lousy in the error handling
 359             throw new Error(e);
 360         }
 361     }
 362 
 363     /**
 364      * "Namespace" for code needed to generate the report file.
 365      */
 366     static class ReportOutput {
 367         @XmlElement("report")
 368         interface Report extends TypedXmlWriter {
 369             @XmlElement
 370             void wsdl(String file); // location of WSDL
 371 
 372             @XmlElement
 373             QualifiedName portType();
 374 
 375             @XmlElement
 376             QualifiedName service();
 377 
 378             @XmlElement
 379             QualifiedName port();
 380 
 381             /**
 382              * Name of the class that has {@link javax.jws.WebService}.
 383              */
 384             @XmlElement
 385             void implClass(String name);
 386 
 387             @XmlElement
 388             Schema schema();
 389         }
 390 
 391         interface QualifiedName extends TypedXmlWriter {
 392             @XmlAttribute
 393             void uri(String ns);
 394 
 395             @XmlAttribute
 396             void localName(String localName);
 397         }
 398 
 399         interface Schema extends TypedXmlWriter {
 400             @XmlAttribute
 401             void ns(String ns);
 402 
 403             @XmlAttribute
 404             void location(String filePath);
 405         }
 406 
 407         private static void writeQName(QName n, QualifiedName w) {
 408             w.uri(n.getNamespaceURI());
 409             w.localName(n.getLocalPart());
 410         }
 411     }
 412 
 413     protected void usage(Options options) {
 414         // Just don't see any point in passing WsgenOptions
 415         // BadCommandLineException also shouldn't have options
 416         if (options == null)
 417             options = this.options;
 418         if (options instanceof WsgenOptions) {
 419             System.out.println(WscompileMessages.WSGEN_HELP("WSGEN",
 420                     ((WsgenOptions)options).protocols,
 421                     ((WsgenOptions)options).nonstdProtocols.keySet()));
 422             System.out.println(WscompileMessages.WSGEN_USAGE_EXTENSIONS());
 423             System.out.println(WscompileMessages.WSGEN_USAGE_EXAMPLES());
 424         }
 425     }
 426 
 427     class Listener extends WsimportListener {
 428         ConsoleErrorReporter cer = new ConsoleErrorReporter(out == null ? new PrintStream(new NullStream()) : out);
 429 
 430         @Override
 431         public void generatedFile(String fileName) {
 432             message(fileName);
 433         }
 434 
 435         @Override
 436         public void message(String msg) {
 437             out.println(msg);
 438         }
 439 
 440         @Override
 441         public void error(SAXParseException exception) {
 442             cer.error(exception);
 443         }
 444 
 445         @Override
 446         public void fatalError(SAXParseException exception) {
 447             cer.fatalError(exception);
 448         }
 449 
 450         @Override
 451         public void warning(SAXParseException exception) {
 452             cer.warning(exception);
 453         }
 454 
 455         @Override
 456         public void info(SAXParseException exception) {
 457             cer.info(exception);
 458         }
 459     }
 460 }