gbn: make resend timeout dynamic

Prior to this commit, the timeout before a client resends the queue
of packets was always a fixed value. This fixed timeout isn't
suitable for all clients as the latency for different clients varies.

With this commit, we instead set the resend timeout based on how long
it took for the other party to respond during the handshake process.
The timeout is set to the time it took for the server to respond
multiplied by the resendMultiplier, unless the duration is shorter than
the default resend timeout. If the the resend timeout has been manually
set, the resend timeout will always be set to that value, and won't be
dynamically set.

Author: ViktorT-11

gbn/gbn_client.go

@@ -108,6 +108,9 @@ handshake:
 			return err
 		}
 
+		// Notify the timeout manager that we sent a SYN.
+		g.timeoutManager.Sent(msg)
+
 		for {
 			// Wait for SYN
 			log.Debugf("Client waiting for SYN")
@@ -162,6 +165,10 @@ handshake:
 		return io.EOF
 	}
 
+	// Notify the timeout manager we've received the SYN response from the
+	// counterparty.
+	g.timeoutManager.Received(resp)
+
 	// Send SYNACK
 	log.Debugf("Client sending SYNACK")
 	synack, err := new(PacketSYNACK).Serialize()

gbn/gbn_conn.go

@@ -366,6 +366,9 @@ func (g *GoBackNConn) sendPacket(ctx context.Context, msg Message) error {
 		return fmt.Errorf("error calling sendToStream: %s", err)
 	}
 
+	// Notify the timeout manager that a message has been sent.
+	g.timeoutManager.Sent(msg)
+
 	return nil
 }
 
@@ -499,6 +502,9 @@ func (g *GoBackNConn) receivePacketsForever() error { // nolint:gocyclo
 			return fmt.Errorf("deserialize error: %s", err)
 		}
 
+		// Notify the timeout manager that a message has been received.
+		g.timeoutManager.Received(msg)
+
 		// Reset the ping & pong timer if any packet is received.
 		// If ping/pong is disabled, this is a no-op.
 		g.pingTicker.Reset()

gbn/gbn_server.go

@@ -123,6 +123,9 @@ func (g *GoBackNConn) serverHandshake() error { // nolint:gocyclo
 			return err
 		}
 
+		// Notify the timeout manager that we sent a SYN.
+		g.timeoutManager.Sent(msg)
+
 		// Wait for SYNACK
 		log.Debugf("Waiting for client SYNACK")
 		select {
@@ -155,6 +158,10 @@ func (g *GoBackNConn) serverHandshake() error { // nolint:gocyclo
 
 		switch msg.(type) {
 		case *PacketSYNACK:
+			// Notify the timeout manager we've received the SYNACK
+			// response from the counterparty.
+			g.timeoutManager.Received(msg)
+
 			break
 		case *PacketSYN:
 			log.Debugf("Received SYN. Resend SYN.")

gbn/options.go

@@ -22,6 +22,17 @@ func WithTimeout(timeout time.Duration) Option {
 	}
 }
 
+// WithResendMultiplier is used to set the resend multiplier. This is the
+// multiplier we use when dynamically setting the resend timeout, based on how
+// long it took for other party to respond during the handshake.
+// Note that when setting the resend timeout manually with the WithTimeout
+// option, this option will have no effect.
+func WithResendMultiplier(multiplier int) Option {
+	return func(conn *GoBackNConn) {
+		conn.timeoutManager.SetResendMultiplier(multiplier)
+	}
+}
+
 // WithHandshakeTimeout is used to set the timeout used during the handshake.
 // If the timeout is reached without response from the peer then the handshake
 // will be aborted and restarted.

mailbox/client_conn.go

@@ -45,6 +45,10 @@ const (
 	// to receive ACKS from the peer before resending the queue.
 	gbnTimeout = 1000 * time.Millisecond
 
+	// gbnResendMultiplier is the multiplier that we want the gbn
+	// connection to use when dynamically setting the resend timeout.
+	gbnResendMultiplier = 5
+
 	// gbnN is the queue size, N, that the gbn server will use. The gbn
 	// server will send up to N packets before requiring an ACK for the
 	// first packet in the queue.
@@ -156,7 +160,7 @@ func NewClientConn(ctx context.Context, sid [64]byte, serverHost string,
 	c := &ClientConn{
 		transport: transport,
 		gbnOptions: []gbn.Option{
-			gbn.WithTimeout(gbnTimeout),
+			gbn.WithResendMultiplier(gbnResendMultiplier),
 			gbn.WithHandshakeTimeout(gbnHandshakeTimeout),
 			gbn.WithKeepalivePing(
 				gbnClientPingTimeout, gbnPongTimeout,

mailbox/server_conn.go

@@ -77,7 +77,7 @@ func NewServerConn(ctx context.Context, serverHost string,
 		cancel: cancel,
 		quit:   make(chan struct{}),
 		gbnOptions: []gbn.Option{
-			gbn.WithTimeout(gbnTimeout),
+			gbn.WithResendMultiplier(gbnResendMultiplier),
 			gbn.WithHandshakeTimeout(gbnHandshakeTimeout),
 			gbn.WithKeepalivePing(
 				gbnServerPingTimeout, gbnPongTimeout,