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;
  }
예제 #2
0
  /**
   * 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());
      }
    }
  }
예제 #3
0
  @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);
  }
예제 #4
0
  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);
  }
예제 #6
0
 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;
 }
예제 #7
0
  @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 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;
  }
예제 #9
0
  /**
   * 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;
  }
예제 #10
0
 public void printSchema(Definition def, OutputStream out) throws WSDLException {
   WSDLWriter writer = WSDLFactory.newInstance().newWSDLWriter();
   writer.writeWSDL(def, out);
 }
예제 #11
0
 private static WSDLFactory getWsdlFactoryInstance() throws WSDLException {
   if (null == wsdlFactoryInstance) {
     wsdlFactoryInstance = WSDLFactory.newInstance();
   }
   return wsdlFactoryInstance;
 }
예제 #12
0
 private WSDLCache() throws WSDLException {
   cache = new HashMap<String, Definition>();
   factory = WSDLFactory.newInstance();
 }