Go中安全传递net.Listener文件描述符到子进程的教程

package main

import (
    "fmt"
    "net"
    "os"
    "os/exec"
    "log"
)

func main() {
    // 1. 创建一个TCP监听器
    listener, err := net.Listen("tcp", ":8080")
    if err != nil {
        log.Fatalf("父进程创建监听器失败: %v", err)
    }
    fmt.Printf("父进程在 %s 上监听...\n", listener.Addr())

    // 2. 获取监听器的 *os.File 句柄
    // l.File() 返回一个 *os.File，它是一个新的文件描述符，指向与监听器相同的底层文件。
    // 这个新的文件描述符在父进程中是独立的，需要在使用后关闭。
    listenerFile, err := listener.(*net.TCPListener).File()
    if err != nil {
        log.Fatalf("父进程获取监听器文件失败: %v", err)
    }
    defer listenerFile.Close() // 确保在父进程退出前关闭这个复制的FD

    // 3. 准备启动子进程
    cmd := exec.Command("./child_process") // 假设子进程可执行文件名为 child_process
    cmd.ExtraFiles = []*os.File{listenerFile} // 将监听器文件添加到 ExtraFiles 列表

    // 可选：设置环境变量，告知子进程FD的索引，提高可读性
    // 在本例中，listenerFile 是 ExtraFiles 的第一个元素，所以其FD索引是3。
    cmd.Env = append(os.Environ(), "LISTENER_FD_INDEX=3")

    // 4. 启动子进程
    fmt.Println("父进程启动子进程...")
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr
    if err := cmd.Start(); err != nil {
        log.Fatalf("父进程启动子进程失败: %v", err)
    }

    // 5. 父进程可以选择关闭自己的监听器，或者继续处理请求
    // 如果父进程希望完全移交监听器给子进程，则可以关闭。
    // 如果父进程和子进程需要共同处理请求（如在负载均衡器后），则父进程可继续监听。
    // 这里我们选择关闭父进程的监听器，模拟完全移交。
    listener.Close()
    fmt.Println("父进程已关闭自己的监听器。")

    // 6. 等待子进程完成 (如果子进程是一个长期运行的服务，父进程可能不需要等待)
    if err := cmd.Wait(); err != nil {
        fmt.Printf("子进程退出，错误: %v\n", err)
    } else {
        fmt.Println("子进程正常退出。")
    }
}

package main

import (
    "fmt"
    "net"
    "os"
    "log"
    "time"
)

func main() {
    // 1. 获取传递过来的文件描述符索引 (如果父进程通过环境变量传递)
    fdIndexStr := os.Getenv("LISTENER_FD_INDEX")
    fdIndex := 3 // 默认值，如果环境变量未设置或解析失败

    if fdIndexStr != "" {
        if val, err := fmt.Sscanf(fdIndexStr, "%d", &fdIndex); err == nil && val == 1 {
            fmt.Printf("子进程从环境变量获取到监听器FD索引: %d\n", fdIndex)
        } else {
            fmt.Printf("子进程解析环境变量LISTENER_FD_INDEX失败，使用默认值: %d\n", fdIndex)
        }
    } else {
        fmt.Printf("子进程未从环境变量获取到监听器FD索引，使用默认值: %d\n", fdIndex)
    }

    // 2. 使用 os.NewFile 从文件描述符重建 *os.File
    // 第一个参数是文件描述符的整数值，第二个参数是文件的名称（任意字符串，用于调试或日志）。
    file := os.NewFile(uintptr(fdIndex), "listener_from_parent")
    if file == nil {
        log.Fatalf("子进程无法从FD %d 创建 *os.File", fdIndex)
    }
    defer file.Close() // 确保在子进程退出前关闭这个文件句柄

    // 3. 使用 net.FileListener 从 *os.File 重建 net.Listener
    listener, err := net.FileListener(file)
    if err != nil {
        log.Fatalf("子进程无法从文件重建监听器: %v", err)
    }
    defer listener.Close() // 确保在子进程退出前关闭监听器

    fmt.Printf("子进程成功继承监听器，在 %s 上服务...\n", listener.Addr())

    // 4. 子进程开始处理请求
    // 模拟处理请求，这里只是简单打印信息
    go func() {
        for {
            conn, err := listener.Accept()
            if err != nil {
                // 如果监听器已关闭，Accept会返回错误
                fmt.Printf("子进程接受连接错误: %v\n", err)
                return
            }
            fmt.Printf("子进程接受到来自 %s 的连接\n", conn.RemoteAddr())
            conn.Write([]byte("Hello from child process!\n"))
            conn.Close()
        }
    }()

    // 模拟子进程运行一段时间
    time.Sleep(10 * time.Second)
    fmt.Println("子进程运行结束。")
}