/*
* Copyright 2001-2005 The Apache Software Foundation.
*
* 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
*
* 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.axis.deployment.wsdd;
import org.apache.axis.AxisEngine;
import org.apache.axis.AxisFault;
import org.apache.axis.ConfigurationException;
import org.apache.axis.Constants;
import org.apache.axis.EngineConfiguration;
import org.apache.axis.FaultableHandler;
import org.apache.axis.Handler;
import org.apache.axis.MessageContext;
import org.apache.axis.attachments.Attachments;
import org.apache.axis.attachments.AttachmentsImpl;
import org.apache.axis.constants.Style;
import org.apache.axis.constants.Use;
import org.apache.axis.description.JavaServiceDesc;
import org.apache.axis.description.ServiceDesc;
import org.apache.axis.encoding.DeserializerFactory;
import org.apache.axis.encoding.SerializationContext;
import org.apache.axis.encoding.SerializerFactory;
import org.apache.axis.encoding.TypeMapping;
import org.apache.axis.encoding.TypeMappingRegistry;
import org.apache.axis.encoding.TypeMappingRegistryImpl;
import org.apache.axis.encoding.ser.ArraySerializerFactory;
import org.apache.axis.encoding.ser.BaseDeserializerFactory;
import org.apache.axis.encoding.ser.BaseSerializerFactory;
import org.apache.axis.handlers.HandlerInfoChainFactory;
import org.apache.axis.handlers.soap.SOAPService;
import org.apache.axis.providers.java.JavaProvider;
import org.apache.axis.utils.Messages;
import org.apache.axis.utils.XMLUtils;
import org.w3c.dom.Element;
import org.xml.sax.helpers.AttributesImpl;
import javax.xml.namespace.QName;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
import java.util.Vector;
/**
* A service represented in WSDD.
*
* @author Glen Daniels (gdaniels@apache.org)
*/
public class WSDDService
extends WSDDTargetedChain
implements WSDDTypeMappingContainer
{
private TypeMappingRegistry tmr = null;
private Vector faultFlows = new Vector();
private Vector typeMappings = new Vector();
private Vector operations = new Vector();
/** Which namespaces should auto-dispatch to this service? */
private Vector namespaces = new Vector();
/** Which roles does this service support? */
private List roles = new ArrayList();
private String descriptionURL;
/** Style - document, wrapped, message, or RPC (the default) */
private Style style = Style.DEFAULT;
/** Use - encoded (the default) or literal */
private Use use = Use.DEFAULT;
private transient SOAPService cachedService = null;
/**
* Our provider - used to figure out which Handler we use as a service
* pivot (see getInstance() below)
*/
private QName providerQName;
// private HandlerInfoChainFactory _hiChainFactory;
private WSDDJAXRPCHandlerInfoChain _wsddHIchain;
JavaServiceDesc desc = new JavaServiceDesc();
/**
* Is streaming (i.e. NO high-fidelity recording, deserialize on the fly)
* on for this service?
*/
private boolean streaming = false;
/**
* What attachment format should be used?
*/
private int sendType = Attachments.SEND_TYPE_NOTSET;
/**
* Default constructor
*/
public WSDDService()
{
}
/**
*
* @param e (Element) XXX
* @throws WSDDException XXX
*/
public WSDDService(Element e)
throws WSDDException
{
super(e);
desc.setName(getQName().getLocalPart());
String styleStr = e.getAttribute(ATTR_STYLE);
if (styleStr != null && !styleStr.equals("")) {
style = Style.getStyle(styleStr, Style.DEFAULT);
desc.setStyle(style);
providerQName = style.getProvider();
}
String useStr = e.getAttribute(ATTR_USE);
if (useStr != null && !useStr.equals("")) {
use = Use.getUse(useStr, Use.DEFAULT);
desc.setUse(use);
} else {
if (style != Style.RPC) {
// Default to use=literal if not style=RPC
use = Use.LITERAL;
desc.setUse(use);
}
}
String streamStr = e.getAttribute(ATTR_STREAMING);
if (streamStr != null && streamStr.equals("on")) {
streaming = true;
}
String attachmentStr = e.getAttribute(ATTR_ATTACHMENT_FORMAT);
if (attachmentStr != null && !attachmentStr.equals("")) {
sendType = AttachmentsImpl.getSendType(attachmentStr);
}
Element [] operationElements = getChildElements(e, ELEM_WSDD_OPERATION);
for (int i = 0; i < operationElements.length; i++) {
WSDDOperation operation = new WSDDOperation(operationElements[i],
desc);
addOperation(operation);
}
Element [] typeMappingElements = getChildElements(e, ELEM_WSDD_TYPEMAPPING);
for (int i = 0; i < typeMappingElements.length; i++) {
WSDDTypeMapping mapping =
new WSDDTypeMapping(typeMappingElements[i]);
typeMappings.add(mapping);
}
Element [] beanMappingElements = getChildElements(e, ELEM_WSDD_BEANMAPPING);
for (int i = 0; i < beanMappingElements.length; i++) {
WSDDBeanMapping mapping =
new WSDDBeanMapping(beanMappingElements[i]);
typeMappings.add(mapping);
}
Element [] arrayMappingElements = getChildElements(e, ELEM_WSDD_ARRAYMAPPING);
for (int i = 0; i < arrayMappingElements.length; i++) {
WSDDArrayMapping mapping =
new WSDDArrayMapping(arrayMappingElements[i]);
typeMappings.add(mapping);
}
Element [] namespaceElements = getChildElements(e, ELEM_WSDD_NAMESPACE);
for (int i = 0; i < namespaceElements.length; i++) {
// Register a namespace for this service
String ns = XMLUtils.getChildCharacterData(namespaceElements[i]);
namespaces.add(ns);
}
if (!namespaces.isEmpty())
desc.setNamespaceMappings(namespaces);
Element [] roleElements = getChildElements(e, ELEM_WSDD_ROLE);
for (int i = 0; i < roleElements.length; i++) {
String role = XMLUtils.getChildCharacterData(roleElements[i]);
roles.add(role);
}
Element wsdlElem = getChildElement(e, ELEM_WSDD_WSDLFILE);
if (wsdlElem != null) {
String fileName = XMLUtils.getChildCharacterData(wsdlElem);
desc.setWSDLFile(fileName.trim());
}
Element docElem = getChildElement(e, ELEM_WSDD_DOC);
if (docElem != null) {
WSDDDocumentation documentation = new WSDDDocumentation(docElem);
desc.setDocumentation(documentation.getValue());
}
Element urlElem = getChildElement(e, ELEM_WSDD_ENDPOINTURL);
if (urlElem != null) {
String endpointURL = XMLUtils.getChildCharacterData(urlElem);
desc.setEndpointURL(endpointURL);
}
String providerStr = e.getAttribute(ATTR_PROVIDER);
if (providerStr != null && !providerStr.equals("")) {
providerQName = XMLUtils.getQNameFromString(providerStr, e);
if (WSDDConstants.QNAME_JAVAMSG_PROVIDER.equals(providerQName)) {
// Message style if message provider...
desc.setStyle(Style.MESSAGE);
}
}
// Add in JAX-RPC support for HandlerInfo chains
Element hcEl = getChildElement(e, ELEM_WSDD_JAXRPC_CHAIN);
if (hcEl != null) {
_wsddHIchain = new WSDDJAXRPCHandlerInfoChain(hcEl);
}
// Initialize TypeMappingRegistry
initTMR();
// call to validate standard descriptors for this service
validateDescriptors();
}
/**
* Initialize a TypeMappingRegistry with the
* WSDDTypeMappings.
* Note: Extensions of WSDDService may override
* initTMR to popluate the tmr with different
* type mappings.
*/
protected void initTMR() throws WSDDException
{
// If not created, construct a tmr
// and populate it with the type mappings.
if (tmr == null) {
createTMR();
for (int i=0; i<typeMappings.size(); i++) {
deployTypeMapping((WSDDTypeMapping)
typeMappings.get(i));
}
}
}
private void createTMR() {
tmr = new TypeMappingRegistryImpl(false);
String version = getParameter("typeMappingVersion");
((TypeMappingRegistryImpl)tmr).doRegisterFromVersion(version);
}
/**
* This method can be used for dynamic deployment using new WSDDService()
* etc. It validates some standard parameters for some standard providers
* (if present). Do this before deployment.deployService().
*/
public void validateDescriptors() throws WSDDException
{
if (tmr == null) {
initTMR();
}
desc.setTypeMappingRegistry(tmr);
desc.setTypeMapping(getTypeMapping(desc.getUse().getEncoding()));
String allowedMethods = getParameter(JavaProvider.OPTION_ALLOWEDMETHODS);
if (allowedMethods != null && !"*".equals(allowedMethods)) {
ArrayList methodList = new ArrayList();
StringTokenizer tokenizer = new StringTokenizer(allowedMethods, " ,");
while (tokenizer.hasMoreTokens()) {
methodList.add(tokenizer.nextToken());
}
desc.setAllowedMethods(methodList);
}
}
/**
* Add a WSDDTypeMapping to the Service.
* @param mapping
**/
public void addTypeMapping(WSDDTypeMapping mapping) {
typeMappings.add(mapping);
}
/**
* Add a WSDDOperation to the Service.
* @param operation the operation to add
**/
public void addOperation(WSDDOperation operation) {
operations.add(operation);
desc.addOperationDesc(operation.getOperationDesc());
}
protected QName getElementName()
{
return QNAME_SERVICE;
}
/**
* Get any service description URL which might be associated with this
* service.
*
* @return a String containing a URL, or null.
*/
public String getServiceDescriptionURL()
{
return descriptionURL;
}
/**
* Set the service description URL for this service.
*
* @param sdUrl a String containing a URL
*/
public void setServiceDescriptionURL(String sdUrl)
{
descriptionURL = sdUrl;
}
public QName getProviderQName() {
return providerQName;
}
public void setProviderQName(QName providerQName) {
this.providerQName = providerQName;
}
public ServiceDesc getServiceDesc() {
return desc;
}
/**
* Get the service style - document or RPC
*/
public Style getStyle() {
return style;
}
/**
* Set the service style - document or RPC
*/
public void setStyle(Style style) {
this.style = style;
}
/**
* Get the service use - literal or encoded
*/
public Use getUse() {
return use;
}
/**
* Set the service use - literal or encoded
*/
public void setUse(Use use) {
this.use = use;
}
/**
*
* @return XXX
*/
public WSDDFaultFlow[] getFaultFlows()
{
WSDDFaultFlow[] t = new WSDDFaultFlow[faultFlows.size()];
faultFlows.toArray(t);
return t;
}
/**
* Obtain the list of namespaces registered for this service
* @return a Vector of namespaces (Strings) which should dispatch to
* this service
*/
public Vector getNamespaces()
{
return namespaces;
}
/**
*
* @param name XXX
* @return XXX
*/
public WSDDFaultFlow getFaultFlow(QName name)
{
WSDDFaultFlow[] t = getFaultFlows();
for (int n = 0; n < t.length; n++) {
if (t[n].getQName().equals(name)) {
return t[n];
}
}
return null;
}
/**
*
* @param registry XXX
* @return XXX
* @throws ConfigurationException XXX
*/
public Handler makeNewInstance(EngineConfiguration registry)
throws ConfigurationException
{
if (cachedService != null) {
return cachedService;
}
// Make sure tmr is initialized.
initTMR();
Handler reqHandler = null;
WSDDChain request = getRequestFlow();
if (request != null) {
reqHandler = request.getInstance(registry);
}
Handler providerHandler = null;
if (providerQName != null) {
try {
providerHandler = WSDDProvider.getInstance(providerQName,
this,
registry);
} catch (Exception e) {
throw new ConfigurationException(e);
}
if (providerHandler == null)
throw new WSDDException(
Messages.getMessage("couldntConstructProvider00"));
}
Handler respHandler = null;
WSDDChain response = getResponseFlow();
if (response != null) {
respHandler = response.getInstance(registry);
}
SOAPService service = new SOAPService(reqHandler, providerHandler,
respHandler);
service.setStyle(style);
service.setUse(use);
service.setServiceDescription(desc);
service.setHighFidelityRecording(!streaming);
service.setSendType(sendType);
if ( getQName() != null )
service.setName(getQName().getLocalPart());
service.setOptions(getParametersTable());
service.setRoles(roles);
service.setEngine(((WSDDDeployment)registry).getEngine());
if (use != Use.ENCODED) {
// If not encoded, turn off multi-refs and prefer
// not to sent xsi:type and xsi:nil
service.setOption(AxisEngine.PROP_DOMULTIREFS, Boolean.FALSE);
service.setOption(AxisEngine.PROP_SEND_XSI, Boolean.FALSE);
}
// Set handlerInfoChain
if (_wsddHIchain != null) {
HandlerInfoChainFactory hiChainFactory = _wsddHIchain.getHandlerChainFactory();
service.setOption(Constants.ATTR_HANDLERINFOCHAIN, hiChainFactory);
}
AxisEngine.normaliseOptions(service);
WSDDFaultFlow [] faultFlows = getFaultFlows();
if (faultFlows != null && faultFlows.length > 0) {
FaultableHandler wrapper = new FaultableHandler(service);
for (int i = 0; i < faultFlows.length; i++) {
WSDDFaultFlow flow = faultFlows[i];
Handler faultHandler = flow.getInstance(registry);
wrapper.setOption("fault-" + flow.getQName().getLocalPart(),
faultHandler);
}
}
try {
service.getInitializedServiceDesc(MessageContext.getCurrentContext());
} catch (AxisFault axisFault) {
throw new ConfigurationException(axisFault);
}
cachedService = service;
return service;
}
public void deployTypeMapping(WSDDTypeMapping mapping)
throws WSDDException
{
if (!typeMappings.contains(mapping)) {
typeMappings.add(mapping);
}
if (tmr == null) {
createTMR();
}
try {
// Get the encoding style from the mapping, if it isn't set
// use the use of the service to map doc/lit or rpc/enc
String encodingStyle = mapping.getEncodingStyle();
if (encodingStyle == null) {
encodingStyle = use.getEncoding();
}
TypeMapping tm = tmr.getOrMakeTypeMapping(encodingStyle);
desc.setTypeMappingRegistry(tmr);
desc.setTypeMapping(tm);
SerializerFactory ser = null;
DeserializerFactory deser = null;
// Try to construct a serializerFactory by introspecting for the
// following:
// public static create(Class javaType, QName xmlType)
// public <constructor>(Class javaType, QName xmlType)
// public <constructor>()
//
// The BaseSerializerFactory createFactory() method is a utility
// that does this for us.
if (mapping.getSerializerName() != null &&
!mapping.getSerializerName().equals("")) {
ser = BaseSerializerFactory.createFactory(mapping.getSerializer(),
mapping.getLanguageSpecificType(),
mapping.getQName());
}
if (mapping instanceof WSDDArrayMapping && ser instanceof ArraySerializerFactory) {
WSDDArrayMapping am = (WSDDArrayMapping) mapping;
ArraySerializerFactory factory = (ArraySerializerFactory) ser;
factory.setComponentType(am.getInnerType());
}
if (mapping.getDeserializerName() != null &&
!mapping.getDeserializerName().equals("")) {
deser = BaseDeserializerFactory.createFactory(mapping.getDeserializer(),
mapping.getLanguageSpecificType(),
mapping.getQName());
}
tm.register( mapping.getLanguageSpecificType(), mapping.getQName(), ser, deser);
} catch (ClassNotFoundException e) {
log.error(Messages.getMessage("unabletoDeployTypemapping00", mapping.getQName().toString()), e);
throw new WSDDNonFatalException(e);
} catch (Exception e) {
throw new WSDDException(e);
}
}
/**
* Write this element out to a SerializationContext
*/
public void writeToContext(SerializationContext context)
throws IOException {
AttributesImpl attrs = new AttributesImpl();
QName name = getQName();
if (name != null) {
attrs.addAttribute("", ATTR_NAME, ATTR_NAME,
"CDATA", context.qName2String(name));
}
if (providerQName != null) {
attrs.addAttribute("", ATTR_PROVIDER, ATTR_PROVIDER,
"CDATA", context.qName2String(providerQName));
}
if (style != Style.DEFAULT) {
attrs.addAttribute("", ATTR_STYLE, ATTR_STYLE,
"CDATA", style.getName());
}
if (use != Use.DEFAULT) {
attrs.addAttribute("", ATTR_USE, ATTR_USE,
"CDATA", use.getName());
}
if (streaming) {
attrs.addAttribute("", ATTR_STREAMING, ATTR_STREAMING,
"CDATA", "on");
}
if (sendType != Attachments.SEND_TYPE_NOTSET) {
attrs.addAttribute("", ATTR_ATTACHMENT_FORMAT,
ATTR_ATTACHMENT_FORMAT, "CDATA",
AttachmentsImpl.getSendTypeString(sendType));
}
context.startElement(WSDDConstants.QNAME_SERVICE, attrs);
if (desc.getWSDLFile() != null) {
context.startElement(QNAME_WSDLFILE, null);
context.writeSafeString(desc.getWSDLFile());
context.endElement();
}
if (desc.getDocumentation() != null) {
WSDDDocumentation documentation = new WSDDDocumentation(desc.getDocumentation());
documentation.writeToContext(context);
}
for (int i = 0; i < operations.size(); i++) {
WSDDOperation operation = (WSDDOperation) operations.elementAt(i);
operation.writeToContext(context);
}
writeFlowsToContext(context);
writeParamsToContext(context);
for (int i=0; i < typeMappings.size(); i++) {
((WSDDTypeMapping) typeMappings.elementAt(i)).writeToContext(context);
}
for (int i=0; i < namespaces.size(); i++ ) {
context.startElement(QNAME_NAMESPACE, null);
context.writeString((String)namespaces.get(i));
context.endElement();
}
String endpointURL = desc.getEndpointURL();
if (endpointURL != null) {
context.startElement(QNAME_ENDPOINTURL, null);
context.writeSafeString(endpointURL);
context.endElement();
}
if (_wsddHIchain != null) {
_wsddHIchain.writeToContext(context);
}
context.endElement();
}
public void setCachedService(SOAPService service)
{
cachedService = service;
}
public Vector getTypeMappings() {
return typeMappings;
}
public void setTypeMappings(Vector typeMappings) {
this.typeMappings = typeMappings;
}
public void deployToRegistry(WSDDDeployment registry)
{
registry.addService(this);
// Register the name of the service as a valid namespace, just for
// backwards compatibility
registry.registerNamespaceForService(getQName().getLocalPart(), this);
for (int i = 0; i < namespaces.size(); i++) {
String namespace = (String) namespaces.elementAt(i);
registry.registerNamespaceForService(namespace, this);
}
super.deployToRegistry(registry);
}
public void removeNamespaceMappings(WSDDDeployment registry)
{
for (int i = 0; i < namespaces.size(); i++) {
String namespace = (String) namespaces.elementAt(i);
registry.removeNamespaceMapping(namespace);
}
registry.removeNamespaceMapping(getQName().getLocalPart());
}
public TypeMapping getTypeMapping(String encodingStyle) {
// If type mapping registry not initialized yet, return null.
if (tmr == null) {
return null;
}
return (TypeMapping) tmr.getOrMakeTypeMapping(encodingStyle);
}
public WSDDJAXRPCHandlerInfoChain getHandlerInfoChain() {
return _wsddHIchain;
}
public void setHandlerInfoChain(WSDDJAXRPCHandlerInfoChain hichain) {
_wsddHIchain = hichain;
}
}
|
