Eventually stop retrying port allocation if it fails repeatedly.

lib/http_multi_server.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library http_multi_server;
 
 import 'dart:async';
 import 'dart:io';
 
 import 'src/multi_headers.dart';
@@ skipping 110 matching lines @@
         HttpServer.bindSecure(address, port, backlog: backlog,
             certificateName: certificateName,
             requestClientCertificate: requestClientCertificate));
   }
 
   /// A helper method for initializing loopback servers.
   ///
   /// [bind] should forward to either [HttpServer.bind] or
   /// [HttpServer.bindSecure].
   static Future<HttpServer> _loopback(int port,
-      Future<HttpServer> bind(InternetAddress address, int port)) {
+      Future<HttpServer> bind(InternetAddress address, int port),
+      [int remainingRetries]) {
+    if (remainingRetries == null) remainingRetries = 5;
+
     return Future.wait([
       supportsIpV6,
       bind(InternetAddress.LOOPBACK_IP_V4, port)
     ]).then((results) {
       var supportsIpV6 = results[0];
       var v4Server = results[1];
 
       if (!supportsIpV6) return v4Server;
 
       // Reuse the IPv4 server's port so that if [port] is 0, both servers use
       // the same ephemeral port.
       return bind(InternetAddress.LOOPBACK_IP_V6, v4Server.port)
           .then((v6Server) {
         return new HttpMultiServer([v4Server, v6Server]);
       }).catchError((error) {
         if (error is! SocketException) throw error;
         if (error.osError.errno != _addressInUseErrno) throw error;
         if (port != 0) throw error;
+        if (remainingRetries == 0) throw error;
 
         // A port being available on IPv4 doesn't necessarily mean that the same
         // port is available on IPv6. If it's not (which is rare in practice),
         // we try again until we find one that's available on both.
         v4Server.close();
-        return _loopback(port, bind);
+        return _loopback(port, bind, remainingRetries - 1);
       });
     });
   }
 
   Future close({bool force: false}) =>
       Future.wait(_servers.map((server) => server.close(force: force)));
 
   /// Returns an HttpConnectionsInfo object summarizing the total number of
   /// current connections handled by all the servers.
   HttpConnectionsInfo connectionsInfo() {
     var info = new HttpConnectionsInfo();
     for (var server in _servers) {
       var subInfo = server.connectionsInfo();
       info.total += subInfo.total;
       info.active += subInfo.active;
       info.idle += subInfo.idle;
       info.closing += subInfo.closing;
     }
     return info;
   }
 }