Revert "feat: add TCP_NODELAY utilities and apply them to connections and listeners for improved latency"
This reverts commit 572d31d18c8e4d5dd48ec0b9ef9f18430bc8d5ee.
cognitive-glitch committed
Dec 9, 2025 at 10:48 UTC
e7295d10a2b1b558a364b88eb1b518384a35c43b
8 files changed
+20
-173
cmd/relay-server/bps_manager.go
+1
-1
@@ -12,7 +12,7 @@ import (
12
// BPSManager manages per-lease bytes-per-second rate limiting
13
type BPSManager struct {
14
mu sync.Mutex
15
- bpsLimits map[string]int64 // leaseID -> bytes-per-second (0 = unlimited)
15
+ bpsLimits map[string]int64 // leaseID -> bytes-per-second (0 = unlimited)
16
bpsBuckets map[string]*ratelimit.Bucket // leaseID -> rate limit bucket
17
defaultBPS int64 // default bytes-per-second for new leases
18
}
cmd/relay-server/view.go
+3
-9
@@ -176,19 +176,13 @@ func serveHTTP(addr string, serv *portal.RelayServer, bpsManager *BPSManager, no
176
})
177
178
srv := &http.Server{
179
+ Addr: addr,
180
Handler: handler,
181
}
182
182
- // Create TCP listener with TCP_NODELAY enabled for low-latency relay protocol
183
- listener, err := net.Listen("tcp", addr)
184
- if err != nil {
185
- log.Fatal().Err(err).Msgf("[server] failed to listen on %s", addr)
186
- }
187
- noDelayListener := utils.NewTCPNoDelayListener(listener)
188
-
183
go func() {
184
log.Info().Msgf("[server] http: %s", addr)
191
- if err := srv.Serve(noDelayListener); err != nil && err != http.ErrServerClosed {
185
+ if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
186
log.Error().Err(err).Msg("[server] http error")
187
cancel()
188
}
@@ -564,7 +558,7 @@ func convertLeaseEntriesToRows(serv *portal.RelayServer) []leaseRow {
558
Metadata: lease.Metadata,
559
}
560
567
- if !row.Hide {
561
+ if row.Hide != true {
562
rows = append(rows, row)
563
}
564
}
portal/core/cryptoops/handshaker_test.go
+5
-15
@@ -11,17 +11,14 @@ import (
11
12
"golang.org/x/crypto/curve25519"
13
"gosuda.org/portal/portal/core/proto/rdsec"
14
- "gosuda.org/portal/utils"
14
)
15
17
-// pipeConn creates a bidirectional pipe for testing using TCP loopback.
18
-// TCP_NODELAY is enabled on both connections for low-latency testing.
16
+// pipeConn creates a bidirectional pipe for testing using TCP loopback
17
func pipeConn() (net.Conn, net.Conn) {
20
- rawListener, err := net.Listen("tcp", "127.0.0.1:0")
18
+ listener, err := net.Listen("tcp", "127.0.0.1:0")
19
if err != nil {
20
panic(err)
21
}
24
- listener := utils.NewTCPNoDelayListener(rawListener)
22
23
connCh := make(chan net.Conn, 1)
24
go func() {
@@ -37,9 +34,6 @@ func pipeConn() (net.Conn, net.Conn) {
34
if err != nil {
35
panic(err)
36
}
40
- if err := utils.SetTCPNoDelay(clientConn); err != nil {
41
- panic(err)
42
- }
37
38
serverConn := <-connCh
39
return clientConn, serverConn
@@ -688,12 +682,11 @@ func TestRealNetworkConnection(t *testing.T) {
682
clientCred, _ := NewCredential()
683
serverCred, _ := NewCredential()
684
691
- // Start server with TCP_NODELAY enabled
692
- rawListener, err := net.Listen("tcp", "127.0.0.1:0")
685
+ // Start server
686
+ listener, err := net.Listen("tcp", "127.0.0.1:0")
687
if err != nil {
688
t.Fatalf("Failed to start listener: %v", err)
689
}
696
- listener := utils.NewTCPNoDelayListener(rawListener)
690
defer listener.Close()
691
692
serverAddr := listener.Addr().String()
@@ -714,14 +707,11 @@ func TestRealNetworkConnection(t *testing.T) {
707
serverSecure, serverErr = serverHandshaker.ServerHandshake(conn, []string{"test-alpn"})
708
}()
709
717
- // Connect client with TCP_NODELAY enabled
710
+ // Connect client
711
clientConn, err := net.Dial("tcp", serverAddr)
712
if err != nil {
713
t.Fatalf("Failed to connect: %v", err)
714
}
722
- if err := utils.SetTCPNoDelay(clientConn); err != nil {
723
- t.Fatalf("Failed to set TCP_NODELAY: %v", err)
724
- }
715
716
clientHandshaker := NewHandshaker(clientCred)
717
clientSecure, clientErr := clientHandshaker.ClientHandshake(clientConn, "test-alpn")
portal/integration_test.go
+2
-6
@@ -10,7 +10,6 @@ import (
10
"github.com/stretchr/testify/require"
11
"gosuda.org/portal/portal/core/cryptoops"
12
"gosuda.org/portal/portal/core/proto/rdverb"
13
- "gosuda.org/portal/utils"
13
)
14
15
// generateTestCredential creates a new credential for testing
@@ -27,10 +26,9 @@ func TestIntegration_FullFlow(t *testing.T) {
26
server.Start()
27
defer server.Stop()
28
30
- // Create a listener for the server with TCP_NODELAY enabled
31
- rawListener, err := net.Listen("tcp", "127.0.0.1:0")
29
+ // Create a listener for the server
30
+ listener, err := net.Listen("tcp", "127.0.0.1:0")
31
require.NoError(t, err)
33
- listener := utils.NewTCPNoDelayListener(rawListener)
32
defer listener.Close()
33
34
go func() {
@@ -49,7 +47,6 @@ func TestIntegration_FullFlow(t *testing.T) {
47
hostCred := generateTestCredential(t)
48
hostConn, err := net.Dial("tcp", serverAddr)
49
require.NoError(t, err)
52
- require.NoError(t, utils.SetTCPNoDelay(hostConn))
50
51
hostClient := NewRelayClient(hostConn)
52
require.NotNil(t, hostClient)
@@ -78,7 +75,6 @@ func TestIntegration_FullFlow(t *testing.T) {
75
peerCred := generateTestCredential(t)
76
peerConn, err := net.Dial("tcp", serverAddr)
77
require.NoError(t, err)
81
- require.NoError(t, utils.SetTCPNoDelay(peerConn))
78
79
peerClient := NewRelayClient(peerConn)
80
require.NotNil(t, peerClient)
sdk/sdk.go
+1
-1
@@ -302,7 +302,7 @@ func (g *Client) listenerWorker(server *connRelay) {
302
303
if !exists {
304
log.Warn().Str("lease_id", lease).Msg("[SDK] No listener found for lease, closing connection")
305
- incoming.Close() // Close unused connection
305
+ incoming.SecureConnection.Close() // Close unused connection
306
continue
307
}
308
sdk/sdk_e2e_test.go
+6
-18
@@ -59,18 +59,14 @@ func TestE2E_ClientToAppThroughRelay(t *testing.T) {
59
}
60
})
61
62
- // Create TCP listener with TCP_NODELAY enabled for low-latency relay protocol
63
- relayListener, err := net.Listen("tcp", relayAddr)
64
- require.NoError(t, err, "Failed to create relay listener")
65
- noDelayListener := utils.NewTCPNoDelayListener(relayListener)
66
-
62
relayHTTPServer := &http.Server{
63
+ Addr: relayAddr,
64
Handler: relayMux,
65
}
66
67
go func() {
68
log.Info().Str("addr", relayAddr).Msg("[TEST] Relay HTTP server starting")
73
- if err := relayHTTPServer.Serve(noDelayListener); err != nil && err != http.ErrServerClosed {
69
+ if err := relayHTTPServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
70
log.Error().Err(err).Msg("[TEST] Relay HTTP server error")
71
}
72
}()
@@ -223,16 +219,12 @@ func TestE2E_MultipleConnections(t *testing.T) {
219
relayServer.HandleConnection(stream)
220
})
221
226
- // Create TCP listener with TCP_NODELAY enabled
227
- relayListener, err := net.Listen("tcp", relayAddr)
228
- require.NoError(t, err, "Failed to create relay listener")
229
- noDelayListener := utils.NewTCPNoDelayListener(relayListener)
230
-
222
relayHTTPServer := &http.Server{
223
+ Addr: relayAddr,
224
Handler: relayMux,
225
}
226
235
- go relayHTTPServer.Serve(noDelayListener)
227
+ go relayHTTPServer.ListenAndServe()
228
defer func() {
229
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
230
defer cancel()
@@ -367,16 +359,12 @@ func TestE2E_ConnectionTimeout(t *testing.T) {
359
relayServer.HandleConnection(stream)
360
})
361
370
- // Create TCP listener with TCP_NODELAY enabled
371
- relayListener, err := net.Listen("tcp", relayAddr)
372
- require.NoError(t, err, "Failed to create relay listener")
373
- noDelayListener := utils.NewTCPNoDelayListener(relayListener)
374
-
362
relayHTTPServer := &http.Server{
363
+ Addr: relayAddr,
364
Handler: relayMux,
365
}
366
379
- go relayHTTPServer.Serve(noDelayListener)
367
+ go relayHTTPServer.ListenAndServe()
368
defer func() {
369
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
370
defer cancel()
utils/utils.go
+2
-51
@@ -5,70 +5,21 @@ import (
5
"fmt"
6
"io"
7
"mime"
8
- "net"
8
"net/http"
9
"net/url"
10
"regexp"
11
"strings"
12
13
"github.com/gorilla/websocket"
15
- "github.com/rs/zerolog/log"
14
15
"gosuda.org/portal/portal/utils/wsstream"
16
)
17
20
-// SetTCPNoDelay enables TCP_NODELAY on a TCP connection to disable Nagle's algorithm.
21
-// Returns nil for non-TCP connections (e.g., Unix sockets, WebSocket over WASM).
22
-func SetTCPNoDelay(conn net.Conn) error {
23
- if tcpConn, ok := conn.(*net.TCPConn); ok {
24
- return tcpConn.SetNoDelay(true)
25
- }
26
- return nil
27
-}
28
-
29
-// TCPNoDelayListener wraps a net.Listener to enable TCP_NODELAY on accepted connections.
30
-type TCPNoDelayListener struct {
31
- net.Listener
32
-}
33
-
34
-// Accept accepts a connection and enables TCP_NODELAY.
35
-func (l *TCPNoDelayListener) Accept() (net.Conn, error) {
36
- conn, err := l.Listener.Accept()
37
- if err != nil {
38
- return nil, err
39
- }
40
- if err := SetTCPNoDelay(conn); err != nil {
41
- log.Debug().Err(err).Msg("failed to set TCP_NODELAY on accepted connection")
42
- }
43
- return conn, nil
44
-}
45
-
46
-// NewTCPNoDelayListener wraps a listener to enable TCP_NODELAY on accepted connections.
47
-func NewTCPNoDelayListener(l net.Listener) *TCPNoDelayListener {
48
- return &TCPNoDelayListener{Listener: l}
49
-}
50
-
18
// NewWebSocketDialer returns a dialer that establishes WebSocket connections
52
-// and wraps them as io.ReadWriteCloser. TCP_NODELAY is enabled on the underlying
53
-// TCP connection to minimize latency for interactive relay protocols.
19
+// and wraps them as io.ReadWriteCloser.
20
func NewWebSocketDialer() func(context.Context, string) (io.ReadWriteCloser, error) {
55
- dialer := &websocket.Dialer{
56
- NetDialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
57
- d := &net.Dialer{}
58
- conn, err := d.DialContext(ctx, network, addr)
59
- if err != nil {
60
- return nil, err
61
- }
62
- if err := SetTCPNoDelay(conn); err != nil {
63
- log.Debug().Err(err).Msg("failed to set TCP_NODELAY on WebSocket connection")
64
- }
65
- return conn, nil
66
- },
67
- HandshakeTimeout: websocket.DefaultDialer.HandshakeTimeout,
68
- }
69
-
21
return func(ctx context.Context, url string) (io.ReadWriteCloser, error) {
71
- wsConn, _, err := dialer.DialContext(ctx, url, nil)
22
+ wsConn, _, err := websocket.DefaultDialer.Dial(url, nil)
23
if err != nil {
24
return nil, err
25
}
utils/utils_test.go
-72
@@ -1,11 +1,9 @@
1
package utils
2
3
import (
4
- "net"
4
"testing"
5
6
"github.com/stretchr/testify/assert"
8
- "github.com/stretchr/testify/require"
7
)
8
9
func TestIsURLSafeName(t *testing.T) {
@@ -260,73 +258,3 @@ func TestIsSubdomain(t *testing.T) {
258
})
259
}
260
}
263
-
264
-func TestSetTCPNoDelay(t *testing.T) {
265
- listener, err := net.Listen("tcp", "127.0.0.1:0")
266
- require.NoError(t, err)
267
- defer listener.Close()
268
-
269
- go func() {
270
- conn, _ := listener.Accept()
271
- if conn != nil {
272
- conn.Close()
273
- }
274
- }()
275
-
276
- conn, err := net.Dial("tcp", listener.Addr().String())
277
- require.NoError(t, err)
278
- defer conn.Close()
279
-
280
- // Should succeed on TCP connection
281
- err = SetTCPNoDelay(conn)
282
- require.NoError(t, err)
283
-
284
- // Verify it's a TCP connection
285
- _, ok := conn.(*net.TCPConn)
286
- require.True(t, ok, "expected *net.TCPConn")
287
-}
288
-
289
-func TestSetTCPNoDelay_NonTCP(t *testing.T) {
290
- // Test with a non-TCP connection (using a pipe)
291
- server, client := net.Pipe()
292
- defer server.Close()
293
- defer client.Close()
294
-
295
- // Should return nil for non-TCP connections (no-op)
296
- err := SetTCPNoDelay(client)
297
- require.NoError(t, err)
298
-}
299
-
300
-func TestTCPNoDelayListener(t *testing.T) {
301
- rawListener, err := net.Listen("tcp", "127.0.0.1:0")
302
- require.NoError(t, err)
303
-
304
- listener := NewTCPNoDelayListener(rawListener)
305
- defer listener.Close()
306
-
307
- go func() {
308
- conn, err := net.Dial("tcp", listener.Addr().String())
309
- if err == nil {
310
- conn.Close()
311
- }
312
- }()
313
-
314
- conn, err := listener.Accept()
315
- require.NoError(t, err)
316
- defer conn.Close()
317
-
318
- // Verify it's a TCP connection (TCP_NODELAY was set during Accept)
319
- _, ok := conn.(*net.TCPConn)
320
- require.True(t, ok, "expected *net.TCPConn from TCPNoDelayListener")
321
-}
322
-
323
-func TestTCPNoDelayListener_Addr(t *testing.T) {
324
- rawListener, err := net.Listen("tcp", "127.0.0.1:0")
325
- require.NoError(t, err)
326
-
327
- listener := NewTCPNoDelayListener(rawListener)
328
- defer listener.Close()
329
-
330
- // Verify Addr() returns the correct address
331
- require.Equal(t, rawListener.Addr(), listener.Addr())
332
-}