Go语言实现服务器优雅重启：保持连接不中断的策略与实践

package main

import (
    "fmt"
    "log"
    "net"
    "net/http"
    "os"
    "os/exec"
    "os/signal"
    "strconv"
    "syscall"
    "time"
)

const (
    defaultPort = ":8080"
    fdIndex     = 3 // ExtraFiles从FD 3开始
    envRestart  = "RESTART_FD"
)

func main() {
    // 检查是否是子进程启动，并尝试从继承的FD恢复Listener
    listener, err := tryRestoreListener()
    if err != nil {
        log.Fatalf("Failed to restore listener: %v", err)
    }

    if listener == nil {
        // 如果没有继承FD，则作为主进程首次启动
        listener, err = net.Listen("tcp", defaultPort)
        if err != nil {
            log.Fatalf("Failed to listen on %s: %v", defaultPort, err)
        }
        fmt.Printf("Main process started, listening on %s\n", defaultPort)
    } else {
        fmt.Printf("Restarted process started, listening on inherited FD (%s)\n", listener.Addr().String())
    }

    // HTTP Server
    server := &http.Server{Handler: http.HandlerFunc(handler)}

    // 启动HTTP服务
    go func() {
        log.Fatal(server.Serve(listener))
    }()

    // 信号处理
    sigChan := make(chan os.Signal, 1)
    signal.Notify(sigChan, syscall.SIGHUP, syscall.SIGTERM, syscall.SIGINT)

    for {
        sig := <-sigChan
        fmt.Printf("Received signal: %v\n", sig)

        switch sig {
        case syscall.SIGHUP:
            // 优雅重启信号
            fmt.Println("Initiating graceful restart...")
            if err := restart(listener); err != nil {
                log.Printf("Restart failed: %v", err)
            } else {
                fmt.Println("New process started, current process shutting down gracefully...")
                // 停止接受新连接
                server.SetKeepAlivesEnabled(false) // 禁用Keep-Alive，加速现有连接关闭
                _ = listener.Close() // 关闭监听器，不再接受新连接

                // 等待现有连接完成
                ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
                defer cancel()
                if err := server.Shutdown(ctx); err != nil {
                    log.Printf("Error during graceful shutdown: %v", err)
                }
                fmt.Println("Old process exited.")
                os.Exit(0)
            }
        case syscall.SIGTERM, syscall.SIGINT:
            // 正常关闭信号
            fmt.Println("Initiating graceful shutdown...")
            ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
            defer cancel()
            if err := server.Shutdown(ctx); err != nil {
                log.Fatalf("Server shutdown failed: %v", err)
            }
            fmt.Println("Server exited.")
            os.Exit(0)
        }
    }
}

// tryRestoreListener 尝试从继承的文件描述符恢复Listener
func tryRestoreListener() (net.Listener, error) {
    fdStr := os.Getenv(envRestart)
    if fdStr == "" {
        return nil, nil // 没有继承FD
    }

    fd, err := strconv.Atoi(fdStr)
    if err != nil {
        return nil, fmt.Errorf("invalid FD value: %w", err)
    }

    // os.NewFile的第二个参数是文件名，这里可以随意给
    file := os.NewFile(uintptr(fd), "listener_socket")
    if file == nil {
        return nil, fmt.Errorf("failed to create os.File from FD %d", fd)
    }
    defer file.Close() // 使用完后关闭文件句柄

    listener, err := net.FileListener(file)
    if err != nil {
        return nil, fmt.Errorf("failed to create FileListener: %w", err)
    }
    return listener, nil
}

// restart 启动一个新的进程并传递监听器FD
func restart(listener net.Listener) error {
    // 将Listener转换为*os.File
    f, err := listener.(*net.TCPListener).File()
    if err != nil {
        return fmt.Errorf("failed to get listener file: %w", err)
    }
    defer f.Close() // 确保文件描述符在当前进程中被关闭

    // 准备新进程的参数和环境变量
    cmd := exec.Command(os.Args[0])
    cmd.Env = os.Environ()
    cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%d", envRestart, f.Fd())) // 传递FD

    // ExtraFiles 确保FD在子进程中是打开的
    cmd.ExtraFiles = []*os.File{f}

    // 启动新进程
    if err := cmd.Start(); err != nil {
        return fmt.Errorf("failed to start new process: %w", err)
    }

    fmt.Printf("New process (PID: %d) started.\n", cmd.Process.Pid)
    return nil
}

// handler 简单的HTTP请求处理函数
func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello from PID %d at %s\n", os.Getpid(), time.Now().Format(time.RFC3339))
}