From bdd0a41aed7edf21ec2a65cfa17a86af2ef8c48a Mon Sep 17 00:00:00 2001 From: dims Date: Tue, 17 Jun 2008 00:23:01 +0000 Subject: Move Tuscany from Incubator to top level. git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@668359 13f79535-47bb-0310-9956-ffa450edef68 --- sandbox/ant/relax-ws/DISCLAIMER | 8 + sandbox/ant/relax-ws/LICENSE | 205 ++++++++++++ sandbox/ant/relax-ws/NOTICE | 8 + sandbox/ant/relax-ws/pom.xml | 70 +++++ .../sca/interfacedef/relaxws/Convert2Wsdl.java | 342 +++++++++++++++++++++ .../relaxws/RelaxWSDocumentProcessor.java | 90 ++++++ .../sca/interfacedef/relaxws/RelaxWSModel.java | 41 +++ .../interfacedef/relaxws/RelaxWSModelResolver.java | 151 +++++++++ .../interfacedef/relaxws/RelaxWSWSDLLocator.java | 83 +++++ ...sca.contribution.processor.URLArtifactProcessor | 19 ++ ...tuscany.sca.contribution.resolver.ModelResolver | 18 ++ .../sca/interfacedef/relaxws/RelaxWSTestCase.java | 44 +++ .../sca/interfacedef/relaxws/helloworld.rws | 21 ++ 13 files changed, 1100 insertions(+) create mode 100644 sandbox/ant/relax-ws/DISCLAIMER create mode 100644 sandbox/ant/relax-ws/LICENSE create mode 100644 sandbox/ant/relax-ws/NOTICE create mode 100644 sandbox/ant/relax-ws/pom.xml create mode 100644 sandbox/ant/relax-ws/src/main/java/org/apache/tuscany/sca/interfacedef/relaxws/Convert2Wsdl.java create mode 100644 sandbox/ant/relax-ws/src/main/java/org/apache/tuscany/sca/interfacedef/relaxws/RelaxWSDocumentProcessor.java create mode 100644 sandbox/ant/relax-ws/src/main/java/org/apache/tuscany/sca/interfacedef/relaxws/RelaxWSModel.java create mode 100644 sandbox/ant/relax-ws/src/main/java/org/apache/tuscany/sca/interfacedef/relaxws/RelaxWSModelResolver.java create mode 100644 sandbox/ant/relax-ws/src/main/java/org/apache/tuscany/sca/interfacedef/relaxws/RelaxWSWSDLLocator.java create mode 100644 sandbox/ant/relax-ws/src/main/resources/META-INF/services/org.apache.tuscany.sca.contribution.processor.URLArtifactProcessor create mode 100644 sandbox/ant/relax-ws/src/main/resources/META-INF/services/org.apache.tuscany.sca.contribution.resolver.ModelResolver create mode 100644 sandbox/ant/relax-ws/src/test/java/org/apache/tuscany/sca/interfacedef/relaxws/RelaxWSTestCase.java create mode 100644 sandbox/ant/relax-ws/src/test/resources/org/apache/tuscany/sca/interfacedef/relaxws/helloworld.rws (limited to 'sandbox/ant/relax-ws') diff --git a/sandbox/ant/relax-ws/DISCLAIMER b/sandbox/ant/relax-ws/DISCLAIMER new file mode 100644 index 0000000000..d68a410903 --- /dev/null +++ b/sandbox/ant/relax-ws/DISCLAIMER @@ -0,0 +1,8 @@ +Apache Tuscany is an effort undergoing incubation at The Apache Software +Foundation (ASF), sponsored by the Apache Web Services PMC. Incubation is +required of all newly accepted projects until a further review indicates that +the infrastructure, communications, and decision making process have stabilized +in a manner consistent with other successful ASF projects. While incubation +status is not necessarily a reflection of the completeness or stability of the +code, it does indicate that the project has yet to be fully endorsed by the ASF. + diff --git a/sandbox/ant/relax-ws/LICENSE b/sandbox/ant/relax-ws/LICENSE new file mode 100644 index 0000000000..8aa906c321 --- /dev/null +++ b/sandbox/ant/relax-ws/LICENSE @@ -0,0 +1,205 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed 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. + + + diff --git a/sandbox/ant/relax-ws/NOTICE b/sandbox/ant/relax-ws/NOTICE new file mode 100644 index 0000000000..aeeca5ef8d --- /dev/null +++ b/sandbox/ant/relax-ws/NOTICE @@ -0,0 +1,8 @@ +${pom.name} +Copyright (c) 2005 - 2008 The Apache Software Foundation + +This product includes software developed by +The Apache Software Foundation (http://www.apache.org/). + +This product uses Relax WS (http://code.google.com/p/relax-ws/) with the following copyright: + * Copyright 2008 Jason Sando diff --git a/sandbox/ant/relax-ws/pom.xml b/sandbox/ant/relax-ws/pom.xml new file mode 100644 index 0000000000..483008859e --- /dev/null +++ b/sandbox/ant/relax-ws/pom.xml @@ -0,0 +1,70 @@ + + + + 4.0.0 + + org.apache.tuscany.sca + tuscany-modules + 1.2-incubating-SNAPSHOT + ../pom.xml + + + tuscany-interface-relax-ws + Apache Tuscany SCA Relax WS Interface + + + + + antelder.apache + http://people.apache.org/~antelder/maven + + false + + + + + + + org.apache.tuscany.sca + tuscany-interface-wsdl-xml + 1.2-incubating-SNAPSHOT + + + com.google.code.p.relaxws + relaxws + 0.1 + + + com.google.code.p.relaxws + isorelax + 0.1 + + + com.google.code.p.relaxws + jing + 0.1 + + + com.google.code.p.relaxws + trang + 0.1 + + + diff --git a/sandbox/ant/relax-ws/src/main/java/org/apache/tuscany/sca/interfacedef/relaxws/Convert2Wsdl.java b/sandbox/ant/relax-ws/src/main/java/org/apache/tuscany/sca/interfacedef/relaxws/Convert2Wsdl.java new file mode 100644 index 0000000000..33726a6f8c --- /dev/null +++ b/sandbox/ant/relax-ws/src/main/java/org/apache/tuscany/sca/interfacedef/relaxws/Convert2Wsdl.java @@ -0,0 +1,342 @@ +/* + * Copyright 2008 Jason Sando + * + * Licensed 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.tuscany.sca.interfacedef.relaxws; + +import com.thaiopensource.relaxng.edit.SchemaCollection; +import com.thaiopensource.relaxng.input.InputFailedException; +import com.thaiopensource.relaxng.input.InputFormat; +import com.thaiopensource.relaxng.input.parse.compact.CompactParseInputFormat; +import com.thaiopensource.relaxng.output.LocalOutputDirectory; +import com.thaiopensource.relaxng.output.OutputDirectory; +import com.thaiopensource.relaxng.output.OutputFormat; +import com.thaiopensource.relaxng.output.xsd.XsdOutputFormat; +import com.thaiopensource.xml.sax.ErrorHandlerImpl; +import com.google.code.p.relaxws.parser.*; + +import java.io.*; +import java.net.URL; +import java.util.HashSet; +import java.util.Set; + +/** + * TUSCANY: change to support calling programatically + * - avoid using Files + * - add constructor + * - make convert method public + */ + +/** + * Convert from relaxws-wiz to wsdl. + * + * 1. parse the input file + * 2. append all rnc blocks into a single buffer, then convert to XSD, to be + * embedded in the wsdl. + * 3. Output wsdl. + */ +public class Convert2Wsdl { + + private PrintWriter out; + private ASTservice tree; + + private static void usage (String reason) { + if (reason != null) + System.err.println ("Command failed: " + reason); + System.err.println ("\nUSAGE:"); + System.err.println("Convert2Wsdl [-d output-folder] "); + System.exit (1); + } + + private static void fail (String reason) { + if (reason != null) + System.err.println ("Command failed: " + reason); + System.exit (1); + } + + private static String fileBase (String name) { + int dot = name.lastIndexOf('.'); + if (dot != -1) { + name = name.substring (0, dot); + } + return name; + } + + public static void main(String[] args) throws Exception { + + String outputPath = null; + String inputFilePath = null; + + int lastArg = args.length - 1; + for (int i = 0; i < args.length; i++) { + if ("-d".equals (args[i]) && (i < lastArg)) { + outputPath = args[i + 1]; + i++; + } else if (args[i].startsWith("-")) { + usage("unrecognized option " + args[i]); + } else { + if (inputFilePath != null) { + usage("Multiple input files specified: " + inputFilePath + "," + args[i]); + } + inputFilePath = args[i]; + } + } + + if (inputFilePath == null) { + usage(null); + } + + File inputFile = new File (inputFilePath); + if (!inputFile.exists()) { + fail ("'" + inputFilePath + "' not found."); + } + if (outputPath == null) { + outputPath = inputFile.getParent(); + } + + File outputFileDir = new File (outputPath); + if (!outputFileDir.exists()) { + if (!outputFileDir.mkdirs()) { + fail ("failed to create output folder '" + outputPath + "'"); + } + } + + BufferedReader rdr = new BufferedReader (new FileReader(inputFile)); + RelaxWizParser p = new RelaxWizParser (rdr); + ASTservice tree = p.service (); + + File outputFile = new File(outputFileDir, fileBase(inputFile.getName()) + ".wsdl"); + System.err.println("Convert2Wsdl: processing '" + inputFile.getName() + "' to '" + outputFile.getPath()); + + PrintWriter out = new PrintWriter(new FileWriter(outputFile)); + + Convert2Wsdl converter = new Convert2Wsdl(tree, out); + converter.convert(); + + out.close(); + } + + public Convert2Wsdl(ASTservice tree, PrintWriter out) { + this.tree = tree; + this.out = out; + } + + public void convert() throws Exception { + + if (tree.getNamespace() == null) { + tree.setNamespace("http://tempuri.org/" + tree.getName()); + } + String ns = tree.getNamespace(); + + out.print ("\n"); + out.print ("\n" + + "\n" + + " \n"); + + // Make a pass through and assign all message names, and build proper rnc block + Set messageNames = new HashSet(); + StringBuffer rncBuff = new StringBuffer(); + rncBuff.append ("default namespace = \"" + ns + "\"\n"); +// rncBuff.append ("(\n"); + for (Node portNode: tree.getChildren()) { + if (portNode instanceof ASTtypesDecl) { + rncBuff.append(((ASTtypesDecl) portNode).getRnc()); + continue; + } + + ASTportDecl port = (ASTportDecl) portNode; + + // patch up default name if not set. + if (port.getName() == null) { + port.setName (tree.getName() + "Port"); + } + + // enumerate operations in this port + for (Node opNode: port.getChildren()) { + ASToperationDecl op = (ASToperationDecl) opNode; + + // children of op node + for (Node msgNode: op.getChildren()) { + ASTMessageDef message = (ASTMessageDef) msgNode; + message.setDefaultMessageName(op.getName()); + + if (messageNames.contains(message.getMessageName())) { + // todo: loop searching for unique name + message.setMessageName(message.getMessageName() + "1"); + } else { + messageNames.add(message.getMessageName()); + } + + if (message.getName() == null) { + message.setDefaultName (op.getName()); + } + + rncBuff.append (message.getName() + " = "); + rncBuff.append ("element " + message.getName() + " {\n"); + String s = message.getRnc(); + if (s.trim().length() == 0) { + s = "text"; + } + rncBuff.append (s); + rncBuff.append ("}\n"); + } + } + } +// rncBuff.append (")"); + + // convert rnc to xsd + String xsdText = toXsd(rncBuff.toString()); + out.print (xsdText); + + out.print (" \n"); + + // declare messages for each in and out of each operation for each port (must be unique) + out.println (); + for (Node portNode: tree.getChildren()) { + + if (portNode instanceof ASTtypesDecl) { + continue; + } + + ASTportDecl port = (ASTportDecl) portNode; + + // enumerate operations in this port + for (Node opNode: port.getChildren()) { + ASToperationDecl op = (ASToperationDecl) opNode; + + // children of op node + for (Node msgNode: op.getChildren()) { + ASTMessageDef message = (ASTMessageDef) msgNode; + // declare message type + out.println (" "); + out.println (" "); + out.println (" "); + } + + } + + out.println (); + out.println (" "); + for (Node opNode: port.getChildren()) { + ASToperationDecl op = (ASToperationDecl) opNode; + + out.println (" "); + + // children of op node + for (Node msgNode: op.getChildren()) { + ASTMessageDef message = (ASTMessageDef) msgNode; + + switch (message.getType()) { + case In: + out.println (" "); + break; + + case Out: + out.println (" "); + break; + + case Fault: + // todo + } + } + + out.println (" "); + } + out.println (" "); + + // binding to soap + out.println (); + out.println (" "); + out.println (" "); + for (Node opNode: port.getChildren()) { + ASToperationDecl op = (ASToperationDecl) opNode; + + out.println (" "); + out.println (" "); + out.println (" \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " "); + out.println (" "); + } + out.println (" "); + + out.println(); + out.println (" \n" + + " \n" + + " \n" + + " \n" + + " "); + } + + + out.print ("\n"); + out.close(); + } + + private static String toXsd (String rnc) throws Exception { + + // write the rnc to a temp file + File rncInput = File.createTempFile("relaxwiz", ".rnc"); + FileWriter fw = new FileWriter (rncInput); + fw.write(rnc); + fw.close(); + + // Use Trang to convert to an XSD file + InputFormat inFormat = new CompactParseInputFormat(); + ErrorHandlerImpl handler = new ErrorHandlerImpl(); + SchemaCollection sc = null; + try { + sc = inFormat.load(new URL("file", "", rncInput.getAbsolutePath()).toString(), new String[0], "xsd", handler); + } catch (InputFailedException e) { + System.err.println("Error in RNC preprocessor, source follows:"); + int line = 0; + for (String s: rnc.split("\n")) { + line++; + System.err.printf("%3d: %s\n", line, s); + } + System.exit (1); + } + OutputFormat of = new XsdOutputFormat(); + File xsdOutput = File.createTempFile("relaxwiz", ".xsd"); + OutputDirectory od = new LocalOutputDirectory(sc.getMainUri(), + xsdOutput, + "xsd", + "UTF-8", + 80, + 2); + String[] outParams = new String[]{new URL("file", "", xsdOutput.getAbsolutePath()).toString()}; + of.output(sc, od, new String[]{}, "rnc", handler); + + // read in file and return as string. + BufferedReader reader = new BufferedReader(new FileReader (xsdOutput)); + String line; + StringBuffer buf = new StringBuffer(); + while ((line = reader.readLine()) != null) { + if (line.startsWith(" { + + private WSDLFactory factory; + + public RelaxWSDocumentProcessor(ModelFactoryExtensionPoint modelFactories) { + this.factory = modelFactories.getFactory(WSDLFactory.class); + } + + public RelaxWSModel read(URL contributionURL, URI artifactURI, URL artifactURL) throws ContributionReadException { + + try { + + javax.wsdl.factory.WSDLFactory wsdlFactory = javax.wsdl.factory.WSDLFactory.newInstance(); + WSDLReader wsdlReader = wsdlFactory.newWSDLReader(); + wsdlReader.setFeature("javax.wsdl.verbose",false); + wsdlReader.setFeature("javax.wsdl.importDocuments",false); + + WSDLLocator locator = new RelaxWSWSDLLocator(artifactURL); + Definition definition = wsdlReader.readWSDL(locator); + WSDLDefinition wsdlDefinition = factory.createWSDLDefinition(); + + wsdlDefinition.setDefinition(definition); + wsdlDefinition.setUnresolved(true); + wsdlDefinition.setNamespace(definition.getTargetNamespace()); + wsdlDefinition.setUnresolved(false); + + RelaxWSModel rwsModel = new RelaxWSModel(wsdlDefinition); + return rwsModel; + + } catch (WSDLException e) { + throw new ContributionReadException(e); + } + } + + public String getArtifactType() { + return ".rws"; + } + + public Class getModelType() { + return RelaxWSModel.class; + } + + public void resolve(RelaxWSModel arg0, ModelResolver arg1) throws ContributionResolveException { + } + +} diff --git a/sandbox/ant/relax-ws/src/main/java/org/apache/tuscany/sca/interfacedef/relaxws/RelaxWSModel.java b/sandbox/ant/relax-ws/src/main/java/org/apache/tuscany/sca/interfacedef/relaxws/RelaxWSModel.java new file mode 100644 index 0000000000..c47a5853a5 --- /dev/null +++ b/sandbox/ant/relax-ws/src/main/java/org/apache/tuscany/sca/interfacedef/relaxws/RelaxWSModel.java @@ -0,0 +1,41 @@ +/* + * 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.tuscany.sca.interfacedef.relaxws; + +import org.apache.tuscany.sca.interfacedef.wsdl.WSDLDefinition; + +/** + * Model object for Relax WS documents. + * Just a holder for a WSDLDefinition needed so the RelaxWSModelResolver + * can get a hook in to add the WSDLDefinition to the WSDLModelResolver + */ +public class RelaxWSModel { + + protected WSDLDefinition wsdlDefinition; + + public RelaxWSModel(WSDLDefinition wsdlDefinition) { + this.wsdlDefinition = wsdlDefinition; + } + + public WSDLDefinition getWsdlDefinition() { + return wsdlDefinition; + } + +} diff --git a/sandbox/ant/relax-ws/src/main/java/org/apache/tuscany/sca/interfacedef/relaxws/RelaxWSModelResolver.java b/sandbox/ant/relax-ws/src/main/java/org/apache/tuscany/sca/interfacedef/relaxws/RelaxWSModelResolver.java new file mode 100644 index 0000000000..190f1d2b81 --- /dev/null +++ b/sandbox/ant/relax-ws/src/main/java/org/apache/tuscany/sca/interfacedef/relaxws/RelaxWSModelResolver.java @@ -0,0 +1,151 @@ +/* + * 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.tuscany.sca.interfacedef.relaxws; + +import static org.apache.tuscany.sca.interfacedef.wsdl.xml.WSDLModelResolver.XSD_QNAME_LIST; + +import java.net.URI; +import java.util.List; + +import javax.wsdl.Definition; +import javax.wsdl.Types; +import javax.wsdl.extensions.ExtensibilityElement; +import javax.wsdl.extensions.UnknownExtensibilityElement; +import javax.wsdl.extensions.schema.Schema; + +import org.apache.tuscany.sca.contribution.Contribution; +import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint; +import org.apache.tuscany.sca.contribution.resolver.ModelResolver; +import org.apache.tuscany.sca.interfacedef.wsdl.WSDLDefinition; +import org.apache.tuscany.sca.interfacedef.wsdl.WSDLFactory; +import org.apache.tuscany.sca.interfacedef.wsdl.XSDefinition; +import org.w3c.dom.Attr; +import org.w3c.dom.Document; +import org.w3c.dom.Element; +import org.w3c.dom.NamedNodeMap; +import org.w3c.dom.Node; + +/** + * A ModelResolver that takes a RelaxWSModel object and gives the + * underlying WSDLDefinition to the WSDL model resolver. + */ +public class RelaxWSModelResolver implements ModelResolver { + + private ModelResolver modelresolver; + Contribution contribution; + private WSDLFactory wsdlFactory; + + public RelaxWSModelResolver(Contribution contribution, ModelFactoryExtensionPoint modelFactories) { + modelresolver = contribution.getModelResolver(); + this.contribution = contribution; + this.wsdlFactory = modelFactories.getFactory(WSDLFactory.class); + } + + public void addModel(Object arg0) { + RelaxWSModel rwsModel = (RelaxWSModel)arg0; + readInlineSchemas(rwsModel.wsdlDefinition, rwsModel.wsdlDefinition.getDefinition()); + modelresolver.addModel(rwsModel.wsdlDefinition); + } + + public Object removeModel(Object arg0) { + RelaxWSModel rwsModel = (RelaxWSModel)arg0; + return modelresolver.removeModel(rwsModel.wsdlDefinition); + } + + public T resolveModel(Class arg0, T arg1) { + // nothing needed for RelaxWSModelResolver + return null; + } + + // TODO following methods are a direct copy from the WSDLModelResolver + // need to refactor so the code can be shared + + protected void readInlineSchemas(WSDLDefinition wsdlDefinition, Definition definition) { + if (contribution == null) { + // Check null for test cases + return; + } + Types types = definition.getTypes(); + if (types != null) { + int index = 0; + for (Object ext : types.getExtensibilityElements()) { + ExtensibilityElement extElement = (ExtensibilityElement)ext; + Element element = null; + if (XSD_QNAME_LIST.contains(extElement.getElementType())) { + if (extElement instanceof Schema) { + element = ((Schema)extElement).getElement(); + } else if (extElement instanceof UnknownExtensibilityElement) { + element = ((UnknownExtensibilityElement)extElement).getElement(); + } + } + if (element != null) { + Document doc = promote(element); + XSDefinition xsDefinition = wsdlFactory.createXSDefinition(); + xsDefinition.setUnresolved(true); + xsDefinition.setNamespace(element.getAttribute("targetNamespace")); + xsDefinition.setDocument(doc); + xsDefinition.setLocation(URI.create(doc.getDocumentURI() + "#" + index)); + XSDefinition resolved = + contribution.getModelResolver().resolveModel(XSDefinition.class, xsDefinition); + if (resolved != null && !resolved.isUnresolved()) { + if (!wsdlDefinition.getXmlSchemas().contains(resolved)) { + wsdlDefinition.getXmlSchemas().add(xsDefinition); + } + } + index++; + } + } + } + for (Object imports : definition.getImports().values()) { + List impList = (List)imports; + for (Object i : impList) { + javax.wsdl.Import anImport = (javax.wsdl.Import)i; + // Read inline schemas + if (anImport.getDefinition() != null) { + readInlineSchemas(wsdlDefinition, anImport.getDefinition()); + } + } + } + } + + private Document promote(Element element) { + Document doc = (Document)element.getOwnerDocument().cloneNode(false); + Element schema = (Element)doc.importNode(element, true); + doc.appendChild(schema); + Node parent = element.getParentNode(); + while (parent instanceof Element) { + Element root = (Element)parent; + NamedNodeMap nodeMap = root.getAttributes(); + for (int i = 0; i < nodeMap.getLength(); i++) { + Attr attr = (Attr)nodeMap.item(i); + String name = attr.getName(); + if ("xmlns".equals(name) || name.startsWith("xmlns:")) { + if (schema.getAttributeNode(name) == null) { + schema.setAttributeNodeNS((Attr)doc.importNode(attr, true)); + } + } + } + parent = parent.getParentNode(); + } + doc.setDocumentURI(element.getOwnerDocument().getDocumentURI()); + return doc; + } + +} diff --git a/sandbox/ant/relax-ws/src/main/java/org/apache/tuscany/sca/interfacedef/relaxws/RelaxWSWSDLLocator.java b/sandbox/ant/relax-ws/src/main/java/org/apache/tuscany/sca/interfacedef/relaxws/RelaxWSWSDLLocator.java new file mode 100644 index 0000000000..d5b12eef95 --- /dev/null +++ b/sandbox/ant/relax-ws/src/main/java/org/apache/tuscany/sca/interfacedef/relaxws/RelaxWSWSDLLocator.java @@ -0,0 +1,83 @@ +/* + * 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.tuscany.sca.interfacedef.relaxws; + +import java.io.BufferedReader; +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.io.FileReader; +import java.io.InputStreamReader; +import java.io.PrintWriter; +import java.io.StringReader; +import java.net.URL; + +import javax.wsdl.xml.WSDLLocator; + +import org.xml.sax.InputSource; + +import com.google.code.p.relaxws.parser.RelaxWizParser; + +/** + * WSDLLocator for reading a Relax WS .rws file into a WSDL4J Definition + */ +public class RelaxWSWSDLLocator implements WSDLLocator { + + URL rwsURL; + String wsdlString; + + public RelaxWSWSDLLocator(URL rwsURL) { + this.rwsURL = rwsURL; + } + + public void close() { + } + + public InputSource getBaseInputSource() { + if (wsdlString == null) { + try { + convertRwsToWsdl(); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + return new InputSource(new StringReader(wsdlString)); + } + + protected void convertRwsToWsdl() throws Exception { + RelaxWizParser parser = new RelaxWizParser (new BufferedReader (new InputStreamReader(rwsURL.openStream()))); + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + Convert2Wsdl convertor = new Convert2Wsdl(parser.service(), new PrintWriter(baos)); + convertor.convert(); + wsdlString = baos.toString(); + } + + public String getBaseURI() { + return rwsURL.toString(); + } + + public InputSource getImportInputSource(String arg0, String arg1) { + return null; + } + + public String getLatestImportURI() { + return null; + } + +} diff --git a/sandbox/ant/relax-ws/src/main/resources/META-INF/services/org.apache.tuscany.sca.contribution.processor.URLArtifactProcessor b/sandbox/ant/relax-ws/src/main/resources/META-INF/services/org.apache.tuscany.sca.contribution.processor.URLArtifactProcessor new file mode 100644 index 0000000000..2a0baf793c --- /dev/null +++ b/sandbox/ant/relax-ws/src/main/resources/META-INF/services/org.apache.tuscany.sca.contribution.processor.URLArtifactProcessor @@ -0,0 +1,19 @@ +# 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. + +# Implementation class for the artifact processor extension +org.apache.tuscany.sca.interfacedef.relaxws.RelaxWSDocumentProcessor;type=.rws,model=org.apache.tuscany.sca.interfacedef.relaxws.RelaxWSModel diff --git a/sandbox/ant/relax-ws/src/main/resources/META-INF/services/org.apache.tuscany.sca.contribution.resolver.ModelResolver b/sandbox/ant/relax-ws/src/main/resources/META-INF/services/org.apache.tuscany.sca.contribution.resolver.ModelResolver new file mode 100644 index 0000000000..a173f77a52 --- /dev/null +++ b/sandbox/ant/relax-ws/src/main/resources/META-INF/services/org.apache.tuscany.sca.contribution.resolver.ModelResolver @@ -0,0 +1,18 @@ +# 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. + +org.apache.tuscany.sca.interfacedef.relaxws.RelaxWSModelResolver;model=org.apache.tuscany.sca.interfacedef.relaxws.RelaxWSModel diff --git a/sandbox/ant/relax-ws/src/test/java/org/apache/tuscany/sca/interfacedef/relaxws/RelaxWSTestCase.java b/sandbox/ant/relax-ws/src/test/java/org/apache/tuscany/sca/interfacedef/relaxws/RelaxWSTestCase.java new file mode 100644 index 0000000000..30b53c0e7b --- /dev/null +++ b/sandbox/ant/relax-ws/src/test/java/org/apache/tuscany/sca/interfacedef/relaxws/RelaxWSTestCase.java @@ -0,0 +1,44 @@ +/* + * 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.tuscany.sca.interfacedef.relaxws; + +import java.net.URL; + +import javax.wsdl.Definition; +import javax.wsdl.WSDLException; +import javax.wsdl.xml.WSDLReader; + +import junit.framework.TestCase; + +import org.apache.tuscany.sca.interfacedef.relaxws.RelaxWSWSDLLocator; + +public class RelaxWSTestCase extends TestCase { + + public void testConvert() throws WSDLException { + URL rwsURL = this.getClass().getClassLoader().getResource("org/apache/tuscany/sca/interfacedef/relaxws/helloworld.rws"); + RelaxWSWSDLLocator locator = new RelaxWSWSDLLocator(rwsURL); + javax.wsdl.factory.WSDLFactory wsdlFactory = javax.wsdl.factory.WSDLFactory.newInstance(); + WSDLReader wsdlReader = wsdlFactory.newWSDLReader(); + wsdlReader.setFeature("javax.wsdl.verbose",false); + wsdlReader.setFeature("javax.wsdl.importDocuments",false); + Definition definition = wsdlReader.readWSDL(locator); + assertNotNull(definition); + } +} diff --git a/sandbox/ant/relax-ws/src/test/resources/org/apache/tuscany/sca/interfacedef/relaxws/helloworld.rws b/sandbox/ant/relax-ws/src/test/resources/org/apache/tuscany/sca/interfacedef/relaxws/helloworld.rws new file mode 100644 index 0000000000..602298e8ee --- /dev/null +++ b/sandbox/ant/relax-ws/src/test/resources/org/apache/tuscany/sca/interfacedef/relaxws/helloworld.rws @@ -0,0 +1,21 @@ +# +# This is "hello world" in relax-ws. +# +namespace http://tuscany.apache.org/samples + +service HelloWorld { + + port { + operation SayHello { + in { + element name {xsd:string} + } + + out { + element message {xsd:string} + } + + } + + } +} \ No newline at end of file -- cgit v1.2.3