コード例 #1
0
  @Override
  public void writeResponse(
      String baseUri, String ctxUri, EndpointInfo endpointInfo, OutputStream os) {
    try {
      int idx = baseUri.toLowerCase().indexOf("?");
      Map<String, String> params = UrlUtils.parseQueryString(baseUri.substring(idx + 1));

      String base;

      if (endpointInfo.getProperty("publishedEndpointUrl") != null) {
        base = String.valueOf(endpointInfo.getProperty("publishedEndpointUrl"));
      } else {
        base = baseUri.substring(0, baseUri.toLowerCase().indexOf("?"));
      }

      String wsdl = params.get("wsdl");
      if (wsdl != null) {
        // Always use the URL decoded version to ensure that we have a
        // canonical representation of the import URL for lookup.
        wsdl = URLDecoder.decode(wsdl, "utf-8");
      }

      String xsd = params.get("xsd");
      if (xsd != null) {
        // Always use the URL decoded version to ensure that we have a
        // canonical representation of the import URL for lookup.
        xsd = URLDecoder.decode(xsd, "utf-8");
      }

      Map<String, Definition> mp =
          CastUtils.cast(
              (Map) endpointInfo.getService().getProperty(WSDLQueryHandler.class.getName()));
      Map<String, SchemaReference> smp =
          CastUtils.cast(
              (Map)
                  endpointInfo
                      .getService()
                      .getProperty(WSDLQueryHandler.class.getName() + ".Schemas"));

      if (mp == null) {
        endpointInfo
            .getService()
            .setProperty(WSDLQueryHandler.class.getName(), new ConcurrentHashMap());
        mp =
            CastUtils.cast(
                (Map) endpointInfo.getService().getProperty(WSDLQueryHandler.class.getName()));
      }
      if (smp == null) {
        endpointInfo
            .getService()
            .setProperty(WSDLQueryHandler.class.getName() + ".Schemas", new ConcurrentHashMap());
        smp =
            CastUtils.cast(
                (Map)
                    endpointInfo
                        .getService()
                        .getProperty(WSDLQueryHandler.class.getName() + ".Schemas"));
      }

      if (!mp.containsKey("")) {
        Definition def = getDefinition(endpointInfo);

        mp.put("", def);
        updateDefinition(def, mp, smp, base, endpointInfo);
      }

      Document doc;
      if (xsd == null) {
        Definition def = mp.get(wsdl);
        if (def == null) {
          String wsdl2 =
              resolveWithCatalogs(OASISCatalogManager.getCatalogManager(bus), wsdl, base);
          if (wsdl2 != null) {
            def = mp.get(wsdl2);
          }
        }
        if (def == null) {
          throw new WSDLQueryException(
              new org.apache.cxf.common.i18n.Message("WSDL_NOT_FOUND", LOG, wsdl), null);
        }

        synchronized (def) {
          // writing a def is not threadsafe.  Sync on it to make sure
          // we don't get any ConcurrentModificationExceptions
          if (endpointInfo.getProperty("publishedEndpointUrl") != null) {
            String publishingUrl = String.valueOf(endpointInfo.getProperty("publishedEndpointUrl"));
            updatePublishedEndpointUrl(publishingUrl, def, endpointInfo.getName());
          }

          WSDLWriter wsdlWriter =
              bus.getExtension(WSDLManager.class).getWSDLFactory().newWSDLWriter();
          def.setExtensionRegistry(bus.getExtension(WSDLManager.class).getExtensionRegistry());
          doc = wsdlWriter.getDocument(def);
        }
      } else {
        SchemaReference si = smp.get(xsd);
        if (si == null) {
          String xsd2 = resolveWithCatalogs(OASISCatalogManager.getCatalogManager(bus), xsd, base);
          if (xsd2 != null) {
            si = smp.get(xsd2);
          }
        }
        if (si == null) {
          throw new WSDLQueryException(
              new org.apache.cxf.common.i18n.Message("SCHEMA_NOT_FOUND", LOG, wsdl), null);
        }

        String uri = si.getReferencedSchema().getDocumentBaseURI();
        uri =
            resolveWithCatalogs(
                OASISCatalogManager.getCatalogManager(bus),
                uri,
                si.getReferencedSchema().getDocumentBaseURI());
        if (uri == null) {
          uri = si.getReferencedSchema().getDocumentBaseURI();
        }
        ResourceManagerWSDLLocator rml = new ResourceManagerWSDLLocator(uri, bus);

        InputSource src = rml.getBaseInputSource();
        doc = XMLUtils.getParser().parse(src);
      }

      updateDoc(doc, base, mp, smp, endpointInfo);
      String enc = null;
      try {
        enc = doc.getXmlEncoding();
      } catch (Exception ex) {
        // ignore - not dom level 3
      }
      if (enc == null) {
        enc = "utf-8";
      }

      XMLStreamWriter writer = StaxUtils.createXMLStreamWriter(os, enc);
      StaxUtils.writeNode(doc, writer, true);
      writer.flush();
    } catch (WSDLQueryException wex) {
      throw wex;
    } catch (Exception wex) {
      throw new WSDLQueryException(
          new org.apache.cxf.common.i18n.Message("COULD_NOT_PROVIDE_WSDL", LOG, baseUri), wex);
    }
  }
コード例 #2
0
  protected void updateSchemaImports(
      Schema schema, Map<String, SchemaReference> doneSchemas, String base) {
    OASISCatalogManager catalogs = OASISCatalogManager.getCatalogManager(bus);
    Collection<List<?>> imports = CastUtils.cast((Collection<?>) schema.getImports().values());
    for (List<?> lst : imports) {
      List<SchemaImport> impLst = CastUtils.cast(lst);
      for (SchemaImport imp : impLst) {
        String start = imp.getSchemaLocationURI();

        if (start != null) {
          String decodedStart = null;
          // Always use the URL decoded version to ensure that we have a
          // canonical representation of the import URL for lookup.
          try {
            decodedStart = URLDecoder.decode(start, "utf-8");
          } catch (UnsupportedEncodingException e) {
            throw new WSDLQueryException(
                new org.apache.cxf.common.i18n.Message("COULD_NOT_PROVIDE_WSDL", LOG, start), e);
          }

          if (!doneSchemas.containsKey(decodedStart)) {
            String resolvedSchemaLocation = resolveWithCatalogs(catalogs, start, base);
            if (resolvedSchemaLocation == null) {
              try {
                checkSchemaUrl(doneSchemas, start, decodedStart, imp);
              } catch (MalformedURLException e) {
                if (doneSchemas.put(decodedStart, imp) == null) {
                  updateSchemaImports(imp.getReferencedSchema(), doneSchemas, base);
                }
              }
            } else {
              if (doneSchemas.put(decodedStart, imp) == null) {
                doneSchemas.put(resolvedSchemaLocation, imp);
                updateSchemaImports(imp.getReferencedSchema(), doneSchemas, base);
              }
            }
          }
        }
      }
    }

    List<SchemaReference> includes = CastUtils.cast(schema.getIncludes());
    for (SchemaReference included : includes) {
      String start = included.getSchemaLocationURI();

      if (start != null) {
        String decodedStart = null;
        // Always use the URL decoded version to ensure that we have a
        // canonical representation of the import URL for lookup.
        try {
          decodedStart = URLDecoder.decode(start, "utf-8");
        } catch (UnsupportedEncodingException e) {
          /*throw new WSDLQueryException(new org.apache.cxf.common.i18n.Message("COULD_NOT_PROVIDE_WSDL",
          LOG,
          start), e); */
        }

        String resolvedSchemaLocation = resolveWithCatalogs(catalogs, start, base);
        if (resolvedSchemaLocation == null) {
          if (!doneSchemas.containsKey(decodedStart)) {
            try {
              checkSchemaUrl(doneSchemas, start, decodedStart, included);
            } catch (MalformedURLException e) {
              if (doneSchemas.put(decodedStart, included) == null) {
                updateSchemaImports(included.getReferencedSchema(), doneSchemas, base);
              }
            }
          }
        } else if (!doneSchemas.containsKey(decodedStart)
            || !doneSchemas.containsKey(resolvedSchemaLocation)) {
          doneSchemas.put(decodedStart, included);
          doneSchemas.put(resolvedSchemaLocation, included);
          updateSchemaImports(included.getReferencedSchema(), doneSchemas, base);
        }
      }
    }
    List<SchemaReference> redefines = CastUtils.cast(schema.getRedefines());
    for (SchemaReference included : redefines) {
      String start = included.getSchemaLocationURI();

      if (start != null) {
        String decodedStart = null;
        // Always use the URL decoded version to ensure that we have a
        // canonical representation of the import URL for lookup.
        try {
          decodedStart = URLDecoder.decode(start, "utf-8");
        } catch (UnsupportedEncodingException e) {
          throw new WSDLQueryException(
              new org.apache.cxf.common.i18n.Message("COULD_NOT_PROVIDE_WSDL", LOG, start), e);
        }

        String resolvedSchemaLocation = resolveWithCatalogs(catalogs, start, base);
        if (resolvedSchemaLocation == null) {
          if (!doneSchemas.containsKey(decodedStart)) {
            try {
              checkSchemaUrl(doneSchemas, start, decodedStart, included);
            } catch (MalformedURLException e) {
              if (doneSchemas.put(decodedStart, included) == null) {
                updateSchemaImports(included.getReferencedSchema(), doneSchemas, base);
              }
            }
          }
        } else if (!doneSchemas.containsKey(decodedStart)
            || !doneSchemas.containsKey(resolvedSchemaLocation)) {
          doneSchemas.put(decodedStart, included);
          doneSchemas.put(resolvedSchemaLocation, included);
          updateSchemaImports(included.getReferencedSchema(), doneSchemas, base);
        }
      }
    }
  }