coder
diff --git a/‎listener.go
Lines changed: 46 additions & 0 deletions b/‎listener.go
Lines changed: 46 additions & 0 deletions
diff --git a/‎listener_test.go
Lines changed: 109 additions & 0 deletions b/‎listener_test.go
Lines changed: 109 additions & 0 deletions
@@ -0,0 +1,46 @@
+package retry
+
+import (
+	"log"
+	"net"
+	"time"
+)
+
+type Listener struct {
+	LogTmpErr func(err error)
+	net.Listener
+}
+
+const (
+	initialListenerDelay = 5 * time.Millisecond
+	maxListenerDelay     = time.Second
+)
+
+func (l *Listener) Accept() (net.Conn, error) {
+	var retryDelay time.Duration
+	for {
+		c, err := l.Listener.Accept()
+		if err != nil {
+			ne, ok := err.(net.Error)
+			if ok && ne.Temporary() {
+				if retryDelay == 0 {
+					retryDelay = initialListenerDelay
+				} else {
+					retryDelay *= 2
+					if retryDelay > maxListenerDelay {
+						retryDelay = maxListenerDelay
+					}
+				}
+				if l.LogTmpErr == nil {
+					log.Printf("retry: temp error accepting next connection: %v; retrying in %v", err, retryDelay)
+				} else {
+					l.LogTmpErr(err)
+				}
+				time.Sleep(retryDelay)
+				continue
+			}
+			return nil, err
+		}
+		return c, nil
+	}
+}
@@ -0,0 +1,109 @@
+package retry
+
+import (
+	"net"
+	"testing"
+
+	"github.com/pkg/errors"
+	"github.com/stretchr/testify/require"
+)
+
+type testListener struct {
+	acceptFn func() (net.Conn, error)
+}
+
+func newTestListener(acceptFn func() (net.Conn, error)) net.Listener {
+	return &Listener{
+		LogTmpErr: func(err error) {},
+		Listener: &testListener{
+			acceptFn: acceptFn,
+		},
+	}
+}
+
+func (l *testListener) Accept() (net.Conn, error) {
+	return l.acceptFn()
+}
+
+func (l *testListener) Close() error {
+	panic("do not call")
+}
+
+func (l *testListener) Addr() net.Addr {
+	panic("do not call")
+}
+
+type testNetError struct {
+	temporary bool
+}
+
+func (e *testNetError) Error() string {
+	return "test net error"
+}
+
+func (e *testNetError) Temporary() bool {
+	return e.temporary
+}
+
+func (e *testNetError) Timeout() bool {
+	panic("do not call")
+}
+
+func TestListener(t *testing.T) {
+	t.Parallel()
+	t.Run("general error", func(t *testing.T) {
+		t.Parallel()
+
+		expectedErr := errors.New("general error")
+		acceptFn := func() (net.Conn, error) {
+			return nil, expectedErr
+		}
+
+		_, err := newTestListener(acceptFn).Accept()
+		require.Equal(t, expectedErr, err)
+	})
+	t.Run("success", func(t *testing.T) {
+		t.Parallel()
+
+		acceptFn := func() (net.Conn, error) {
+			return nil, nil
+		}
+
+		_, err := newTestListener(acceptFn).Accept()
+		require.Nil(t, err)
+	})
+	t.Run("non temp net error", func(t *testing.T) {
+		t.Parallel()
+
+		expectedErr := &testNetError{false}
+		acceptFn := func() (net.Conn, error) {
+			return nil, expectedErr
+		}
+
+		_, err := newTestListener(acceptFn).Accept()
+		require.Equal(t, expectedErr, err)
+	})
+	t.Run("3x temp net error", func(t *testing.T) {
+		t.Parallel()
+
+		callCount := 0
+		acceptFn := func() (net.Conn, error) {
+			callCount++
+			switch callCount {
+			case 1:
+				return nil, &testNetError{true}
+			case 2:
+				return nil, &testNetError{true}
+			case 3:
+				return nil, nil
+			default:
+				t.Fatal("test listener called too many times; callCount: %v", callCount)
+				panic("unreachable")
+			}
+		}
+
+		_, err := newTestListener(acceptFn).Accept()
+		require.Nil(t, err)
+		require.Equal(t, callCount, 3)
+	})
+}