From bdd0a41aed7edf21ec2a65cfa17a86af2ef8c48a Mon Sep 17 00:00:00 2001 From: dims Date: Tue, 17 Jun 2008 00:23:01 +0000 Subject: Move Tuscany from Incubator to top level. git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@668359 13f79535-47bb-0310-9956-ffa450edef68 --- .../axis2/assembly/WebServiceAssemblyFactory.java | 31 ++ .../binding/axis2/assembly/WebServiceBinding.java | 51 +++ .../impl/WebServiceAssemblyFactoryImpl.java | 42 ++ .../axis2/assembly/impl/WebServiceBindingImpl.java | 116 +++++ .../ExternalWebServiceConfigurationBuilder.java | 153 +++++++ .../builder/ExternalWebServiceWireBuilder.java | 61 +++ .../WebServiceEntryPointConfigurationBuilder.java | 170 ++++++++ .../ExternalWebServiceRuntimeConfiguration.java | 32 ++ .../WebServiceEntryPointRuntimeConfiguration.java | 32 ++ .../axis2/handler/ExternalWebServiceClient.java | 143 ++++++ .../handler/ExternalWebServiceTargetInvoker.java | 110 +++++ ...bServiceEntryPointInOutSyncMessageReceiver.java | 177 ++++++++ .../axis2/handler/WebServiceEntryPointServlet.java | 480 ++++++++++++++++++++ .../axis2/handler/WebServiceOperationMetaData.java | 484 +++++++++++++++++++++ .../axis2/handler/WebServicePortMetaData.java | 362 +++++++++++++++ .../axis2/loader/WebServiceSCDLModelLoader.java | 74 ++++ .../tuscany/binding/axis2/util/AxiomHelper.java | 185 ++++++++ 17 files changed, 2703 insertions(+) create mode 100644 tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/assembly/WebServiceAssemblyFactory.java create mode 100644 tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/assembly/WebServiceBinding.java create mode 100644 tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/assembly/impl/WebServiceAssemblyFactoryImpl.java create mode 100644 tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/assembly/impl/WebServiceBindingImpl.java create mode 100644 tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/builder/ExternalWebServiceConfigurationBuilder.java create mode 100644 tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/builder/ExternalWebServiceWireBuilder.java create mode 100644 tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/builder/WebServiceEntryPointConfigurationBuilder.java create mode 100644 tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/config/ExternalWebServiceRuntimeConfiguration.java create mode 100644 tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/config/WebServiceEntryPointRuntimeConfiguration.java create mode 100644 tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/handler/ExternalWebServiceClient.java create mode 100644 tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/handler/ExternalWebServiceTargetInvoker.java create mode 100644 tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/handler/WebServiceEntryPointInOutSyncMessageReceiver.java create mode 100644 tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/handler/WebServiceEntryPointServlet.java create mode 100644 tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/handler/WebServiceOperationMetaData.java create mode 100644 tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/handler/WebServicePortMetaData.java create mode 100644 tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/loader/WebServiceSCDLModelLoader.java create mode 100644 tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/util/AxiomHelper.java (limited to 'tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany') diff --git a/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/assembly/WebServiceAssemblyFactory.java b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/assembly/WebServiceAssemblyFactory.java new file mode 100644 index 0000000000..2906435ac4 --- /dev/null +++ b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/assembly/WebServiceAssemblyFactory.java @@ -0,0 +1,31 @@ +/** + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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.tuscany.binding.axis2.assembly; + +import org.apache.tuscany.model.assembly.AssemblyFactory; + +/** + * The Factory for the model. + */ +public interface WebServiceAssemblyFactory extends AssemblyFactory { + + /** + * Returns a new WebServiceBinding. + */ + WebServiceBinding createWebServiceBinding(); + +} diff --git a/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/assembly/WebServiceBinding.java b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/assembly/WebServiceBinding.java new file mode 100644 index 0000000000..6eabebd358 --- /dev/null +++ b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/assembly/WebServiceBinding.java @@ -0,0 +1,51 @@ +/** + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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.tuscany.binding.axis2.assembly; + +import javax.wsdl.Definition; +import javax.wsdl.Port; + +import org.apache.tuscany.model.assembly.Binding; + +/** + * Represents a Web service binding. + */ +public interface WebServiceBinding extends Binding { + + /** + * Returns the WSDL port defining this binding. + */ + Port getWSDLPort(); + + /** + * Returns the WSDL definition containing the WSDL port. + * @return + */ + Definition getWSDLDefinition(); + + /** + * Sets the WSDL port defining this binding. + */ + void setWSDLPort(Port value); + + /** + * Sets the WSDL definition containing the WSDL port. + * @param definition + */ + void setWSDLDefinition(Definition definition); + +} diff --git a/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/assembly/impl/WebServiceAssemblyFactoryImpl.java b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/assembly/impl/WebServiceAssemblyFactoryImpl.java new file mode 100644 index 0000000000..7840ebf6ef --- /dev/null +++ b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/assembly/impl/WebServiceAssemblyFactoryImpl.java @@ -0,0 +1,42 @@ +/** + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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.tuscany.binding.axis2.assembly.impl; + +import org.apache.tuscany.binding.axis2.assembly.WebServiceAssemblyFactory; +import org.apache.tuscany.binding.axis2.assembly.WebServiceBinding; +import org.apache.tuscany.model.assembly.impl.AssemblyFactoryImpl; + +/** + * An implementation of the model Factory. + */ +public class WebServiceAssemblyFactoryImpl extends AssemblyFactoryImpl implements WebServiceAssemblyFactory { + + /** + * Creates an instance of the factory. + */ + public WebServiceAssemblyFactoryImpl() { + super(); + } + + /** + * @see org.apache.tuscany.binding.axis2.assembly.WebServiceAssemblyFactory#createWebServiceBinding() + */ + public WebServiceBinding createWebServiceBinding() { + return new WebServiceBindingImpl(); + } + +} diff --git a/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/assembly/impl/WebServiceBindingImpl.java b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/assembly/impl/WebServiceBindingImpl.java new file mode 100644 index 0000000000..d89055ff73 --- /dev/null +++ b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/assembly/impl/WebServiceBindingImpl.java @@ -0,0 +1,116 @@ +/** + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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.tuscany.binding.axis2.assembly.impl; + +import java.util.Collection; +import java.util.List; + +import javax.wsdl.Definition; +import javax.wsdl.Port; +import javax.wsdl.Service; + +import org.apache.tuscany.binding.axis2.assembly.WebServiceBinding; +import org.apache.tuscany.model.assembly.AssemblyModelContext; +import org.apache.tuscany.model.assembly.impl.BindingImpl; + +/** + * An implementation of WebServiceBinding. + */ +public class WebServiceBindingImpl extends BindingImpl implements WebServiceBinding { + + private Definition definition; + private Port port; + private String portURI; + + /** + * Constructor + */ + protected WebServiceBindingImpl() { + } + + /** + * @see org.apache.tuscany.binding.axis2.assembly.WebServiceBinding#getWSDLPort() + */ + public Port getWSDLPort() { + return port; + } + + /** + * @see org.apache.tuscany.binding.axis2.assembly.WebServiceBinding#setWSDLPort(javax.wsdl.Port) + */ + public void setWSDLPort(Port value) { + checkNotFrozen(); + this.port=value; + } + + /** + * @see org.apache.tuscany.binding.axis2.assembly.WebServiceBinding#getWSDLDefinition() + */ + public Definition getWSDLDefinition() { + return definition; + } + + /** + * @see org.apache.tuscany.binding.axis2.assembly.WebServiceBinding#setWSDLDefinition(javax.wsdl.Definition) + */ + public void setWSDLDefinition(Definition definition) { + checkNotFrozen(); + this.definition=definition; + } + + /** + * @param portURI The portURI to set. + */ + public void setPortURI(String portURI) { + this.portURI = portURI; + } + + /** + * @see org.apache.tuscany.model.assembly.impl.BindingImpl#initialize(org.apache.tuscany.model.assembly.AssemblyModelContext) + */ + public void initialize(AssemblyModelContext modelContext) { + if (isInitialized()) + return; + super.initialize(modelContext); + + // Get the WSDL port namespace and name + if (port==null && portURI!=null) { + int h=portURI.indexOf('#'); + String portNamespace=portURI.substring(0,h); + String portName=portURI.substring(h+1); + + // Load the WSDL definitions for the given namespace + List definitions=modelContext.getAssemblyLoader().loadDefinitions(portNamespace); + if (definitions==null) + throw new IllegalArgumentException("Cannot find WSDL definition for "+portNamespace); + for (Definition definition: definitions) { + + // Find the port with the given name + for (Service service : (Collection)definition.getServices().values()) { + Port port=service.getPort(portName); + if (port!=null) { + this.definition=definition; + this.port=port; + return; + } + } + } + throw new IllegalArgumentException("Cannot find WSDL port "+portURI); + } + } + +} diff --git a/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/builder/ExternalWebServiceConfigurationBuilder.java b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/builder/ExternalWebServiceConfigurationBuilder.java new file mode 100644 index 0000000000..bae333ad85 --- /dev/null +++ b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/builder/ExternalWebServiceConfigurationBuilder.java @@ -0,0 +1,153 @@ +/** + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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.tuscany.binding.axis2.builder; + +import java.lang.reflect.Method; +import java.util.Collection; +import java.util.Map; +import java.util.Set; + +import org.apache.tuscany.binding.axis2.assembly.WebServiceBinding; +import org.apache.tuscany.binding.axis2.config.ExternalWebServiceRuntimeConfiguration; +import org.apache.tuscany.binding.axis2.handler.ExternalWebServiceClient; +import org.apache.tuscany.core.builder.BuilderException; +import org.apache.tuscany.core.builder.RuntimeConfigurationBuilder; +import org.apache.tuscany.core.config.JavaIntrospectionHelper; +import org.apache.tuscany.core.context.Context; +import org.apache.tuscany.core.context.QualifiedName; +import org.apache.tuscany.core.injection.SingletonObjectFactory; +import org.apache.tuscany.core.invocation.InvocationConfiguration; +import org.apache.tuscany.core.invocation.MethodHashMap; +import org.apache.tuscany.core.invocation.ProxyConfiguration; +import org.apache.tuscany.core.invocation.impl.InvokerInterceptor; +import org.apache.tuscany.core.invocation.spi.ProxyFactory; +import org.apache.tuscany.core.invocation.spi.ProxyFactoryFactory; +import org.apache.tuscany.core.message.MessageFactory; +import org.apache.tuscany.core.runtime.RuntimeContext; +import org.apache.tuscany.core.system.annotation.Autowire; +import org.apache.tuscany.model.assembly.AssemblyModelObject; +import org.apache.tuscany.model.assembly.ConfiguredService; +import org.apache.tuscany.model.assembly.ExternalService; +import org.apache.tuscany.model.assembly.Service; +import org.apache.tuscany.model.assembly.ServiceContract; +import org.osoa.sca.annotations.Init; +import org.osoa.sca.annotations.Scope; + +import commonj.sdo.helper.TypeHelper; + +/** + * Creates a RuntimeConfigurationBuilder for an external service configured with the {@link WebServiceBinding} + * + * @version $Rev$ $Date$ + */ +@Scope("MODULE") +public class ExternalWebServiceConfigurationBuilder implements RuntimeConfigurationBuilder { + + private RuntimeContext runtimeContext; + + private ProxyFactoryFactory proxyFactoryFactory; + + private MessageFactory messageFactory; + + private RuntimeConfigurationBuilder policyBuilder; + + public ExternalWebServiceConfigurationBuilder() { + } + + @Init(eager = true) + public void init() { + runtimeContext.addBuilder(this); + } + + /** + * @param runtimeContext The runtimeContext to set. + */ + @Autowire + public void setRuntimeContext(RuntimeContext runtimeContext) { + this.runtimeContext = runtimeContext; + } + + /** + * Sets the factory used to construct proxies implmementing the business interface required by a reference + */ + @Autowire + public void setProxyFactoryFactory(ProxyFactoryFactory factory) { + this.proxyFactoryFactory = factory; + } + + /** + * Sets the factory used to construct invocation messages + * + * @param msgFactory + */ + @Autowire + public void setMessageFactory(MessageFactory msgFactory) { + this.messageFactory = msgFactory; + } + + /** + * Sets a builder responsible for creating source-side and target-side invocation chains for a reference. The + * reference builder may be hierarchical, containing other child reference builders that operate on specific + * metadata used to construct and invocation chain. + * + * @see org.apache.tuscany.core.builder.impl.HierarchicalBuilder + */ + public void setPolicyBuilder(RuntimeConfigurationBuilder builder) { + policyBuilder = builder; + } + + public void build(AssemblyModelObject object, Context context) throws BuilderException { + if (!(object instanceof ExternalService)) { + return; + } + ExternalService externalService = (ExternalService) object; + if (externalService.getBindings().size() < 1 || !(externalService.getBindings().get(0) instanceof WebServiceBinding)) { + return; + } + + WebServiceBinding wsBinding=(WebServiceBinding)externalService.getBindings().get(0); + + TypeHelper typeHelper=externalService.getAggregate().getAssemblyModelContext().getTypeHelper(); + ExternalWebServiceClient externalWebServiceClient=new ExternalWebServiceClient(externalService, wsBinding, typeHelper); + ExternalWebServiceRuntimeConfiguration config = new ExternalWebServiceRuntimeConfiguration(externalService.getName(), new SingletonObjectFactory(externalWebServiceClient)); + + ConfiguredService configuredService = externalService.getConfiguredService(); + Service service = configuredService.getService(); + ServiceContract serviceContract = service.getServiceContract(); + Map iConfigMap = new MethodHashMap(); + ProxyFactory proxyFactory = proxyFactoryFactory.createProxyFactory(); + Set javaMethods = JavaIntrospectionHelper.getAllUniqueMethods(serviceContract.getInterface()); + for (Method method : javaMethods) { + InvocationConfiguration iConfig = new InvocationConfiguration(method); + iConfigMap.put(method, iConfig); + } + QualifiedName qName = new QualifiedName(externalService.getName() + "/" + service.getName()); + ProxyConfiguration pConfiguration = new ProxyConfiguration(qName, iConfigMap, serviceContract.getInterface().getClassLoader(), messageFactory); + proxyFactory.setBusinessInterface(serviceContract.getInterface()); + proxyFactory.setProxyConfiguration(pConfiguration); + config.addTargetProxyFactory(service.getName(), proxyFactory); + configuredService.setProxyFactory(proxyFactory); + if (policyBuilder != null) { + // invoke the reference builder to handle additional policy metadata + policyBuilder.build(configuredService, context); + } + // add tail interceptor + for (InvocationConfiguration iConfig : (Collection) iConfigMap.values()) { + iConfig.addTargetInterceptor(new InvokerInterceptor()); + } + + externalService.getConfiguredService().setRuntimeConfiguration(config); + } + +} diff --git a/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/builder/ExternalWebServiceWireBuilder.java b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/builder/ExternalWebServiceWireBuilder.java new file mode 100644 index 0000000000..4daf167d74 --- /dev/null +++ b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/builder/ExternalWebServiceWireBuilder.java @@ -0,0 +1,61 @@ +package org.apache.tuscany.binding.axis2.builder; + +import org.apache.tuscany.binding.axis2.config.ExternalWebServiceRuntimeConfiguration; +import org.apache.tuscany.binding.axis2.handler.ExternalWebServiceTargetInvoker; +import org.apache.tuscany.core.builder.BuilderConfigException; +import org.apache.tuscany.core.builder.WireBuilder; +import org.apache.tuscany.core.context.ScopeContext; +import org.apache.tuscany.core.invocation.InvocationConfiguration; +import org.apache.tuscany.core.invocation.spi.ProxyFactory; +import org.apache.tuscany.core.runtime.RuntimeContext; +import org.apache.tuscany.core.system.annotation.Autowire; +import org.osoa.sca.annotations.Init; +import org.osoa.sca.annotations.Scope; + +@Scope("MODULE") +public class ExternalWebServiceWireBuilder implements WireBuilder { + + private RuntimeContext runtimeContext; + + /** + * Constructs a new ExternalWebServiceWireBuilder. + */ + public ExternalWebServiceWireBuilder() { + super(); + } + + @Autowire + public void setRuntimeContext(RuntimeContext context) { + runtimeContext = context; + } + + @Init(eager=true) + public void init() { + runtimeContext.addBuilder(this); + } + + public void connect(ProxyFactory sourceFactory, ProxyFactory targetFactory, Class targetType, boolean downScope, ScopeContext targetScopeContext) throws BuilderConfigException { + if (!(ExternalWebServiceRuntimeConfiguration.class.isAssignableFrom(targetType))) { + return; + } + for (InvocationConfiguration sourceInvocationConfig : sourceFactory.getProxyConfiguration().getInvocationConfigurations().values()) { + + ExternalWebServiceTargetInvoker invoker = new ExternalWebServiceTargetInvoker(sourceFactory.getProxyConfiguration().getTargetName(), sourceInvocationConfig.getMethod(), targetScopeContext); + + // if (downScope) { + // // the source scope is shorter than the target, so the invoker can cache the target instance + // invoker.setCacheable(true); + // } else { + // invoker.setCacheable(false); + // } + sourceInvocationConfig.setTargetInvoker(invoker); + } + + } + + public void completeTargetChain(ProxyFactory targetFactory, Class targetType, ScopeContext targetScopeContext) + throws BuilderConfigException { + //TODO implement + } + +} diff --git a/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/builder/WebServiceEntryPointConfigurationBuilder.java b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/builder/WebServiceEntryPointConfigurationBuilder.java new file mode 100644 index 0000000000..a164f5bc44 --- /dev/null +++ b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/builder/WebServiceEntryPointConfigurationBuilder.java @@ -0,0 +1,170 @@ +/** + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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.tuscany.binding.axis2.builder; + +import java.lang.reflect.Method; +import java.util.Collection; +import java.util.HashMap; +import java.util.Map; +import java.util.Set; + +import org.apache.tuscany.binding.axis2.assembly.WebServiceBinding; +import org.apache.tuscany.binding.axis2.config.WebServiceEntryPointRuntimeConfiguration; +import org.apache.tuscany.core.builder.BuilderException; +import org.apache.tuscany.core.builder.RuntimeConfigurationBuilder; +import org.apache.tuscany.core.builder.impl.EntryPointRuntimeConfiguration; +import org.apache.tuscany.core.config.JavaIntrospectionHelper; +import org.apache.tuscany.core.context.AggregateContext; +import org.apache.tuscany.core.context.QualifiedName; +import org.apache.tuscany.core.invocation.Interceptor; +import org.apache.tuscany.core.invocation.InvocationConfiguration; +import org.apache.tuscany.core.invocation.InvocationRuntimeException; +import org.apache.tuscany.core.invocation.ProxyConfiguration; +import org.apache.tuscany.core.invocation.TargetInvoker; +import org.apache.tuscany.core.invocation.spi.ProxyFactory; +import org.apache.tuscany.core.invocation.spi.ProxyFactoryFactory; +import org.apache.tuscany.core.message.Message; +import org.apache.tuscany.core.message.MessageFactory; +import org.apache.tuscany.core.runtime.RuntimeContext; +import org.apache.tuscany.core.system.annotation.Autowire; +import org.apache.tuscany.model.assembly.AssemblyModelObject; +import org.apache.tuscany.model.assembly.ConfiguredService; +import org.apache.tuscany.model.assembly.EntryPoint; +import org.apache.tuscany.model.assembly.Service; +import org.apache.tuscany.model.assembly.ServiceContract; +import org.osoa.sca.annotations.Init; +import org.osoa.sca.annotations.Scope; + +/** + * Creates a RuntimeConfigurationBuilder for an entry point configured with the {@link WebServiceBinding} + * + * @version $Rev$ $Date$ + */ +@Scope("MODULE") +public class WebServiceEntryPointConfigurationBuilder implements RuntimeConfigurationBuilder { + + private RuntimeContext runtimeContext; + + private ProxyFactoryFactory proxyFactoryFactory; + + private MessageFactory messageFactory; + + private RuntimeConfigurationBuilder policyBuilder; + + public WebServiceEntryPointConfigurationBuilder() { + } + + @Init(eager = true) + public void init() { + runtimeContext.addBuilder(this); + } + + /** + * @param runtimeContext The runtimeContext to set. + */ + @Autowire + public void setRuntimeContext(RuntimeContext runtimeContext) { + this.runtimeContext = runtimeContext; + } + + /** + * Sets the factory used to construct proxies implmementing the business interface required by a reference + */ + @Autowire + public void setProxyFactoryFactory(ProxyFactoryFactory factory) { + this.proxyFactoryFactory = factory; + } + + /** + * Sets the factory used to construct invocation messages + * + * @param msgFactory + */ + @Autowire + public void setMessageFactory(MessageFactory msgFactory) { + this.messageFactory = msgFactory; + } + + /** + * Sets a builder responsible for creating source-side and target-side invocation chains for a reference. The + * reference builder may be hierarchical, containing other child reference builders that operate on specific + * metadata used to construct and invocation chain. + * + * @see org.apache.tuscany.core.builder.impl.HierarchicalBuilder + */ + public void setPolicyBuilder(RuntimeConfigurationBuilder builder) { + policyBuilder = builder; + } + + public void build(AssemblyModelObject object, AggregateContext parentContext) throws BuilderException { + if (!(object instanceof EntryPoint)) { + return; + } + EntryPoint entryPoint = (EntryPoint) object; + if (entryPoint.getBindings().size() < 1 || !(entryPoint.getBindings().get(0) instanceof WebServiceBinding)) { + return; + } + + EntryPointRuntimeConfiguration config = new WebServiceEntryPointRuntimeConfiguration(entryPoint.getName(), entryPoint.getConfiguredService().getService().getName(), messageFactory); + + ConfiguredService configuredService = entryPoint.getConfiguredService(); + Service service = configuredService.getService(); + ServiceContract serviceContract = service.getServiceContract(); + Map iConfigMap = new HashMap(); + ProxyFactory proxyFactory = proxyFactoryFactory.createProxyFactory(); + Set javaMethods = JavaIntrospectionHelper.getAllUniqueMethods(serviceContract.getInterface()); + for (Method method : javaMethods) { + InvocationConfiguration iConfig = new InvocationConfiguration(method); + iConfigMap.put(method, iConfig); + } + QualifiedName qName = new QualifiedName(entryPoint.getConfiguredReference().getTargetConfiguredServices().get(0).getAggregatePart().getName() + "/" + service.getName()); + ProxyConfiguration pConfiguration = new ProxyConfiguration(qName, iConfigMap, serviceContract.getInterface().getClassLoader(), messageFactory); + proxyFactory.setBusinessInterface(serviceContract.getInterface()); + proxyFactory.setProxyConfiguration(pConfiguration); + config.addSourceProxyFactory(service.getName(), proxyFactory); + configuredService.setProxyFactory(proxyFactory); + if (policyBuilder != null) { + // invoke the reference builder to handle additional policy metadata + policyBuilder.build(configuredService, parentContext); + } + // add tail interceptor + for (InvocationConfiguration iConfig : (Collection) iConfigMap.values()) { + iConfig.addTargetInterceptor(new EntryPointInvokerInterceptor()); + } + entryPoint.getConfiguredReference().setRuntimeConfiguration(config); + } + + //FIXME same as the InvokerInterceptor except that it doesn't throw an exception in setNext + // For some reason another InvokerInterceptor is added after this one, need Jim to look into it + // and figure out why. + public class EntryPointInvokerInterceptor implements Interceptor { + + public EntryPointInvokerInterceptor() { + } + + public Message invoke(Message msg) throws InvocationRuntimeException { + TargetInvoker invoker = msg.getTargetInvoker(); + if (invoker == null) { + throw new InvocationRuntimeException("No target invoker specified on message"); + } + return invoker.invoke(msg); + } + + public void setNext(Interceptor next) { + } + + } + + +} diff --git a/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/config/ExternalWebServiceRuntimeConfiguration.java b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/config/ExternalWebServiceRuntimeConfiguration.java new file mode 100644 index 0000000000..c776e861e2 --- /dev/null +++ b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/config/ExternalWebServiceRuntimeConfiguration.java @@ -0,0 +1,32 @@ +/** + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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.tuscany.binding.axis2.config; + +import org.apache.tuscany.core.builder.ObjectFactory; +import org.apache.tuscany.core.builder.impl.BaseExternalServiceRuntimeConfiguration; + +/** + * Creates instances of {@link org.apache.tuscany.core.context.ExternalServiceContext} configured with the appropriate + * invocation chains and bindings. This implementation serves as a marker for + * {@link org.apache.tuscany.binding.axis2.builder.ExternalWebServiceWireBuilder} + * + * @version $Rev$ $Date$ + */ +public class ExternalWebServiceRuntimeConfiguration extends BaseExternalServiceRuntimeConfiguration { + + public ExternalWebServiceRuntimeConfiguration(String name, ObjectFactory objectFactory) { + super(name, objectFactory); + } + +} diff --git a/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/config/WebServiceEntryPointRuntimeConfiguration.java b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/config/WebServiceEntryPointRuntimeConfiguration.java new file mode 100644 index 0000000000..3038fa258e --- /dev/null +++ b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/config/WebServiceEntryPointRuntimeConfiguration.java @@ -0,0 +1,32 @@ +/** + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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.tuscany.binding.axis2.config; + +import org.apache.tuscany.core.builder.impl.EntryPointRuntimeConfiguration; +import org.apache.tuscany.core.message.MessageFactory; + +/** + * Creates instances of {@link org.apache.tuscany.core.context.EntryPointContext} configured with the appropriate + * invocation chains and bindings. This implementation serves as a marker for + * {@link org.apache.tuscany.binding.axis2.builder.WebServiceEntryPointWireBuilder} + * + * @version $Rev$ $Date$ + */ +public class WebServiceEntryPointRuntimeConfiguration extends EntryPointRuntimeConfiguration { + + public WebServiceEntryPointRuntimeConfiguration(String name, String serviceName, MessageFactory messageFactory) { + super(name, serviceName, messageFactory); + } + +} diff --git a/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/handler/ExternalWebServiceClient.java b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/handler/ExternalWebServiceClient.java new file mode 100644 index 0000000000..39bd26f72d --- /dev/null +++ b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/handler/ExternalWebServiceClient.java @@ -0,0 +1,143 @@ +/** + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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.tuscany.binding.axis2.handler; + +import java.lang.reflect.Method; + +import javax.xml.namespace.QName; +import javax.xml.parsers.FactoryConfigurationError; + +import org.apache.axis2.AxisFault; +import org.apache.axis2.Constants; +import org.apache.axis2.addressing.EndpointReference; +import org.apache.axis2.client.Options; +import org.apache.axis2.client.ServiceClient; +import org.apache.axis2.context.MessageContextConstants; +import org.apache.axis2.om.OMElement; +import org.apache.tuscany.binding.axis2.assembly.WebServiceBinding; +import org.apache.tuscany.binding.axis2.util.AxiomHelper; +import org.apache.tuscany.model.assembly.ExternalService; +import org.osoa.sca.ServiceRuntimeException; + +import commonj.sdo.helper.TypeHelper; + +/** + * An ExternalWebServiceClient using Axis2 + */ +public class ExternalWebServiceClient { + + private ExternalService externalService; + private TypeHelper typeHelper; + private WebServicePortMetaData wsPortMetaData; + + /** + * Constructs a new ExternalWebServiceClient. + * + * @param externalService + * @param wsBinding + */ + public ExternalWebServiceClient(ExternalService externalService, WebServiceBinding wsBinding, TypeHelper typeHelper) { + this.externalService = externalService; + this.typeHelper=typeHelper; + this.wsPortMetaData = new WebServicePortMetaData(wsBinding.getWSDLDefinition(), wsBinding.getWSDLPort(), wsBinding.getURI(), false); + } + + /** + * Invoke an operation on the external Web service. + * + * @param method + * @param args + * @return + */ + public Object invoke(Method method, Object[] args) { + + ServiceClient serviceClient; + ClassLoader ccl=Thread.currentThread().getContextClassLoader(); + try { + Thread.currentThread().setContextClassLoader(ExternalWebServiceClient.class.getClassLoader()); + + serviceClient = createServiceClient(method); + + } finally { + Thread.currentThread().setContextClassLoader(ccl); + } + + String typeName = method.getName(); + String typeNS = wsPortMetaData.getPortType().getQName().getNamespaceURI(); + + OMElement requestOM = AxiomHelper.toOMElement(typeHelper, args, new QName(typeNS, typeName)); + + OMElement responseOM; + ccl=Thread.currentThread().getContextClassLoader(); + try { + Thread.currentThread().setContextClassLoader(ExternalWebServiceClient.class.getClassLoader()); + + responseOM = serviceClient.sendReceive(requestOM); + + } catch (AxisFault e) { + throw new ServiceRuntimeException(e); + } finally { + Thread.currentThread().setContextClassLoader(ccl); + } + + Object[] os = AxiomHelper.toObjects(typeHelper, responseOM); + Object response; + if (os == null || os.length < 1) { + response = null; + } else { + response = os[0]; + } + + return response; + } + + private ServiceClient createServiceClient(Method method) throws FactoryConfigurationError { + + /* + * TODO: Simlistic impl for now, needs to be redone. Should cache our ConfigurationContext and pass in on ServiceClient constructor, should + * probably use WSDL configured Axis2 OperationClient + */ + + Options options = new Options(); + + options.setProperty(Constants.Configuration.DISABLE_ADDRESSING_FOR_OUT_MESSAGES, Boolean.TRUE); + + WebServiceOperationMetaData operationMetaData = wsPortMetaData.getOperationMetaData(method.getName()); + + EndpointReference targetEPR = new EndpointReference(wsPortMetaData.getEndpoint()); + options.setTo(targetEPR); + + String soapAction = operationMetaData.getSOAPAction(); + if (soapAction != null) { + options.setSoapAction(soapAction); + } + + // If use is encoded assume its an old style service and wont understand chunking + if ("encoded".equals(operationMetaData.getUse())) { + options.setProperty(MessageContextConstants.CHUNKED, Boolean.FALSE); + } + + ServiceClient serviceClient; + try { + serviceClient = new ServiceClient(); + } catch (org.apache.axis2.AxisFault e) { + throw new RuntimeException(e); + } + + serviceClient.setOptions(options); + + return serviceClient; + } + +} diff --git a/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/handler/ExternalWebServiceTargetInvoker.java b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/handler/ExternalWebServiceTargetInvoker.java new file mode 100644 index 0000000000..fcb2e2e944 --- /dev/null +++ b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/handler/ExternalWebServiceTargetInvoker.java @@ -0,0 +1,110 @@ +/** + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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.tuscany.binding.axis2.handler; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +import org.apache.tuscany.core.context.ExternalServiceContext; +import org.apache.tuscany.core.context.InstanceContext; +import org.apache.tuscany.core.context.QualifiedName; +import org.apache.tuscany.core.context.ScopeContext; +import org.apache.tuscany.core.context.TargetException; +import org.apache.tuscany.core.invocation.Interceptor; +import org.apache.tuscany.core.invocation.TargetInvoker; +import org.apache.tuscany.core.message.Message; + +/** + * Responsible for invoking an external web service + * + * @version $Rev$ $Date$ + */ +public class ExternalWebServiceTargetInvoker implements TargetInvoker { + + private QualifiedName serviceName; + private String esName; + private Method method; + private ScopeContext container; + + private ExternalServiceContext context; + + /** + * Constructs a new ExternalWebServiceTargetInvoker. + * @param esName + * @param container + */ + public ExternalWebServiceTargetInvoker(QualifiedName serviceName, Method method, ScopeContext container) { + assert (serviceName != null) : "No service name specified"; + assert (method != null) : "No method specified"; + assert (container != null) : "No scope container specified"; + this.serviceName = serviceName; + this.esName=serviceName.getPartName(); + this.method = method; + this.container = container; + } + + public Object invokeTarget(Object payload) throws InvocationTargetException { + if (context == null) { + InstanceContext iContext = container.getContext(esName); + if (!(iContext instanceof ExternalServiceContext)) { + TargetException te = new TargetException("Unexpected target context type"); + te.setIdentifier(iContext.getClass().getName()); + te.addContextName(iContext.getName()); + throw te; + } + context = (ExternalServiceContext) iContext; + } + ExternalWebServiceClient client = (ExternalWebServiceClient) context.getImplementationInstance(true); + if (payload != null) { + return client.invoke(method, (Object[])payload); + } else { + return client.invoke(method, null); + } + } + + public boolean isCacheable() { + return false; + } + + public Message invoke(Message msg) { + try { + Object resp = invokeTarget(msg.getBody()); + msg.setBody(resp); + } catch (InvocationTargetException e) { + msg.setBody(e.getCause()); + } catch (Throwable e) { + msg.setBody(e); + } + return msg; + } + + public void setNext(Interceptor next) { + throw new UnsupportedOperationException(); + } + + public Object clone() { + try { + ExternalWebServiceTargetInvoker invoker = (ExternalWebServiceTargetInvoker) super.clone(); + invoker.container = container; + invoker.context = this.context; + invoker.esName = this.esName; + invoker.method = this.method; + invoker.serviceName = this.serviceName; + return invoker; + } catch (CloneNotSupportedException e) { + return null; // will not happen + } + } + +} diff --git a/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/handler/WebServiceEntryPointInOutSyncMessageReceiver.java b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/handler/WebServiceEntryPointInOutSyncMessageReceiver.java new file mode 100644 index 0000000000..f0f49d5654 --- /dev/null +++ b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/handler/WebServiceEntryPointInOutSyncMessageReceiver.java @@ -0,0 +1,177 @@ +package org.apache.tuscany.binding.axis2.handler; + +import java.io.IOException; +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.ListIterator; + +import javax.wsdl.Part; +import javax.xml.namespace.QName; +import javax.xml.stream.XMLStreamException; + +import org.apache.axis2.AxisFault; +import org.apache.axis2.context.MessageContext; +import org.apache.axis2.context.OperationContext; +import org.apache.axis2.description.AxisOperation; +import org.apache.axis2.engine.MessageReceiver; +import org.apache.axis2.om.OMAbstractFactory; +import org.apache.axis2.om.OMDocument; +import org.apache.axis2.om.OMElement; +import org.apache.axis2.om.OMFactory; +import org.apache.axis2.om.OMNamespace; +import org.apache.axis2.receivers.AbstractInOutSyncMessageReceiver; +import org.apache.axis2.soap.SOAPBody; +import org.apache.axis2.soap.SOAPEnvelope; +import org.apache.axis2.soap.SOAPFactory; +import org.apache.tuscany.binding.axis2.util.AxiomHelper; +import org.apache.tuscany.core.context.AggregateContext; +import org.apache.tuscany.core.context.EntryPointContext; +import org.apache.tuscany.core.context.InstanceContext; +import org.apache.tuscany.model.assembly.EntryPoint; +import org.apache.tuscany.sdo.helper.TypeHelperImpl; +import org.apache.tuscany.sdo.util.SDOUtil; +import org.apache.wsdl.WSDLConstants; +import org.eclipse.emf.common.util.UniqueEList; + +import commonj.sdo.DataObject; +import commonj.sdo.Property; +import commonj.sdo.Sequence; +import commonj.sdo.Type; +import commonj.sdo.helper.TypeHelper; + +public class WebServiceEntryPointInOutSyncMessageReceiver extends AbstractInOutSyncMessageReceiver { + // public static final String MEP_URL = "http://www.w3.org/2004/08/wsdl/tuscany/in-out"; + public static final String MEP_URL = WSDLConstants.MEP_URI_OUT_IN; + + protected final AggregateContext moduleContext; + + protected final EntryPoint entryPoint; + protected final EntryPointContext entryPointContext; + + private final WebServicePortMetaData wsdlPortInfo; + + /** + * Field log + */ + + /** + * Constructor WebServiceEntryPointInOutSyncMessageReceiver + * + * @param entryPoint + * @param moduleContext + * @param context + * @param wsdlPortInfo + */ + public WebServiceEntryPointInOutSyncMessageReceiver(AggregateContext moduleContext, EntryPoint entryPoint, EntryPointContext context, WebServicePortMetaData wsdlPortInfo) { + this.moduleContext = moduleContext; + this.entryPoint = entryPoint; + this.entryPointContext= context; + this.wsdlPortInfo = wsdlPortInfo; + } + + public void invokeBusinessLogic(MessageContext msgContext, MessageContext outMsgContext) throws AxisFault { + + ClassLoader ccl=Thread.currentThread().getContextClassLoader(); + try { + Thread.currentThread().setContextClassLoader(entryPoint.getAggregate().getAssemblyModelContext().getApplicationResourceLoader().getClassLoader()); + + AxisOperation axisOperation = msgContext.getAxisOperation(); + String axisOperationName= axisOperation.getName().getLocalPart(); + + TypeHelper typeHelper=entryPoint.getAggregate().getAssemblyModelContext().getTypeHelper(); + + OMElement requestOM = msgContext.getEnvelope().getBody().getFirstElement(); + DataObject msgdo = AxiomHelper.toDataObject(typeHelper, requestOM); + // Sequence parmSeq = msgdo.getSequence("mixed"); + + requestOM = msgContext.getEnvelope().getBody().getFirstElement(); + Object[] args = AxiomHelper.toObjects(typeHelper, requestOM); + + + + +// ArrayList parms = new ArrayList(parmSeq.size()); +// for (int i = 0; i < parmSeq.size(); ++i) { +// Object parmDO = (Object) parmSeq.getValue(i);// parm element +// if (parmDO instanceof DataObject) { +// +// Sequence nn = ((DataObject) parmDO).getSequence("mixed"); +// +// for (int j = 0; j < nn.size(); j++) { +// +// Object valueDO = (Object) nn.getValue(j); // data array s +// if (valueDO instanceof DataObject) { +// +// Sequence seqVal = ((DataObject) valueDO).getSequence("mixed"); +// Object seqDO = seqVal.getValue(0); +// if (seqDO instanceof String) { +// parms.add(seqDO); +// } else { +// parms.add(valueDO); // no sure if this is right? +// +// } +// } +// } +// } +// } +// Object[] args= parms.toArray(new Object[parms.size()]); + Class[] argsClazz= new Class[args.length]; + for(int i= args.length -1; i> -1; --i){ + argsClazz[i]= args[i].getClass(); + + } + Class clazz = entryPoint.getConfiguredService().getService().getServiceContract().getInterface(); + Method operationMethod= clazz.getMethod(axisOperationName, argsClazz); + + + InvocationHandler handler = (InvocationHandler) entryPointContext.getImplementationInstance(); + + + Object response = handler.invoke(null, operationMethod, args); + + + SOAPFactory fac = getSOAPFactory(msgContext); + SOAPEnvelope soapenv = fac.getDefaultEnvelope(); + SOAPBody soapbody = soapenv.getBody(); + //new SDO way.... + QName responseTypeQN = getResponseTypeName(operationMethod.getName()); + OMElement responseOM = AxiomHelper.toOMElement(typeHelper, new Object[] {response}, responseTypeQN); + soapbody.addChild(responseOM); + + + + //Endof new SDO way + + + + + + // se.addChild(sf.createText(response, true)); + outMsgContext.setEnvelope(soapenv); + // outMsgContext.setAxisOperation(axisOperation); + // outMsgContext.setAxisService(msgContext.getAxisService()); + + + } catch (Exception e) { + e.printStackTrace(); + throw new AxisFault("Error creating DataObject from Soapenvelope. " + e.getClass() + " " + e.getMessage(), e); + + } catch (Throwable e) { + + e.printStackTrace(); + throw new AxisFault("Error creating DataObject from Soapenvelope. " + e.getClass() + " " + e.getMessage(), e); + } finally { + Thread.currentThread().setContextClassLoader(ccl); + } + + } + protected QName getResponseTypeName(String operationName) { + WebServiceOperationMetaData op = wsdlPortInfo.getOperationMetaData(operationName); + Part part = op.getOutputPart(0); + QName elementName = part.getElementName(); + return elementName; + } + + +} diff --git a/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/handler/WebServiceEntryPointServlet.java b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/handler/WebServiceEntryPointServlet.java new file mode 100644 index 0000000000..cfcac3acdd --- /dev/null +++ b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/handler/WebServiceEntryPointServlet.java @@ -0,0 +1,480 @@ +/** + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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.tuscany.binding.axis2.handler; + +import java.io.File; +import java.io.IOException; +import java.io.OutputStream; +import java.util.Enumeration; +import java.util.HashMap; +import java.util.Iterator; +import java.util.Map; + +import javax.servlet.ServletConfig; +import javax.servlet.ServletContext; +import javax.servlet.ServletException; +import javax.servlet.http.HttpServlet; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import javax.wsdl.Definition; +import javax.wsdl.Operation; +import javax.wsdl.Port; +import javax.wsdl.PortType; +import javax.xml.namespace.QName; + +import org.apache.axis2.AxisFault; +import org.apache.axis2.Constants; +import org.apache.axis2.context.ConfigurationContext; +import org.apache.axis2.context.ConfigurationContextFactory; +import org.apache.axis2.context.MessageContext; +import org.apache.axis2.context.SessionContext; +import org.apache.axis2.description.AxisOperation; +import org.apache.axis2.description.AxisService; +import org.apache.axis2.description.AxisServiceGroup; +import org.apache.axis2.description.InOutAxisOperation; +import org.apache.axis2.engine.AxisConfiguration; +import org.apache.axis2.engine.AxisEngine; +import org.apache.axis2.transport.http.HTTPConstants; +import org.apache.axis2.transport.http.HTTPTransportUtils; +import org.apache.axis2.transport.http.ListingAgent; +import org.apache.axis2.transport.http.ServletBasedOutTransportInfo; +import org.apache.tuscany.binding.axis2.assembly.WebServiceBinding; +import org.apache.tuscany.core.context.AggregateContext; +import org.apache.tuscany.core.context.EntryPointContext; +import org.apache.tuscany.core.context.InstanceContext; +import org.apache.tuscany.core.runtime.RuntimeContext; +import org.apache.tuscany.model.assembly.Binding; +import org.apache.tuscany.model.assembly.Component; +import org.apache.tuscany.model.assembly.EntryPoint; +import org.apache.tuscany.model.assembly.Module; + +/** + * Class AxisServlet + */ +public class WebServiceEntryPointServlet + extends HttpServlet +{ + + private static final long serialVersionUID = -2085869393709833372L; + + private static final String CONFIGURATION_CONTEXT = "CONFIGURATION_CONTEXT"; + + public static final String SESSION_ID = "SessionId"; + + private ConfigurationContext configContext; + + private AxisConfiguration axisConfiguration; + + private ListingAgent lister; + + private MessageContext createAndSetInitialParamsToMsgCtxt( Object sessionContext, MessageContext msgContext, + HttpServletResponse httpServletResponse, + HttpServletRequest httpServletRequest ) + throws AxisFault + { + msgContext = new MessageContext(); + msgContext.setConfigurationContext( configContext ); + msgContext.setSessionContext( (SessionContext) sessionContext ); + msgContext.setTransportIn( axisConfiguration.getTransportIn( new QName( Constants.TRANSPORT_HTTP ) ) ); + msgContext.setTransportOut( axisConfiguration.getTransportOut( new QName( Constants.TRANSPORT_HTTP ) ) ); + + msgContext.setProperty( Constants.OUT_TRANSPORT_INFO, new ServletBasedOutTransportInfo( httpServletResponse ) ); + msgContext.setProperty( MessageContext.TRANSPORT_HEADERS, getTransportHeaders( httpServletRequest ) ); + msgContext.setProperty( SESSION_ID, httpServletRequest.getSession().getId() ); + + return msgContext; + } + + public void destroy() + { + super.destroy(); + } + + /** + * Method doGet + * + * @param httpServletRequest + * @param httpServletResponse + * @throws ServletException + * @throws IOException + */ + protected void doGet( HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse ) + throws ServletException, IOException + { + MessageContext msgContext = null; + OutputStream out = null; + + try + { + Object sessionContext = getSessionContext( httpServletRequest ); + HashMap map = getHTTPParameters( httpServletRequest ); + + msgContext = createAndSetInitialParamsToMsgCtxt( sessionContext, msgContext, httpServletResponse, + httpServletRequest ); + msgContext.setDoingREST( true ); + msgContext.setServerSide( true ); + out = httpServletResponse.getOutputStream(); + + boolean processed = HTTPTransportUtils.processHTTPGetRequest( msgContext, httpServletRequest + .getInputStream(), out, httpServletRequest.getContentType(), httpServletRequest + .getHeader( HTTPConstants.HEADER_SOAP_ACTION ), httpServletRequest.getRequestURL().toString(), + configContext, map ); + + if ( !processed ) + { + lister.handle( httpServletRequest, httpServletResponse, out ); + } + } + catch ( AxisFault e ) + { + if ( msgContext != null ) + { + handleFault( msgContext, out, e ); + } + else + { + throw new ServletException( e ); + } + } + catch ( Exception e ) + { + throw new ServletException( e ); + } + } + + /* + * (non-Javadoc) + * @see javax.servlet.http.HttpServlet#doPost(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse) + */ + + /** + * Method doPost + * + * @param req + * @param res + * @throws ServletException + * @throws IOException + */ + protected void doPost( HttpServletRequest req, HttpServletResponse res ) + throws ServletException, IOException + { + MessageContext msgContext = null; + OutputStream out = null; + + ClassLoader tccl = Thread.currentThread().getContextClassLoader(); + ClassLoader mycl = getClass().getClassLoader(); + try + { + if ( tccl != mycl ) + { + Thread.currentThread().setContextClassLoader( mycl ); + } + Object sessionContext = getSessionContext( req ); + + msgContext = createAndSetInitialParamsToMsgCtxt( sessionContext, msgContext, res, req ); + + // adding ServletContext into msgContext; + msgContext.setProperty( Constants.SERVLET_CONTEXT, sessionContext ); + out = res.getOutputStream(); + HTTPTransportUtils.processHTTPPostRequest( msgContext, req.getInputStream(), out, req.getContentType(), req + .getHeader( HTTPConstants.HEADER_SOAP_ACTION ), req.getRequestURL().toString() ); + + Object contextWritten = msgContext.getOperationContext().getProperty( Constants.RESPONSE_WRITTEN ); + + res.setContentType( "text/xml; charset=" + msgContext.getProperty( MessageContext.CHARACTER_SET_ENCODING ) ); + + if ( ( contextWritten == null ) || !Constants.VALUE_TRUE.equals( contextWritten ) ) + { + res.setStatus( HttpServletResponse.SC_ACCEPTED ); + } + } + catch ( AxisFault e ) + { + if ( msgContext != null ) + { + res.setStatus( HttpServletResponse.SC_INTERNAL_SERVER_ERROR ); + handleFault( msgContext, out, e ); + } + else + { + throw new ServletException( e ); + } + } + finally + { + if ( tccl != mycl ) + { + Thread.currentThread().setContextClassLoader( tccl ); + } + } + } + + private void handleFault( MessageContext msgContext, OutputStream out, AxisFault e ) + throws AxisFault + { + msgContext.setProperty( MessageContext.TRANSPORT_OUT, out ); + + AxisEngine engine = new AxisEngine( configContext ); + MessageContext faultContext = engine.createFaultMessageContext( msgContext, e ); + + engine.sendFault( faultContext ); + } + + /** + * Method init + * + * @param config + * @throws ServletException + */ + public void init( ServletConfig config ) + throws ServletException + { + ClassLoader tccl = Thread.currentThread().getContextClassLoader(); + ClassLoader mycl = getClass().getClassLoader(); + try + { + if ( tccl != mycl ) + { + Thread.currentThread().setContextClassLoader( mycl ); + } + configContext = initConfigContext( config ); + initTuscany( configContext.getAxisConfiguration(), config ); + lister = new ListingAgent( configContext ); + axisConfiguration = configContext.getAxisConfiguration(); + config.getServletContext().setAttribute( CONFIGURATION_CONTEXT, configContext ); + } + catch ( Exception e ) + { + e.printStackTrace(); + throw new ServletException( e ); + } + finally + { + if ( tccl != mycl ) + { + Thread.currentThread().setContextClassLoader( tccl ); + } + } + } + + RuntimeContext getTuscanyWebAppRuntime( ServletConfig config ) + { + + Object ret = (RuntimeContext) ( config ).getServletContext() + .getAttribute( "org.apache.tuscany.core.runtime.RuntimeContext" ); + if ( !( ret instanceof RuntimeContext ) ) + { + RuntimeException rete = new RuntimeException( "Tuscany configuration not found! " + + ( ( ret == null ) ? "" : "unexpected class" + ret.getClass() ) ); + rete.printStackTrace();//pretty majar make sure something gets logged. + throw rete; + + } + return (RuntimeContext) ret; + } + + void initTuscany( final AxisConfiguration axisConfig, ServletConfig config ) + throws AxisFault + { + + // Register all the Web service entry points + RuntimeContext tuscanyRuntime = getTuscanyWebAppRuntime( config ); + + // Get the current SCA module context + + // AggregateContext moduleContext = (AggregateContext) tuscanyRuntime.getAggregate().getAssemblyModelContext();//getRootContext();//.getModuleComponentContext(); + try + { + tuscanyRuntime.start(); + AggregateContext moduleContext = tuscanyRuntime.getRootContext(); + Module rootModule = (Module) moduleContext.getAggregate(); + + for ( Iterator m = rootModule.getComponents().iterator(); m.hasNext(); ) + { + Module module = (Module) ( (Component) m.next() ).getComponentImplementation(); + + for ( Iterator i = module.getEntryPoints().iterator(); i.hasNext(); ) + { + EntryPoint entryPoint = (EntryPoint) i.next(); + final String epName = entryPoint.getName(); + + ServletContext servletContext = config.getServletContext(); + AggregateContext moduleContext2 = (AggregateContext) servletContext + .getAttribute( "org.apache.tuscany.core.webapp.ModuleComponentContext" ); + InstanceContext entryPointContext = moduleContext2.getContext( epName ); + + Binding binding = (Binding) entryPoint.getBindings().get( 0 ); + if ( binding instanceof WebServiceBinding ) + { + + WebServiceBinding wsBinding = (WebServiceBinding) binding; + Definition definition = wsBinding.getWSDLDefinition(); + Port port = wsBinding.getWSDLPort(); + QName qname = new QName( definition.getTargetNamespace(), port.getName() ); + if ( qname != null ) + { + + WebServicePortMetaData wsdlPortInfo = new WebServicePortMetaData( definition, port, null, + false ); + + WebServiceEntryPointInOutSyncMessageReceiver msgrec = new WebServiceEntryPointInOutSyncMessageReceiver( + moduleContext, + entryPoint, + (EntryPointContext) entryPointContext, + wsdlPortInfo ); + + AxisServiceGroup serviceGroup = new AxisServiceGroup( axisConfig ); + axisConfig + .addMessageReceiver( WebServiceEntryPointInOutSyncMessageReceiver.MEP_URL, msgrec ); + serviceGroup.setServiceGroupName( wsdlPortInfo.getServiceName().getLocalPart() ); + + // to create service from wsdl stream ---> + // AxisServiceBuilder axisServiceBuilder = new AxisServiceBuilder(); + // return axisServiceBuilder.getAxisService(in); + + AxisService axisService = new AxisService( epName ); + axisService.setParent( serviceGroup ); + axisService.setServiceDescription( "Tuscany configured service EntryPoint name '" + epName + + "'" ); + // axisService.setTargetNamespace(wsdlPortInfo.getPortName().getNamespaceURI()); + axisService.addMessageReceiver( WebServiceEntryPointInOutSyncMessageReceiver.MEP_URL, + msgrec ); + + // Create operation descriptions for all the operations + PortType wsdlPortType = wsdlPortInfo.getPortType(); + for ( Iterator j = wsdlPortType.getOperations().iterator(); j.hasNext(); ) + { + Operation wsdlOperation = (Operation) j.next(); + String operationName = wsdlOperation.getName(); + AxisOperation axisOp = new InOutAxisOperation( new javax.xml.namespace.QName( qname + .getNamespaceURI(), operationName ) ); + axisOp.setMessageReceiver( msgrec ); + axisService.addOperation( axisOp ); + axisOp.setMessageExchangePattern( WebServiceEntryPointInOutSyncMessageReceiver.MEP_URL ); + + axisConfig.addService( axisService ); + + } + axisConfig.addServiceGroup( serviceGroup ); + + } + + } + } + } + } + finally + { + // tuscanyRuntime.stop(); + } + } + + /** + * Initialize the Axis configuration context + * + * @param config Servlet configuration + * @throws ServletException + */ + protected ConfigurationContext initConfigContext( ServletConfig config ) + throws ServletException + { + try + { + ServletContext context = config.getServletContext(); + String repoDir = context.getRealPath( "/WEB-INF" ); + ConfigurationContextFactory erfac = new ConfigurationContextFactory(); + ConfigurationContext configContext = erfac.createConfigurationContextFromFileSystem( repoDir ); + configContext.setProperty( Constants.CONTAINER_MANAGED, Constants.VALUE_TRUE ); + configContext.setRootDir( new File( context.getRealPath( "/WEB-INF" ) ) ); + return configContext; + } + catch ( Exception e ) + { + throw new ServletException( e ); + } + } + + private HashMap getHTTPParameters( HttpServletRequest httpServletRequest ) + { + HashMap map = new HashMap(); + Enumeration enu = httpServletRequest.getParameterNames(); + + while ( enu.hasMoreElements() ) + { + String name = (String) enu.nextElement(); + String value = httpServletRequest.getParameter( name ); + + map.put( name, value ); + } + + return map; + } + + private Object getSessionContext( HttpServletRequest httpServletRequest ) + { + Object sessionContext = httpServletRequest.getSession( true ).getAttribute( Constants.SESSION_CONTEXT_PROPERTY ); + + if ( sessionContext == null ) + { + sessionContext = new SessionContext( null ); + httpServletRequest.getSession().setAttribute( Constants.SESSION_CONTEXT_PROPERTY, sessionContext ); + } + + return sessionContext; + } + + private Map getTransportHeaders( HttpServletRequest req ) + { + HashMap headerMap = new HashMap(); + Enumeration headerNames = req.getHeaderNames(); + + while ( headerNames.hasMoreElements() ) + { + String key = (String) headerNames.nextElement(); + String value = req.getHeader( key ); + + headerMap.put( key, value ); + } + + return headerMap; + } + //RRFOO + //TODO get axis2.xml in + /* + * + // Get the current SCA module context + AggregateContext moduleContext = tuscanyRuntime.getModuleComponentContext(); + tuscanyRuntime.start(); + try { + + Module module = (Module)moduleContext.getAggregate(); + AssemblyModelContext modelContext = module.getAssemblyModelContext(); + + // Load the .wsdd configuration + ResourceLoader bundleContext = modelContext.getResourceLoader(); + InputStream wsdd; + try { + URL url = bundleContext.getResource("org/apache/tuscany/binding/axis/engine/config/server-config.wsdd"); + wsdd = url.openStream(); + } catch (IOException e1) { + throw new ServiceRuntimeException(e1); + } + + * + */ +} diff --git a/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/handler/WebServiceOperationMetaData.java b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/handler/WebServiceOperationMetaData.java new file mode 100644 index 0000000000..04c05b95dd --- /dev/null +++ b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/handler/WebServiceOperationMetaData.java @@ -0,0 +1,484 @@ +/** + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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.tuscany.binding.axis2.handler; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Set; +import javax.wsdl.Binding; +import javax.wsdl.BindingInput; +import javax.wsdl.BindingOperation; +import javax.wsdl.BindingOutput; +import javax.wsdl.Input; +import javax.wsdl.Message; +import javax.wsdl.Operation; +import javax.wsdl.Output; +import javax.wsdl.Part; +import javax.wsdl.extensions.soap.SOAPBinding; +import javax.wsdl.extensions.soap.SOAPHeader; +import javax.wsdl.extensions.soap.SOAPOperation; +import javax.xml.namespace.QName; + +/** + * Metadata for a WSDL operation + * + */ +public class WebServiceOperationMetaData { + // WSDL Binding and BindingOperation + private Binding binding; + private BindingOperation bindingOperation; + + // Fields to cache derived metadata + private transient Set inputHeaderParts; + private transient Set outputHeaderParts; + private transient String style; + private transient String use; + private transient String soapAction; + private transient List signature; + private String encoding; + private transient QName rpcOperationName; + + public WebServiceOperationMetaData(Binding binding, BindingOperation bindingOperation) { + this.binding = binding; + this.bindingOperation = bindingOperation; + } + + public WebServiceOperationMetaData(Binding binding, BindingOperation bindingOperation, String style, String use, String encoding, String soapAction) { + this.binding = binding; + this.bindingOperation = bindingOperation; + this.style = style; + this.use = use; + this.encoding = encoding; + this.soapAction = soapAction; + } + + public Set getInputHeaderParts() { + if (inputHeaderParts == null) { + // Build a set of header parts that we need to exclude + inputHeaderParts = new HashSet(); + BindingInput bindingInput = bindingOperation.getBindingInput(); + + if (bindingInput != null) { + Operation operation = bindingOperation.getOperation(); + javax.wsdl.Message message = operation.getInput().getMessage(); + List elements = bindingInput.getExtensibilityElements(); + for (Iterator i = elements.iterator(); i.hasNext();) { + Object extensibilityElement = i.next(); + Part part = getPartFromSOAPHeader(message, extensibilityElement); + if (part != null) { + inputHeaderParts.add(part); + } + } + } + } + return inputHeaderParts; + } + + public Set getOutputHeaderParts() { + if (outputHeaderParts == null) { + // Build a set of header parts that we need to exclude + outputHeaderParts = new HashSet(); + BindingOutput bindingOutput = bindingOperation.getBindingOutput(); + + if (bindingOutput != null) { + Operation operation = bindingOperation.getOperation(); + javax.wsdl.Message message = operation.getOutput().getMessage(); + List elements = bindingOutput.getExtensibilityElements(); + for (Iterator i = elements.iterator(); i.hasNext();) { + Object extensibilityElement = i.next(); + Part part = getPartFromSOAPHeader(message, extensibilityElement); + if (part != null) { + outputHeaderParts.add(part); + } + } + } + } + return outputHeaderParts; + } + + private Part getPartFromSOAPHeader(Message message, Object extensibilityElement) { + Part part = null; + if (extensibilityElement instanceof SOAPHeader) { + SOAPHeader soapHeader = (SOAPHeader) extensibilityElement; + QName msgName = soapHeader.getMessage(); + if (message.getQName().equals(msgName)) { + part = message.getPart(soapHeader.getPart()); + } + } else if (extensibilityElement instanceof SOAPHeader) { + SOAPHeader soapHeader = (SOAPHeader) extensibilityElement; + QName msgName = soapHeader.getMessage(); + if (message.getQName().equals(msgName)) { + part = message.getPart(soapHeader.getPart()); + } + } + return part; + } + + public String getStyle() { + if (style == null) { + SOAPOperation soapOperation = (SOAPOperation) WebServicePortMetaData.getExtensibilityElement(bindingOperation.getExtensibilityElements(), SOAPOperation.class); + if (soapOperation != null) + style = soapOperation.getStyle(); + if (style == null) { + SOAPBinding soapBinding = (SOAPBinding) WebServicePortMetaData.getExtensibilityElement(binding.getExtensibilityElements(), SOAPBinding.class); + if (soapBinding != null) + style = soapBinding.getStyle(); + } + if (style == null) + style = "document"; + } + return style; + } + + /** + * Returns the SOAP action for the given operation. + * + * @param wsdlBindingOperation + * @return + */ + public String getSOAPAction() { + if (soapAction == null) { + final List wsdlBindingOperationExtensions = bindingOperation.getExtensibilityElements(); + final SOAPOperation soapOp = (SOAPOperation) WebServicePortMetaData.getExtensibilityElement(wsdlBindingOperationExtensions, SOAPOperation.class); + if (soapOp != null) + soapAction = soapOp.getSoapActionURI(); + } + return soapAction; + } + + public QName getRPCOperationName() { + if (rpcOperationName == null) { + javax.wsdl.extensions.soap.SOAPBody soapBody = getSOAPBody(true); + String ns = (soapBody != null) ? soapBody.getNamespaceURI() : binding.getPortType().getQName().getNamespaceURI(); + String name = bindingOperation.getOperation().getName(); + rpcOperationName = new QName(ns, name); + } + return rpcOperationName; + } + + private List getSOAPBodyParts(boolean input) { + javax.wsdl.extensions.soap.SOAPBody soapBody = getSOAPBody(input); + if (soapBody != null) { + List parts = soapBody.getParts(); + if (parts!=null) { + List names = new ArrayList(); + for (Iterator i = parts.iterator(); i.hasNext();) { + Object part = i.next(); + if (part instanceof String) + names.add(part); + else if (part instanceof Part) { + names.add(((Part) part).getName()); + } + } + return names; + } else + return null; + } else + return null; + } + + private javax.wsdl.extensions.soap.SOAPBody getSOAPBody(boolean input) { + List elements = null; + if (input) { + BindingInput bindingInput = bindingOperation.getBindingInput(); + if (bindingInput == null) + return null; + elements = bindingInput.getExtensibilityElements(); + } else { + BindingOutput bindingOutput = bindingOperation.getBindingOutput(); + if (bindingOutput == null) + return null; + elements = bindingOutput.getExtensibilityElements(); + } + javax.wsdl.extensions.soap.SOAPBody soapBody = (javax.wsdl.extensions.soap.SOAPBody) WebServicePortMetaData.getExtensibilityElement(elements, + javax.wsdl.extensions.soap.SOAPBody.class); + return soapBody; + } + + /** + * Returns the use attribute + * + * @param wsdlOperation + * @return + */ + public String getUse() { + if (use == null) { + javax.wsdl.extensions.soap.SOAPBody soapBody = getSOAPBody(true); + if (soapBody != null) { + use = soapBody.getUse(); + } + if (use == null) + use = "literal"; + } + return use; + } + + public String getEncoding() { + if (encoding == null) { + javax.wsdl.extensions.soap.SOAPBody soapBody = getSOAPBody(true); + if (soapBody != null) { + List styles=(List)soapBody.getEncodingStyles(); + if (styles!=null && !styles.isEmpty()) + encoding = styles.get(0); + } + if (encoding == null) + encoding = ""; + } + return encoding; + } + + public boolean isDocLitWrapped() { + boolean flag = getStyle().equals("document") && getUse().equals("literal"); + if (!flag) + return false; + Message msg = getMessage(true); + if (msg == null) + return false; + List parts = msg.getOrderedParts(null); + if (parts.size() != 1) + return false; + Part part = (Part) parts.get(0); + QName element = part.getElementName(); + if (element == null) + return false; + return element.getLocalPart().equals(bindingOperation.getOperation().getName()); + } + + /* + public SOAPMediator createMediator(boolean serverMode) + throws SOAPException { + // create a new mediator for each invoke for thread-safety + boolean rpcStyle = getStyle().equals("rpc"); + boolean rpcEncoded = isEncoded(); + + SOAPMediator mediator = null; + + if (!rpcStyle) { + // Document + mediator = new SOAPDocumentLiteralMediatorImpl(this, serverMode); + } else { + if (!rpcEncoded) + mediator = new SOAPRPCLiteralMediatorImpl(this, serverMode); // RPC-literal + else + mediator = new SOAPRPCEncodedMediatorImpl(this, serverMode); // RPC-encoded + } + return mediator; + } + */ + + /** + * Get the operation signature from the WSDL operation + * + * @param wsdlBinding + * @param bindingOperation + * @return + */ + public List getOperationSignature() { + if (signature == null) { + signature = new ArrayList(); + + Operation operation = bindingOperation.getOperation(); + if (operation == null) + return signature; + + final Input input = operation.getInput(); + if (input == null) { + return signature; + } + + String style = getStyle(); + + if (style.equals("rpc")) { + Collection partNames = input.getMessage().getParts().values(); + for (Iterator i = partNames.iterator(); i.hasNext();) { + Part part = (Part) i.next(); + signature.add(part.getName()); + } + } else { + /* + * WS-I Basic Profile 1.1 4.7.6 Operation Signatures + * Definition: operation signature + * + * The profile defines the "operation signature" to be the + * fully qualified name of the child element of SOAP body of + * the SOAP input message described by an operation in a + * WSDL binding. + * + * In the case of rpc-literal binding, the operation name is + * used as a wrapper for the part accessors. In the + * document-literal case, since a wrapper with the operation + * name is not present, the message signatures must be + * correctly designed so that they meet this requirement. + * + * An endpoint that supports multiple operations must + * unambiguously identify the operation being invoked based + * on the input message that it receives. This is only + * possible if all the operations specified in the + * wsdl:binding associated with an endpoint have a unique + * operation signature. + * + * R2710 The operations in a wsdl:binding in a DESCRIPTION + * MUST result in operation signatures that are different + * from one another. + */ + List bodyParts = getSOAPBodyParts(true); + + Collection parts = input.getMessage().getParts().values(); + // Exclude the parts to be transmitted in SOAP header + if (bodyParts == null) + parts.removeAll(getInputHeaderParts()); + for (Iterator i = parts.iterator(); i.hasNext();) { + Part part = (Part) i.next(); + if (bodyParts == null) { + // All parts + QName elementName = part.getElementName(); + if (elementName == null) { + elementName = new QName("", part.getName()); + // TODO: [rfeng] throw new + // ServiceRuntimeException("Message part for + // document style must refer to an XSD element + // using a QName: " + part); + } + signature.add(elementName); + } else { + // "parts" in soap:body + if (bodyParts.contains(part.getName())) { + QName elementName = part.getElementName(); + if (elementName == null) { + elementName = new QName("", part.getName()); + // TODO: [rfeng] throw new + // ServiceRuntimeException("Message part for + // document style must refer to an XSD + // element using a QName: " + part); + } + signature.add(elementName); + } + + } + } + } + } + return signature; + } + + public Message getMessage(boolean isInput) { + Operation operation = bindingOperation.getOperation(); + if (operation == null) + return null; + + if (isInput) { + final Input input = operation.getInput(); + return input == null ? null : input.getMessage(); + } else { + final Output output = operation.getOutput(); + return output == null ? null : output.getMessage(); + } + } + + public Part getInputPart(int index) { + Part part = null; + Message message = getMessage(true); + if (message == null) + return part; + + List parts = message.getOrderedParts(null); + return (Part) parts.get(index); + + } + + public Part getOutputPart(int index) { + Part part = null; + Message message = getMessage(false); + if (message == null) + return part; + + List parts = message.getOrderedParts(null); + return (Part) parts.get(index); + + } + + /** + * Get a list of indexes for each part in the SOAP body + * + * @param isInput TODO + * @return + */ + public List getBodyPartIndexes(boolean isInput) { + List indexes = new ArrayList(); + + Message message = getMessage(isInput); + if (message == null) + return indexes; + + List bodyParts = getSOAPBodyParts(isInput); + List parts = message.getOrderedParts(null); + Set headerParts = (isInput) ? getInputHeaderParts() : getOutputHeaderParts(); + + int index = 0; + for (Iterator i = parts.iterator(); i.hasNext(); index++) { + Part part = (Part) i.next(); + if (headerParts.contains(part)) + continue; + if (bodyParts == null) { + // All parts + indexes.add(new Integer(index)); + } else { + // "parts" in soap:body + if (bodyParts.contains(part.getName())) + indexes.add(new Integer(index)); + + } + } + return indexes; + } + + /** + * Get the corresponding index for a part in the SOAP header by element + * name + * + * @param elementName + * @param isInput TODO + * @return + */ + public int getHeaderPartIndex(QName elementName, boolean isInput) { + + Message message = getMessage(isInput); + if (message == null) + return -1; + + List parts = message.getOrderedParts(null); + Set headerParts = isInput ? getInputHeaderParts() : getOutputHeaderParts(); + + int index = 0; + for (Iterator i = parts.iterator(); i.hasNext(); index++) { + Part part = (Part) i.next(); + // Test if the part is in header section + if (headerParts.contains(part) && elementName.equals(part.getElementName())) { + return index; + } + } + return -1; + } + + public BindingOperation getBindingOperation() { + return bindingOperation; + } + +} \ No newline at end of file diff --git a/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/handler/WebServicePortMetaData.java b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/handler/WebServicePortMetaData.java new file mode 100644 index 0000000000..15eec4dc7e --- /dev/null +++ b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/handler/WebServicePortMetaData.java @@ -0,0 +1,362 @@ +/** + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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.tuscany.binding.axis2.handler; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Iterator; +import java.util.List; + +import javax.wsdl.Binding; +import javax.wsdl.BindingOperation; +import javax.wsdl.Definition; +import javax.wsdl.Port; +import javax.wsdl.PortType; +import javax.wsdl.Service; +import javax.wsdl.extensions.soap.SOAPAddress; +import javax.wsdl.extensions.soap.SOAPBinding; +import javax.xml.namespace.QName; +//import javax.xml.soap.Name; +//import javax.xml.soap.SOAPBodyElement; +//import javax.xml.soap.SOAPElement; + +import org.apache.tuscany.model.types.wsdl.WSDLServiceContract; + +/** + * Metadata for a WSDL port + * + */ +public class WebServicePortMetaData { + + private final static String SOAP_ENCODING_URI = "http://schemas.xmlsoap.org/wsdl/soap/"; + + private Service wsdlService; + private QName wsdlServiceName; + private Port wsdlPort; + private Binding wsdlBinding; + private QName wsdlPortName; + private PortType wsdlPortType; + private QName wsdlPortTypeName; + private String endpoint; + private boolean managed; + private List allOperationMetaData; + private WSDLServiceContract interfaceType; + + /** + * Constructor + * + * @param wsdlDefinition + * @param portName + */ + public WebServicePortMetaData(Definition wsdlDefinition, Port wsdlPort, String endpoint, boolean managed) { + + // Lookup the named port + this.wsdlPort=wsdlPort; + wsdlPortName = new QName(wsdlDefinition.getTargetNamespace(), wsdlPort.getName()); + + Collection services=(Collection)wsdlDefinition.getServices().values(); + for (Service service : services) { + if (service.getPorts().containsValue(wsdlPort)) { + wsdlService = service; + wsdlServiceName = service.getQName(); + break; + } + } + + // Save the binding + wsdlBinding = wsdlPort.getBinding(); + if (wsdlBinding == null) { + throw new IllegalArgumentException("WSDL binding cannot be found for " + wsdlPortName); + } + + // Save the portType + wsdlPortType = wsdlBinding.getPortType(); + if (wsdlPortType == null) { + throw new IllegalArgumentException("WSDL portType cannot be found for " + wsdlPortName); + } + wsdlPortTypeName = wsdlPortType.getQName(); + + // Save the endpoint + this.endpoint = endpoint; + + // Track if this endpoint is managed or not + this.managed = managed; + } + + /** + * Constructor + * + * @param serviceName + * @param portName + * @param portType + */ + public WebServicePortMetaData(QName serviceName, String portName, QName portTypeName, String endpoint) { + wsdlServiceName = serviceName; + wsdlPortName = new QName(serviceName.getNamespaceURI(), portName); + wsdlPortTypeName = portTypeName; + this.endpoint = endpoint; + } + + /** + * @return Returns the wsdlPort. + */ + public javax.wsdl.Port getPort() { + return wsdlPort; + } + + /** + * @return Returns the wsdlService. + */ + public QName getServiceName() { + return wsdlServiceName; + } + + /** + * @return Returns the wsdlService. + */ + public javax.wsdl.Service getService() { + return wsdlService; + } + + /** + * @return Returns the wsdlPortType. + */ + public PortType getPortType() { + return wsdlPortType; + } + + /** + * @return Returns the wsdlPortType. + */ + public QName getPortTypeName() { + return wsdlPortTypeName; + } + + /** + * @return Returns the wsdlBinding. + */ + public Binding getBinding() { + return wsdlBinding; + } + + /** + * @return Returns the wsdlPortName. + */ + public QName getPortName() { + return wsdlPortName; + } + + /** + * Returns the endpoint of a given port. + * + * @param wsdlPort + * @return + */ + public String getEndpoint() { + + // Return the specified endpoint + if (endpoint != null) + return endpoint; + + // Find the target endpoint on the port + if (wsdlPort != null) { + final List wsdlPortExtensions = wsdlPort.getExtensibilityElements(); + for (Iterator i = wsdlPortExtensions.iterator(); i.hasNext();) { + final Object extension = i.next(); + if (extension instanceof SOAPAddress) { + final SOAPAddress address = (SOAPAddress) extension; + return address.getLocationURI(); + } + } + } + + return null; + } + + /** + * Returns the SOAP binding style. + * @return + */ + public String getStyle() { + + // Find the binding style + String style = null; + if (wsdlBinding != null) { + final List wsdlBindingExtensions = wsdlBinding.getExtensibilityElements(); + SOAPBinding soapBinding = (SOAPBinding) getExtensibilityElement(wsdlBindingExtensions, SOAPBinding.class); + if (soapBinding != null) + style = soapBinding.getStyle(); + } + + // Default to document + return (style == null) ? "document" : style; + } + + /** + * Returns the use attribute + * @return + */ + public String getUse() { + List list = getAllOperationMetaData(); + WebServiceOperationMetaData operationMetaData = (WebServiceOperationMetaData) list.get(0); + return operationMetaData.getUse(); + } + + /** + * Returns the encoding attribute + * @return + */ + public String getEncoding() { + List list = getAllOperationMetaData(); + WebServiceOperationMetaData operationMetaData = (WebServiceOperationMetaData) list.get(0); + return operationMetaData.getEncoding(); + } + + /** + * @return Returns true if this is a managed web service. + */ + public boolean isManaged() { + return managed; + } + + /** + * Returns the first extensibility element of the given type. + * @param elements + * @param type + * @return + */ + public static Object getExtensibilityElement(List elements, Class type) { + for (Iterator i = elements.iterator(); i.hasNext();) { + Object element = i.next(); + if (type.isInstance(element)) + return element; + } + return null; + } + + /** + * Returns the extensibility elements of the given type. + * @param elements + * @param type + * @return + */ + public static List getExtensibilityElements(List elements, Class type) { + List result = new ArrayList(); + for (Iterator i = elements.iterator(); i.hasNext();) { + Object element = i.next(); + if (type.isInstance(element)) + result.add(element); + } + return result; + } + + /** + * Get the operation signature from the SOAP Body + * @param body + * @return A list of QNames + */ +// public static List getOperationSignature(javax.xml.soap.SOAPBody body) { +// List signature = new ArrayList(); +// for (Iterator i = body.getChildElements(); i.hasNext();) { +// Object child = i.next(); +// if (child instanceof SOAPBodyElement) { +// Name name = ((SOAPBodyElement) child).getElementName(); +// QName qname = new QName(name.getURI(), name.getLocalName(), name.getPrefix()); +// signature.add(qname); +// } +// } +// return signature; +// } + +// public static List getRPCOperationSignature(javax.xml.soap.SOAPBody body) { +// List signature = new ArrayList(); +// for (Iterator i = body.getChildElements(); i.hasNext();) { +// Object child = i.next(); +// if (child instanceof SOAPBodyElement) { +// SOAPBodyElement op = ((SOAPBodyElement) child); +// for (Iterator j = op.getChildElements(); j.hasNext();) { +// Object part = i.next(); +// if (part instanceof SOAPElement) { +// SOAPElement p = (SOAPElement) part; +// signature.add(p.getLocalName()); +// } +// } +// } +// } +// return signature; +// } + +// public WebServiceOperationMetaData getOperationMetaData(javax.xml.soap.SOAPBody body) { +// List s1 = getOperationSignature(body); +// // List rpcParts = getRPCOperationSignature(body); +// for (Iterator it = getAllOperationMetaData().iterator(); it.hasNext();) { +// WebServiceOperationMetaData descriptor = (WebServiceOperationMetaData) it.next(); +// +// String style = descriptor.getStyle(); +// +// if (style.equals("document")) { +// List s2 = descriptor.getOperationSignature(); +// if (s1.equals(s2)) +// return descriptor; +// } else { +// QName op1 = (QName) s1.get(0); +// QName op2 = descriptor.getRPCOperationName(); +// if (op1.equals(op2)) { +// /* +// * // FIXME: [rfeng] We don't support method overloading +// * List partNames = getOperationSignature(binding, +// * bindingOperation); if (rpcParts.equals(partNames)) +// */ +// return descriptor; +// } +// } +// } +// return null; +// } + + public List getAllOperationMetaData() { + if (allOperationMetaData == null) { + allOperationMetaData = new ArrayList(); + for (Iterator it = wsdlBinding.getBindingOperations().iterator(); it.hasNext();) { + final BindingOperation bindingOperation = (BindingOperation) it.next(); + if (bindingOperation.getOperation() != null) + allOperationMetaData.add(new WebServiceOperationMetaData(wsdlBinding, bindingOperation)); + } + } + return allOperationMetaData; + } + + public WebServiceOperationMetaData getOperationMetaData(String operationName) { + for (Iterator it = getAllOperationMetaData().iterator(); it.hasNext();) { + WebServiceOperationMetaData descriptor = (WebServiceOperationMetaData) it.next(); + String opName = descriptor.getBindingOperation().getOperation().getName(); + + if (opName.equals(operationName)) + return descriptor; + } + return null; + } + + /** + * Returns the WSDL service contract + * @return + */ + public WSDLServiceContract getInterfaceType() { + return interfaceType; + } + +} \ No newline at end of file diff --git a/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/loader/WebServiceSCDLModelLoader.java b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/loader/WebServiceSCDLModelLoader.java new file mode 100644 index 0000000000..d587a4680f --- /dev/null +++ b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/loader/WebServiceSCDLModelLoader.java @@ -0,0 +1,74 @@ +package org.apache.tuscany.binding.axis2.loader; + +import org.apache.tuscany.binding.axis2.assembly.WebServiceAssemblyFactory; +import org.apache.tuscany.binding.axis2.assembly.WebServiceBinding; +import org.apache.tuscany.binding.axis2.assembly.impl.WebServiceAssemblyFactoryImpl; +import org.apache.tuscany.binding.axis2.assembly.impl.WebServiceBindingImpl; +import org.apache.tuscany.core.runtime.RuntimeContext; +import org.apache.tuscany.core.system.annotation.Autowire; +import org.apache.tuscany.core.loader.SCDLModelLoaderRegistry; +import org.apache.tuscany.model.assembly.AssemblyModelContext; +import org.apache.tuscany.model.assembly.AssemblyModelObject; +import org.apache.tuscany.model.scdl.loader.SCDLModelLoader; +import org.osoa.sca.annotations.Init; +import org.osoa.sca.annotations.Destroy; + +/** + * Populates the assembly model from an SCDL model + */ +@org.osoa.sca.annotations.Scope("MODULE") +public class WebServiceSCDLModelLoader implements SCDLModelLoader { + + private RuntimeContext runtimeContext; + private SCDLModelLoaderRegistry loaderRegistry; + private WebServiceAssemblyFactory wsFactory; + + /** + * Constructs a new WebServiceSCDLModelLoader. + */ + public WebServiceSCDLModelLoader() { + this.wsFactory=new WebServiceAssemblyFactoryImpl(); + } + + /** + * @param runtimeContext The runtimeContext to set. + */ + @Autowire + public void setRuntimeContext(RuntimeContext runtimeContext) { + this.runtimeContext = runtimeContext; + } + + // @Autowire + public void setLoaderRegistry(SCDLModelLoaderRegistry registry) { + this.loaderRegistry = registry; + } + + @Init(eager=true) + public void init() { + runtimeContext.addLoader(this); +// loaderRegistry.registerLoader(this); + } + + @Destroy + public void destroy() { + loaderRegistry.unregisterLoader(this); + } + + /** + * @see org.apache.tuscany.model.scdl.loader.SCDLModelLoader#load(org.apache.tuscany.model.assembly.AssemblyModelContext, java.lang.Object) + */ + public AssemblyModelObject load(AssemblyModelContext modelContext, Object object) { + if (object instanceof org.apache.tuscany.model.scdl.WebServiceBinding) { + org.apache.tuscany.model.scdl.WebServiceBinding scdlBinding=(org.apache.tuscany.model.scdl.WebServiceBinding)object; + WebServiceBinding binding=wsFactory.createWebServiceBinding(); + binding.setURI(scdlBinding.getUri()); + + // Set the port URI into the assembly binding, it'll be resolved in the initialize method + ((WebServiceBindingImpl)binding).setPortURI(scdlBinding.getPort()); + + return binding; + + } else + return null; + } +} diff --git a/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/util/AxiomHelper.java b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/util/AxiomHelper.java new file mode 100644 index 0000000000..3df1a4104d --- /dev/null +++ b/tags/java-stable-20060304/sca/binding.axis2/src/main/java/org/apache/tuscany/binding/axis2/util/AxiomHelper.java @@ -0,0 +1,185 @@ +/** + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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.tuscany.binding.axis2.util; + +import java.io.IOException; +import java.io.PipedInputStream; +import java.io.PipedOutputStream; +import java.util.List; + +import javax.xml.namespace.QName; +import javax.xml.stream.FactoryConfigurationError; +import javax.xml.stream.XMLInputFactory; +import javax.xml.stream.XMLStreamException; +import javax.xml.stream.XMLStreamReader; + +import org.apache.axis2.om.OMAbstractFactory; +import org.apache.axis2.om.OMElement; +import org.apache.axis2.om.OMXMLParserWrapper; +import org.apache.axis2.om.impl.llom.factory.OMXMLBuilderFactory; +import org.apache.tuscany.sdo.helper.DataFactoryImpl; +import org.apache.tuscany.sdo.helper.XMLHelperImpl; +import org.apache.tuscany.sdo.helper.XSDHelperImpl; +import org.osoa.sca.ServiceRuntimeException; + +import commonj.sdo.DataObject; +import commonj.sdo.Property; +import commonj.sdo.helper.TypeHelper; +import commonj.sdo.helper.XMLDocument; +import commonj.sdo.helper.XSDHelper; + +/** + * Utility methods to convert between Axis2 AXIOM, SDO DataObjects and Java objects. + * + * Most of these methods rely on the schemas having been registered with XSDHelper.define + */ +public class AxiomHelper { + + /** + * Deserialize an OMElement into Java Objects + * + * @param om + * the OMElement + * @return the array of deserialized Java objects + */ + public static Object[] toObjects(TypeHelper typeHelper, OMElement om) { + DataObject dataObject = toDataObject(typeHelper, om); + Object[] os = toObjects(dataObject); + return os; + } + + /** + * Convert a typed DataObject to Java objects + * + * @param dataObject + * @return the array of Objects from the DataObject + */ + public static Object[] toObjects(DataObject dataObject) { + List ips = dataObject.getInstanceProperties(); + Object[] os = new Object[ips.size()]; + for (int i = 0; i < ips.size(); i++) { + os[i] = dataObject.get((Property) ips.get(i)); + } + return os; + } + + /** + * Convert objects to an AXIOM OMElement + * + * @param os + * @param typeNS + * @param typeName + * @return an AXIOM OMElement + */ + public static OMElement toOMElement(TypeHelper typeHelper, Object[] os, QName typeQN) { + DataObject dataObject = toDataObject(typeHelper, os, typeQN); + OMElement omElement = toOMElement(typeHelper, dataObject, typeQN); + return omElement; + } + + /** + * Convert a DataObject to AXIOM OMElement + * + * @param dataObject + * @param typeNS + * @param typeName + * @return + * @throws XMLStreamException + * @throws IOException + */ + public static OMElement toOMElement(TypeHelper typeHelper, DataObject dataObject, QName typeQN) { + try { + + PipedOutputStream pos = new PipedOutputStream(); + PipedInputStream pis = new PipedInputStream(pos); + new XMLHelperImpl(typeHelper).save(dataObject, typeQN.getNamespaceURI(), typeQN.getLocalPart(), pos); + pos.close(); + + XMLStreamReader parser; + ClassLoader ccl=Thread.currentThread().getContextClassLoader(); + try { + Thread.currentThread().setContextClassLoader(AxiomHelper.class.getClassLoader()); + parser = XMLInputFactory.newInstance().createXMLStreamReader(pis); + } finally { + Thread.currentThread().setContextClassLoader(ccl); + } + OMXMLParserWrapper builder = OMXMLBuilderFactory.createStAXOMBuilder(OMAbstractFactory.getOMFactory(), parser); + OMElement root = builder.getDocumentElement(); + + return root; + + } catch (IOException e) { + throw new ServiceRuntimeException(e); + } catch (XMLStreamException e) { + throw new ServiceRuntimeException(e); + } catch (FactoryConfigurationError e) { + throw new ServiceRuntimeException(e); + } + } + + /** + * Deserialize an AXIOM OMElement into a DataObject + * + * @param omElement + * @return + */ + public static DataObject toDataObject(TypeHelper typeHelper, OMElement omElement) { + try { + + PipedOutputStream pos = new PipedOutputStream(); + PipedInputStream pis = new PipedInputStream(pos); + + ClassLoader ccl=Thread.currentThread().getContextClassLoader(); + try { + Thread.currentThread().setContextClassLoader(AxiomHelper.class.getClassLoader()); + omElement.serialize(pos); + } finally { + Thread.currentThread().setContextClassLoader(ccl); + } + + pos.flush(); + pos.close(); + + XMLDocument document = new XMLHelperImpl(typeHelper).load(pis); + + return document.getRootObject(); + + } catch (IOException e) { + throw new ServiceRuntimeException(e); + } catch (XMLStreamException e) { + throw new ServiceRuntimeException(e); + } + } + + /** + * Convert objects to typed DataObject + * + * @param typeNS + * @param typeName + * @param os + * @return the DataObject + */ + public static DataObject toDataObject(TypeHelper typeHelper, Object[] os, QName typeQN) { + XSDHelper xsdHelper=new XSDHelperImpl(typeHelper); + Property property=xsdHelper.getGlobalProperty(typeQN.getNamespaceURI(), typeQN.getLocalPart(), true); + DataObject dataObject = new DataFactoryImpl(typeHelper).create(property.getType()); + List ips = dataObject.getInstanceProperties(); + for (int i = 0; i < ips.size(); i++) { + Property p = (Property) ips.get(i); + dataObject.set(i, os[i]); + } + return dataObject; + } + +} -- cgit v1.2.3