Limit pub to 16 concurrent HTTP requests.

sdk/lib/_internal/pub/lib/src/http.dart

 // Copyright (c) 2012, 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.
 
 /// Helpers for dealing with HTTP.
 library pub.http;
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 
 import 'package:http/http.dart' as http;
+import 'package:http_throttle/http_throttle.dart';
 
 import 'io.dart';
 import 'log.dart' as log;
 import 'oauth2.dart' as oauth2;
 import 'sdk.dart' as sdk;
 import 'utils.dart';
 
 // TODO(nweiz): make this configurable
 /// The amount of time in milliseconds to allow HTTP requests before assuming
 /// they've failed.
 final HTTP_TIMEOUT = 30 * 1000;
 
 /// Headers and field names that should be censored in the log output.
 final _CENSORED_FIELDS = const ['refresh_token', 'authorization'];
 
 /// Headers required for pub.dartlang.org API requests.
 ///
 /// The Accept header tells pub.dartlang.org which version of the API we're
 /// expecting, so it can either serve that version or give us a 406 error if
 /// it's not supported.
 final PUB_API_HEADERS = const {'Accept': 'application/vnd.pub.v2+json'};
 
 /// An HTTP client that transforms 40* errors and socket exceptions into more
 /// user-friendly error messages.
 ///
 /// This also adds a 30-second timeout to every request. This can be configured
 /// on a per-request basis by setting the 'Pub-Request-Timeout' header to the
 /// desired number of milliseconds, or to "None" to disable the timeout.
-class PubHttpClient extends http.BaseClient {
+class _PubHttpClient extends http.BaseClient {
   final _requestStopwatches = new Map<http.BaseRequest, Stopwatch>();
 
-  http.Client inner;
+  http.Client _inner;
 
-  PubHttpClient([http.Client inner])
-      : this.inner = inner == null ? new http.Client() : inner;
+  _PubHttpClient([http.Client inner])
+      : this._inner = inner == null ? new http.Client() : inner;
 
   Future<http.StreamedResponse> send(http.BaseRequest request) {
     _requestStopwatches[request] = new Stopwatch()..start();
     request.headers[HttpHeaders.USER_AGENT] = "Dart pub ${sdk.version}";
     _logRequest(request);
 
     // TODO(nweiz): remove this when issue 4061 is fixed.
     var stackTrace;
     try {
       throw null;
     } catch (_, localStackTrace) {
       stackTrace = localStackTrace;
     }
 
     var timeoutLength = HTTP_TIMEOUT;
     var timeoutString = request.headers.remove('Pub-Request-Timeout');
     if (timeoutString == 'None') {
       timeoutLength = null;
     } else if (timeoutString != null) {
       timeoutLength = int.parse(timeoutString);
     }
 
-    var future = inner.send(request).then((streamedResponse) {
+    var future = _inner.send(request).then((streamedResponse) {
       _logResponse(streamedResponse);
 
       var status = streamedResponse.statusCode;
       // 401 responses should be handled by the OAuth2 client. It's very
       // unlikely that they'll be returned by non-OAuth2 requests. We also want
       // to pass along 400 responses from the token endpoint.
       var tokenRequest = urisEqual(
           streamedResponse.request.url, oauth2.tokenEndpoint);
       if (status < 400 || status == 401 || (status == 400 && tokenRequest)) {
         return streamedResponse;
@@ skipping 103 matching lines @@
   /// [name] and [value].
   String _logField(String name, String value) {
     if (_CENSORED_FIELDS.contains(name.toLowerCase())) {
       return "$name: <censored>";
     } else {
       return "$name: $value";
     }
   }
 }
 
+/// The [_PubHttpClient] wrapped by [httpClient].
+final _pubClient = new _PubHttpClient();
+
 /// The HTTP client to use for all HTTP requests.
-final httpClient = new PubHttpClient();
+final httpClient = new ThrottleClient(16, _pubClient);
+
+/// The underlying HTTP client wrapped by [httpClient].
+http.Client get innerHttpClient => _pubClient._inner;
+set innerHttpClient(http.Client client) => _pubClient._inner = client;
 
 /// Handles a successful JSON-formatted response from pub.dartlang.org.
 ///
 /// These responses are expected to be of the form `{"success": {"message":
 /// "some message"}}`. If the format is correct, the message will be printed;
 /// otherwise an error will be raised.
 void handleJsonSuccess(http.Response response) {
   var parsed = parseJsonResponse(response);
   if (parsed['success'] is! Map ||
       !parsed['success'].containsKey('message') ||
@@ skipping 39 matching lines @@
 
 /// Exception thrown when an HTTP operation fails.
 class PubHttpException implements Exception {
   final http.Response response;
 
   const PubHttpException(this.response);
 
   String toString() => 'HTTP error ${response.statusCode}: '
       '${response.reasonPhrase}';
 }