← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/main/org/jboss/remoting/transport/multiplex/MultiplexClientInvoker.java

  • Committer: Package Import Robot
  • Author(s): Torsten Werner
  • Date: 2011-09-09 14:01:03 UTC
  • mfrom: (1.1.6 upstream)
  • Revision ID: package-import@ubuntu.com-20110909140103-hqokx61534tas9rg
Tags: 2.5.3.SP1-1
http://bugs.debian.org/628303
* Newer but not newest upstream release. Do not build samples.
* Change debian/watch to upstream's svn repo.
* Add patch to fix compile error caused by tomcat update.
  (Closes: #628303)
* Switch to source format 3.0.
* Switch to debhelper level 7.
* Remove useless Depends.
* Update Standards-Version: 3.9.2.
* Update README.source.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/main/org/jboss/remoting/transport/multiplex/MultiplexClientInvoker.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
 
 
23
package org.jboss.remoting.transport.multiplex;
 
24
 
 
25
import org.jboss.logging.Logger;
 
26
import org.jboss.remoting.ConnectionFailedException;
 
27
import org.jboss.remoting.InvokerLocator;
 
28
import org.jboss.remoting.marshal.Marshaller;
 
29
import org.jboss.remoting.marshal.UnMarshaller;
 
30
import org.jboss.remoting.marshal.serializable.SerializableMarshaller;
 
31
import org.jboss.remoting.transport.BidirectionalClientInvoker;
 
32
import org.jboss.remoting.transport.PortUtil;
 
33
import org.jboss.remoting.transport.multiplex.MultiplexServerInvoker.SocketGroupInfo;
 
34
import org.jboss.remoting.transport.multiplex.utility.AddressPair;
 
35
import org.jboss.remoting.transport.socket.ClientSocketWrapper;
 
36
import org.jboss.remoting.transport.socket.SocketClientInvoker;
 
37
 
 
38
import java.io.IOException;
 
39
import java.net.InetAddress;
 
40
import java.net.InetSocketAddress;
 
41
import java.net.Socket;
 
42
import java.util.Map;
 
43
 
 
44
/**
 
45
 * <code>MultiplexClientInvoker</code> is the client side of the Multiplex transport.
 
46
 * For more information, see Remoting documentation on labs.jboss.org.
 
47
 *
 
48
 * @author <a href="mailto:tom.elrod@jboss.com">Tom Elrod</a>
 
49
 * @author <a href="mailto:ron.sigal@jboss.com">Ron Sigal</a>
 
50
 * 
 
51
 * @deprecated As of release 2.4.0 the multiplex transport will no longer be actively supported.
 
52
 */
 
53
public class MultiplexClientInvoker extends SocketClientInvoker implements BidirectionalClientInvoker
 
54
{
 
55
   private static final Logger log = Logger.getLogger(MultiplexClientInvoker.class);
 
56
   private static final boolean isTraceEnabled = log.isTraceEnabled();
 
57
   
 
58
   private InetAddress connectAddress;
 
59
   private String connectHost;
 
60
   private int connectPort;
 
61
   private InetSocketAddress connectSocketAddress;
 
62
   private InetSocketAddress bindSocketAddress;
 
63
   private String socketGroupId;
 
64
   private MultiplexServerInvoker.SocketGroupInfo socketGroupInfo;
 
65
   private AddressPair addressPair;
 
66
   private boolean readyToRun;
 
67
 
 
68
   protected String clientSocketClassName = ClientSocketWrapper.class.getName();
 
69
 
 
70
 
 
71
/**
 
72
 * Create a new <code>MultiplexClientInvoker</code>.
 
73
 *
 
74
 * @param locator
 
75
 */
 
76
   public MultiplexClientInvoker(InvokerLocator locator) throws IOException
 
77
   {
 
78
      super(locator);
 
79
   }
 
80
 
 
81
 
 
82
/**
 
83
 * Create a new <code>MultiplexClientInvoker</code>.
 
84
 *
 
85
 * @param locator
 
86
 */
 
87
   public MultiplexClientInvoker(InvokerLocator locator, Map configuration) throws IOException
 
88
   {
 
89
      super(locator, configuration);
 
90
   }
 
91
 
 
92
 
 
93
   protected void handleConnect() throws ConnectionFailedException
 
94
   {
 
95
      try
 
96
      {
 
97
      log.debug("configuring MultiplexClientInvoker for: " + locator);
 
98
      super.handleConnect();
 
99
 
 
100
      this.connectAddress = InetAddress.getByName(locator.getHost());
 
101
      this.connectHost = connectAddress.getHostName();
 
102
      this.connectPort = locator.getPort();
 
103
      this.connectSocketAddress = new InetSocketAddress(connectAddress, connectPort);
 
104
 
 
105
      if (getSocketFactory() != null)
 
106
         configuration.put(Multiplex.SOCKET_FACTORY, getSocketFactory());
 
107
 
 
108
      Map parameters = configuration;
 
109
 
 
110
      if (parameters != null)
 
111
      {
 
112
         configureSocketGroupParameters(parameters);
 
113
      }
 
114
      }
 
115
      catch (Exception e)
 
116
      {
 
117
         throw new ConnectionFailedException(e.getMessage());
 
118
      }
 
119
   }
 
120
 
 
121
 
 
122
/**
 
123
 * Finishes the start up process, once adequate bind and connect information is
 
124
 * made available.  For more information, see the Multiplex subsystem documentation
 
125
 * at labs.jboss.org.
 
126
 */
 
127
   public void finishStart() throws IOException
 
128
   {
 
129
      if (socketGroupInfo != null &&
 
130
          socketGroupInfo.getBindAddress() != null &&
 
131
          bindSocketAddress == null)
 
132
      {
 
133
         InetAddress bindAddress = socketGroupInfo.getBindAddress();
 
134
         int bindPort = socketGroupInfo.getBindPort();
 
135
         bindSocketAddress = new InetSocketAddress(bindAddress, bindPort);
 
136
      }
 
137
 
 
138
      if (socketGroupInfo != null &&
 
139
          socketGroupInfo.getBindAddress() != null &&
 
140
          addressPair == null)
 
141
      {
 
142
         String bindHost = socketGroupInfo.getBindAddress().getHostName();
 
143
         int bindPort = socketGroupInfo.getBindPort();
 
144
         addressPair = new AddressPair(connectHost, connectPort, bindHost, bindPort);
 
145
      }
 
146
 
 
147
      readyToRun = true;
 
148
   }
 
149
 
 
150
   public InvokerLocator getCallbackLocator(Map metadata)
 
151
   {
 
152
      Socket socket = socketGroupInfo.getPrimingSocket();
 
153
      metadata.put(Multiplex.MULTIPLEX_CONNECT_HOST,
 
154
                   socket.getInetAddress().getHostAddress());
 
155
      metadata.put(Multiplex.MULTIPLEX_CONNECT_PORT,
 
156
                   Integer.toString(socket.getPort()));
 
157
      metadata.put(Multiplex.MULTIPLEX_BIND_HOST,
 
158
            socket.getInetAddress().getHostAddress());
 
159
      metadata.put(Multiplex.MULTIPLEX_BIND_PORT,
 
160
            Integer.toString(socket.getPort()));
 
161
      InvokerLocator locator = new InvokerLocator("multiplex",
 
162
                                                  socket.getLocalAddress().getHostAddress(),
 
163
                                                  socket.getLocalPort(),
 
164
                                                  null,
 
165
                                                  metadata);
 
166
      return locator;
 
167
   }
 
168
 
 
169
/**
 
170
 * @param parameters
 
171
 * @throws IOException
 
172
 */
 
173
   protected void configureSocketGroupParameters(Map parameters) throws IOException
 
174
   {
 
175
      String bindHost;
 
176
      String bindPortString;
 
177
      int bindPort = -1;
 
178
      InetAddress bindAddress = null;
 
179
      socketGroupId = (String) parameters.get(Multiplex.CLIENT_MULTIPLEX_ID);
 
180
      log.debug("socketGroupId: " + socketGroupId);
 
181
 
 
182
      synchronized (MultiplexServerInvoker.SocketGroupInfo.class)
 
183
      {
 
184
         if (socketGroupId != null)
 
185
            socketGroupInfo = (SocketGroupInfo) MultiplexServerInvoker.getSocketGroupMap().get(socketGroupId);
 
186
 
 
187
         if (socketGroupInfo != null && socketGroupInfo.getServerInvoker() != null)
 
188
         {
 
189
            log.debug("client rule 1");
 
190
 
 
191
            // If we get here, it's because a MultiplexServerInvoker created a SocketGroupInfo with matching
 
192
            // group id.  We want to make sure that it didn't get a connect address or connect port different
 
193
            // than the ones passed in through the parameters map.
 
194
            InetAddress socketGroupConnectAddress = socketGroupInfo.getConnectAddress();
 
195
            int socketGroupConnectPort = socketGroupInfo.getConnectPort();
 
196
 
 
197
            if (socketGroupConnectAddress != null && !socketGroupConnectAddress.equals(connectAddress))
 
198
            {
 
199
               String message = "socket group connect address (" + socketGroupConnectAddress +
 
200
                                ") does not match connect address (" + connectAddress + ")";
 
201
               log.error(message);
 
202
               throw new IOException(message);
 
203
            }
 
204
 
 
205
            if (socketGroupConnectPort > 0 && socketGroupConnectPort != connectPort)
 
206
            {
 
207
               String message = "socket group connect port (" + socketGroupConnectPort +
 
208
                                ") does not match connect port (" + connectPort + ")";
 
209
               log.error(message);
 
210
               throw new IOException(message);
 
211
            }
 
212
 
 
213
            bindAddress = socketGroupInfo.getBindAddress();
 
214
            bindPort = socketGroupInfo.getBindPort();
 
215
            bindSocketAddress = new InetSocketAddress(bindAddress, bindPort);
 
216
 
 
217
            if (socketGroupInfo.getPrimingSocket() == null)
 
218
            {
 
219
               String connectHost = connectAddress.getHostName();
 
220
               MultiplexServerInvoker.createPrimingSocket(socketGroupInfo, connectHost, connectPort,
 
221
                                                          bindAddress, bindPort,
 
222
                                                          configuration, timeout);
 
223
            }
 
224
 
 
225
            socketGroupInfo.setConnectAddress(connectAddress);
 
226
            socketGroupInfo.setConnectPort(connectPort);
 
227
            socketGroupInfo.addClientInvoker(this);
 
228
 
 
229
            // We got socketGroupInfo by socketGroupId.  Make sure it is also stored by AddressPair.
 
230
            bindHost = bindAddress.getHostName();
 
231
            addressPair = new AddressPair(connectHost, connectPort, bindHost, bindPort);
 
232
            MultiplexServerInvoker.getAddressPairMap().put(addressPair, socketGroupInfo);
 
233
 
 
234
            MultiplexServerInvoker serverInvoker = socketGroupInfo.getServerInvoker();
 
235
            if (serverInvoker != null)
 
236
               serverInvoker.finishStart();
 
237
 
 
238
            finishStart();
 
239
            return;
 
240
         }
 
241
 
 
242
         bindHost = (String) parameters.get(Multiplex.MULTIPLEX_BIND_HOST);
 
243
         bindPortString = (String) parameters.get(Multiplex.MULTIPLEX_BIND_PORT);
 
244
 
 
245
         if (bindHost != null && bindPortString == null)
 
246
         {
 
247
            bindPortString = "0";
 
248
         }
 
249
 
 
250
         if (bindHost == null && bindPortString != null)
 
251
         {
 
252
            bindHost = "localhost";
 
253
         }
 
254
 
 
255
         if (bindHost != null)
 
256
         {
 
257
            log.debug("client rule 2");
 
258
 
 
259
            try
 
260
            {
 
261
               bindPort = Integer.parseInt(bindPortString);
 
262
            }
 
263
            catch (NumberFormatException e)
 
264
            {
 
265
               throw new IOException("number format error for bindPort: " + bindPortString);
 
266
            }
 
267
 
 
268
            if (bindPort != 0)
 
269
            {
 
270
               bindSocketAddress = new InetSocketAddress(bindHost, bindPort);
 
271
               addressPair = new AddressPair(connectHost, connectPort, bindHost, bindPort);
 
272
               socketGroupInfo = (SocketGroupInfo) MultiplexServerInvoker.getAddressPairMap().get(addressPair);
 
273
            }
 
274
 
 
275
            // If socketGroupInfo exists, it's because it was created, along with a priming socket, by a
 
276
            // MultiplexServerInvoker.  Note that we don't look for a match if the bind port was
 
277
            // anonymous.
 
278
            if (socketGroupInfo != null)
 
279
            {
 
280
               socketGroupInfo.setConnectAddress(connectAddress);
 
281
               socketGroupInfo.setConnectPort(connectPort);
 
282
               socketGroupInfo.addClientInvoker(this);
 
283
 
 
284
               // We got socketGroupInfo by AddressPair.  Make sure it is stored by socketGroupId, if we have one.
 
285
               if (socketGroupId != null)
 
286
               {
 
287
                  String socketGroupSocketGroupId = socketGroupInfo.getSocketGroupId();
 
288
 
 
289
                  if (socketGroupSocketGroupId != null && !socketGroupSocketGroupId.equals(socketGroupId))
 
290
                  {
 
291
                     String message = "socket group multiplexId (" + socketGroupSocketGroupId +
 
292
                                      ") does not match multiplexId (" + socketGroupId + ")";
 
293
                     log.error(message);
 
294
                     throw new IOException(message);
 
295
                  }
 
296
 
 
297
                  if (socketGroupSocketGroupId == null)
 
298
                  {
 
299
                     socketGroupInfo.setSocketGroupId(socketGroupId);
 
300
                     MultiplexServerInvoker.getSocketGroupMap().put(socketGroupId, socketGroupInfo);
 
301
                  }
 
302
               }
 
303
 
 
304
               finishStart();
 
305
               return;
 
306
            }
 
307
 
 
308
            if (bindPort == 0 && socketGroupId == null)
 
309
            {
 
310
               String message = "Can never be found by any MultiplexServerInvoker: " +
 
311
                                "bind port == 0 and socketGroupId == null";
 
312
               log.warn(message);
 
313
            }
 
314
 
 
315
            // Anonymous bind port
 
316
            if (bindPort == 0)
 
317
               bindPort = PortUtil.findFreePort(bindHost);
 
318
 
 
319
            socketGroupInfo = new SocketGroupInfo();
 
320
            socketGroupInfo.setConnectAddress(connectAddress);
 
321
            socketGroupInfo.setConnectPort(connectPort);
 
322
            socketGroupInfo.addClientInvoker(this);
 
323
 
 
324
            // Set bindAddress and bindPort to be able to test for inconsistencies with bind address
 
325
            // and bind port determined by companion MultiplexServerInvoker.
 
326
            bindAddress = InetAddress.getByName(bindHost);
 
327
            socketGroupInfo.setBindAddress(bindAddress);
 
328
            socketGroupInfo.setBindPort(bindPort);
 
329
 
 
330
            String connectHost = connectAddress.getHostName();
 
331
            MultiplexServerInvoker.createPrimingSocket(socketGroupInfo, connectHost, connectPort,
 
332
                                                       bindAddress, bindPort, configuration, timeout);
 
333
            MultiplexServerInvoker.getAddressPairMap().put(addressPair, socketGroupInfo);
 
334
 
 
335
            if (socketGroupId != null)
 
336
            {
 
337
               socketGroupInfo.setSocketGroupId(socketGroupId);
 
338
               MultiplexServerInvoker.getSocketGroupMap().put(socketGroupId, socketGroupInfo);
 
339
            }
 
340
 
 
341
            finishStart();
 
342
            return;
 
343
         }
 
344
 
 
345
         if (socketGroupId != null)
 
346
         {
 
347
            log.debug("client rule 3");
 
348
 
 
349
            if (socketGroupInfo == null)
 
350
            {
 
351
               socketGroupInfo = new SocketGroupInfo();
 
352
               socketGroupInfo.setSocketGroupId(socketGroupId);
 
353
               socketGroupInfo.setConnectAddress(connectAddress);
 
354
               socketGroupInfo.setConnectPort(connectPort);
 
355
               MultiplexServerInvoker.getSocketGroupMap().put(socketGroupId, socketGroupInfo);
 
356
            }
 
357
 
 
358
            socketGroupInfo.addClientInvoker(this);
 
359
            return;
 
360
         }
 
361
 
 
362
         log.debug("client rule 4");
 
363
         String connectHost = connectAddress.getHostName();
 
364
         socketGroupInfo = new SocketGroupInfo();
 
365
         MultiplexServerInvoker.createPrimingSocket(socketGroupInfo, connectHost, connectPort,
 
366
                                                    configuration, timeout);
 
367
         finishStart();
 
368
      }
 
369
   }
 
370
 
 
371
   /**
 
372
    * @param sessionId
 
373
    * @param invocation
 
374
    * @param marshaller
 
375
    * @return
 
376
    * @throws java.io.IOException
 
377
    * @throws org.jboss.remoting.ConnectionFailedException
 
378
    *
 
379
    */
 
380
   protected Object transport(String sessionId, Object invocation, Map metadata, Marshaller marshaller, UnMarshaller unmarshaller)
 
381
   throws IOException, ConnectionFailedException, ClassNotFoundException
 
382
   {
 
383
      log.debug("entering transport()");
 
384
      if (!readyToRun)
 
385
         throw new IOException("connection to server has not been made");
 
386
 
 
387
      return super.transport(sessionId, invocation, metadata, marshaller, unmarshaller);
 
388
   }
 
389
 
 
390
 
 
391
   /**
 
392
    * subclasses must implement this method to provide a hook to disconnect from the remote server, if this applies
 
393
    * to the specific transport. However, in some transport implementations, this may not make must difference since
 
394
    * the connection is not persistent among invocations, such as SOAP.  In these cases, the method should
 
395
    * silently return without any processing.
 
396
    */
 
397
   protected void handleDisconnect()
 
398
   {
 
399
      //TODO: -TME Should this be a no op or need to pool?
 
400
 
 
401
      log.debug("entering handleDisconnect()");
 
402
      super.handleDisconnect();
 
403
 
 
404
      synchronized (MultiplexServerInvoker.SocketGroupInfo.class)
 
405
      {
 
406
         if (socketGroupInfo != null)
 
407
         {
 
408
            socketGroupInfo.removeClientInvoker(this);
 
409
 
 
410
            if (socketGroupInfo.getClientInvokers().isEmpty() && socketGroupInfo.getServerInvoker() == null)
 
411
            {
 
412
               log.debug("invoker group shutting down: " + socketGroupInfo.getSocketGroupId());
 
413
 
 
414
               if (socketGroupInfo.getPrimingSocket() != null)
 
415
               {
 
416
                  log.debug("MultiplexClientInvoker: closing bind priming socket");
 
417
 
 
418
                  VirtualSocket ps = socketGroupInfo.getPrimingSocket();
 
419
                  if (ps != null)
 
420
                  {
 
421
                     try
 
422
                     {
 
423
                        // When the remote virtual MultiplexServerInvoker learns that the
 
424
                        // priming socket has closed, it will close its VirtualServerSocket,
 
425
                        // rendering unshareable the MultiplexingManager that underlies this
 
426
                        // socket group.  We mark it as unshareable immediately so that it will
 
427
                        // not be reused by any other socket group.
 
428
                        ps.getManager().unregisterShareable();
 
429
                        ps.close();
 
430
                     }
 
431
                     catch (IOException e)
 
432
                     {
 
433
                        log.error("Error closing bind priming socket during cleanup upon stopping", e);
 
434
                     }
 
435
                  }
 
436
               }
 
437
 
 
438
               socketGroupId = socketGroupInfo.getSocketGroupId();
 
439
 
 
440
               if (socketGroupId != null)
 
441
               {
 
442
                  MultiplexServerInvoker.getSocketGroupMap().remove(socketGroupId);
 
443
               }
 
444
 
 
445
               // addressPair is set in finishStart().
 
446
               if (addressPair != null)
 
447
               {
 
448
                  MultiplexServerInvoker.getAddressPairMap().remove(addressPair);
 
449
               }
 
450
            }
 
451
 
 
452
            socketGroupInfo = null;  // Prevent from occurring a second time in Finalizer thread.
 
453
         }
 
454
      }
 
455
   }
 
456
 
 
457
 
 
458
/**
 
459
 * @return
 
460
 */
 
461
   protected InetSocketAddress getBindSocketAddress()
 
462
   {
 
463
      return bindSocketAddress;
 
464
   }
 
465
 
 
466
 
 
467
/**
 
468
 * @return
 
469
 */
 
470
   protected InetSocketAddress getConnectSocketAddress()
 
471
   {
 
472
      return connectSocketAddress;
 
473
   }
 
474
 
 
475
 
 
476
   /**
 
477
    * Each implementation of the remote client invoker should have
 
478
    * a default data type that is uses in the case it is not specified
 
479
    * in the invoker locator uri.
 
480
    *
 
481
    * @return
 
482
    */
 
483
   protected String getDefaultDataType()
 
484
   {
 
485
      return SerializableMarshaller.DATATYPE;
 
486
   }
 
487
 
 
488
 
 
489
   protected Socket createSocket(String address, int port, int timeout) throws IOException
 
490
   {
 
491
      log.debug("MultiplexClientInvoker.createSocket()");
 
492
      
 
493
      if (timeout < 0)
 
494
      {
 
495
         timeout = getTimeout();
 
496
         if (timeout < 0)
 
497
            timeout = 0;
 
498
      }
 
499
 
 
500
      // If connection has been broken, try to connect to new server.
 
501
      if (socketGroupInfo != null && socketGroupInfo.getPrimingSocket() != null)
 
502
      {
 
503
         VirtualSocket primingSocket = socketGroupInfo.getPrimingSocket();
 
504
         if (!primingSocket.isFunctional() || primingSocket.hasReceivedDisconnectMessage())
 
505
         {
 
506
            log.info("Current server is inaccessible.  Will try to connect to new server");
 
507
            primingSocket.close();
 
508
 
 
509
            // Get new priming socket.
 
510
            if (bindSocketAddress != null)
 
511
            {
 
512
               InetAddress bindAddress = bindSocketAddress.getAddress();
 
513
               int bindPort = PortUtil.findFreePort(bindSocketAddress.getHostName());
 
514
               socketGroupInfo.setBindPort(bindPort);
 
515
               bindSocketAddress = new InetSocketAddress(bindAddress, bindPort);
 
516
               MultiplexServerInvoker.createPrimingSocket(socketGroupInfo,
 
517
                                                          connectHost, connectPort,
 
518
                                                          bindAddress, bindPort,
 
519
                                                          configuration, timeout);
 
520
            }
 
521
            else
 
522
               MultiplexServerInvoker.createPrimingSocket(socketGroupInfo,
 
523
                                                          connectHost, connectPort,
 
524
                                                          configuration, port);
 
525
 
 
526
            MultiplexServerInvoker serverInvoker = socketGroupInfo.getServerInvoker();
 
527
            if (serverInvoker != null)
 
528
            {
 
529
               try
 
530
               {
 
531
                  // Restart callback server invoker with new server socket.
 
532
                  serverInvoker.stop();
 
533
                  socketGroupInfo.setServerInvoker(null);
 
534
                  serverInvoker.resetLocator(bindSocketAddress.getPort());
 
535
                  serverInvoker.refreshServerSocket();
 
536
                  serverInvoker.setup();
 
537
                  serverInvoker.start();
 
538
               }
 
539
               catch (Exception e)
 
540
               {
 
541
                  log.error(e.getMessage(), e);
 
542
               }
 
543
            }
 
544
 
 
545
            VirtualSocket socket = new VirtualSocket(configuration);
 
546
            for (int i = 0; i < 3; i++)
 
547
            {
 
548
               try
 
549
               {
 
550
                  socket.connect(connectSocketAddress, bindSocketAddress, timeout);
 
551
                  return socket;
 
552
               }
 
553
               catch (Exception e)
 
554
               {
 
555
                  try
 
556
                  {
 
557
                     Thread.sleep(500);
 
558
                  }
 
559
                  catch (InterruptedException e1)
 
560
                  {
 
561
                  }
 
562
               }
 
563
            }
 
564
         }
 
565
      }
 
566
 
 
567
      VirtualSocket socket = new VirtualSocket(configuration);
 
568
      socket.connect(connectSocketAddress, bindSocketAddress, timeout);
 
569
      return socket;
 
570
   }
 
571
}
 
 
b'\\ No newline at end of file'