Refine search
/** * Return a WSDL definition model for a server. * * @param server the server. * @return the definition. * @throws WSDLException */ public Definition getWSDLDefinition(Server server) throws WSDLException { Service service = server.getEndpoint().getService(); ServiceWSDLBuilder wsdlBuilder = new ServiceWSDLBuilder(bus, service.getServiceInfos().get(0)); wsdlBuilder.setUseSchemaImports(false); return wsdlBuilder.build(); }
protected void buildBindingInput(Definition def, BindingOperation bindingOperation, BindingMessageInfo bindingMessageInfo) { BindingInput bindingInput = null; if (bindingMessageInfo != null) { bindingInput = def.createBindingInput(); addDocumentation(bindingInput, bindingMessageInfo.getDocumentation()); bindingInput.setName(bindingMessageInfo.getMessageInfo().getName().getLocalPart()); bindingOperation.setBindingInput(bindingInput); addExtensibilityAttributes(def, bindingInput, bindingMessageInfo.getExtensionAttributes()); addExtensibilityElements(def, bindingInput, getWSDL11Extensors(bindingMessageInfo)); } }
private void addExtensibilityAttributes(Definition def, AttributeExtensible attributeExtensible, Map<QName, Object> attributes) { if (attributes == null) { return; } for (Map.Entry<QName, Object> entry : attributes.entrySet()) { addNamespace(entry.getKey().getNamespaceURI(), def); attributeExtensible.setExtensionAttribute(entry.getKey(), entry.getValue()); } }
protected void addNamespace(String namespaceURI, Definition def) { addNamespace(getPrefix(namespaceURI), namespaceURI, def); }
protected Definition getDefinition(EndpointInfo endpointInfo) throws WSDLException { return new ServiceWSDLBuilder(bus, endpointInfo.getService()).build(); }
definition = new ServiceWSDLBuilder(getBus(), server.getEndpoint().getService().getServiceInfos() .iterator().next()).build(); EndpointInfo ei = server.getEndpoint().getService().getServiceInfos().iterator().next() .getEndpoints().iterator().next(); if (serviceInfo.getName().equals(service) && getEndpoint() != null && serviceInfo.getEndpoint(new QName(serviceInfo.getName().getNamespaceURI(), getEndpoint())) != null) { ei = serviceInfo.getEndpoint(new QName(serviceInfo.getName().getNamespaceURI(), serviceInfos.add(serInfo); ServiceWSDLBuilder swBuilder = new ServiceWSDLBuilder(getBus(), serviceInfos); opInfo.setProperty(WSDLServiceBuilder.WSDL_OPERATION, null); description = WSDLFactory.newInstance().newWSDLWriter().getDocument(swBuilder.build()); } catch (WSDLException ex) { throw new DeploymentException(ex);
if (!mie.getKey().getNamespaceURI().equals(definition.getTargetNamespace())) { continue; Message message = definition.createMessage(); addDocumentation(message, mie.getValue().getMessageDocumentation()); message.setUndefined(false); message.setQName(mie.getKey()); for (MessagePartInfo mpi : mie.getValue().getMessageParts()) { Part part = definition.createPart(); boolean elemental = mpi.isElement(); part.setTypeName(mpi.getTypeQName()); addDocumentation(definition, serviceInfo.getTopLevelDoc()); Service serv = definition.createService(); addDocumentation(serv, serviceInfo.getDocumentation()); serv.setQName(serviceInfo.getName()); addNamespace(serviceInfo.getName().getNamespaceURI(), definition); addExtensibilityElements(definition, serv, getWSDL11Extensors(serviceInfo)); definition.addService(serv); addNamespace(ei.getTransportId(), definition); Port port = definition.createPort(); addDocumentation(port, ei.getDocumentation()); port.setName(ei.getName().getLocalPart()); port.setBinding(definition.getBinding(ei.getBinding().getName())); addExtensibilityElements(definition, port, getWSDL11Extensors(ei)); serv.addPort(port);
operation = def.createOperation(); addDocumentation(operation, operationInfo.getDocumentation()); operation.setUndefined(false); operation.setName(operationInfo.getName().getLocalPart()); addNamespace(operationInfo.getName().getNamespaceURI(), def); if (operationInfo.isOneWay()) { operation.setStyle(OperationType.ONE_WAY); addExtensibilityElements(def, operation, getWSDL11Extensors(operationInfo)); Input input = def.createInput(); addDocumentation(input, operationInfo.getInput().getDocumentation()); input.setName(operationInfo.getInputName()); Message message = def.createMessage(); buildMessage(message, operationInfo.getInput(), def); this.addExtensibilityAttributes(def, input, getInputExtensionAttributes(operationInfo)); this.addExtensibilityElements(def, input, getWSDL11Extensors(operationInfo.getInput())); input.setMessage(message); operation.setInput(input); addDocumentation(output, operationInfo.getOutput().getDocumentation()); buildMessage(message, operationInfo.getOutput(), def); this.addExtensibilityAttributes(def, output, getOutputExtensionAttributes(operationInfo)); this.addExtensibilityElements(def, output, getWSDL11Extensors(operationInfo.getOutput())); output.setMessage(message); operation.setOutput(output); addDocumentation(fault, faultInfo.getDocumentation()); fault.setName(faultInfo.getFaultName().getLocalPart());
definition = newDefinition(si.getName(), si.getTargetNamespace()); addNamespace(WSDLConstants.CONVENTIONAL_TNS_PREFIX, si.getTargetNamespace(), definition); addExtensibilityElements(definition, definition, getWSDL11Extensors(si.getDescription())); Definition portTypeDef = definition; Definition orig = definition; if (!isSameTNS(service)) { portTypeDef = newDefinition(service.getInterface().getName(), service.getInterface().getName().getNamespaceURI()); Import wsdlImport = definition.createImport(); String tns = service.getInterface().getName().getNamespaceURI(); wsdlImport.setDefinition(portTypeDef); wsdlImport.setNamespaceURI(tns); wsdlImport.setLocationURI(service.getInterface().getName().getLocalPart() + ".wsdl"); definition.addImport(wsdlImport); addNamespace(getPrefix(tns), tns, definition); definition = portTypeDef; portTypes.add(buildPortType(service.getInterface(), portTypeDef)); buildTypes(service.getSchemas(), imports, portTypeDef); } else { buildTypesWithSchemaImports(service.getSchemas(), imports, portTypeDef); buildBinding(definition, service.getBindings(), portTypes); buildService(service, definition);
protected void buildMessage(Message message, AbstractMessageContainer messageContainer, final Definition def) { addDocumentation(message, messageContainer.getMessageDocumentation()); message.setQName(messageContainer.getName()); message.setUndefined(false); def.addMessage(message); List<MessagePartInfo> messageParts = messageContainer.getMessageParts(); Part messagePart = null; for (MessagePartInfo messagePartInfo : messageParts) { messagePart = def.createPart(); messagePart.setName(messagePartInfo.getName().getLocalPart()); if (messagePartInfo.isElement()) { messagePart.setElementName(messagePartInfo.getElementQName()); addNamespace(messagePartInfo.getElementQName().getNamespaceURI(), def); } else if (messagePartInfo.getTypeQName() != null) { messagePart.setTypeName(messagePartInfo.getTypeQName()); addNamespace(messagePartInfo.getTypeQName().getNamespaceURI(), def); } message.addPart(messagePart); } }
protected void buildBinding(Definition definition, Collection<BindingInfo> bindingInfos, Collection<PortType> portTypes) { Binding binding = null; for (BindingInfo bindingInfo : bindingInfos) { binding = definition.createBinding(); addDocumentation(binding, bindingInfo.getDocumentation()); binding.setUndefined(false); for (PortType portType : portTypes) { if (portType.getQName().equals(bindingInfo.getInterface().getName())) { binding.setPortType(portType); break; } } binding.setQName(bindingInfo.getName()); if (!bindingInfo.getName().getNamespaceURI().equals(definition.getTargetNamespace())) { addNamespace(bindingInfo.getName().getNamespaceURI(), definition); } buildBindingOperation(definition, binding, bindingInfo.getOperations()); addExtensibilityElements(definition, binding, getWSDL11Extensors(bindingInfo)); definition.addBinding(binding); } }
protected void buildBindingOutput(Definition def, BindingOperation bindingOperation, BindingMessageInfo bindingMessageInfo) { BindingOutput bindingOutput = null; if (bindingMessageInfo != null) { bindingOutput = def.createBindingOutput(); addDocumentation(bindingOutput, bindingMessageInfo.getDocumentation()); bindingOutput.setName(bindingMessageInfo.getMessageInfo().getName().getLocalPart()); bindingOperation.setBindingOutput(bindingOutput); addExtensibilityAttributes(def, bindingOutput, bindingMessageInfo.getExtensionAttributes()); addExtensibilityElements(def, bindingOutput, getWSDL11Extensors(bindingMessageInfo)); } }
protected void buildBindingOperation(Definition def, Binding binding, Collection<BindingOperationInfo> bindingOperationInfos) { BindingOperation bindingOperation = null; for (BindingOperationInfo bindingOperationInfo : bindingOperationInfos) { bindingOperation = def.createBindingOperation(); addDocumentation(bindingOperation, bindingOperationInfo.getDocumentation()); bindingOperation.setName(bindingOperationInfo.getName().getLocalPart()); for (Operation operation : CastUtils.cast(binding.getPortType().getOperations(), Operation.class)) { if (operation.getName().equals(bindingOperation.getName())) { bindingOperation.setOperation(operation); break; } } buildBindingInput(def, bindingOperation, bindingOperationInfo.getInput()); buildBindingOutput(def, bindingOperation, bindingOperationInfo.getOutput()); buildBindingFault(def, bindingOperation, bindingOperationInfo.getFaults()); addExtensibilityAttributes(def, bindingOperation, bindingOperationInfo.getExtensionAttributes()); addExtensibilityElements(def, bindingOperation, getWSDL11Extensors(bindingOperationInfo)); binding.addBindingOperation(bindingOperation); } }
protected void buildBindingFault(Definition def, BindingOperation bindingOperation, Collection<BindingFaultInfo> bindingFaultInfos) { BindingFault bindingFault = null; for (BindingFaultInfo bindingFaultInfo : bindingFaultInfos) { bindingFault = def.createBindingFault(); addDocumentation(bindingFault, bindingFaultInfo.getDocumentation()); bindingFault.setName(bindingFaultInfo.getFaultInfo().getFaultName().getLocalPart()); bindingOperation.addBindingFault(bindingFault); addExtensibilityAttributes(def, bindingFault, bindingFaultInfo.getExtensionAttributes()); addExtensibilityElements(def, bindingFault, getWSDL11Extensors(bindingFaultInfo)); } }
final Map<String, SchemaInfo> imports, final Definition def) { Types types = def.createTypes(); Schema schema = getSchemaImplementation(def); schema.setRequired(true); schema.setElementType(WSDLConstants.QNAME_SCHEMA); addSchemaImport(schema, schemaInfo, referencedSchema); Document doc = createDocument(); Element nd = XMLUtils.createElementNS(doc, new QName(WSDLConstants.NS_SCHEMA_XSD, "schema")); nd.setAttribute("xmlns", WSDLConstants.NS_SCHEMA_XSD); doc.appendChild(nd); Schema schema = getSchemaImplementation(def); schema.setRequired(true); schema.setElementType(WSDLConstants.QNAME_SCHEMA); Collection<String> defNamespaces = CastUtils.cast(def.getNamespaces().values()); nd.appendChild(impElement); addSchemaImport(schema, schemaInfo, referencedSchema); types.addExtensibilityElement(schema); def.setTypes(types);
if (file == null && dir != null) { if (dir.isDirectory()) { file = new File(dir, getServiceModel().getName().getLocalPart() + ".wsdl"); } else { file = dir; file = new File(getServiceModel().getName().getLocalPart() + ".wsdl"); WSDLWriter wsdlWriter = WSDLFactory.newInstance().newWSDLWriter(); ServiceWSDLBuilder builder = new ServiceWSDLBuilder(getBus(), getServiceModel()); builder.setUseSchemaImports(this.allowImports()); name = name.substring(0, name.lastIndexOf(".wsdl")); builder.setBaseFileName(name); Map<String, SchemaInfo> imports = new HashMap<>(); def = builder.build(imports); wsdlWriter.writeWSDL(def, os); os.close(); if (def.getImports().size() > 0) { for (Import wsdlImport : WSDLDefinitionBuilder.getImports(def)) { Definition wsdlDef = wsdlImport.getDefinition(); wsdlFile = new File(outputdir, wsdlImport.getLocationURI()); } else { wsdlFile = new File(outputdir, wsdlDef.getQName().getLocalPart() + ".wsdl");
/** * Create a wsdl Definition object from the endpoint information and register * it in the local data structure for future reference. * * @param bus CXF's hub for access to internal constructs * @param mp a map of known wsdl Definition objects * @param message * @param smp a map of known xsd SchemaReference objects * @param base the request URL * @param endpointInfo information for a web service 'port' inside of a service * @throws WSDLException */ protected void updateWSDLKeyDefinition(Bus bus, Map<String, Definition> mp, Message message, Map<String, SchemaReference> smp, String base, EndpointInfo endpointInfo) throws WSDLException { if (!mp.containsKey("")) { ServiceWSDLBuilder builder = new ServiceWSDLBuilder(bus, endpointInfo.getService()); builder.setUseSchemaImports( MessageUtils.getContextualBoolean(message, WSDL_CREATE_IMPORTS, false)); // base file name is ignored if createSchemaImports == false! builder.setBaseFileName(endpointInfo.getService().getName().getLocalPart()); Definition def = builder.build(new HashMap<String, SchemaInfo>()); mp.put("", def); updateDefinition(bus, def, mp, smp, base, "", ""); } }
File wsdlFile = getPublishLocation(serviceName.getLocalPart(), deploymentName, wsdlLocation); if (wsdlFile == null) return; createParentDir(wsdlFile); ServiceWSDLBuilder builder = new ServiceWSDLBuilder(bus, serviceInfos); Definition def = builder.build();
protected PortType buildPortType(InterfaceInfo intf, final Definition def) { PortType portType = null; try { portType = intf.getProperty(WSDLServiceBuilder.WSDL_PORTTYPE, PortType.class); } catch (ClassCastException e) { // do nothing } if (portType == null) { portType = def.createPortType(); portType.setQName(intf.getName()); addDocumentation(portType, intf.getDocumentation()); addNamespace(intf.getName().getNamespaceURI(), def); addExtensibilityElements(def, portType, getWSDL11Extensors(intf)); addExtensibilityAttributes(def, portType, intf.getExtensionAttributes()); portType.setUndefined(false); buildPortTypeOperation(portType, intf.getOperations(), def); } def.addPortType(portType); return portType; }
final Map<String, SchemaInfo> imports, final Definition def) { Types types = def.createTypes(); Schema schema = getSchemaImplementation(def); schema.setRequired(true); schema.setElementType(WSDLConstants.QNAME_SCHEMA); addSchemaImport(schema, schemaInfo, referencedSchema); doc.appendChild(nd); Schema schema = getSchemaImplementation(def); schema.setRequired(true); schema.setElementType(WSDLConstants.QNAME_SCHEMA); Collection<String> defNamespaces = CastUtils.cast(def.getNamespaces().values()); nd.appendChild(impElement); addSchemaImport(schema, schemaInfo, referencedSchema); types.addExtensibilityElement(schema); def.setTypes(types);