java/src/IceInternal/RoutableReference.java

   1 // **********************************************************************
   2 //
   3 // Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   4 //
   5 // This copy of Ice is licensed to you under the terms described in the
   6 // ICE_LICENSE file included in this distribution.
   7 //
   8 // **********************************************************************
   9
  10 package IceInternal;
  11
  12 public class RoutableReference extends Reference
  13 {
  14     public final EndpointI[]
  15     getEndpoints()
  16     {
  17         return _endpoints;
  18     }
  19
  20     public final String
  21     getAdapterId()
  22     {
  23         return _adapterId;
  24     }
  25
  26     public final LocatorInfo
  27     getLocatorInfo()
  28     {
  29         return _locatorInfo;
  30     }
  31
  32     public final RouterInfo
  33     getRouterInfo()
  34     {
  35         return _routerInfo;
  36     }
  37
  38     public final boolean
  39     getCollocationOptimized()
  40     {
  41         return _collocationOptimized;
  42     }
  43
  44     public final boolean
  45     getCacheConnection()
  46     {
  47         return _cacheConnection;
  48     }
  49
  50     public final boolean
  51     getPreferSecure()
  52     {
  53         return _preferSecure;
  54     }
  55
  56     public final Ice.EndpointSelectionType
  57     getEndpointSelection()
  58     {
  59         return _endpointSelection;
  60     }
  61
  62     public final int
  63     getLocatorCacheTimeout()
  64     {
  65         return _locatorCacheTimeout;
  66     }
  67
  68     public final String
  69     getConnectionId()
  70     {
  71         return _connectionId;
  72     }
  73
  74     public Reference
  75     changeCompress(boolean newCompress)
  76     {
  77         RoutableReference r = (RoutableReference)super.changeCompress(newCompress);
  78         if(r != this && _endpoints.length > 0) // Also override the compress flag on the endpoints if it was updated.
  79         {
  80             EndpointI[] newEndpoints = new EndpointI[_endpoints.length];
  81             for(int i = 0; i < _endpoints.length; i++)
  82             {
  83                 newEndpoints[i] = _endpoints[i].compress(newCompress);
  84             }
  85             r._endpoints = newEndpoints;
  86         }
  87         return r;
  88     }
  89
  90     public Reference
  91     changeEndpoints(EndpointI[] newEndpoints)
  92     {
  93         if(java.util.Arrays.equals(newEndpoints, _endpoints))
  94         {
  95             return this;
  96         }
  97         RoutableReference r = (RoutableReference)getInstance().referenceFactory().copy(this);
  98         r._endpoints = newEndpoints;
  99         r._adapterId = "";
 100         r.applyOverrides(r._endpoints);
 101         return r;
 102     }
 103
 104     public Reference
 105     changeAdapterId(String newAdapterId)
 106     {
 107         if(_adapterId.equals(newAdapterId))
 108         {
 109             return this;
 110         }
 111         RoutableReference r = (RoutableReference)getInstance().referenceFactory().copy(this);
 112         r._adapterId = newAdapterId;
 113         r._endpoints = _emptyEndpoints;
 114         return r;
 115     }
 116
 117     public Reference
 118     changeLocator(Ice.LocatorPrx newLocator)
 119     {
 120         LocatorInfo newLocatorInfo = getInstance().locatorManager().get(newLocator);
 121         if(newLocatorInfo != null && _locatorInfo != null && newLocatorInfo.equals(_locatorInfo))
 122         {
 123             return this;
 124         }
 125         RoutableReference r = (RoutableReference)getInstance().referenceFactory().copy(this);
 126         r._locatorInfo = newLocatorInfo;
 127         return r;
 128     }
 129
 130     public Reference
 131     changeRouter(Ice.RouterPrx newRouter)
 132     {
 133         RouterInfo newRouterInfo = getInstance().routerManager().get(newRouter);
 134         if(newRouterInfo != null && _routerInfo != null && newRouterInfo.equals(_routerInfo))
 135         {
 136             return this;
 137         }
 138         RoutableReference r = (RoutableReference)getInstance().referenceFactory().copy(this);
 139         r._routerInfo = newRouterInfo;
 140         return r;
 141     }
 142
 143     public Reference
 144     changeCollocationOptimized(boolean newCollocationOptimized)
 145     {
 146         if(newCollocationOptimized == _collocationOptimized)
 147         {
 148             return this;
 149         }
 150         RoutableReference r = (RoutableReference)getInstance().referenceFactory().copy(this);
 151         r._collocationOptimized = newCollocationOptimized;
 152         return r;
 153     }
 154
 155     public final Reference
 156     changeCacheConnection(boolean newCache)
 157     {
 158         if(newCache == _cacheConnection)
 159         {
 160             return this;
 161         }
 162         RoutableReference r = (RoutableReference)getInstance().referenceFactory().copy(this);
 163         r._cacheConnection = newCache;
 164         return r;
 165     }
 166
 167     public Reference
 168     changePreferSecure(boolean newPreferSecure)
 169     {
 170         if(newPreferSecure == _preferSecure)
 171         {
 172             return this;
 173         }
 174         RoutableReference r = (RoutableReference)getInstance().referenceFactory().copy(this);
 175         r._preferSecure = newPreferSecure;
 176         return r;
 177     }
 178
 179     public final Reference
 180     changeEndpointSelection(Ice.EndpointSelectionType newType)
 181     {
 182         if(newType == _endpointSelection)
 183         {
 184             return this;
 185         }
 186         RoutableReference r = (RoutableReference)getInstance().referenceFactory().copy(this);
 187         r._endpointSelection = newType;
 188         return r;
 189     }
 190
 191     public Reference
 192     changeLocatorCacheTimeout(int newTimeout)
 193     {
 194         if(_locatorCacheTimeout == newTimeout)
 195         {
 196             return this;
 197         }
 198         RoutableReference r = (RoutableReference)getInstance().referenceFactory().copy(this);
 199         r._locatorCacheTimeout = newTimeout;
 200         return r;
 201     }
 202
 203     public Reference
 204     changeTimeout(int newTimeout)
 205     {
 206         if(_overrideTimeout && _timeout == newTimeout)
 207         {
 208             return this;
 209         }
 210         RoutableReference r = (RoutableReference)getInstance().referenceFactory().copy(this);
 211         r._timeout = newTimeout;
 212         r._overrideTimeout = true;
 213         if(_endpoints.length > 0)
 214         {
 215             EndpointI[] newEndpoints = new EndpointI[_endpoints.length];
 216             for(int i = 0; i < _endpoints.length; i++)
 217             {
 218                 newEndpoints[i] = _endpoints[i].timeout(newTimeout);
 219             }
 220             r._endpoints = newEndpoints;
 221         }
 222         return r;
 223     }
 224
 225     public Reference
 226     changeConnectionId(String id)
 227     {
 228         if(_connectionId.equals(id))
 229         {
 230             return this;
 231         }
 232         RoutableReference r = (RoutableReference)getInstance().referenceFactory().copy(this);
 233         r._connectionId = id;
 234         if(_endpoints.length > 0)
 235         {
 236             EndpointI[] newEndpoints = new EndpointI[_endpoints.length];
 237             for(int i = 0; i < _endpoints.length; i++)
 238             {
 239                 newEndpoints[i] = _endpoints[i].connectionId(id);
 240             }
 241             r._endpoints = newEndpoints;
 242         }
 243         return r;
 244     }
 245
 246     public boolean
 247     isIndirect()
 248     {
 249         return _endpoints.length == 0;
 250     }
 251
 252     public boolean
 253     isWellKnown()
 254     {
 255         return _endpoints.length == 0 && _adapterId.length() == 0;
 256     }
 257
 258     public void
 259     streamWrite(BasicStream s)
 260         throws Ice.MarshalException
 261     {
 262         super.streamWrite(s);
 263
 264         s.writeSize(_endpoints.length);
 265         if(_endpoints.length > 0)
 266         {
 267             assert(_adapterId.length() == 0);
 268             for(EndpointI endpoint : _endpoints)
 269             {
 270                 endpoint.streamWrite(s);
 271             }
 272         }
 273         else
 274         {
 275             s.writeString(_adapterId); // Adapter id.
 276         }
 277     }
 278
 279     public String
 280     toString()
 281     {
 282         //
 283         // WARNING: Certain features, such as proxy validation in Glacier2,
 284         // depend on the format of proxy strings. Changes to toString() and
 285         // methods called to generate parts of the reference string could break
 286         // these features. Please review for all features that depend on the
 287         // format of proxyToString() before changing this and related code.
 288         //
 289         StringBuilder s = new StringBuilder(128);
 290         s.append(super.toString());
 291         if(_endpoints.length > 0)
 292         {
 293             for(EndpointI endpoint : _endpoints)
 294             {
 295                 String endp = endpoint.toString();
 296                 if(endp != null && endp.length() > 0)
 297                 {
 298                     s.append(':');
 299                     s.append(endp);
 300                 }
 301             }
 302         }
 303         else if(_adapterId.length() > 0)
 304         {
 305             s.append(" @ ");
 306
 307             //
 308             // If the encoded adapter id string contains characters which
 309             // the reference parser uses as separators, then we enclose
 310             // the adapter id string in quotes.
 311             //
 312             String a = IceUtilInternal.StringUtil.escapeString(_adapterId, null);
 313             if(IceUtilInternal.StringUtil.findFirstOf(a, " :@") != -1)
 314             {
 315                 s.append('"');
 316                 s.append(a);
 317                 s.append('"');
 318             }
 319             else
 320             {
 321                 s.append(a);
 322             }
 323         }
 324         return s.toString();
 325     }
 326
 327     public java.util.Map<String, String> toProperty(String prefix)
 328     {
 329         java.util.Map<String, String> properties = new java.util.HashMap<String, String>();
 330
 331         properties.put(prefix, toString());
 332         properties.put(prefix + ".CollocationOptimized", _collocationOptimized ? "1" : "0");
 333         properties.put(prefix + ".ConnectionCached", _cacheConnection ? "1" : "0");
 334         properties.put(prefix + ".PreferSecure", _preferSecure ? "1" : "0");
 335         properties.put(prefix + ".EndpointSelection",
 336                        _endpointSelection == Ice.EndpointSelectionType.Random ? "Random" : "Ordered");
 337
 338         StringBuffer s = new StringBuffer();
 339         s.append(_locatorCacheTimeout);
 340         properties.put(prefix + ".LocatorCacheTimeout", s.toString());
 341
 342         if(_routerInfo != null)
 343         {
 344             Ice.ObjectPrxHelperBase h = (Ice.ObjectPrxHelperBase)_routerInfo.getRouter();
 345             java.util.Map<String, String> routerProperties = h.__reference().toProperty(prefix + ".Router");
 346             for(java.util.Map.Entry<String, String> p : routerProperties.entrySet())
 347             {
 348                 properties.put(p.getKey(), p.getValue());
 349             }
 350         }
 351
 352         if(_locatorInfo != null)
 353         {
 354             Ice.ObjectPrxHelperBase h = (Ice.ObjectPrxHelperBase)_locatorInfo.getLocator();
 355             java.util.Map<String, String> locatorProperties = h.__reference().toProperty(prefix + ".Locator");
 356             for(java.util.Map.Entry<String, String> p : locatorProperties.entrySet())
 357             {
 358                 properties.put(p.getKey(), p.getValue());
 359             }
 360         }
 361
 362         return properties;
 363     }
 364
 365     public synchronized int
 366     hashCode()
 367     {
 368         if(!_hashInitialized)
 369         {
 370             super.hashCode(); // Initializes _hashValue.
 371
 372             // Add hash of adapter ID to base hash.
 373             _hashValue = 5 * _hashValue + _adapterId.hashCode();
 374         }
 375         return _hashValue;
 376     }
 377
 378     public boolean
 379     equals(java.lang.Object obj)
 380     {
 381         if(this == obj)
 382         {
 383             return true;
 384         }
 385         if(!(obj instanceof RoutableReference))
 386         {
 387             return false;
 388         }
 389
 390         if(!super.equals(obj))
 391         {
 392             return false;
 393         }
 394         RoutableReference rhs = (RoutableReference)obj; // Guaranteed to succeed.
 395         if(_locatorInfo == null ? rhs._locatorInfo != null : !_locatorInfo.equals(rhs._locatorInfo))
 396         {
 397             return false;
 398         }
 399         if(_routerInfo == null ? rhs._routerInfo != null : !_routerInfo.equals(rhs._routerInfo))
 400         {
 401             return false;
 402         }
 403         if(_collocationOptimized != rhs._collocationOptimized)
 404         {
 405             return false;
 406         }
 407         if(_cacheConnection != rhs._cacheConnection)
 408         {
 409             return false;
 410         }
 411         if(_preferSecure != rhs._preferSecure)
 412         {
 413             return false;
 414         }
 415         if(_endpointSelection != rhs._endpointSelection)
 416         {
 417             return false;
 418         }
 419         if(_locatorCacheTimeout != rhs._locatorCacheTimeout)
 420         {
 421             return false;
 422         }
 423         if(!_connectionId.equals(rhs._connectionId))
 424         {
 425            return false;
 426         }
 427         if(_overrideTimeout != rhs._overrideTimeout)
 428         {
 429            return false;
 430         }
 431         if(_overrideTimeout && _timeout != rhs._timeout)
 432         {
 433             return false;
 434         }
 435         if(!java.util.Arrays.equals(_endpoints, rhs._endpoints))
 436         {
 437             return false;
 438         }
 439         if(!_adapterId.equals(rhs._adapterId))
 440         {
 441            return false;
 442         }
 443         return true;
 444     }
 445
 446     public Ice.ConnectionI
 447     getConnection(Ice.BooleanHolder comp)
 448     {
 449         if(_routerInfo != null)
 450         {
 451             //
 452             // If we route, we send everything to the router's client
 453             // proxy endpoints.
 454             //
 455             EndpointI[] endpts = _routerInfo.getClientEndpoints();
 456             if(endpts.length > 0)
 457             {
 458                 applyOverrides(endpts);
 459                 return createConnection(endpts, comp);
 460             }
 461         }
 462
 463         if(_endpoints.length > 0)
 464         {
 465             return createConnection(_endpoints, comp);
 466         }
 467
 468         while(true)
 469         {
 470             Ice.BooleanHolder cached = new Ice.BooleanHolder(false);
 471             EndpointI[] endpts = null;
 472             if(_locatorInfo != null)
 473             {
 474                 endpts = _locatorInfo.getEndpoints(this, _locatorCacheTimeout, cached);
 475                 applyOverrides(endpts);
 476             }
 477
 478             if(endpts == null || endpts.length == 0)
 479             {
 480                 throw new Ice.NoEndpointException(toString());
 481             }
 482
 483             try
 484             {
 485                 return createConnection(endpts, comp);
 486             }
 487             catch(Ice.NoEndpointException ex)
 488             {
 489                 throw ex; // No need to retry if there's no endpoints.
 490             }
 491             catch(Ice.LocalException ex)
 492             {
 493                 assert(_locatorInfo != null);
 494                 _locatorInfo.clearCache(this);
 495                 if(cached.value)
 496                 {
 497                     TraceLevels traceLevels = getInstance().traceLevels();
 498                     if(traceLevels.retry >= 2)
 499                     {
 500                         String s = "connection to cached endpoints failed\n" +
 501                             "removing endpoints from cache and trying one more time\n" + ex;
 502                         getInstance().initializationData().logger.trace(traceLevels.retryCat, s);
 503                     }
 504                     continue; // Try again if the endpoints were cached.
 505                 }
 506                 throw ex;
 507             }
 508         }
 509     }
 510
 511     public void
 512     getConnection(final GetConnectionCallback callback)
 513     {
 514         if(_routerInfo != null)
 515         {
 516             //
 517             // If we route, we send everything to the router's client
 518             // proxy endpoints.
 519             //
 520             _routerInfo.getClientEndpoints(new RouterInfo.GetClientEndpointsCallback()
 521                 {
 522                     public void
 523                     setEndpoints(EndpointI[] endpts)
 524                     {
 525                         if(endpts.length > 0)
 526                         {
 527                             applyOverrides(endpts);
 528                             createConnection(endpts, callback);
 529                         }
 530                         else
 531                         {
 532                             getConnectionNoRouterInfo(callback);
 533                         }
 534                     }
 535
 536                     public void
 537                     setException(Ice.LocalException ex)
 538                     {
 539                         callback.setException(ex);
 540                     }
 541                 });
 542         }
 543         else
 544         {
 545             getConnectionNoRouterInfo(callback);
 546         }
 547     }
 548
 549     public void
 550     getConnectionNoRouterInfo(final GetConnectionCallback callback)
 551     {
 552         if(_endpoints.length > 0)
 553         {
 554             createConnection(_endpoints, callback);
 555             return;
 556         }
 557
 558         final RoutableReference self = this;
 559         if(_locatorInfo != null)
 560         {
 561             _locatorInfo.getEndpoints(this, _locatorCacheTimeout, new LocatorInfo.GetEndpointsCallback()
 562             {
 563                 public void
 564                 setEndpoints(EndpointI[] endpoints, final boolean cached)
 565                 {
 566                     if(endpoints.length == 0)
 567                     {
 568                         callback.setException(new Ice.NoEndpointException(self.toString()));
 569                         return;
 570                     }
 571
 572                     applyOverrides(endpoints);
 573                     createConnection(endpoints, new GetConnectionCallback()
 574                     {
 575                         public void
 576                         setConnection(Ice.ConnectionI connection, boolean compress)
 577                         {
 578                             callback.setConnection(connection, compress);
 579                         }
 580
 581                         public void
 582                         setException(Ice.LocalException exc)
 583                         {
 584                             try
 585                             {
 586                                 throw exc;
 587                             }
 588                             catch(Ice.NoEndpointException ex)
 589                             {
 590                                 callback.setException(ex); // No need to retry if there's no endpoints.
 591                             }
 592                             catch(Ice.LocalException ex)
 593                             {
 594                                 assert(_locatorInfo != null);
 595                                 _locatorInfo.clearCache(self);
 596                                 if(cached)
 597                                 {
 598                                     TraceLevels traceLvls = getInstance().traceLevels();
 599                                     if(traceLvls.retry >= 2)
 600                                     {
 601                                         String s = "connection to cached endpoints failed\n" +
 602                                             "removing endpoints from cache and trying one more time\n" + ex;
 603                                         getInstance().initializationData().logger.trace(traceLvls.retryCat, s);
 604                                     }
 605                                     getConnectionNoRouterInfo(callback); // Retry.
 606                                     return;
 607                                 }
 608                                 callback.setException(ex);
 609                             }
 610                         }
 611                         });
 612                 }
 613
 614                 public void
 615                 setException(Ice.LocalException ex)
 616                 {
 617                     callback.setException(ex);
 618                 }
 619             });
 620         }
 621         else
 622         {
 623             callback.setException(new Ice.NoEndpointException(toString()));
 624         }
 625     }
 626
 627     protected
 628     RoutableReference(Instance instance,
 629                       Ice.Communicator communicator,
 630                       Ice.Identity identity,
 631                       String facet,
 632                       int mode,
 633                       boolean secure,
 634                       EndpointI[] endpoints,
 635                       String adapterId,
 636                       LocatorInfo locatorInfo,
 637                       RouterInfo routerInfo,
 638                       boolean collocationOptimized,
 639                       boolean cacheConnection,
 640                       boolean prefereSecure,
 641                       Ice.EndpointSelectionType endpointSelection,
 642                       int locatorCacheTimeout)
 643     {
 644         super(instance, communicator, identity, facet, mode, secure);
 645         _endpoints = endpoints;
 646         _adapterId = adapterId;
 647         _locatorInfo = locatorInfo;
 648         _routerInfo = routerInfo;
 649         _collocationOptimized = collocationOptimized;
 650         _cacheConnection = cacheConnection;
 651         _preferSecure = prefereSecure;
 652         _endpointSelection = endpointSelection;
 653         _locatorCacheTimeout = locatorCacheTimeout;
 654         _overrideTimeout = false;
 655         _timeout = -1;
 656
 657         if(_endpoints == null)
 658         {
 659             _endpoints = _emptyEndpoints;
 660         }
 661         if(_adapterId == null)
 662         {
 663             _adapterId = "";
 664         }
 665         assert(_adapterId.length() == 0 || _endpoints.length == 0);
 666     }
 667
 668     protected void
 669     applyOverrides(EndpointI[] endpts)
 670     {
 671         //
 672         // Apply the endpoint overrides to each endpoint.
 673         //
 674         for(int i = 0; i < endpts.length; ++i)
 675         {
 676             endpts[i] = endpts[i].connectionId(_connectionId);
 677             if(_overrideCompress)
 678             {
 679                 endpts[i] = endpts[i].compress(_compress);
 680             }
 681             if(_overrideTimeout)
 682             {
 683                 endpts[i] = endpts[i].timeout(_timeout);
 684             }
 685         }
 686     }
 687
 688     private EndpointI[]
 689     filterEndpoints(EndpointI[] allEndpoints)
 690     {
 691         java.util.List<EndpointI> endpoints = new java.util.ArrayList<EndpointI>();
 692
 693         //
 694         // Filter out opaque endpoints.
 695         //
 696         for(EndpointI endpoint : allEndpoints)
 697         {
 698             if(!(endpoint instanceof IceInternal.OpaqueEndpointI))
 699             {
 700                 endpoints.add(endpoint);
 701             }
 702         }
 703
 704         //
 705         // Filter out endpoints according to the mode of the reference.
 706         //
 707         switch(getMode())
 708         {
 709             case Reference.ModeTwoway:
 710             case Reference.ModeOneway:
 711             case Reference.ModeBatchOneway:
 712             {
 713                 //
 714                 // Filter out datagram endpoints.
 715                 //
 716                 java.util.Iterator<EndpointI> i = endpoints.iterator();
 717                 while(i.hasNext())
 718                 {
 719                     EndpointI endpoint = i.next();
 720                     if(endpoint.datagram())
 721                     {
 722                         i.remove();
 723                     }
 724                 }
 725                 break;
 726             }
 727
 728             case Reference.ModeDatagram:
 729             case Reference.ModeBatchDatagram:
 730             {
 731                 //
 732                 // Filter out non-datagram endpoints.
 733                 //
 734                 java.util.Iterator<EndpointI> i = endpoints.iterator();
 735                 while(i.hasNext())
 736                 {
 737                     EndpointI endpoint = i.next();
 738                     if(!endpoint.datagram())
 739                     {
 740                         i.remove();
 741                     }
 742                 }
 743                 break;
 744             }
 745         }
 746
 747         //
 748         // Sort the endpoints according to the endpoint selection type.
 749         //
 750         switch(getEndpointSelection())
 751         {
 752             case Random:
 753             {
 754                 java.util.Collections.shuffle(endpoints);
 755                 break;
 756             }
 757             case Ordered:
 758             {
 759                 // Nothing to do.
 760                 break;
 761             }
 762             default:
 763             {
 764                 assert(false);
 765                 break;
 766             }
 767         }
 768
 769         //
 770         // If a secure connection is requested or secure overrides is
 771         // set, remove all non-secure endpoints. Otherwise if preferSecure is set
 772         // make secure endpoints prefered. By default make non-secure
 773         // endpoints preferred over secure endpoints.
 774         //
 775         DefaultsAndOverrides overrides = getInstance().defaultsAndOverrides();
 776         if(overrides.overrideSecure ? overrides.overrideSecureValue : getSecure())
 777         {
 778             java.util.Iterator<EndpointI> i = endpoints.iterator();
 779             while(i.hasNext())
 780             {
 781                 EndpointI endpoint = i.next();
 782                 if(!endpoint.secure())
 783                 {
 784                     i.remove();
 785                 }
 786             }
 787         }
 788         else if(getPreferSecure())
 789         {
 790             java.util.Collections.sort(endpoints, _preferSecureEndpointComparator);
 791         }
 792         else
 793         {
 794             java.util.Collections.sort(endpoints, _preferNonSecureEndpointComparator);
 795         }
 796
 797         return (EndpointI[])endpoints.toArray(new EndpointI[endpoints.size()]);
 798     }
 799
 800     protected Ice.ConnectionI
 801     createConnection(EndpointI[] allEndpoints, Ice.BooleanHolder compress)
 802     {
 803         EndpointI[] endpoints = filterEndpoints(allEndpoints);
 804         if(endpoints.length == 0)
 805         {
 806             throw new Ice.NoEndpointException(toString());
 807         }
 808
 809         //
 810         // Finally, create the connection.
 811         //
 812         OutgoingConnectionFactory factory = getInstance().outgoingConnectionFactory();
 813         Ice.ConnectionI connection = null;
 814         if(getCacheConnection() || endpoints.length == 1)
 815         {
 816             //
 817             // Get an existing connection or create one if there's no
 818             // existing connection to one of the given endpoints.
 819             //
 820             connection = factory.create(endpoints, false, getEndpointSelection(), compress);
 821         }
 822         else
 823         {
 824             //
 825             // Go through the list of endpoints and try to create the
 826             // connection until it succeeds. This is different from just
 827             // calling create() with the given endpoints since this might
 828             // create a new connection even if there's an existing
 829             // connection for one of the endpoints.
 830             //
 831
 832             Ice.LocalException exception = null;
 833             EndpointI[] endpoint = new EndpointI[1];
 834             for(int i = 0; i < endpoints.length; ++i)
 835             {
 836                 try
 837                 {
 838                     endpoint[0] = endpoints[i];
 839                     final boolean more = i != endpoints.length - 1;
 840                     connection = factory.create(endpoint, more, getEndpointSelection(), compress);
 841                     break;
 842                 }
 843                 catch(Ice.LocalException ex)
 844                 {
 845                     exception = ex;
 846                 }
 847             }
 848
 849             if(connection == null)
 850             {
 851                 assert(exception != null);
 852                 throw exception;
 853             }
 854         }
 855
 856         assert(connection != null);
 857
 858         //
 859         // If we have a router, set the object adapter for this router
 860         // (if any) to the new connection, so that callbacks from the
 861         // router can be received over this new connection.
 862         //
 863         if(_routerInfo != null && _routerInfo.getAdapter() != null)
 864         {
 865             connection.setAdapter(_routerInfo.getAdapter());
 866         }
 867
 868         return connection;
 869     }
 870
 871     protected void
 872     createConnection(EndpointI[] allEndpoints, final GetConnectionCallback callback)
 873     {
 874         final EndpointI[] endpoints = filterEndpoints(allEndpoints);
 875         if(endpoints.length == 0)
 876         {
 877             callback.setException(new Ice.NoEndpointException(toString()));
 878             return;
 879         }
 880
 881         //
 882         // Finally, create the connection.
 883         //
 884         final OutgoingConnectionFactory factory = getInstance().outgoingConnectionFactory();
 885         if(getCacheConnection() || endpoints.length == 1)
 886         {
 887             //
 888             // Get an existing connection or create one if there's no
 889             // existing connection to one of the given endpoints.
 890             //
 891             factory.create(endpoints, false, getEndpointSelection(),
 892                            new OutgoingConnectionFactory.CreateConnectionCallback()
 893                            {
 894                                public void
 895                                setConnection(Ice.ConnectionI connection, boolean compress)
 896                                {
 897                                    //
 898                                    // If we have a router, set the object adapter for this router
 899                                    // (if any) to the new connection, so that callbacks from the
 900                                    // router can be received over this new connection.
 901                                    //
 902                                    if(_routerInfo != null && _routerInfo.getAdapter() != null)
 903                                    {
 904                                        connection.setAdapter(_routerInfo.getAdapter());
 905                                    }
 906                                    callback.setConnection(connection, compress);
 907                                }
 908
 909                                public void
 910                                setException(Ice.LocalException ex)
 911                                {
 912                                    callback.setException(ex);
 913                                }
 914                            });
 915         }
 916         else
 917         {
 918             //
 919             // Go through the list of endpoints and try to create the
 920             // connection until it succeeds. This is different from just
 921             // calling create() with the given endpoints since this might
 922             // create a new connection even if there's an existing
 923             // connection for one of the endpoints.
 924             //
 925
 926             factory.create(new EndpointI[]{ endpoints[0] }, true, getEndpointSelection(),
 927                            new OutgoingConnectionFactory.CreateConnectionCallback()
 928                            {
 929                                public void
 930                                setConnection(Ice.ConnectionI connection, boolean compress)
 931                                {
 932                                    //
 933                                    // If we have a router, set the object adapter for this router
 934                                    // (if any) to the new connection, so that callbacks from the
 935                                    // router can be received over this new connection.
 936                                    //
 937                                    if(_routerInfo != null && _routerInfo.getAdapter() != null)
 938                                    {
 939                                        connection.setAdapter(_routerInfo.getAdapter());
 940                                    }
 941                                    callback.setConnection(connection, compress);
 942                                }
 943
 944                                public void
 945                                setException(final Ice.LocalException ex)
 946                                {
 947                                    if(_exception == null)
 948                                    {
 949                                        _exception = ex;
 950                                    }
 951
 952                                    if(++_i == endpoints.length)
 953                                    {
 954                                        callback.setException(_exception);
 955                                        return;
 956                                    }
 957
 958                                    final boolean more = _i != endpoints.length - 1;
 959                                    final EndpointI[] endpoint = new EndpointI[]{ endpoints[_i] };
 960                                    factory.create(endpoint, more, getEndpointSelection(), this);
 961                                }
 962
 963                                private int _i = 0;
 964                                private Ice.LocalException _exception = null;
 965                            });
 966         }
 967     }
 968
 969     static class EndpointComparator implements java.util.Comparator<EndpointI>
 970     {
 971         EndpointComparator(boolean preferSecure)
 972         {
 973             _preferSecure = preferSecure;
 974         }
 975
 976         public int
 977         compare(EndpointI le, EndpointI re)
 978         {
 979             boolean ls = le.secure();
 980             boolean rs = re.secure();
 981             if((ls && rs) || (!ls && !rs))
 982             {
 983                 return 0;
 984             }
 985             else if(!ls && rs)
 986             {
 987                 if(_preferSecure)
 988                 {
 989                     return 1;
 990                 }
 991                 else
 992                 {
 993                     return -1;
 994                 }
 995             }
 996             else
 997             {
 998                 if(_preferSecure)
 999                 {
1000                     return -1;
1001                 }
1002                 else
1003                 {
1004                     return 1;
1005                 }
1006             }
1007         }
1008
1009         private boolean _preferSecure;
1010     }
1011
1012     private static EndpointComparator _preferNonSecureEndpointComparator = new EndpointComparator(false);
1013     private static EndpointComparator _preferSecureEndpointComparator = new EndpointComparator(true);
1014     private static EndpointI[] _emptyEndpoints = new EndpointI[0];
1015
1016     private EndpointI[] _endpoints;
1017     private String _adapterId;
1018     private LocatorInfo _locatorInfo; // Null if no router is used.
1019     private RouterInfo _routerInfo; // Null if no router is used.
1020     private boolean _collocationOptimized;
1021     private boolean _cacheConnection;
1022     private boolean _preferSecure;
1023     private Ice.EndpointSelectionType _endpointSelection;
1024     private int _locatorCacheTimeout;
1025
1026     private boolean _overrideTimeout;
1027     private int _timeout; // Only used if _overrideTimeout == true
1028     private String _connectionId = "";
1029 }