Java tutorial
/******************************************************************************* * Copyright (c) 2006-2010 eBay Inc. All Rights Reserved. * 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 *******************************************************************************/ package org.ebayopensource.turmeric.eclipse.resources.util; import java.io.File; import java.io.FileInputStream; import java.io.FileWriter; import java.io.IOException; import java.io.InputStream; import java.net.MalformedURLException; import java.net.URL; import java.util.Arrays; import java.util.Properties; import java.util.jar.JarFile; import javax.wsdl.Definition; import javax.wsdl.Service; import javax.wsdl.WSDLException; import org.apache.commons.io.IOUtils; import org.apache.commons.lang.StringUtils; import org.apache.xerces.parsers.DOMParser; import org.ebayopensource.turmeric.eclipse.core.logging.SOALogger; import org.ebayopensource.turmeric.eclipse.core.resources.constants.SOAProjectConstants; import org.ebayopensource.turmeric.eclipse.resources.model.SOAIntfMetadata; import org.ebayopensource.turmeric.eclipse.resources.model.SOAIntfProject; import org.ebayopensource.turmeric.eclipse.utils.io.IOUtil; import org.ebayopensource.turmeric.eclipse.utils.io.PropertiesFileUtil; import org.ebayopensource.turmeric.eclipse.utils.lang.StringUtil; import org.ebayopensource.turmeric.eclipse.utils.plugin.WorkspaceUtil; import org.ebayopensource.turmeric.eclipse.utils.wsdl.WSDLUtil; import org.ebayopensource.turmeric.eclipse.utils.xml.XMLUtil; import org.eclipse.core.resources.IFile; import org.eclipse.core.resources.IProject; import org.eclipse.core.resources.IResource; import org.eclipse.core.resources.IncrementalProjectBuilder; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.IPath; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.core.runtime.Path; import org.osgi.framework.Version; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.w3c.dom.Node; import org.w3c.dom.Text; import org.xml.sax.InputSource; /** * The Class SOAIntfUtil. * * @author smathew */ public class SOAIntfUtil { private static final SOALogger logger = SOALogger.getLogger(); /** * This function returns the version of the service metadata. * For pre 2.4 services, the version would be 1.0.0. * For post 2.4 services, the logic would be the following: * 1) For services available in the workspace, * it would firstly look into the service_intf_project.properties for key sipp_version * 2) For services only available in the underlying repo system as a jar, * then check service_metadata.properties for key smpp_version * * @param assetName the asset name * @param assetLocation the asset location * @return the service metadata version * @throws Exception the exception */ public static Version getServiceMetadataVersion(String assetName, String assetLocation) throws Exception { final SOAIntfMetadata metadata = SOAIntfUtil.loadIntfMetadata(assetLocation, assetName); try { return new Version(metadata.getMetadataVersion()); } catch (RuntimeException e) { logger.warning("Invalid service metadata version number->", metadata.getMetadataVersion(), ". Use the default version instead->", SOAProjectConstants.DEFAULT_VERSION); } return new Version(SOAProjectConstants.DEFAULT_VERSION); } /** * Gets the service version from wsdl. * * @param wsdl the wsdl * @param publicServiceName the public service name * @return the service version from wsdl */ public static String getServiceVersionFromWsdl(Definition wsdl, String publicServiceName) { if (wsdl == null) { return ""; } for (Object obj : wsdl.getServices().values()) { final Service service = (Service) obj; if (service.getQName().getLocalPart().equals(publicServiceName)) { if (service.getDocumentationElement() != null) { final Element elem = service.getDocumentationElement(); for (int i = 0; i < elem.getChildNodes().getLength(); i++) { Node node = elem.getChildNodes().item(i); if (node.getNodeType() == Node.ELEMENT_NODE && (node.getLocalName().equals(ELEM_NAME_VERSION_V2_CAMEL_CASE) || node.getLocalName().equals(ELEM_NAME_VERSION_V3_CAMEL_CASE))) { if (node.hasChildNodes()) { return node.getFirstChild().getNodeValue(); } } } } } } return ""; } /** * Load metadata props. * * @param assetLocation the asset location * @param serviceName the service name * @return the properties * @throws Exception the exception */ public static Properties loadMetadataProps(String assetLocation, final String serviceName) throws Exception { if (SOALogger.DEBUG) logger.entering(assetLocation, serviceName); Properties props = null; if (assetLocation != null && serviceName != null) { if (assetLocation.endsWith(SOAProjectConstants.JAR_EXT)) { final JarFile file = new JarFile(assetLocation); logger.info("loading service_metadata.properties from the service jar->", assetLocation); props = loadMetadataProps(new JarFile[] { file }, serviceName); } else { IPath path = new Path(assetLocation); props = loadMetadataProps(path, serviceName); } } if (SOALogger.DEBUG) logger.exiting(props); return props; } /** * Load intf metadata. * * @param assetLocation the asset location * @param serviceName the service name * @return the sOA intf metadata * @throws Exception the exception */ public static SOAIntfMetadata loadIntfMetadata(final String assetLocation, final String serviceName) throws Exception { if (SOALogger.DEBUG) logger.entering(assetLocation, serviceName); SOAIntfMetadata result = null; if (assetLocation != null && serviceName != null) { Properties props = loadMetadataProps(assetLocation, serviceName); if (props != null) { final SOAIntfMetadata intfMetadata = getMetadataFromProperties(props, null); final Definition wsdl = getWSDLUrlFromIntfProject(serviceName, assetLocation); if (wsdl != null) { setInformationFromWsdl(wsdl, intfMetadata); } else { throw new IllegalArgumentException("Unable to find WSDL file for service->" + serviceName); } result = intfMetadata; } } if (SOALogger.DEBUG) logger.exiting(result); return result; } /** * Load metadata props. * * @param zipFiles the zip files * @param serviceName the service name * @return the properties * @throws IOException Signals that an I/O exception has occurred. * @throws CoreException the core exception */ public static Properties loadMetadataProps(final JarFile zipFiles[], String serviceName) throws IOException, CoreException { if (SOALogger.DEBUG) logger.entering(Arrays.asList(zipFiles), serviceName); Properties properties = null; for (JarFile zipFile : zipFiles) { try { serviceName = StringUtils.isEmpty(serviceName) ? zipFile.getName() : serviceName; final String jarEntryPath = SOAProjectConstants.METADATA_PROPS_LOCATION_JAR + serviceName + WorkspaceUtil.PATH_SEPERATOR + SOAProjectConstants.PROPS_FILE_SERVICE_METADATA; properties = IOUtil.loadProperties(zipFile, jarEntryPath); // a project can have many jar files and we never // know which one has the props file if (properties != null) break; } catch (Exception e) { // This exception is swallowed... One jar not having it doesnt // mean failure } } if (SOALogger.DEBUG) logger.exiting(properties); return properties; } /** * Load metadata props. * * @param project the project * @param serviceName the service name * @return the properties * @throws IOException Signals that an I/O exception has occurred. * @throws CoreException the core exception */ public static Properties loadMetadataProps(final IProject project, final String serviceName) throws IOException, CoreException { if (SOALogger.DEBUG) logger.entering(project, serviceName); final IFile file = getMetadataFile(project, serviceName != null ? serviceName : project.getName()); Properties result = null; if (file.isAccessible()) result = WorkspaceUtil.loadProperties(file); Properties intfProps = loadIntfProjectPropFile(project); if (intfProps != null) { //values stored in the SIPP file would have higher priority if (result == null) result = intfProps; else { result.putAll(intfProps); } } if (SOALogger.DEBUG) logger.exiting(result); return result; } /** * Save metadata props. * * @param oldProperties the old properties * @param newProperties the new properties * @param intfProject the intf project * @return true, if successful * @throws IOException Signals that an I/O exception has occurred. * @throws CoreException the core exception */ public static boolean saveMetadataProps(Properties oldProperties, Properties newProperties, SOAIntfProject intfProject) throws IOException, CoreException { if (SOALogger.DEBUG) logger.entering(oldProperties, newProperties, intfProject); boolean result = false; if (!PropertiesFileUtil.isEqual(oldProperties, newProperties)) { PropertiesFileUtil.writeToFile(newProperties, getMetadataFile(intfProject), SOAProjectConstants.PROPS_COMMENTS); result = true; } if (SOALogger.DEBUG) logger.exiting(result); return result; } /** * Save metadata props. * * @param newProperties the new properties * @param intfProject the intf project * @throws IOException Signals that an I/O exception has occurred. * @throws CoreException the core exception */ public static void saveMetadataProps(Properties newProperties, SOAIntfProject intfProject) throws IOException, CoreException { if (SOALogger.DEBUG) logger.entering(newProperties, intfProject); PropertiesFileUtil.writeToFile(newProperties, getMetadataFile(intfProject), SOAProjectConstants.PROPS_COMMENTS); if (SOALogger.DEBUG) logger.exiting(); } /** * Save metadata props. * * @param newProperties the new properties * @param intfProject the intf project * @throws IOException Signals that an I/O exception has occurred. * @throws CoreException the core exception */ public static void saveMetadataProps(Properties newProperties, IProject intfProject) throws IOException, CoreException { if (SOALogger.DEBUG) logger.entering(newProperties, intfProject); PropertiesFileUtil.writeToFile(newProperties, getMetadataFile(intfProject, intfProject.getName()), SOAProjectConstants.PROPS_COMMENTS); if (SOALogger.DEBUG) logger.exiting(); } /** * This is only supposed to be used for modifying service layers and version. <<<<<<< HEAD * * @param intfProject the intf project * @param monitor the monitor * @throws IOException Signals that an I/O exception has occurred. * @throws CoreException the core exception ======= * @param intfProject * @throws IOException * @throws CoreException >>>>>>> TURMERIC-1351 */ public static void saveMetadataProps(SOAIntfProject intfProject, IProgressMonitor monitor) throws IOException, CoreException { if (SOALogger.DEBUG) logger.entering(intfProject); final SOAIntfMetadata intfMetadata = intfProject.getMetadata(); final IProject project = intfProject.getProject(); final IFile oldMetadataFile = getOldMetadataFile(project, intfMetadata.getServiceName()); IFile metadataFile = null; Properties props = null; if (oldMetadataFile.exists() == true) { //pre 2.4 projects metadataFile = oldMetadataFile; props = loadMetadataProps(project, intfMetadata.getServiceName()); } else { metadataFile = getIntfProjectPropFile(project); props = loadIntfProjectPropFile(project); } props.setProperty(SOAProjectConstants.SERVICE_METADATA_PROPS_SERVICE_LAYER, intfMetadata.getServiceLayer()); props.setProperty(SOAProjectConstants.SERVICE_METADATA_PROPS_SERVICE_VERSION, intfMetadata.getServiceVersion()); PropertiesFileUtil.writeToFile(props, metadataFile, SOAProjectConstants.PROPS_COMMENTS); if (oldMetadataFile.exists() == false) { //post 2.4 projects project.build(IncrementalProjectBuilder.CLEAN_BUILD, monitor); } if (SOALogger.DEBUG) logger.exiting(); } /** * Get the IFile instance of the <<<<<<< HEAD * [PROJECT]/gen-meta-src/META-INF/soa/common/config/[SERVICE_NAME]/service_metadata.properties. * * @param project the project * @param serviceName The interface project name or the service name * @return the new metadata file ======= * [PROJECT]/gen-meta-src/META-INF/soa/common/config/[SERVICE_NAME]/service_metadata.properties * * @param project * @param serviceName * The interface project name or the service name * @return >>>>>>> TURMERIC-1351 */ public static IFile getNewMetadataFile(final IProject project, final String serviceName) { return getMetadataFile(project, SOAIntfProject.GEN_META_SRC_COMMON_CONFIG, serviceName); } /** * return the instance of the service_metadata.properties file. For old project * structure it would call getOldMetadataFile(), otherwise it would invoke * getNewMetadataFile(); * * @param project the project * @param serviceName the service name * @return the metadata file */ public static IFile getMetadataFile(final IProject project, final String serviceName) { final IFile metadataFile = getOldMetadataFile(project, serviceName); if (metadataFile.exists() == true) return metadataFile; else return getNewMetadataFile(project, serviceName); } private static IFile getMetadataFile(final IProject project, final String root, final String serviceName) { return project.getFile(StringUtil.toString(root, WorkspaceUtil.PATH_SEPERATOR, serviceName, WorkspaceUtil.PATH_SEPERATOR, SOAProjectConstants.PROPS_FILE_SERVICE_METADATA)); } /** * Get the IFile instance of the * [PROJECT]/meta-src/META-INF/soa/common/config/[SERVICE_NAME]/service_metadata.properties. * * @param project the project * @param serviceName The interface project name or the service name * @return the old metadata file */ public static IFile getOldMetadataFile(final IProject project, final String serviceName) { return getMetadataFile(project, SOAIntfProject.META_SRC_COMMON_CONFIG, serviceName); } /** * Gets the type mappings file. * * @param project the project * @param serviceName the service name * @return the type mappings file */ public static IFile getTypeMappingsFile(final IProject project, final String serviceName) { return project.getFile( StringUtil.toString(SOAIntfProject.GEN_META_SRC_COMMON_CONFIG, WorkspaceUtil.PATH_SEPERATOR, serviceName, WorkspaceUtil.PATH_SEPERATOR, SOAProjectConstants.FILE_TYPE_MAPPINGS)); } /** * Gets the metadata file. * * @param intfProject the intf project * @return the metadata file */ public static IFile getMetadataFile(SOAIntfProject intfProject) { IProject project = intfProject.getEclipseMetadata().getProject(); return getMetadataFile(project, intfProject.getMetadata().getServiceName()); } /** * Gets the intf project prop file. * * @param project the project * @return the intf project prop file */ public static IFile getIntfProjectPropFile(final IProject project) { return project.getFile(SOAProjectConstants.PROPS_FILE_SERVICE_INTERFACE); } public static IFile getIntfProtoBufFile(final IProject project) { String protoBufPath = getIntfProtoBufFilePath(project.getName()); return project.getFile(protoBufPath); } public static String getIntfProtoBufFilePath(String adminName) { return SOAProjectConstants.FOLDER_META_SRC + "/" + SOAProjectConstants.META_PROTO_BUF + "/" + adminName + "/" + adminName + ".proto"; } /** * Load intf project prop file. * * @param project the project * @return the properties * @throws CoreException the core exception * @throws IOException Signals that an I/O exception has occurred. */ public static Properties loadIntfProjectPropFile(final IProject project) throws CoreException, IOException { final Properties properties = new Properties(); final IFile file = getIntfProjectPropFile(project); if (file.isAccessible() == false) { logger.warning("The interface project's property file[", file.getLocation(), "] is not accessible"); return properties; } InputStream io = null; try { io = file.getContents(); properties.load(io); } finally { IOUtils.closeQuietly(io); } return properties; } /** * Sets the information from wsdl. * * @param wsdlLocation the wsdl location * @param metadata the metadata * @throws WSDLException the wSDL exception */ public static void setInformationFromWsdl(final URL wsdlLocation, final SOAIntfMetadata metadata) throws WSDLException { if (wsdlLocation != null) { setInformationFromWsdl(wsdlLocation.toString(), metadata); } } /** * Sets the information from wsdl. * * @param documentBaseURI the document base uri * @param wsdlStream the wsdl stream * @param metadata the metadata * @throws WSDLException the wSDL exception */ public static void setInformationFromWsdl(final String documentBaseURI, final InputStream wsdlStream, final SOAIntfMetadata metadata) throws WSDLException { try { if (SOALogger.DEBUG) logger.entering(documentBaseURI, wsdlStream, metadata); if (wsdlStream != null) { final Definition wsdl = WSDLUtil.readWSDL(documentBaseURI, wsdlStream); setInformationFromWsdl(wsdl, metadata); } } finally { IOUtils.closeQuietly(wsdlStream); if (SOALogger.DEBUG) logger.exiting(); } } /** * Sets the information from wsdl. * * @param wsdlLocation the wsdl location * @param metadata the metadata * @throws WSDLException the wSDL exception */ public static void setInformationFromWsdl(final String wsdlLocation, final SOAIntfMetadata metadata) throws WSDLException { if (SOALogger.DEBUG) logger.entering(wsdlLocation, metadata); if (StringUtils.isNotBlank(wsdlLocation)) { final Definition wsdl = WSDLUtil.readWSDL(wsdlLocation); setInformationFromWsdl(wsdl, metadata); } if (SOALogger.DEBUG) logger.exiting(); } /** * Sets the information from wsdl. * * @param wsdl the wsdl * @param metadata the metadata * @throws WSDLException the wSDL exception */ public static void setInformationFromWsdl(final Definition wsdl, final SOAIntfMetadata metadata) throws WSDLException { if (SOALogger.DEBUG) logger.entering(wsdl, metadata); if (wsdl != null && metadata != null) { if (metadata.getPublicServiceName() == null) metadata.setPublicServiceName(WSDLUtil.getServiceNameFromWSDL(wsdl)); if (metadata.getTargetNamespace() == null) metadata.setTargetNamespace(WSDLUtil.getTargetNamespace(wsdl)); metadata.setServiceLocation(WSDLUtil.getServiceLocationFromWSDL(wsdl)); } if (SOALogger.DEBUG) logger.exiting(); } /** * load the metadata from * [PROJECT]/meta-src/META-INF/soa/common/config/[SERVICE_NAME]/service_metadata.properties. * * @param project the project * @param metadata the metadata * @throws IOException Signals that an I/O exception has occurred. * @throws CoreException the core exception * @throws WSDLException the wSDL exception */ public static void fillMetadata(final IProject project, final SOAIntfMetadata metadata) throws IOException, CoreException, WSDLException { if (SOALogger.DEBUG) logger.entering(project, metadata); final Properties properties = loadMetadataProps(project, metadata.getServiceName()); if (properties != null) { getMetadataFromProperties(properties, metadata); if (SOAProjectConstants.InterfaceSourceType.WSDL.equals(metadata.getSourceType())) { final IFile wsdlFile = SOAServiceUtil.getWsdlFile(project, project.getName()); if (wsdlFile != null) setInformationFromWsdl(wsdlFile.getLocation().toString(), wsdlFile.getContents(), metadata); } } if (SOALogger.DEBUG) logger.exiting(); } /** * Gets the metadata from properties. * * @param properties the properties * @param metadata the metadata * @return the metadata from properties * @throws MalformedURLException the malformed url exception */ public static SOAIntfMetadata getMetadataFromProperties(final Properties properties, SOAIntfMetadata metadata) throws MalformedURLException { if (SOALogger.DEBUG) logger.entering(properties, metadata); if (metadata == null) { metadata = SOAIntfMetadata.create(SOAProjectConstants.InterfaceSourceType.WSDL); } String adminName = properties.containsKey(SOAProjectConstants.PROP_KEY_ADMIN_NAME) ? properties.getProperty(SOAProjectConstants.PROP_KEY_ADMIN_NAME) : properties.getProperty(SOAProjectConstants.PROP_KEY_SERVICE_NAME); adminName = StringUtils.trim(adminName); metadata.setServiceName(adminName); metadata.setPublicServiceName( StringUtils.trim(properties.getProperty(SOAProjectConstants.PROP_KEY_SERVICE_NAME))); if (StringUtils.isBlank(metadata.getServiceInterface())) { metadata.setServiceInterface(StringUtils.trim(properties .getProperty(SOAProjectConstants.SERVICE_METADATA_PROPS_SERVICE_INTERFACE_CLASS_NAME))); } if (StringUtils.isBlank(metadata.getServiceLayer())) { metadata.setServiceLayer(StringUtils .trim(properties.getProperty(SOAProjectConstants.SERVICE_METADATA_PROPS_SERVICE_LAYER))); } if (StringUtils.isBlank(metadata.getServiceVersion())) { metadata.setServiceVersion(StringUtils .trim(properties.getProperty(SOAProjectConstants.SERVICE_METADATA_PROPS_SERVICE_VERSION))); } if (properties.containsKey(SOAProjectConstants.PROPS_KEY_SIPP_VERSION)) { metadata.setMetadataVersion( StringUtils.trim(properties.getProperty(SOAProjectConstants.PROPS_KEY_SIPP_VERSION))); } else if (properties.containsKey(SOAProjectConstants.PROPS_KEY_SMP_VERSION)) { metadata.setMetadataVersion( StringUtils.trim(properties.getProperty(SOAProjectConstants.PROPS_KEY_SMP_VERSION))); } if (properties.containsKey(SOAProjectConstants.PROPS_SERVICE_NAMESPACE_PART)) { metadata.setServiceNamespacePart( StringUtils.trim(properties.getProperty(SOAProjectConstants.PROPS_SERVICE_NAMESPACE_PART))); } if (properties.containsKey(SOAProjectConstants.PROPS_SERVICE_DOMAIN_NAME)) { metadata.setServiceDomainName( StringUtils.trim(properties.getProperty(SOAProjectConstants.PROPS_SERVICE_DOMAIN_NAME))); } if (properties.containsKey(SOAProjectConstants.PROP_KEY_NON_XSD_FORMATS)) { metadata.setServiceNonXSDProtocols( StringUtils.trim(properties.getProperty(SOAProjectConstants.PROP_KEY_NON_XSD_FORMATS))); } if (properties.containsKey(SOAProjectConstants.PROPS_SUPPORT_ZERO_CONFIG)) { metadata.setZeroConfig(Boolean.valueOf( StringUtils.trim(properties.getProperty(SOAProjectConstants.PROPS_SUPPORT_ZERO_CONFIG)))); } final String wsdlUrl = StringUtils .trim(properties.getProperty(SOAProjectConstants.PROP_KEY_ORIGINAL_WSDL_URI)); if (WSDLUtil.isValidURL(wsdlUrl)) { metadata.setOriginalWSDLUrl(new URL(wsdlUrl)); } else { metadata.setSourceType(SOAProjectConstants.InterfaceSourceType.JAVA); } if (SOALogger.DEBUG) logger.exiting(metadata); return metadata; } /** * load the service_metadata.properties from the correct location: * 1) if file exists in meta-src folder, then it is using old dir structure * 2) if file exists in gen-meta-src folder, then it is using the new dir structure and it is already been generated * 3) if file does not exist in the previous two locations, then it should be using new dir but file not generated yet. * Read it from service_interface_project.properties file. * * @param projectDir the project dir * @param serviceName the service name * @return the properties * @throws IOException Signals that an I/O exception has occurred. */ public static Properties loadMetadataProps(final IPath projectDir, final String serviceName) throws IOException { if (SOALogger.DEBUG) logger.entering(projectDir, serviceName); final String pathSuffix = serviceName + WorkspaceUtil.PATH_SEPERATOR + SOAProjectConstants.PROPS_FILE_SERVICE_METADATA; File metadataFile = null; final IPath root = (IPath) projectDir.clone(); final IPath serviceMetadataPath = root.append(SOAIntfProject.META_SRC_COMMON_CONFIG).append(pathSuffix); final IPath serviceGenMetadataPath = root.append(SOAIntfProject.GEN_META_SRC_COMMON_CONFIG) .append(pathSuffix); if (serviceMetadataPath.makeAbsolute().toFile().exists()) { //the smp file exists in the meta-src folder metadataFile = serviceMetadataPath.makeAbsolute().toFile(); logger.info("Loading service metadata from the old dir structure->", metadataFile); } else if (serviceGenMetadataPath.makeAbsolute().toFile().exists()) { //the smp file already been generated metadataFile = serviceGenMetadataPath.makeAbsolute().toFile(); logger.info("Loading service metadata from the new dir structure->", metadataFile); } else { //the smp file not generated yet metadataFile = projectDir.append(SOAProjectConstants.PROPS_FILE_SERVICE_INTERFACE).makeAbsolute() .toFile(); logger.info("Loading service metadata from the service_intf_project.propperties->", metadataFile); } Properties result = null; if (metadataFile.exists() && metadataFile.canRead()) { result = new Properties(); InputStream in = null; try { //TODO decode the white spaces: %20 in = new FileInputStream(metadataFile); result.load(in); } finally { IOUtils.closeQuietly(in); } } if (SOALogger.DEBUG) logger.exiting(result); return result; } /** * Gets the wSDL url from intf project. * * @param serviceName the service name * @param requiredServiceProjectPath the required service project path * @return the wSDL url from intf project * @throws Exception the exception */ public static Definition getWSDLUrlFromIntfProject(final String serviceName, String requiredServiceProjectPath) throws Exception { final IProject project = WorkspaceUtil.getProject(serviceName); return getWSDLUrlFromProject(project, requiredServiceProjectPath, serviceName); } private static final String ELEM_NAME_SERVICE = "service"; private static final String ELEM_NAME_DOCUMENTATION = "documentation"; private static final String ELEM_NAME_VERSION_V2_CAMEL_CASE = "Version"; private static final String ELEM_NAME_VERSION_V3_CAMEL_CASE = "version"; /** * The format should be the following * <wsdl:service name="CreativeService"> * <wsdl:documentation> * <version>1.0</version> * </wsdl:documentation> * ... * * @param project the project * @param newVersion the new version * @param monitor the monitor * @throws Exception the exception */ public static void modifyWsdlAppInfoVersion(final IProject project, final String newVersion, IProgressMonitor monitor) throws Exception { monitor.setTaskName("Modifying service WSDL..."); final String serviceName = project.getName(); final IFile wsdlFile = SOAServiceUtil.getWsdlFile(project, serviceName); InputStream ins = null; Definition wsdl = null; try { ins = wsdlFile.getContents(); wsdl = WSDLUtil.readWSDL(ins); } finally { IOUtils.closeQuietly(ins); } monitor.worked(10); if (wsdl == null) return; DOMParser domParser = new DOMParser(); Document doc = null; try { ins = wsdlFile.getContents(); domParser.parse(new InputSource(ins)); doc = domParser.getDocument(); } finally { IOUtils.closeQuietly(ins); } monitor.worked(10); if (doc == null) return; Node wsdlNode = doc.getFirstChild(); Node serviceNode = null; for (int i = wsdlNode.getChildNodes().getLength() - 1; i >= 0; i--) { Node node = wsdlNode.getChildNodes().item(i); if (node.getNodeType() == Node.ELEMENT_NODE && ELEM_NAME_SERVICE.equals(node.getLocalName())) { serviceNode = node; break; } } monitor.worked(10); if (serviceNode == null) return; Node documentationNode = null; for (int i = 0; i < serviceNode.getChildNodes().getLength(); i++) { Node node = serviceNode.getChildNodes().item(i); if (ELEM_NAME_DOCUMENTATION.equals(node.getLocalName())) { documentationNode = node; } } monitor.worked(10); boolean needUpdateWsdl = false; if (documentationNode != null) { //we found the documentation node Node verNode = null; for (int i = 0; i < documentationNode.getChildNodes().getLength(); i++) { Node node = documentationNode.getChildNodes().item(i); if (ELEM_NAME_VERSION_V2_CAMEL_CASE.equals(node.getLocalName()) || ELEM_NAME_VERSION_V3_CAMEL_CASE.equals(node.getLocalName())) { verNode = node; break; } } if (verNode == null) { // add version node to document node if there is no version // node. Element v3Version = doc.createElement("version"); Text versionText = doc.createTextNode(newVersion); v3Version.appendChild(versionText); documentationNode.appendChild(v3Version); needUpdateWsdl = true; } else { if (ELEM_NAME_VERSION_V2_CAMEL_CASE.equals(verNode.getLocalName())) { // if current version node is V2 format, replace it with V3 // format Element v3Version = doc.createElement("version"); Text versionText = doc.createTextNode(newVersion); v3Version.appendChild(versionText); documentationNode.replaceChild(v3Version, verNode); needUpdateWsdl = true; } else { // current version format is V3, update version value. for (int i = 0; i < verNode.getChildNodes().getLength(); i++) { Node node = verNode.getChildNodes().item(i); if (node.getNodeType() == Node.TEXT_NODE && newVersion.equals(node.getNodeValue()) == false) { logger.warning("Version defined in WSDL's service section->", node.getNodeValue(), " is older than the new version->", newVersion); node.setNodeValue(newVersion); needUpdateWsdl = true; break; } } } } } monitor.worked(10); if (needUpdateWsdl == true) { FileWriter writer = null; try { writer = new FileWriter(wsdlFile.getLocation().toFile()); XMLUtil.writeXML(wsdlNode, writer); } finally { IOUtils.closeQuietly(writer); wsdlFile.refreshLocal(IResource.DEPTH_ONE, monitor); } } else { logger.info("WSDL already have the correct version '", newVersion, "', skip the modification for WSDL->", wsdlFile.getLocation()); } monitor.worked(10); } private static Definition getWSDLUrlFromProject(final IProject project, String requiredServiceProjectPath, final String serviceName) throws Exception { if (SOALogger.DEBUG) logger.entering(project, requiredServiceProjectPath, serviceName); Definition result = null; // load the wsdl directly from the project if available if (project != null && project.isAccessible()) { final IFile wsdlFile = SOAServiceUtil.getWsdlFile(project, serviceName); if (wsdlFile != null && wsdlFile.exists()) { if (SOALogger.DEBUG) logger.debug("Directly loading WSDL from the project->", wsdlFile.getLocation()); result = WSDLUtil.readWSDL(wsdlFile.getLocation().toString()); } } // read from the local system if (result == null && StringUtils.isNotBlank(requiredServiceProjectPath)) { final IPath intfProjectPath = new Path(requiredServiceProjectPath); if (SOAProjectConstants.FILE_EXTENSION_JAR.equalsIgnoreCase(intfProjectPath.getFileExtension())) { final File file = intfProjectPath.toFile(); final String jarEntryLoc = StringUtil.toString(SOAProjectConstants.META_INF_WSDL, WorkspaceUtil.PATH_SEPERATOR, serviceName, WorkspaceUtil.PATH_SEPERATOR, serviceName, SOAProjectConstants.WSDL_EXT); if (SOALogger.DEBUG) logger.debug("Reading WSDL from ", file, "!", jarEntryLoc); result = WSDLUtil.readWSDLFromJarFile(file, jarEntryLoc); } else { final IPath wsdlPath = intfProjectPath.append(SOAIntfProject.META_SRC_WSDL).append(serviceName) .append(serviceName).addFileExtension("wsdl"); if (wsdlPath.toFile().exists()) { if (SOALogger.DEBUG) logger.debug("Loading WSDL from ", wsdlPath); result = WSDLUtil.readWSDL(wsdlPath.toString()); } } } if (SOALogger.DEBUG) logger.exiting(result); return result; } }