← Back to branch summary

~ubuntu-branches/ubuntu/raring/libjboss-remoting-java/raring

« back to all changes in this revision

Viewing changes to src/tests/org/jboss/test/remoting/callback/timeout/CallbackTimeoutTestParent.java

  • Committer: Package Import Robot
  • Author(s): Torsten Werner
  • Date: 2011-09-09 14:01:03 UTC
  • mto: This revision was merged to the branch mainline in revision 9.
  • Revision ID: package-import@ubuntu.com-20110909140103-o8ucrolqt5g25k57
Tags: upstream-2.5.3.SP1
Import upstream version 2.5.3.SP1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/tests/org/jboss/test/remoting/callback/timeout/CallbackTimeoutTestParent.java
 
1
/*
 
2
 * JBoss, Home of Professional Open Source
 
3
 * Copyright 2005, JBoss Inc., and individual contributors as indicated
 
4
 * by the @authors tag. See the copyright.txt in the distribution for a
 
5
 * full listing of individual contributors.
 
6
 *
 
7
 * This is free software; you can redistribute it and/or modify it
 
8
 * under the terms of the GNU Lesser General Public License as
 
9
 * published by the Free Software Foundation; either version 2.1 of
 
10
 * the License, or (at your option) any later version.
 
11
 *
 
12
 * This software is distributed in the hope that it will be useful,
 
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 
15
 * Lesser General Public License for more details.
 
16
 *
 
17
 * You should have received a copy of the GNU Lesser General Public
 
18
 * License along with this software; if not, write to the Free
 
19
 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 
20
 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 
21
 */
 
22
package org.jboss.test.remoting.callback.timeout;
 
23
 
 
24
import java.lang.reflect.Field;
 
25
import java.net.InetAddress;
 
26
import java.util.HashMap;
 
27
import java.util.HashSet;
 
28
import java.util.Iterator;
 
29
import java.util.Map;
 
30
import java.util.Set;
 
31
 
 
32
import javax.management.MBeanServer;
 
33
 
 
34
import junit.framework.TestCase;
 
35
 
 
36
import org.apache.log4j.ConsoleAppender;
 
37
import org.apache.log4j.Level;
 
38
import org.apache.log4j.Logger;
 
39
import org.apache.log4j.PatternLayout;
 
40
import org.jboss.remoting.Client;
 
41
import org.jboss.remoting.InvocationRequest;
 
42
import org.jboss.remoting.InvokerLocator;
 
43
import org.jboss.remoting.ServerInvocationHandler;
 
44
import org.jboss.remoting.ServerInvoker;
 
45
import org.jboss.remoting.callback.Callback;
 
46
import org.jboss.remoting.callback.HandleCallbackException;
 
47
import org.jboss.remoting.callback.InvokerCallbackHandler;
 
48
import org.jboss.remoting.callback.ServerInvokerCallbackHandler;
 
49
import org.jboss.remoting.transport.Connector;
 
50
import org.jboss.remoting.transport.PortUtil;
 
51
 
 
52
 
 
53
 
 
54
/**
 
55
 * Unit test for JBREM-799.
 
56
 * 
 
57
 * @author <a href="ron.sigal@jboss.com">Ron Sigal</a>
 
58
 * @version $Revision: 1.1.2.2 $
 
59
 * <p>
 
60
 * Copyright Jan 25, 2008
 
61
 * </p>
 
62
 */
 
63
abstract public class CallbackTimeoutTestParent extends TestCase
 
64
{
 
65
   public static int port;
 
66
   private static Logger log = Logger.getLogger(CallbackTimeoutTestParent.class);
 
67
   private static final String CALLBACK_TEST = "callbackTest";
 
68
 
 
69
   private static boolean firstTime = true;
 
70
 
 
71
   // remoting server connector
 
72
   private Connector connector;
 
73
   private InvokerLocator serverLocator;
 
74
   private TestInvocationHandler invocationHandler;
 
75
 
 
76
 
 
77
   /**
 
78
    * Sets up target remoting server.
 
79
    */
 
80
   public void setUp() throws Exception
 
81
   {
 
82
      if (firstTime)
 
83
      {
 
84
         firstTime = false;
 
85
         Logger.getLogger("org.jboss.remoting").setLevel(Level.INFO);
 
86
         Logger.getLogger("org.jboss.test.remoting").setLevel(Level.INFO);
 
87
         String pattern = "[%d{ABSOLUTE}] [%t] %5p (%F:%L) - %m%n";
 
88
         PatternLayout layout = new PatternLayout(pattern);
 
89
         ConsoleAppender consoleAppender = new ConsoleAppender(layout);
 
90
         Logger.getRootLogger().addAppender(consoleAppender);  
 
91
      }
 
92
   }
 
93
 
 
94
 
 
95
   public void tearDown()
 
96
   {
 
97
   }
 
98
 
 
99
 
 
100
   /**
 
101
    * Verifies that "timeout" value is used in absence of "callbackTimeout" value.
 
102
    */
 
103
   public void testNoCallbackTimeout() throws Throwable
 
104
   {
 
105
      log.info("entering " + getName());
 
106
 
 
107
      // Start server.
 
108
      String host = InetAddress.getLocalHost().getHostAddress();
 
109
      port = PortUtil.findFreePort(host);
 
110
      String locatorURI = getTransport() + "://" + host + ":" + port; 
 
111
      serverLocator = new InvokerLocator(locatorURI);
 
112
      log.info("Starting remoting server with locator uri of: " + locatorURI);
 
113
      HashMap config = new HashMap();
 
114
      config.put(InvokerLocator.FORCE_REMOTE, "true");
 
115
      config.put(ServerInvoker.TIMEOUT, "3000");
 
116
      addExtraServerConfig(config);
 
117
      connector = new Connector(serverLocator, config);
 
118
      connector.create();
 
119
      invocationHandler = new TestInvocationHandler();
 
120
      connector.addInvocationHandler("sample", invocationHandler);
 
121
      connector.start();
 
122
 
 
123
      // Create client.
 
124
      HashMap clientConfig = new HashMap();
 
125
      clientConfig.put(InvokerLocator.FORCE_REMOTE, "true");
 
126
      addExtraClientConfig(clientConfig);
 
127
      final Client client = new Client(serverLocator, clientConfig);
 
128
      client.connect();
 
129
      assertEquals("abc", client.invoke("abc"));
 
130
      log.info("client is connected");
 
131
 
 
132
      // Add callback handler.
 
133
      TestInvokerCallbackHandler testCallbackHandler = new TestInvokerCallbackHandler();
 
134
      client.addListener(testCallbackHandler, new HashMap(), null, true);
 
135
      client.invoke(CALLBACK_TEST);
 
136
      assertEquals(1, testCallbackHandler.counter);
 
137
      log.info("callback handler is installed");
 
138
      
 
139
      // Verify that "timeout" is used correctly.
 
140
      ServerInvoker serverInvoker = connector.getServerInvoker();
 
141
      Map configuration = serverInvoker.getConfiguration();
 
142
      assertEquals("3000", configuration.get(ServerInvoker.TIMEOUT));
 
143
 
 
144
      // Verify that "timeout" is used in the absence of "callbackTimeout".
 
145
      Field field = ServerInvoker.class.getDeclaredField("callbackHandlers");
 
146
      field.setAccessible(true);
 
147
      Map callbackHandlers = (Map) field.get(serverInvoker);
 
148
      assertEquals(1, callbackHandlers.size());
 
149
      Object o = callbackHandlers.values().iterator().next();
 
150
      ServerInvokerCallbackHandler callbackHandler = (ServerInvokerCallbackHandler) o;
 
151
      field = ServerInvokerCallbackHandler.class.getDeclaredField("callBackClient");
 
152
      field.setAccessible(true);
 
153
      Client callBackClient = (Client) field.get(callbackHandler);
 
154
      configuration = callBackClient.getConfiguration();
 
155
      assertEquals("3000", configuration.get(ServerInvoker.TIMEOUT));
 
156
 
 
157
      client.removeListener(testCallbackHandler);
 
158
      client.disconnect();
 
159
      connector.stop();
 
160
   }
 
161
 
 
162
 
 
163
   /**
 
164
    * Verifies that "callbackTimeout" value overrides "timeout" value.
 
165
    * Values are specified in configuration map.
 
166
    */
 
167
   public void testDistinctCallbackTimeoutConfigMap() throws Throwable
 
168
   {
 
169
      log.info("entering " + getName());
 
170
 
 
171
      // Start server.
 
172
      String host = InetAddress.getLocalHost().getHostAddress();
 
173
      port = PortUtil.findFreePort(host);
 
174
      String locatorURI = getTransport() + "://" + host + ":" + port; 
 
175
      serverLocator = new InvokerLocator(locatorURI);
 
176
      log.info("Starting remoting server with locator uri of: " + locatorURI);
 
177
      HashMap config = new HashMap();
 
178
      config.put(InvokerLocator.FORCE_REMOTE, "true");
 
179
      config.put(ServerInvoker.TIMEOUT, "3000");
 
180
      config.put(ServerInvokerCallbackHandler.CALLBACK_TIMEOUT, "7000");
 
181
      addExtraServerConfig(config);
 
182
      connector = new Connector(serverLocator, config);
 
183
      connector.create();
 
184
      invocationHandler = new TestInvocationHandler();
 
185
      connector.addInvocationHandler("sample", invocationHandler);
 
186
      connector.start();
 
187
 
 
188
      // Create client.
 
189
      HashMap clientConfig = new HashMap();
 
190
      clientConfig.put(InvokerLocator.FORCE_REMOTE, "true");
 
191
      addExtraClientConfig(clientConfig);
 
192
      final Client client = new Client(serverLocator, clientConfig);
 
193
      client.connect();
 
194
      assertEquals("abc", client.invoke("abc"));
 
195
      log.info("client is connected");
 
196
 
 
197
      // Add callback handler.
 
198
      TestInvokerCallbackHandler testCallbackHandler = new TestInvokerCallbackHandler();
 
199
      client.addListener(testCallbackHandler, new HashMap(), null, true);
 
200
      client.invoke(CALLBACK_TEST);
 
201
      assertEquals(1, testCallbackHandler.counter);
 
202
      log.info("callback handler is installed");
 
203
 
 
204
      // Verify that "timeout" is used correctly.
 
205
      ServerInvoker serverInvoker = connector.getServerInvoker();
 
206
      Map configuration = serverInvoker.getConfiguration();
 
207
      assertEquals("3000", configuration.get(ServerInvoker.TIMEOUT));
 
208
 
 
209
      // Verify that "callbackTimeout" is used correctly.
 
210
      Field field = ServerInvoker.class.getDeclaredField("callbackHandlers");
 
211
      field.setAccessible(true);
 
212
      Map callbackHandlers = (Map) field.get(serverInvoker);
 
213
      assertEquals(1, callbackHandlers.size());
 
214
      Object o = callbackHandlers.values().iterator().next();
 
215
      ServerInvokerCallbackHandler callbackHandler = (ServerInvokerCallbackHandler) o;
 
216
      field = ServerInvokerCallbackHandler.class.getDeclaredField("callBackClient");
 
217
      field.setAccessible(true);
 
218
      Client callBackClient = (Client) field.get(callbackHandler);
 
219
      configuration = callBackClient.getConfiguration();
 
220
      assertEquals("7000", configuration.get(ServerInvoker.TIMEOUT));
 
221
 
 
222
      client.removeListener(testCallbackHandler);
 
223
      client.disconnect();
 
224
      connector.stop();
 
225
   }
 
226
 
 
227
 
 
228
   /**
 
229
    * Verifies that "callbackTimeout" value overrides "timeout" value.
 
230
    * Values are specified in InvokerLocator.
 
231
    */
 
232
   public void testDistinctCallbackTimeoutLocator() throws Throwable
 
233
   {
 
234
      log.info("entering " + getName());
 
235
 
 
236
      // Start server.
 
237
      String host = InetAddress.getLocalHost().getHostAddress();
 
238
      port = PortUtil.findFreePort(host);
 
239
      String locatorURI = getTransport() + "://" + host + ":" + port; 
 
240
      locatorURI += "/?timeout=3000&callbackTimeout=7000";
 
241
      serverLocator = new InvokerLocator(locatorURI);
 
242
      log.info("Starting remoting server with locator uri of: " + locatorURI);
 
243
      HashMap config = new HashMap();
 
244
      config.put(InvokerLocator.FORCE_REMOTE, "true");
 
245
      addExtraServerConfig(config);
 
246
      connector = new Connector(serverLocator, config);
 
247
      connector.create();
 
248
      invocationHandler = new TestInvocationHandler();
 
249
      connector.addInvocationHandler("sample", invocationHandler);
 
250
      connector.start();
 
251
 
 
252
      // Create client.
 
253
      HashMap clientConfig = new HashMap();
 
254
      clientConfig.put(InvokerLocator.FORCE_REMOTE, "true");
 
255
      addExtraClientConfig(clientConfig);
 
256
      final Client client = new Client(serverLocator, clientConfig);
 
257
      client.connect();
 
258
      assertEquals("abc", client.invoke("abc"));
 
259
      log.info("client is connected");
 
260
 
 
261
      // Add callback handler.
 
262
      TestInvokerCallbackHandler testCallbackHandler = new TestInvokerCallbackHandler();
 
263
      client.addListener(testCallbackHandler, new HashMap(), null, true);
 
264
      client.invoke(CALLBACK_TEST);
 
265
      assertEquals(1, testCallbackHandler.counter);
 
266
      log.info("callback handler is installed");
 
267
 
 
268
      // Verify that "timeout" is used correctly.
 
269
      ServerInvoker serverInvoker = connector.getServerInvoker();
 
270
      Map configuration = serverInvoker.getConfiguration();
 
271
      assertEquals("3000", configuration.get(ServerInvoker.TIMEOUT));
 
272
 
 
273
      // Verify that "callbackTimeout" is used correctly.
 
274
      Field field = ServerInvoker.class.getDeclaredField("callbackHandlers");
 
275
      field.setAccessible(true);
 
276
      Map callbackHandlers = (Map) field.get(serverInvoker);
 
277
      assertEquals(1, callbackHandlers.size());
 
278
      Object o = callbackHandlers.values().iterator().next();
 
279
      ServerInvokerCallbackHandler callbackHandler = (ServerInvokerCallbackHandler) o;
 
280
      field = ServerInvokerCallbackHandler.class.getDeclaredField("callBackClient");
 
281
      field.setAccessible(true);
 
282
      Client callBackClient = (Client) field.get(callbackHandler);
 
283
      configuration = callBackClient.getConfiguration();
 
284
      assertEquals("7000", configuration.get(ServerInvoker.TIMEOUT));
 
285
 
 
286
      client.removeListener(testCallbackHandler);
 
287
      client.disconnect();
 
288
      connector.stop();
 
289
   }
 
290
 
 
291
 
 
292
   /**
 
293
    * Verifies that "timeout" value is used in absense of "callbackTimeout".
 
294
    * "timeout" value is specified in Client.addListener() metadata map.
 
295
    */
 
296
   public void testNoCallbackTimeoutMetadata() throws Throwable
 
297
   {
 
298
      log.info("entering " + getName());
 
299
 
 
300
      // Start server.
 
301
      String host = InetAddress.getLocalHost().getHostAddress();
 
302
      port = PortUtil.findFreePort(host);
 
303
      String locatorURI = getTransport() + "://" + host + ":" + port; 
 
304
      serverLocator = new InvokerLocator(locatorURI);
 
305
      log.info("Starting remoting server with locator uri of: " + locatorURI);
 
306
      HashMap config = new HashMap();
 
307
      config.put(InvokerLocator.FORCE_REMOTE, "true");
 
308
      addExtraServerConfig(config);
 
309
      connector = new Connector(serverLocator, config);
 
310
      connector.create();
 
311
      invocationHandler = new TestInvocationHandler();
 
312
      connector.addInvocationHandler("sample", invocationHandler);
 
313
      connector.start();
 
314
 
 
315
      // Create client.
 
316
      HashMap clientConfig = new HashMap();
 
317
      clientConfig.put(InvokerLocator.FORCE_REMOTE, "true");
 
318
      addExtraClientConfig(clientConfig);
 
319
      final Client client = new Client(serverLocator, clientConfig);
 
320
      client.connect();
 
321
      assertEquals("abc", client.invoke("abc"));
 
322
      log.info("client is connected");
 
323
 
 
324
      // Add callback handler.
 
325
      TestInvokerCallbackHandler testCallbackHandler = new TestInvokerCallbackHandler();
 
326
      Map metadata = new HashMap();
 
327
      metadata.put(ServerInvoker.TIMEOUT, "3000");
 
328
      client.addListener(testCallbackHandler, metadata, null, true);
 
329
      client.invoke(CALLBACK_TEST);
 
330
      assertEquals(1, testCallbackHandler.counter);
 
331
      log.info("callback handler is installed");
 
332
 
 
333
      // Verify that "timeout" is used in the absence of "callbackTimeout".
 
334
      ServerInvoker serverInvoker = connector.getServerInvoker();
 
335
      Field field = ServerInvoker.class.getDeclaredField("callbackHandlers");
 
336
      field.setAccessible(true);
 
337
      Map callbackHandlers = (Map) field.get(serverInvoker);
 
338
      assertEquals(1, callbackHandlers.size());
 
339
      Object o = callbackHandlers.values().iterator().next();
 
340
      ServerInvokerCallbackHandler callbackHandler = (ServerInvokerCallbackHandler) o;
 
341
      field = ServerInvokerCallbackHandler.class.getDeclaredField("callBackClient");
 
342
      field.setAccessible(true);
 
343
      Client callBackClient = (Client) field.get(callbackHandler);
 
344
      Map configuration = callBackClient.getConfiguration();
 
345
      assertEquals("3000", configuration.get(ServerInvoker.TIMEOUT));
 
346
 
 
347
      client.removeListener(testCallbackHandler);
 
348
      client.disconnect();
 
349
      connector.stop();
 
350
   }
 
351
 
 
352
 
 
353
   /**
 
354
    * Verifies that "callbackTimeout" value overrides "timeout" value.
 
355
    * "callbackTimeout" is specified in Client.addListener() metadata map.
 
356
    */
 
357
   public void testDistinctCallbackTimeoutMetadata() throws Throwable
 
358
   {
 
359
      log.info("entering " + getName());
 
360
 
 
361
      // Start server.
 
362
      String host = InetAddress.getLocalHost().getHostAddress();
 
363
      port = PortUtil.findFreePort(host);
 
364
      String locatorURI = getTransport() + "://" + host + ":" + port; 
 
365
      serverLocator = new InvokerLocator(locatorURI);
 
366
      log.info("Starting remoting server with locator uri of: " + locatorURI);
 
367
      HashMap config = new HashMap();
 
368
      config.put(InvokerLocator.FORCE_REMOTE, "true");
 
369
      addExtraServerConfig(config);
 
370
      connector = new Connector(serverLocator, config);
 
371
      connector.create();
 
372
      invocationHandler = new TestInvocationHandler();
 
373
      connector.addInvocationHandler("sample", invocationHandler);
 
374
      connector.start();
 
375
 
 
376
      // Create client.
 
377
      HashMap clientConfig = new HashMap();
 
378
      clientConfig.put(InvokerLocator.FORCE_REMOTE, "true");
 
379
      addExtraClientConfig(clientConfig);
 
380
      final Client client = new Client(serverLocator, clientConfig);
 
381
      client.connect();
 
382
      assertEquals("abc", client.invoke("abc"));
 
383
      log.info("client is connected");
 
384
 
 
385
      // Add callback handler.
 
386
      TestInvokerCallbackHandler testCallbackHandler = new TestInvokerCallbackHandler();
 
387
      Map metadata = new HashMap();
 
388
      metadata.put(ServerInvokerCallbackHandler.CALLBACK_TIMEOUT, "7000");
 
389
      client.addListener(testCallbackHandler, metadata, null, true);
 
390
      client.invoke(CALLBACK_TEST);
 
391
      assertEquals(1, testCallbackHandler.counter);
 
392
      log.info("callback handler is installed");
 
393
 
 
394
      // Verify that "callbackTimeout" is used correctly.
 
395
      ServerInvoker serverInvoker = connector.getServerInvoker();
 
396
      Field field = ServerInvoker.class.getDeclaredField("callbackHandlers");
 
397
      field.setAccessible(true);
 
398
      Map callbackHandlers = (Map) field.get(serverInvoker);
 
399
      assertEquals(1, callbackHandlers.size());
 
400
      Object o = callbackHandlers.values().iterator().next();
 
401
      ServerInvokerCallbackHandler callbackHandler = (ServerInvokerCallbackHandler) o;
 
402
      field = ServerInvokerCallbackHandler.class.getDeclaredField("callBackClient");
 
403
      field.setAccessible(true);
 
404
      Client callBackClient = (Client) field.get(callbackHandler);
 
405
      Map configuration = callBackClient.getConfiguration();
 
406
      assertEquals("7000", configuration.get(ServerInvoker.TIMEOUT));
 
407
 
 
408
      client.removeListener(testCallbackHandler);
 
409
      client.disconnect();
 
410
      connector.stop();
 
411
   }
 
412
 
 
413
 
 
414
   /**
 
415
    * Verifies that "callbackTimeout" specified in Client.addListener() metadata
 
416
    * map overrides values in server InvokerLocator and server configuration map.
 
417
    */
 
418
   public void testMetadataOverridesLocatorAndConfigMap() throws Throwable
 
419
   {
 
420
      log.info("entering " + getName());
 
421
 
 
422
      // Start server.
 
423
      String host = InetAddress.getLocalHost().getHostAddress();
 
424
      port = PortUtil.findFreePort(host);
 
425
      String locatorURI = getTransport() + "://" + host + ":" + port; 
 
426
      locatorURI += "/?callbackTimeout=3000";
 
427
      serverLocator = new InvokerLocator(locatorURI);
 
428
      log.info("Starting remoting server with locator uri of: " + locatorURI);
 
429
      HashMap config = new HashMap();
 
430
      config.put(InvokerLocator.FORCE_REMOTE, "true");
 
431
      config.put(ServerInvokerCallbackHandler.CALLBACK_TIMEOUT, "7000");
 
432
      addExtraServerConfig(config);
 
433
      connector = new Connector(serverLocator, config);
 
434
      connector.create();
 
435
      invocationHandler = new TestInvocationHandler();
 
436
      connector.addInvocationHandler("sample", invocationHandler);
 
437
      connector.start();
 
438
 
 
439
      // Create client.
 
440
      HashMap clientConfig = new HashMap();
 
441
      clientConfig.put(InvokerLocator.FORCE_REMOTE, "true");
 
442
      addExtraClientConfig(clientConfig);
 
443
      final Client client = new Client(serverLocator, clientConfig);
 
444
      client.connect();
 
445
      assertEquals("abc", client.invoke("abc"));
 
446
      log.info("client is connected");
 
447
 
 
448
      // Add callback handler.
 
449
      TestInvokerCallbackHandler testCallbackHandler = new TestInvokerCallbackHandler();
 
450
      Map metadata = new HashMap();
 
451
      metadata.put(ServerInvokerCallbackHandler.CALLBACK_TIMEOUT, "11000");
 
452
      client.addListener(testCallbackHandler, metadata, null, true);
 
453
      client.invoke(CALLBACK_TEST);
 
454
      assertEquals(1, testCallbackHandler.counter);
 
455
      log.info("callback handler is installed");
 
456
 
 
457
      // Verify that "callbackTimeout" from Client.addListener() metadata
 
458
      // has precedence.
 
459
      ServerInvoker serverInvoker = connector.getServerInvoker();
 
460
      Field field = ServerInvoker.class.getDeclaredField("callbackHandlers");
 
461
      field.setAccessible(true);
 
462
      Map callbackHandlers = (Map) field.get(serverInvoker);
 
463
      assertEquals(1, callbackHandlers.size());
 
464
      Object o = callbackHandlers.values().iterator().next();
 
465
      ServerInvokerCallbackHandler callbackHandler = (ServerInvokerCallbackHandler) o;
 
466
      field = ServerInvokerCallbackHandler.class.getDeclaredField("callBackClient");
 
467
      field.setAccessible(true);
 
468
      Client callBackClient = (Client) field.get(callbackHandler);
 
469
      Map configuration = callBackClient.getConfiguration();
 
470
      assertEquals("11000", configuration.get(ServerInvoker.TIMEOUT));
 
471
 
 
472
      client.removeListener(testCallbackHandler);
 
473
      client.disconnect();
 
474
      connector.stop();
 
475
   }
 
476
   
 
477
   
 
478
   /**
 
479
    * Verifies that "callbackTimeout" specified in server InvokerLocator
 
480
    * overrides value specified in server configuration map.
 
481
    */
 
482
   public void testLocatorOverridesConfigMap() throws Throwable
 
483
   {
 
484
      log.info("entering " + getName());
 
485
 
 
486
      // Start server.
 
487
      String host = InetAddress.getLocalHost().getHostAddress();
 
488
      port = PortUtil.findFreePort(host);
 
489
      String locatorURI = getTransport() + "://" + host + ":" + port; 
 
490
      locatorURI += "/?callbackTimeout=3000";
 
491
      serverLocator = new InvokerLocator(locatorURI);
 
492
      log.info("Starting remoting server with locator uri of: " + locatorURI);
 
493
      HashMap config = new HashMap();
 
494
      config.put(InvokerLocator.FORCE_REMOTE, "true");
 
495
      config.put(ServerInvokerCallbackHandler.CALLBACK_TIMEOUT, "7000");
 
496
      addExtraServerConfig(config);
 
497
      connector = new Connector(serverLocator, config);
 
498
      connector.create();
 
499
      invocationHandler = new TestInvocationHandler();
 
500
      connector.addInvocationHandler("sample", invocationHandler);
 
501
      connector.start();
 
502
 
 
503
      // Create client.
 
504
      HashMap clientConfig = new HashMap();
 
505
      clientConfig.put(InvokerLocator.FORCE_REMOTE, "true");
 
506
      addExtraClientConfig(clientConfig);
 
507
      final Client client = new Client(serverLocator, clientConfig);
 
508
      client.connect();
 
509
      assertEquals("abc", client.invoke("abc"));
 
510
      log.info("client is connected");
 
511
 
 
512
      // Add callback handler.
 
513
      TestInvokerCallbackHandler testCallbackHandler = new TestInvokerCallbackHandler();
 
514
      client.addListener(testCallbackHandler, new HashMap(), null, true);
 
515
      client.invoke(CALLBACK_TEST);
 
516
      assertEquals(1, testCallbackHandler.counter);
 
517
      log.info("callback handler is installed");
 
518
 
 
519
      // Verify that "callbackTimeout" from InvokerLocator overrides value
 
520
      // in configuration map.
 
521
      ServerInvoker serverInvoker = connector.getServerInvoker();
 
522
      Field field = ServerInvoker.class.getDeclaredField("callbackHandlers");
 
523
      field.setAccessible(true);
 
524
      Map callbackHandlers = (Map) field.get(serverInvoker);
 
525
      assertEquals(1, callbackHandlers.size());
 
526
      Object o = callbackHandlers.values().iterator().next();
 
527
      ServerInvokerCallbackHandler callbackHandler = (ServerInvokerCallbackHandler) o;
 
528
      field = ServerInvokerCallbackHandler.class.getDeclaredField("callBackClient");
 
529
      field.setAccessible(true);
 
530
      Client callBackClient = (Client) field.get(callbackHandler);
 
531
      Map configuration = callBackClient.getConfiguration();
 
532
      assertEquals("3000", configuration.get(ServerInvoker.TIMEOUT));
 
533
 
 
534
      client.removeListener(testCallbackHandler);
 
535
      client.disconnect();
 
536
      connector.stop();
 
537
   }
 
538
   
 
539
   
 
540
   abstract protected String getTransport();
 
541
   
 
542
   
 
543
   protected void addExtraClientConfig(Map config) {}
 
544
   protected void addExtraServerConfig(Map config) {}
 
545
   
 
546
 
 
547
   static class TestInvocationHandler implements ServerInvocationHandler
 
548
   {
 
549
      public Set listeners = new HashSet();
 
550
      
 
551
      public void addListener(InvokerCallbackHandler callbackHandler)
 
552
      {
 
553
         listeners.add(callbackHandler);
 
554
      }
 
555
      public Object invoke(final InvocationRequest invocation) throws Throwable
 
556
      {
 
557
         if (CALLBACK_TEST.equals(invocation.getParameter()))
 
558
         {
 
559
            Iterator it = listeners.iterator();
 
560
            while (it.hasNext())
 
561
            {
 
562
               InvokerCallbackHandler handler = (InvokerCallbackHandler) it.next();
 
563
               handler.handleCallback(new Callback("test"));
 
564
            }
 
565
         }
 
566
         return invocation.getParameter();
 
567
      }
 
568
      public void removeListener(InvokerCallbackHandler callbackHandler) {}
 
569
      public void setMBeanServer(MBeanServer server) {}
 
570
      public void setInvoker(ServerInvoker invoker) {}
 
571
   }
 
572
   
 
573
   
 
574
   static class TestInvokerCallbackHandler implements InvokerCallbackHandler
 
575
   {
 
576
      public int counter;
 
577
      
 
578
      public void handleCallback(Callback callback) throws HandleCallbackException
 
579
      {
 
580
         counter++;
 
581
      }
 
582
   }
 
583
}
 
 
b'\\ No newline at end of file'