feat(server): implement graceful shutdown on SIGINT/SIGTERM

Signed-off-by: Ankush Chavan <cankush625@gmail.com>

Author: cankush625

db/expiry.go

@@ -17,16 +17,22 @@ const (
 // this handles bursts of expiring keys efficiently.
 // The cleanup interval is derived from ServerConfig.Hz and is re-read on
 // each tick, so CONFIG SET hz takes effect without a restart.
-func StartActiveExpiry() {
+// The goroutine exits when stop is closed.
+func StartActiveExpiry(stop <-chan struct{}) {
 	go func() {
 		for {
 			// A fresh ticker is created on every iteration so that changes to hz
 			// via CONFIG SET take effect on the next cycle without a restart.
 			// Reusing a single ticker would lock in the interval set at startup.
 			interval := ServerConfig.CleanupInterval()
 			ticker := time.NewTicker(interval)
-			<-ticker.C
-			ticker.Stop()
+			select {
+			case <-stop:
+				ticker.Stop()
+				return
+			case <-ticker.C:
+				ticker.Stop()
+			}
 
 			if !ServerConfig.ActiveExpireEnabled {
 				continue

main.go

@@ -7,6 +7,9 @@ import (
 	"fmt"
 	"net"
 	"os"
+	"os/signal"
+	"sync"
+	"syscall"
 )
 
 func main() {
@@ -22,14 +25,36 @@ func main() {
 		fmt.Printf("Failed to bind to port %d\n", *port)
 		os.Exit(1)
 	}
-	defer l.Close()
-	db.StartActiveExpiry()
+
+	stop := make(chan struct{})
+	db.StartActiveExpiry(stop)
+
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+	go func() {
+		<-quit
+		fmt.Println("Shutting down...")
+		close(stop)
+		l.Close()
+	}()
+
+	var wg sync.WaitGroup
 	for {
 		conn, err := l.Accept()
 		if err != nil {
-			fmt.Println("Error accepting connection: ", err.Error())
-			continue
+			// l.Close() during shutdown causes Accept to return an error.
+			// Check if we're shutting down to avoid a spurious log line.
+			select {
+			case <-stop:
+			default:
+				fmt.Println("Error accepting connection: ", err.Error())
+			}
+			break
 		}
-		go resp.HandleConn(conn)
+		wg.Add(1)
+		go resp.HandleConn(conn, &wg)
 	}
+
+	wg.Wait()
+	fmt.Println("Shutdown complete.")
 }

resp/handler.go

@@ -4,12 +4,18 @@ import (
 	"bufio"
 	"io"
 	"net"
+	"sync"
 )
 
 // HandleConn reads RESP commands from the connection and writes replies.
 // It uses a bufio.Reader to read one complete RESP message at a time,
 // so commands split across multiple TCP packets are handled correctly.
-func HandleConn(conn net.Conn) {
+// wg must be held by the caller before invoking HandleConn; it is released
+// when the connection is fully done so the server can wait for all
+// in-flight connections during graceful shutdown.
+func HandleConn(conn net.Conn, wg *sync.WaitGroup) {
+	defer wg.Done()
+	defer conn.Close()
 	reader := bufio.NewReader(conn)
 	for {
 		msg, err := readMessage(reader)