Add custom ListenConfig support for server (#280)

Co-authored-by: SystemGlitch <jeremy.la@outlook.fr>

Author: supakornn

server.go

@@ -51,6 +51,12 @@ type Options struct {
 	// HTTP2 configures HTTP/2 connections.
 	HTTP2 *http.HTTP2Config
 
+	// ListenConfig optionally specifies the configuration for the network listener.
+	// If not provided, the default net.ListenConfig is used.
+	// This can be useful for customizing keep-alives and other network-level settings
+	// for optimal performance in large traffic scenarios.
+	ListenConfig *net.ListenConfig
+
 	// ConnState specifies an optional callback function that is
 	// called when a client connection changes state. See the
 	// `http.ConnState` type and associated constants for details.
@@ -110,6 +116,7 @@ type Server struct {
 
 	ctx           context.Context
 	baseContext   func(net.Listener) context.Context
+	listenConfig  *net.ListenConfig
 	startupHooks  []func(*Server)
 	shutdownHooks []func(*Server)
 
@@ -163,6 +170,7 @@ func New(opts Options) (*Server, error) {
 		},
 		ctx:           context.Background(),
 		baseContext:   opts.BaseContext,
+		listenConfig:  opts.ListenConfig,
 		config:        cfg,
 		services:      make(map[string]Service),
 		Lang:          languages,
@@ -267,7 +275,7 @@ func (s *Server) LookupService(name string) (Service, bool) {
 	return service, ok
 }
 
-// RegisterService on thise server using its name (returned by `Service.Name()`).
+// RegisterService on this server using its name (returned by `Service.Name()`).
 // A service's name should be unique.
 // `Service.Init(server)` is called on the given service upon registration.
 func (s *Server) RegisterService(service Service) {
@@ -424,7 +432,13 @@ func (s *Server) Start() error {
 		close(s.stopChannel)
 	}()
 
-	ln, err := net.Listen("tcp", s.server.Addr)
+	var ln net.Listener
+	var err error
+	if s.listenConfig != nil {
+		ln, err = s.listenConfig.Listen(context.Background(), "tcp", s.server.Addr)
+	} else {
+		ln, err = net.Listen("tcp", s.server.Addr)
+	}
 	if err != nil {
 		return errors.New(err)
 	}

server_test.go

@@ -57,12 +57,16 @@ func TestServer(t *testing.T) {
 		})
 
 		http2Cfg := &http.HTTP2Config{}
+		customListenConfig := &net.ListenConfig{
+			KeepAlive: 1 * time.Minute,
+		}
 		s, err := New(Options{
 			MaxHeaderBytes: 123,
 			ConnState:      func(_ net.Conn, _ http.ConnState) {},
 			BaseContext:    func(_ net.Listener) context.Context { return context.Background() },
 			ConnContext:    func(ctx context.Context, _ net.Conn) context.Context { return ctx },
 			HTTP2:          http2Cfg,
+			ListenConfig:   customListenConfig,
 		})
 		require.NoError(t, err)
 
@@ -85,6 +89,7 @@ func TestServer(t *testing.T) {
 		assert.NotNil(t, s.baseContext)
 		assert.NotNil(t, s.server.BaseContext)
 		assert.Same(t, http2Cfg, s.server.HTTP2)
+		assert.Same(t, customListenConfig, s.listenConfig)
 		assert.Equal(t, "http://127.0.0.1:8080", s.BaseURL())
 		assert.Equal(t, "http://127.0.0.1:8080", s.ProxyBaseURL())
 		assert.NoError(t, s.CloseDB())
@@ -696,6 +701,83 @@ func TestServer(t *testing.T) {
 			assert.Equal(t, "cannot start the server, context is canceled", err.Error())
 		}
 	})
+
+	t.Run("StartWithCustomListenConfig", func(t *testing.T) {
+		cfg := config.LoadDefault()
+		cfg.Set("server.port", 0)
+
+		customListenConfig := &net.ListenConfig{
+			KeepAlive: 1 * time.Minute,
+		}
+
+		server, err := New(Options{
+			Config:       cfg,
+			ListenConfig: customListenConfig,
+		})
+		require.NoError(t, err)
+
+		wg := sync.WaitGroup{}
+		wg.Add(2)
+
+		server.RegisterStartupHook(func(s *Server) {
+			assert.True(t, server.IsReady())
+			assert.NotEqual(t, 0, s.Port())
+
+			res, err := http.Get(s.BaseURL())
+			defer func() {
+				assert.NoError(t, res.Body.Close())
+			}()
+			assert.NoError(t, err)
+			respBody, err := io.ReadAll(res.Body)
+			assert.NoError(t, err)
+			assert.Equal(t, []byte("hello world"), respBody)
+
+			server.Stop()
+			wg.Done()
+		})
+
+		server.RegisterRoutes(func(_ *Server, router *Router) {
+			router.Get("/", func(r *Response, _ *Request) {
+				r.String(http.StatusOK, "hello world")
+			}).Name("base")
+		})
+
+		go func() {
+			err := server.Start()
+			assert.NoError(t, err)
+			wg.Done()
+		}()
+
+		wg.Wait()
+		assert.False(t, server.IsReady())
+		assert.Equal(t, uint32(3), server.state.Load())
+	})
+
+	t.Run("StartWithCustomListenConfigControlError", func(t *testing.T) {
+		cfg := config.LoadDefault()
+		cfg.Set("server.port", 0)
+
+		// Create a custom ListenConfig with a Control function that always returns an error
+		// to ensure that the custom config is correctly used if provided.
+		// The StartWithCustomListenConfig test only checks that the server still works and is able
+		// to process requests with the custom config.
+		expectedErr := fmt.Errorf("test control error")
+		customListenConfig := &net.ListenConfig{
+			Control: func(_, _ string, _ syscall.RawConn) error {
+				return expectedErr
+			},
+		}
+
+		server, err := New(Options{
+			Config:       cfg,
+			ListenConfig: customListenConfig,
+		})
+		require.NoError(t, err)
+
+		// Attempt to start the server - it should fail with the error from Control
+		err = server.Start()
+		assert.ErrorIs(t, err, expectedErr)
+	})
 }
 
 func TestNoServerFromContext(t *testing.T) {