public static IStatus isWSDLAccessible(URL contextURL) {
Properties props = System.getProperties();
String oldPropValue = props.getProperty(DEF_FACTORY_PROPERTY_NAME);
props.setProperty(DEF_FACTORY_PROPERTY_NAME, PRIVATE_DEF_FACTORY_CLASS);
WSDLFactory factory;
try {
factory = WSDLFactory.newInstance();
WSDLReader wsdlReader = factory.newWSDLReader();
wsdlReader.setFeature(Constants.FEATURE_VERBOSE, false);
wsdlReader.setFeature("javax.wsdl.importDocuments", true); // $NON-NLS-1$
String context = null;
if (contextURL != null) context = contextURL.toString();
wsdlReader.readWSDL(context);
} catch (WSDLException e) {
if (contextURL.getProtocol().equalsIgnoreCase("https")) { // $NON-NLS-1$
return StatusUtils.warningStatus(
JBossWSUIMessages.TesterWSDLUtils_WSDL_HTTPS_Secured_Inaccessible);
} else {
return StatusUtils.errorStatus(JBossWSUIMessages.TesterWSDLUtils_WSDL_Inaccessible, e);
}
}
if (oldPropValue != null) {
props.setProperty(DEF_FACTORY_PROPERTY_NAME, oldPropValue);
} else {
props.remove(DEF_FACTORY_PROPERTY_NAME);
}
return Status.OK_STATUS;
}
@Test
public void testWSDLLocatorWithDefaultCatalog() throws Exception {
URL wsdl = getClass().getResource("/wsdl/catalog/hello_world_services.wsdl");
assertNotNull(wsdl);
WSDLFactory wsdlFactory = WSDLFactory.newInstance();
WSDLReader wsdlReader = wsdlFactory.newWSDLReader();
CatalogWSDLLocator wsdlLocator =
new CatalogWSDLLocator(wsdl.toString(), OASISCatalogManager.getCatalogManager(null));
wsdlReader.setFeature("javax.wsdl.verbose", false);
wsdlReader.readWSDL(wsdlLocator);
}
/**
* Loads nested schema type definitions from wsdl.
*
* @throws IOException
* @throws WSDLException
* @throws TransformerFactoryConfigurationError
* @throws TransformerException
* @throws TransformerConfigurationException
*/
private void loadSchemas()
throws WSDLException, IOException, TransformerConfigurationException, TransformerException,
TransformerFactoryConfigurationError {
Definition definition =
WSDLFactory.newInstance().newWSDLReader().readWSDL(wsdl.getFile().getAbsolutePath());
Types types = definition.getTypes();
List<?> schemaTypes = types.getExtensibilityElements();
for (Object schemaObject : schemaTypes) {
if (schemaObject instanceof SchemaImpl) {
SchemaImpl schema = (SchemaImpl) schemaObject;
inheritNamespaces(schema, definition);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
Source source = new DOMSource(schema.getElement());
Result result = new StreamResult(bos);
TransformerFactory.newInstance().newTransformer().transform(source, result);
Resource schemaResource = new ByteArrayResource(bos.toByteArray());
schemas.add(schemaResource);
if (definition
.getTargetNamespace()
.equals(schema.getElement().getAttribute("targetNamespace"))) {
setXsd(schemaResource);
}
} else {
log.warn("Found unsupported schema type implementation " + schemaObject.getClass());
}
}
}
public File writeDefinition(File targetDir, File defnFile) throws Exception {
File bkFile = new File(targetDir, "bk_" + defnFile.getName());
FileWriter writer = new FileWriter(bkFile);
WSDLFactory factory =
WSDLFactory.newInstance("org.apache.cxf.tools.corba.utils.TestWSDLCorbaFactoryImpl");
WSDLReader reader = factory.newWSDLReader();
reader.setFeature("javax.wsdl.importDocuments", false);
ExtensionRegistry extReg = new ExtensionRegistry();
addExtensions(extReg);
reader.setExtensionRegistry(extReg);
Definition wsdlDefn = reader.readWSDL(defnFile.toString());
WSDLWriter wsdlWriter = factory.newWSDLWriter();
wsdlWriter.writeWSDL(wsdlDefn, writer);
writer.close();
writer = null;
reader = null;
return bkFile;
}
@Test
public void testWSDLLocatorWithoutCatalog() throws Exception {
URL wsdl = getClass().getResource("/wsdl/catalog/hello_world_services.wsdl");
assertNotNull(wsdl);
WSDLFactory wsdlFactory = WSDLFactory.newInstance();
WSDLReader wsdlReader = wsdlFactory.newWSDLReader();
wsdlReader.setFeature("javax.wsdl.verbose", false);
OASISCatalogManager catalog = new OASISCatalogManager();
CatalogWSDLLocator wsdlLocator = new CatalogWSDLLocator(wsdl.toString(), catalog);
try {
wsdlReader.readWSDL(wsdlLocator);
fail("Test did not fail as expected");
} catch (WSDLException e) {
// ignore
}
}
public synchronized Definition get(String url) throws WSDLException {
Definition definition = cache.get(url);
if (definition == null) {
WSDLReader reader = factory.newWSDLReader();
definition = reader.readWSDL(url);
cache.put(url, definition);
}
return definition;
}
public static Definition readWSDLURL(URL contextURL, String wsdlLoc) throws WSDLException {
Properties props = System.getProperties();
String oldPropValue = props.getProperty(DEF_FACTORY_PROPERTY_NAME);
props.setProperty(DEF_FACTORY_PROPERTY_NAME, PRIVATE_DEF_FACTORY_CLASS);
WSDLFactory factory = WSDLFactory.newInstance();
WSDLReader wsdlReader = factory.newWSDLReader();
wsdlReader.setFeature(Constants.FEATURE_VERBOSE, false);
wsdlReader.setFeature("javax.wsdl.importDocuments", true); // $NON-NLS-1$
String context = null;
if (contextURL != null) context = contextURL.toString();
Definition def = wsdlReader.readWSDL(context, wsdlLoc);
if (oldPropValue != null) {
props.setProperty(DEF_FACTORY_PROPERTY_NAME, oldPropValue);
} else {
props.remove(DEF_FACTORY_PROPERTY_NAME);
}
return def;
}
public synchronized MyEndpointReference activateEndpoint(QName pid, Endpoint endpoint)
throws Exception {
if (__log.isDebugEnabled()) {
__log.debug("Activate endpoint: " + endpoint);
}
OdeService service = _activeOdeServices.get(endpoint);
if (service == null) service = new OdeService(this, endpoint);
try {
ProcessConf pc = _store.getProcessConfiguration(pid);
InputStream is = pc.getCBPInputStream();
OProcess compiledProcess = null;
try {
Serializer ofh = new Serializer(is);
compiledProcess = ofh.readOProcess();
} finally {
is.close();
}
QName portType = null;
for (Map.Entry<String, Endpoint> provide : pc.getProvideEndpoints().entrySet()) {
if (provide.getValue().equals(endpoint)) {
OPartnerLink plink = compiledProcess.getPartnerLink(provide.getKey());
portType = plink.myRolePortType.getQName();
break;
}
}
if (portType == null) {
if (__log.isDebugEnabled()) {
__log.debug("Could not find PortType for endpoint");
}
} else {
Definition def = pc.getDefinitionForService(endpoint.serviceName);
if (def == null) {
__log.debug("Could not find definition for service: " + endpoint.serviceName);
} else {
def = new WSDLFlattener(def).getDefinition(portType);
Document doc = WSDLFactory.newInstance().newWSDLWriter().getDocument(def);
addEndpointDoc(endpoint.serviceName, doc);
}
}
} catch (Exception e) {
__log.warn("Exception during endpoint activation", e);
}
MyEndpointReference myepr = new MyEndpointReference(service);
service.activate();
_activeOdeServices.put(endpoint, service);
_serviceEprMap.put(service, myepr);
return myepr;
}
/**
* This method is used to get wsdl difference comparison.
*
* @param WSDLOne wsdl one.
* @param WSDLTwo wsdl two.
* @return Comparison object which includes the difference parameters.
* @throws ComparisonException
* @throws WSDLException
* @throws RegistryException
* @throws UnsupportedEncodingException
*/
private Comparison getWSDLComparison(Resource WSDLOne, Resource WSDLTwo)
throws ComparisonException, WSDLException, RegistryException, UnsupportedEncodingException {
GovernanceDiffGeneratorFactory diffGeneratorFactory = new GovernanceDiffGeneratorFactory();
DiffGenerator flow = diffGeneratorFactory.getDiffGenerator();
WSDLReader wsdlReader = WSDLFactory.newInstance().newWSDLReader();
InputSource inputSourceOne =
new InputSource(new ByteArrayInputStream((byte[]) WSDLOne.getContent()));
Definition originalWSDL = wsdlReader.readWSDL(null, inputSourceOne);
InputSource inputSourceTwo =
new InputSource(new ByteArrayInputStream((byte[]) WSDLTwo.getContent()));
Definition changedWSDL = wsdlReader.readWSDL(null, inputSourceTwo);
return flow.compare(originalWSDL, changedWSDL, ComparatorConstants.WSDL_MEDIA_TYPE);
}
/**
* Build the WSDL model.
*
* @param abstractService collected Service information
* @param prebuild XSD generator for type section
* @return WSDL definition
*/
public Definition buildDefinition(AbstractService abstractService, XsdSchemaGenerator xsdgen)
throws WSDLException, java.lang.Exception {
String serviceName = helper.reformatOWLSSupportedByString(abstractService.getID());
String serviceDescription = abstractService.getDescription();
Map<String, Vector<AbstractServiceParameter>> mapInputs =
new HashMap<String, Vector<AbstractServiceParameter>>();
Map<String, Vector<AbstractServiceParameter>> mapOutputs =
new HashMap<String, Vector<AbstractServiceParameter>>();
Map<String, AtomicProcess> mapProcesses = new HashMap<String, AtomicProcess>();
System.out.println("[BUILD] Servicename: " + serviceName);
System.out.println("[BUILD] description: " + serviceDescription);
if (!this.validateServiceParameterTypes(abstractService)) {
throw new Exception("Error in parameter list. Datatype not found.");
}
Vector<AtomicProcess> processes = abstractService.getProcesses();
Iterator<AtomicProcess> itA = processes.iterator();
while (itA.hasNext()) {
AtomicProcess ap = itA.next();
Vector<AbstractServiceParameter> inputParameter = ap.getInputParameter();
Vector<AbstractServiceParameter> outputParameter = ap.getOutputParameter();
String operationName = ap.getName();
// for (int i = 0; i < ap.getOutputParameter().size(); i++) {
// String operationName = "get"
// + ((AbstractServiceParameter) ap
// .getOutputParameter().get(i)).getID();
System.out.println("[BUILD] Operation : " + operationName);
// }
mapInputs.put(operationName, inputParameter);
mapOutputs.put(operationName, outputParameter);
mapProcesses.put(operationName, ap);
}
WSDLFactory wsdlFactory = WSDLFactory.newInstance();
ExtensionRegistry extensionRegistry = wsdlFactory.newPopulatedExtensionRegistry();
Definition def = wsdlFactory.newDefinition();
SchemaSerializer schemaSer = new SchemaSerializer();
extensionRegistry.setDefaultSerializer(schemaSer);
//
// NAMESPACE
//
// e.g. "http://dmas.dfki.de/axis/services/"
int index = abstractService.getBase().lastIndexOf(".");
String targetNS = abstractService.getBase().substring(0, index);
if (OWLS2WSDLSettings.getInstance().getProperty("CHANGE_TNS").equals("yes")) {
String tns_basepath = OWLS2WSDLSettings.getInstance().getProperty("TNS_BASEPATH");
targetNS = tns_basepath + serviceName;
def.setQName(new QName(tns_basepath, serviceName)); // +"Service"));
} else {
def.setQName(
new QName(abstractService.getBasePath(), serviceName)); // abstractService.getID()));
}
System.out.println("abstractService.getBase : " + abstractService.getBase());
System.out.println("abstractService.getBasePath: " + abstractService.getBasePath());
// def.setDocumentBaseURI("http://document/base");
def.setTargetNamespace(targetNS);
def.addNamespace("tns", targetNS);
def.addNamespace("intf", targetNS);
def.addNamespace("impl", targetNS + "-impl");
def.addNamespace("", targetNS);
def.addNamespace("xsd", "http://www.w3.org/2001/XMLSchema");
def.addNamespace("wsdl", "http://schemas.xmlsoap.org/wsdl/");
def.addNamespace("wsdlsoap", "http://schemas.xmlsoap.org/wsdl/soap/");
def.addNamespace("SOAP-ENC", "http://schemas.xmlsoap.org/soap/encoding/");
def.addNamespace("apachesoap", "http://xml.apache.org/xml-soap");
System.out.println("INFO: " + def.getQName().toString());
System.out.println("tns : " + def.getNamespace("tns" + serviceName));
// WA: xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/"
// WA: xmlns:wsdlsoap="http://schemas.xmlsoap.org/wsdl/soap/"
//
// IMPORTS AND TYPES
//
/*
* Import importsec = def.createImport(); importsec.setDefinition(def);
* importsec.setLocationURI("locationURI");
* importsec.setNamespaceURI("nsURI"); def.addImport(importsec);
*/
// LESEN DES SCHEMAS AUS DATEISYSTEM
// ===========================================
// DOMParser domp = new DOMParser();
// try {
// //domp.parse("file:/D:/development/xsd/generated.xsd");
// domp.parse("file:/D:/tmp/StEmilion.xsd");
// }
// catch(Exception e) { e.printStackTrace(); }
//
// Document doc = domp.getDocument();
// Element element = doc.getDocumentElement();
// =============================================================================
Element element = null;
try {
// construct schema model for all parameter
Iterator<Entry<String, Vector<AbstractServiceParameter>>> itAp =
mapInputs.entrySet().iterator();
while (itAp.hasNext()) {
for (Iterator<AbstractServiceParameter> it = itAp.next().getValue().iterator();
it.hasNext(); ) {
AbstractServiceParameter param = it.next();
System.out.println("[BUILD] IN :" + param.getUri());
if (!this.isPrimitiveType(param.getUri())) {
xsdgen.appendToSchema(
AbstractDatatypeKB.getInstance().getAbstractDatatypeKBData().get(param.getUri()));
System.out.println("[BUILD] added to type section.");
}
}
}
itAp = mapOutputs.entrySet().iterator();
while (itAp.hasNext()) {
for (Iterator<AbstractServiceParameter> it = itAp.next().getValue().iterator();
it.hasNext(); ) {
AbstractServiceParameter param = it.next();
System.out.println("[BUILD] OUT :" + param.getUri());
if (!this.isPrimitiveType(param.getUri())) {
xsdgen.appendToSchema(
AbstractDatatypeKB.getInstance().getAbstractDatatypeKBData().get(param.getUri()));
System.out.println("[BUILD] added to type section.");
}
}
}
xsdgen.deleteObsoleteTypesFromSchema();
// org.jdom.Document jdoc =
// XMLUtils.convertSchemaToElement(AbstractDatatypeKB.getInstance().getXmlSchemaElement("http://www.w3.org/TR/2003/PR-owl-guide-20031209/wine#StEmilion",
// false, -1)).getDocument();
org.jdom.Document jdoc = XMLUtils.convertSchemaToElement(xsdgen.getSchema()).getDocument();
DOMOutputter w3cOutputter = new DOMOutputter();
Document doc = w3cOutputter.output(jdoc);
element = doc.getDocumentElement();
NamedNodeMap attList = element.getAttributes();
for (int i = 0; i < attList.getLength(); i++) {
Node n = element.getAttributes().item(i);
if (n.getTextContent().equals("http://www.w3.org/2001/XMLSchema")) {
element.removeAttributeNode((Attr) n);
}
}
element.setAttribute("targetNamespace", targetNS);
element.setAttribute("xmlns", targetNS);
} catch (org.jdom.JDOMException jdome) {
jdome.printStackTrace();
} catch (org.xml.sax.SAXException saxe) {
saxe.printStackTrace();
} catch (java.io.IOException ioe) {
ioe.printStackTrace();
} catch (java.lang.Exception e) {
e.printStackTrace();
}
UnknownExtensibilityElement extensibilityElement = new UnknownExtensibilityElement();
extensibilityElement.setElement(element);
extensibilityElement.setElementType(new QName(element.getNamespaceURI()));
extensibilityElement.setRequired(Boolean.TRUE);
// System.out.println("EXENSIBILITYELEMENT: "+extensibilityElement);
Types types = def.getTypes();
types = def.createTypes();
types.addExtensibilityElement(extensibilityElement);
def.setTypes(types);
// Schema schema = new SchemaImpl();
// DOMParser domp = new DOMParser();
// try {
// domp.parse("file:/D:/development/xsd/generated.xsd");
// Document doc = domp.getDocument();
// NodeList nodes = doc.getElementsByTagName("xsd:schema");
// for(int i=0; i<nodes.getLength();i++) {
// schema.setElement(doc.getDocumentElement());
// schema.setElementType(new QName(nodes.item(i).getNamespaceURI()));
// schema.setDocumentBaseURI(nodes.item(i).getNamespaceURI());
// types.addExtensibilityElement(schema);
// def.setTypes(types);
// }
// System.out.println("DOC1:"+doc.toString());
// System.out.println("NODES:"+nodes.getLength());
// }
// catch(Exception e) {
// e.printStackTrace();
// }
// //UnknownExtensibilityElement extensibilityElement = new
// UnknownExtensibilityElement();
// // org.jdom.Element jdelem = XMLUtils.convertSchemaToElement(schema);
// // System.out.println("JDOM ELEMENT: "+jdelem.toString());
// http://mail-archives.apache.org/mod_mbox/ws-axis-dev/200406.mbox/%[email protected]%3e
//
// Schema schema = (Schema)
// extensionRegistry.createExtension(javax.wsdl.Types, new
// QName("http://www.w3.org/2001/XMLSchema", "schema"));
// DocumentBuilderFactory factory =
// DocumentBuilderFactory.newInstance();
// DocumentBuilder builder = factory.newDocumentBuilder();
// Document schemaDeclaration = builder.newDocument();
// //... (populate schemaDeclaration with elements and types)
// schema.setDeclaration(schemaDeclaration);
// types.addExtensibilityElement(schema);
// (get-) Operation name
// String operationName = "get";
// for (int i = 0; i < outputParameter.size(); i++) {
// AbstractServiceParameter param = (AbstractServiceParameter) outputParameter
// .get(i);
// operationName += param.getID();
// }
//
// MESSAGES, PARTS
// =================================================================
// description fehlt noch
Service service = def.createService();
// service.setDocumentationElement()
service.setQName(new QName(targetNS, serviceName + "Service"));
SOAPBinding soapBinding =
(SOAPBinding)
extensionRegistry.createExtension(
Binding.class, new QName("http://schemas.xmlsoap.org/wsdl/soap/", "binding"));
soapBinding.setTransportURI("http://schemas.xmlsoap.org/soap/http");
soapBinding.setStyle("rpc");
SOAPBody body =
(SOAPBody)
extensionRegistry.createExtension(
BindingInput.class, new QName("http://schemas.xmlsoap.org/wsdl/soap/", "body"));
body.setUse("literal");
ArrayList<String> listOfStyles = new ArrayList<String>();
listOfStyles.add("http://schemas.xmlsoap.org/soap/encoding/");
body.setEncodingStyles(listOfStyles);
body.setNamespaceURI(targetNS);
Binding binding = def.createBinding();
// == add PortType and Binding to WSDL defintion
PortType portType = def.createPortType();
portType.setQName(new QName(targetNS, serviceName + "PortType"));
// == Binding section
binding.setQName(new QName(targetNS, serviceName + "Binding"));
binding.addExtensibilityElement(soapBinding);
BindingInput binding_input = def.createBindingInput();
// binding_input.setName("BINDING IN");
binding_input.addExtensibilityElement(body);
BindingOutput binding_out = def.createBindingOutput();
// binding_out.setName("BINDING OUT");
binding_out.addExtensibilityElement(body);
Iterator<Entry<String, Vector<AbstractServiceParameter>>> itOps =
mapInputs.entrySet().iterator();
while (itOps.hasNext()) {
Entry<String, Vector<AbstractServiceParameter>> op = itOps.next();
String operationName = op.getKey();
AtomicProcess ap = mapProcesses.get(operationName);
Vector<AbstractServiceParameter> inputParameter = mapInputs.get(operationName);
Vector<AbstractServiceParameter> outputParameter = mapOutputs.get(operationName);
Message request = def.createMessage();
request.setQName(new QName(targetNS, operationName + "Request"));
boolean duplicateInputs = false;
boolean duplicateOutputs = false;
if (ap.hasDuplicateInputParameter()) {
duplicateInputs = true;
}
if (ap.hasDuplicateOutputParameter()) {
duplicateOutputs = true;
}
for (int ipi = 0; ipi < inputParameter.size(); ipi++) {
AbstractServiceParameter param = (AbstractServiceParameter) inputParameter.get(ipi);
Part part = def.createPart();
if (duplicateInputs) {
part.setName(param.getID() + String.valueOf(param.getPos()));
} else {
part.setName(param.getID());
}
System.out.println("SET TYPE OF PART: " + param.toString());
if (param.isPrimitiveXsdType()) {
part.setTypeName(new QName("http://www.w3.org/2001/XMLSchema", param.getTypeLocal()));
} else {
part.setTypeName(new QName(targetNS, param.getTypeRemote()));
}
request.addPart(part);
}
request.setUndefined(false);
def.addMessage(request);
Message response = def.createMessage();
response.setQName(new QName(targetNS, operationName + "Response"));
for (int opi = 0; opi < outputParameter.size(); opi++) {
AbstractServiceParameter param = (AbstractServiceParameter) outputParameter.get(opi);
Part part = def.createPart();
if (duplicateOutputs) {
part.setName(param.getID() + String.valueOf(param.getPos()));
} else {
part.setName(param.getID());
}
System.out.println("SET TYPE OF PART: " + param.toString());
if (param.isPrimitiveXsdType()) {
part.setTypeName(new QName("http://www.w3.org/2001/XMLSchema", param.getTypeLocal()));
} else {
part.setTypeName(new QName(targetNS, param.getTypeRemote()));
}
response.addPart(part);
}
response.setUndefined(false);
def.addMessage(response);
//
// PORTTYPE, OPERATION
//
Input input = def.createInput();
input.setMessage(request);
Output output = def.createOutput();
output.setMessage(response);
// == build the wsdl operation + bindings for each owls output parameter
Operation operation = def.createOperation();
// operation.setName(operationName);
operation.setName(ap.getOperationName());
operation.setInput(input);
operation.setOutput(output);
operation.setUndefined(false);
portType.addOperation(operation);
portType.setUndefined(false);
SOAPOperation soapOperation =
(SOAPOperation)
extensionRegistry.createExtension(
BindingOperation.class,
new QName("http://schemas.xmlsoap.org/wsdl/soap/", "operation"));
soapOperation.setSoapActionURI("");
// soapOperation.setStyle("document");
BindingOperation binding_op = def.createBindingOperation();
// binding_op.setName(operationName);
binding_op.setName(ap.getOperationName());
binding_op.addExtensibilityElement(soapOperation);
binding_op.setOperation(operation);
binding_op.setBindingInput(binding_input);
binding_op.setBindingOutput(binding_out);
binding.addBindingOperation(binding_op);
binding.setPortType(portType);
binding.setUndefined(false);
def.addBinding(binding);
}
def.addPortType(portType);
//
// SERVICE
//
SOAPAddress soapAddress =
(SOAPAddress)
extensionRegistry.createExtension(
Port.class, new QName("http://schemas.xmlsoap.org/wsdl/soap/", "address"));
soapAddress.setLocationURI(targetNS);
Port port = def.createPort();
port.setName(serviceName + "Port");
port.setBinding(binding);
port.addExtensibilityElement(soapAddress);
service.addPort(port);
def.addService(service);
return def;
}
public void printSchema(Definition def, OutputStream out) throws WSDLException {
WSDLWriter writer = WSDLFactory.newInstance().newWSDLWriter();
writer.writeWSDL(def, out);
}
private static WSDLFactory getWsdlFactoryInstance() throws WSDLException {
if (null == wsdlFactoryInstance) {
wsdlFactoryInstance = WSDLFactory.newInstance();
}
return wsdlFactoryInstance;
}
private WSDLCache() throws WSDLException {
cache = new HashMap<String, Definition>();
factory = WSDLFactory.newInstance();
}