/*
* Copyright 2001-2004 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.axis ;
import org.apache.axis.attachments.Attachments;
import org.apache.axis.client.AxisClient;
import org.apache.axis.components.logger.LogFactory;
import org.apache.axis.description.OperationDesc;
import org.apache.axis.description.ServiceDesc;
import org.apache.axis.encoding.TypeMapping;
import org.apache.axis.encoding.TypeMappingRegistry;
import org.apache.axis.constants.Style;
import org.apache.axis.constants.Use;
import org.apache.axis.handlers.soap.SOAPService;
import org.apache.axis.schema.SchemaVersion;
import org.apache.axis.session.Session;
import org.apache.axis.soap.SOAPConstants;
import org.apache.axis.utils.JavaUtils;
import org.apache.axis.utils.LockableHashtable;
import org.apache.axis.utils.Messages;
import org.apache.commons.logging.Log;
import javax.xml.namespace.QName;
import javax.xml.rpc.Call;
import javax.xml.rpc.handler.soap.SOAPMessageContext;
import java.io.File;
import java.util.ArrayList;
import java.util.Hashtable;
// fixme: fields are declared throughout this class, some at the top, and some
// near to where they are used. We should move all field declarations into a
// single block - it makes it easier to see what is decalred in this class and
// what is inherited. It also makes it easier to find them.
/**
* A MessageContext is the Axis implementation of the javax
* SOAPMessageContext class, and is core to message processing
* in handlers and other parts of the system.
*
* This class also contains constants for accessing some
* well-known properties. Using a hierarchical namespace is
* strongly suggested in order to lower the chance for
* conflicts.
*
* (These constants should be viewed as an explicit list of well
* known and widely used context keys, there's nothing wrong
* with directly using the key strings. This is the reason for
* the hierarchical constant namespace.
*
* Actually I think we might just list the keys in the docs and
* provide no such constants since they create yet another
* namespace, but we'd have no compile-time checks then.
*
* Whaddya think? - todo by Jacek)
*
*
* @author Doug Davis (dug@us.ibm.com)
* @author Jacek Kopecky (jacek@idoox.com)
*/
public class MessageContext implements SOAPMessageContext {
/** The <code>Log</code> used for logging all messages. */
protected static Log log =
LogFactory.getLog(MessageContext.class.getName());
/**
* The request message. If we're on the client, this is the outgoing
* message heading to the server. If we're on the server, this is the
* incoming message we've received from the client.
*/
private Message requestMessage;
/**
* The response message. If we're on the server, this is the outgoing
* message heading back to the client. If we're on the client, this is the
* incoming message we've received from the server.
*/
private Message responseMessage;
/**
* That unique key/name that the next router/dispatch handler should use
* to determine what to do next.
*/
private String targetService;
/**
* The name of the Transport which this message was received on (or is
* headed to, for the client).
*/
private String transportName;
/**
* The default <code>ClassLoader</code> that this service should use.
*/
private ClassLoader classLoader;
/**
* The AxisEngine which this context is involved with.
*/
private AxisEngine axisEngine;
/**
* A Session associated with this request.
*/
private Session session;
/**
* Should we track session state, or not?
* default is not.
* Could potentially refactor this so that
* maintainSession iff session != null...
*/
private boolean maintainSession = false;
// fixme: ambiguity here due to lac of docs - havePassedPivot vs
// request/response, vs sending/processing & recieving/responding
// I may have just missed the key bit of text
/**
* Are we doing request stuff, or response stuff? True if processing
* response (I think).
*/
private boolean havePassedPivot = false;
/**
* Maximum amount of time to wait on a request, in milliseconds.
*/
private int timeout = Constants.DEFAULT_MESSAGE_TIMEOUT;
/**
* An indication of whether we require "high fidelity" recording of
* deserialized messages for this interaction. Defaults to true for
* now, and can be set to false, usually at service-dispatch time.
*/
private boolean highFidelity = true;
/**
* Storage for an arbitrary bag of properties associated with this
* MessageContext.
*/
private LockableHashtable bag = new LockableHashtable();
/*
* These variables are logically part of the bag, but are separated
* because they are used often and the Hashtable is more expensive.
*
* fixme: this may be fixed by moving to a plain Map impl like HashMap.
* Alternatively, we could hide all this magic behind a custom Map impl -
* is synchronization on the map needed? these properties aren't
* synchronized so I'm guessing not.
*/
private String username = null;
private String password = null;
private String encodingStyle = Use.ENCODED.getEncoding();
private boolean useSOAPAction = false;
private String SOAPActionURI = null;
/**
* SOAP Actor roles.
*/
private String[] roles;
/** Our SOAP namespaces and such. */
private SOAPConstants soapConstants = Constants.DEFAULT_SOAP_VERSION;
/** Schema version information - defaults to 2001. */
private SchemaVersion schemaVersion = SchemaVersion.SCHEMA_2001;
/** Our current operation. */
private OperationDesc currentOperation = null;
/**
* The current operation.
*
* @return the current operation; may be <code>null</code>
*/
public OperationDesc getOperation()
{
return currentOperation;
}
/**
* Set the current operation.
*
* @param operation the <code>Operation</code> this context is executing
*/
public void setOperation(OperationDesc operation)
{
currentOperation = operation;
}
/**
* Returns a list of operation descriptors that could may
* possibly match a body containing an element of the given QName.
* For non-DOCUMENT, the list of operation descriptors that match
* the name is returned. For DOCUMENT, all the operations that have
* qname as a parameter are returned
*
* @param qname of the first element in the body
* @return list of operation descriptions
* @throws AxisFault if the operation names could not be looked up
*/
public OperationDesc [] getPossibleOperationsByQName(QName qname) throws AxisFault
{
if (currentOperation != null) {
return new OperationDesc [] { currentOperation };
}
OperationDesc [] possibleOperations = null;
if (serviceHandler == null) {
try {
if (log.isDebugEnabled()) {
log.debug(Messages.getMessage("dispatching00",
qname.getNamespaceURI()));
}
// Try looking this QName up in our mapping table...
setService(axisEngine.getConfig().
getServiceByNamespaceURI(qname.getNamespaceURI()));
} catch (ConfigurationException e) {
// Didn't find one...
}
}
if (serviceHandler != null) {
ServiceDesc desc = serviceHandler.getInitializedServiceDesc(this);
if (desc != null) {
if (desc.getStyle() != Style.DOCUMENT) {
possibleOperations = desc.getOperationsByQName(qname);
} else {
// DOCUMENT Style
// Get all of the operations that have qname as
// a possible parameter QName
ArrayList allOperations = desc.getOperations();
ArrayList foundOperations = new ArrayList();
for (int i=0; i < allOperations.size(); i++ ) {
OperationDesc tryOp =
(OperationDesc) allOperations.get(i);
if (tryOp.getParamByQName(qname) != null) {
foundOperations.add(tryOp);
}
}
if (foundOperations.size() > 0) {
possibleOperations = (OperationDesc[])
JavaUtils.convert(foundOperations,
OperationDesc[].class);
}
}
}
}
return possibleOperations;
}
/**
* get the first possible operation that could match a
* body containing an element of the given QName. Sets the currentOperation
* field in the process; if that field is already set then its value
* is returned instead
* @param qname name of the message body
* @return an operation or null
* @throws AxisFault
*/
public OperationDesc getOperationByQName(QName qname) throws AxisFault
{
if (currentOperation == null) {
OperationDesc [] possibleOperations = getPossibleOperationsByQName(qname);
if (possibleOperations != null && possibleOperations.length > 0) {
currentOperation = possibleOperations[0];
}
}
return currentOperation;
}
/**
* Get the active message context.
*
* @return the current active message context
*/
public static MessageContext getCurrentContext() {
return AxisEngine.getCurrentMessageContext();
}
/**
* Temporary directory to store attachments.
*/
protected static String systemTempDir= null;
/**
* set the temp dir
* TODO: move this piece of code out of this class and into a utilities
* class.
*/
static {
try {
//get the temp dir from the engine
systemTempDir=AxisProperties.getProperty(AxisEngine.ENV_ATTACHMENT_DIR);
} catch(Throwable t) {
systemTempDir= null;
}
if(systemTempDir== null) {
try {
//or create and delete a file in the temp dir to make
//sure we have write access to it.
File tf= File.createTempFile("Axis", ".tmp");
File dir= tf.getParentFile();
if (tf.exists()) {
tf.delete();
}
if (dir != null) {
systemTempDir= dir.getCanonicalPath();
}
} catch(Throwable t) {
log.debug("Unable to find a temp dir with write access");
systemTempDir= null;
}
}
}
/**
* Create a message context.
* @param engine the controlling axis engine. Null is actually accepted here,
* though passing a null engine in is strongly discouraged as many of the methods
* assume that it is in fact defined.
*/
public MessageContext(AxisEngine engine) {
this.axisEngine = engine;
if(null != engine){
java.util.Hashtable opts= engine.getOptions();
String attachmentsdir= null;
if(null!=opts) {
attachmentsdir= (String) opts.get(AxisEngine.PROP_ATTACHMENT_DIR);
}
if(null == attachmentsdir) {
attachmentsdir= systemTempDir;
}
if(attachmentsdir != null){
setProperty(ATTACHMENTS_DIR, attachmentsdir);
}
// If SOAP 1.2 has been specified as the default for the engine,
// switch the constants over.
String defaultSOAPVersion = (String)engine.getOption(
AxisEngine.PROP_SOAP_VERSION);
if (defaultSOAPVersion != null && "1.2".equals(defaultSOAPVersion)) {
setSOAPConstants(SOAPConstants.SOAP12_CONSTANTS);
}
String singleSOAPVersion = (String)engine.getOption(
AxisEngine.PROP_SOAP_ALLOWED_VERSION);
if (singleSOAPVersion != null) {
if ("1.2".equals(singleSOAPVersion)) {
setProperty(Constants.MC_SINGLE_SOAP_VERSION,
SOAPConstants.SOAP12_CONSTANTS);
} else if ("1.1".equals(singleSOAPVersion)) {
setProperty(Constants.MC_SINGLE_SOAP_VERSION,
SOAPConstants.SOAP11_CONSTANTS);
}
}
}
}
/**
* during finalization, the dispose() method is called.
* @see #dispose()
*/
protected void finalize() {
dispose();
}
/**
* Mappings of QNames to serializers/deserializers (and therfore
* to Java types).
*/
private TypeMappingRegistry mappingRegistry = null;
/**
* Replace the engine's type mapping registry with a local one. This will
* have no effect on any type mappings obtained before this call.
*
* @param reg the new <code>TypeMappingRegistry</code>
*/
public void setTypeMappingRegistry(TypeMappingRegistry reg) {
mappingRegistry = reg;
}
/**
* Get the currently in-scope type mapping registry.
*
* By default, will return a reference to the AxisEngine's TMR until
* someone sets our local one (usually as a result of setting the
* serviceHandler).
*
* @return the type mapping registry to use for this request.
*/
public TypeMappingRegistry getTypeMappingRegistry() {
if (mappingRegistry == null) {
return axisEngine.getTypeMappingRegistry();
}
return mappingRegistry;
}
/**
* Return the type mapping currently in scope for our encoding style.
*
* @return the type mapping
*/
public TypeMapping getTypeMapping()
{
return (TypeMapping)getTypeMappingRegistry().
getTypeMapping(encodingStyle);
}
/**
* The name of the transport for this context.
*
* @return the transport name
*/
public String getTransportName()
{
return transportName;
}
// fixme: the transport names should be a type-safe e-num, or the range
// of legal values should be specified in the documentation and validated
// in the method (raising IllegalArgumentException)
/**
* Set the transport name for this context.
*
* @param transportName the name of the transport
*/
public void setTransportName(String transportName)
{
this.transportName = transportName;
}
/**
* Get the <code>SOAPConstants</code> used by this message context.
*
* @return the soap constants
*/
public SOAPConstants getSOAPConstants() {
return soapConstants;
}
/**
* Set the <code>SOAPConstants</code> used by this message context.
* This may also affect the encoding style.
*
* @param soapConstants the new soap constants to use
*/
public void setSOAPConstants(SOAPConstants soapConstants) {
// when changing SOAP versions, remember to keep the encodingURI
// in synch.
if (this.soapConstants.getEncodingURI().equals(encodingStyle)) {
encodingStyle = soapConstants.getEncodingURI();
}
this.soapConstants = soapConstants;
}
/**
* Get the XML schema version information.
*
* @return the <code>SchemaVersion</code> in use
*/
public SchemaVersion getSchemaVersion() {
return schemaVersion;
}
/**
* Set the XML schema version this message context will use.
*
* @param schemaVersion the new <code>SchemaVersion</code>
*/
public void setSchemaVersion(SchemaVersion schemaVersion) {
this.schemaVersion = schemaVersion;
}
/**
* Get the current session.
*
* @return the <code>Session</code> this message context is within
*/
public Session getSession()
{
return session;
}
/**
* Set the current session.
*
* @param session the new <code>Session</code>
*/
public void setSession(Session session)
{
this.session = session;
}
/**
* Indicates if the opration is encoded.
*
* @return <code>true</code> if it is encoded, <code>false</code> otherwise
*/
public boolean isEncoded() {
return (getOperationUse() == Use.ENCODED);
//return soapConstants.getEncodingURI().equals(encodingStyle);
}
/**
* Set whether we are maintaining session state.
*
* @param yesno flag to set to <code>true</code> to maintain sessions
*/
public void setMaintainSession (boolean yesno) {
maintainSession = yesno;
}
/**
* Discover if we are maintaining session state.
*
* @return <code>true</code> if we are maintaining state, <code>false</code>
* otherwise
*/
public boolean getMaintainSession () {
return maintainSession;
}
/**
* Get the request message.
*
* @return the request message (may be null).
*/
public Message getRequestMessage() {
return requestMessage ;
}
/**
* Set the request message, and make sure that message is associated
* with this MessageContext.
*
* @param reqMsg the new request Message.
*/
public void setRequestMessage(Message reqMsg) {
requestMessage = reqMsg ;
if (requestMessage != null) {
requestMessage.setMessageContext(this);
}
}
/**
* Get the response message.
*
* @return the response message (may be null).
*/
public Message getResponseMessage() { return responseMessage ; }
/**
* Set the response message, and make sure that message is associated
* with this MessageContext.
*
* @param respMsg the new response Message.
*/
public void setResponseMessage(Message respMsg) {
responseMessage = respMsg;
if (responseMessage != null) {
responseMessage.setMessageContext(this);
//if we have received attachments of a particular type
// than that should be the default type to send.
Message reqMsg = getRequestMessage();
if (null != reqMsg) {
Attachments reqAttch = reqMsg.getAttachmentsImpl();
Attachments respAttch = respMsg.getAttachmentsImpl();
if (null != reqAttch && null != respAttch) {
if (respAttch.getSendType() == Attachments.SEND_TYPE_NOTSET)
//only if not explicity set.
respAttch.setSendType(reqAttch.getSendType());
}
}
}
}
/**
* Return the current (i.e. request before the pivot, response after)
* message.
*
* @return the current <code>Message</code>
*/
public Message getCurrentMessage()
{
return (havePassedPivot ? responseMessage : requestMessage);
}
/**
* Gets the SOAPMessage from this message context.
*
* @return the <code>SOAPMessage</code>, <code>null</code> if no request
* <code>SOAPMessage</code> is present in this
* <code>SOAPMessageContext</code>
*/
public javax.xml.soap.SOAPMessage getMessage() {
return getCurrentMessage();
}
/**
* Set the current message. This will set the request before the pivot,
* and the response afterwards, as guaged by the passedPivod property.
*
* @param curMsg the <code>Message</code> to assign
*/
public void setCurrentMessage(Message curMsg)
{
curMsg.setMessageContext(this);
if (havePassedPivot) {
responseMessage = curMsg;
} else {
requestMessage = curMsg;
}
}
/**
* Sets the SOAPMessage for this message context.
* This is equivalent to casting <code>message</code> to
* <code>Message</code> and then passing it on to
* <code>setCurrentMessage()</code>.
*
* @param message the <code>SOAPMessage</code> this context is for
*/
public void setMessage(javax.xml.soap.SOAPMessage message) {
setCurrentMessage((Message)message);
}
/**
* Determine when we've passed the pivot.
*
* @return <code>true</code> if we have, <code>false</code> otherwise
*/
public boolean getPastPivot()
{
return havePassedPivot;
}
// fixme: is there any legitimate case where we could pass the pivot and
// then go back again? Is there documentation about the life-cycle of a
// MessageContext, and in particular the re-use of instances that would be
// relevant?
/**
* Indicate when we've passed the pivot.
*
* @param pastPivot true if we are past the pivot point, false otherwise
*/
public void setPastPivot(boolean pastPivot)
{
havePassedPivot = pastPivot;
}
/**
* Set timeout in our MessageContext.
*
* @param value the maximum amount of time, in milliseconds
*/
public void setTimeout (int value) {
timeout = value;
}
/**
* Get timeout from our MessageContext.
*
* @return value the maximum amount of time, in milliseconds
*/
public int getTimeout () {
return timeout;
}
/**
* Get the classloader, implicitly binding to the thread context
* classloader if an override has not been supplied.
*
* @return the class loader
*/
public ClassLoader getClassLoader() {
if ( classLoader == null ) {
classLoader = Thread.currentThread().getContextClassLoader();
}
return( classLoader );
}
/**
* Set a new classloader. Setting to null will result in getClassLoader()
* binding back to the thread context class loader.
*
* @param cl the new <code>ClassLoader</code> or <code>null</code>
*/
public void setClassLoader(ClassLoader cl ) {
classLoader = cl ;
}
/**
* Get the name of the targed service for this message.
*
* @return the target service
*/
public String getTargetService() {
return targetService;
}
/**
* Get the axis engine. This will be <code>null</code> if the message was
* created outside an engine
*
* @return the current axis engine
*/
public AxisEngine getAxisEngine()
{
return axisEngine;
}
/**
* Set the target service for this message.
* <p>
* This looks up the named service in the registry, and has
* the side effect of setting our TypeMappingRegistry to the
* service's.
*
* @param tServ the name of the target service
* @throws AxisFault if anything goes wrong in resolving or setting the
* service
*/
public void setTargetService(String tServ) throws AxisFault {
log.debug("MessageContext: setTargetService(" + tServ+")");
if (tServ == null) {
setService(null);
}
else {
try {
setService(getAxisEngine().getService(tServ));
} catch (AxisFault fault) {
// If we're on the client, don't throw this fault...
if (!isClient()) {
throw fault;
}
}
}
targetService = tServ;
}
/** ServiceHandler is the handler that is the "service". This handler
* can (and probably will actually be a chain that contains the
* service specific request/response/pivot point handlers
*/
private SOAPService serviceHandler ;
/**
* Get the <code>SOAPService</code> used to handle services in this
* context.
*
* @return the service handler
*/
public SOAPService getService() {
return serviceHandler;
}
/**
* Set the <code>SOAPService</code> used to handle services in this
* context. This method configures a wide range of
* <code>MessageContext</code> properties to suit the handler.
*
* @param sh the new service handler
* @throws AxisFault if the service could not be set
*/
public void setService(SOAPService sh) throws AxisFault
{
log.debug("MessageContext: setServiceHandler("+sh+")");
serviceHandler = sh;
if (sh != null) {
if(!sh.isRunning()) {
throw new AxisFault(Messages.getMessage("disabled00"));
}
targetService = sh.getName();
SOAPService service = sh;
TypeMappingRegistry tmr = service.getTypeMappingRegistry();
setTypeMappingRegistry(tmr);
// styles are not "soap version aware" so compensate...
setEncodingStyle(service.getUse().getEncoding());
// This MessageContext should now defer properties it can't find
// to the Service's options.
bag.setParent(sh.getOptions());
// Note that we need (or don't need) high-fidelity SAX recording
// of deserialized messages according to the setting on the
// new service.
highFidelity = service.needsHighFidelityRecording();
service.getInitializedServiceDesc(this);
}
}
/**
* Let us know whether this is the client or the server.
*
* @return true if we are a client
*/
public boolean isClient()
{
return (axisEngine instanceof AxisClient);
}
// fixme: public final statics tend to go in a block at the top of the
// class deffinition, not marooned in the middle
// fixme: chose public static final /or/ public final static
/** Contains an instance of Handler, which is the
* ServiceContext and the entrypoint of this service.
*
* (if it has been so configured - will our deployment
* tool do this by default? - todo by Jacek)
*/
public static final String ENGINE_HANDLER = "engine.handler";
/** This String is the URL that the message came to.
*/
public static final String TRANS_URL = "transport.url";
/** Has a quit been requested? Hackish... but useful... -- RobJ */
public static final String QUIT_REQUESTED = "quit.requested";
/** Place to store an AuthenticatedUser. */
public static final String AUTHUSER = "authenticatedUser";
/** If on the client - this is the Call object. */
public static final String CALL = "call_object" ;
/** Are we doing Msg vs RPC? - For Java Binding. */
public static final String IS_MSG = "isMsg" ;
/** The directory where in coming attachments are created. */
public static final String ATTACHMENTS_DIR = "attachments.directory" ;
/** A boolean param, to control whether we accept missing parameters
* as nulls or refuse to acknowledge them.
*/
public final static String ACCEPTMISSINGPARAMS = "acceptMissingParams";
/** The value of the property is used by service WSDL generation (aka ?WSDL)
* For the service's interface namespace if not set TRANS_URL property is used.
*/
public static final String WSDLGEN_INTFNAMESPACE = "axis.wsdlgen.intfnamespace";
/** The value of the property is used by service WSDL generation (aka ?WSDL).
* For the service's location if not set TRANS_URL property is used.
* (helps provide support through proxies.
*/
public static final String WSDLGEN_SERV_LOC_URL = "axis.wsdlgen.serv.loc.url";
// fixme: should this be a type-safe e-num?
/** The value of the property is used by service WSDL generation (aka ?WSDL).
* Set this property to request a certain level of HTTP.
* The values MUST use org.apache.axis.transport.http.HTTPConstants.HEADER_PROTOCOL_10
* for HTTP 1.0
* The values MUST use org.apache.axis.transport.http.HTTPConstants.HEADER_PROTOCOL_11
* for HTTP 1.1
*/
public static final String HTTP_TRANSPORT_VERSION = "axis.transport.version";
// fixme: is this the name of a security provider, or the name of a security
// provider class, or the actualy class of a security provider, or
// something else?
/**
* The security provider.
*/
public static final String SECURITY_PROVIDER = "securityProvider";
/*
* IMPORTANT.
* If adding any new constants to this class. Make them final. The
* ones above are left non-final for compatibility reasons.
*/
/**
* Get a <code>String</code> property by name.
*
* @param propName the name of the property to fetch
* @return the value of the named property
* @throws ClassCastException if the property named does not have a
* <code>String</code> value
*/
public String getStrProp(String propName) {
return (String) getProperty(propName);
}
/**
* Tests to see if the named property is set in the 'bag', returning
* <code>false</code> if it is not present at all.
* This is equivalent to <code>isPropertyTrue(propName, false)</code>.
*
* @param propName the name of the property to check
* @return true or false, depending on the value of the property
*/
public boolean isPropertyTrue(String propName) {
return isPropertyTrue(propName, false);
}
/**
* Test if a property is set to something we consider to be true in the
* 'bag'.
* <ul>
* <li>If not there then <code>defaultVal</code> is returned.</li>
* <li>If there, then...<ul>
* <li>if its a <code>Boolean</code>, we'll return booleanValue()</li>
* <li>if its an <code>Integer</code>, we'll return <code>false</code>
* if its <code>0</code> else <code>true</code></li>
* <li>if its a <code>String</code> we'll return <code>false</code> if its
* <code>"false"</code>" or <code>"0"</code> else <code>true</code></li>
* <li>All other types return <code>true</code></li>
* </ul></li>
* </ul>
*
* @param propName the name of the property to check
* @param defaultVal the default value
* @return true or false, depending on the value of the property
*/
public boolean isPropertyTrue(String propName, boolean defaultVal) {
return JavaUtils.isTrue(getProperty(propName), defaultVal);
}
/**
* Allows you to set a named property to the passed in value.
* There are a few known properties (like username, password, etc)
* that are variables in Call. The rest of the properties are
* stored in a Hashtable. These common properties should be
* accessed via the accessors for speed/type safety, but they may
* still be obtained via this method. It's up to one of the
* Handlers (or the Axis engine itself) to go looking for
* one of them.
*
* @param name Name of the property
* @param value Value of the property
*/
public void setProperty(String name, Object value) {
if (name == null || value == null) {
return;
// Is this right? Shouldn't we throw an exception like:
// throw new IllegalArgumentException(msg);
}
else if (name.equals(Call.USERNAME_PROPERTY)) {
if (!(value instanceof String)) {
throw new IllegalArgumentException(
Messages.getMessage("badProp00", new String[] {
name, "java.lang.String", value.getClass().getName()}));
}
setUsername((String) value);
}
else if (name.equals(Call.PASSWORD_PROPERTY)) {
if (!(value instanceof String)) {
throw new IllegalArgumentException(
Messages.getMessage("badProp00", new String[] {
name, "java.lang.String", value.getClass().getName()}));
}
setPassword((String) value);
}
else if (name.equals(Call.SESSION_MAINTAIN_PROPERTY)) {
if (!(value instanceof Boolean)) {
throw new IllegalArgumentException(
Messages.getMessage("badProp00", new String[]
{name,
"java.lang.Boolean",
value.getClass().getName()}));
}
setMaintainSession(((Boolean) value).booleanValue());
}
else if (name.equals(Call.SOAPACTION_USE_PROPERTY)) {
if (!(value instanceof Boolean)) {
throw new IllegalArgumentException(
Messages.getMessage("badProp00", new String[]
{name,
"java.lang.Boolean",
value.getClass().getName()}));
}
setUseSOAPAction(((Boolean) value).booleanValue());
}
else if (name.equals(Call.SOAPACTION_URI_PROPERTY)) {
if (!(value instanceof String)) {
throw new IllegalArgumentException(
Messages.getMessage("badProp00", new String[]
{name,
"java.lang.String",
value.getClass().getName()}));
}
setSOAPActionURI((String) value);
}
else if (name.equals(Call.ENCODINGSTYLE_URI_PROPERTY)) {
if (!(value instanceof String)) {
throw new IllegalArgumentException(
Messages.getMessage("badProp00", new String[]
{name,
"java.lang.String",
value.getClass().getName()}));
}
setEncodingStyle((String) value);
}
else {
bag.put(name, value);
}
} // setProperty
/**
* Returns true if the MessageContext contains a property with the specified name.
* @param name Name of the property whose presense is to be tested
* @return Returns true if the MessageContext contains the
property; otherwise false
*/
public boolean containsProperty(String name) {
Object propertyValue = getProperty(name);
return (propertyValue != null);
}
/**
* Returns an <code>Iterator</code> view of the names of the properties in
* this <code>MessageContext</code>.
*
* @return an <code>Iterator</code> over all property names
*/
public java.util.Iterator getPropertyNames() {
// fixme: this is potentially unsafe for the caller - changing the
// properties will kill the iterator. Consider iterating over a copy:
// return new HashSet(bag.keySet()).iterator();
return bag.keySet().iterator();
}
/**
* Returns an Iterator view of the names of the properties
* in this MessageContext and any parents of the LockableHashtable
* @return Iterator for the property names
*/
public java.util.Iterator getAllPropertyNames() {
return bag.getAllKeys().iterator();
}
/**
* Returns the value associated with the named property - or null if not
* defined/set.
*
* @param name the property name
* @return Object value of the property - or null
*/
public Object getProperty(String name) {
if (name != null) {
if (name.equals(Call.USERNAME_PROPERTY)) {
return getUsername();
}
else if (name.equals(Call.PASSWORD_PROPERTY)) {
return getPassword();
}
else if (name.equals(Call.SESSION_MAINTAIN_PROPERTY)) {
return getMaintainSession() ? Boolean.TRUE : Boolean.FALSE;
}
else if (name.equals(Call.OPERATION_STYLE_PROPERTY)) {
return (getOperationStyle() == null) ? null : getOperationStyle().getName();
}
else if (name.equals(Call.SOAPACTION_USE_PROPERTY)) {
return useSOAPAction() ? Boolean.TRUE : Boolean.FALSE;
}
else if (name.equals(Call.SOAPACTION_URI_PROPERTY)) {
return getSOAPActionURI();
}
else if (name.equals(Call.ENCODINGSTYLE_URI_PROPERTY)) {
return getEncodingStyle();
}
else if (bag == null) {
return null;
}
else {
return bag.get(name);
}
}
else {
return null;
}
}
// fixme: this makes no copy of parent, so later modifications to parent
// can alter this context - is this intended? If so, it needs documenting.
// If not, it needs fixing.
/**
* Set the Hashtable that contains the default values for our
* properties.
*
* @param parent
*/
public void setPropertyParent(Hashtable parent)
{
bag.setParent(parent);
}
/**
* Set the username.
*
* @param username the new user name
*/
public void setUsername(String username) {
this.username = username;
} // setUsername
/**
* Get the user name.
*
* @return the user name as a <code>String</code>
*/
public String getUsername() {
return username;
} // getUsername
/**
* Set the password.
*
* @param password a <code>String</code> containing the new password
*/
public void setPassword(String password) {
this.password = password;
} // setPassword
/**
* Get the password.
*
* @return the current password <code>String</code>
*/
public String getPassword() {
return password;
} // getPassword
/**
* Get the operation style. This is either the style of the current
* operation or if that is not set, the style of the service handler, or
* if that is not set, <code>Style.RPC</code>.
*
* @return the <code>Style</code> of this message
*/
public Style getOperationStyle() {
if (currentOperation != null) {
return currentOperation.getStyle();
}
if (serviceHandler != null) {
return serviceHandler.getStyle();
}
return Style.RPC;
} // getOperationStyle
/**
* Get the operation use.
*
* @return the operation <code>Use</code>
*/
public Use getOperationUse() {
if (currentOperation != null) {
return currentOperation.getUse();
}
if (serviceHandler != null) {
return serviceHandler.getUse();
}
return Use.ENCODED;
} // getOperationUse
/**
* Enable or dissable the use of soap action information. When enabled,
* the message context will attempt to use the soap action URI
* information during binding of soap messages to service methods. When
* dissabled, it will make no such attempt.
*
* @param useSOAPAction <code>true</code> if soap action URI information
* should be used, <code>false</code> otherwise
*/
public void setUseSOAPAction(boolean useSOAPAction) {
this.useSOAPAction = useSOAPAction;
} // setUseSOAPAction
// fixme: this doesn't follow beany naming conventions - should be
// isUseSOAPActions or getUseSOAPActions or something prettier
/**
* Indicates wether the soap action URI is being used or not.
*
* @return <code>true</code> if it is, <code>false</code> otherwise
*/
public boolean useSOAPAction() {
return useSOAPAction;
} // useSOAPAction
// fixme: this throws IllegalArgumentException but never raises it -
// perhaps in a sub-class?
// fixme: IllegalArgumentException is unchecked. Best practice says you
// should document unchecked exceptions, but not list them in throws
/**
* Set the soapAction URI.
*
* @param SOAPActionURI a <code>String</code> giving the new soap action
* URI
* @throws IllegalArgumentException if the URI is not liked
*/
public void setSOAPActionURI(String SOAPActionURI)
throws IllegalArgumentException {
this.SOAPActionURI = SOAPActionURI;
} // setSOAPActionURI
/**
* Get the soapAction URI.
*
* @return the URI of this soap action
*/
public String getSOAPActionURI() {
return SOAPActionURI;
} // getSOAPActionURI
/**
* Sets the encoding style to the URI passed in.
*
* @param namespaceURI URI of the encoding to use.
*/
public void setEncodingStyle(String namespaceURI) {
if (namespaceURI == null) {
namespaceURI = Constants.URI_LITERAL_ENC;
}
else if (Constants.isSOAP_ENC(namespaceURI)) {
namespaceURI = soapConstants.getEncodingURI();
}
encodingStyle = namespaceURI;
} // setEncodingStype
/**
* Returns the encoding style as a URI that should be used for the SOAP
* message.
*
* @return String URI of the encoding style to use
*/
public String getEncodingStyle() {
return encodingStyle;
} // getEncodingStyle
public void removeProperty(String propName)
{
if (bag != null) {
bag.remove(propName);
}
}
/**
* Return this context to a clean state.
*/
public void reset()
{
if (bag != null) {
bag.clear();
}
serviceHandler = null;
havePassedPivot = false;
currentOperation = null;
}
/**
* Read the high fidelity property.
* <p>
* Some behavior may be apropreate for high fidelity contexts that is not
* relevant for low fidelity ones or vica-versa.
*
* @return <code>true</code> if the context is high fidelity,
* <code>false</code> otherwise
*/
public boolean isHighFidelity() {
return highFidelity;
}
/**
* Set the high fidelity propert.
* <p>
* Users of the context may be changing what they do based upon this flag.
*
* @param highFidelity the new value of the highFidelity property
*/
public void setHighFidelity(boolean highFidelity) {
this.highFidelity = highFidelity;
}
/**
* Gets the SOAP actor roles associated with an execution of the
* <code>HandlerChain</code> and its contained <code>Handler</code>
* instances.
* <p>
* <i>Not (yet) implemented method in the SOAPMessageContext interface</i>.
* <p>
* <b>Note:</b> SOAP actor roles apply to the SOAP node and are managed
* using <code>HandlerChain.setRoles()</code> and
* <code>HandlerChain.getRoles()</code>. Handler instances in the
* <code>HandlerChain</code> use this information about the SOAP actor roles
* to process the SOAP header blocks. Note that the SOAP actor roles are
* invariant during the processing of SOAP message through the
* <code>HandlerChain</code>.
*
* @return an array of URIs for SOAP actor roles
* @see javax.xml.rpc.handler.HandlerChain#setRoles(java.lang.String[]) HandlerChain.setRoles(java.lang.String[])
* @see javax.xml.rpc.handler.HandlerChain#getRoles() HandlerChain.getRoles()
*/
public String[] getRoles() {
//TODO: Flesh this out.
return roles;
}
/**
* Set the SOAP actor roles associated with an executioni of
* <code>CodeHandlerChain</code> and its contained <code>Handler</code>
* instances.
*
* @param roles an array of <code>String</code> instances, each representing
* the URI for a SOAP actor role
*/
public void setRoles( String[] roles) {
this.roles = roles;
}
/**
* if a message (or subclass) has any disposal needs, this method
* is where it goes. Subclasses *must* call super.dispose(), and
* be prepared to be called from the finalizer as well as earlier
*/
public synchronized void dispose() {
log.debug("disposing of message context");
if(requestMessage!=null) {
requestMessage.dispose();
requestMessage=null;
}
if(responseMessage!=null) {
responseMessage.dispose();
responseMessage=null;
}
}
}