/*
* 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.util.UIDGenerator;
import org.apache.axis2.AxisFault;
import org.apache.axis2.addressing.EndpointReference;
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.description.TransportInDescription;
import org.apache.axis2.engine.AxisConfiguration;
import org.apache.axis2.engine.ListenerManager;
import org.apache.axis2.i18n.Messages;
import org.apache.axis2.util.LoggingControl;
import org.apache.axis2.util.MetaDataEntry;
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.Map;
import java.util.HashMap;
/**
* Well this is never clearly defined, what it does or the life-cycle.
* So do NOT use this as it might not live up to your expectation.
*/
public class ServiceContext extends AbstractContext
implements Externalizable, SafeSerializable {
/*
* setup for logging
*/
private static final Log log = LogFactory.getLog(ServiceContext.class);
private static final String myClassName = "ServiceContext";
/**
* 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 = 8265625275015738957L;
/**
* @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;
public static final String SERVICE_OBJECT = "serviceObject";
private EndpointReference targetEPR;
private EndpointReference myEPR;
private transient AxisService axisService;
// the service group context is the same as the parent
private transient ServiceGroupContext serviceGroupContext;
private transient ConfigurationContext configContext;
/**
* Should we cache the last OperationContext?
*/
private boolean cachingOperationContext;
/**
* A cache for the last OperationContext
*/
private transient OperationContext lastOperationContext;
//----------------------------------------------------------------
// 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;
/**
* The AxisService metadata will be used during
* activate to match up with an existing object
*/
private transient MetaDataEntry metaAxisService = null;
/**
* The ServiceGroupContext object will be used during
* activate to finish its restoration
*/
private transient ServiceGroupContext metaParent = null;
//----------------------------------------------------------------
// end MetaData section
//----------------------------------------------------------------
/**
* Public constructor (only here because this class is Externalizable)
*/
public ServiceContext() {
}
/**
* Constructor (package access, should only be used by ServiceGroupContext)
*
* @param axisService the AxisService for which to create a context
* @param serviceGroupContext the parent ServiceGroupContext
*/
ServiceContext(AxisService axisService, ServiceGroupContext serviceGroupContext) {
super(serviceGroupContext);
this.serviceGroupContext = serviceGroupContext;
this.axisService = axisService;
this.configContext = (ConfigurationContext) parent.getParent();
}
public OperationContext createOperationContext(QName name) {
AxisOperation axisOp = axisService.getOperation(name);
return createOperationContext(axisOp);
}
public OperationContext createOperationContext(AxisOperation axisOp) {
OperationContext ctx = new OperationContext(axisOp, this);
configContext.contextCreated(ctx);
return ctx;
}
public AxisService getAxisService() {
checkActivateWarning("getAxisService");
return axisService;
}
public ConfigurationContext getConfigurationContext() {
checkActivateWarning("getConfigurationContext");
return configContext;
}
public ServiceGroupContext getServiceGroupContext() {
checkActivateWarning("getServiceGroupContext");
return serviceGroupContext;
}
/**
* To get the ERP for a given service , if the transport is present and not
* running then it will add as a listener to ListenerManager , there it will
* init that and start the listener , and finally ask the EPR from transport
* for a given service
*
* @param transport : Name of the transport
* @return
* @throws AxisFault
*/
public EndpointReference getMyEPR(String transport) throws AxisFault {
axisService.isEnableAllTransports();
ConfigurationContext configctx = this.configContext;
if (configctx != null) {
ListenerManager lm = configctx.getListenerManager();
if (!lm.isListenerRunning(transport)) {
TransportInDescription trsin =
configctx.getAxisConfiguration().getTransportIn(transport);
if (trsin != null) {
lm.addListener(trsin, false);
} else {
throw new AxisFault(Messages.getMessage("transportnotfound",
transport));
}
}
if (!lm.isStopped()) {
return lm.getEPRforService(axisService.getName(), null, transport);
}
}
return null;
}
public EndpointReference getTargetEPR() {
return targetEPR;
}
public void setTargetEPR(EndpointReference targetEPR) {
this.targetEPR = targetEPR;
}
public void setMyEPR(EndpointReference myEPR) {
this.myEPR = myEPR;
}
public OperationContext getLastOperationContext() {
return lastOperationContext;
}
public void setLastOperationContext(OperationContext lastOperationContext) {
this.lastOperationContext = lastOperationContext;
}
public boolean isCachingOperationContext() {
return cachingOperationContext;
}
public void setCachingOperationContext(boolean cacheLastOperationContext) {
this.cachingOperationContext = cacheLastOperationContext;
}
/**
* Returns a name associated with this ServiceContext.
* <p/>
* Note: this name is from the corresponding
* AxisService object.
*
* @return The name string, or null if no name can be found
*/
public String getName() {
if (axisService != null) {
return axisService.getName();
}
if (metaAxisService != null) {
return metaAxisService.getName();
}
return null;
}
/**
* Returns a name associated with the ServiceGroupContext
* associated with this ServiceContext.
*
* @return The name string, or null if no name can be found
*/
public String getGroupName() {
if (serviceGroupContext != null) {
return serviceGroupContext.getId();
}
if (metaParent != null) {
return metaParent.getId();
}
return null;
}
/* ===============================================================
* Externalizable support
* ===============================================================
*/
/**
* Save the contents of this object.
* <p/>
* 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(cachingOperationContext);
out.writeObject(getLogCorrelationIDString());
// EndpointReference targetEPR
out.writeObject(targetEPR);
// EndpointReference myEPR
out.writeObject(myEPR);
//---------------------------------------------------------
// properties
//---------------------------------------------------------
out.writeMap(getProperties());
//---------------------------------------------------------
// AxisService
//---------------------------------------------------------
metaAxisService = null;
if (axisService != null) {
String serviceAndPortNames = ActivateUtils.getAxisServiceExternalizeExtraName(axisService);
// If there is a service & port QName stored on the AxisService then write it out so
// it can be used during deserialization to hook up the message context to the
// correct AxisService.
metaAxisService =
new MetaDataEntry(axisService.getClass().getName(), axisService.getName(),
serviceAndPortNames);
}
out.writeObject(metaAxisService);
//---------------------------------------------------------
// parent
//---------------------------------------------------------
out.writeObject(getParent());
}
/**
* Restore the contents of the object that was previously saved.
* <p/>
* 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
if (LoggingControl.debugLoggingAllowed && log.isTraceEnabled()) {
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);
cachingOperationContext = in.readBoolean();
logCorrelationIDString = (String) in.readObject();
// trace point
if (LoggingControl.debugLoggingAllowed && log.isTraceEnabled()) {
log.trace(myClassName + ":readExternal(): reading input stream for [" +
getLogCorrelationIDString()+ "] ");
}
// EndpointReference targetEPR
targetEPR = (EndpointReference) in.readObject();
// EndpointReference myEPR
myEPR = (EndpointReference) in.readObject();
//---------------------------------------------------------
// properties
//---------------------------------------------------------
properties = in.readMap(new HashMap());
//---------------------------------------------------------
// AxisService
//---------------------------------------------------------
// axisService is not usable until the meta data has been reconciled
metaAxisService = (MetaDataEntry) in.readObject();
//---------------------------------------------------------
// parent
//---------------------------------------------------------
// ServiceGroupContext is not usable until it has been activated
metaParent = (ServiceGroupContext) in.readObject();
//---------------------------------------------------------
// other
//---------------------------------------------------------
// currently not saving this object
lastOperationContext = null;
//---------------------------------------------------------
// 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;
}
// use the supplied configuration context
configContext = cc;
// get the axis configuration
AxisConfiguration axisConfig = cc.getAxisConfiguration();
// We previously saved metaAxisService; restore it
axisService = null;
if (metaAxisService != null) {
axisService = ActivateUtils.findService(axisConfig, metaAxisService.getClassName(),
metaAxisService.getQNameAsString(),
metaAxisService.getExtraName());
}
// the parent ServiceGroupContext object was saved
// either use the restored object or sync up with
// an existing ServiceGroupContext object
if (metaParent != null) {
// find out if a copy of the ServiceGroupContext object exists on this
// engine where this ServiceContext is being restored/activated
// if so, use that object instead of the restored object
// in order to make sure that future changes to group-level
// properties are preserved for future operations
String groupName = metaParent.getId();
ServiceGroupContext existingSGC = cc.getServiceGroupContext(groupName);
if (existingSGC == null) {
// could not find an existing ServiceGroupContext
// use the restored object
metaParent.activate(cc);
// set parent
this.setParent(metaParent);
} else {
// switch over to the existing object
this.setParent(existingSGC);
// 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(existingSGC);
}
} else {
// set parent to null
this.setParent(metaParent);
}
// this is another pointer to our parent object
serviceGroupContext = (ServiceGroupContext) this.getParent();
if (serviceGroupContext != null) {
// add the service context to the table
serviceGroupContext.addServiceContext(this);
}
//-------------------------------------------------------
// done, reset the flag
//-------------------------------------------------------
needsToBeReconciled = false;
// make sure this restored object is in the parent's list
if (metaParent != null) {
// make sure this restored object is in the parent's list
metaParent.addServiceContext(this);
}
}
/**
* This will do a copy of the properties from this context object
* to the properties of the specified context object.
*
* @param context The ServiceContext object to hold the merged properties
* @param doParentProperties Indicates whether to go up the context hierachy
* copy the properties at each level
*/
public void putContextProperties(ServiceContext context, boolean doParentProperties) {
if (context != null) {
// get the current properties on this context object
Map<String, Object> props = getProperties();
// copy them to the specified context object
context.mergeProperties(props);
if (doParentProperties) {
ServiceGroupContext mySGC = null;
if (serviceGroupContext != null) {
mySGC = serviceGroupContext;
} else if (metaParent != null) {
mySGC = metaParent;
}
if (mySGC != null) {
ServiceGroupContext sgc = context.getServiceGroupContext();
mySGC.putContextProperties(sgc);
}
}
}
}
/**
* 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 + "@" + UIDGenerator.generateUID();
}
return logCorrelationIDString;
}
/**
* Trace a warning message, if needed, indicating that this
* object needs to be activated before accessing certain fields.
*
* @param methodname The method where the warning occurs
*/
private void checkActivateWarning(String methodname) {
if (needsToBeReconciled) {
if (LoggingControl.debugLoggingAllowed && log.isDebugEnabled()) {
log.debug(getLogCorrelationIDString()+ ":" + methodname + "(): ****WARNING**** "
+ myClassName + ".activate(configurationContext) needs to be invoked.");
}
}
}
public ConfigurationContext getRootContext() {
return configContext;
}
}