Initial implementation (#1)
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..da41cf2
--- /dev/null
+++ b/README.md
@@ -0,0 +1,26 @@
+Middleware for the [`http`](https://pub.dartlang.org/packages/http) package that
+transparently retries failing requests.
+
+To use this, just create an [`RetryClient`][RetryClient] that wraps the
+underlying [`http.Client`][Client]:
+
+[RetryClient]: https://www.dartdocs.org/documentation/http_retry/latest/http_retry/RetryClient-class.html
+[Client]: https://www.dartdocs.org/documentation/http/latest/http/Client-class.html
+
+```dart
+import 'package:http/http.dart' as http;
+import 'package:http_retry/http_retry.dart';
+
+main() async {
+ var client = new RetryClient(new http.Client());
+ print(await client.read("http://example.org"));
+ await client.close();
+}
+```
+
+By default, this retries any request whose response has status code 503
+Temporary Failure up to three retries. It waits 500ms before the first retry,
+and increases the delay by 1.5x each time. All of this can be customized using
+the [`new RetryClient()`][new RetryClient] constructor.
+
+[new RetryClient]: https://www.dartdocs.org/documentation/http_retry/latest/http_retry/RetryClient/RetryClient.html
diff --git a/lib/http_retry.dart b/lib/http_retry.dart
new file mode 100644
index 0000000..03cebd8
--- /dev/null
+++ b/lib/http_retry.dart
@@ -0,0 +1,99 @@
+// Copyright (c) 2017, 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.
+
+import 'dart:async';
+import 'dart:math' as math;
+
+import 'package:async/async.dart';
+import 'package:http/http.dart';
+
+/// An HTTP client wrapper that automatically retries failing requests.
+class RetryClient extends BaseClient {
+ /// The wrapped client.
+ final Client _inner;
+
+ /// The number of times a request should be retried.
+ final int _retries;
+
+ /// The callback that determines whether a request should be retried.
+ final bool Function(StreamedResponse) _when;
+
+ /// The callback that determines how long to wait before retrying a request.
+ final Duration Function(int) _delay;
+
+ /// Creates a client wrapping [inner] that retries HTTP requests.
+ ///
+ /// This retries a failing request [retries] times (3 by default). Note that
+ /// `n` retries means that the request will be sent at most `n + 1` times.
+ ///
+ /// By default, this retries requests whose responses have status code 503
+ /// Temporary Failure. If [when] is passed, it retries any request for whose
+ /// response [when] returns `true`.
+ ///
+ /// By default, this waits 500ms between the original request and the first
+ /// retry, then increases the delay by 1.5x for each subsequent retry. If
+ /// [delay] is passed, it's used to determine the time to wait before the
+ /// given (zero-based) retry.
+ RetryClient(this._inner,
+ {int retries,
+ bool when(StreamedResponse response),
+ Duration delay(int retryCount)})
+ : _retries = retries ?? 3,
+ _when = when ?? ((response) => response.statusCode == 503),
+ _delay = delay ??
+ ((retryCount) =>
+ new Duration(milliseconds: 500) * math.pow(1.5, retryCount)) {
+ RangeError.checkNotNegative(_retries, "retries");
+ }
+
+ /// Like [new RetryClient], but with a pre-computed list of [delays]
+ /// between each retry.
+ ///
+ /// This will retry a request at most `delays.length` times, using each delay
+ /// in order. It will wait for `delays[0]` after the initial request,
+ /// `delays[1]` after the first retry, and so on.
+ RetryClient.withDelays(Client inner, Iterable<Duration> delays,
+ {bool when(StreamedResponse response)})
+ : this._withDelays(inner, delays.toList(), when: when);
+
+ RetryClient._withDelays(Client inner, List<Duration> delays,
+ {bool when(StreamedResponse response)})
+ : this(inner,
+ retries: delays.length, delay: (retryCount) => delays[retryCount]);
+
+ Future<StreamedResponse> send(BaseRequest request) async {
+ var splitter = new StreamSplitter(request.finalize());
+
+ var i = 0;
+ while (true) {
+ var response = await _inner.send(_copyRequest(request, splitter.split()));
+ if (i == _retries || !_when(response)) return response;
+
+ // Make sure the response stream is listened to so that we don't leave
+ // dangling connections.
+ response.stream.listen((_) {}).cancel()?.catchError((_) {});
+ await new Future.delayed(_delay(i));
+ i++;
+ }
+ }
+
+ /// Returns a copy of [original] with the given [body].
+ StreamedRequest _copyRequest(BaseRequest original, Stream<List<int>> body) {
+ var request = new StreamedRequest(original.method, original.url);
+ request.contentLength = original.contentLength;
+ request.followRedirects = original.followRedirects;
+ request.headers.addAll(original.headers);
+ request.maxRedirects = original.maxRedirects;
+ request.persistentConnection = original.persistentConnection;
+
+ body.listen(request.sink.add,
+ onError: request.sink.addError,
+ onDone: request.sink.close,
+ cancelOnError: true);
+
+ return request;
+ }
+
+ void close() => _inner.close();
+}
diff --git a/pubspec.yaml b/pubspec.yaml
new file mode 100644
index 0000000..6af9806
--- /dev/null
+++ b/pubspec.yaml
@@ -0,0 +1,16 @@
+name: http_retry
+version: 0.1.0-dev
+description: HTTP client middleware that automatically retries requests.
+author: Dart Team <misc@dartlang.org>
+homepage: https://github.com/dart-lang/http_retry
+
+environment:
+ sdk: '>=1.24.0 <2.0.0'
+
+dependencies:
+ async: ">=1.2.0 <=3.0.0"
+ http: "^0.11.0"
+
+dev_dependencies:
+ fake_async: "^0.1.2"
+ test: "^0.12.0"
diff --git a/test/http_retry_test.dart b/test/http_retry_test.dart
new file mode 100644
index 0000000..3ba61b4
--- /dev/null
+++ b/test/http_retry_test.dart
@@ -0,0 +1,190 @@
+// Copyright (c) 2017, 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.
+
+import 'package:fake_async/fake_async.dart';
+import 'package:http/http.dart';
+import 'package:http/testing.dart';
+import 'package:test/test.dart';
+
+import 'package:http_retry/http_retry.dart';
+
+void main() {
+ group("doesn't retry when", () {
+ test("a request has a non-503 error code", () async {
+ var client = new RetryClient(new MockClient(
+ expectAsync1((_) async => new Response("", 502), count: 1)));
+ var response = await client.get("http://example.org");
+ expect(response.statusCode, equals(502));
+ });
+
+ test("a request doesn't match when()", () async {
+ var client = new RetryClient(
+ new MockClient(
+ expectAsync1((_) async => new Response("", 503), count: 1)),
+ when: (_) => false);
+ var response = await client.get("http://example.org");
+ expect(response.statusCode, equals(503));
+ });
+
+ test("retries is 0", () async {
+ var client = new RetryClient(
+ new MockClient(
+ expectAsync1((_) async => new Response("", 503), count: 1)),
+ retries: 0);
+ var response = await client.get("http://example.org");
+ expect(response.statusCode, equals(503));
+ });
+ });
+
+ test("retries on a 503 by default", () async {
+ var count = 0;
+ var client = new RetryClient(
+ new MockClient(expectAsync1((request) async {
+ count++;
+ return count < 2 ? new Response("", 503) : new Response("", 200);
+ }, count: 2)),
+ delay: (_) => Duration.ZERO);
+
+ var response = await client.get("http://example.org");
+ expect(response.statusCode, equals(200));
+ });
+
+ test("retries on any request where when() returns true", () async {
+ var count = 0;
+ var client = new RetryClient(
+ new MockClient(expectAsync1((request) async {
+ count++;
+ return new Response("", 503,
+ headers: {"retry": count < 2 ? "true" : "false"});
+ }, count: 2)),
+ when: (response) => response.headers["retry"] == "true",
+ delay: (_) => Duration.ZERO);
+
+ var response = await client.get("http://example.org");
+ expect(response.headers, containsPair("retry", "false"));
+ expect(response.statusCode, equals(503));
+ });
+
+ test("retries three times by default", () async {
+ var client = new RetryClient(
+ new MockClient(
+ expectAsync1((_) async => new Response("", 503), count: 4)),
+ delay: (_) => Duration.ZERO);
+ var response = await client.get("http://example.org");
+ expect(response.statusCode, equals(503));
+ });
+
+ test("retries the given number of times", () async {
+ var client = new RetryClient(
+ new MockClient(
+ expectAsync1((_) async => new Response("", 503), count: 13)),
+ retries: 12,
+ delay: (_) => Duration.ZERO);
+ var response = await client.get("http://example.org");
+ expect(response.statusCode, equals(503));
+ });
+
+ test("waits 1.5x as long each time by default", () {
+ new FakeAsync().run((fake) {
+ var count = 0;
+ var client = new RetryClient(new MockClient(expectAsync1((_) async {
+ count++;
+ if (count == 1) {
+ expect(fake.elapsed, equals(Duration.ZERO));
+ } else if (count == 2) {
+ expect(fake.elapsed, equals(new Duration(milliseconds: 500)));
+ } else if (count == 3) {
+ expect(fake.elapsed, equals(new Duration(milliseconds: 1250)));
+ } else if (count == 4) {
+ expect(fake.elapsed, equals(new Duration(milliseconds: 2375)));
+ }
+
+ return new Response("", 503);
+ }, count: 4)));
+
+ expect(client.get("http://example.org"), completes);
+ fake.elapse(new Duration(minutes: 10));
+ });
+ });
+
+ test("waits according to the delay parameter", () {
+ new FakeAsync().run((fake) {
+ var count = 0;
+ var client = new RetryClient(
+ new MockClient(expectAsync1((_) async {
+ count++;
+ if (count == 1) {
+ expect(fake.elapsed, equals(Duration.ZERO));
+ } else if (count == 2) {
+ expect(fake.elapsed, equals(Duration.ZERO));
+ } else if (count == 3) {
+ expect(fake.elapsed, equals(new Duration(seconds: 1)));
+ } else if (count == 4) {
+ expect(fake.elapsed, equals(new Duration(seconds: 3)));
+ }
+
+ return new Response("", 503);
+ }, count: 4)),
+ delay: (requestCount) => new Duration(seconds: requestCount));
+
+ expect(client.get("http://example.org"), completes);
+ fake.elapse(new Duration(minutes: 10));
+ });
+ });
+
+ test("waits according to the delay list", () {
+ new FakeAsync().run((fake) {
+ var count = 0;
+ var client = new RetryClient.withDelays(
+ new MockClient(expectAsync1((_) async {
+ count++;
+ if (count == 1) {
+ expect(fake.elapsed, equals(Duration.ZERO));
+ } else if (count == 2) {
+ expect(fake.elapsed, equals(new Duration(seconds: 1)));
+ } else if (count == 3) {
+ expect(fake.elapsed, equals(new Duration(seconds: 61)));
+ } else if (count == 4) {
+ expect(fake.elapsed, equals(new Duration(seconds: 73)));
+ }
+
+ return new Response("", 503);
+ }, count: 4)),
+ [
+ new Duration(seconds: 1),
+ new Duration(minutes: 1),
+ new Duration(seconds: 12)
+ ]);
+
+ expect(client.get("http://example.org"), completes);
+ fake.elapse(new Duration(minutes: 10));
+ });
+ });
+
+ test("copies all request attributes for each attempt", () async {
+ var client = new RetryClient.withDelays(
+ new MockClient(expectAsync1((request) async {
+ expect(request.contentLength, equals(5));
+ expect(request.followRedirects, isFalse);
+ expect(request.headers, containsPair("foo", "bar"));
+ expect(request.maxRedirects, equals(12));
+ expect(request.method, equals("POST"));
+ expect(request.persistentConnection, isFalse);
+ expect(request.url, equals(Uri.parse("http://example.org")));
+ expect(request.body, equals("hello"));
+ return new Response("", 503);
+ }, count: 2)),
+ [Duration.ZERO]);
+
+ var request = new Request("POST", Uri.parse("http://example.org"));
+ request.body = "hello";
+ request.followRedirects = false;
+ request.headers["foo"] = "bar";
+ request.maxRedirects = 12;
+ request.persistentConnection = false;
+
+ var response = await client.send(request);
+ expect(response.statusCode, equals(503));
+ });
+}
