gbn: add timeout manager

The timeout manager is a manager for all timeout values used by the
different components of the gbn package. The timeout manager enables
the functionality of dynamically changing the resend timeout value based
on how long it takes to receive an response from the counterparty.

To make the gbn package more modular, we'll move the responsibility of
managing the timeout values of the gbn package to the timeout manager in
the next commit.

Author: ViktorT-11

gbn/timeout_manager.go

@@ -0,0 +1,228 @@
+package gbn
+
+import (
+	"math"
+	"sync"
+	"time"
+)
+
+const (
+	defaultTMHandshakeTimeout = 100 * time.Millisecond
+	defaultTMResendTimeout    = 100 * time.Millisecond
+	minimumResendTimeout      = 100 * time.Millisecond
+	defaultTMFinSendTimeout   = 1000 * time.Millisecond
+	defaultResendMultiplier   = 5
+	DefaultTMSendTimeout      = math.MaxInt64
+	DefaultTMRecvTimeout      = math.MaxInt64
+)
+
+// TimeoutManager manages the different timeouts used by the gbn package.
+type TimeoutManager struct {
+	// isServer is used to indicate whether the timeout manager is used
+	// by the server or the client.
+	isServer bool
+
+	// useStaticTimeout is used to indicate whether the resendTimeout
+	// has been manually set, and if so, should not be updated dynamically.
+	useStaticTimeout bool
+
+	// resendTimeout defines the current resend timeout used by the
+	// timeout manager.
+	// The resend timeout is the duration that will be waited before
+	// resending the packets in the current queue. The timeout is
+	// dynamically set during the handshake process, and is set to the time
+	// it took for the other party to respond, multiplied by the
+	// resendMultiplier.
+	resendTimeout time.Duration
+
+	// resendMultiplier defines the multiplier used when multiplying the
+	// duration it took for the other party to respond when setting the
+	// resendTimeout dynamically during the handshake.
+	resendMultiplier int
+
+	// latestSentSYNTime is used to keep track of the time when the latest
+	// SYN message was sent. This is used to dynamically set the resend
+	// timeout, based on how long it took for the other party to respond to
+	// the SYN message.
+	latestSentSYNTime time.Time
+
+	// handshakeTimeout is the time after which the server or client
+	// will abort and restart the handshake if the expected response is
+	// not received from the peer.
+	handshakeTimeout time.Duration
+
+	// finSendTimeout is the timeout after which the created context for
+	// sending a FIN message will be time out.
+	finSendTimeout time.Duration
+
+	// sendTimeout defines the max time we will wait to send a msg before
+	// timing out.
+	sendTimeout time.Duration
+
+	// recvTimeout defines the max time we will wait to receive a msg before
+	// timing out.
+	recvTimeout time.Duration
+
+	// timeoutManagerMu should be locked when updating or accessing any of
+	// timeout manager's timeout fields.
+	timeoutManagerMu sync.RWMutex
+}
+
+// NewTimeOutManager creates a new timeout manager.
+func NewTimeOutManager(isServer bool) *TimeoutManager {
+	return &TimeoutManager{
+		isServer:         isServer,
+		resendTimeout:    defaultTMResendTimeout,
+		handshakeTimeout: defaultTMHandshakeTimeout,
+		useStaticTimeout: false,
+		resendMultiplier: defaultResendMultiplier,
+		finSendTimeout:   defaultTMFinSendTimeout,
+		recvTimeout:      DefaultTMRecvTimeout,
+		sendTimeout:      DefaultTMSendTimeout,
+	}
+}
+
+// Sent is should be called when a message is sent by the connection.
+func (m *TimeoutManager) Sent(msg Message) {
+	// TODO(viktor): In the future, we may want to use this to keep track of
+	// the time it took for the other party to respond to other types of
+	// messages than the handshake, and dynamically keep updating the resend
+	// timeout to ensure that it reflects the current response time.
+	switch msg.(type) { //nolint:gocritic
+	case *PacketSYN:
+		// Note that we may send multiple SYN messages before receiving
+		// a response. Therefore, this field might be updated multiple
+		// times.
+		m.latestSentSYNTime = time.Now()
+	}
+}
+
+// Received is should be called when a message is received by the connection.
+func (m *TimeoutManager) Received(msg Message) {
+	// TODO(viktor): In the future, we may want to use this to keep track of
+	// the time it took for the other party to respond to other types of
+	// messages than the handshake, and dynamically keep updating the resend
+	// timeout to ensure that it reflects the current response time.
+	switch msg.(type) {
+	case *PacketSYN:
+		if !m.isServer {
+			m.updateResendTimeout(time.Since(m.latestSentSYNTime))
+		}
+
+	case *PacketSYNACK:
+		if m.isServer {
+			m.updateResendTimeout(time.Since(m.latestSentSYNTime))
+		}
+	}
+}
+
+// updateResendTimeout updates the resend timeout based on the given response
+// time. The resend timeout will be only be updated if the given response time
+// is greater than the default resend timeout, after being multiplied by the
+// resendMultiplier.
+// If a static timeout has been manually set, then this function will do be a
+// no-op.
+func (m *TimeoutManager) updateResendTimeout(responseTime time.Duration) {
+	if m.useStaticTimeout {
+		log.Tracef("Not increasing resendTimeout as it has been set " +
+			"manually")
+
+		return
+	}
+
+	multipliedTimeout := time.Duration(m.resendMultiplier) * responseTime
+
+	if multipliedTimeout > minimumResendTimeout {
+		log.Tracef("Updating resendTimeout to %v", multipliedTimeout)
+
+		m.resendTimeout = multipliedTimeout
+	} else {
+		log.Tracef("Not updating resendTimeout to %v as it is not "+
+			"greater than the minimum resendTimeout which is %v",
+			multipliedTimeout, m.resendTimeout)
+	}
+}
+
+// GetResendTimeout returns the current resend timeout.
+func (m *TimeoutManager) GetResendTimeout() time.Duration {
+	m.timeoutManagerMu.RLock()
+	defer m.timeoutManagerMu.RUnlock()
+
+	return m.resendTimeout
+}
+
+// GetHandshakeTimeout returns the handshake timeout.
+func (m *TimeoutManager) GetHandshakeTimeout() time.Duration {
+	m.timeoutManagerMu.RLock()
+	defer m.timeoutManagerMu.RUnlock()
+
+	return m.handshakeTimeout
+}
+
+// GetFinSendTimeout returns the fin send timeout.
+func (m *TimeoutManager) GetFinSendTimeout() time.Duration {
+	m.timeoutManagerMu.RLock()
+	defer m.timeoutManagerMu.RUnlock()
+
+	return m.finSendTimeout
+}
+
+// GetSendTimeout returns the send timeout.
+func (m *TimeoutManager) GetSendTimeout() time.Duration {
+	m.timeoutManagerMu.RLock()
+	defer m.timeoutManagerMu.RUnlock()
+
+	return m.sendTimeout
+}
+
+// GetRecvTimeout returns the recv timeout.
+func (m *TimeoutManager) GetRecvTimeout() time.Duration {
+	m.timeoutManagerMu.RLock()
+	defer m.timeoutManagerMu.RUnlock()
+
+	return m.recvTimeout
+}
+
+// SetStaticResendTimeout sets the resend timeout to the given value, and also
+// marks the timeout manager as using a static resend timeout, which will mean
+// that the resend timeout will not be updated dynamically.
+func (m *TimeoutManager) SetStaticResendTimeout(resendTimeout time.Duration) {
+	m.timeoutManagerMu.Lock()
+	defer m.timeoutManagerMu.Unlock()
+
+	m.resendTimeout = resendTimeout
+	m.useStaticTimeout = true
+}
+
+// SetResendMultiplier sets the resend multiplier used when dynamically
+// setting the resend timeout.
+func (m *TimeoutManager) SetResendMultiplier(resendMultiplier int) {
+	m.timeoutManagerMu.Lock()
+	defer m.timeoutManagerMu.Unlock()
+
+	m.resendMultiplier = resendMultiplier
+}
+
+// SetHandshakeTimeout sets the handshake timeout.
+func (m *TimeoutManager) SetHandshakeTimeout(handshakeTimeout time.Duration) {
+	m.timeoutManagerMu.Lock()
+	defer m.timeoutManagerMu.Unlock()
+
+	m.handshakeTimeout = handshakeTimeout
+}
+
+// SetSendTimeout sets the send timeout.
+func (m *TimeoutManager) SetSendTimeout(timeout time.Duration) {
+	m.timeoutManagerMu.Lock()
+	defer m.timeoutManagerMu.Unlock()
+
+	m.sendTimeout = timeout
+}
+
+// SetRecvTimeout sets the receive timeout.
+func (m *TimeoutManager) SetRecvTimeout(timeout time.Duration) {
+	m.timeoutManagerMu.Lock()
+	defer m.timeoutManagerMu.Unlock()
+
+	m.recvTimeout = timeout
+}

gbn/timeout_manager_test.go

@@ -0,0 +1,122 @@
+package gbn
+
+import (
+	"testing"
+	"time"
+
+	"github.com/lightningnetwork/lnd/lntest/wait"
+	"github.com/stretchr/testify/require"
+)
+
+// TestDynamicTimeout ensures that the resend timeout is dynamically set as
+// expected during for the timeout manager.
+func TestDynamicTimeout(t *testing.T) {
+	t.Parallel()
+
+	// Create a new timeout manager to use for the test.
+	tm := NewTimeOutManager(false)
+
+	// First, we'll ensure that the resend timeout doesn't change if we
+	// don't send and receive messages.
+	noResendTimeoutChange(t, tm, time.Second)
+
+	// Next, we'll simulate that a SYN message has been sent and received.
+	// This should change the resend timeout given that the new timeout is
+	// greater than the minimum allowed timeout.
+	initialResendTimeout := tm.GetResendTimeout()
+
+	sendAndReceive(t, tm)
+
+	// The resend timeout should now have dynamically changed.
+	resendTimeout := tm.GetResendTimeout()
+	require.NotEqual(t, initialResendTimeout, resendTimeout)
+
+	// Let's also test that the resend timeout is dynamically set to the
+	// expected value, and that the resend multiplier works as expected. If
+	// we set resend multiplier to 10, then send and receive a response
+	// after 1 second, then the resend timeout should be around 10 seconds.
+	tm.SetResendMultiplier(10)
+
+	sendAndReceive(t, tm)
+
+	// As it takes a short amount of time to simulate the send and receive
+	// of the message, we'll accept a set resend timeout within a range of
+	// 10-11 seconds as correct.
+	resendTimeout = tm.GetResendTimeout()
+	require.GreaterOrEqual(t, resendTimeout, time.Second*10)
+	require.Less(t, resendTimeout, time.Second*11)
+
+	// Finally, we'll test that the resend timeout isn't dynamically set if
+	// the new timeout is less than the minimum allowed resend timeout.
+	tm.SetResendMultiplier(1)
+
+	sendAndReceiveWithDuration(t, tm, time.Millisecond*50)
+
+	unchangedResendTimeout := tm.GetResendTimeout()
+	require.Equal(t, resendTimeout, unchangedResendTimeout)
+}
+
+// TestStaticTimeout ensures that the resend timeout isn't dynamically set if a
+// static timeout has been set.
+func TestStaticTimeout(t *testing.T) {
+	t.Parallel()
+
+	// Create a new timeout manager to use for the test.
+	tm := NewTimeOutManager(false)
+	staticTimeout := time.Second * 2
+
+	// Set a static timeout for the timeout manager.
+	tm.SetStaticResendTimeout(staticTimeout)
+
+	// Then ensure that the resend timeout isn't dynamically set if we send
+	// and receive messages after setting a static timeout.
+	sendAndReceive(t, tm)
+
+	resendTimeout := tm.GetResendTimeout()
+	require.Equal(t, staticTimeout, resendTimeout)
+}
+
+// sendAndReceive simulates that a SYN message has been sent for the passed the
+// timeout manager, and then waits for one second before a simulating the SYN
+// response. While waiting, the function asserts that the resend timeout hasn't
+// changed.
+func sendAndReceive(t *testing.T, tm *TimeoutManager) {
+	t.Helper()
+
+	sendAndReceiveWithDuration(t, tm, time.Second)
+}
+
+// sendAndReceive simulates that a SYN message has been sent for the passed the
+// timeout manager, and then waits for specified delay before a simulating the
+// SYN response. While waiting, the function asserts that the resend timeout
+// hasn't changed.
+func sendAndReceiveWithDuration(t *testing.T, tm *TimeoutManager,
+	responseDelay time.Duration) {
+
+	t.Helper()
+
+	synMsg := &PacketSYN{N: 20}
+
+	tm.Sent(synMsg)
+
+	noResendTimeoutChange(t, tm, responseDelay)
+
+	tm.Received(synMsg)
+}
+
+// noResendTimeoutChange asserts that the resend timeout hasn't changed for the
+// passed timeout manager for the specified duration.
+func noResendTimeoutChange(t *testing.T, tm *TimeoutManager,
+	duration time.Duration) {
+
+	t.Helper()
+
+	resendTimeout := tm.GetResendTimeout()
+
+	err := wait.Invariant(func() bool {
+		currentResendTimeout := tm.GetResendTimeout()
+
+		return resendTimeout == currentResendTimeout
+	}, duration)
+	require.NoError(t, err)
+}