Java tutorial
/* * 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.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.util.MetaDataEntry; 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.LinkedHashMap; /** * Provides tests that focus on the message context object graph */ public class MessageContextSaveCTest extends TestCase { protected static final Log log = LogFactory.getLog(MessageContextSaveCTest.class); private File persistentStore = null; //------------------------------------------------------------------------- // variables for the object graph //------------------------------------------------------------------------- // used on a save of a message context, uses the same setup // as the regular top-level objects. the difference is that // the phase contains handlers that split the action across // two handlers private ConfigurationContext saveConfigurationContext = null; private AxisConfiguration saveAxisConfiguration = null; // used on a restore of a message context, uses the same setup // as the regular top-level objects with the exception that the // context objects don't exist. also, the phase contains handlers // that split the action across two handlers private ConfigurationContext restoreConfigurationContext = null; private AxisConfiguration restoreAxisConfiguration = null; // used on a restore of a message context, uses the same setup // as the regular top-level objects with service-level context objects // with the name service name. also, the phase contains handlers // that split the action across two handlers private ConfigurationContext equivConfigurationContext = null; private AxisConfiguration equivAxisConfiguration = null; //------------------------------ // service group ABC //------------------------------ private String serviceGroupName_ABC = "ABCServiceGroup"; private String serviceName_A = "ServiceA"; private String serviceName_B = "ServiceB"; private String serviceName_C = "ServiceC"; private QName service_QName_A = new QName(serviceName_A); private QName service_QName_B = new QName(serviceName_B); private QName service_QName_C = new QName(serviceName_C); private String operationName_A1 = "TestOperationA1"; private String operationName_A2 = "TestOperationA2"; private QName operation_QName_A1 = new QName(operationName_A1); private QName operation_QName_A2 = new QName(operationName_A2); private ServiceGroupContext srvGrpCtx_ABC_save = null; private AxisServiceGroup axisSrvGrp_ABC_save = null; private AxisServiceGroup axisSrvGrp_ABC_restore = null; private ServiceGroupContext srvGrpCtx_ABC_equiv = null; private AxisServiceGroup axisSrvGrp_ABC_equiv = null; private ServiceContext srvCtx_A_save = null; private ServiceContext srvCtx_B_save = null; private ServiceContext srvCtx_C_save = null; private AxisService axisSrv_A_save = null; private AxisService axisSrv_B_save = null; private AxisService axisSrv_C_save = null; private ServiceContext srvCtx_A_restore = null; private ServiceContext srvCtx_B_restore = null; private ServiceContext srvCtx_C_restore = null; private AxisService axisSrv_A_restore = null; private AxisService axisSrv_B_restore = null; private AxisService axisSrv_C_restore = null; private ServiceContext srvCtx_A_equiv = null; private ServiceContext srvCtx_B_equiv = null; private ServiceContext srvCtx_C_equiv = null; private AxisService axisSrv_A_equiv = null; private AxisService axisSrv_B_equiv = null; private AxisService axisSrv_C_equiv = null; private OperationContext opCtx_A1_save = null; private OperationContext opCtx_A2_save = null; private AxisOperation axisOp_A1_save = null; private AxisOperation axisOp_A2_save = null; private OperationContext opCtx_A1_restore = null; private OperationContext opCtx_A2_restore = null; private AxisOperation axisOp_A1_restore = null; private AxisOperation axisOp_A2_restore = null; private OperationContext opCtx_A1_equiv = null; private OperationContext opCtx_A2_equiv = null; private AxisOperation axisOp_A1_equiv = null; private AxisOperation axisOp_A2_equiv = null; private MessageContext msgCtx_A1_1_save = null; private MessageContext msgCtx_A1_2_save = null; private MessageContext msgCtx_A2_save = null; private MessageContext msgCtx_A1_1_equiv = null; private MessageContext msgCtx_A1_2_equiv = null; private MessageContext msgCtx_A2_equiv = null; //------------------------------------- // objects needed for message context //------------------------------------ private TransportOutDescription transportOut = null; private TransportOutDescription transportOut2 = null; private TransportOutDescription transportOut3 = null; private TransportInDescription transportIn = null; private TransportInDescription transportIn2 = null; private TransportInDescription transportIn3 = null; private Phase phaseSave = null; private Phase phaseRestore = null; private Phase phaseEquiv = null; private ArrayList executedHandlers = null; private MessageContext restoredMessageContext = null; //------------------------------------------------------------------------- // methods //------------------------------------------------------------------------- public MessageContextSaveCTest(String arg0) { super(arg0); try { prepare(); } catch (Exception e) { log.debug("MessageContextSaveCTest:constructor: error in setting up object graph [" + e.getClass().getName() + " : " + e.getMessage() + "]"); } } // // prepare the object hierarchy for testing // private void prepare() throws Exception { //----------------------------------------------------------------- // setup the top-level objects //----------------------------------------------------------------- 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); saveAxisConfiguration = new AxisConfiguration(); saveConfigurationContext = new ConfigurationContext(saveAxisConfiguration); saveConfigurationContext.getAxisConfiguration().addMessageReceiver("http://www.w3.org/2004/08/wsdl/in-only", new RawXMLINOnlyMessageReceiver()); saveConfigurationContext.getAxisConfiguration().addMessageReceiver("http://www.w3.org/2004/08/wsdl/in-out", new RawXMLINOutMessageReceiver()); saveConfigurationContext.getAxisConfiguration().getInFlowPhases().add(dispatchPhase); restoreAxisConfiguration = new AxisConfiguration(); restoreConfigurationContext = new ConfigurationContext(restoreAxisConfiguration); restoreConfigurationContext.getAxisConfiguration() .addMessageReceiver("http://www.w3.org/2004/08/wsdl/in-only", new RawXMLINOnlyMessageReceiver()); restoreConfigurationContext.getAxisConfiguration() .addMessageReceiver("http://www.w3.org/2004/08/wsdl/in-out", new RawXMLINOutMessageReceiver()); restoreConfigurationContext.getAxisConfiguration().getInFlowPhases().add(dispatchPhase); equivAxisConfiguration = new AxisConfiguration(); equivConfigurationContext = new ConfigurationContext(equivAxisConfiguration); equivConfigurationContext.getAxisConfiguration() .addMessageReceiver("http://www.w3.org/2004/08/wsdl/in-only", new RawXMLINOnlyMessageReceiver()); equivConfigurationContext.getAxisConfiguration().addMessageReceiver("http://www.w3.org/2004/08/wsdl/in-out", new RawXMLINOutMessageReceiver()); equivConfigurationContext.getAxisConfiguration().getInFlowPhases().add(dispatchPhase); //---------------------------- // transport-related objects //---------------------------- transportOut = new TransportOutDescription("null"); transportOut2 = new TransportOutDescription("happy"); transportOut3 = new TransportOutDescription("golucky"); transportOut.setSender(new CommonsHTTPTransportSender()); transportOut2.setSender(new CommonsHTTPTransportSender()); transportOut3.setSender(new CommonsHTTPTransportSender()); saveAxisConfiguration.addTransportOut(transportOut3); saveAxisConfiguration.addTransportOut(transportOut2); saveAxisConfiguration.addTransportOut(transportOut); restoreAxisConfiguration.addTransportOut(transportOut3); restoreAxisConfiguration.addTransportOut(transportOut2); restoreAxisConfiguration.addTransportOut(transportOut); equivAxisConfiguration.addTransportOut(transportOut3); equivAxisConfiguration.addTransportOut(transportOut2); equivAxisConfiguration.addTransportOut(transportOut); transportIn = new TransportInDescription("null"); transportIn2 = new TransportInDescription("always"); transportIn3 = new TransportInDescription("thebest"); transportIn.setReceiver(new SimpleHTTPServer()); transportIn2.setReceiver(new SimpleHTTPServer()); transportIn3.setReceiver(new SimpleHTTPServer()); saveAxisConfiguration.addTransportIn(transportIn2); saveAxisConfiguration.addTransportIn(transportIn); saveAxisConfiguration.addTransportIn(transportIn3); restoreAxisConfiguration.addTransportIn(transportIn2); restoreAxisConfiguration.addTransportIn(transportIn); restoreAxisConfiguration.addTransportIn(transportIn3); equivAxisConfiguration.addTransportIn(transportIn2); equivAxisConfiguration.addTransportIn(transportIn); equivAxisConfiguration.addTransportIn(transportIn3); //---------------------------- // phase-related objects //---------------------------- persistentStore = File.createTempFile("mcObjTest", null); phaseSave = new Phase("PhaseTest"); phaseSave.addHandler(new TempHandler(1, 1)); phaseSave.addHandler(new SaveHandler(2, persistentStore, true)); phaseSave.addHandler(new TempHandler(3, 1)); ArrayList phases_Save = new ArrayList(); phases_Save.add(phaseSave); saveAxisConfiguration.setInPhasesUptoAndIncludingPostDispatch(phases_Save); phaseRestore = new Phase("PhaseTest"); phaseRestore.addHandler(new TempHandler(1, 1)); phaseRestore.addHandler(new SaveHandler(2, persistentStore, false)); phaseRestore.addHandler(new TempHandler(3, 1)); ArrayList phases_Restore = new ArrayList(); phases_Restore.add(phaseRestore); restoreAxisConfiguration.setInPhasesUptoAndIncludingPostDispatch(phases_Restore); phaseEquiv = new Phase("PhaseTest"); phaseEquiv.addHandler(new TempHandler(1, 1)); phaseEquiv.addHandler(new SaveHandler(2, persistentStore, true)); phaseEquiv.addHandler(new TempHandler(3, 1)); ArrayList phases_Equiv = new ArrayList(); phases_Equiv.add(phaseEquiv); equivAxisConfiguration.setInPhasesUptoAndIncludingPostDispatch(phases_Equiv); //----------------------------------------------------------------- // setup the axis side of the hierachy //----------------------------------------------------------------- // ABC group //---------------------------- axisSrvGrp_ABC_save = new AxisServiceGroup(saveAxisConfiguration); axisSrvGrp_ABC_save.setServiceGroupName(serviceGroupName_ABC); axisSrv_A_save = new AxisService(service_QName_A.getLocalPart()); axisSrv_B_save = new AxisService(service_QName_B.getLocalPart()); axisSrv_C_save = new AxisService(service_QName_C.getLocalPart()); axisSrvGrp_ABC_save.addService(axisSrv_A_save); axisSrvGrp_ABC_save.addService(axisSrv_B_save); axisSrvGrp_ABC_save.addService(axisSrv_C_save); axisOp_A1_save = new InOutAxisOperation(operation_QName_A1); axisOp_A2_save = new InOutAxisOperation(operation_QName_A2); axisOp_A1_save.setMessageReceiver(new MessageReceiver() { public void receive(MessageContext messageCtx) { } }); axisOp_A2_save.setMessageReceiver(new MessageReceiver() { public void receive(MessageContext messageCtx) { } }); axisSrv_A_save.addOperation(axisOp_A1_save); axisSrv_A_save.mapActionToOperation(operation_QName_A1.getLocalPart(), axisOp_A1_save); axisSrv_A_save.addOperation(axisOp_A2_save); axisSrv_A_save.mapActionToOperation(operation_QName_A2.getLocalPart(), axisOp_A2_save); saveAxisConfiguration.addService(axisSrv_A_save); saveAxisConfiguration.addService(axisSrv_B_save); saveAxisConfiguration.addService(axisSrv_C_save); //--------------------- axisSrvGrp_ABC_restore = new AxisServiceGroup(restoreAxisConfiguration); axisSrvGrp_ABC_restore.setServiceGroupName(serviceGroupName_ABC); axisSrv_A_restore = new AxisService(service_QName_A.getLocalPart()); axisSrv_B_restore = new AxisService(service_QName_B.getLocalPart()); axisSrv_C_restore = new AxisService(service_QName_C.getLocalPart()); axisSrvGrp_ABC_restore.addService(axisSrv_A_restore); axisSrvGrp_ABC_restore.addService(axisSrv_B_restore); axisSrvGrp_ABC_restore.addService(axisSrv_C_restore); axisOp_A1_restore = new InOutAxisOperation(operation_QName_A1); axisOp_A2_restore = new InOutAxisOperation(operation_QName_A2); axisOp_A1_restore.setMessageReceiver(new MessageReceiver() { public void receive(MessageContext messageCtx) { } }); axisOp_A2_restore.setMessageReceiver(new MessageReceiver() { public void receive(MessageContext messageCtx) { } }); axisSrv_A_restore.addOperation(axisOp_A1_restore); axisSrv_A_restore.mapActionToOperation(operation_QName_A1.getLocalPart(), axisOp_A1_restore); axisSrv_A_restore.addOperation(axisOp_A2_restore); axisSrv_A_restore.mapActionToOperation(operation_QName_A2.getLocalPart(), axisOp_A2_restore); restoreAxisConfiguration.addService(axisSrv_A_restore); restoreAxisConfiguration.addService(axisSrv_B_restore); restoreAxisConfiguration.addService(axisSrv_C_restore); axisOp_A1_save.getRemainingPhasesInFlow().add(phaseSave); axisOp_A2_save.getRemainingPhasesInFlow().add(phaseSave); axisOp_A1_restore.getRemainingPhasesInFlow().add(phaseRestore); axisOp_A2_restore.getRemainingPhasesInFlow().add(phaseRestore); //------------------------------- axisSrvGrp_ABC_equiv = new AxisServiceGroup(equivAxisConfiguration); axisSrvGrp_ABC_equiv.setServiceGroupName(serviceGroupName_ABC); axisSrv_A_equiv = new AxisService(service_QName_A.getLocalPart()); axisSrv_B_equiv = new AxisService(service_QName_B.getLocalPart()); axisSrv_C_equiv = new AxisService(service_QName_C.getLocalPart()); axisSrvGrp_ABC_equiv.addService(axisSrv_A_equiv); axisSrvGrp_ABC_equiv.addService(axisSrv_B_equiv); axisSrvGrp_ABC_equiv.addService(axisSrv_C_equiv); axisOp_A1_equiv = new InOutAxisOperation(operation_QName_A1); axisOp_A2_equiv = new InOutAxisOperation(operation_QName_A2); axisOp_A1_equiv.setMessageReceiver(new MessageReceiver() { public void receive(MessageContext messageCtx) { } }); axisOp_A2_equiv.setMessageReceiver(new MessageReceiver() { public void receive(MessageContext messageCtx) { } }); axisSrv_A_equiv.addOperation(axisOp_A1_equiv); axisSrv_A_equiv.mapActionToOperation(operation_QName_A1.getLocalPart(), axisOp_A1_equiv); axisSrv_A_equiv.addOperation(axisOp_A2_equiv); axisSrv_A_equiv.mapActionToOperation(operation_QName_A2.getLocalPart(), axisOp_A2_equiv); equivAxisConfiguration.addService(axisSrv_A_equiv); equivAxisConfiguration.addService(axisSrv_B_equiv); equivAxisConfiguration.addService(axisSrv_C_equiv); //----------------------------------------------------------------- // setup the context objects //----------------------------------------------------------------- srvGrpCtx_ABC_save = saveConfigurationContext.createServiceGroupContext(axisSrvGrp_ABC_save); srvGrpCtx_ABC_save.setId(serviceGroupName_ABC); srvCtx_A_save = srvGrpCtx_ABC_save.getServiceContext(axisSrv_A_save); srvCtx_B_save = srvGrpCtx_ABC_save.getServiceContext(axisSrv_B_save); srvCtx_C_save = srvGrpCtx_ABC_save.getServiceContext(axisSrv_C_save); opCtx_A1_save = srvCtx_A_save.createOperationContext(operation_QName_A1); opCtx_A2_save = srvCtx_A_save.createOperationContext(operation_QName_A2); //---------------------------------------- srvGrpCtx_ABC_equiv = equivConfigurationContext.createServiceGroupContext(axisSrvGrp_ABC_equiv); srvGrpCtx_ABC_equiv.setId(serviceGroupName_ABC); srvCtx_A_equiv = srvGrpCtx_ABC_equiv.getServiceContext(axisSrv_A_equiv); srvCtx_B_equiv = srvGrpCtx_ABC_equiv.getServiceContext(axisSrv_B_equiv); srvCtx_C_equiv = srvGrpCtx_ABC_equiv.getServiceContext(axisSrv_C_equiv); opCtx_A1_equiv = srvCtx_A_equiv.createOperationContext(operation_QName_A1); opCtx_A2_equiv = srvCtx_A_equiv.createOperationContext(operation_QName_A2); //---------------------------------------- // message context objects //---------------------------------------- msgCtx_A1_1_save = createMessageContext(opCtx_A1_save, saveConfigurationContext, MessageContext.IN_FLOW); msgCtx_A1_2_save = createMessageContext(opCtx_A1_save, saveConfigurationContext, MessageContext.OUT_FLOW); msgCtx_A2_save = createMessageContext(opCtx_A2_save, saveConfigurationContext, MessageContext.IN_FLOW); msgCtx_A1_1_equiv = createMessageContext(opCtx_A1_equiv, equivConfigurationContext, MessageContext.IN_FLOW); msgCtx_A1_2_equiv = createMessageContext(opCtx_A1_equiv, equivConfigurationContext, MessageContext.OUT_FLOW); msgCtx_A2_equiv = createMessageContext(opCtx_A2_equiv, equivConfigurationContext, MessageContext.IN_FLOW); //----------------------------------------------------------------- // other objects //----------------------------------------------------------------- executedHandlers = new ArrayList(); } private MessageContext createMessageContext(OperationContext oc, ConfigurationContext cc, int flowType) throws Exception { MessageContext mc = cc.createMessageContext(); mc.setFLOW(flowType); mc.setTransportIn(transportIn); mc.setTransportOut(transportOut); mc.setServerSide(true); // mc.setProperty(MessageContext.TRANSPORT_OUT, System.out); SOAPFactory omFac = OMAbstractFactory.getSOAP11Factory(); mc.setEnvelope(omFac.getDefaultEnvelope()); AxisOperation axisOperation = oc.getAxisOperation(); String action = axisOperation.getName().getLocalPart(); mc.setSoapAction(action); // System.out.flush(); mc.setMessageID(UUIDGenerator.getUUID()); axisOperation.registerOperationContext(mc, oc); mc.setOperationContext(oc); ServiceContext sc = oc.getServiceContext(); mc.setServiceContext(sc); mc.setTo(new EndpointReference("axis2/services/NullService")); mc.setWSAAction("DummyOp"); AxisMessage axisMessage = axisOperation.getMessage(WSDLConstants.MESSAGE_LABEL_IN_VALUE); mc.setAxisMessage(axisMessage); return mc; } protected void setUp() throws Exception { //org.apache.log4j.BasicConfigurator.configure(); } public void testHierarchyNewContext() throws Exception { String title = "MessageContextSaveCTest:testHierarchyNewContext(): "; MessageContext mc = msgCtx_A1_2_save; OperationContext oc = mc.getOperationContext(); log.debug(title + "*** Original OperationContext message context table ****"); showMCTable(oc); // run the message through the message processing // this causes the message context to get saved log.debug(title + "- - - Save the message context from the engine - - - -"); AxisEngine.receive(mc); LinkedHashMap original_object_graph = getObjectGraphInfo(mc); log.debug(title + "*** Originial object graph ****"); showObjectGraphInfo(original_object_graph); log.debug( title + "- - - Restore the message context on a separate engine - - - - - - - - - - - - - - - -"); MessageContext mc2 = restoreMessageContext(persistentStore, restoreConfigurationContext); LinkedHashMap restored_object_graph = getObjectGraphInfo(mc2); log.debug(title + "*** Restored object graph ****"); showObjectGraphInfo(restored_object_graph); OperationContext oc2 = mc2.getOperationContext(); log.debug(title + "*** Restored OperationContext message context table ****"); showMCTable(oc2); boolean mcTableMatch = compareMCTable(oc, oc2); assertTrue(mcTableMatch); // resume the restored paused message context on an engine that has the // same setup as the engine where the save occurred // but doesn't have the Context objects log.debug(title + "- - - Resume the restored message context - - - - - - - - - - - - - - - -"); AxisEngine.resume(mc2); LinkedHashMap resumed_object_graph = getObjectGraphInfo(mc2); log.debug(title + "*** Post Resumed object graph ****"); showObjectGraphInfo(resumed_object_graph); // compare object hashcodes - expect differences boolean expectFalse = compareObjectGraphInfo(original_object_graph, restored_object_graph, true); assertFalse(expectFalse); boolean expectSameObjectIds = compareObjectGraphInfo(original_object_graph, restored_object_graph, false); assertTrue(expectSameObjectIds); boolean isSame = compareObjectGraphInfo(restored_object_graph, resumed_object_graph, false); assertTrue(isSame); } public void testHierarchyReuse() throws Exception { String title = "MessageContextSaveCTest:testHierarchyReuse(): "; MessageContext mc = msgCtx_A1_1_save; // run the message through the message processing // this causes the message context to get saved log.debug(title + "- - - Save the message context from the engine - - - -"); AxisEngine.receive(mc); LinkedHashMap original_object_graph = getObjectGraphInfo(mc); log.debug(title + "*** Originial object graph ****"); showObjectGraphInfo(original_object_graph); log.debug( title + "- - - Restore the message context on a separate engine - - - - - - - - - - - - - - - -"); MessageContext mc2 = restoreMessageContext(persistentStore, equivConfigurationContext); LinkedHashMap restored_object_graph = getObjectGraphInfo(mc2); log.debug(title + "*** Restored object graph ****"); showObjectGraphInfo(restored_object_graph); // we don't use strict checking here since the engine where the // restoration takes place is a "copy", ie, there are new objects // for the same names/identifications boolean hasEquivalence = compareObjectGraphInfo(original_object_graph, restored_object_graph, false); assertTrue(hasEquivalence); // get an object graph from an equivalent message context on the separate engine // we would expect a strict match of the object graphs between the // restored message context and the message context on the separate engine LinkedHashMap separate_object_graph = getObjectGraphInfo(msgCtx_A1_1_equiv); // compare the restored object graph with the existing object graph boolean expectStrict = compareObjectGraphInfo(restored_object_graph, separate_object_graph, true); assertTrue(expectStrict); // resume the restored paused message context on an engine that has the // same setup as the engine where the save occurred // and save has the Service-level Context objects log.debug(title + "- - - Resume the restored message context - - - - - - - - - - - - - - - -"); AxisEngine.resume(mc2); LinkedHashMap resumed_object_graph = getObjectGraphInfo(mc2); log.debug(title + "*** Post Resumed object graph ****"); showObjectGraphInfo(resumed_object_graph); // there should be no changes in the object graph in our case after the resume hasEquivalence = compareObjectGraphInfo(restored_object_graph, resumed_object_graph, true); assertTrue(hasEquivalence); } /** * Restores a previously saved message context */ public MessageContext restoreMessageContext(File restoreFile, ConfigurationContext cc) { String title = "restoreMessageContext(): "; MessageContext restoredMC = null; File theFile = restoreFile; String theFilename = null; // the configuration context to use for message context activation ConfigurationContext cfgCtx = cc; boolean restoredOk = false; if ((theFile != null) && (theFile.exists())) { theFilename = theFile.getName(); log.debug(title + "temp file = [" + theFilename + "]"); // --------------------------------------------------------- // 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....."); restoredOk = false; MessageContext msgContext2 = (MessageContext) inObjStream.readObject(); inObjStream.close(); inStream.close(); msgContext2.activate(cfgCtx); restoredOk = true; log.debug(title + "....restored message context....."); // now put the restored message context in the global // variable for the test restoredMC = msgContext2; } catch (Exception ex2) { log.debug(title + "error with restoring message context = [" + ex2.getClass().getName() + " : " + ex2.getMessage() + "]"); ex2.printStackTrace(); restoredMessageContext = null; } assertTrue(restoredOk); // if the restore of the message context succeeded, // then don't keep the temporary file around boolean removeTmpFile = restoredOk; if (removeTmpFile) { try { theFile.delete(); } catch (Exception e) { // just absorb it } } } return restoredMC; } private LinkedHashMap getObjectGraphInfo(MessageContext msgCtx) { if (msgCtx == null) { return null; } MetaDataEntry metaMC = null; MetaDataEntry metaOC = null; MetaDataEntry metaSC = null; MetaDataEntry metaSGC = null; MetaDataEntry metaCC = null; MetaDataEntry metaAO = null; MetaDataEntry metaAS = null; MetaDataEntry metaASG = null; MetaDataEntry metaAC = null; String keyMC = null; String keyOC = null; String keySC = null; String keySGC = null; String keyCC = null; String keyAO = null; String keyAS = null; String keyASG = null; String keyAC = null; LinkedHashMap objInfo = new LinkedHashMap(); // get the identification info about the primary objects in the object graph // class name // name string // hashcode string // message context keyMC = msgCtx.getClass().getName(); metaMC = new MetaDataEntry(keyMC, msgCtx.getMessageID(), "[" + msgCtx.hashCode() + "]"); objInfo.put(keyMC, metaMC); // operation context OperationContext oc = msgCtx.getOperationContext(); keyOC = oc.getClass().getName(); metaOC = new MetaDataEntry(keyOC, oc.getOperationName(), "[" + oc.hashCode() + "]"); objInfo.put(keyOC, metaOC); // service context ServiceContext sc = msgCtx.getServiceContext(); keySC = sc.getClass().getName(); metaSC = new MetaDataEntry(keySC, sc.getName(), "[" + sc.hashCode() + "]"); objInfo.put(keySC, metaSC); // service group context ServiceGroupContext sgc = msgCtx.getServiceGroupContext(); keySGC = sgc.getClass().getName(); metaSGC = new MetaDataEntry(keySGC, sgc.getId(), "[" + sgc.hashCode() + "]"); objInfo.put(keySGC, metaSGC); // configuration context ConfigurationContext cc = msgCtx.getConfigurationContext(); keyCC = cc.getClass().getName(); metaCC = new MetaDataEntry(keyCC, null, "[" + cc.hashCode() + "]"); objInfo.put(keyCC, metaCC); // axis operation AxisOperation ao = msgCtx.getAxisOperation(); keyAO = ao.getClass().getName(); metaAO = new MetaDataEntry(keyAO, ao.getName().toString(), "[" + ao.hashCode() + "]"); objInfo.put(keyAO, metaAO); // axis service AxisService as = msgCtx.getAxisService(); keyAS = as.getClass().getName(); metaAS = new MetaDataEntry(keyAS, as.getName(), "[" + as.hashCode() + "]"); objInfo.put(keyAS, metaAS); // axis service group AxisServiceGroup asg = msgCtx.getAxisServiceGroup(); keyASG = asg.getClass().getName(); metaASG = new MetaDataEntry(keyASG, asg.getServiceGroupName(), "[" + asg.hashCode() + "]"); objInfo.put(keyASG, metaASG); // axis configuration AxisConfiguration ac = cc.getAxisConfiguration(); keyAC = ac.getClass().getName(); metaAC = new MetaDataEntry(keyAC, null, "[" + ac.hashCode() + "]"); objInfo.put(keyAC, metaAC); return objInfo; } /** * Compare two mappings containing object graph info. * This uses the class name and object ID. * <p/> * Strict comparison includes the object hash codes. If * you expect the same object to be represented in * both maps, you may want to use Strict checking. * <p/> * * @param map1 The first object graph info map * @param map2 The second object graph info map * @param strict TRUE if strict comparison * @return Outcome of the comparison: TRUE if equivalent, FALSE otherwise */ private boolean compareObjectGraphInfo(LinkedHashMap map1, LinkedHashMap map2, boolean strict) { String title = "MessageContextSaveCTest: compareObjectGraphInfo(): "; if ((map1 != null) && (map2 != null)) { if (map1.size() != map2.size()) { log.debug(title + "Object graph info mappings are different sizes."); return false; } Iterator it = map1.keySet().iterator(); while (it.hasNext()) { // the key is the class name associated with the object String key = (String) it.next(); // skip certain objects, those will always be unique if ((key.indexOf("MessageContext") == -1) && (key.indexOf("OperationContext") == -1) && (key.indexOf("ConfigurationContext") == -1) && (key.indexOf("AxisConfiguration") == -1)) { // the class names listed above were not found // so we're dealing with the other objects MetaDataEntry value1 = (MetaDataEntry) map1.get(key); MetaDataEntry value2 = (MetaDataEntry) map2.get(key); if ((value1 != null) && (value2 != null)) { // check the object identification String name1 = value1.getName(); String name2 = value2.getName(); if ((name1 != null) && (name2 != null)) { if (name1.equals(name2) == false) { log.debug(title + "name1 [" + name1 + "] != name2 [" + name2 + "]"); return false; } } else if ((name1 == null) && (name2 == null)) { // ok } else { // mismatch log.debug(title + "name1 [" + name1 + "] != name2 [" + name2 + "]"); return false; } // Strict testing means checking the object hashcodes. // Use this option when you expect the same // objects in the map. if (strict) { String code1 = value1.getExtraName(); String code2 = value2.getExtraName(); if ((code1 != null) && (code2 != null)) { if (code1.equals(code2) == false) { log.debug(title + "name [" + name1 + "] code1 [" + code1 + "] != code2 [" + code2 + "]"); return false; } } else if ((code1 == null) && (code2 == null)) { // ok } else { // mismatch log.debug(title + "name [" + name1 + "]code1 [" + code1 + "] != code2 [" + code2 + "]"); return false; } } } else if ((value1 == null) && (value2 == null)) { // ok } else { // mismatch log.debug(title + "value1 [" + value1 + "] != value2 [" + value2 + "]"); return false; } } } return true; } else if ((map1 == null) && (map2 == null)) { return true; } else { log.debug(title + "mismatch: one or more of the maps are null. "); return false; } } private void showObjectGraphInfo(LinkedHashMap map) { if (map == null) { return; } Iterator it = map.keySet().iterator(); while (it.hasNext()) { String metaClassName = (String) it.next(); MetaDataEntry meta = (MetaDataEntry) map.get(metaClassName); if (meta != null) { String classname = meta.getClassName(); String name = meta.getName(); String hashcode = meta.getExtraName(); log.debug("class[" + classname + "] id[" + name + "] hashcode" + hashcode + " "); } } } private boolean compareMCTable(OperationContext oc1, OperationContext oc2) { String title = "compareMCTable: "; if ((oc1 != null) && (oc2 != null)) { HashMap mcTable1 = oc1.getMessageContexts(); HashMap mcTable2 = oc2.getMessageContexts(); if ((mcTable1 != null) && (mcTable2 != null)) { if ((!mcTable1.isEmpty()) && (!mcTable2.isEmpty())) { int size1 = mcTable1.size(); int size2 = mcTable2.size(); if (size1 != size2) { log.debug(title + " Return FALSE: table sizes don't match size1[" + size1 + "] != size2 [" + size2 + "] "); return false; } Iterator it1 = mcTable1.keySet().iterator(); while (it1.hasNext()) { String key1 = (String) it1.next(); MessageContext mc1 = (MessageContext) mcTable1.get(key1); MessageContext mc2 = (MessageContext) mcTable2.get(key1); if ((mc1 != null) && (mc2 != null)) { // check the IDs String id1 = mc1.getMessageID(); String id2 = mc2.getMessageID(); if ((id1 != null) && (id2 != null)) { if (!id1.equals(id2)) { log.debug(title + " Return FALSE: message IDs don't match id1[" + id1 + "] != id2 [" + id2 + "] "); return false; } } else if ((id1 == null) && (id2 == null)) { // can't tell, keep going } else { // mismatch log.debug(title + " Return FALSE: message IDs don't match id1[" + id1 + "] != id2 [" + id2 + "] "); return false; } } else if ((mc1 == null) && (mc2 == null)) { // entries match } else { // mismatch log.debug(title + " Return FALSE: message context objects don't match "); return false; } } log.debug(title + " Return TRUE: message context tables match"); return true; } else if (mcTable1.isEmpty() && mcTable2.isEmpty()) { log.debug(title + " Return TRUE: message context tables are both empty "); return true; } else { log.debug(title + " Return FALSE: message context tables mismatch"); return false; } } else if ((mcTable1 == null) && (mcTable2 == null)) { log.debug(title + " Return TRUE: message context tables are null"); return true; } else { log.debug(title + " Return FALSE: message context tables don't match"); return false; } } else if ((oc1 == null) && (oc2 == null)) { log.debug(title + " Return TRUE: operation context objects are null "); return true; } else { log.debug(title + " Return FALSE: operation context objects don't match "); return false; } } private void showMCTable(OperationContext oc) { if (oc == null) { return; } HashMap mcTable = oc.getMessageContexts(); if ((mcTable == null) || (mcTable.isEmpty())) { return; } Iterator it = mcTable.keySet().iterator(); while (it.hasNext()) { String key = (String) it.next(); MessageContext mc = (MessageContext) mcTable.get(key); if (mc != null) { String id = mc.getMessageID(); log.debug("message context table entry: label [" + key + "] message ID [" + id + "] "); } } } /** * 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; } //========================================================================= // Handler classes //========================================================================= /** * Pauses and saves the message context the message context */ public class SaveHandler extends AbstractHandler { private Integer handlerID = null; private File theFile = null; private String theFilename = null; private boolean performSave = true; private boolean savedOk = false; //----------------------------------------------------------------- // constructors //----------------------------------------------------------------- public SaveHandler() { this.handlerID = new Integer(-5); } public SaveHandler(int index, File saveFile, boolean doIt) { this.handlerID = new Integer(index); init(new HandlerDescription(new String("handler" + index))); theFile = saveFile; performSave = doIt; } //----------------------------------------------------------------- // methods //----------------------------------------------------------------- public int getHandlerID() { if (handlerID != null) { return handlerID.intValue(); } return -5; } public InvocationResponse invoke(MessageContext msgContext) throws AxisFault { String title = "SaveHandler[" + getHandlerID() + "]:invoke(): "; savedOk = false; if (performSave == false) { log.debug(title + "Configured for no action to be performed."); return InvocationResponse.CONTINUE; } log.debug(title + "msgContext.pause()"); msgContext.pause(); if (theFile != null) { try { log.debug(title + "Resetting the file to use."); theFile.delete(); theFile.createNewFile(); theFilename = theFile.getName(); log.debug(title + "temp file = [" + theFilename + "]"); } catch (Exception ex) { log.debug(title + "error creating new file = [" + ex.getMessage() + "]"); } if (theFile.exists() == true) { // --------------------------------------------------------- // 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....."); savedOk = false; outObjStream.writeObject(msgContext); // close out the streams outObjStream.flush(); outObjStream.close(); outStream.flush(); outStream.close(); savedOk = 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(savedOk); } } log.debug(title + "executedHandlers.add(" + handlerID + ")"); executedHandlers.add(handlerID); return InvocationResponse.SUSPEND; } } public class TempHandler extends AbstractHandler { private Integer handlerID = null; private int count = 0; private int numberProperties = 3; private String propertyKey = "Property"; private String propertyValue = "ServiceLevelSetting"; //----------------------------------------------------------------- // constructors //----------------------------------------------------------------- public TempHandler() { this.handlerID = new Integer(-5); } public TempHandler(int index) { this.handlerID = new Integer(index); init(new HandlerDescription(new String("handler" + index))); } public TempHandler(int index, int number) { this.handlerID = new Integer(index); init(new HandlerDescription(new String("handler" + index))); numberProperties = number; } //----------------------------------------------------------------- // methods //----------------------------------------------------------------- public int getHandlerID() { if (handlerID != null) { return handlerID.intValue(); } return -5; } public InvocationResponse invoke(MessageContext msgContext) throws AxisFault { String title = "TempHandler[" + getHandlerID() + "]:invoke(): "; // get the service context from the message context ServiceContext serviceContext = msgContext.getServiceContext(); if (serviceContext == null) { // get the service context from the operation context OperationContext operationContext = msgContext.getOperationContext(); serviceContext = operationContext.getServiceContext(); } if (serviceContext != null) { for (int j = 0; j < numberProperties; j++) { count++; String key = new String(propertyKey + ".ID[" + getHandlerID() + "]." + count); String value = new String(propertyValue + "[" + count + "]"); serviceContext.setProperty(key, value); } } log.debug(title + "executedHandlers.add(" + handlerID + ")"); executedHandlers.add(handlerID); return InvocationResponse.CONTINUE; } } }