diff options
Diffstat (limited to 'sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org')
19 files changed, 1855 insertions, 0 deletions
diff --git a/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/assembly/WebServiceAssemblyFactory.java b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/assembly/WebServiceAssemblyFactory.java new file mode 100644 index 0000000000..46d5cac4dd --- /dev/null +++ b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/assembly/WebServiceAssemblyFactory.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.celtix.assembly; + +import org.apache.tuscany.core.loader.WSDLDefinitionRegistry; +import org.apache.tuscany.model.assembly.AssemblyFactory; + +/** + * The <b>Factory</b> for the model. + */ +public interface WebServiceAssemblyFactory extends AssemblyFactory { + + /** + * Returns a new WebServiceBinding. + */ + WebServiceBinding createWebServiceBinding(WSDLDefinitionRegistry wsdlRegistry); + +} diff --git a/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/assembly/WebServiceBinding.java b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/assembly/WebServiceBinding.java new file mode 100644 index 0000000000..82dd08ef0d --- /dev/null +++ b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/assembly/WebServiceBinding.java @@ -0,0 +1,80 @@ +/** + * + * 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.celtix.assembly; + +import javax.wsdl.Definition; +import javax.wsdl.Port; +import javax.wsdl.Service; + +import commonj.sdo.helper.TypeHelper; + +import org.apache.tuscany.common.resource.ResourceLoader; +import org.apache.tuscany.model.assembly.Binding; +import org.objectweb.celtix.Bus; + +/** + * Represents a Web service binding. + */ +public interface WebServiceBinding extends Binding { + + /** + * Set the URI of the WSDL port for this binding. + * + * @param portURI the URI of the WSDL port + */ + void setPortURI(String portURI); + + /** + * Returns the WSDL port defining this binding. + */ + Port getWSDLPort(); + + /** + * Returns the WSDL service defining this binding. + */ + Service getWSDLService(); + + /** + * Returns the WSDL definition containing the WSDL port. + * + * @return the WSDL definition containing the WSDL port + */ + 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); + + TypeHelper getTypeHelper(); + + void setTypeHelper(TypeHelper typeHelper); + + ResourceLoader getResourceLoader(); + + void setResourceLoader(ResourceLoader resourceLoader); + + Bus getBus(); + void setBus(Bus b); +} diff --git a/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/assembly/impl/WebServiceAssemblyFactoryImpl.java b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/assembly/impl/WebServiceAssemblyFactoryImpl.java new file mode 100644 index 0000000000..1288f67719 --- /dev/null +++ b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/assembly/impl/WebServiceAssemblyFactoryImpl.java @@ -0,0 +1,43 @@ +/** + * + * 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.celtix.assembly.impl; + +import org.apache.tuscany.binding.celtix.assembly.WebServiceAssemblyFactory; +import org.apache.tuscany.binding.celtix.assembly.WebServiceBinding; +import org.apache.tuscany.core.loader.WSDLDefinitionRegistry; +import org.apache.tuscany.model.assembly.impl.AssemblyFactoryImpl; + +/** + * An implementation of the model <b>Factory</b>. + */ +public class WebServiceAssemblyFactoryImpl extends AssemblyFactoryImpl implements WebServiceAssemblyFactory { + + /** + * Creates an instance of the factory. + */ + public WebServiceAssemblyFactoryImpl() { + super(); + } + + /** + * @see org.apache.tuscany.binding.celtix.assembly.WebServiceAssemblyFactory#createWebServiceBinding() + */ + public WebServiceBinding createWebServiceBinding(WSDLDefinitionRegistry wsdlRegistry) { + return new WebServiceBindingImpl(wsdlRegistry); + } + +} diff --git a/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/assembly/impl/WebServiceBindingImpl.java b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/assembly/impl/WebServiceBindingImpl.java new file mode 100644 index 0000000000..477d2b656a --- /dev/null +++ b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/assembly/impl/WebServiceBindingImpl.java @@ -0,0 +1,184 @@ +/** + * + * 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.celtix.assembly.impl; + +import java.util.Collection; +import java.util.List; +import javax.wsdl.Definition; +import javax.wsdl.Port; +import javax.wsdl.Service; +import javax.xml.namespace.QName; + +import commonj.sdo.helper.TypeHelper; +import org.apache.tuscany.binding.celtix.assembly.WebServiceBinding; +import org.apache.tuscany.common.resource.ResourceLoader; +import org.apache.tuscany.core.loader.WSDLDefinitionRegistry; +import org.apache.tuscany.model.assembly.AssemblyContext; +import org.apache.tuscany.model.assembly.impl.BindingImpl; +import org.objectweb.celtix.Bus; + +/** + * An implementation of WebServiceBinding. + */ +public class WebServiceBindingImpl extends BindingImpl implements WebServiceBinding { + + private WSDLDefinitionRegistry wsdlRegistry; + + private Definition definition; + private Port port; + private Service service; + private String portURI; + private TypeHelper typeHelper; + private ResourceLoader resourceLoader; + private Bus bus; + + /** + * Constructor + */ + protected WebServiceBindingImpl(WSDLDefinitionRegistry reg) { + wsdlRegistry = reg; + } + + /** + * @see org.apache.tuscany.binding.celtix.assembly.WebServiceBinding#getWSDLPort() + */ + public Port getWSDLPort() { + return port; + } + + public Service getWSDLService() { + return service; + } + + + + /** + * @see org.apache.tuscany.binding.celtix.assembly.WebServiceBinding#setWSDLPort(javax.wsdl.Port) + */ + public void setWSDLPort(Port value) { + checkNotFrozen(); + port = value; + } + + /** + * @see org.apache.tuscany.binding.celtix.assembly.WebServiceBinding#getWSDLDefinition() + */ + public Definition getWSDLDefinition() { + return definition; + } + + /** + * @see WebServiceBinding#setWSDLDefinition(javax.wsdl.Definition) + */ + public void setWSDLDefinition(Definition def) { + checkNotFrozen(); + definition = def; + } + + /** + * @param uri The portURI to set. + */ + public void setPortURI(String uri) { + portURI = uri; + } + + public TypeHelper getTypeHelper() { + return typeHelper; + } + + public void setTypeHelper(TypeHelper pTypeHelper) { + this.typeHelper = pTypeHelper; + } + + public ResourceLoader getResourceLoader() { + return resourceLoader; + } + + public void setResourceLoader(ResourceLoader resourceLoader) { + this.resourceLoader = resourceLoader; + } + + /** + * @see BindingImpl#initialize(org.apache.tuscany.model.assembly.AssemblyContext) + */ + @SuppressWarnings("unchecked") + public void initialize(AssemblyContext 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 serviceName; + String portName; + + String fragment = portURI.substring(h + 1); + if (fragment.startsWith("wsdl.endpoint(") && fragment.endsWith(")")) { + fragment = fragment.substring(14, fragment.length() - 1); + int slash = fragment.indexOf('/'); + if (slash != -1) { + serviceName = fragment.substring(0, slash); + portName = fragment.substring(slash + 1); + } else { + serviceName = null; + portName = fragment; + } + } else { + serviceName = null; + portName = fragment; + } + + // Load the WSDL definitions for the given namespace + List<Definition> definitions = wsdlRegistry.getDefinitionsForNamespace(portNamespace, resourceLoader); + if (definitions == null) { + throw new IllegalArgumentException("Cannot find WSDL definition for " + portNamespace); + } + for (Definition def : definitions) { + + // Find the port with the given name + for (Service serv : (Collection<Service>)def.getServices().values()) { + QName sqn = serv.getQName(); + if (serviceName != null + && !serviceName.equals(sqn.getLocalPart())) { + continue; + } + + Port p = serv.getPort(portName); + if (p != null) { + service = serv; + definition = def; + port = p; + return; + } + } + } + throw new IllegalArgumentException("Cannot find WSDL port " + portURI); + } + } + + public Bus getBus() { + return bus; + } + + public void setBus(Bus b) { + bus = b; + } + +} diff --git a/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/builder/ExternalWebServiceBuilder.java b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/builder/ExternalWebServiceBuilder.java new file mode 100644 index 0000000000..99ffaa5d8a --- /dev/null +++ b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/builder/ExternalWebServiceBuilder.java @@ -0,0 +1,48 @@ +/* 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.celtix.builder; + +import org.apache.tuscany.binding.celtix.assembly.WebServiceBinding; +import org.apache.tuscany.binding.celtix.config.ExternalWebServiceContextFactory; +import org.apache.tuscany.binding.celtix.handler.ExternalWebServiceClient; +import org.apache.tuscany.core.extension.ExternalServiceBuilderSupport; +import org.apache.tuscany.core.extension.ExternalServiceContextFactory; +import org.apache.tuscany.core.injection.SingletonObjectFactory; +import org.apache.tuscany.model.assembly.ExternalService; +import org.osoa.sca.annotations.Init; +import org.osoa.sca.annotations.Scope; + + +/** + * Creates a <code>ContextFactoryBuilder</code> for an external service configured with the {@link + * WebServiceBinding} + * + * @version $Rev$ $Date$ + */ +@Scope("MODULE") +public class ExternalWebServiceBuilder extends ExternalServiceBuilderSupport<WebServiceBinding> { + + @Init(eager = true) + public void init() throws Exception { + super.init(); + } + + protected ExternalServiceContextFactory createExternalServiceContextFactory( + ExternalService externalService) { + ExternalWebServiceClient externalWebServiceClient = new ExternalWebServiceClient(externalService); + return new ExternalWebServiceContextFactory(externalService.getName(), + new SingletonObjectFactory<ExternalWebServiceClient>(externalWebServiceClient)); + } +} diff --git a/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/builder/ExternalWebServiceWireBuilder.java b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/builder/ExternalWebServiceWireBuilder.java new file mode 100644 index 0000000000..e16456f80c --- /dev/null +++ b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/builder/ExternalWebServiceWireBuilder.java @@ -0,0 +1,35 @@ +/* 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.celtix.builder; + +import java.lang.reflect.Method; + +import org.apache.tuscany.binding.celtix.config.ExternalWebServiceContextFactory; +import org.apache.tuscany.binding.celtix.handler.ExternalWebServiceTargetInvoker; +import org.apache.tuscany.core.context.QualifiedName; +import org.apache.tuscany.core.context.ScopeContext; +import org.apache.tuscany.core.extension.WireBuilderSupport; +import org.apache.tuscany.core.wire.TargetInvoker; +import org.osoa.sca.annotations.Scope; + + +@Scope("MODULE") +public class ExternalWebServiceWireBuilder extends WireBuilderSupport<ExternalWebServiceContextFactory> { + + protected TargetInvoker createInvoker(QualifiedName targetName, Method operation, + ScopeContext context, boolean downScope) { + return new ExternalWebServiceTargetInvoker(targetName, operation, context); + } +}
\ No newline at end of file diff --git a/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/builder/WebServiceEntryPointBuilder.java b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/builder/WebServiceEntryPointBuilder.java new file mode 100644 index 0000000000..705b8c9784 --- /dev/null +++ b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/builder/WebServiceEntryPointBuilder.java @@ -0,0 +1,47 @@ +/* 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.celtix.builder; + +import org.apache.tuscany.binding.celtix.assembly.WebServiceBinding; +import org.apache.tuscany.binding.celtix.config.WebServiceEntryPointContextFactory; + +import org.apache.tuscany.core.extension.EntryPointBuilderSupport; +import org.apache.tuscany.core.extension.EntryPointContextFactory; +import org.apache.tuscany.core.message.MessageFactory; +import org.apache.tuscany.core.system.annotation.Autowire; +import org.apache.tuscany.core.webapp.ServletHost; +import org.apache.tuscany.model.assembly.EntryPoint; +import org.osoa.sca.annotations.Scope; + +/** + * Creates a <code>ContextFactory</code> for an entry point configured with the {@link WebServiceBinding} + * + * @version $Rev$ $Date$ + */ +@Scope("MODULE") +public class WebServiceEntryPointBuilder extends EntryPointBuilderSupport<WebServiceBinding> { + ServletHost tomcatHost; + + @Autowire + public void setTomcatHost(ServletHost tomcatHost) { + this.tomcatHost = tomcatHost; + } + + + protected EntryPointContextFactory createEntryPointContextFactory(EntryPoint entryPoint, + MessageFactory msgFactory) { + return new WebServiceEntryPointContextFactory(tomcatHost, entryPoint, msgFactory); + } +} diff --git a/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/config/ExternalWebServiceContextFactory.java b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/config/ExternalWebServiceContextFactory.java new file mode 100644 index 0000000000..52fedd4b56 --- /dev/null +++ b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/config/ExternalWebServiceContextFactory.java @@ -0,0 +1,35 @@ +/** + * + * 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.celtix.config; + +import org.apache.tuscany.core.builder.ObjectFactory; +import org.apache.tuscany.core.extension.ExternalServiceContextFactory; + +/** + * 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.celtix.builder.ExternalWebServiceWireBuilder} + * + * @version $Rev$ $Date$ + */ +public class ExternalWebServiceContextFactory extends ExternalServiceContextFactory { + + public ExternalWebServiceContextFactory(String name, ObjectFactory objectFactory) { + super(name, objectFactory); + } + +} diff --git a/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/config/WebServiceEntryPointContextFactory.java b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/config/WebServiceEntryPointContextFactory.java new file mode 100644 index 0000000000..39e0b10053 --- /dev/null +++ b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/config/WebServiceEntryPointContextFactory.java @@ -0,0 +1,58 @@ +/** + * + * 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.celtix.config; + +import org.apache.tuscany.binding.celtix.handler.CeltixEntryPointContextImpl; +import org.apache.tuscany.core.builder.ContextCreationException; +import org.apache.tuscany.core.context.EntryPointContext; +import org.apache.tuscany.core.extension.EntryPointContextFactory; +import org.apache.tuscany.core.message.MessageFactory; +import org.apache.tuscany.core.webapp.ServletHost; +import org.apache.tuscany.model.assembly.EntryPoint; + +/** + * 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 + * + * @version $Rev$ $Date$ + */ +public class WebServiceEntryPointContextFactory extends EntryPointContextFactory { + MessageFactory messageFactory; + EntryPoint entryPoint; + ServletHost servlet; + + public WebServiceEntryPointContextFactory(ServletHost tomcatHost, + EntryPoint entryPoint, + MessageFactory mf) { + super(entryPoint.getName(), mf); + messageFactory = mf; + this.entryPoint = entryPoint; + servlet = tomcatHost; + } + + public EntryPointContext createContext() throws ContextCreationException { + if (servlet == null) { + return new CeltixEntryPointContextImpl(entryPoint, + getSourceWireFactories().get(0), + messageFactory); + } else { + //REVISIT - running in tomcat + return null; + } + } + +} diff --git a/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/handler/CeltixEntryPointContextImpl.java b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/handler/CeltixEntryPointContextImpl.java new file mode 100644 index 0000000000..5b2e0df3d6 --- /dev/null +++ b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/handler/CeltixEntryPointContextImpl.java @@ -0,0 +1,263 @@ +/** + * + * 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.celtix.handler; + +import java.lang.reflect.Method; +import java.net.MalformedURLException; +import java.net.URL; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.Executor; + +import javax.jws.soap.SOAPBinding.Style; +import javax.wsdl.Binding; +import javax.wsdl.BindingInput; +import javax.wsdl.BindingOperation; +import javax.wsdl.Definition; +import javax.wsdl.Port; +import javax.wsdl.extensions.ExtensibilityElement; +import javax.wsdl.extensions.soap.SOAPAddress; +import javax.wsdl.extensions.soap.SOAPBody; +import javax.xml.namespace.QName; +import javax.xml.ws.WebServiceProvider; + +import commonj.sdo.helper.TypeHelper; + +import org.apache.tuscany.binding.celtix.assembly.WebServiceBinding; +import org.apache.tuscany.binding.celtix.handler.io.SCAServerDataBindingCallback; +import org.apache.tuscany.core.builder.BuilderConfigException; +import org.apache.tuscany.core.context.ContextInitException; +import org.apache.tuscany.core.context.CoreRuntimeException; +import org.apache.tuscany.core.context.impl.EntryPointContextImpl; +import org.apache.tuscany.core.message.MessageFactory; +import org.apache.tuscany.core.wire.SourceWireFactory; +import org.apache.tuscany.model.assembly.EntryPoint; +import org.objectweb.celtix.Bus; +import org.objectweb.celtix.bindings.DataBindingCallback; +import org.objectweb.celtix.bindings.ServerBinding; +import org.objectweb.celtix.bindings.ServerBindingEndpointCallback; +import org.objectweb.celtix.bindings.ServerDataBindingCallback; +import org.objectweb.celtix.bus.bindings.WSDLMetaDataCache; +import org.objectweb.celtix.bus.bindings.WSDLOperationInfo; +import org.objectweb.celtix.context.ObjectMessageContext; +import org.objectweb.celtix.ws.addressing.AttributedURIType; +import org.objectweb.celtix.ws.addressing.EndpointReferenceType; +import org.objectweb.celtix.wsdl.EndpointReferenceUtils; +import org.osoa.sca.annotations.Destroy; +import org.xmlsoap.schemas.wsdl.http.AddressType; + +public class CeltixEntryPointContextImpl extends EntryPointContextImpl + implements ServerBindingEndpointCallback { + + EntryPoint entry; + private Bus bus; + private Port port; + private TypeHelper typeHelper; + private WSDLMetaDataCache wsdlCache; + private ServerBinding serverBinding; + private Object entryPointProxy; + private WebServiceBinding wsBinding; + + private Map<QName, ServerDataBindingCallback> opMap = + new ConcurrentHashMap<QName, ServerDataBindingCallback>(); + + + public CeltixEntryPointContextImpl(EntryPoint entry, + SourceWireFactory sourceWireFactory, + MessageFactory messageFactory) + throws ContextInitException { + + super(entry.getName(), sourceWireFactory, messageFactory); + this.entry = entry; + } + + public void start() throws ContextInitException { + super.start(); + + entryPointProxy = getInstance(null); + wsBinding = (WebServiceBinding)entry.getBindings().get(0); + bus = wsBinding.getBus(); + typeHelper = wsBinding.getTypeHelper(); + Definition wsdlDef = wsBinding.getWSDLDefinition(); + port = wsBinding.getWSDLPort(); + wsdlCache = new WSDLMetaDataCache(wsdlDef, wsBinding.getWSDLPort()); + + initOperationMap(wsdlDef); + + String key = wsdlDef.getDocumentBaseURI(); + URL url; + try { + url = new URL(key); + } catch (MalformedURLException e) { + throw new ContextInitException(e); + } + + EndpointReferenceType reference = EndpointReferenceUtils.getEndpointReference(url, + wsBinding.getWSDLService().getQName(), + wsBinding.getWSDLPort().getName()); + + AttributedURIType address = new AttributedURIType(); + + String bindingId = null; + Binding binding = wsBinding.getWSDLPort().getBinding(); + if (null != binding) { + List list = binding.getExtensibilityElements(); + if (!list.isEmpty()) { + bindingId = ((ExtensibilityElement)list.get(0)).getElementType().getNamespaceURI(); + } + } + List<?> list = wsBinding.getWSDLPort().getExtensibilityElements(); + for (Object ep : list) { + ExtensibilityElement ext = (ExtensibilityElement)ep; + if (ext instanceof SOAPAddress) { + if (bindingId == null) { + bindingId = ((SOAPAddress)ext).getLocationURI(); + } + address.setValue(((SOAPAddress)ext).getLocationURI()); + } + if (ext instanceof AddressType) { + if (bindingId == null) { + bindingId = ((AddressType)ext).getLocation(); + } + address.setValue(((AddressType)ext).getLocation()); + } + } + if (reference.getAddress() == null) { + //REVIST - bug in Celtix that the HTTP transport won't find the address correctly + reference.setAddress(address); + } + + try { + serverBinding = bus.getBindingManager().getBindingFactory(bindingId).createServerBinding( + reference, this); + serverBinding.activate(); + } catch (Exception e) { + throw new ContextInitException(e); + } + } + + @Destroy + public void stop() throws CoreRuntimeException { + System.out.println("In stop"); + super.stop(); + } + + private void initOperationMap(Definition def) { + List ops = port.getBinding().getBindingOperations(); + Iterator opIt = ops.iterator(); + while (opIt.hasNext()) { + BindingOperation op = (BindingOperation)opIt.next(); + BindingInput bindingInput = op.getBindingInput(); + List elements = bindingInput.getExtensibilityElements(); + QName qn = new QName(def.getTargetNamespace(), op.getName()); + for (Iterator i = elements.iterator(); i.hasNext();) { + Object element = i.next(); + if (SOAPBody.class.isInstance(element)) { + SOAPBody body = (SOAPBody)element; + if (body.getNamespaceURI() != null) { + qn = new QName(body.getNamespaceURI(), op.getName()); + } + } + } + + ServerDataBindingCallback cb = getDataBindingCallback(qn, null, + DataBindingCallback.Mode.PARTS); + opMap.put(qn, cb); + if (!"".equals(cb.getRequestWrapperQName().getLocalPart())) { + opMap.put(cb.getRequestWrapperQName(), cb); + } + } + } + public ServerDataBindingCallback getDataBindingCallback(QName operationName, + ObjectMessageContext objContext, + DataBindingCallback.Mode mode) { + if (opMap.containsKey(operationName)) { + return opMap.get(operationName); + } + WSDLOperationInfo opInfo = wsdlCache.getOperationInfo(operationName.getLocalPart()); + if (opInfo == null) { + //REVISIT - really map the operation name to a WSDL operation + for (String opName : wsdlCache.getAllOperationInfo().keySet()) { + if (operationName.getLocalPart().equalsIgnoreCase(opName)) { + opInfo = wsdlCache.getOperationInfo(opName); + break; + } + } + } + boolean inout = false; + + + Class<?> serviceInterface = getServiceInterface(); + Method meth = getMethod(serviceInterface, operationName.getLocalPart()); + + return new SCAServerDataBindingCallback(opInfo, + typeHelper, + wsBinding.getResourceLoader(), + inout, + meth, + entryPointProxy); + } + protected Method getMethod(Class<?> serviceInterface, String operationName) { + // Note: this doesn't support overloaded operations + Method[] methods = serviceInterface.getMethods(); + for (Method m : methods) { + if (m.getName().equals(operationName)) { + return m; + } + // tolerate WSDL with capatalized operation name + StringBuilder sb = new StringBuilder(operationName); + sb.setCharAt(0, Character.toLowerCase(sb.charAt(0))); + if (m.getName().equals(sb.toString())) { + return m; + } + } + throw new BuilderConfigException("no operation named " + operationName + + " found on service interface: " + serviceInterface.getName()); + } + + + public DataBindingCallback getFaultDataBindingCallback(ObjectMessageContext objContext) { + // REVISIT - what to do about faults + return null; + } + + public Map<QName, ? extends DataBindingCallback> getOperations() { + return opMap; + } + + public Style getStyle() { + return wsdlCache.getStyle(); + } + public DataBindingCallback.Mode getServiceMode() { + return DataBindingCallback.Mode.PARTS; + } + + public WebServiceProvider getWebServiceProvider() { + //not needed I think + return null; + } + + public Executor getExecutor() { + //Let the transport handle it (or it goes to the Bus default wq + //if the transport cannot handle it + return null; + } + +} + diff --git a/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/handler/ExternalWebServiceClient.java b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/handler/ExternalWebServiceClient.java new file mode 100644 index 0000000000..01c571a611 --- /dev/null +++ b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/handler/ExternalWebServiceClient.java @@ -0,0 +1,199 @@ +/** + * + * 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.celtix.handler; + + +import java.io.IOException; +import java.net.MalformedURLException; +import java.net.URL; +import java.util.List; +import javax.jws.WebParam.Mode; +import javax.wsdl.Binding; +import javax.wsdl.Definition; +import javax.wsdl.WSDLException; +import javax.wsdl.extensions.ExtensibilityElement; +import javax.wsdl.extensions.soap.SOAPAddress; +import javax.xml.ws.Holder; +import javax.xml.ws.ProtocolException; + +import commonj.sdo.helper.TypeHelper; +import org.apache.tuscany.binding.celtix.assembly.WebServiceBinding; +import org.apache.tuscany.binding.celtix.handler.io.SCADataBindingCallback; +import org.apache.tuscany.core.builder.BuilderException; +import org.apache.tuscany.core.builder.BuilderInitException; +import org.apache.tuscany.model.assembly.ExternalService; +import org.objectweb.celtix.Bus; +import org.objectweb.celtix.BusException; +import org.objectweb.celtix.bindings.ClientBinding; +import org.objectweb.celtix.bindings.DataBindingCallback; +import org.objectweb.celtix.bus.bindings.WSDLMetaDataCache; +import org.objectweb.celtix.bus.bindings.WSDLOperationInfo; +import org.objectweb.celtix.context.ObjectMessageContext; +import org.objectweb.celtix.ws.addressing.EndpointReferenceType; +import org.objectweb.celtix.wsdl.EndpointReferenceUtils; +import org.xmlsoap.schemas.wsdl.http.AddressType; + + +/** + * An ExternalWebServiceClient using Celtix + */ +public class ExternalWebServiceClient { + + private Bus bus; + private TypeHelper typeHelper; + private WSDLMetaDataCache wsdlCache; + private ClientBinding clientBinding; + private WebServiceBinding wsBinding; + + + + public ExternalWebServiceClient(ExternalService externalService) throws BuilderException { + wsBinding = (WebServiceBinding)externalService.getBindings().get(0); + bus = wsBinding.getBus(); + typeHelper = wsBinding.getTypeHelper(); + Definition wsdlDef = wsBinding.getWSDLDefinition(); + wsdlCache = new WSDLMetaDataCache(wsdlDef, wsBinding.getWSDLPort()); + + try { + String key = wsdlDef.getDocumentBaseURI(); + URL url = new URL(key); + + EndpointReferenceType reference = EndpointReferenceUtils.getEndpointReference(url, + wsBinding.getWSDLService().getQName(), + wsBinding.getWSDLPort().getName()); + + String bindingId = null; + Binding binding = wsBinding.getWSDLPort().getBinding(); + if (null != binding) { + List list = binding.getExtensibilityElements(); + if (!list.isEmpty()) { + bindingId = ((ExtensibilityElement)list.get(0)).getElementType().getNamespaceURI(); + } + } + if (bindingId == null) { + List<?> list = wsBinding.getWSDLPort().getExtensibilityElements(); + for (Object ep : list) { + ExtensibilityElement ext = (ExtensibilityElement)ep; + if (ext instanceof SOAPAddress) { + bindingId = ((SOAPAddress)ext).getLocationURI(); + } + if (ext instanceof AddressType) { + bindingId = ((AddressType)ext).getLocation(); + } + } + + } + clientBinding = bus.getBindingManager().getBindingFactory(bindingId).createClientBinding( + reference); + } catch (MalformedURLException e) { + throw new BuilderInitException(e); + } catch (BusException e) { + throw new BuilderInitException(e); + } catch (WSDLException e) { + throw new BuilderInitException(e); + } catch (IOException e) { + throw new BuilderInitException(e); + } + } + + /** + * Invoke an operation on the external Web service. + * + * @param operationName the name of the WS operation to invoke + * @param args the Java object arguments to the WS operation + * @return the response from the WS as a Java object + */ + public Object invoke(String operationName, Object[] args) { + WSDLOperationInfo opInfo = wsdlCache.getOperationInfo(operationName); + if (opInfo == null) { + //REVISIT - really map the operation name to a WSDL operation + for (String opName : wsdlCache.getAllOperationInfo().keySet()) { + if (operationName.equalsIgnoreCase(opName)) { + opInfo = wsdlCache.getOperationInfo(opName); + break; + } + } + } + ObjectMessageContext objMsgContext = clientBinding.createObjectContext(); + + boolean hasInOut = false; + int inOutCount = 0; + Object realArgs[] = new Object[args.length]; + if (opInfo.getParamsLength() == 0) { + //REVISIT - opInfo doesn't return the needed info for the wrapped doc/lit case. + //Bug in Celtix + realArgs = args; + } else { + for (int x = 0; x < args.length; x++) { + if (opInfo.getWebParam(x).mode() == Mode.IN) { + realArgs[x] = args[x]; + } else { + realArgs[x] = new Holder<Object>(args[x]); + inOutCount++; + hasInOut = true; + } + } + } + + objMsgContext.setMessageObjects(realArgs); + + boolean isOneway = opInfo.isOneWay(); + DataBindingCallback callback = new SCADataBindingCallback(opInfo, typeHelper, + wsBinding.getResourceLoader(), + hasInOut); + + try { + if (isOneway) { + clientBinding.invokeOneWay(objMsgContext, + callback); + } else { + objMsgContext = clientBinding.invoke(objMsgContext, + callback); + } + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + if (objMsgContext.getException() != null) { + //REVISIT - Exceptions + /* + if (isValidException(objMsgContext)) { + throw (Exception)objMsgContext.getException(); + } else { + throw new ProtocolException(objMsgContext.getException()); + } + */ + throw new ProtocolException(objMsgContext.getException()); + } + + if (hasInOut) { + Object ret[] = new Object[inOutCount + 1]; + ret[0] = objMsgContext.getReturn(); + inOutCount = 1; + for (int x = 0; x < args.length; x++) { + if (opInfo.getWebParam(x).mode() != Mode.IN) { + Holder<?> holder = (Holder<?>)realArgs[x]; + ret[inOutCount] = holder.value; + inOutCount++; + } + } + return ret; + } + return objMsgContext.getReturn(); + } +} diff --git a/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/handler/ExternalWebServiceTargetInvoker.java b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/handler/ExternalWebServiceTargetInvoker.java new file mode 100644 index 0000000000..06786ca76d --- /dev/null +++ b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/handler/ExternalWebServiceTargetInvoker.java @@ -0,0 +1,115 @@ +/** + * + * 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.celtix.handler; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +import org.apache.tuscany.core.context.Context; +import org.apache.tuscany.core.context.ExternalServiceContext; +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.message.Message; +import org.apache.tuscany.core.wire.Interceptor; +import org.apache.tuscany.core.wire.TargetInvoker; + + +/** + * 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. + */ + public ExternalWebServiceTargetInvoker(QualifiedName servicename, + Method meth, + ScopeContext cont) { + assert servicename != null : "No service name specified"; + assert meth != null : "No method specified"; + assert cont != null : "No scope container specified"; + this.serviceName = servicename; + this.esName = serviceName.getPartName(); + this.method = meth; + this.container = cont; + } + + public Object invokeTarget(Object payload) throws InvocationTargetException { + if (context == null) { + Context 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.getHandler(); + if (payload != null) { + return client.invoke(method.getName(), (Object[])payload); + } else { + return client.invoke(method.getName(), new Object[0]); + } + } + + 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() throws CloneNotSupportedException { + 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) { + // will not happen + return null; + } + } + +} diff --git a/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/handler/io/NodeDataReader.java b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/handler/io/NodeDataReader.java new file mode 100644 index 0000000000..d1b13f6e17 --- /dev/null +++ b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/handler/io/NodeDataReader.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.celtix.handler.io; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.util.List; +import javax.xml.namespace.QName; +import javax.xml.ws.WebServiceException; + +import org.w3c.dom.Node; +import org.w3c.dom.bootstrap.DOMImplementationRegistry; +import org.w3c.dom.ls.DOMImplementationLS; +import org.w3c.dom.ls.LSOutput; +import org.w3c.dom.ls.LSSerializer; +import commonj.sdo.DataObject; +import commonj.sdo.Property; +import commonj.sdo.helper.XMLDocument; + +import org.apache.tuscany.databinding.sdo.SDOXMLHelper; +import org.apache.tuscany.sdo.helper.XMLHelperImpl; +import org.objectweb.celtix.bindings.DataReader; +import org.objectweb.celtix.context.ObjectMessageContext; + +public class NodeDataReader implements DataReader<Node> { + + SCADataBindingCallback callback; + + public NodeDataReader(SCADataBindingCallback cb) { + callback = cb; + } + + public Object read(int idx, Node input) { + return read(null, idx, input); + } + + public Object read(QName name, int idx, Node input) { + try { + byte bytes[] = getNodeBytes(input); + Object os[] = SDOXMLHelper.toObjects(callback.getResourceClassLoader(), + callback.getTypeHelper(), bytes, false); + return os[0]; + } catch (RuntimeException e) { + throw e; + } catch (Exception e) { + throw new WebServiceException(e); + } + + } + + public void readWrapper(ObjectMessageContext objCtx, boolean isOutBound, Node input) { + try { + QName wrapperName; + if (isOutBound) { + wrapperName = callback.getOperationInfo().getResponseWrapperQName(); + } else { + wrapperName = callback.getOperationInfo().getRequestWrapperQName(); + } + + Node nd = input.getFirstChild(); + while (nd != null + && !wrapperName.getNamespaceURI().equals(nd.getNamespaceURI()) + && !wrapperName.getLocalPart().equals(nd.getLocalName())) { + nd = nd.getNextSibling(); + } + + //REVISIT - This is SUCH a HACK. This needs to be done with StAX or something + //a bit better than streaming and reparsing + InputStream in = getNodeStream(nd); + XMLDocument document = new XMLHelperImpl(callback.getTypeHelper()).load(in); + DataObject object = document.getRootObject(); + + List ips = object.getInstanceProperties(); + Object[] os = new Object[object.getInstanceProperties().size()]; + for (int i = 0; i < os.length; i++) { + os[i] = object.get((Property)ips.get(i)); + } + + if (callback.hasInOut()) { + //REVISIT - inOuts + } else { + if (isOutBound) { + objCtx.setReturn(os[0]); + } else { + objCtx.setMessageObjects(os); + } + } + } catch (IOException e) { + throw new WebServiceException(e); + } catch (ClassCastException e) { + throw new WebServiceException(e); + } catch (ClassNotFoundException e) { + throw new WebServiceException(e); + } catch (InstantiationException e) { + throw new WebServiceException(e); + } catch (IllegalAccessException e) { + throw new WebServiceException(e); + } + } + private byte[] getNodeBytes(Node node) + throws ClassCastException, ClassNotFoundException, + InstantiationException, IllegalAccessException { + + //This is also a hack, the JDK should already have this set, but it doesn't + DOMImplementationRegistry registry = DOMImplementationRegistry.newInstance(); + if (registry == null) { + System.setProperty(DOMImplementationRegistry.PROPERTY, + "com.sun.org.apache.xerces.internal.dom.DOMImplementationSourceImpl"); + registry = DOMImplementationRegistry.newInstance(); + } + DOMImplementationLS impl = (DOMImplementationLS)registry.getDOMImplementation("LS"); + if (impl == null) { + System.setProperty(DOMImplementationRegistry.PROPERTY, + "com.sun.org.apache.xerces.internal.dom.DOMImplementationSourceImpl"); + registry = DOMImplementationRegistry.newInstance(); + impl = (DOMImplementationLS)registry.getDOMImplementation("LS"); + } + LSOutput output = impl.createLSOutput(); + ByteArrayOutputStream bout = new ByteArrayOutputStream(); + output.setByteStream(bout); + LSSerializer writer = impl.createLSSerializer(); + writer.write(node, output); + + return bout.toByteArray(); + } + + private InputStream getNodeStream(Node node) + throws ClassCastException, ClassNotFoundException, + InstantiationException, IllegalAccessException { + + DOMImplementationRegistry registry = DOMImplementationRegistry.newInstance(); + if (registry == null) { + //This is also a hack, the JDK should already have this set, but it doesn't + System.setProperty(DOMImplementationRegistry.PROPERTY, + "com.sun.org.apache.xerces.internal.dom.DOMImplementationSourceImpl"); + registry = DOMImplementationRegistry.newInstance(); + } + DOMImplementationLS impl = (DOMImplementationLS)registry.getDOMImplementation("LS"); + if (impl == null) { + System.setProperty(DOMImplementationRegistry.PROPERTY, + "com.sun.org.apache.xerces.internal.dom.DOMImplementationSourceImpl"); + registry = DOMImplementationRegistry.newInstance(); + impl = (DOMImplementationLS)registry.getDOMImplementation("LS"); + } + LSOutput output = impl.createLSOutput(); + RawByteArrayOutputStream bout = new RawByteArrayOutputStream(); + output.setByteStream(bout); + LSSerializer writer = impl.createLSSerializer(); + writer.write(node, output); + + return new ByteArrayInputStream(bout.getBytes(), 0, bout.size()); + } + +} diff --git a/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/handler/io/NodeDataWriter.java b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/handler/io/NodeDataWriter.java new file mode 100644 index 0000000000..27c2276c2a --- /dev/null +++ b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/handler/io/NodeDataWriter.java @@ -0,0 +1,179 @@ +/** + * + * 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.celtix.handler.io; + + +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.util.List; +import javax.xml.namespace.QName; +import javax.xml.parsers.ParserConfigurationException; +import javax.xml.parsers.SAXParser; +import javax.xml.parsers.SAXParserFactory; +import javax.xml.ws.Holder; +import javax.xml.ws.WebServiceException; + +import org.w3c.dom.Document; +import org.w3c.dom.Element; +import org.w3c.dom.Node; +import org.xml.sax.Attributes; +import org.xml.sax.SAXException; +import org.xml.sax.helpers.DefaultHandler; +import commonj.sdo.DataObject; +import commonj.sdo.Property; +import commonj.sdo.helper.TypeHelper; +import commonj.sdo.helper.XSDHelper; + +import org.apache.tuscany.databinding.sdo.SDOXMLHelper; +import org.apache.tuscany.sdo.helper.DataFactoryImpl; +import org.apache.tuscany.sdo.helper.XMLHelperImpl; +import org.apache.tuscany.sdo.helper.XSDHelperImpl; +import org.objectweb.celtix.bindings.DataWriter; +import org.objectweb.celtix.context.ObjectMessageContext; + +public class NodeDataWriter implements DataWriter<Node> { + SCADataBindingCallback callback; + + public NodeDataWriter(SCADataBindingCallback cb) { + callback = cb; + } + + public void write(Object obj, Node output) { + write(obj, null, output); + } + + public void write(Object obj, QName elName, Node output) { + byte bytes[] = SDOXMLHelper.toXMLBytes( + callback.getResourceClassLoader(), + callback.getTypeHelper(), + new Object[] {obj}, + elName, + false); + ByteArrayInputStream bin = new ByteArrayInputStream(bytes); + SAXParserFactory factory = SAXParserFactory.newInstance(); + factory.setNamespaceAware(true); + try { + SAXParser parser = factory.newSAXParser(); + parser.parse(bin, new NodeContentHandler(output)); + } catch (RuntimeException e) { + throw e; + } catch (Exception e) { + throw new WebServiceException(e); + } + + } + + public void writeWrapper(ObjectMessageContext objCtx, boolean isOutbound, Node nd) { + QName wrapperName; + if (isOutbound) { + wrapperName = callback.getOperationInfo().getResponseWrapperQName(); + } else { + wrapperName = callback.getOperationInfo().getRequestWrapperQName(); + } + + DataObject obj = toWrappedDataObject(callback.getTypeHelper(), + isOutbound ? objCtx.getReturn() : null, + objCtx.getMessageObjects(), + wrapperName); + + try { + //REVISIT - this is SUCH a hack. SDO needs to be able to + //go directly to some formats other than streams. They are working + //on stax, but not there yet. + RawByteArrayOutputStream bout = new RawByteArrayOutputStream(); + new XMLHelperImpl(callback.getTypeHelper()).save(obj, + wrapperName.getNamespaceURI(), + wrapperName.getLocalPart(), + bout); + + ByteArrayInputStream bin = new ByteArrayInputStream(bout.getBytes(), + 0, + bout.size()); + SAXParserFactory factory = SAXParserFactory.newInstance(); + factory.setNamespaceAware(true); + SAXParser parser = factory.newSAXParser(); + parser.parse(bin, new NodeContentHandler(nd)); + } catch (IOException e) { + throw new WebServiceException(e); + } catch (ParserConfigurationException e) { + throw new WebServiceException(e); + } catch (SAXException e) { + throw new WebServiceException(e); + } + } + + + public static DataObject toWrappedDataObject(TypeHelper typeHelper, + Object ret, + 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(); + int offset = 0; + if (ret != null) { + dataObject.set(0, ret); + offset = 1; + } + for (int i = offset; i < ips.size(); i++) { + if (os[i - offset] instanceof Holder) { + Holder<?> holder = (Holder<?>)os[i - offset]; + dataObject.set(i, holder.value); + } else { + dataObject.set(i, os[i - offset]); + } + } + return dataObject; + } + + private class NodeContentHandler extends DefaultHandler { + Node current; + Document doc; + + public NodeContentHandler(Node nd) { + doc = nd.getOwnerDocument(); + if (doc == null && nd instanceof Document) { + doc = (Document)nd; + } + current = nd; + } + + public void characters(char[] ch, int start, int length) { + current.appendChild(doc.createTextNode(new String(ch, start, length))); + } + + public void startElement(String uri, String localName, + String qName, Attributes attributes) { + Element newEl = doc.createElementNS(uri, qName); + current.appendChild(newEl); + current = newEl; + for (int x = 0; x < attributes.getLength(); x++) { + newEl.setAttributeNS(attributes.getURI(x), + attributes.getQName(x), + attributes.getValue(x)); + } + } + + public void endElement(String uri, String localName, String qName) { + current = current.getParentNode(); + } + } + + +} diff --git a/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/handler/io/RawByteArrayOutputStream.java b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/handler/io/RawByteArrayOutputStream.java new file mode 100644 index 0000000000..902a3e618c --- /dev/null +++ b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/handler/io/RawByteArrayOutputStream.java @@ -0,0 +1,28 @@ +/** + * + * 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.celtix.handler.io; + +import java.io.ByteArrayOutputStream; + +/** + * Just to allow raw access to the byte[] to avoid a copy + */ +class RawByteArrayOutputStream extends ByteArrayOutputStream { + public byte[] getBytes() { + return buf; + } +} diff --git a/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/handler/io/SCADataBindingCallback.java b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/handler/io/SCADataBindingCallback.java new file mode 100644 index 0000000000..00dc403f2c --- /dev/null +++ b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/handler/io/SCADataBindingCallback.java @@ -0,0 +1,91 @@ +/** + * + * 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.celtix.handler.io; + + +import org.w3c.dom.Node; +import commonj.sdo.helper.TypeHelper; + +import org.apache.tuscany.common.resource.ResourceLoader; +import org.objectweb.celtix.bindings.DataReader; +import org.objectweb.celtix.bindings.DataWriter; +import org.objectweb.celtix.bus.bindings.AbstractWSDLOperationDataBindingCallback; +import org.objectweb.celtix.bus.bindings.WSDLOperationInfo; +import org.objectweb.celtix.context.ObjectMessageContext; + +public class SCADataBindingCallback extends AbstractWSDLOperationDataBindingCallback { + + protected TypeHelper typeHelper; + protected boolean hasInOut; + protected ResourceLoader loader; + + public SCADataBindingCallback(WSDLOperationInfo op, + TypeHelper helper, + ResourceLoader l, + boolean inout) { + super(op); + typeHelper = helper; + hasInOut = inout; + loader = l; + } + + public ResourceLoader getResourceLoader() { + return loader; + } + public ClassLoader getResourceClassLoader() { + return loader.getClassLoader(); + } + + public TypeHelper getTypeHelper() { + return typeHelper; + } + + public boolean hasInOut() { + return hasInOut; + } + + public Mode getMode() { + return Mode.PARTS; + } + + public Class<?>[] getSupportedFormats() { + return new Class<?>[]{Node.class}; + } + + @SuppressWarnings("unchecked") + public <T> DataWriter<T> createWriter(Class<T> cls) { + if (cls == Node.class) { + return (DataWriter<T>)new NodeDataWriter(this); + } + return null; + } + + @SuppressWarnings("unchecked") + public <T> DataReader<T> createReader(Class<T> cls) { + if (cls == Node.class) { + return (DataReader<T>)new NodeDataReader(this); + } + //REVISIT - need to figure out what to do with Faults + return null; + } + + public void initObjectContext(ObjectMessageContext octx) { + //REVISIT - is this even used? + } + + +} diff --git a/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/handler/io/SCAServerDataBindingCallback.java b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/handler/io/SCAServerDataBindingCallback.java new file mode 100644 index 0000000000..5926e066c2 --- /dev/null +++ b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/handler/io/SCAServerDataBindingCallback.java @@ -0,0 +1,61 @@ +/** + * + * 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.celtix.handler.io; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +import commonj.sdo.helper.TypeHelper; + +import org.apache.tuscany.common.resource.ResourceLoader; +import org.objectweb.celtix.bindings.ServerDataBindingCallback; +import org.objectweb.celtix.bus.bindings.WSDLOperationInfo; +import org.objectweb.celtix.context.ObjectMessageContext; + +public class SCAServerDataBindingCallback extends SCADataBindingCallback + implements ServerDataBindingCallback { + Method method; + Object targetObject; + + public SCAServerDataBindingCallback(WSDLOperationInfo op, TypeHelper helper, + ResourceLoader l, + boolean inout, Method meth, Object target) { + super(op, helper, l, inout); + method = meth; + targetObject = target; + } + + + public void invoke(ObjectMessageContext octx) throws InvocationTargetException { + Object ret; + try { + ret = method.invoke(targetObject, octx.getMessageObjects()); + } catch (RuntimeException e) { + throw e; + } catch (Exception e) { + throw new InvocationTargetException(e); + } + octx.setReturn(ret); + } + + public void initObjectContext(ObjectMessageContext octx) { + Object o[] = new Object[method.getParameterTypes().length]; + //REVIST - holders? + octx.setMessageObjects(o); + } + +} diff --git a/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/loader/TuscanyWSDLManager.java b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/loader/TuscanyWSDLManager.java new file mode 100644 index 0000000000..913b43cfeb --- /dev/null +++ b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/loader/TuscanyWSDLManager.java @@ -0,0 +1,88 @@ +/** + * + * 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.celtix.loader; + +import java.io.IOException; +import java.net.URL; + +import javax.wsdl.Definition; +import javax.wsdl.WSDLException; +import javax.wsdl.extensions.ExtensionRegistry; +import javax.wsdl.factory.WSDLFactory; + +import org.w3c.dom.Element; + +import org.apache.tuscany.core.loader.WSDLDefinitionRegistry; + +import org.objectweb.celtix.BusException; +import org.objectweb.celtix.wsdl.WSDLManager; + +public class TuscanyWSDLManager implements WSDLManager { + WSDLDefinitionRegistry wsdlDefinitionRegistry; + + public TuscanyWSDLManager(WSDLDefinitionRegistry w) throws BusException { + wsdlDefinitionRegistry = w; + } + + public WSDLFactory getWSDLFactory() { + //Not supported + return null; + } + + public ExtensionRegistry getExtenstionRegistry() { + return wsdlDefinitionRegistry.getExtensionRegistry(); + } + + public Definition getDefinition(URL url) throws WSDLException { + try { + //FIXME pass the current ResourceLoader + return wsdlDefinitionRegistry.loadDefinition(null, url, null); + } catch (IOException e) { + throw new WSDLException(WSDLException.CONFIGURATION_ERROR, e.getMessage()); + } + } + + public Definition getDefinition(String url) throws WSDLException { + try { + //The namespace is the wsdl targetNamesapce, it is only used + //when the wsdl is created into cache. we are ok here to set it to null. + //FIXME pass the current ResourceLoader + return wsdlDefinitionRegistry.loadDefinition(null, new URL(url), null); + } catch (IOException e) { + throw new WSDLException(WSDLException.CONFIGURATION_ERROR, e.getMessage()); + } + } + + public Definition getDefinition(Element el) throws WSDLException { + //Not supported + return null; + } + + public Definition getDefinition(Class<?> sei) throws WSDLException { + //Not supported + return null; + } + + public void addDefinition(Object key, Definition wsdl) { + //Not supported + } + + public void shutdown() { + } + + +} diff --git a/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/loader/WebServiceBindingLoader.java b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/loader/WebServiceBindingLoader.java new file mode 100644 index 0000000000..3520203523 --- /dev/null +++ b/sca-java-1.x/branches/java-post-M1/sca/bindings/binding.celtix/src/main/java/org/apache/tuscany/binding/celtix/loader/WebServiceBindingLoader.java @@ -0,0 +1,99 @@ +/** + * + * Copyright 2005 The Apache Software Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.tuscany.binding.celtix.loader; + +import java.util.Map; +import java.util.WeakHashMap; + +import javax.xml.namespace.QName; +import javax.xml.stream.XMLStreamException; +import javax.xml.stream.XMLStreamReader; + +import org.apache.tuscany.binding.celtix.assembly.WebServiceAssemblyFactory; +import org.apache.tuscany.binding.celtix.assembly.WebServiceBinding; +import org.apache.tuscany.binding.celtix.assembly.impl.WebServiceAssemblyFactoryImpl; +import org.apache.tuscany.core.config.ConfigurationLoadException; +import org.apache.tuscany.core.loader.LoaderContext; +import org.apache.tuscany.core.loader.StAXElementLoader; +import org.apache.tuscany.core.loader.StAXLoaderRegistry; +import org.apache.tuscany.core.loader.WSDLDefinitionRegistry; +import org.apache.tuscany.core.system.annotation.Autowire; +import org.objectweb.celtix.Bus; +import org.osoa.sca.annotations.Destroy; +import org.osoa.sca.annotations.Init; +import org.osoa.sca.annotations.Scope; + + +/** + * @version $Rev$ $Date$ + */ +@Scope("MODULE") +public class WebServiceBindingLoader implements StAXElementLoader<WebServiceBinding> { + public static final QName BINDING_WS = new QName("http://www.osoa.org/xmlns/sca/0.9", "binding.ws"); + + private static final WebServiceAssemblyFactory WS_FACTORY = new WebServiceAssemblyFactoryImpl(); + + protected StAXLoaderRegistry registry; + protected WSDLDefinitionRegistry wsdlRegistry; + + private Bus bus; + + @Autowire + public void setRegistry(StAXLoaderRegistry reg) { + this.registry = reg; + } + + @Autowire + public void setWsdlRegistry(WSDLDefinitionRegistry wsdlReg) { + try { + Map<String, Object> properties = new WeakHashMap<String, Object>(); + properties.put("celtix.WSDLManager", new TuscanyWSDLManager(wsdlReg)); + bus = Bus.init(new String[0], properties); + wsdlRegistry = wsdlReg; + } catch (Exception e) { + e.printStackTrace(); + } + } + + @Init(eager = true) + public void start() { + registry.registerLoader(BINDING_WS, this); + } + + @Destroy + public void stop() { + try { + registry.unregisterLoader(BINDING_WS, this); + bus.shutdown(true); + } catch (Exception e) { + e.printStackTrace(); + } + } + + @SuppressWarnings("deprecation") + public WebServiceBinding load(XMLStreamReader reader, LoaderContext loaderContext) + throws XMLStreamException, ConfigurationLoadException { + + WebServiceBinding binding = WS_FACTORY.createWebServiceBinding(wsdlRegistry); + binding.setURI(reader.getAttributeValue(null, "uri")); + binding.setPortURI(reader.getAttributeValue(null, "port")); + binding.setTypeHelper(registry.getContext().getTypeHelper()); + binding.setResourceLoader(loaderContext.getResourceLoader()); + binding.setBus(bus); + return binding; + } +} |