Recover gracefully if a matching port is unavailable.

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';
 import 'src/utils.dart';
 
+/// The error code for an error caused by a port already being in use.
+final _addressInUseErrno = _computeAddressInUseErrno();
+int _computeAddressInUseErrno() {
+  if (Platform.isWindows) return 10048;
+  if (Platform.isMacOS) return 48;
+  assert(Platform.isLinux);
+  return 98;
+}
+
 /// An implementation of `dart:io`'s [HttpServer] that wraps multiple servers
 /// and forwards methods to all of them.
 ///
 /// This is useful for serving the same application on multiple network
 /// interfaces while still having a unified way of controlling the servers. In
 /// particular, it supports serving on both the IPv4 and IPv6 loopback addresses
 /// using [HttpMultiServer.loopback].
 class HttpMultiServer extends StreamView<HttpRequest> implements HttpServer {
   /// The wrapped servers.
   final Set<HttpServer> _servers;
@@ skipping 104 matching lines @@
       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;
+
+        // 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);

[skybrian, 2015/03/09 22:34:57]

Retrying forever will cause the program to spin when something has gone terribly
wrong and ports are *really* scarce. I don't think this is too likely in
practice, but a general rule of thumb with network programming is that it's
better to exit with an error after a few retries, to avoid making severe
congestion worse.

(Or possibly back off by waiting increasingly longer before retrying, but that
seems overly fancy and would result in mysterious delays rather than a clear
error.)

[nweiz, 2015/03/09 23:38:15]

https://codereview.chromium.org/992843002/

       });
     });
   }
 
   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;
   }
 }