TUSCANY-2930 main part of separating wireFormat.jmsdefault out from wireFormat.jmsTextXML. I've spotted a few more things that need fixing but this basic functionality passes all of our current JMS tests and now better matched what the specification says about default format.

git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@768263 13f79535-47bb-0310-9956-ffa450edef68

15 files changed, 1109 insertions, 40 deletions

diff --git a/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/context/JMSBindingContext.java b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/context/JMSBindingContext.java
index 6801270ee1..64c07dbae3 100644
--- a/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/context/JMSBindingContext.java
+++ b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/context/JMSBindingContext.java
@@ -42,6 +42,7 @@ public class JMSBindingContext {
     private Destination replyToDestination;
     private JMSResourceFactory jmsResourceFactory;
     private long timeToLive;
+    private boolean useBytesForWFJMSDefaultResponse;
 
     public Message getJmsMsg() {
         return jmsMsg;
@@ -130,4 +131,13 @@ public class JMSBindingContext {
     public void setTimeToLive(long timeToLive) {
 		this.timeToLive = timeToLive;
 	}
+
+    public boolean isUseBytesForWFJMSDefaultResponse() {
+        return useBytesForWFJMSDefaultResponse;
+    }
+
+    public void setUseBytesForWFJMSDefaultResponse(
+            boolean useBytesForWFJMSDefaultResponse) {
+        this.useBytesForWFJMSDefaultResponse = useBytesForWFJMSDefaultResponse;
+    }
 }
diff --git a/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/provider/DefaultMessageProcessor.java b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/provider/DefaultMessageProcessor.java
new file mode 100644
index 0000000000..76f069c6d9
--- /dev/null
+++ b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/provider/DefaultMessageProcessor.java
@@ -0,0 +1,267 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.tuscany.sca.binding.jms.provider;
+
+import java.io.ByteArrayInputStream;
+import java.io.StringReader;
+import java.util.logging.Logger;
+
+import javax.jms.BytesMessage;
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.Session;
+import javax.jms.TextMessage;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+
+import org.apache.axiom.om.OMElement;
+import org.apache.axiom.om.OMNode;
+import org.apache.axiom.om.impl.builder.StAXOMBuilder;
+import org.apache.tuscany.sca.binding.jms.impl.JMSBinding;
+import org.apache.tuscany.sca.binding.jms.impl.JMSBindingConstants;
+import org.apache.tuscany.sca.binding.jms.impl.JMSBindingException;
+import org.apache.tuscany.sca.interfacedef.util.FaultException;
+
+/**
+ * MessageProcessor for sending/receiving XML over javax.jms.TextMessage or javax.jms.BytesMessage 
+ * with the JMSBinding.
+ * This is very specific to the default wire format and is not tied into the usual hierarchy
+ * of message processors
+ * 
+ * @version $Rev$ $Date$
+ */
+public class DefaultMessageProcessor extends AbstractMessageProcessor {
+    private static final Logger logger = Logger.getLogger(DefaultMessageProcessor.class.getName());
+
+    public DefaultMessageProcessor(JMSBinding jmsBinding) {
+        super(jmsBinding);
+    }
+    
+    // inherited methods that don't do anything useful
+    @Override
+    protected Message createJMSMessage(Session session, Object o) {
+        // should not be used
+        return null;
+    }
+    
+    @Override
+    protected Object extractPayload(Message msg) {
+        // if it's not a text/bytes message or a fault then we don;t know what to do with it
+        return null;
+    }
+    
+    // TODO - This makes the assumption that whatever the text/bytes configuration of the
+    //        jms binding, unchecked faults will be sent as bytes. 
+    @Override
+    public Message createFaultMessage(Session session, Throwable o) {
+        return createFaultJMSBytesMessage(session, o);
+    }
+    
+    // handle text messages
+    
+    public Object extractPayloadFromJMSTextMessage(Message msg, OMElement wrapper) {
+        if (msg instanceof TextMessage) {
+            try {
+                String xml = ((TextMessage) msg).getText();
+                Object os;
+                if (xml != null) {
+                    XMLStreamReader reader = XMLInputFactory.newInstance().createXMLStreamReader(new StringReader(xml));
+                    StAXOMBuilder builder = new StAXOMBuilder(reader);
+                    os = builder.getDocumentElement();
+                } else {
+                    os = null;
+                }
+                
+                if (wrapper != null){
+                    //don't modify the original wrapper since it will be reused
+                    //clone the wrapper
+                    OMElement newWrapper = wrapper.cloneOMElement();
+                    newWrapper.addChild((OMNode)os);
+                    return newWrapper;
+                }
+                
+                return os;
+    
+            } catch (XMLStreamException e) {
+                throw new JMSBindingException(e);
+            } catch (JMSException e) {
+                throw new JMSBindingException(e);
+            }
+        } else {
+            // handle the non-text fault case
+            return super.extractPayloadFromJMSMessage(msg);
+        }
+    }
+    
+    public Message insertPayloadIntoJMSTextMessage(Session session, Object o, boolean unwrap) {
+
+        try {
+
+            TextMessage message = session.createTextMessage();
+
+            if (o instanceof OMElement) {
+                
+                if (unwrap){
+                    if (((OMElement)o).getFirstElement() != null ){
+                        message.setText(((OMElement)o).getFirstElement().toString());
+                    }
+                }else {
+                    message.setText(o.toString());
+                }
+            } else if ((o instanceof Object[]) && ((Object[]) o)[0] instanceof OMElement) {
+                if (unwrap){
+                    message.setText(((OMElement)((Object[]) o)[0]).getFirstElement().toString());
+                    //message.setText((((Object[]) o)[0]).toString());
+                }else {
+                    message.setText(((Object[]) o)[0].toString());
+                }
+            } else if (o != null) {
+                throw new IllegalStateException("expecting OMElement payload: " + o);
+            }
+
+            return message;
+
+        } catch (JMSException e) {
+            throw new JMSBindingException(e);
+        }
+    }
+
+    public Message createFaultJMSTextMessage(Session session, Throwable o) {
+
+        if (session == null) {
+            logger.fine("no response session to create fault message: " + String.valueOf(o));
+            return null;
+        }
+        if (o instanceof FaultException) {
+            try {
+
+                TextMessage message = session.createTextMessage();
+                message.setText(String.valueOf(((FaultException) o).getFaultInfo()));
+                message.setBooleanProperty(JMSBindingConstants.FAULT_PROPERTY, true);
+                return message;
+
+            } catch (JMSException e) {
+                throw new JMSBindingException(e);
+            }
+        } else {
+            // handle the non XML fault case
+            return super.createFaultMessage(session, o);
+        }
+    }
+
+    // handle bytes messages
+    
+    public Object extractPayloadFromJMSBytesMessage(Message msg, OMElement wrapper) {
+        
+        if (msg instanceof BytesMessage) {        
+            try {
+                Object os;
+    
+                long noOfBytes = ((BytesMessage) msg).getBodyLength();
+                byte[] bytes = new byte[(int) noOfBytes];
+                ((BytesMessage) msg).readBytes(bytes);
+    
+                if ((bytes != null) && (bytes.length > 0)) {
+                    XMLStreamReader reader = XMLInputFactory.newInstance().createXMLStreamReader(new ByteArrayInputStream(bytes));
+                    StAXOMBuilder builder = new StAXOMBuilder(reader);
+                    os = builder.getDocumentElement();
+                } else {
+                    os = null;
+                }
+                
+                if (wrapper != null){
+                    //don't modify the original wrapper since it will be reused
+                    //clone the wrapper
+                    OMElement newWrapper = wrapper.cloneOMElement();
+                    if (os != null){
+                        newWrapper.addChild((OMNode)os);
+                    } 
+                    return newWrapper;
+                }
+                
+                return os;
+    
+            } catch (XMLStreamException e) {
+                throw new JMSBindingException(e);
+            } catch (JMSException e) {
+                throw new JMSBindingException(e);
+            }
+        } else {
+            // trap the non-bytes fault case
+            return super.extractPayloadFromJMSMessage(msg);
+        }
+    }
+    
+    public Message insertPayloadIntoJMSBytesMessage(Session session, Object o, boolean unwrap) {
+
+        try {
+
+            BytesMessage message = session.createBytesMessage();
+            
+
+            if (o instanceof OMElement) {
+                if (unwrap) {
+                    if (((OMElement)o).getFirstElement() != null){
+                        message.writeBytes(((OMElement)o).getFirstElement().toString().getBytes());
+                    }
+                } else {
+                    message.writeBytes(o.toString().getBytes());                    
+                }
+
+            } else if ((o instanceof Object[]) && ((Object[]) o)[0] instanceof OMElement) {
+                if (unwrap){
+                    message.writeBytes(((OMElement)((Object[]) o)[0]).getFirstElement().toString().getBytes());
+                }else {
+                    message.writeBytes(((Object[]) o)[0].toString().getBytes());
+                }
+            } else if (o != null) {
+                throw new IllegalStateException("expecting OMElement payload: " + o);
+            }
+
+            return message;
+
+        } catch (JMSException e) {
+            throw new JMSBindingException(e);
+        }
+    }
+    
+    public Message createFaultJMSBytesMessage(Session session, Throwable o) {
+
+        if (session == null) {
+            logger.fine("no response session to create fault message: " + String.valueOf(o));
+            return null;
+        }
+        
+        if (o instanceof FaultException) {
+            try {
+
+                BytesMessage message = session.createBytesMessage();
+                message.writeBytes(String.valueOf(((FaultException) o).getFaultInfo()).getBytes());
+                message.setBooleanProperty(JMSBindingConstants.FAULT_PROPERTY, true);
+                return message;
+
+            } catch (JMSException e) {
+                throw new JMSBindingException(e);
+            }
+        } else {
+            return super.createFaultMessage(session, o);
+        }
+    }    
+}
diff --git a/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/provider/RRBJMSBindingInvoker.java b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/provider/RRBJMSBindingInvoker.java
index e2b75de5b9..ee9501bf89 100644
--- a/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/provider/RRBJMSBindingInvoker.java
+++ b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/provider/RRBJMSBindingInvoker.java
@@ -49,8 +49,6 @@ public class RRBJMSBindingInvoker implements Invoker, DataExchangeSemantics {
 
     protected JMSBinding jmsBinding;
     protected JMSResourceFactory jmsResourceFactory;
-    protected JMSMessageProcessor requestMessageProcessor;
-    protected JMSMessageProcessor responseMessageProcessor;
     protected Destination bindingRequestDest;
     protected Destination bindingReplyDest;
     protected RuntimeComponentReference reference;
@@ -65,9 +63,7 @@ public class RRBJMSBindingInvoker implements Invoker, DataExchangeSemantics {
         this.jmsResourceFactory = jmsResourceFactory;
         this.reference = reference;
         this.runtimeWire = reference.getRuntimeWire(jmsBinding);
-        this.requestMessageProcessor = JMSMessageProcessorUtil.getRequestMessageProcessor(jmsBinding);
-        this.responseMessageProcessor = JMSMessageProcessorUtil.getResponseMessageProcessor(jmsBinding);
-        
+       
         try {
             // If this is a callback reference, the destination is determined dynamically based on
             // properties of the inbound service request.  We should not look for or require a
diff --git a/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/transport/TransportReferenceInterceptor.java b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/transport/TransportReferenceInterceptor.java
index 8382e3874f..0628cfbb32 100644
--- a/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/transport/TransportReferenceInterceptor.java
+++ b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/transport/TransportReferenceInterceptor.java
@@ -49,8 +49,6 @@ public class TransportReferenceInterceptor implements Interceptor {
     private RuntimeWire runtimeWire;
     private JMSResourceFactory jmsResourceFactory;
     private JMSBinding jmsBinding;
-    private JMSMessageProcessor requestMessageProcessor;
-    private JMSMessageProcessor responseMessageProcessor;
     private RuntimeComponentReference reference;    
 
     public TransportReferenceInterceptor(JMSBinding jmsBinding, JMSResourceFactory jmsResourceFactory, RuntimeWire runtimeWire) {
@@ -58,8 +56,6 @@ public class TransportReferenceInterceptor implements Interceptor {
         this.jmsBinding = jmsBinding;
         this.runtimeWire = runtimeWire;
         this.jmsResourceFactory = jmsResourceFactory;
-        this.requestMessageProcessor = JMSMessageProcessorUtil.getRequestMessageProcessor(jmsBinding);
-        this.responseMessageProcessor = JMSMessageProcessorUtil.getResponseMessageProcessor(jmsBinding);
         this.reference = (RuntimeComponentReference)runtimeWire.getSource().getContract();        
     }
     
diff --git a/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmsdefault/runtime/WireFormatJMSDefaultProviderFactory.java b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmsdefault/runtime/WireFormatJMSDefaultProviderFactory.java
new file mode 100644
index 0000000000..cde7dfd6aa
--- /dev/null
+++ b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmsdefault/runtime/WireFormatJMSDefaultProviderFactory.java
@@ -0,0 +1,69 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.binding.jms.wireformat.jmsdefault.runtime;
+
+import org.apache.tuscany.sca.assembly.Binding;
+import org.apache.tuscany.sca.binding.jms.impl.JMSBinding;
+import org.apache.tuscany.sca.binding.jms.provider.JMSResourceFactory;
+import org.apache.tuscany.sca.binding.jms.provider.JMSResourceFactoryExtensionPoint;
+import org.apache.tuscany.sca.binding.jms.wireformat.jmsdefault.WireFormatJMSDefault;
+import org.apache.tuscany.sca.core.ExtensionPointRegistry;
+import org.apache.tuscany.sca.provider.WireFormatProvider;
+import org.apache.tuscany.sca.provider.WireFormatProviderFactory;
+import org.apache.tuscany.sca.runtime.RuntimeComponent;
+import org.apache.tuscany.sca.runtime.RuntimeComponentReference;
+import org.apache.tuscany.sca.runtime.RuntimeComponentService;
+
+/**
+ * @version $Rev$ $Date$
+ */
+public class WireFormatJMSDefaultProviderFactory implements WireFormatProviderFactory<WireFormatJMSDefault> {
+    private ExtensionPointRegistry registry;
+    private JMSResourceFactoryExtensionPoint jmsRFEP;
+
+    public WireFormatJMSDefaultProviderFactory(ExtensionPointRegistry registry) {
+        super();
+        this.registry = registry;
+        jmsRFEP = (JMSResourceFactoryExtensionPoint) registry.getExtensionPoint(JMSResourceFactoryExtensionPoint.class);
+    }
+
+    /**
+     */
+    public WireFormatProvider createReferenceWireFormatProvider(RuntimeComponent component, RuntimeComponentReference reference,
+            Binding binding) {
+        return new WireFormatJMSDefaultReferenceProvider(registry, component, reference, binding);
+    }
+
+    /**
+      */
+    public WireFormatProvider createServiceWireFormatProvider(RuntimeComponent component, RuntimeComponentService service, Binding binding) {
+        JMSResourceFactory jmsRF = jmsRFEP.createJMSResourceFactory((JMSBinding) binding);
+        return new WireFormatJMSDefaultServiceProvider(registry, component, service, binding, jmsRF);
+    }
+
+    /**
+     * @see org.apache.tuscany.sca.provider.ProviderFactory#getModelType()
+     */
+    public Class getModelType() {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+}
diff --git a/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmsdefault/runtime/WireFormatJMSDefaultReferenceInterceptor.java b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmsdefault/runtime/WireFormatJMSDefaultReferenceInterceptor.java
new file mode 100644
index 0000000000..f132940b22
--- /dev/null
+++ b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmsdefault/runtime/WireFormatJMSDefaultReferenceInterceptor.java
@@ -0,0 +1,176 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+package org.apache.tuscany.sca.binding.jms.wireformat.jmsdefault.runtime;
+
+import java.util.HashMap;
+import java.util.List;
+import javax.jms.BytesMessage;
+import javax.jms.JMSException;
+import javax.jms.Session;
+import javax.xml.namespace.QName;
+
+import org.apache.axiom.om.OMElement;
+import org.apache.tuscany.sca.binding.jms.context.JMSBindingContext;
+import org.apache.tuscany.sca.binding.jms.impl.JMSBinding;
+import org.apache.tuscany.sca.binding.jms.impl.JMSBindingConstants;
+import org.apache.tuscany.sca.binding.jms.impl.JMSBindingException;
+import org.apache.tuscany.sca.binding.jms.provider.JMSMessageProcessor;
+import org.apache.tuscany.sca.binding.jms.provider.JMSMessageProcessorUtil;
+import org.apache.tuscany.sca.binding.jms.provider.JMSResourceFactory;
+import org.apache.tuscany.sca.binding.jms.provider.DefaultMessageProcessor;
+import org.apache.tuscany.sca.binding.jms.wireformat.jmsdefault.WireFormatJMSDefault;
+import org.apache.tuscany.sca.interfacedef.DataType;
+import org.apache.tuscany.sca.interfacedef.Operation;
+import org.apache.tuscany.sca.interfacedef.util.FaultException;
+import org.apache.tuscany.sca.invocation.Interceptor;
+import org.apache.tuscany.sca.invocation.Invoker;
+import org.apache.tuscany.sca.invocation.Message;
+import org.apache.tuscany.sca.runtime.RuntimeWire;
+
+/**
+ * 
+ * @version $Rev$ $Date$
+ */
+public class WireFormatJMSDefaultReferenceInterceptor implements Interceptor {
+
+    private Invoker next;
+    private RuntimeWire runtimeWire;
+    private JMSResourceFactory jmsResourceFactory;
+    private JMSBinding jmsBinding;
+    private DefaultMessageProcessor requestMessageProcessor;
+    private DefaultMessageProcessor responseMessageProcessor;
+    private HashMap<String, Boolean> inputWrapperMap;
+    private HashMap<String, OMElement> outputWrapperMap;
+
+    public WireFormatJMSDefaultReferenceInterceptor(JMSBinding jmsBinding, JMSResourceFactory jmsResourceFactory, RuntimeWire runtimeWire, HashMap<String, Boolean> inputWrapperMap,
+            HashMap<String, OMElement> outputWrapperMap) {
+        super();
+        this.jmsBinding = jmsBinding;
+        this.runtimeWire = runtimeWire;
+        this.jmsResourceFactory = jmsResourceFactory;
+        // Note the default processor doesn't follow the normal processor pattern 
+        // as it has to handle both text and bytes messages
+        this.requestMessageProcessor = new DefaultMessageProcessor(jmsBinding);
+        this.responseMessageProcessor = new DefaultMessageProcessor(jmsBinding);
+        this.inputWrapperMap = inputWrapperMap;
+        this.outputWrapperMap = outputWrapperMap;
+    }
+
+    public Message invoke(Message msg) {
+
+        if (jmsBinding.getRequestWireFormat() instanceof WireFormatJMSDefault) {
+            msg = invokeRequest(msg);
+        }
+
+        msg = getNext().invoke(msg);
+
+        if (jmsBinding.getResponseWireFormat() instanceof WireFormatJMSDefault) {
+            msg = invokeResponse(msg);
+        }
+
+        return msg;
+    }
+
+    public Message invokeRequest(Message msg) {
+        try {
+            // get the jms context
+            JMSBindingContext context = msg.getBindingContext();
+            Session session = context.getJmsSession();
+
+            javax.jms.Message requestMsg;
+
+            if (((WireFormatJMSDefault) jmsBinding.getRequestWireFormat()).isUseBytesMessage()) {
+                requestMsg = requestMessageProcessor.insertPayloadIntoJMSBytesMessage(session, msg.getBody(), this.inputWrapperMap.get(msg.getOperation().getName()));
+            } else {
+                requestMsg = requestMessageProcessor.insertPayloadIntoJMSTextMessage(session, msg.getBody(), this.inputWrapperMap.get(msg.getOperation().getName()));
+            }
+
+            msg.setBody(requestMsg);
+
+            requestMsg.setJMSReplyTo(context.getReplyToDestination());
+
+            return msg;
+        } catch (JMSException e) {
+            throw new JMSBindingException(e);
+        }
+    }
+
+    public Message invokeResponse(Message msg) {
+        if (msg.getBody() != null) {
+            javax.jms.Message jmsMsg = (javax.jms.Message) msg.getBody();
+
+            Operation op = msg.getOperation();
+            DataType outputDataType = op.getOutputType();
+
+            Class<?> outputType = null;
+            if (outputDataType != null) {
+                outputType = outputDataType.getPhysical();
+            }
+
+            if (outputType != null && javax.jms.Message.class.isAssignableFrom(outputType)) {
+                msg.setBody(jmsMsg);
+            } else {
+
+                OMElement wrapper = null;
+                // if we have a fault no need to wrap the response
+                try {
+                    if (!jmsMsg.getBooleanProperty(JMSBindingConstants.FAULT_PROPERTY)) {
+                        // If there is only one arg we must add a wrapper if the operation is wrapper style
+                        wrapper = this.outputWrapperMap.get(msg.getOperation().getName());
+                    }
+                } catch (JMSException e) {
+                    throw new JMSBindingException(e);
+                }
+
+                Object response;
+                if (jmsMsg instanceof BytesMessage) {
+                    response = responseMessageProcessor.extractPayloadFromJMSBytesMessage(jmsMsg, wrapper);
+                } else {
+                    response = responseMessageProcessor.extractPayloadFromJMSTextMessage(jmsMsg, wrapper);
+                }
+
+                if (response != null) {
+                    msg.setBody(response);
+                    try {
+                        if (jmsMsg.getBooleanProperty(JMSBindingConstants.FAULT_PROPERTY)) {
+                            FaultException e = new FaultException("remote exception", response);
+                            OMElement om = (OMElement) response;
+                            e.setFaultName(new QName(om.getNamespace().getNamespaceURI(), om.getLocalName()));
+                            msg.setFaultBody(e);
+                        }
+                    } catch (JMSException e) {
+                        throw new JMSBindingException(e);
+                    }
+                } else {
+                    msg.setBody(null);
+                }
+            }
+        }
+
+        return msg;
+    }
+
+    public Invoker getNext() {
+        return next;
+    }
+
+    public void setNext(Invoker next) {
+        this.next = next;
+    }
+}
diff --git a/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmsdefault/runtime/WireFormatJMSDefaultReferenceProvider.java b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmsdefault/runtime/WireFormatJMSDefaultReferenceProvider.java
new file mode 100644
index 0000000000..669f033ac6
--- /dev/null
+++ b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmsdefault/runtime/WireFormatJMSDefaultReferenceProvider.java
@@ -0,0 +1,192 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.binding.jms.wireformat.jmsdefault.runtime;
+
+import java.util.HashMap;
+import java.util.List;
+
+import org.apache.axiom.om.OMAbstractFactory;
+import org.apache.axiom.om.OMElement;
+import org.apache.axiom.om.OMFactory;
+import org.apache.axiom.om.OMNamespace;
+import org.apache.tuscany.sca.assembly.Binding;
+import org.apache.tuscany.sca.binding.jms.impl.JMSBinding;
+import org.apache.tuscany.sca.binding.jms.impl.JMSBindingConstants;
+import org.apache.tuscany.sca.binding.jms.wireformat.jmsdefault.WireFormatJMSDefault;
+import org.apache.tuscany.sca.binding.ws.WebServiceBinding;
+import org.apache.tuscany.sca.binding.ws.WebServiceBindingFactory;
+import org.apache.tuscany.sca.binding.ws.wsdlgen.BindingWSDLGenerator;
+import org.apache.tuscany.sca.core.ExtensionPointRegistry;
+import org.apache.tuscany.sca.interfacedef.DataType;
+import org.apache.tuscany.sca.interfacedef.InterfaceContract;
+import org.apache.tuscany.sca.interfacedef.Operation;
+import org.apache.tuscany.sca.interfacedef.util.ElementInfo;
+import org.apache.tuscany.sca.invocation.Interceptor;
+import org.apache.tuscany.sca.invocation.Phase;
+import org.apache.tuscany.sca.provider.WireFormatProvider;
+import org.apache.tuscany.sca.runtime.RuntimeComponent;
+import org.apache.tuscany.sca.runtime.RuntimeComponentReference;
+
+/**
+ * @version $Rev$ $Date$
+ */
+public class WireFormatJMSDefaultReferenceProvider implements WireFormatProvider {
+    private ExtensionPointRegistry registry;
+    private RuntimeComponent component;
+    private RuntimeComponentReference reference;
+    private JMSBinding binding;
+    private InterfaceContract interfaceContract;
+    private HashMap<String, Boolean> inputWrapperMap;
+    private HashMap<String, OMElement> outputWrapperMap;
+
+    public WireFormatJMSDefaultReferenceProvider(ExtensionPointRegistry registry, RuntimeComponent component, RuntimeComponentReference reference, Binding binding) {
+        super();
+        this.registry = registry;
+        this.component = component;
+        this.reference = reference;
+        this.binding = (JMSBinding) binding;
+
+        this.inputWrapperMap = new HashMap<String, Boolean>();
+        this.outputWrapperMap = new HashMap<String, OMElement>();
+
+        // configure the reference based on this wire format
+
+        // currently maintaining the message processor structure which
+        // contains the details of jms message processing so set the message
+        // type here if not set explicitly in SCDL
+        if (this.binding.getRequestWireFormat() instanceof WireFormatJMSDefault){
+            this.binding.setRequestMessageProcessorName(JMSBindingConstants.DEFAULT_MP_CLASSNAME);
+        }
+        if (this.binding.getResponseWireFormat() instanceof WireFormatJMSDefault){
+            this.binding.setResponseMessageProcessorName(JMSBindingConstants.DEFAULT_MP_CLASSNAME);
+        }
+
+        List<Operation> opList = reference.getReference().getInterfaceContract().getInterface().getOperations();
+
+        // Go through each operation and add wrapper info
+        OMFactory factory = OMAbstractFactory.getOMFactory();
+
+        // set the binding interface contract to represent the WSDL for the
+        // xml messages that will be sent
+        // I think we have to check for asIs because the Java2WSDL will blow up when using javax.jms.Message
+        if (reference.getInterfaceContract() != null && !isAsIs()) {
+            WebServiceBindingFactory wsFactory = registry.getExtensionPoint(WebServiceBindingFactory.class);
+            WebServiceBinding wsBinding = wsFactory.createWebServiceBinding();
+            BindingWSDLGenerator.generateWSDL(component, reference, wsBinding, registry, null);
+            interfaceContract = wsBinding.getBindingInterfaceContract();
+            interfaceContract.getInterface().resetDataBinding(OMElement.class.getName());
+
+            List<Operation> wsdlOpList = interfaceContract.getInterface().getOperations();
+
+            for (Operation op : opList) {
+
+                String name = op.getName();
+                Operation matchingWsdlOp = null;
+
+                // find the matching wsdlop
+                for (Operation wsdlOp : wsdlOpList) {
+                    if (name.equals(wsdlOp.getName())) {
+                        matchingWsdlOp = wsdlOp;
+
+                        break;
+                    }
+                }
+
+                // only add operations that need to be wrapped/unwrapped
+                // we need to look at the wsdl interface to determine if the op is wrapped or not
+
+                // TODO - not sure we really support viewing the input/output as separately wrapped 
+                // like the separate code paths imply.  Not sure how many @OneWay tests we have, this might 
+                // not be an issue.  
+
+                if (matchingWsdlOp.isInputWrapperStyle()) {
+                    if (op.getInputType().getLogical().size() == 1) {
+                        this.inputWrapperMap.put(name, true);
+                    } else {
+                        this.inputWrapperMap.put(name, false);
+                    }
+                } else {
+                    this.inputWrapperMap.put(name, false);
+                }
+
+                if (matchingWsdlOp.isOutputWrapperStyle()) {
+                    // we only need to know what the wrapper is on the deserialization
+                    // might need to change this when there input/output wrapper style is different
+                    ElementInfo ei = op.getOutputWrapper().getWrapperElement();
+                    String namespace = ei.getQName().getNamespaceURI();
+                    String opName = ei.getQName().getLocalPart();
+                    OMNamespace ns = factory.createOMNamespace(namespace, "ns2");
+                    OMElement wrapper = factory.createOMElement(opName, ns);
+
+                    this.outputWrapperMap.put(name, wrapper);
+                } 
+            }
+        } else {
+            interfaceContract = reference.getInterfaceContract();
+        }
+
+    }
+
+    protected boolean isAsIs() {
+        InterfaceContract ic = reference.getInterfaceContract();
+        if (ic.getInterface().getOperations().size() != 1) {
+            return false;
+        }
+
+        List<DataType> inputDataTypes = ic.getInterface().getOperations().get(0).getInputType().getLogical();
+
+        if (inputDataTypes.size() != 1) {
+            return false;
+        }
+
+        Class<?> inputType = inputDataTypes.get(0).getPhysical();
+
+        if (javax.jms.Message.class.isAssignableFrom(inputType)) {
+            return true;
+        }
+        return false;
+    }
+
+    public InterfaceContract configureWireFormatInterfaceContract(InterfaceContract interfaceContract){
+        
+        if (this.interfaceContract != null &&
+            !isAsIs()) {
+            if (this.binding.getRequestWireFormat() instanceof WireFormatJMSDefault){
+                // set the request data transformation
+                interfaceContract.getInterface().resetInterfaceInputTypes(this.interfaceContract.getInterface());
+            }
+            if (this.binding.getResponseWireFormat() instanceof WireFormatJMSDefault){
+                // set the response data transformation
+                interfaceContract.getInterface().resetInterfaceOutputTypes(this.interfaceContract.getInterface());
+            }
+        }
+        
+        return interfaceContract;
+    }   
+
+    public Interceptor createInterceptor() {
+        return new WireFormatJMSDefaultReferenceInterceptor((JMSBinding) binding, null, reference.getRuntimeWire(binding), inputWrapperMap, outputWrapperMap);
+    }
+
+    public String getPhase() {
+        return Phase.REFERENCE_BINDING_WIREFORMAT;
+    }
+
+}
diff --git a/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmsdefault/runtime/WireFormatJMSDefaultServiceInterceptor.java b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmsdefault/runtime/WireFormatJMSDefaultServiceInterceptor.java
new file mode 100644
index 0000000000..0753b8e7ef
--- /dev/null
+++ b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmsdefault/runtime/WireFormatJMSDefaultServiceInterceptor.java
@@ -0,0 +1,176 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+package org.apache.tuscany.sca.binding.jms.wireformat.jmsdefault.runtime;
+
+import java.util.HashMap;
+import java.util.List;
+
+import javax.jms.BytesMessage;
+import javax.jms.Session;
+
+import org.apache.axiom.om.OMElement;
+import org.apache.tuscany.sca.binding.jms.context.JMSBindingContext;
+import org.apache.tuscany.sca.binding.jms.impl.JMSBinding;
+import org.apache.tuscany.sca.binding.jms.provider.DefaultMessageProcessor;
+import org.apache.tuscany.sca.binding.jms.provider.JMSMessageProcessor;
+import org.apache.tuscany.sca.binding.jms.provider.JMSMessageProcessorUtil;
+import org.apache.tuscany.sca.binding.jms.provider.JMSResourceFactory;
+import org.apache.tuscany.sca.binding.jms.wireformat.jmsdefault.WireFormatJMSDefault;
+import org.apache.tuscany.sca.interfacedef.DataType;
+import org.apache.tuscany.sca.interfacedef.Operation;
+import org.apache.tuscany.sca.invocation.Interceptor;
+import org.apache.tuscany.sca.invocation.Invoker;
+import org.apache.tuscany.sca.invocation.Message;
+import org.apache.tuscany.sca.runtime.RuntimeWire;
+
+/**
+ * Policy handler to handle PolicySet related to Logging with the QName {http://tuscany.apache.org/xmlns/sca/1.0/impl/java}LoggingPolicy
+ * 
+ * @version $Rev$ $Date$
+ */
+public class WireFormatJMSDefaultServiceInterceptor implements Interceptor {
+    private Invoker next;
+    private RuntimeWire runtimeWire;
+    private JMSResourceFactory jmsResourceFactory;
+    private JMSBinding jmsBinding;
+    private DefaultMessageProcessor requestMessageProcessor;
+    private DefaultMessageProcessor responseMessageProcessor;
+    private HashMap<String,OMElement> inputWrapperMap;
+    private HashMap<String, Boolean> outputWrapperMap;
+
+    public WireFormatJMSDefaultServiceInterceptor(JMSBinding jmsBinding, JMSResourceFactory jmsResourceFactory, RuntimeWire runtimeWire, HashMap<String, OMElement> inputWrapperMap,
+            HashMap<String, Boolean> outputWrapperMap) {
+        super();
+        this.jmsBinding = jmsBinding;
+        this.runtimeWire = runtimeWire;
+        this.jmsResourceFactory = jmsResourceFactory;
+        // Note the default processor doesn't follow the normal processor pattern 
+        // as it has to handle both text and bytes messages
+        this.requestMessageProcessor = new DefaultMessageProcessor(jmsBinding);
+        this.responseMessageProcessor = new DefaultMessageProcessor(jmsBinding);
+        this.inputWrapperMap = inputWrapperMap;
+        this.outputWrapperMap = outputWrapperMap;
+        
+    }
+
+    public Message invoke(Message msg) {
+        
+        if (jmsBinding.getRequestWireFormat() instanceof WireFormatJMSDefault) {
+            msg = invokeRequest(msg);
+        }
+
+        msg = getNext().invoke(msg);
+
+        // if it's oneway return back
+        Operation operation = msg.getOperation();
+        if (operation != null && operation.isNonBlocking()) {
+            return msg;
+        }
+
+        if (jmsBinding.getResponseWireFormat() instanceof WireFormatJMSDefault) {
+            msg = invokeResponse(msg);
+        }
+
+        return msg;
+    }
+
+    public Message invokeRequest(Message msg) {
+        // get the jms context
+        JMSBindingContext context = msg.getBindingContext();
+        javax.jms.Message jmsMsg = context.getJmsMsg();
+
+        Operation op = msg.getOperation();
+        List<DataType> inputDataTypes = op.getInputType().getLogical();
+
+        Class<?> inputType = null;
+        if (inputDataTypes.size() == 1) {
+            inputType = inputDataTypes.get(0).getPhysical();
+        }
+        if (inputType != null && javax.jms.Message.class.isAssignableFrom(inputType)) {
+            msg.setBody(new Object[] { jmsMsg });
+            
+            if (jmsMsg instanceof BytesMessage) {
+                context.setUseBytesForWFJMSDefaultResponse(true);
+            } else {
+                context.setUseBytesForWFJMSDefaultResponse(false);
+            }
+        } else {
+
+            // If there is only one arg we must add a wrapper if the operation is wrapper style
+            OMElement wrapper = this.inputWrapperMap.get(msg.getOperation().getName());
+
+            Object requestPayload;
+            if (jmsMsg instanceof BytesMessage) {
+                requestPayload = responseMessageProcessor.extractPayloadFromJMSBytesMessage(jmsMsg, wrapper);
+                context.setUseBytesForWFJMSDefaultResponse(true);
+            } else {
+                requestPayload = responseMessageProcessor.extractPayloadFromJMSTextMessage(jmsMsg, wrapper );
+                context.setUseBytesForWFJMSDefaultResponse(false);
+            }
+
+            msg.setBody(new Object[] { requestPayload });
+        }
+
+        return msg;
+
+    }
+
+    public Message invokeResponse(Message msg) {
+
+        // get the jms context
+        JMSBindingContext context = msg.getBindingContext();
+        Session session = context.getJmsResponseSession();
+
+        javax.jms.Message responseJMSMsg;
+        
+        boolean respondBytesMessage = context.isUseBytesForWFJMSDefaultResponse();
+        
+        if (msg.isFault()) {
+            if (respondBytesMessage == true) {
+                responseJMSMsg = requestMessageProcessor.createFaultJMSBytesMessage(session, (Throwable) msg.getBody());
+            } else {
+                responseJMSMsg = responseMessageProcessor.createFaultJMSTextMessage(session, (Throwable) msg.getBody());
+            }
+        } else {
+            boolean unwrap = false;
+            
+            if (this.outputWrapperMap.get(msg.getOperation().getName()) != null){
+                unwrap = this.outputWrapperMap.get(msg.getOperation().getName());
+            }
+            
+            if (respondBytesMessage == true) {
+                responseJMSMsg = requestMessageProcessor.insertPayloadIntoJMSBytesMessage(session, msg.getBody(), unwrap);
+            } else {
+                responseJMSMsg = requestMessageProcessor.insertPayloadIntoJMSTextMessage(session, msg.getBody(), unwrap);
+            }
+        }
+
+        msg.setBody(responseJMSMsg);
+
+        return msg;
+    }
+
+    public Invoker getNext() {
+        return next;
+    }
+
+    public void setNext(Invoker next) {
+        this.next = next;
+    }
+}
diff --git a/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmsdefault/runtime/WireFormatJMSDefaultServiceProvider.java b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmsdefault/runtime/WireFormatJMSDefaultServiceProvider.java
new file mode 100644
index 0000000000..8284857b8c
--- /dev/null
+++ b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmsdefault/runtime/WireFormatJMSDefaultServiceProvider.java
@@ -0,0 +1,191 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.binding.jms.wireformat.jmsdefault.runtime;
+
+import java.util.HashMap;
+import java.util.List;
+
+import org.apache.axiom.om.OMAbstractFactory;
+import org.apache.axiom.om.OMElement;
+import org.apache.axiom.om.OMFactory;
+import org.apache.axiom.om.OMNamespace;
+import org.apache.tuscany.sca.assembly.Binding;
+import org.apache.tuscany.sca.binding.jms.impl.JMSBinding;
+import org.apache.tuscany.sca.binding.jms.impl.JMSBindingConstants;
+import org.apache.tuscany.sca.binding.jms.provider.JMSResourceFactory;
+import org.apache.tuscany.sca.binding.jms.wireformat.jmsdefault.WireFormatJMSDefault;
+import org.apache.tuscany.sca.binding.ws.WebServiceBinding;
+import org.apache.tuscany.sca.binding.ws.WebServiceBindingFactory;
+import org.apache.tuscany.sca.binding.ws.wsdlgen.BindingWSDLGenerator;
+import org.apache.tuscany.sca.core.ExtensionPointRegistry;
+import org.apache.tuscany.sca.interfacedef.DataType;
+import org.apache.tuscany.sca.interfacedef.InterfaceContract;
+import org.apache.tuscany.sca.interfacedef.Operation;
+import org.apache.tuscany.sca.interfacedef.util.ElementInfo;
+import org.apache.tuscany.sca.invocation.Interceptor;
+import org.apache.tuscany.sca.invocation.Phase;
+import org.apache.tuscany.sca.provider.WireFormatProvider;
+import org.apache.tuscany.sca.runtime.RuntimeComponent;
+import org.apache.tuscany.sca.runtime.RuntimeComponentService;
+
+/**
+ * @version $Rev$ $Date$
+ */
+public class WireFormatJMSDefaultServiceProvider implements WireFormatProvider {
+    private ExtensionPointRegistry registry;
+    private RuntimeComponent component;
+    private RuntimeComponentService service;
+    private JMSBinding binding;
+    private JMSResourceFactory jmsResourceFactory;
+    private InterfaceContract interfaceContract;
+    private HashMap<String, OMElement> inputWrapperMap;
+    private HashMap<String, Boolean> outputWrapperMap;
+
+    public WireFormatJMSDefaultServiceProvider(ExtensionPointRegistry registry, RuntimeComponent component, RuntimeComponentService service, Binding binding, JMSResourceFactory jmsResourceFactory) {
+        super();
+        this.component = component;
+        this.service = service;
+        this.binding = (JMSBinding) binding;
+        this.jmsResourceFactory = jmsResourceFactory;
+
+        this.inputWrapperMap = new HashMap<String, OMElement>();
+        this.outputWrapperMap = new HashMap<String, Boolean>();
+
+        // configure the service based on this wire format
+
+        // currently maintaining the message processor structure which
+        // contains the details of jms message processing so set the message
+        // type here if not set explicitly in SCDL
+        if (this.binding.getRequestWireFormat() instanceof WireFormatJMSDefault){
+            this.binding.setRequestMessageProcessorName(JMSBindingConstants.DEFAULT_MP_CLASSNAME);
+        }
+        if (this.binding.getResponseWireFormat() instanceof WireFormatJMSDefault){
+            this.binding.setResponseMessageProcessorName(JMSBindingConstants.DEFAULT_MP_CLASSNAME);
+        }
+
+        List<Operation> opList = service.getService().getInterfaceContract().getInterface().getOperations();
+
+        // Go through each operation and add wrapper info
+        OMFactory factory = OMAbstractFactory.getOMFactory();
+
+        // set the binding interface contract to represent the WSDL for the
+        // xml messages that will be sent
+
+        // I think we have to check for asIs because the Java2WSDL will blow up when using javax.jms.Message
+        if (service.getInterfaceContract() != null && !isAsIs()) {
+            WebServiceBindingFactory wsFactory = registry.getExtensionPoint(WebServiceBindingFactory.class);
+            WebServiceBinding wsBinding = wsFactory.createWebServiceBinding();
+            BindingWSDLGenerator.generateWSDL(component, service, wsBinding, registry, null);
+            interfaceContract = wsBinding.getBindingInterfaceContract();
+            interfaceContract.getInterface().resetDataBinding(OMElement.class.getName());
+
+            List<Operation> wsdlOpList = interfaceContract.getInterface().getOperations();
+
+            for (Operation op : opList) {
+                String name = op.getName();
+
+                Operation matchingWsdlOp = null;
+
+                // find the matching wsdlop
+                for (Operation wsdlOp : wsdlOpList) {
+                    if (name.equals(wsdlOp.getName())) {
+                        matchingWsdlOp = wsdlOp;
+                        break;
+                    }
+                }
+
+                // only add operations that need to be wrapped/unwrapped
+
+                // TODO - not sure we really support viewing the input/output as separately wrapped 
+                // like the separate code paths imply.  Not sure how many @OneWay tests we have, this might 
+                // not be an issue.  
+                if (matchingWsdlOp.isInputWrapperStyle()) {
+                    if (op.getInputType().getLogical().size() == 1) {
+                        // we only need to know what the wrapper is on the deserialization
+                        // might need to change this when the input/output wrapper style is different
+                        ElementInfo ei = op.getInputWrapper().getWrapperElement();
+                        String namespace = ei.getQName().getNamespaceURI();
+                        String opName = ei.getQName().getLocalPart();
+                        OMNamespace ns = factory.createOMNamespace(namespace, "ns1");
+                        OMElement wrapper = factory.createOMElement(opName, ns);
+                        this.inputWrapperMap.put(name, wrapper);
+                    }
+                }
+
+                if (matchingWsdlOp.isOutputWrapperStyle()) {
+                    this.outputWrapperMap.put(name, true);
+                } else {
+                    this.outputWrapperMap.put(name, false);
+                }
+
+            }
+
+        } else {            
+            interfaceContract = service.getInterfaceContract();
+        }
+    }
+
+    protected boolean isAsIs() {
+        InterfaceContract ic = service.getInterfaceContract();
+        if (ic.getInterface().getOperations().size() != 1) {
+            return false;
+        }
+
+        List<DataType> inputDataTypes = ic.getInterface().getOperations().get(0).getInputType().getLogical();
+
+        if (inputDataTypes.size() != 1) {
+            return false;
+        }
+
+        Class<?> inputType = inputDataTypes.get(0).getPhysical();
+
+        if (javax.jms.Message.class.isAssignableFrom(inputType)) {
+            return true;
+        }
+        return false;
+    }
+
+    public InterfaceContract configureWireFormatInterfaceContract(InterfaceContract interfaceContract){
+        
+        if (this.interfaceContract != null &&
+            !isAsIs()) {
+            if (this.binding.getRequestWireFormat() instanceof WireFormatJMSDefault){
+                // set the request data transformation
+                interfaceContract.getInterface().resetInterfaceInputTypes(this.interfaceContract.getInterface());
+            }
+            if (this.binding.getResponseWireFormat() instanceof WireFormatJMSDefault){
+                // set the response data transformation
+                interfaceContract.getInterface().resetInterfaceOutputTypes(this.interfaceContract.getInterface());
+            }
+        }
+        
+        return interfaceContract;
+    }    
+
+
+    public Interceptor createInterceptor() {
+        return new WireFormatJMSDefaultServiceInterceptor(binding, jmsResourceFactory, service.getRuntimeWire(binding), this.inputWrapperMap, this.outputWrapperMap);
+    }
+
+    public String getPhase() {
+        return Phase.SERVICE_BINDING_WIREFORMAT;
+    }
+
+}
diff --git a/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmstext/runtime/WireFormatJMSTextReferenceProvider.java b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmstext/runtime/WireFormatJMSTextReferenceProvider.java
index 24d963010c..5a8af69c64 100644
--- a/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmstext/runtime/WireFormatJMSTextReferenceProvider.java
+++ b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmstext/runtime/WireFormatJMSTextReferenceProvider.java
@@ -57,10 +57,17 @@ public class WireFormatJMSTextReferenceProvider implements WireFormatProvider {
         // currently maintaining the message processor structure which 
         // contains the details of jms message processing however override 
         // any message processors specified in the SCDL in this case
-        if (this.binding.getRequestWireFormat() instanceof WireFormatJMSText){
+        
+        // this wire format doubles up as the execution logic for user defined
+        // message processors so check the processor name is still set to default 
+        // before overwriting 
+
+        if ((this.binding.getRequestWireFormat() instanceof WireFormatJMSText) &&
+            (this.binding.getRequestMessageProcessorName().equals(JMSBindingConstants.DEFAULT_MP_CLASSNAME))){
             this.binding.setRequestMessageProcessorName(JMSBindingConstants.TEXT_MP_CLASSNAME);
         }
-        if (this.binding.getResponseWireFormat() instanceof WireFormatJMSText){
+        if ((this.binding.getResponseWireFormat() instanceof WireFormatJMSText) &&
+            (this.binding.getResponseMessageProcessorName().equals(JMSBindingConstants.DEFAULT_MP_CLASSNAME))){
             this.binding.setResponseMessageProcessorName(JMSBindingConstants.TEXT_MP_CLASSNAME);
         } 
 
diff --git a/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmstext/runtime/WireFormatJMSTextServiceProvider.java b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmstext/runtime/WireFormatJMSTextServiceProvider.java
index 3f759ff73b..76808fc5dd 100644
--- a/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmstext/runtime/WireFormatJMSTextServiceProvider.java
+++ b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmstext/runtime/WireFormatJMSTextServiceProvider.java
@@ -56,12 +56,19 @@ public class WireFormatJMSTextServiceProvider implements WireFormatProvider {
         // currently maintaining the message processor structure which 
         // contains the details of jms message processing however override 
         // any message processors specified in the SCDL in this case
-        if (this.binding.getRequestWireFormat() instanceof WireFormatJMSText){
+ 
+        // this wire format doubles up as the execution logic for user defined
+        // message processors so check the processor name is still set to default 
+        // before overwriting
+        
+        if ((this.binding.getRequestWireFormat() instanceof WireFormatJMSText) &&
+            (this.binding.getRequestMessageProcessorName().equals(JMSBindingConstants.DEFAULT_MP_CLASSNAME))){
             this.binding.setRequestMessageProcessorName(JMSBindingConstants.TEXT_MP_CLASSNAME);
         }
-        if (this.binding.getResponseWireFormat() instanceof WireFormatJMSText){
+        if ((this.binding.getResponseWireFormat() instanceof WireFormatJMSText) &&
+            (this.binding.getResponseMessageProcessorName().equals(JMSBindingConstants.DEFAULT_MP_CLASSNAME))){
             this.binding.setResponseMessageProcessorName(JMSBindingConstants.TEXT_MP_CLASSNAME);
-        }       
+        }   
         
         // just point to the reference interface contract so no 
         // databinding transformation takes place
diff --git a/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmstextxml/runtime/WireFormatJMSTextXMLReferenceProvider.java b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmstextxml/runtime/WireFormatJMSTextXMLReferenceProvider.java
index 1365cf951e..a52ee3df18 100644
--- a/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmstextxml/runtime/WireFormatJMSTextXMLReferenceProvider.java
+++ b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmstextxml/runtime/WireFormatJMSTextXMLReferenceProvider.java
@@ -60,17 +60,14 @@ public class WireFormatJMSTextXMLReferenceProvider implements WireFormatProvider
         // currently maintaining the message processor structure which 
         // contains the details of jms message processing so set the message
         // type here if not set explicitly in SCDL
-        //
-        // defaults to JMSBindingConstants.XML_MP_CLASSNAME so no need to set it 
-/*        
+
         if (this.binding.getRequestWireFormat() instanceof WireFormatJMSTextXML){
             this.binding.setRequestMessageProcessorName(JMSBindingConstants.XML_MP_CLASSNAME);
         }
         if (this.binding.getResponseWireFormat() instanceof WireFormatJMSTextXML){
             this.binding.setResponseMessageProcessorName(JMSBindingConstants.XML_MP_CLASSNAME);
         }
-*/        
-         
+
         // create a local interface contract that is configured specifically to 
         // deal with the data format that this wire format is expecting to sent to 
         // and receive from the databinding interceptor. The request/response parts of 
diff --git a/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmstextxml/runtime/WireFormatJMSTextXMLServiceInterceptor.java b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmstextxml/runtime/WireFormatJMSTextXMLServiceInterceptor.java
index 9236055542..e0a5c86202 100644
--- a/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmstextxml/runtime/WireFormatJMSTextXMLServiceInterceptor.java
+++ b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmstextxml/runtime/WireFormatJMSTextXMLServiceInterceptor.java
@@ -80,14 +80,10 @@ public class WireFormatJMSTextXMLServiceInterceptor implements Interceptor {
         // get the jms context
         JMSBindingContext context = msg.getBindingContext();
         javax.jms.Message jmsMsg = context.getJmsMsg();
-        
-        if ("onMessage".equals(msg.getOperation().getName())) {
-            msg.setBody(new Object[]{jmsMsg});
-        } else {
-            Object requestPayload = requestMessageProcessor.extractPayloadFromJMSMessage(jmsMsg);
-            msg.setBody(new Object[]{requestPayload});
-        }
-                
+
+        Object requestPayload = requestMessageProcessor.extractPayloadFromJMSMessage(jmsMsg);
+        msg.setBody(new Object[] { requestPayload });
+
         return msg;
     }
     
diff --git a/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmstextxml/runtime/WireFormatJMSTextXMLServiceProvider.java b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmstextxml/runtime/WireFormatJMSTextXMLServiceProvider.java
index bccbb669b2..7e48dc76a0 100644
--- a/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmstextxml/runtime/WireFormatJMSTextXMLServiceProvider.java
+++ b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/java/org/apache/tuscany/sca/binding/jms/wireformat/jmstextxml/runtime/WireFormatJMSTextXMLServiceProvider.java
@@ -63,15 +63,12 @@ public class WireFormatJMSTextXMLServiceProvider implements WireFormatProvider {
         // currently maintaining the message processor structure which 
         // contains the details of jms message processing so set the message
         // type here if not set explicitly in SCDL
-        // defaults to JMSBindingConstants.XML_MP_CLASSNAME so no need to set it 
-/*        
         if (this.binding.getRequestWireFormat() instanceof WireFormatJMSTextXML){
             this.binding.setRequestMessageProcessorName(JMSBindingConstants.XML_MP_CLASSNAME);
         }
         if (this.binding.getResponseWireFormat() instanceof WireFormatJMSTextXML){
             this.binding.setResponseMessageProcessorName(JMSBindingConstants.XML_MP_CLASSNAME);
         }
-*/
         
         // create a local interface contract that is configured specifically to 
         // deal with the data format that this wire format is expecting to sent to 
@@ -85,18 +82,9 @@ public class WireFormatJMSTextXMLServiceProvider implements WireFormatProvider {
         interfaceContract.getInterface().resetDataBinding(OMElement.class.getName());       
     }
     
-    protected boolean isOnMessage() {
-        InterfaceContract ic = service.getInterfaceContract();
-        if (ic.getInterface().getOperations().size() != 1) {
-            return false;
-        }
-        return "onMessage".equals(ic.getInterface().getOperations().get(0).getName());
-    }
-    
     public InterfaceContract configureWireFormatInterfaceContract(InterfaceContract interfaceContract){
         
-        if (this.interfaceContract != null &&
-            !isOnMessage()) {
+        if (this.interfaceContract != null) {
             if (this.binding.getRequestWireFormat() instanceof WireFormatJMSTextXML){
                 // set the request data transformation
                 interfaceContract.getInterface().resetInterfaceInputTypes(this.interfaceContract.getInterface());
diff --git a/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/resources/META-INF/services/org.apache.tuscany.sca.provider.WireFormatProviderFactory b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/resources/META-INF/services/org.apache.tuscany.sca.provider.WireFormatProviderFactory
index 02ae135f16..c81b4514b4 100644
--- a/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/resources/META-INF/services/org.apache.tuscany.sca.provider.WireFormatProviderFactory
+++ b/branches/sca-java-1.x/modules/binding-jms-runtime/src/main/resources/META-INF/services/org.apache.tuscany.sca.provider.WireFormatProviderFactory
@@ -16,6 +16,7 @@
 # under the License. 

 

 # Implementation class for the binding extension

+org.apache.tuscany.sca.binding.jms.wireformat.jmsdefault.runtime.WireFormatJMSDefaultProviderFactory;model=org.apache.tuscany.sca.binding.jms.wireformat.jmsdefault.WireFormatJMSDefault

 org.apache.tuscany.sca.binding.jms.wireformat.jmstextxml.runtime.WireFormatJMSTextXMLProviderFactory;model=org.apache.tuscany.sca.binding.jms.wireformat.jmstextxml.WireFormatJMSTextXML

 org.apache.tuscany.sca.binding.jms.wireformat.jmsbytes.runtime.WireFormatJMSBytesProviderFactory;model=org.apache.tuscany.sca.binding.jms.wireformat.jmsbytes.WireFormatJMSBytes

 org.apache.tuscany.sca.binding.jms.wireformat.jmstext.runtime.WireFormatJMSTextProviderFactory;model=org.apache.tuscany.sca.binding.jms.wireformat.jmstext.WireFormatJMSText