| /* |
| * 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 { |
| |
| log.debug( |
| "MessageContextSaveATest:testReceive(): start - - engine.receive(mc) - - - - - - - - - - - - - - - -"); |
| AxisEngine.receive(mc); |
| |
| log.debug( |
| "MessageContextSaveATest:testReceive(): resume - - engine.resume(mc) - - - - - - - - - - - - - - - -"); |
| AxisEngine.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) - - - - - - - - - - - - - - - -"); |
| AxisEngine.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; |
| } |
| |
| } |
| } |
