factor out the exponential backoff code, too

Author: trevj

src/churn-pipe/churn-pipe.ts

@@ -12,30 +12,14 @@ import ipaddr = require('ipaddr.js');
 import logging = require('../logging/logging');
 import net = require('../net/net.types');
 import PassThrough = require('../transformers/passthrough');
+import promises = require('../promises/promises');
 import protean = require('../transformers/protean');
 import sequence = require('../transformers/byteSequenceShaper');
 
 import Socket = freedom.UdpSocket.Socket;
 
 var log :logging.Log = new logging.Log('churn-pipe');
 
-// Retry an async function with exponential backoff for up to 2 seconds
-// before failing.
-var retry_ = <T>(func:() => Promise<T>, delayMs?:number) : Promise<T> => {
-  delayMs = delayMs || 10;
-  return func().catch((err) => {
-    delayMs *= 2;
-    if (delayMs > 2000) {
-      return Promise.reject(err);
-    }
-    return new Promise<T>((F, R) => {
-      setTimeout(() => {
-        retry_(func, delayMs).then(F, R);
-      }, delayMs);
-    });
-  });
-}
-
 // Maps transformer names to class constructors.
 var transformers :{[name:string] : new() => Transformer} = {
   'caesar': caesar.CaesarCipher,
@@ -47,6 +31,10 @@ var transformers :{[name:string] : new() => Transformer} = {
   'sequenceShaper': sequence.ByteSequenceShaper
 };
 
+// Local socket rebinding retry timing (see bindLocal)
+const INITIAL_REBIND_INTERVAL_MS = 10;
+const MAX_REBIND_INTERVAL_MS = 2000;
+
 interface MirrorSet {
   // If true, these mirrors represent a remote endpoint that has been
   // explicitly signaled to us.
@@ -198,13 +186,13 @@ class Pipe {
     // This retry is needed because the browser releases the UDP port
     // asynchronously after we call close() on the RTCPeerConnection, so
     // this call to bind() may initially fail, until the port is released.
-    portPromise = retry_(() => {
+    portPromise = promises.retryWithExponentialBackoff(() => {
       log.debug('%1: trying to bind public endpoint: %2',
           this.name_, publicEndpoint);
       // TODO: Once https://github.com/freedomjs/freedom/issues/283 is
       // fixed, catch here, and only retry on an ALREADY_BOUND error.
       return socket.bind(anyInterface, publicEndpoint.port);
-    }).then(() => {
+    }, MAX_REBIND_INTERVAL_MS, INITIAL_REBIND_INTERVAL_MS).then(() => {
       log.debug('%1: successfully bound public endpoint: %2',
           this.name_, publicEndpoint);
       socket.on('onData', (recvFromInfo:freedom.UdpSocket.RecvFromInfo) => {

src/promises/promises.ts

@@ -12,3 +12,20 @@ export const retry = <T>(f: () => Promise<T>, maxAttempts: number): Promise<T> =
     }
   });
 };
+
+// Invokes f with exponential backoff between retries, resolving with its result
+// on the first success and rejecting on maxAttempts-th failure.
+export const retryWithExponentialBackoff = <T>(f: () => Promise<T>,
+    maxIntervalMs: number, initialIntervalMs: number): Promise<T> => {
+  return f().catch((e: Error) => {
+    initialIntervalMs *= 2;
+    if (initialIntervalMs > maxIntervalMs) {
+      return Promise.reject(e);
+    }
+    return new Promise<T>((F, R) => {
+      setTimeout(() => {
+        retryWithExponentialBackoff(f, maxIntervalMs, initialIntervalMs).then(F, R);
+      }, initialIntervalMs);
+    });
+  });
+};