001: package org.objectweb.celtix.systest.ws.rm;
002:
003: import java.net.URL;
004: import java.util.List;
005:
006: import javax.xml.namespace.QName;
007: import javax.xml.soap.SOAPMessage;
008: import javax.xml.ws.BindingProvider;
009: import javax.xml.ws.handler.Handler;
010: import javax.xml.ws.handler.LogicalMessageContext;
011:
012: import junit.framework.Test;
013: import junit.framework.TestSuite;
014:
015: import org.objectweb.celtix.Bus;
016: import org.objectweb.celtix.bindings.AbstractBindingImpl;
017: import org.objectweb.celtix.bus.busimpl.BusConfigurationBuilder;
018: import org.objectweb.celtix.bus.ws.rm.Names;
019: import org.objectweb.celtix.bus.ws.rm.RMHandler;
020: import org.objectweb.celtix.configuration.ConfigurationBuilder;
021: import org.objectweb.celtix.configuration.ConfigurationBuilderFactory;
022: import org.objectweb.celtix.greeter_control.Control;
023: import org.objectweb.celtix.greeter_control.ControlService;
024: import org.objectweb.celtix.greeter_control.Greeter;
025: import org.objectweb.celtix.greeter_control.GreeterService;
026: import org.objectweb.celtix.systest.common.ClientServerSetupBase;
027: import org.objectweb.celtix.systest.common.ClientServerTestBase;
028:
029: /**
030: * Tests Reliable Messaging.
031: */
032: public class SequenceTest extends ClientServerTestBase {
033:
034: private static final String APP_NAMESPACE = "http://celtix.objectweb.org/greeter_control";
035: private static final String GREETMEONEWAY_ACTION = APP_NAMESPACE
036: + "/types/Greeter/greetMeOneWay";
037: private static final String GREETME_ACTION = APP_NAMESPACE
038: + "/types/Greeter/greetMe";
039: private static final String GREETME_RESPONSE_ACTION = GREETME_ACTION
040: + "Response";
041:
042: private static final QName CONTROL_SERVICE_NAME = new QName(
043: APP_NAMESPACE, "ControlService");
044: private static final QName SERVICE_NAME = new QName(APP_NAMESPACE,
045: "GreeterService");
046: private static final QName CONTROL_PORT_NAME = new QName(
047: APP_NAMESPACE, "ControlPort");
048: private static final QName PORT_NAME = new QName(APP_NAMESPACE,
049: "GreeterPort");
050:
051: private Bus bus;
052: private GreeterService greeterService;
053: private Greeter greeter;
054: private Control control;
055: private String currentConfiguration;
056: private MessageFlow mf;
057:
058: // enable currently disabled tests when transport apis allows to
059: // originate standalone requests from server side
060:
061: private boolean doTestOnewayAnonymousAcks = true;
062: private boolean doTestOnewayDeferredAnonymousAcks = true;
063: private boolean doTestOnewayDeferredNonAnonymousAcks = true;
064: private boolean doTestOnewayAnonymousAcksSequenceLength1 = true;
065: private boolean doTestOnewayAnonymousAcksSupressed = true;
066: private boolean doTestTwowayNonAnonymous = true;
067: private boolean doTestTwowayNonAnonymousDeferred = true;
068: private boolean doTestTwowayNonAnonymousMaximumSequenceLength2;
069: private boolean doTestTwowayNonAnonymousNoOffer;
070: private boolean doTestTwowayMessageLoss = true;
071:
072: public static void main(String[] args) {
073: junit.textui.TestRunner.run(SequenceTest.class);
074: }
075:
076: public static Test suite() throws Exception {
077: TestSuite suite = new TestSuite(SequenceTest.class);
078: return new ClientServerSetupBase(suite) {
079: public void startServers() throws Exception {
080: // special case handling for WS-Addressing system test to avoid
081: // UUID related issue when server is run as separate process
082: // via maven on Win2k
083: assertTrue("server did not launch correctly",
084: launchServer(Server.class, "Windows 2000"
085: .equals(System.getProperty("os.name"))));
086: }
087:
088: public void setUp() throws Exception {
089: // avoid re-using a previously created configuration for a bus
090: // with id "celtix"
091: ConfigurationBuilder builder = ConfigurationBuilderFactory
092: .getBuilder();
093: builder.buildConfiguration(
094: BusConfigurationBuilder.BUS_CONFIGURATION_URI,
095: "celtix");
096:
097: super .setUp();
098:
099: }
100: };
101: }
102:
103: public void tearDown() {
104: if (null != greeter) {
105: boolean found = false;
106: BindingProvider provider = (BindingProvider) greeter;
107: AbstractBindingImpl abi = (AbstractBindingImpl) provider
108: .getBinding();
109: List<Handler> handlerChain = abi
110: .getPreLogicalSystemHandlers();
111: for (Handler h : handlerChain) {
112: if (h instanceof RMHandler) {
113: ((RMHandler) h).destroy();
114: found = true;
115: break;
116: }
117: }
118: assertTrue(
119: "Cound not find RM handler in pre logical system handler chain",
120: found);
121: }
122: }
123:
124: // --- tests ---
125:
126: public void testOnewayAnonymousAcks() throws Exception {
127: if (!doTestOnewayAnonymousAcks) {
128: return;
129: }
130: setupEndpoints("anonymous");
131:
132: greeter.greetMeOneWay("once");
133: greeter.greetMeOneWay("twice");
134: greeter.greetMeOneWay("thrice");
135:
136: // three application messages plus createSequence
137:
138: mf.verifyMessages(4, true);
139: String[] expectedActions = new String[] {
140: Names.WSRM_CREATE_SEQUENCE_ACTION,
141: GREETMEONEWAY_ACTION, GREETMEONEWAY_ACTION,
142: GREETMEONEWAY_ACTION };
143: mf.verifyActions(expectedActions, true);
144: mf.verifyMessageNumbers(new String[] { null, "1", "2", "3" },
145: true);
146:
147: // createSequenceResponse plus 4 partial responses
148: mf.verifyMessages(5, false);
149: expectedActions = new String[] { null,
150: Names.WSRM_CREATE_SEQUENCE_RESPONSE_ACTION, null, null,
151: null };
152: mf.verifyActions(expectedActions, false);
153: mf.verifyMessageNumbers(new String[] { null, null, null, null,
154: null }, false);
155: mf.verifyAcknowledgements(new boolean[] { false, false, true,
156: true, true }, false);
157: }
158:
159: public void testOnewayDeferredAnonymousAcks() throws Exception {
160: if (!doTestOnewayDeferredAnonymousAcks) {
161: return;
162: }
163: setupEndpoints("anonymous-deferred");
164:
165: greeter.greetMeOneWay("once");
166: greeter.greetMeOneWay("twice");
167:
168: try {
169: Thread.sleep(3 * 1000);
170: } catch (InterruptedException ex) {
171: // ignore
172: }
173:
174: greeter.greetMeOneWay("thrice");
175:
176: // three application messages plus createSequence
177: mf.verifyMessages(4, true);
178: String[] expectedActions = new String[] {
179: Names.WSRM_CREATE_SEQUENCE_ACTION,
180: GREETMEONEWAY_ACTION, GREETMEONEWAY_ACTION,
181: GREETMEONEWAY_ACTION };
182: mf.verifyActions(expectedActions, true);
183: mf.verifyMessageNumbers(new String[] { null, "1", "2", "3" },
184: true);
185:
186: // createSequenceResponse message plus 4 partial responses, only the
187: // last one should include a sequence acknowledgment
188:
189: mf.verifyMessages(5, false);
190: expectedActions = new String[] { null,
191: Names.WSRM_CREATE_SEQUENCE_RESPONSE_ACTION, null, null,
192: null };
193: mf.verifyActions(expectedActions, false);
194: mf.verifyMessageNumbers(new String[] { null, null, null, null,
195: null }, false);
196: mf.verifyAcknowledgements(new boolean[] { false, false, false,
197: false, true }, false);
198: }
199:
200: public void testOnewayDeferredNonAnonymousAcks() throws Exception {
201: if (!doTestOnewayDeferredNonAnonymousAcks) {
202: return;
203: }
204: setupEndpoints("nonanonymous-deferred");
205:
206: greeter.greetMeOneWay("once");
207: greeter.greetMeOneWay("twice");
208:
209: // CreateSequence plus two greetMeOneWay requests
210:
211: mf.verifyMessages(3, true);
212: String[] expectedActions = new String[] {
213: Names.WSRM_CREATE_SEQUENCE_ACTION,
214: GREETMEONEWAY_ACTION, GREETMEONEWAY_ACTION };
215: mf.verifyActions(expectedActions, true);
216: mf.verifyMessageNumbers(new String[] { null, "1", "2" }, true);
217:
218: // CreateSequenceResponse plus three partial responses, no acknowledgments included
219:
220: mf.verifyMessages(4, false);
221: expectedActions = new String[] { null,
222: Names.WSRM_CREATE_SEQUENCE_RESPONSE_ACTION, null, null };
223: mf.verifyActions(expectedActions, false);
224: mf.verifyMessageNumbers(new String[4], false);
225: mf.verifyAcknowledgements(new boolean[4], false);
226:
227: mf.getInboundContexts().clear();
228: mf.getOutboundMessages().clear();
229:
230: try {
231: Thread.sleep(3 * 1000);
232: } catch (InterruptedException ex) {
233: // ignore
234: }
235:
236: // a standalone acknowledgement should have been sent from the server side by now
237:
238: mf.verifyMessages(0, true);
239: mf.verifyMessages(1, false);
240:
241: }
242:
243: public void testOnewayAnonymousAcksSequenceLength1()
244: throws Exception {
245: if (!doTestOnewayAnonymousAcksSequenceLength1) {
246: return;
247: }
248: setupEndpoints("anonymous-seqlength1");
249:
250: greeter.greetMeOneWay("once");
251: greeter.greetMeOneWay("twice");
252:
253: // two application messages plus two createSequence plus two
254: // terminateSequence
255:
256: mf.verifyMessages(6, true);
257: String[] expectedActions = new String[] {
258: Names.WSRM_CREATE_SEQUENCE_ACTION,
259: GREETMEONEWAY_ACTION,
260: Names.WSRM_TERMINATE_SEQUENCE_ACTION,
261: Names.WSRM_CREATE_SEQUENCE_ACTION,
262: GREETMEONEWAY_ACTION,
263: Names.WSRM_TERMINATE_SEQUENCE_ACTION };
264: mf.verifyActions(expectedActions, true);
265: mf.verifyMessageNumbers(new String[] { null, "1", null, null,
266: "1", null }, true);
267: mf.verifyLastMessage(new boolean[] { false, true, false, false,
268: true, false }, true);
269:
270: // createSequenceResponse message plus partial responses to
271: // greetMeOneWay and terminateSequence ||: 2
272:
273: mf.verifyMessages(8, false, 100, 5);
274:
275: expectedActions = new String[] { null,
276: Names.WSRM_CREATE_SEQUENCE_RESPONSE_ACTION, null, null,
277: null, Names.WSRM_CREATE_SEQUENCE_RESPONSE_ACTION, null,
278: null };
279: mf.verifyActions(expectedActions, false);
280: mf.verifyMessageNumbers(new String[] { null, null, null, null,
281: null, null, null, null }, false);
282: mf.verifyLastMessage(new boolean[] { false, false, false,
283: false, false, false, false, false }, false);
284: mf.verifyAcknowledgements(new boolean[] { false, false, true,
285: false, false, false, true, false }, false);
286: }
287:
288: public void testOnewayAnonymousAcksSupressed() throws Exception {
289:
290: if (!doTestOnewayAnonymousAcksSupressed) {
291: return;
292: }
293: setupEndpoints("anonymous-suppressed");
294:
295: greeter.greetMeOneWay("once");
296: greeter.greetMeOneWay("twice");
297: greeter.greetMeOneWay("thrice");
298:
299: // three application messages plus createSequence
300: mf.verifyMessages(4, true);
301: String[] expectedActions = new String[] {
302: Names.WSRM_CREATE_SEQUENCE_ACTION,
303: GREETMEONEWAY_ACTION, GREETMEONEWAY_ACTION,
304: GREETMEONEWAY_ACTION };
305: mf.verifyActions(expectedActions, true);
306: mf.verifyMessageNumbers(new String[] { null, "1", "2", "3" },
307: true);
308:
309: // createSequenceResponse plus 4 partial responses, none of which
310: // contain an acknowledgment
311:
312: mf.verifyMessages(5, false);
313: expectedActions = new String[] { null,
314: Names.WSRM_CREATE_SEQUENCE_RESPONSE_ACTION, null, null,
315: null };
316: mf.verifyActions(expectedActions, false);
317: mf.verifyMessageNumbers(new String[] { null, null, null, null,
318: null }, false);
319: mf.verifyAcknowledgements(new boolean[] { false, false, false,
320: false, false }, false);
321:
322: mf.getOutboundMessages().clear();
323: mf.getInboundContexts().clear();
324:
325: // allow resends to kick in
326: Thread.sleep(10 * 1000);
327:
328: // between 1 and 3 resends
329: // note that for now neither AckRequested nor up-to-date
330: // SequenceAcknowledgment headers are added to resent messages
331: // also, as the server is configured to not piggyback
332: // SequenceAcknowledgments onto the partial response, the client
333: // will keep retransmitting its messages indefinitely
334:
335: int nOutbound = mf.getOutboundMessages().size();
336: assertTrue("unexpected number of resends: " + nOutbound,
337: nOutbound >= 1);
338: // mf.verifyAckRequestedOutbound();
339: }
340:
341: public void testTwowayNonAnonymous() throws Exception {
342: if (!doTestTwowayNonAnonymous) {
343: return;
344: }
345: setupEndpoints("twoway");
346:
347: greeter.greetMe("one");
348: greeter.greetMe("two");
349: greeter.greetMe("three");
350:
351: // CreateSequence and three greetMe messages
352: // TODO there should be partial responses to the decoupled responses!
353:
354: mf.verifyMessages(4, true);
355: String[] expectedActions = new String[] {
356: Names.WSRM_CREATE_SEQUENCE_ACTION, GREETME_ACTION,
357: GREETME_ACTION, GREETME_ACTION };
358: mf.verifyActions(expectedActions, true);
359: mf.verifyMessageNumbers(new String[] { null, "1", "2", "3" },
360: true);
361: mf.verifyLastMessage(
362: new boolean[] { false, false, false, false }, true);
363: mf.verifyAcknowledgements(new boolean[] { false, false, true,
364: true }, true);
365:
366: // createSequenceResponse plus 3 greetMeResponse messages plus
367: // one partial response for each of the four messages
368:
369: mf.verifyMessages(8, false);
370: expectedActions = new String[] { null,
371: Names.WSRM_CREATE_SEQUENCE_RESPONSE_ACTION, null,
372: GREETME_RESPONSE_ACTION, null, GREETME_RESPONSE_ACTION,
373: null, GREETME_RESPONSE_ACTION };
374: mf.verifyActions(expectedActions, false);
375: mf.verifyMessageNumbers(new String[] { null, null, null, "1",
376: null, "2", null, "3" }, false);
377: mf.verifyLastMessage(new boolean[8], false);
378: mf.verifyAcknowledgements(new boolean[] { false, false, false,
379: true, false, true, false, true }, false);
380: }
381:
382: public void testTwowayNonAnonymousDeferred() throws Exception {
383: if (!doTestTwowayNonAnonymousDeferred) {
384: return;
385: }
386: setupEndpoints("nonanonymous-deferred");
387:
388: greeter.greetMe("one");
389: greeter.greetMe("two");
390:
391: // CreateSequence and three greetMe messages, no acknowledgments included
392:
393: mf.verifyMessages(3, true);
394: String[] expectedActions = new String[] {
395: Names.WSRM_CREATE_SEQUENCE_ACTION, GREETME_ACTION,
396: GREETME_ACTION };
397: mf.verifyActions(expectedActions, true);
398: mf.verifyMessageNumbers(new String[] { null, "1", "2" }, true);
399: mf.verifyLastMessage(new boolean[3], true);
400: mf.verifyAcknowledgements(new boolean[3], true);
401:
402: // CreateSequenceResponse plus 2 greetMeResponse messages plus
403: // one partial response for each of the four messages no acknowledgments included
404:
405: mf.verifyMessages(6, false);
406: expectedActions = new String[] { null,
407: Names.WSRM_CREATE_SEQUENCE_RESPONSE_ACTION, null,
408: GREETME_RESPONSE_ACTION, null, GREETME_RESPONSE_ACTION };
409: mf.verifyActions(expectedActions, false);
410: mf.verifyMessageNumbers(new String[] { null, null, null, "1",
411: null, "2" }, false);
412: mf.verifyLastMessage(new boolean[6], false);
413: mf.verifyAcknowledgements(new boolean[6], false);
414:
415: mf.getInboundContexts().clear();
416: mf.getOutboundMessages().clear();
417:
418: // a standalone acknowledgement should have been sent from the server side by now
419:
420: mf.verifyMessages(1, true, 1000, 5);
421: mf.verifyMessageNumbers(new String[1], true);
422: mf.verifyLastMessage(new boolean[1], true);
423: mf.verifyAcknowledgements(new boolean[] { true }, true);
424:
425: // TODO: verify incoming requests also
426:
427: }
428:
429: /**
430: * A maximum sequence length of 2 is configured for the client only.
431: * However, as we use the defaults regarding the including and acceptance for
432: * inbound sequence offers and correlate offered sequences that are included
433: * in a CreateSequence request and accepted with those that are created on behalf
434: * of such a request, the server also tries terminate its sequences.
435: * Note that as part of the sequence termination exchange a standalone sequence
436: * acknowledgment needs to be sent regardless of whether or nor acknowledgments are
437: * delivered steadily with every response.
438: */
439:
440: public void testTwowayNonAnonymousMaximumSequenceLength2()
441: throws Exception {
442:
443: if (!doTestTwowayNonAnonymousMaximumSequenceLength2) {
444: return;
445: }
446: setupEndpoints("twoway-seqlength2");
447:
448: greeter.greetMe("one");
449: greeter.greetMe("two");
450: greeter.greetMe("three");
451:
452: mf.verifyMessages(7, true);
453: String[] expectedActions = new String[] {
454: Names.WSRM_CREATE_SEQUENCE_ACTION, GREETME_ACTION,
455: GREETME_ACTION, Names.WSRM_TERMINATE_SEQUENCE_ACTION,
456: Names.WSRM_SEQUENCE_ACKNOWLEDGMENT_ACTION,
457: Names.WSRM_CREATE_SEQUENCE_ACTION, GREETME_ACTION };
458: mf.verifyActions(expectedActions, true);
459: mf.verifyMessageNumbers(new String[] { null, "1", "2", null,
460: null, null, "1" }, true);
461: mf.verifyLastMessage(new boolean[] { false, false, true, false,
462: false, false, false }, true);
463: mf.verifyAcknowledgements(new boolean[] { false, false, true,
464: false, true, false, false }, true);
465:
466: // Note that we don't expect a partial response to standalone LastMessage or
467: // SequenceAcknowledgment messages
468:
469: mf.verifyMessages(12, false, 100, 5);
470:
471: expectedActions = new String[] { null,
472: Names.WSRM_CREATE_SEQUENCE_RESPONSE_ACTION, null,
473: GREETME_RESPONSE_ACTION, null, GREETME_RESPONSE_ACTION,
474: null, Names.WSRM_TERMINATE_SEQUENCE_ACTION, null,
475: Names.WSRM_CREATE_SEQUENCE_RESPONSE_ACTION, null,
476: GREETME_RESPONSE_ACTION };
477: mf.verifyActions(expectedActions, false);
478: mf.verifyMessageNumbers(new String[] { null, null, null, "1",
479: null, "2", null, null, null, null, null, "1" }, false);
480: boolean[] expected = new boolean[12];
481: expected[5] = true;
482: mf.verifyLastMessage(expected, false);
483: expected[3] = true;
484: expected[11] = true;
485: mf.verifyAcknowledgements(expected, false);
486: }
487:
488: public void testTwowayNonAnonymousNoOffer() throws Exception {
489: if (!doTestTwowayNonAnonymousNoOffer) {
490: return;
491: }
492: setupEndpoints("twoway-no-offer");
493:
494: greeter.greetMe("one");
495: greeter.greetMe("two");
496:
497: // Outbound expected:
498: // CreateSequence + (2 * greetMe) + CreateSequenceResponse = 4 messages
499: // TODO there should be partial responses to the decoupled responses!
500:
501: mf.verifyMessages(4, true);
502: String[] expectedActions = new String[] {
503: Names.WSRM_CREATE_SEQUENCE_ACTION, GREETME_ACTION,
504: Names.WSRM_CREATE_SEQUENCE_RESPONSE_ACTION,
505: GREETME_ACTION };
506: mf.verifyActions(expectedActions, true);
507: mf.verifyMessageNumbers(new String[] { null, "1", null, "2" },
508: true);
509: mf.verifyLastMessage(
510: new boolean[] { false, false, false, false }, true);
511: mf.verifyAcknowledgements(new boolean[] { false, false, false,
512: true }, true);
513:
514: // Inbound expected:
515: // createSequenceResponse + (2 * greetMeResponse) + CreateSequence +
516: // (4 * partial response [for each outbound message]) = 8
517:
518: mf.verifyMessages(8, false, 1000, 3);
519:
520: mf.purgePartialResponses();
521:
522: expectedActions = new String[] {
523: Names.WSRM_CREATE_SEQUENCE_RESPONSE_ACTION,
524: Names.WSRM_CREATE_SEQUENCE_ACTION,
525: GREETME_RESPONSE_ACTION, GREETME_RESPONSE_ACTION };
526: mf.verifyActions(expectedActions, false);
527: mf.verifyMessageNumbers(new String[] { null, null, "1", "2" },
528: false);
529: mf.verifyAcknowledgements(new boolean[] { false, false, true,
530: true }, false);
531: }
532:
533: public void testTwowayMessageLoss() throws Exception {
534: if (!doTestTwowayMessageLoss) {
535: return;
536: }
537: setupEndpoints("twoway-message-loss");
538:
539: greeter.greetMe("one");
540: greeter.greetMe("two");
541: greeter.greetMe("three");
542: greeter.greetMe("four");
543:
544: // CreateSequence and four greetMe messages
545:
546: mf.verifyMessages(5, true);
547: String[] expectedActions = new String[] {
548: Names.WSRM_CREATE_SEQUENCE_ACTION, GREETME_ACTION,
549: GREETME_ACTION, GREETME_ACTION, GREETME_ACTION };
550: mf.verifyActions(expectedActions, true);
551: mf.verifyMessageNumbers(
552: new String[] { null, "1", "2", "3", "4" }, true);
553: mf.verifyLastMessage(new boolean[] { false, false, false,
554: false, false }, true);
555: mf.verifyAcknowledgements(new boolean[] { false, false, true,
556: false, true }, true);
557:
558: // createSequenceResponse
559: // + 2 greetMeResponse actions (non-discarded messages)
560: // + 2 greetMe actions (discarded messages)
561: // + 3 partial responses (to CSR & each of the non-discarded messages)
562:
563: mf.verifyMessages(8, false);
564: expectedActions = new String[] { null,
565: Names.WSRM_CREATE_SEQUENCE_RESPONSE_ACTION, null,
566: GREETME_RESPONSE_ACTION, GREETME_ACTION, null,
567: GREETME_RESPONSE_ACTION, GREETME_ACTION };
568: mf.verifyActions(expectedActions, false);
569: mf.verifyMessageNumbers(new String[] { null, null, null, "1",
570: null, null, "2", null }, false);
571: mf.verifyLastMessage(new boolean[8], false);
572: mf.verifyAcknowledgements(new boolean[] { false, false, false,
573: true, false, false, true, false }, false);
574:
575: mf.clear();
576:
577: // wait for resends to occur
578: // for some reason only the first retransmission for each message works fine
579: // the second time round a message with an empty body is re-transmitted
580: /*
581: mf.verifyMessages(4, true, 1000, 20);
582: expectedActions = new String[] {GREETME_ACTION, GREETME_ACTION,
583: GREETME_ACTION, GREETME_ACTION};
584: */
585: mf.verifyMessages(2, true, 1000, 10);
586: expectedActions = new String[] { GREETME_ACTION, GREETME_ACTION };
587: mf.verifyActions(expectedActions, true);
588:
589: }
590:
591: // --- test setup helpers ---
592:
593: private void createControl() {
594: if (null == control) {
595: URL wsdl = getClass().getResource(
596: "/wsdl/greeter_control.wsdl");
597: ControlService controlService = new ControlService(wsdl,
598: CONTROL_SERVICE_NAME);
599: control = controlService.getPort(CONTROL_PORT_NAME,
600: Control.class);
601: }
602: }
603:
604: private void setupEndpoints(String configuration) throws Exception {
605:
606: if (configuration != null
607: && configuration.equals(currentConfiguration)) {
608: return;
609: }
610:
611: if (configuration.indexOf("shutdown") > 0 && null != bus) {
612: bus.shutdown(true);
613: bus = null;
614: }
615:
616: if (null == bus) {
617: bus = Bus.init();
618: }
619:
620: createControl();
621:
622: control.stopGreeter();
623: control.startGreeter(configuration);
624:
625: if (null != configuration && configuration.length() > 0) {
626: ControlImpl.setConfigFileProperty(configuration);
627: }
628:
629: TestConfigurator tc = new TestConfigurator();
630: tc.configureClient(SERVICE_NAME, PORT_NAME.getLocalPart());
631:
632: URL wsdl = getClass().getResource("/wsdl/greeter_control.wsdl");
633: greeterService = new GreeterService(wsdl, SERVICE_NAME);
634: greeter = greeterService.getPort(PORT_NAME, Greeter.class);
635:
636: BindingProvider provider = (BindingProvider) greeter;
637: AbstractBindingImpl abi = (AbstractBindingImpl) provider
638: .getBinding();
639: List<Handler> handlerChain = abi.getHandlerChain();
640: assertTrue(handlerChain.size() > 0);
641:
642: List<SOAPMessage> outboundMessages = null;
643: List<LogicalMessageContext> inboundContexts = null;
644:
645: boolean found = false;
646: for (Handler h : handlerChain) {
647: if (!found && h instanceof SOAPMessageRecorder) {
648: SOAPMessageRecorder recorder = (SOAPMessageRecorder) h;
649: outboundMessages = recorder.getOutboundMessages();
650: outboundMessages.clear();
651: found = true;
652: break;
653: }
654: }
655: assertTrue(
656: "Could not find SOAPMessageRecorder in post protocol handler chain",
657: found);
658:
659: handlerChain = abi.getPreLogicalSystemHandlers();
660: assertTrue(handlerChain.size() > 0);
661: found = false;
662: for (Handler h : handlerChain) {
663: if (!found && h instanceof LogicalMessageContextRecorder) {
664: LogicalMessageContextRecorder recorder = (LogicalMessageContextRecorder) h;
665: inboundContexts = recorder.getInboundContexts();
666: inboundContexts.clear();
667: found = true;
668: break;
669: }
670: }
671: assertTrue(
672: "Could not find LogicalMessageContextRecorder in pre logical system handler chain",
673: found);
674: currentConfiguration = configuration;
675:
676: mf = new MessageFlow(outboundMessages, inboundContexts);
677:
678: }
679:
680: }
|