org.apache.axis2.context.OperationContext Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of axis2-kernel Show documentation
Show all versions of axis2-kernel Show documentation
Core Parts of Axis2. This includes Axis2 engine, Client API, Addressing support, etc.,
/*
* 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.context;
import org.apache.axiom.om.util.UUIDGenerator;
import org.apache.axis2.AxisFault;
import org.apache.axis2.context.externalize.ActivateUtils;
import org.apache.axis2.context.externalize.ExternalizeConstants;
import org.apache.axis2.context.externalize.SafeObjectInputStream;
import org.apache.axis2.context.externalize.SafeObjectOutputStream;
import org.apache.axis2.context.externalize.SafeSerializable;
import org.apache.axis2.description.AxisOperation;
import org.apache.axis2.description.AxisService;
import org.apache.axis2.engine.AxisConfiguration;
import org.apache.axis2.util.MetaDataEntry;
import org.apache.axis2.wsdl.WSDLConstants.WSDL20_2004_Constants;
import org.apache.axis2.wsdl.WSDLConstants.WSDL20_2006Constants;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import javax.xml.namespace.QName;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
/**
* An OperationContext represents a running "instance" of an operation, which is
* represented by an AxisOperation object. This concept is needed to allow
* messages to be grouped into operations as in WSDL 2.0-speak operations are
* essentially arbitrary message exchange patterns. So as messages are being
* exchanged the OperationContext remembers the state of where in the message
* exchange pattern it is in.
*
* The base implementation of OperationContext
* supports MEPs which have one input message and/or one output message. That
* is, it supports the all the MEPs that are in the WSDL 2.0 specification. In
* order to support another MEP one must extend this class and register its
* creation in the OperationContexFactory.
*/
public class OperationContext extends AbstractContext
implements Externalizable, SafeSerializable {
/*
* setup for logging
*/
private static final Log log = LogFactory.getLog(OperationContext.class);
private static final String myClassName = "OperationContext";
private boolean debugEnabled = log.isDebugEnabled();
/**
* An ID which can be used to correlate operations on an instance of
* this object in the log files
*/
private String logCorrelationIDString = null;
/**
* @serial The serialization version ID tracks the version of the class.
* If a class definition changes, then the serialization/externalization
* of the class is affected. If a change to the class is made which is
* not compatible with the serialization/externalization of the class,
* then the serialization version ID should be updated.
* Refer to the "serialVer" utility to compute a serialization
* version ID.
*/
private static final long serialVersionUID = -7264782778333554350L;
/**
* @serial Tracks the revision level of a class to identify changes to the
* class definition that are compatible to serialization/externalization.
* If a class definition changes, then the serialization/externalization
* of the class is affected.
* Refer to the writeExternal() and readExternal() methods.
*/
// supported revision levels, add a new level to manage compatible changes
private static final int REVISION_2 = 2;
// current revision level of this object
private static final int revisionID = REVISION_2;
/**
* @serial isComplete flag
*/
private boolean isComplete;
/**
* @serial key string
*/
//The key value of the operationContextMap;
private String key;
// the AxisOperation of which this is a running instance. The MEP of this
// AxisOperation must be one of the 8 predefined ones in WSDL 2.0.
private transient AxisOperation axisOperation;
/**
* the set of message contexts associated with this operation
*/
private transient HashMap messageContexts;
//----------------------------------------------------------------
// MetaData for data to be restored in activate after readExternal
//----------------------------------------------------------------
/**
* Indicates whether the message context has been reconstituted
* and needs to have its object references reconciled
*/
private transient boolean needsToBeReconciled = false;
/**
* Suppresses warning messages for activation
* when doing internal reconciliation
*/
private transient boolean suppressWarnings = false;
/**
* The AxisOperation metadata will be used during
* activate to match up with an existing object
*/
private transient MetaDataEntry metaAxisOperation = null;
/**
* The AxisService metadata will be used during
* activate to match up with an existing object
*/
private transient MetaDataEntry metaAxisService = null;
/**
* The ServiceContext metadata will be used during
* activate to match up with an existing object
*/
private transient ServiceContext metaParent = null;
/**
* This is used to hold information about message context objects
* that are in the messageContexts map. This allows message context
* objects to be isolated from the object graph so that duplicate
* copies of objects are not saved/restored.
*/
private HashMap metaMessageContextMap = null;
/**
* This is used to hold temporarily any message context objects
* that were isolated from the messageContexts map.
*/
private transient HashMap isolatedMessageContexts = null;
/**
* This is used to hold temporarily any message context objects
* from the messageContexts map for save/restore activities.
*/
private transient HashMap workingSet = null;
//----------------------------------------------------------------
// end MetaData section
//----------------------------------------------------------------
/**
* Simple constructor (needed for deserialization, shouldn't be used otherwise!)
*/
public OperationContext() {
super(null);
this.messageContexts = new HashMap();
}
/**
* Constructs a new OperationContext.
*
* @param axisOperation the AxisOperation whose running instances' state this
* OperationContext represents.
* @param serviceContext the parent ServiceContext representing any state related to
* the set of all operations of the service.
*/
public OperationContext(AxisOperation axisOperation,
ServiceContext serviceContext) {
super(serviceContext);
this.messageContexts = new HashMap();
this.axisOperation = axisOperation;
this.setParent(serviceContext);
}
/**
* When a new message is added to the MEPContext the logic
* should be included remove the MEPContext from the table in the
* EngineContext. Example: IN_IN_OUT At the second IN
* message the MEPContext should be removed from the AxisOperation.
*
* @param msgContext
*/
public void addMessageContext(MessageContext msgContext) throws AxisFault {
if (axisOperation != null) {
axisOperation.addMessageContext(msgContext, this);
touch();
}
}
/**
* Removes the pointers to this OperationContext in the
* ConfigurationContext's OperationContextMap so that this
* OperationContext will eventually get garbage collected
* along with the MessageContext's it contains. Note that if
* the caller wants to make sure its safe to clean up this OperationContext
* he should call isComplete() first. However, in cases like IN_OPTIONAL_OUT
* and OUT_OPTIONAL_IN, it is possibe this will get called without the MEP
* being complete due to the optional nature of the MEP.
*/
public void cleanup() {
ServiceContext serv = getServiceContext();
if (serv != null) {
serv.getConfigurationContext().unregisterOperationContext(key);
}
}
/**
* @return Returns the axisOperation.
*/
public AxisOperation getAxisOperation() {
if (needsToBeReconciled && !suppressWarnings && debugEnabled) {
log.debug(getLogCorrelationIDString() +
":getAxisOperation(): ****WARNING**** OperationContext.activate(configurationContext) needs to be invoked.");
}
return axisOperation;
}
/**
* Returns the EngineContext in which the parent ServiceContext lives.
*
* @return Returns parent ServiceContext's parent EngineContext.
*/
public ConfigurationContext getConfigurationContext() {
if (parent != null) {
return ((ServiceContext) parent).getConfigurationContext();
} else {
return null;
}
}
/**
* @param messageLabel
* @return Returns MessageContext.
* @throws AxisFault
*/
public MessageContext getMessageContext(String messageLabel)
throws AxisFault {
if (messageContexts == null) {
return null;
}
return (MessageContext) messageContexts.get(messageLabel);
}
/**
* Remove the indicated message context.
* Example Usage: The exchange is aborted and we need to
* undo the work and free resources.
* @param label
* @throws AxisFault
*/
public void removeMessageContext(String label) throws AxisFault {
MessageContext mc = getMessageContext(label);
if (mc != null) {
messageContexts.remove(mc);
setComplete(false);
touch();
}
}
public HashMap getMessageContexts() {
return messageContexts;
}
/**
* Returns the ServiceContext in which this OperationContext lives.
*
* @return Returns parent ServiceContext.
*/
public ServiceContext getServiceContext() {
return (ServiceContext) parent;
}
/**
* Checks to see if the MEP is complete. i.e. whether all the messages that
* are associated with the MEP has arrived and MEP is complete.
*/
public boolean isComplete() {
return isComplete;
}
public void setComplete(boolean complete) {
isComplete = complete;
}
public void setKey(String key) {
this.key = key;
}
/* ===============================================================
* Externalizable support
* ===============================================================
*/
/**
* Save the contents of this object.
*
* NOTE: Transient fields and static fields are not saved.
* Also, objects that represent "static" data are
* not saved, except for enough information to be
* able to find matching objects when the message
* context is re-constituted.
*
* @param out The stream to write the object contents to
* @throws IOException
*/
public void writeExternal(ObjectOutput o) throws IOException {
SafeObjectOutputStream out = SafeObjectOutputStream.install(o);
//---------------------------------------------------------
// in order to handle future changes to the message
// context definition, be sure to maintain the
// object level identifiers
//---------------------------------------------------------
// serialization version ID
out.writeLong(serialVersionUID);
// revision ID
out.writeInt(revisionID);
//---------------------------------------------------------
// various simple fields
//---------------------------------------------------------
out.writeLong(getLastTouchedTime());
out.writeBoolean(isComplete);
out.writeObject(key);
out.writeObject(logCorrelationIDString);
//---------------------------------------------------------
// properties
//---------------------------------------------------------
out.writeUTF("properties"); // write marker
out.writeMap(getProperties());
//---------------------------------------------------------
// AxisOperation axisOperation
//---------------------------------------------------------
out.writeUTF("metaAxisOperation"); // write marker
metaAxisOperation = null;
if (axisOperation != null) {
metaAxisOperation = new MetaDataEntry(axisOperation.getClass().getName(),
axisOperation.getName().toString());
}
out.writeObject(metaAxisOperation);
//---------------------------------------------------------
// AxisOperation axisService
//---------------------------------------------------------
// save the meta data for the corresponding axis service to better
// match up the axis operation
out.writeUTF("metaAxisService"); // write marker
metaAxisService = null;
AxisService axisService = axisOperation.getAxisService();
if (axisService != null) {
metaAxisService =
new MetaDataEntry(axisService.getClass().getName(), axisService.getName());
}
out.writeObject(metaAxisService);
//---------------------------------------------------------
// parent
//---------------------------------------------------------
out.writeUTF("parent"); // write marker
out.writeObject(this.getServiceContext());
//---------------------------------------------------------
// HashMap messageContexts table
//---------------------------------------------------------
// NOTES: The assumption is that the table contains message contexts
// that are in the OperationContext hierarchy. To reduce overlap
// of object information that is being saved, extract the
// message context objects from the hierachy before saving.
// When the OperationContext is restored, the "slimmed down"
// message context objects are plugged back into the hierachy
// using the restored OperationContext as a basis.
// first deal with the original messageContexts table
HashMap tmpMsgCtxMap = null;
if ((messageContexts != null) && (!messageContexts.isEmpty())) {
// create a table of the non-isolated message contexts
workingSet = new HashMap();
tmpMsgCtxMap = new HashMap();
Set keySet = messageContexts.keySet();
Iterator itKeys = keySet.iterator();
while (itKeys.hasNext()) {
// expect the key to be a string
String keyObj = (String) itKeys.next();
// get the message context associated with that label
MessageContext value = (MessageContext) messageContexts.get(keyObj);
boolean addToWorkingSet = true;
// check to see if this message context was isolated
if (isolatedMessageContexts != null) {
if (!isolatedMessageContexts.isEmpty()) {
// see if the message context was previously isolated
MessageContext valueIsolated =
(MessageContext) isolatedMessageContexts.get(keyObj);
if (valueIsolated != null) {
String idIsol = valueIsolated.getMessageID();
if (idIsol != null) {
if (idIsol.equals(value.getMessageID())) {
// don't add to working set
addToWorkingSet = false;
}
}
}
}
}
if (addToWorkingSet) {
// put the meta data entry in the list
workingSet.put(keyObj, value);
}
}
// now we have a working set
Set keySet2 = workingSet.keySet();
Iterator itKeys2 = keySet2.iterator();
while (itKeys2.hasNext()) {
// expect the key to be a string
String keyObj2 = (String) itKeys2.next();
// get the message context associated with that label
MessageContext mc = (MessageContext) workingSet.get(keyObj2);
// construct a copy of the message context
// that has been extracted from the object hierarchy
MessageContext copyMC = mc.extractCopyMessageContext();
// Don't persist the message of the other message contexts
copyMC.setEnvelope(null);
// put the modified entry in the list
tmpMsgCtxMap.put(keyObj2, copyMC);
// trace point
if (log.isTraceEnabled()) {
log.trace(getLogCorrelationIDString() +
":writeExternal(): getting working set entry key [" + keyObj2 +
"] message context ID[" + copyMC.getMessageID() + "]");
}
}
}
out.writeUTF("messagecontexts"); // write marker
out.writeMap(tmpMsgCtxMap);
out.writeUTF("metaMessageContextMap");
out.writeMap(metaMessageContextMap);
//---------------------------------------------------------
// done
//---------------------------------------------------------
}
/**
* Restore the contents of the object that was previously saved.
*
* NOTE: The field data must read back in the same order and type
* as it was written. Some data will need to be validated when
* resurrected.
*
* @param in The stream to read the object contents from
* @throws IOException
* @throws ClassNotFoundException
*/
public void readExternal(ObjectInput inObject) throws IOException, ClassNotFoundException {
SafeObjectInputStream in = SafeObjectInputStream.install(inObject);
// set the flag to indicate that the message context is being
// reconstituted and will need to have certain object references
// to be reconciled with the current engine setup
needsToBeReconciled = true;
// trace point
log.trace(myClassName + ":readExternal(): BEGIN bytes available in stream [" +
in.available() + "] ");
//---------------------------------------------------------
// object level identifiers
//---------------------------------------------------------
// serialization version ID
long suid = in.readLong();
// revision ID
int revID = in.readInt();
// make sure the object data is in a version we can handle
if (suid != serialVersionUID) {
throw new ClassNotFoundException(ExternalizeConstants.UNSUPPORTED_SUID);
}
// make sure the object data is in a revision level we can handle
if (revID != REVISION_2) {
throw new ClassNotFoundException(ExternalizeConstants.UNSUPPORTED_REVID);
}
//---------------------------------------------------------
// various simple fields
//---------------------------------------------------------
long time = in.readLong();
setLastTouchedTime(time);
isComplete = in.readBoolean();
key = (String) in.readObject();
logCorrelationIDString = (String) in.readObject();
// trace point
if (log.isTraceEnabled()) {
log.trace(myClassName + ":readExternal(): reading input stream for [" +
getLogCorrelationIDString() + "] ");
}
//---------------------------------------------------------
// properties
//---------------------------------------------------------
in.readUTF(); // read marker
properties = in.readMap(new HashMapUpdateLockable());
//---------------------------------------------------------
// axis operation meta data
//---------------------------------------------------------
// axisOperation is not usable until the meta data has been reconciled
axisOperation = null;
in.readUTF(); // read marker
metaAxisOperation = (MetaDataEntry) in.readObject();
//---------------------------------------------------------
// axis service meta data
//---------------------------------------------------------
// axisService is not usable until the meta data has been reconciled
in.readUTF(); // read marker
metaAxisService = (MetaDataEntry) in.readObject();
//---------------------------------------------------------
// parent
//---------------------------------------------------------
// ServiceContext is not usable until it has been activated
in.readUTF(); // read marker
metaParent = (ServiceContext) in.readObject();
//---------------------------------------------------------
// HashMap messageContexts table
//---------------------------------------------------------
// set to empty until this can be activiated
messageContexts = new HashMap();
in.readUTF(); // read marker
workingSet = in.readHashMap();
in.readUTF(); // read marker
metaMessageContextMap = in.readHashMap();
//---------------------------------------------------------
// done
//---------------------------------------------------------
}
/**
* This method checks to see if additional work needs to be
* done in order to complete the object reconstitution.
* Some parts of the object restored from the readExternal()
* cannot be completed until we have a configurationContext
* from the active engine. The configurationContext is used
* to help this object to plug back into the engine's
* configuration and deployment objects.
*
* @param cc The configuration context object representing the active configuration
*/
public void activate(ConfigurationContext cc) {
// see if there's any work to do
if (!needsToBeReconciled) {
// return quick
return;
}
// get the axis configuration
AxisConfiguration axisConfig = cc.getAxisConfiguration();
// We previously saved metaAxisService; restore it
AxisService axisService = null;
if (metaAxisService != null) {
axisService = ActivateUtils.findService(axisConfig, metaAxisService.getClassName(),
metaAxisService.getQNameAsString());
}
// We previously saved metaAxisOperation; restore it
if (metaAxisOperation != null) {
if (axisService != null) {
this.axisOperation = ActivateUtils.findOperation(axisService,
metaAxisOperation.getClassName(),
metaAxisOperation.getQName());
} else {
this.axisOperation = ActivateUtils.findOperation(axisConfig,
metaAxisOperation.getClassName(),
metaAxisOperation.getQName());
}
}
// the parent ServiceContext object was saved
// either use the restored object or sync up with
// an existing ServiceContext object
if (metaParent != null) {
// find out if a copy of the ServiceContext object exists on this
// engine where this OperationContext is being restored/activated
// if so, use that object instead of the restored object
// in order to make sure that future changes to service-level
// properties are preserved for future operations
String groupName = metaParent.getGroupName();
String serviceName = metaParent.getName();
ServiceContext existingSC = null;
// first look for the ServiceContext via the ServiceContextGroup
ServiceGroupContext sgc = cc.getServiceGroupContext(groupName);
if (sgc != null) {
existingSC = sgc.findServiceContext(serviceName);
}
if (existingSC == null) {
// we couldn't find the ServiceContext via the ServiceContextGroup
// try via the set of existing operation contexts
OperationContext existingOC =
cc.findOperationContext(getOperationName(), serviceName, groupName);
if (existingOC != null) {
existingSC = (ServiceContext) existingOC.getParent();
}
}
if (existingSC == null) {
// could not find an existing ServiceContext
// use the restored object
metaParent.activate(cc);
// set parent
this.setParent(metaParent);
} else {
// switch over to the existing object
this.setParent(existingSC);
// do a copy of the properties from the restored object
// to the existing ServiceContext
// Should the copy be a non-destructive one? That is,
// if the key already exists in the properties table of the
// existing object, should the value be overwritten from the
// restored ojbect? For now, the decision is that the state
// that has been preserved for a saved context object is
// is important to be restored.
metaParent.putContextProperties(existingSC, true);
}
} else {
// set parent to null
this.setParent(metaParent);
}
// reseed the operation context map
ServiceContext serv = getServiceContext();
ConfigurationContext activeCC;
if (serv != null) {
activeCC = serv.getConfigurationContext();
} else {
activeCC = cc;
}
if (key != null) {
// We only want to (re)register this if it's an outbound message
String mepString = getAxisOperation().getMessageExchangePattern();
if (mepString.equals(WSDL20_2006Constants.MEP_URI_OUT_ONLY)
|| mepString.equals(WSDL20_2004_Constants.MEP_URI_OUT_ONLY)
|| ((mepString.equals(WSDL20_2006Constants.MEP_URI_OUT_IN)
|| mepString.equals(WSDL20_2004_Constants.MEP_URI_OUT_IN))
&& !isComplete)) {
// make sure this OperationContext object is registered in the
// list maintained by the ConfigurationContext object
boolean registrationSuceeded = activeCC.registerOperationContext(key, this, true);
if (!registrationSuceeded) {
// trace point
if (log.isTraceEnabled()) {
log.trace(getLogCorrelationIDString()+ ":activate(): " +
"OperationContext key [" + key
+ "] already exists in ConfigurationContext map. " +
"This OperationContext ["
+ this.toString() + "] was not added to the table.");
}
}
}
}
//-------------------------------------------------------
// update the modified entries in the messageContexts table
//-------------------------------------------------------
// NOTE: an entry in the metaMessageContextMap must wait
// for its corresponding active message context object
// to call this operation context object so we don't
// need to handle the metaMessagecontextMap table here
if ((workingSet != null) && (!workingSet.isEmpty())) {
Set keySet = workingSet.keySet();
Iterator itKeys = keySet.iterator();
while (itKeys.hasNext()) {
// expect the key to be a string
String keyObj = (String) itKeys.next();
// get the message context associated with that label
MessageContext value = (MessageContext) workingSet.get((Object) keyObj);
// activate that object
if (value != null) {
// trace point
if (log.isTraceEnabled()) {
log.trace(getLogCorrelationIDString() + ":activate(): key [" + keyObj +
"] message id [" + value.getMessageID() + "]");
}
suppressWarnings = true;
value.activateWithOperationContext(this);
suppressWarnings = false;
if (messageContexts == null) {
messageContexts = new HashMap();
}
}
// put the entry in the "real" table
// note that the key or the value could be null
messageContexts.put(keyObj, value);
}
}
//-------------------------------------------------------
// done, reset the flag
//-------------------------------------------------------
needsToBeReconciled = false;
}
/**
* Isolate the specified message context object
* to prepare for serialization. Instead of
* saving the entire message context object,
* just setup some metadata about the message
* context.
*
* Note: this will remove the specified
* message context object from the message context
* table.
*
* @param mc The message context object
*/
public void isolateMessageContext(MessageContext mc) {
if (mc == null) {
return;
}
if ((messageContexts == null) || (messageContexts.isEmpty())) {
return;
}
// get the message ID from the message context
String messageID = mc.getMessageID();
if (messageID == null) {
// can't locate it without identification
return;
}
Iterator it = messageContexts.keySet().iterator();
while (it.hasNext()) {
// get the key
Object keyObj = it.next();
// get the value associated with that key
MessageContext value = (MessageContext) messageContexts.get(keyObj);
if (value != null) {
String valueID = value.getMessageID();
if ((valueID != null) && valueID.equals(messageID)) {
// found the input message context in our table
if (metaMessageContextMap == null) {
metaMessageContextMap = new HashMap();
}
// build a meta data entry
// MessageContext class name
// MessageContext messageID
// key used in the original hashmap that is associated with this MessageContext
// note: this is typically something like "In", "Out", "Fault"
//
MetaDataEntry metaData = new MetaDataEntry(value.getClass().getName(),
value.getMessageID(),
keyObj.toString());
// put the meta data entry in the list
// note that if the entry was already in the list,
// this will replace that entry
metaMessageContextMap.put(keyObj, metaData);
// don't change the original table - there's potentially lots of areas that
// grab the table
// // now remove the original entry from the messageContexts table
// messageContexts.remove(keyObj);
// put the original entry in the temporary list
if (isolatedMessageContexts == null) {
isolatedMessageContexts = new HashMap();
}
// note that if the entry was already in the list,
// this will replace that entry
isolatedMessageContexts.put(keyObj, value);
// trace point
if (log.isTraceEnabled()) {
log.trace(getLogCorrelationIDString() +
":isolateMessageContext(): set up message context id[" + valueID +
"] with key [" + keyObj.toString() +
"] from messageContexts table to prepare for serialization.");
}
break;
}
}
}
}
/**
* Restore the specified MessageContext object in the
* table used to hold the message contexts associated
* with this operation.
*
* @param msg The message context object
*/
public void restoreMessageContext(MessageContext msg) {
// see if the activation has been done
if (needsToBeReconciled) {
// nope, need to do the activation first
if (debugEnabled) {
log.debug(getLogCorrelationIDString() +
":restoreMessageContext(): *** WARNING : need to invoke activate() prior to restoring the MessageContext to the list.");
}
return;
}
if (msg == null) {
return;
}
String msgID = msg.getMessageID();
if (msgID == null) {
if (debugEnabled) {
// can't identify message context
log.debug(getLogCorrelationIDString() +
":restoreMessageContext(): *** WARNING : MessageContext does not have a message ID.");
}
return;
}
// first check the metaMessageContextMap to see if
// the specified message context object matches any
// of the metadata entries.
if ((metaMessageContextMap != null) && (!metaMessageContextMap.isEmpty())) {
Iterator itMeta = metaMessageContextMap.keySet().iterator();
while (itMeta.hasNext()) {
String keyM = (String) itMeta.next();
MetaDataEntry valueM = (MetaDataEntry) metaMessageContextMap.get(keyM);
String valueM_ID;
if (valueM != null) {
valueM_ID = valueM.getQNameAsString();
if (msgID.equals(valueM_ID)) {
String label = valueM.getExtraName();
if (messageContexts == null) {
messageContexts = new HashMap();
}
// put the message context into the messageContexts table
messageContexts.put(label, msg);
// remove the metadata from the metadata table
metaMessageContextMap.remove(keyM);
if (log.isTraceEnabled()) {
log.trace(getLogCorrelationIDString() +
":restoreMessageContext(): restored label [" + label +
"] message ID [" + msg.getMessageID() + "]");
}
break;
}
}
}
} else
// see if we can put the msg directly in the messageContexts table
if ((messageContexts != null) && (!messageContexts.isEmpty())) {
Iterator itList = messageContexts.keySet().iterator();
while (itList.hasNext()) {
String key = (String) itList.next();
MessageContext value = (MessageContext) messageContexts.get(key);
String valueID;
if (value != null) {
valueID = value.getMessageID();
if (msgID.equals(valueID)) {
// update the entry
messageContexts.put(key, msg);
}
}
}
}
}
/**
* Get the name associated with the operation.
*
* @return The name String
*/
public String getOperationName() {
String opName = null;
if (axisOperation != null) {
QName qname = axisOperation.getName();
if (qname != null) {
opName = qname.getLocalPart();
}
}
return opName;
}
/**
* Get the name associated with the service.
*
* @return The name String
*/
public String getServiceName() {
String srvName = null;
ServiceContext sc = (ServiceContext) getParent();
if (sc == null) {
sc = metaParent;
}
if (sc != null) {
srvName = sc.getName();
}
return srvName;
}
/**
* Get the name associated with the service group.
*
* @return The name String
*/
public String getServiceGroupName() {
String srvGroupName = null;
ServiceContext sc = (ServiceContext) getParent();
if (sc == null) {
sc = metaParent;
}
if (sc != null) {
srvGroupName = sc.getGroupName();
}
return srvGroupName;
}
/**
* Compares key parts of the state from the current instance of
* this class with the specified instance to see if they are
* equivalent.
*
* This differs from the java.lang.Object.equals() method in
* that the equals() method generally looks at both the
* object identity (location in memory) and the object state
* (data).
*
*
* @param ctx The object to compare with
* @return TRUE if this object is equivalent with the specified object
* that is, key fields match
* FALSE, otherwise
*/
public boolean isEquivalent(OperationContext ctx) {
// NOTE: the input object is expected to exist (ie, be non-null)
if (this.isComplete != ctx.isComplete()) {
return false;
}
if (!this.axisOperation.equals(ctx.getAxisOperation())) {
return false;
}
// TODO: consider checking the parent objects for equivalency
// TODO: consider checking fields from the super class for equivalency
return true;
}
/**
* Get the ID associated with this object instance.
*
* @return A string that can be output to a log file as an identifier
* for this object instance. It is suitable for matching related log
* entries.
*/
public String getLogCorrelationIDString() {
if (logCorrelationIDString == null) {
logCorrelationIDString = myClassName + "@" + UUIDGenerator.getUUID();
}
return logCorrelationIDString;
}
public ConfigurationContext getRootContext() {
return this.getConfigurationContext();
}
}