| /* | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you 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 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| */ | |
| package org.apache.axis2.wsdl.util; | |
| import org.apache.axis2.util.Counter; | |
| import org.apache.axis2.util.JavaUtils; | |
| import org.apache.commons.logging.Log; | |
| import org.apache.commons.logging.LogFactory; | |
| import javax.wsdl.Binding; | |
| import javax.wsdl.BindingFault; | |
| import javax.wsdl.BindingInput; | |
| import javax.wsdl.BindingOperation; | |
| import javax.wsdl.BindingOutput; | |
| import javax.wsdl.Definition; | |
| import javax.wsdl.Fault; | |
| import javax.wsdl.Import; | |
| import javax.wsdl.Input; | |
| import javax.wsdl.Message; | |
| import javax.wsdl.Operation; | |
| import javax.wsdl.Output; | |
| import javax.wsdl.Part; | |
| import javax.wsdl.Port; | |
| import javax.wsdl.PortType; | |
| import javax.wsdl.Service; | |
| import javax.wsdl.Types; | |
| import javax.wsdl.extensions.ExtensibilityElement; | |
| import javax.wsdl.extensions.ExtensionRegistry; | |
| import javax.xml.namespace.QName; | |
| import java.io.File; | |
| import java.io.FileInputStream; | |
| import java.io.FileOutputStream; | |
| import java.io.ObjectInputStream; | |
| import java.io.ObjectOutputStream; | |
| import java.net.URL; | |
| import java.util.List; | |
| import java.util.Map; | |
| /** | |
| * There are cases where a WSDL definition is kept in memory | |
| * in case it needs to be accessed during runtime. In situations where | |
| * there are lots of WSDL definitions or big WSDLs, the memory footprint can be | |
| * huge. | |
| * | |
| * This class provides support for processing a WSDL4J definition | |
| * with a lower memory footprint. This is useful for certain | |
| * environments. | |
| * | |
| */ | |
| public class WSDLWrapperSaveImpl implements WSDLWrapperImpl { | |
| private static final Log log = LogFactory.getLog(WSDLWrapperSaveImpl.class); | |
| private static final boolean isDebugEnabled = log.isDebugEnabled(); | |
| private static final String myClassName = "WSDLWrapperSaveImpl"; | |
| // javax.wsdl.Definition implements java.io.Serializable | |
| static final long serialVersionUID = -2788807375814097409L; | |
| // the wsdl4j wsdl definition object that is being wrapped | |
| private Definition wsdlDefinition = null; | |
| // the location of the base document used in the wsdl4j definition | |
| private URL wsdlURL = null; | |
| private String wsdlExplicitURI = null; | |
| private String wsdlDocumentBaseURI = null; | |
| // an object that maintains a synchronized counter | |
| private Counter accessCount = null; | |
| // serialization-related information --------------------------- | |
| // | |
| // 'safeToSerialize' indicates whether the wrapped WSDL definition object is | |
| // safe to serialize. This is set to false if the underlying | |
| // WSDL4J's WSDL definition had an error when we tried to | |
| // serialize it. | |
| // | |
| // 'hasBeenSaved' indicates whether the wrapped WSDL definition object | |
| // has been successfully saved | |
| // | |
| // 'hasBeenUpdatedSinceSaving' indicates whether the wrapped WSDL definition | |
| // object has been updated since the last saved/serialziation | |
| // | |
| // | |
| private boolean safeToSerialize = true; | |
| private boolean hasBeenSaved = false; | |
| private boolean hasBeenUpdatedSinceSaving = false; | |
| private File savedDefinitionFile = null; | |
| private String savedFilename = null; | |
| /** | |
| * Constructor | |
| * | |
| * @param def The WSDL Definition | |
| */ | |
| public WSDLWrapperSaveImpl(Definition def) { | |
| if (log.isDebugEnabled()) { | |
| log.debug("WSDLWrapperSaveImpl(Definition def) called"); | |
| log.trace(JavaUtils.callStackToString()); | |
| } | |
| prepare(def, null); | |
| } | |
| /** | |
| * Constructor | |
| * | |
| * @param def The WSDL Definition | |
| * @param wURL The URL for the wsdl | |
| */ | |
| public WSDLWrapperSaveImpl(Definition def, URL wURL) { | |
| if (log.isDebugEnabled()) { | |
| log.debug("WSDLWrapperSaveImpl(Definition def, URL wURL) called"); | |
| log.trace(JavaUtils.callStackToString()); | |
| } | |
| prepare(def, wURL); | |
| } | |
| /** | |
| * Initialize the wsdl definition wrapper | |
| * | |
| * @param def The WSDL4J definition | |
| * @param wURL The URL where the WSDL is obtained | |
| */ | |
| private void prepare(Definition def, URL wURL) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".prepare()"); | |
| } | |
| wsdlDefinition = def; | |
| wsdlURL = wURL; | |
| accessCount = new Counter(); | |
| releaseResources(); | |
| } | |
| //------------------------------------------------------------------------- | |
| // public WSDLDefinitionWrapper methods | |
| //------------------------------------------------------------------------- | |
| /* | |
| * Returns the WSDL4J Definition object that is being wrapped | |
| */ | |
| public Definition getUnwrappedDefinition() { | |
| getWrappedDefinitionForUse(); | |
| Definition def; | |
| if ((wsdlDefinition != null) && | |
| (wsdlDefinition instanceof WSDLDefinitionWrapper)) { | |
| def = ((WSDLDefinitionWrapper) wsdlDefinition).getUnwrappedDefinition(); | |
| } else { | |
| def = wsdlDefinition; | |
| } | |
| return def; | |
| } | |
| /** | |
| * Sets the WSDL4J Definition object that is being wrapped | |
| * | |
| * @param d the WSDL4J Definition object | |
| */ | |
| public void setDefinitionToWrap(Definition d) { | |
| wsdlDefinition = d; | |
| } | |
| /** | |
| * Sets the location for the WSDL4J Definition object that is being wrapped | |
| */ | |
| public void setWSDLLocation(String uriLocation) { | |
| if (uriLocation != null) { | |
| try { | |
| wsdlURL = new URL(uriLocation); | |
| } | |
| catch (Exception e) { | |
| // todo | |
| } | |
| } | |
| } | |
| /** | |
| * Gets the location for the WSDL4J Definition object that is being wrapped | |
| */ | |
| public String getWSDLLocation() { | |
| if (wsdlURL != null) { | |
| return wsdlURL.toString(); | |
| } | |
| else { | |
| return null; | |
| } | |
| } | |
| /** | |
| * Closes the use of the wrapper implementation and allows | |
| * internal resources to be released. | |
| */ | |
| public void close() { | |
| // TODO release temporary files | |
| } | |
| //------------------------------------------------------------------------- | |
| // javax.wsdl.Defintion interface methods | |
| //------------------------------------------------------------------------- | |
| public void setDocumentBaseURI(String d) { | |
| // Set the URI of the base document for the Definition. | |
| // This identifies the origin of the Definition. | |
| // Note that this is the URI of the base document, not the imports. | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".setDocumentBaseURI(" + d + ")"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| wsdlDefinition.setDocumentBaseURI(d); | |
| } | |
| doneUsingWrappedDefinition(); | |
| } | |
| public String getDocumentBaseURI() { | |
| // Get the URI of the base document for the Definition. | |
| // This identifies the origin of the Definition. | |
| // Note that this is the URI of the base document, not the imports. | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".getDocumentBaseURI()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| String results = null; | |
| if (wsdlDefinition != null) { | |
| results = wsdlDefinition.getDocumentBaseURI(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public void setQName(QName n) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".setQName(" + n + ")"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| wsdlDefinition.setQName(n); | |
| } | |
| doneUsingWrappedDefinition(); | |
| } | |
| public QName getQName() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".getQName()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| QName results = null; | |
| if (wsdlDefinition != null) { | |
| results = wsdlDefinition.getQName(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public void setTargetNamespace(String t) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".setTargetNamespace(" + t + ")"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| wsdlDefinition.setTargetNamespace(t); | |
| } | |
| doneUsingWrappedDefinition(); | |
| } | |
| public String getTargetNamespace() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".getTargetNamespace()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| String results = null; | |
| if (wsdlDefinition != null) { | |
| results = wsdlDefinition.getTargetNamespace(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public void addNamespace(String prefix, String namespaceURI) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".addNamespace(" + prefix + ", " + namespaceURI + ")"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| wsdlDefinition.addNamespace(prefix, namespaceURI); | |
| } | |
| doneUsingWrappedDefinition(); | |
| } | |
| public String removeNamespace(String prefix) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".removeNamespace(" + prefix + ")"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| String results = null; | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| results = wsdlDefinition.removeNamespace(prefix); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public String getNamespace(String prefix) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".getNamespace(" + prefix + ")"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| String results = null; | |
| if (wsdlDefinition != null) { | |
| results = wsdlDefinition.getNamespace(prefix); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public String getPrefix(String namespaceURI) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".getPrefix(" + namespaceURI + ")"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| String results = null; | |
| if (wsdlDefinition != null) { | |
| results = wsdlDefinition.getPrefix(namespaceURI); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public Map getNamespaces() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".getNamespaces()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Map results = null; | |
| if (wsdlDefinition != null) { | |
| results = wsdlDefinition.getNamespaces(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public List getNativeAttributeNames() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".getNativeAttributeNames()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| List results = null; | |
| if (wsdlDefinition != null) { | |
| results = wsdlDefinition.getNativeAttributeNames(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public void setTypes(Types types) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".setTypes()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| wsdlDefinition.setTypes(types); | |
| } | |
| doneUsingWrappedDefinition(); | |
| } | |
| public Types getTypes() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".getTypes()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Types results = null; | |
| if (wsdlDefinition != null) { | |
| results = wsdlDefinition.getTypes(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public void addImport(Import importDef) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".addImport(" + importDef + ")"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| wsdlDefinition.addImport(importDef); | |
| } | |
| doneUsingWrappedDefinition(); | |
| } | |
| public Import removeImport(Import importDef) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".removeImport(" + importDef + ")"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Import results = null; | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| results = wsdlDefinition.removeImport(importDef); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public List getImports(String namespaceURI) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".getImports(" + namespaceURI + ")"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| List results = null; | |
| if (wsdlDefinition != null) { | |
| results = wsdlDefinition.getImports(namespaceURI); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public Map getImports() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".getImports()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Map results = null; | |
| if (wsdlDefinition != null) { | |
| results = wsdlDefinition.getImports(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public void addMessage(Message message) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".addMessage(" + message + ")"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| wsdlDefinition.addMessage(message); | |
| } | |
| doneUsingWrappedDefinition(); | |
| } | |
| public Message getMessage(QName name) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".getMessage(" + name + ")"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Message results = null; | |
| if (wsdlDefinition != null) { | |
| results = wsdlDefinition.getMessage(name); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public Message removeMessage(QName name) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".removeMessage(" + name + ")"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Message results = null; | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| results = wsdlDefinition.removeMessage(name); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public Map getMessages() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".getMessages()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Map results = null; | |
| if (wsdlDefinition != null) { | |
| results = wsdlDefinition.getMessages(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public void addBinding(Binding binding) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".addBinding(" + binding + ")"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| wsdlDefinition.addBinding(binding); | |
| } | |
| doneUsingWrappedDefinition(); | |
| } | |
| public Binding getBinding(QName name) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".getBinding(" + name + ")"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Binding results = null; | |
| if (wsdlDefinition != null) { | |
| results = wsdlDefinition.getBinding(name); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public Binding removeBinding(QName name) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".removeBinding(" + name + ")"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Binding results = null; | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| results = wsdlDefinition.removeBinding(name); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public Map getBindings() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".getBindings()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Map results = null; | |
| if (wsdlDefinition != null) { | |
| results = wsdlDefinition.getBindings(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public Map getAllBindings() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".getAllBindings()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Map results = null; | |
| if (wsdlDefinition != null) { | |
| results = wsdlDefinition.getAllBindings(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public void addPortType(PortType portType) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".addPortType(" + portType + ")"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| wsdlDefinition.addPortType(portType); | |
| } | |
| doneUsingWrappedDefinition(); | |
| } | |
| public PortType getPortType(QName name) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".getPortType(" + name + ")"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| PortType results = null; | |
| if (wsdlDefinition != null) { | |
| results = wsdlDefinition.getPortType(name); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public PortType removePortType(QName name) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".removePortType(" + name + ")"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| PortType results = null; | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| results = wsdlDefinition.removePortType(name); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public Map getPortTypes() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".getPortTypes()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Map results = null; | |
| if (wsdlDefinition != null) { | |
| results = wsdlDefinition.getPortTypes(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public Map getAllPortTypes() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".getAllPortTypes()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Map results = null; | |
| if (wsdlDefinition != null) { | |
| results = wsdlDefinition.getAllPortTypes(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public void addService(Service service) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".addService(" + service + ")"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| wsdlDefinition.addService(service); | |
| } | |
| doneUsingWrappedDefinition(); | |
| } | |
| public Service getService(QName name) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".getService(" + name + ")"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Service results = null; | |
| if (wsdlDefinition != null) { | |
| results = wsdlDefinition.getService(name); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public Service removeService(QName name) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".removeService(" + name + ")"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Service results = null; | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| results = wsdlDefinition.removeService(name); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public Map getServices() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".getServices()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Map results = null; | |
| if (wsdlDefinition != null) { | |
| results = wsdlDefinition.getServices(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public Map getAllServices() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".getAllServices()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Map results = null; | |
| if (wsdlDefinition != null) { | |
| results = wsdlDefinition.getAllServices(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public void setDocumentationElement(org.w3c.dom.Element docEl) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".setDocumentationElement()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| wsdlDefinition.setDocumentationElement(docEl); | |
| } | |
| doneUsingWrappedDefinition(); | |
| } | |
| public org.w3c.dom.Element getDocumentationElement() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".getDocumentationElement()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| org.w3c.dom.Element results = null; | |
| if (wsdlDefinition != null) { | |
| return wsdlDefinition.getDocumentationElement(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public void addExtensibilityElement(ExtensibilityElement extElement) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".addExtensibilityElement(" + extElement + ")"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| wsdlDefinition.addExtensibilityElement(extElement); | |
| } | |
| doneUsingWrappedDefinition(); | |
| } | |
| public List getExtensibilityElements() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".getExtensibilityElements()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| List results = null; | |
| if (wsdlDefinition != null) { | |
| results = wsdlDefinition.getExtensibilityElements(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public Binding createBinding() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".createBinding()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Binding results = null; | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| results = wsdlDefinition.createBinding(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public BindingFault createBindingFault() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".createBindingFault()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| BindingFault results = null; | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| results = wsdlDefinition.createBindingFault(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public BindingInput createBindingInput() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".createBindingInput()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| BindingInput results = null; | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| results = wsdlDefinition.createBindingInput(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public BindingOperation createBindingOperation() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".createBindingOperation()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| BindingOperation results = null; | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| results = wsdlDefinition.createBindingOperation(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public BindingOutput createBindingOutput() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".createBindingOutput()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| BindingOutput results = null; | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| results = wsdlDefinition.createBindingOutput(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public Fault createFault() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".createFault()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Fault results = null; | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| results = wsdlDefinition.createFault(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public Import createImport() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".createImport()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Import results = null; | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| results = wsdlDefinition.createImport(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public Input createInput() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".createInput()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Input results = null; | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| results = wsdlDefinition.createInput(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public Message createMessage() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".createMessage()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Message results = null; | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| results = wsdlDefinition.createMessage(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public Operation createOperation() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".createOperation()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Operation results = null; | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| results = wsdlDefinition.createOperation(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public Output createOutput() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".createOutput()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Output results = null; | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| results = wsdlDefinition.createOutput(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public Part createPart() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".createPart()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Part results = null; | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| results = wsdlDefinition.createPart(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public Port createPort() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".createPort()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Port results = null; | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| results = wsdlDefinition.createPort(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public PortType createPortType() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".createPortType()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| PortType results = null; | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| results = wsdlDefinition.createPortType(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public Service createService() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".createService()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Service results = null; | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| results = wsdlDefinition.createService(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public Types createTypes() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".createTypes()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Types results = null; | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| results = wsdlDefinition.createTypes(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public void setExtensionRegistry(ExtensionRegistry extReg) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".setExtensionRegistry(" + extReg + ")"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| wsdlDefinition.setExtensionRegistry(extReg); | |
| } | |
| doneUsingWrappedDefinition(); | |
| } | |
| public ExtensionRegistry getExtensionRegistry() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".getExtensionRegistry()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| ExtensionRegistry results = null; | |
| if (wsdlDefinition != null) { | |
| results = wsdlDefinition.getExtensionRegistry(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public String toString() { | |
| getWrappedDefinitionForUse(); | |
| String results = ""; | |
| if (wsdlDefinition != null) { | |
| results = wsdlDefinition.toString(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| //------------------------------------------------------------------------- | |
| // other AbstractWSDLElement methods | |
| //------------------------------------------------------------------------- | |
| public ExtensibilityElement removeExtensibilityElement(ExtensibilityElement extElement) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".removeExtensibilityElement(" + extElement + ")"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| ExtensibilityElement results = null; | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| results = wsdlDefinition.removeExtensibilityElement(extElement); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public java.lang.Object getExtensionAttribute(QName name) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".getExtensionAttribute(" + name + ")"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| java.lang.Object results = null; | |
| if (wsdlDefinition != null) { | |
| results = wsdlDefinition.getExtensionAttribute(name); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public Map getExtensionAttributes() { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".getExtensionAttributes()"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| Map results = null; | |
| if (wsdlDefinition != null) { | |
| results = wsdlDefinition.getExtensionAttributes(); | |
| } | |
| doneUsingWrappedDefinition(); | |
| return results; | |
| } | |
| public void setExtensionAttribute(QName name, java.lang.Object value) { | |
| if (isDebugEnabled) { | |
| log.debug(myClassName + ".setExtensionAttribute(" + name + ", " + value + ")"); | |
| } | |
| getWrappedDefinitionForUse(); | |
| if (wsdlDefinition != null) { | |
| if (hasBeenSaved) { | |
| hasBeenUpdatedSinceSaving = true; | |
| } | |
| wsdlDefinition.setExtensionAttribute(name, value); | |
| } | |
| doneUsingWrappedDefinition(); | |
| } | |
| //------------------------------------------------------------------------- | |
| // private utility methods | |
| //------------------------------------------------------------------------- | |
| /** | |
| * This is an internal utility to ensure that the | |
| * WSDL definition being wrapped is available for | |
| * use. | |
| * <P> | |
| * For example, if the WSDL4J WSDL definition object | |
| * had been saved, this will reload it. | |
| */ | |
| private void getWrappedDefinitionForUse() { | |
| if (wsdlDefinition == null) { | |
| loadResources(); | |
| } | |
| if (wsdlDefinition != null) { | |
| accessCount.incrementAndGet(); | |
| } | |
| } | |
| /** | |
| * This is an internal utility to indicate that the | |
| * use of WSDL definition has completed. | |
| */ | |
| private void doneUsingWrappedDefinition() { | |
| long assessors = accessCount.decrementAndGet(); | |
| if (assessors == 0) { | |
| releaseResources(); | |
| } | |
| } | |
| /* | |
| * Reduces memory footprint of the in-memory caching of the WSDL definition | |
| * based on the configuration settings | |
| * | |
| */ | |
| public void releaseResources() { | |
| boolean saved = save(); | |
| if (saved) { | |
| // release the in-memory copy of the WSDL4J | |
| wsdlDefinition = null; | |
| } | |
| } | |
| /* | |
| * Loads the the WSDL definition back into memory | |
| */ | |
| public void loadResources() { | |
| if (wsdlDefinition == null) { | |
| wsdlDefinition = restore(); | |
| } | |
| } | |
| /** | |
| * Saves the current WSDL definition object that this wrapper contains. | |
| * This method has a number of checks to determine how to proceed with | |
| * the saving of the WSDL definition object, so the caller should not | |
| * need to make checks on whether to save or not. | |
| * <P> | |
| * The caller is responsible for handling the wrapped WSDL | |
| * definition object, for example, deciding when to release | |
| * it or reload it. | |
| * | |
| * @return True - if the save succeeded | |
| * False - if the save failed | |
| */ | |
| private boolean save() { | |
| // if the wsdl definiton failed to serialize from a previous attempt | |
| // to save it, then don't try to save it | |
| if (safeToSerialize == false) { | |
| // exit quickly | |
| return false; | |
| } | |
| // at this point, we think it is safe to proceed with saving the | |
| // wsdl definition | |
| // make sure there is a file to use for saving the wsdl definition | |
| if (savedDefinitionFile == null) { | |
| try { | |
| savedDefinitionFile = File.createTempFile("wsdlDef_", null); | |
| savedFilename = savedDefinitionFile.getName(); | |
| log.debug(myClassName + ".save(): temp file = [" + savedFilename + "]"); | |
| } | |
| catch (Exception ex) { | |
| log.debug(myClassName + ".save(): error creating temp file = [" + ex.getMessage() + "]"); | |
| savedDefinitionFile = null; | |
| savedFilename = null; | |
| // can't save the wsdl definition at this time | |
| // might be able to do so later | |
| hasBeenSaved = false; | |
| return false; | |
| } | |
| } | |
| if (savedDefinitionFile != null) { | |
| // the File object exists, check to see if the wsdl definition has | |
| // been previously saved | |
| if (hasBeenSaved && !hasBeenUpdatedSinceSaving) { | |
| // no need to save because we saved it already | |
| // and there were no updates to the wsdl definition object | |
| // since the previous save | |
| return true; | |
| } | |
| // --------------------------------------------------------- | |
| // save to the file | |
| // --------------------------------------------------------- | |
| FileOutputStream outStream = null; | |
| ObjectOutputStream outObjStream = null; | |
| try { | |
| // setup an output stream to a physical file | |
| outStream = new FileOutputStream(savedDefinitionFile); | |
| // attach a stream capable of writing objects to the | |
| // stream connected to the file | |
| outObjStream = new ObjectOutputStream(outStream); | |
| // try to save the wsdl object | |
| log.debug(myClassName + ".save(): saving the wsdl definition....."); | |
| outObjStream.writeObject(wsdlDefinition); | |
| // close out the streams | |
| outObjStream.flush(); | |
| outObjStream.close(); | |
| outStream.flush(); | |
| outStream.close(); | |
| hasBeenSaved = true; | |
| hasBeenUpdatedSinceSaving = false; | |
| log.debug(myClassName + ".save(): ....saved the wsdl definition....."); | |
| long filesize = savedDefinitionFile.length(); | |
| log.debug(myClassName + ".save(): file size after save [" + filesize + | |
| "] temp file = [" + savedFilename + "]"); | |
| log.debug(myClassName + ".save(): end - - - - - - - - - - - - - - - -"); | |
| return true; | |
| } | |
| catch (Exception ex2) { | |
| // disable future tries at saving this WSDL definition object | |
| safeToSerialize = false; | |
| // indicate that the file cannot be used to restore from | |
| hasBeenSaved = false; | |
| log.debug(myClassName + ".save(): error with saving the wsdl definition = [" + | |
| ex2.getClass().getName() + " : " + ex2.getMessage() + "]", ex2); | |
| if (savedDefinitionFile != null) { | |
| try { | |
| savedDefinitionFile.delete(); | |
| savedDefinitionFile = null; | |
| savedFilename = null; | |
| } | |
| catch (Exception e) { | |
| // just absorb it | |
| } | |
| } | |
| if (outObjStream != null) { | |
| try { | |
| outObjStream.close(); | |
| } | |
| catch (Exception e) { | |
| // just absorb it | |
| } | |
| } | |
| if (outStream != null) { | |
| try { | |
| outStream.close(); | |
| } | |
| catch (Exception e) { | |
| // just absorb it | |
| } | |
| } | |
| log.debug(myClassName + ".save(): error exit - - - - - - - - - - - - - - - -"); | |
| return false; | |
| } | |
| } | |
| return false; | |
| } | |
| /** | |
| * Restores the WSDL definition from a previously saved copy. | |
| * <P> | |
| * The caller is responsible for handling the wrapped WSDL | |
| * definition object, for example, deciding when to release | |
| * it or reload it. | |
| * | |
| * @return The restored WSDL definition object, or NULL | |
| */ | |
| private Definition restore() { | |
| if (!hasBeenSaved) { | |
| // the wsdl defintion has not been saved, or the previous saved version | |
| // should not be used for some reason | |
| return null; | |
| } | |
| if (savedDefinitionFile == null) { | |
| // no file to restore from | |
| return null; | |
| } | |
| // --------------------------------------------------------- | |
| // restore from the temporary file | |
| // --------------------------------------------------------- | |
| Definition restoredDefinition = null; | |
| FileInputStream inStream = null; | |
| ObjectInputStream inObjStream = null; | |
| try { | |
| // setup an input stream to the file | |
| inStream = new FileInputStream(savedDefinitionFile); | |
| // attach a stream capable of reading objects from the | |
| // stream connected to the file | |
| inObjStream = new ObjectInputStream(inStream); | |
| // try to restore the wrapped wsdl definition | |
| log.debug(myClassName + ".restore(): restoring the WSDL definition ....."); | |
| restoredDefinition = (Definition) inObjStream.readObject(); | |
| inObjStream.close(); | |
| inStream.close(); | |
| log.debug(myClassName + ".restore(): ....restored the WSDL definition ....."); | |
| } | |
| catch (Exception ex2) { | |
| log.debug(myClassName + ".restore(): error with restoring the WSDL definition = [" + | |
| ex2.getClass().getName() + " : " + ex2.getMessage() + "]", ex2); | |
| if (inObjStream != null) { | |
| try { | |
| inObjStream.close(); | |
| } | |
| catch (Exception e) { | |
| // just absorb it | |
| } | |
| } | |
| if (inStream != null) { | |
| try { | |
| inStream.close(); | |
| } | |
| catch (Exception e) { | |
| // just absorb it | |
| } | |
| } | |
| } | |
| log.debug(myClassName + ".restore(): end - - - - - - - - - - - - - - - -"); | |
| return restoredDefinition; | |
| } | |
| } |