/*
* 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.engine;
import junit.framework.TestCase;
import org.apache.axiom.om.OMAbstractFactory;
import org.apache.axiom.om.util.UUIDGenerator;
import org.apache.axiom.soap.SOAPFactory;
import org.apache.axis2.AxisFault;
import org.apache.axis2.addressing.EndpointReference;
import org.apache.axis2.context.ConfigurationContext;
import org.apache.axis2.context.MessageContext;
import org.apache.axis2.context.OperationContext;
import org.apache.axis2.context.ServiceContext;
import org.apache.axis2.context.ServiceGroupContext;
import org.apache.axis2.context.externalize.ActivateUtils;
import org.apache.axis2.description.AxisMessage;
import org.apache.axis2.description.AxisOperation;
import org.apache.axis2.description.AxisService;
import org.apache.axis2.description.AxisServiceGroup;
import org.apache.axis2.description.HandlerDescription;
import org.apache.axis2.description.InOutAxisOperation;
import org.apache.axis2.description.TransportInDescription;
import org.apache.axis2.description.TransportOutDescription;
import org.apache.axis2.dispatchers.AddressingBasedDispatcher;
import org.apache.axis2.dispatchers.RequestURIBasedDispatcher;
import org.apache.axis2.dispatchers.SOAPActionBasedDispatcher;
import org.apache.axis2.dispatchers.SOAPMessageBodyBasedDispatcher;
import org.apache.axis2.handlers.AbstractHandler;
import org.apache.axis2.receivers.RawXMLINOnlyMessageReceiver;
import org.apache.axis2.receivers.RawXMLINOutMessageReceiver;
import org.apache.axis2.transport.http.CommonsHTTPTransportSender;
import org.apache.axis2.transport.http.SimpleHTTPServer;
import org.apache.axis2.wsdl.WSDLConstants;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import javax.xml.namespace.QName;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
public class MessageContextSaveATest extends TestCase {
protected static final Log log = LogFactory.getLog(MessageContextSaveATest.class);
private QName serviceName = new QName("TestService");
private QName operationName = new QName("Operation_1");
private ConfigurationContext configurationContext = null;
private ServiceGroupContext serviceGroupContext = null;
private OperationContext operationContext = null;
private AxisServiceGroup axisServiceGroup = null;
private AxisService axisService = null;
private AxisOperation axisOperation = null;
private AxisMessage axisMessage = null;
private Phase phase1 = null;
private Phase phase2 = null;
private Phase phase3 = null;
private Phase phase4 = null;
private Phase phase5 = null;
private Phase phase6 = null;
private Phase phase7 = null;
private MessageContext mc = null;
private MessageContext mc2 = null;
private ArrayList executedHandlers = null;
public MessageContextSaveATest(String arg0) {
super(arg0);
try {
prepare();
}
catch (Exception e) {
log.debug("MessageContextSaveATest:constructor: error in setting up object graph [" +
e.getClass().getName() + " : " + e.getMessage() + "]");
}
}
//
// prepare the object hierarchy for testing
//
private void prepare() throws Exception {
//-----------------------------------------------------------------
AxisConfiguration axisConfiguration = new AxisConfiguration();
configurationContext = new ConfigurationContext(axisConfiguration);
configurationContext.getAxisConfiguration().addMessageReceiver(
"http://www.w3.org/2004/08/wsdl/in-only", new RawXMLINOnlyMessageReceiver());
configurationContext.getAxisConfiguration().addMessageReceiver(
"http://www.w3.org/2004/08/wsdl/in-out", new RawXMLINOutMessageReceiver());
DispatchPhase dispatchPhase = new DispatchPhase();
dispatchPhase.setName("Dispatch");
AddressingBasedDispatcher abd = new AddressingBasedDispatcher();
abd.initDispatcher();
RequestURIBasedDispatcher rud = new RequestURIBasedDispatcher();
rud.initDispatcher();
SOAPActionBasedDispatcher sabd = new SOAPActionBasedDispatcher();
sabd.initDispatcher();
SOAPMessageBodyBasedDispatcher smbd = new SOAPMessageBodyBasedDispatcher();
smbd.initDispatcher();
dispatchPhase.addHandler(abd);
dispatchPhase.addHandler(rud);
dispatchPhase.addHandler(sabd);
dispatchPhase.addHandler(smbd);
configurationContext.getAxisConfiguration().getInFlowPhases().add(dispatchPhase);
//-----------------------------------------------------------------
axisServiceGroup = new AxisServiceGroup(axisConfiguration);
axisServiceGroup.setServiceGroupName("ServiceGroupTest");
axisService = new AxisService(serviceName.getLocalPart());
axisServiceGroup.addService(axisService);
axisOperation = new InOutAxisOperation(operationName);
axisOperation.setMessageReceiver(new MessageReceiver() {
public void receive(MessageContext messageCtx) {
}
});
axisService.addOperation(axisOperation);
axisService.mapActionToOperation(operationName.getLocalPart(), axisOperation);
configurationContext.getAxisConfiguration().addService(axisService);
//-----------------------------------------------------------------
serviceGroupContext = configurationContext.
createServiceGroupContext(axisService.getAxisServiceGroup());
serviceGroupContext.setId("ServiceGroupContextTest");
ServiceContext serviceContext = serviceGroupContext.getServiceContext(axisService);
operationContext = serviceContext.createOperationContext(operationName);
//-----------------------------------------------------------------
TransportOutDescription transportOut = new TransportOutDescription("null");
TransportOutDescription transportOut2 = new TransportOutDescription("happy");
TransportOutDescription transportOut3 = new TransportOutDescription("golucky");
transportOut.setSender(new CommonsHTTPTransportSender());
transportOut2.setSender(new CommonsHTTPTransportSender());
transportOut3.setSender(new CommonsHTTPTransportSender());
axisConfiguration.addTransportOut(transportOut3);
axisConfiguration.addTransportOut(transportOut2);
axisConfiguration.addTransportOut(transportOut);
TransportInDescription transportIn = new TransportInDescription("null");
TransportInDescription transportIn2 = new TransportInDescription("always");
TransportInDescription transportIn3 = new TransportInDescription("thebest");
transportIn.setReceiver(new SimpleHTTPServer());
transportIn2.setReceiver(new SimpleHTTPServer());
transportIn3.setReceiver(new SimpleHTTPServer());
axisConfiguration.addTransportIn(transportIn2);
axisConfiguration.addTransportIn(transportIn);
axisConfiguration.addTransportIn(transportIn3);
//-----------------------------------------------------------------
mc = configurationContext.createMessageContext();
mc.setTransportIn(transportIn);
mc.setTransportOut(transportOut);
mc.setServerSide(true);
// mc.setProperty(MessageContext.TRANSPORT_OUT, System.out);
SOAPFactory omFac = OMAbstractFactory.getSOAP11Factory();
mc.setEnvelope(omFac.getDefaultEnvelope());
phase1 = new Phase("beginPhase1");
phase1.addHandler(new TempHandler(1));
phase1.addHandler(new TempHandler(2));
phase1.addHandler(new TempHandler(3));
phase1.addHandler(new TempHandler(4));
phase1.addHandler(new TempHandler(5));
phase1.addHandler(new TempHandler(6));
phase1.addHandler(new TempHandler(7));
phase1.addHandler(new TempHandler(8));
phase1.addHandler(new TempHandler(9));
phase2 = new Phase("middlePhase2");
phase2.addHandler(new TempHandler(10));
phase2.addHandler(new TempHandler(11));
phase2.addHandler(new TempHandler(12));
phase2.addHandler(new TempHandler(13));
phase2.addHandler(new TempHandler(14));
phase2.addHandler(new TempHandler(15, true));
phase2.addHandler(new TempHandler(16));
phase2.addHandler(new TempHandler(17));
phase2.addHandler(new TempHandler(18));
phase3 = new Phase("lastPhase3");
phase3.addHandler(new TempHandler(19));
phase3.addHandler(new TempHandler(20));
phase3.addHandler(new TempHandler(21));
phase3.addHandler(new TempHandler(22));
phase3.addHandler(new TempHandler(23));
phase3.addHandler(new TempHandler(24));
phase3.addHandler(new TempHandler(25));
phase3.addHandler(new TempHandler(26));
phase3.addHandler(new TempHandler(27));
phase4 = new Phase("extraPhase1");
phase4.addHandler(new TempHandler(28));
phase4.addHandler(new TempHandler(29));
phase5 = new Phase("extraPhase2");
phase5.addHandler(new TempHandler(30));
phase6 = new Phase("extraPhase3");
phase6.addHandler(new TempHandler(31, true));
phase6.addHandler(new TempHandler(32));
phase7 = new Phase("extraPhase4");
phase7.addHandler(new TempHandler(33));
phase7.addHandler(new TempHandler(34));
phase7.addHandler(new TempHandler(35));
axisOperation.getRemainingPhasesInFlow().add(phase1);
axisOperation.getRemainingPhasesInFlow().add(phase2);
axisOperation.getRemainingPhasesInFlow().add(phase3);
axisOperation.getRemainingPhasesInFlow().add(phase4);
axisOperation.getRemainingPhasesInFlow().add(phase5);
axisOperation.getRemainingPhasesInFlow().add(phase6);
axisOperation.getRemainingPhasesInFlow().add(phase7);
ArrayList phases = new ArrayList();
phases.add(phase1);
phases.add(phase2);
phases.add(phase3);
phases.add(phase4);
phases.add(phase5);
phases.add(phase6);
phases.add(phase7);
axisConfiguration.setInPhasesUptoAndIncludingPostDispatch(phases);
mc.setWSAAction(operationName.getLocalPart());
mc.setSoapAction(operationName.getLocalPart());
// System.out.flush();
mc.setMessageID(UUIDGenerator.getUUID());
//operationContext.addMessageContext(mc); gets done via the register
axisOperation.registerOperationContext(mc, operationContext);
mc.setOperationContext(operationContext);
mc.setServiceContext(serviceContext);
mc.setTo(new EndpointReference("axis2/services/NullService"));
mc.setWSAAction("DummyOp");
axisMessage = axisOperation.getMessage(WSDLConstants.MESSAGE_LABEL_IN_VALUE);
mc.setAxisMessage(axisMessage);
//-----------------------------------------------------------------
executedHandlers = new ArrayList();
}
protected void setUp() throws Exception {
//org.apache.log4j.BasicConfigurator.configure();
}
public void testReceive() throws Exception {
AxisEngine engine = new AxisEngine(configurationContext);
log.debug(
"MessageContextSaveATest:testReceive(): start - - engine.receive(mc) - - - - - - - - - - - - - - - -");
engine.receive(mc);
log.debug(
"MessageContextSaveATest:testReceive(): resume - - engine.resume(mc) - - - - - - - - - - - - - - - -");
engine.resume(mc);
assertEquals(30, executedHandlers.size());
for (int i = 15; i < 30; i++) {
assertEquals(((Integer) executedHandlers.get(i)).intValue(), i + 1);
}
// get the phase lists and see if they match up
ArrayList restoredPhases = mc2.getExecutionChain();
int it_count = 0;
Iterator it = restoredPhases.iterator();
while (it.hasNext()) {
// we know everything at this level is a Phase.
// if you change it, you might get a ClassCastException
Phase restored_phase = (Phase) it.next();
Phase original_phase = null;
it_count++;
if (it_count == 1) {
original_phase = phase1;
} else if (it_count == 2) {
original_phase = phase2;
} else if (it_count == 3) {
original_phase = phase3;
} else if (it_count == 4) {
original_phase = phase4;
} else if (it_count == 5) {
original_phase = phase5;
} else if (it_count == 6) {
original_phase = phase6;
} else if (it_count == 7) {
original_phase = phase7;
} else {
// unexpected
assertTrue(false);
}
boolean isOk = comparePhases(restored_phase, original_phase);
assertTrue(isOk);
}
// -------------------------------------------------------------------
// second resume to start the second pause
// -------------------------------------------------------------------
log.debug(
"MessageContextSaveATest:testReceive(): resume - - engine.resume(mc) - - - - - - - - - - - - - - - -");
engine.resume(mc);
assertEquals(35, executedHandlers.size());
for (int i = 31; i < 35; i++) {
assertEquals(((Integer) executedHandlers.get(i)).intValue(), i + 1);
}
// get the phase lists and see if they match up
restoredPhases = mc2.getExecutionChain();
it_count = 0;
it = restoredPhases.iterator();
while (it.hasNext()) {
// we know everything at this level is a Phase.
// if you change it, you might get a ClassCastException
Phase restored_phase = (Phase) it.next();
Phase original_phase = null;
it_count++;
if (it_count == 1) {
original_phase = phase1;
} else if (it_count == 2) {
original_phase = phase2;
} else if (it_count == 3) {
original_phase = phase3;
} else if (it_count == 4) {
original_phase = phase4;
} else if (it_count == 5) {
original_phase = phase5;
} else if (it_count == 6) {
original_phase = phase6;
} else if (it_count == 7) {
original_phase = phase7;
} else {
// unexpected
assertTrue(false);
}
boolean isOk = comparePhases(restored_phase, original_phase);
assertTrue(isOk);
}
}
/**
* Gets the ID associated with the handler object.
*
* @param o The handler object
* @return The ID associated with the handler,
* -1 otherwise
*/
private int getHandlerID(Object o) {
int id = -1;
if (o instanceof TempHandler) {
id = ((TempHandler) o).getHandlerID();
}
return id;
}
/**
* Check the handler objects to see if they are equivalent.
*
* @param o1 The first handler
* @param o2 The second handler
* @return TRUE if the handler objects are equivalent,
* FALSE otherwise
*/
private boolean compareHandlers(Object o1, Object o2) {
if ((o1 == null) && (o2 == null)) {
return true;
}
if ((o1 != null) && (o2 != null)) {
String c1 = o1.getClass().getName();
String c2 = o2.getClass().getName();
if (c1.equals(c2)) {
log.debug("MessageContextSaveATest::compareHandlers: class [" + c1 + "] match ");
int id1 = getHandlerID(o1);
int id2 = getHandlerID(o2);
if (id1 == id2) {
log.debug("MessageContextSaveATest::compareHandlers: id [" + id1 + "] match");
return true;
} else {
log.debug("MessageContextSaveATest::compareHandlers: id1 [" + id1 +
"] != id2 [" + id2 + "] ");
return false;
}
} else {
log.debug("MessageContextSaveATest::compareHandlers: class1 [" + c1 +
"] != class2 [" + c2 + "] ");
return false;
}
}
return false;
}
/**
* Compare two phases.
*
* @param o1 The first phase object
* @param o2 The second phase object
* @return TRUE if the phases are equivalent,
* FALSE otherwise
*/
private boolean comparePhases(Object o1, Object o2) {
if ((o1 == null) && (o2 == null)) {
log.debug(
"MessageContextSaveATest: comparePhases: Phase1[] == Phase2[] - both null objects");
return true;
}
if (((o1 != null) && (o2 != null))
&& ((o1 instanceof Phase) && (o2 instanceof Phase))
) {
try {
Phase p1 = (Phase) o1;
Phase p2 = (Phase) o2;
String name1 = p1.getName();
String name2 = p2.getName();
List list1 = p1.getHandlers();
List list2 = p2.getHandlers();
if ((list1 == null) && (list2 == null)) {
log.debug("MessageContextSaveATest: comparePhases: Phase1[" + name1 +
"] == Phase2[" + name2 + "]");
return true;
}
if ((list1 != null) && (list2 != null)) {
int size1 = list1.size();
int size2 = list2.size();
if (size1 != size2) {
log.debug("MessageContextSaveATest: comparePhases: Phase1[" +
name1 + "] != Phase2[" + name2 +
"] - mismatched size of handler lists");
return false;
}
for (int j = 0; j < size1; j++) {
Object obj1 = list1.get(j);
Object obj2 = list2.get(j);
if ((obj1 == null) && (obj2 == null)) {
// ok
} else if ((obj1 != null) && (obj2 != null)) {
boolean check;
if (obj1 instanceof Phase) {
check = comparePhases(obj1, obj2);
} else {
// must be a handler
check = compareHandlers(obj1, obj2);
}
if (!check) {
log.debug(
"MessageContextSaveATest: comparePhases: Phase1[" + name1 +
"] != Phase2[" + name2 +
"] - mismatched handler lists");
return false;
}
} else {
// mismatch
log.debug("MessageContextSaveATest: comparePhases: Phase1[" +
name1 + "] != Phase2[" + name2 +
"] - mismatched handler lists");
return false;
}
}
// if we got here, the comparison completed ok
// with a match
log.debug("MessageContextSaveATest: comparePhases: Phase1[" + name1 +
"] == Phase2[" + name2 + "] - matched handler lists");
return true;
}
}
catch (Exception e) {
// some error
e.printStackTrace();
}
}
log.debug("MessageContextSaveATest: comparePhases: Phase1[] != Phase2[]");
return false;
}
private void showMcMap(HashMap map) {
if ((map != null) && (!map.isEmpty())) {
Iterator itList = map.keySet().iterator();
while (itList.hasNext()) {
String key = (String) itList.next();
MessageContext value = (MessageContext) map.get(key);
String valueID = null;
if (value != null) {
valueID = value.getMessageID();
log.debug(
"MessageContextSaveATest: showMcMap: Message context ID[" + valueID +
"] Key Label [" + key + "]");
}
}
} else {
log.debug(
"MessageContextSaveATest: showMcMap: No entries to display for message contexts table.");
}
}
// this checks the save/restore of a message context that hasn't been
// through the engine to simulate what some WS-RM implementations
// need to do - make a simple message context for a RM ack or other
// simple message
public void testSimpleMC() throws Exception {
String title = "MessageContextSaveATest:testSimpleMC(): ";
log.debug(title + "start - - - - - - - - - - - - - - - -");
MessageContext simpleMsg = new MessageContext();
MessageContext restoredSimpleMsg = null;
File theFile = null;
String theFilename = null;
boolean savedMessageContext = false;
boolean restoredMessageContext = false;
boolean comparesOk = false;
try {
theFile = File.createTempFile("Simple", null);
theFilename = theFile.getName();
log.debug(title + "temp file = [" + theFilename + "]");
}
catch (Exception ex) {
log.debug(title + "error creating temp file = [" + ex.getMessage() + "]");
theFile = null;
}
if (theFile != null) {
// ---------------------------------------------------------
// save to the temporary file
// ---------------------------------------------------------
try {
// setup an output stream to a physical file
FileOutputStream outStream = new FileOutputStream(theFile);
// attach a stream capable of writing objects to the
// stream connected to the file
ObjectOutputStream outObjStream = new ObjectOutputStream(outStream);
// try to save the message context
log.debug(title + "saving message context.....");
savedMessageContext = false;
outObjStream.writeObject(simpleMsg);
// close out the streams
outObjStream.flush();
outObjStream.close();
outStream.flush();
outStream.close();
savedMessageContext = true;
log.debug(title + "....saved message context.....");
long filesize = theFile.length();
log.debug(title + "file size after save [" + filesize +
"] temp file = [" + theFilename + "]");
}
catch (Exception ex2) {
log.debug(title + "error with saving message context = [" +
ex2.getClass().getName() + " : " + ex2.getMessage() + "]");
ex2.printStackTrace();
}
assertTrue(savedMessageContext);
// ---------------------------------------------------------
// restore from the temporary file
// ---------------------------------------------------------
try {
// setup an input stream to the file
FileInputStream inStream = new FileInputStream(theFile);
// attach a stream capable of reading objects from the
// stream connected to the file
ObjectInputStream inObjStream = new ObjectInputStream(inStream);
// try to restore the message context
log.debug(title + "restoring a message context.....");
restoredMessageContext = false;
restoredSimpleMsg = (MessageContext) inObjStream.readObject();
inObjStream.close();
inStream.close();
restoredSimpleMsg.activate(configurationContext);
restoredMessageContext = true;
log.debug(title + "....restored message context.....");
// compare to original execution chain
ArrayList restored_execChain = restoredSimpleMsg.getExecutionChain();
ArrayList orig_execChain = simpleMsg.getExecutionChain();
comparesOk =
ActivateUtils.isEquivalent(restored_execChain, orig_execChain, false);
log.debug(title + "execution chain equivalency [" + comparesOk + "]");
assertTrue(comparesOk);
// check executed list
Iterator restored_executed_it = restoredSimpleMsg.getExecutedPhases();
Iterator orig_executed_it = simpleMsg.getExecutedPhases();
if ((restored_executed_it != null) && (orig_executed_it != null)) {
while (restored_executed_it.hasNext() && orig_executed_it.hasNext()) {
Object p1 = restored_executed_it.next();
Object p2 = orig_executed_it.next();
comparesOk = comparePhases(p1, p2);
log.debug(title + "executed phase list: compare phases [" +
comparesOk + "]");
assertTrue(comparesOk);
}
} else {
// problem with the executed lists
assertTrue(false);
}
}
catch (Exception ex2) {
log.debug(title + "error with saving message context = [" +
ex2.getClass().getName() + " : " + ex2.getMessage() + "]");
ex2.printStackTrace();
}
assertTrue(restoredMessageContext);
// if the save/restore of the message context succeeded,
// then don't keep the temporary file around
boolean removeTmpFile = savedMessageContext && restoredMessageContext && comparesOk;
if (removeTmpFile) {
try {
theFile.delete();
}
catch (Exception e) {
// just absorb it
}
}
}
log.debug(title + "end - - - - - - - - - - - - - - - -");
}
// this checks the save/restore of a message context that has
// some properties set
public void testMcProperties() throws Exception {
String title = "MessageContextSaveATest:testMcProperties(): ";
log.debug(title + "start - - - - - - - - - - - - - - - -");
MessageContext simpleMsg = new MessageContext();
MessageContext restoredSimpleMsg = null;
simpleMsg.setProperty("key1", "value1");
simpleMsg.setProperty("key2", null);
simpleMsg.setProperty("key3", new Integer(3));
simpleMsg.setProperty("key4", new Long(4L));
File theFile = null;
String theFilename = null;
boolean pause = false;
boolean savedMessageContext = false;
boolean restoredMessageContext = false;
boolean comparesOk = false;
try {
theFile = File.createTempFile("McProps", null);
theFilename = theFile.getName();
log.debug(title + "temp file = [" + theFilename + "]");
}
catch (Exception ex) {
log.debug(title + "error creating temp file = [" + ex.getMessage() + "]");
theFile = null;
}
if (theFile != null) {
// ---------------------------------------------------------
// save to the temporary file
// ---------------------------------------------------------
try {
// setup an output stream to a physical file
FileOutputStream outStream = new FileOutputStream(theFile);
// attach a stream capable of writing objects to the
// stream connected to the file
ObjectOutputStream outObjStream = new ObjectOutputStream(outStream);
// try to save the message context
log.debug(title + "saving message context.....");
savedMessageContext = false;
outObjStream.writeObject(simpleMsg);
// close out the streams
outObjStream.flush();
outObjStream.close();
outStream.flush();
outStream.close();
savedMessageContext = true;
log.debug(title + "....saved message context.....");
long filesize = theFile.length();
log.debug(title + "file size after save [" + filesize +
"] temp file = [" + theFilename + "]");
}
catch (Exception ex2) {
log.debug(title + "error with saving message context = [" +
ex2.getClass().getName() + " : " + ex2.getMessage() + "]");
ex2.printStackTrace();
}
assertTrue(savedMessageContext);
// ---------------------------------------------------------
// restore from the temporary file
// ---------------------------------------------------------
try {
// setup an input stream to the file
FileInputStream inStream = new FileInputStream(theFile);
// attach a stream capable of reading objects from the
// stream connected to the file
ObjectInputStream inObjStream = new ObjectInputStream(inStream);
// try to restore the message context
log.debug(title + "restoring a message context.....");
restoredMessageContext = false;
restoredSimpleMsg = (MessageContext) inObjStream.readObject();
inObjStream.close();
inStream.close();
restoredSimpleMsg.activate(configurationContext);
restoredMessageContext = true;
log.debug(title + "....restored message context.....");
// compare to original execution chain
ArrayList restored_execChain = restoredSimpleMsg.getExecutionChain();
ArrayList orig_execChain = simpleMsg.getExecutionChain();
comparesOk =
ActivateUtils.isEquivalent(restored_execChain, orig_execChain, false);
log.debug(title + "execution chain equivalency [" + comparesOk + "]");
assertTrue(comparesOk);
// check executed list
Iterator restored_executed_it = restoredSimpleMsg.getExecutedPhases();
Iterator orig_executed_it = simpleMsg.getExecutedPhases();
if ((restored_executed_it != null) && (orig_executed_it != null)) {
while (restored_executed_it.hasNext() && orig_executed_it.hasNext()) {
Object p1 = restored_executed_it.next();
Object p2 = orig_executed_it.next();
comparesOk = comparePhases(p1, p2);
log.debug(title + "executed phase list: compare phases [" +
comparesOk + "]");
assertTrue(comparesOk);
}
} else {
// problem with the executed lists
assertTrue(false);
}
// check the properties
String value1 = (String) restoredSimpleMsg.getProperty("key1");
Object value2 = restoredSimpleMsg.getProperty("key2");
Integer value3 = (Integer) restoredSimpleMsg.getProperty("key3");
Long value4 = (Long) restoredSimpleMsg.getProperty("key4");
assertEquals("value1", value1);
assertNull(value2);
boolean isOk = false;
if ((value3 != null) && value3.equals(new Integer(3))) {
isOk = true;
}
assertTrue(isOk);
if ((value4 != null) && value4.equals(new Long(4L))) {
isOk = true;
}
assertTrue(isOk);
}
catch (Exception ex2) {
log.debug(title + "error with restoring message context = [" +
ex2.getClass().getName() + " : " + ex2.getMessage() + "]");
ex2.printStackTrace();
}
assertTrue(restoredMessageContext);
// if the save/restore of the message context succeeded,
// then don't keep the temporary file around
boolean removeTmpFile = savedMessageContext && restoredMessageContext && comparesOk;
if (removeTmpFile) {
try {
theFile.delete();
}
catch (Exception e) {
// just absorb it
}
}
}
log.debug(title + "end - - - - - - - - - - - - - - - -");
}
public void testMapping() throws Exception {
String title = "MessageContextSaveATest:testMapping(): ";
log.debug(title + "start - - - - - - - - - - - - - - - -");
MessageContext restoredMC = null;
//---------------------------------------------------------------------
// make sure that the operation context messageContexts table
// has an entry for the message context that we working with
//---------------------------------------------------------------------
// look at the OperationContext messageContexts table
HashMap mcMap1 = mc.getOperationContext().getMessageContexts();
if ((mcMap1 == null) || (mcMap1.isEmpty())) {
mc.getAxisOperation().addMessageContext(mc, mc.getOperationContext());
}
// update the table
mcMap1 = mc.getOperationContext().getMessageContexts();
log.debug(title + "- - - - - original message contexts table- - - - - - - - - - -");
showMcMap(mcMap1);
//---------------------------------------------------------------------
// save and restore the message context
//---------------------------------------------------------------------
File theFile;
String theFilename = null;
boolean pause = false;
boolean savedMessageContext = false;
boolean restoredMessageContext = false;
boolean comparesOk = false;
try {
theFile = File.createTempFile("McMappings", null);
theFilename = theFile.getName();
log.debug(title + "temp file = [" + theFilename + "]");
}
catch (Exception ex) {
log.debug(title + "error creating temp file = [" + ex.getMessage() + "]");
theFile = null;
}
if (theFile != null) {
// ---------------------------------------------------------
// save to the temporary file
// ---------------------------------------------------------
try {
// setup an output stream to a physical file
FileOutputStream outStream = new FileOutputStream(theFile);
// attach a stream capable of writing objects to the
// stream connected to the file
ObjectOutputStream outObjStream = new ObjectOutputStream(outStream);
// try to save the message context
log.debug(title + "saving message context.....");
savedMessageContext = false;
outObjStream.writeObject(mc);
// close out the streams
outObjStream.flush();
outObjStream.close();
outStream.flush();
outStream.close();
savedMessageContext = true;
log.debug(title + "....saved message context.....");
long filesize = theFile.length();
log.debug(title + "file size after save [" + filesize +
"] temp file = [" + theFilename + "]");
}
catch (Exception ex2) {
log.debug(title + "error with saving message context = [" +
ex2.getClass().getName() + " : " + ex2.getMessage() + "]");
ex2.printStackTrace();
}
assertTrue(savedMessageContext);
// ---------------------------------------------------------
// restore from the temporary file
// ---------------------------------------------------------
try {
// setup an input stream to the file
FileInputStream inStream = new FileInputStream(theFile);
// attach a stream capable of reading objects from the
// stream connected to the file
ObjectInputStream inObjStream = new ObjectInputStream(inStream);
// try to restore the message context
log.debug(title + "restoring a message context.....");
restoredMessageContext = false;
restoredMC = (MessageContext) inObjStream.readObject();
inObjStream.close();
inStream.close();
restoredMC.activate(configurationContext);
restoredMessageContext = true;
log.debug(title + "....restored message context.....");
// get the table after the restore
HashMap mcMap2 = restoredMC.getOperationContext().getMessageContexts();
log.debug(
"MessageContextSaveATest:testMapping(): - - - - - restored message contexts table- - - - - - - - - - -");
showMcMap(mcMap2);
boolean okMap = compareMCMaps(mcMap1, mcMap2);
assertTrue(okMap);
}
catch (Exception ex2) {
log.debug(title + "error with restoring message context = [" +
ex2.getClass().getName() + " : " + ex2.getMessage() + "]");
ex2.printStackTrace();
}
assertTrue(restoredMessageContext);
// if the save/restore of the message context succeeded,
// then don't keep the temporary file around
boolean removeTmpFile = savedMessageContext && restoredMessageContext && comparesOk;
if (removeTmpFile) {
try {
theFile.delete();
}
catch (Exception e) {
// just absorb it
}
}
}
log.debug(title + "end - - - - - - - - - - - - - - - -");
}
private boolean compareMCMaps(HashMap m1, HashMap m2) {
String title = "MessageContextSaveATest:compareMCMaps(): ";
if ((m1 != null) && (m2 != null)) {
int size1 = m1.size();
int size2 = m2.size();
if (size1 != size2) {
log.debug(title + "MISMATCH: map1 size [" + size1 +
"] != map2 size [" + size2 + "]");
return false;
}
String id1 = null;
String id2 = null;
// check the keys, ordering is not important between the two maps
Iterator it1 = m1.keySet().iterator();
while (it1.hasNext()) {
String key1 = (String) it1.next();
MessageContext value1 = (MessageContext) m1.get(key1);
if (value1 != null) {
id1 = value1.getMessageID();
MessageContext value2 = (MessageContext) m2.get(key1);
if (value2 != null) {
id2 = value2.getMessageID();
} else {
// mismatch
log.debug(title +
"MISMATCH: no message context in one of the tables for key [" +
key1 + "]");
return false;
}
if ((id1 != null) && (id2 != null)) {
if (!id1.equals(id2)) {
// mismatch
log.debug(title + "MISMATCH: messageID_1 [" + id1 +
"] != messageID_2 [" + id2 + "]");
return false;
}
} else {
// null values, can't tell
log.debug(title + "MISMATCH: one or more null message IDs");
return false;
}
}
}
return true;
} else if ((m1 == null) && (m2 == null)) {
return true;
} else {
// mismatch
log.debug(title + "MISMATCH: one of the tables is null");
return false;
}
}
public class TempHandler extends AbstractHandler {
private Integer handlerID = null;
private File theFile = null;
private String theFilename = null;
private boolean pause = false;
private boolean savedMessageContext = false;
private boolean restoredMessageContext = false;
private boolean comparesOk = false;
//-----------------------------------------------------------------
// constructors
//-----------------------------------------------------------------
public TempHandler() {
this.handlerID = new Integer(-5);
}
public TempHandler(int index, boolean pause) {
this.handlerID = new Integer(index);
this.pause = pause;
init(new HandlerDescription("handler" + index));
}
public TempHandler(int index) {
this.handlerID = new Integer(index);
init(new HandlerDescription("handler" + index));
}
//-----------------------------------------------------------------
// methods
//-----------------------------------------------------------------
public int getHandlerID() {
if (handlerID != null) {
return handlerID.intValue();
}
return -5;
}
public InvocationResponse invoke(MessageContext msgContext) throws AxisFault {
String title = "TempHandler[" + getHandlerID() + "]:invoke(): ";
log.debug(title + "pause = [" + pause + "]");
savedMessageContext = false;
restoredMessageContext = false;
if (pause) {
log.debug(title + "msgContext.pause()");
msgContext.pause();
pause = false;
try {
theFile = File.createTempFile("mcSave", null);
theFilename = theFile.getName();
log.debug(title + "temp file = [" + theFilename + "]");
}
catch (Exception ex) {
log.debug(title + "error creating temp file = [" + ex.getMessage() + "]");
theFile = null;
}
if (theFile != null) {
// ---------------------------------------------------------
// save to the temporary file
// ---------------------------------------------------------
try {
// setup an output stream to a physical file
FileOutputStream outStream = new FileOutputStream(theFile);
// attach a stream capable of writing objects to the
// stream connected to the file
ObjectOutputStream outObjStream = new ObjectOutputStream(outStream);
// try to save the message context
log.debug(title + "saving message context.....");
savedMessageContext = false;
outObjStream.writeObject(msgContext);
// close out the streams
outObjStream.flush();
outObjStream.close();
outStream.flush();
outStream.close();
savedMessageContext = true;
log.debug(title + "....saved message context.....");
long filesize = theFile.length();
log.debug(title + "file size after save [" + filesize +
"] temp file = [" + theFilename + "]");
}
catch (Exception ex2) {
log.debug(title + "error with saving message context = [" +
ex2.getClass().getName() + " : " + ex2.getMessage() + "]");
ex2.printStackTrace();
}
assertTrue(savedMessageContext);
// ---------------------------------------------------------
// restore from the temporary file
// ---------------------------------------------------------
try {
// setup an input stream to the file
FileInputStream inStream = new FileInputStream(theFile);
// attach a stream capable of reading objects from the
// stream connected to the file
ObjectInputStream inObjStream = new ObjectInputStream(inStream);
// try to restore the message context
log.debug(title + "restoring a message context.....");
restoredMessageContext = false;
MessageContext msgContext2 = (MessageContext) inObjStream.readObject();
inObjStream.close();
inStream.close();
msgContext2.activate(configurationContext);
restoredMessageContext = true;
log.debug(title + "....restored message context.....");
// compare to original execution chain
ArrayList restored_execChain = msgContext2.getExecutionChain();
ArrayList orig_execChain = msgContext.getExecutionChain();
comparesOk = ActivateUtils
.isEquivalent(restored_execChain, orig_execChain, false);
log.debug(title + "execution chain equivalency [" + comparesOk + "]");
assertTrue(comparesOk);
// check executed list
Iterator restored_executed_it = msgContext2.getExecutedPhases();
Iterator orig_executed_it = msgContext.getExecutedPhases();
if ((restored_executed_it != null) && (orig_executed_it != null)) {
while (restored_executed_it.hasNext() && orig_executed_it.hasNext()) {
Object p1 = restored_executed_it.next();
Object p2 = orig_executed_it.next();
comparesOk = comparePhases(p1, p2);
log.debug(title +
"executed phase list: compare phases [" + comparesOk +
"]");
assertTrue(comparesOk);
}
} else {
// problem with the executed lists
assertTrue(false);
}
// now put the restored message context in the global
// variable for the test
mc2 = msgContext2;
}
catch (Exception ex2) {
log.debug(title + "error with saving message context = [" +
ex2.getClass().getName() + " : " + ex2.getMessage() + "]");
ex2.printStackTrace();
}
assertTrue(restoredMessageContext);
// if the save/restore of the message context succeeded,
// then don't keep the temporary file around
boolean removeTmpFile =
savedMessageContext && restoredMessageContext && comparesOk;
if (removeTmpFile) {
try {
theFile.delete();
}
catch (Exception e) {
// just absorb it
}
}
}
return InvocationResponse.SUSPEND;
} else {
log.debug(title + "executedHandlers.add(" + handlerID + ")");
executedHandlers.add(handlerID);
}
return InvocationResponse.CONTINUE;
}
}
}