BaseMessageContext.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.apache.axis2.jaxws.handler;

import org.apache.axis2.jaxws.core.MessageContext;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.util.Collection;
import java.util.Map;
import java.util.Set;

/**
 * BaseMessageContext is the base class for the two handler message contexts:
 * SoapMessageContext and LogicalMessageContext.  It delegates everything up to
 * the MEPContext, which itself delegates to the requestMC or responseMC, as
 * appropriate.
 * 
 */
public class BaseMessageContext implements javax.xml.ws.handler.MessageContext {
    private static final Log log = LogFactory.getLog(BaseMessageContext.class);

    protected MessageContext messageCtx;
    
    /**
     * @param messageCtx
     */
    protected BaseMessageContext(MessageContext messageCtx) {
        this.messageCtx = messageCtx;
        
        // Install an an AttachmentsAdapter between the 
        // jaxws attachment standard properties and the
        // MessageContext Attachments implementation.
        AttachmentsAdapter.install(messageCtx);
        TransportHeadersAdapter.install(messageCtx);
        SOAPHeadersAdapter.install(messageCtx);
    }

    /* (non-Javadoc)
     * @see java.util.Map#clear()
     */
    public void clear() {
        messageCtx.getMEPContext().clear();
    }

    /* (non-Javadoc)
     * @see java.util.Map#containsKey(java.lang.Object)
     */
    public boolean containsKey(Object key) {
        return messageCtx.getMEPContext().containsKey(key);
    }

    /* (non-Javadoc)
     * @see java.util.Map#containsValue(java.lang.Object)
     */
    public boolean containsValue(Object value) {
        return messageCtx.getMEPContext().containsValue(value);
    }

    /* (non-Javadoc)
     * @see java.util.Map#entrySet()
     */
    public Set<java.util.Map.Entry<String, Object>> entrySet() {
        return messageCtx.getMEPContext().entrySet();
    }

    /* (non-Javadoc)
     * @see java.util.Map#get(java.lang.Object)
     */
    public Object get(Object key) {
        // There are some properties that, in some cases, should not span the message exchange;
        // that is, they should come from only the current message context.  For others properties,
        // they should span the message exchange, meaning a property could be set on the request
        // and it will also be available on the response.  [JAXWS 2.0, Sec 9.4.1.1, pp. 110-113]
        Object returnValue = null;
        if (shouldPropertySpanMEP(key)) {
            returnValue = messageCtx.getMEPContext().get(key);
        } else {
            returnValue = messageCtx.getProperty((String) key);
        }

        // For the HTTP_REQUEST_HEADERS and HTTP_RESPONSE_HEADERS, the CTS tests want a null returned 
        // if there are no headers.  Since we always put an instance of TransportHeadersAdapter,
        // which contains the headers, on the message context, return a null if it is empty.
        if (returnValue != null && (returnValue instanceof TransportHeadersAdapter)) {
            TransportHeadersAdapter adapter = (TransportHeadersAdapter) returnValue;
            if (adapter.isEmpty()) {
                return null;
            }
        }
        return returnValue;
    }

    private boolean shouldPropertySpanMEP(Object key) {
        boolean shouldSpan = true;
        String keyString = (String) key;

        // The CTS tests require that HTTP_REQUEST_HEADERS span the request and response contexts
        // on the service-provider, but do NOT span the request and response context on the 
        // service-requester.  So, for an INBOUND flow, do not allow HTTP_REQUEST_HEADERS to
        // span the request and response contexts.  The result is that the service-requester
        // inbound handler will not see the request headers while processing a response.
        Boolean outbound = (Boolean) messageCtx.getMEPContext().get(MESSAGE_OUTBOUND_PROPERTY);
        if (outbound != null && !outbound)
            if (javax.xml.ws.handler.MessageContext.HTTP_REQUEST_HEADERS.equals(keyString)) {
            shouldSpan = false;
        }
        return shouldSpan;
    }

    /* (non-Javadoc)
     * @see java.util.Map#isEmpty()
     */
    public boolean isEmpty() {
        return messageCtx.getMEPContext().isEmpty();
    }

    /* (non-Javadoc)
     * @see java.util.Map#keySet()
     */
    public Set<String> keySet() {
        return messageCtx.getMEPContext().keySet();
    }

    /* (non-Javadoc)
     * @see java.util.Map#put(java.lang.Object, java.lang.Object)
     */
    public Object put(String key, Object value) {
        return messageCtx.getMEPContext().put(key, value);
    }

    /* (non-Javadoc)
     * @see java.util.Map#putAll(java.util.Map)
     */
    public void putAll(Map<? extends String, ? extends Object> t) {
        messageCtx.getMEPContext().putAll(t);
    }

    /* (non-Javadoc)
     * @see java.util.Map#remove(java.lang.Object)
     */
    public Object remove(Object key) {
        return messageCtx.getMEPContext().remove(key);
    }

    /* (non-Javadoc)
     * @see java.util.Map#size()
     */
    public int size() {
        return messageCtx.getMEPContext().size();
    }

    /* (non-Javadoc)
     * @see java.util.Map#values()
     */
    public Collection<Object> values() {
        return messageCtx.getMEPContext().values();
    }

    /* (non-Javadoc)
     * @see javax.xml.ws.handler.MessageContext#getScope(java.lang.String)
     */
    public Scope getScope(String s) {
        return messageCtx.getMEPContext().getScope(s);
    }

    /* (non-Javadoc)
     * @see javax.xml.ws.handler.MessageContext#setScope(java.lang.String, javax.xml.ws.handler.MessageContext.Scope)
     */
    public void setScope(String s, Scope scope) {
        messageCtx.getMEPContext().setScope(s, scope);
    }

}