Parse Retry-After header in API v1 503 responses.

Karl Rieb · Karl Rieb · commit 7e361b85567a · 2016-03-03T15:22:07.000-08:00
Fixes T84239.
diff --git a/ChangeLog.txt b/ChangeLog.txt
@@ -1,3 +1,4 @@
+- Parse Retry-After header for 503 retry exceptions in API v1.
 - Add example from online tutorial.
 
 ---------------------------------------------
diff --git a/src/main/java/com/dropbox/core/DbxRequestUtil.java b/src/main/java/com/dropbox/core/DbxRequestUtil.java
@@ -332,7 +332,18 @@ public static DbxException unexpectedStatus(HttpRequestor.Response response)
             case 500:
                 return new ServerException(requestId, message);
             case 503:
-                return new RetryException(requestId, message);
+                // API v1 may include Retry-After in 503 responses, v2 does not
+                String retryAfter = getFirstHeaderMaybe(response, "Retry-After");
+                try {
+                    if (retryAfter != null && !retryAfter.trim().isEmpty()) {
+                        int backoffSecs = Integer.parseInt(retryAfter);
+                        return new RetryException(requestId, message, backoffSecs, TimeUnit.SECONDS);
+                    } else {
+                        return new RetryException(requestId, message);
+                    }
+                } catch (NumberFormatException ex) {
+                    return new BadResponseException(requestId, "Invalid value for HTTP header: \"Retry-After\"");
+                }
             default:
                 return new BadResponseCodeException(
                     requestId,
diff --git a/src/test/java/com/dropbox/core/v1/DbxClientV1Test.java b/src/test/java/com/dropbox/core/v1/DbxClientV1Test.java
@@ -21,6 +21,7 @@
 import java.io.InputStream;
 import java.io.IOException;
 import java.io.OutputStream;
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
@@ -65,20 +66,28 @@ public void testRetrySuccess() throws DbxException, IOException {
         DbxClientV1 client = new DbxClientV1(config, "fakeAccessToken");
         String json = "{\"reset\":true,\"entries\":[],\"cursor\":\"fakeCursor\",\"has_more\":true}";
 
+
         // 503 twice, then return result
         HttpRequestor.Uploader mockUploader = mockUploader();
         when(mockUploader.finish())
-            .thenReturn(createEmptyResponse(503))
-            .thenReturn(createEmptyResponse(503))
+            .thenReturn(createEmptyResponse(503))   // no backoff
+            .thenReturn(createRateLimitResponse(1)) // backoff 1 sec
+            .thenReturn(createRateLimitResponse(2)) // backoff 2 sec
             .thenReturn(createSuccessResponse(json));
 
         when(mockRequestor.startPost(anyString(), anyHeaders()))
             .thenReturn(mockUploader);
 
+        long start = System.currentTimeMillis();
         DbxDelta<DbxEntry> actual = client.getDelta(null);
+        long end = System.currentTimeMillis();
 
-        // should have only been called 3 times: initial call + 2 retries
-        verify(mockRequestor, times(3)).startPost(anyString(), anyHeaders());
+        // no way easy way to properly test this, but request should
+        // have taken AT LEAST 3 seconds due to backoff.
+        assertTrue((end - start) >= 3000L, "duration: " + (end - start) + " millis");
+
+        // should have been called 4 times: initial call + 3 retries
+        verify(mockRequestor, times(4)).startPost(anyString(), anyHeaders());
 
         assertEquals(actual.reset, true);
         assertEquals(actual.cursor, "fakeCursor");
@@ -178,14 +187,20 @@ private static HttpRequestor.Response createEmptyResponse(int statusCode) {
         );
     }
 
-    private static HttpRequestor.Response createDownloaderResponse(byte [] body, String header, String json) {
-        Map<String, List<String>> headers = new TreeMap<String, List<String>>(String.CASE_INSENSITIVE_ORDER);
-        headers.put(header, Collections.<String>singletonList(json));
+    private static HttpRequestor.Response createRateLimitResponse(long backoffSeconds) {
+        byte [] body = new byte[0];
+        return new HttpRequestor.Response(
+            503, // API v1 uses 503 for rate limits
+            new ByteArrayInputStream(body),
+            headers("Retry-After", Long.toString(backoffSeconds))
+        );
+    }
 
+    private static HttpRequestor.Response createDownloaderResponse(byte [] body, String header, String json) {
         return new HttpRequestor.Response(
             200,
             new ByteArrayInputStream(body),
-            headers
+            headers(header, json)
         );
     }
 
@@ -210,6 +225,27 @@ public OutputStream answer(InvocationOnMock invocation) {
         return uploader;
     }
 
+    private static Map<String, List<String>> headers(String name, String value, String ... rest) {
+        assertTrue(rest.length % 2 == 0);
+
+        Map<String, List<String>> headers = new TreeMap<String, List<String>>(String.CASE_INSENSITIVE_ORDER);
+        List<String> values = new ArrayList<String>();
+        headers.put(name, values);
+        values.add(value);
+        for (int i = 0; i < rest.length; i += 2) {
+            name = rest[i];
+            value = rest[i+1];
+            values = headers.get(name);
+            if (values == null) {
+                values = new ArrayList<String>();
+                headers.put(name, values);
+            }
+            values.add(value);
+        }
+
+        return headers;
+    }
+
     private static Iterable<HttpRequestor.Header> anyHeaders() {
         return Matchers.<Iterable<HttpRequestor.Header>>any();
     }

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+- Parse Retry-After header for 503 retry exceptions in API v1.`
`1`	`2`	`- Add example from online tutorial.`
`2`	`3`
`3`	`4`	`---------------------------------------------`