游戏开发笔记 - 服务器不停机更新

2024-01-29

全文 ≈ 909字 | 预计阅读时长 4分钟

简单实现服务器不停机更新的机制

前言

之前接触过某 moba 游戏，除了其丰富的游戏内容之外，对其服务器更新机制非常好奇。他们的服务器很少进行停机更新，大部分是不停机更新内容。这是如何实现的呢？

思路

服务器更新场景，一般是业务代码迭代或者配置表需要重载。moba 游戏一般是一个服务器承载 1 或多个房间，所以热更新机制有可能是这样一个设计：

正在使用的服务器

先停止接收新的请求，等待处理完已有的战斗后重启

未使用的服务器

有序重启，防止无服务器可用

当然，实现上肯定不是这么简单。如果按照上面的思路来实现，流程如下：

监听热更新的信号。
收到热更新的信号，创建服务器子进程，同时把 Socket 文件描述符传（file descriptor）递给子进程。
启动服务器子进程，启动成功后发送停机信号给父进程。
父进程处理完请求，退出。

实现

定义服务

type Server struct {
    http     http.Server
    listener net.Listener
    pid      int
    conns    map[int64]*network.WsConn
}

服务逻辑，分别监听 3 个信道： 2-SIGINT, 15-SIGTERM, 1-SIGHUP，启动服务前判断是否子进程，如果是子进程则使用父进程传递进来的文件描述符继续监听。

func NewServer(addr string) (svr *Server) {
    svr = &Server{
        exit:  make(chan bool, 1),
        conns: make(map[string]*network.WsConn, 0),
    }
    svr.http.Addr = addr
    return
}

func (r *Server) ListenAndServe() {
    var err error
    if r.isChild() {
        // fd预留：0stdin、1stdout、2stderr
        f := os.NewFile(3, "")
        r.listener, err = net.FileListener(f)
    } else {
        r.listener, err = net.Listen("tcp", r.http.Addr)
    }
    if err != nil {
        panic(err)
    }
    // 监听信道
    go r.handleSignals()
    // 通知父进程退出
    if r.isChild() {
        syscall.Kill(syscall.Getppid(), syscall.SIGTERM)
    }
    // 启动服务
    if err = r.http.Serve(r.listener); err != nil {
        log.Printf("服务[%d]异常 %v", syscall.Getpid(), err)
    }
    select {
    case <-r.exit:
    case <-time.After(120 * time.Second):
    }
    log.Printf("服务[%d]已关闭", syscall.Getpid())
}

// 监听信道
func (r *Server) handleSignals() {
    ch := make(chan os.Signal, 1)
    signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP)
    for {
        sig := <-ch
        log.Printf("服务[%d]接收信号 %v", syscall.Getpid(), sig)
        switch sig {
        case syscall.SIGINT:
            // 外部停机
            r.shutdown()
        case syscall.SIGTERM:
            // 子进程通知停机
            r.shutdown()
        case syscall.SIGHUP:
            if err := r.reload(); err != nil {
                panic(err)
            }
        }
    }
}

// 是否子进程
func (r *Server) isChild() bool {
    return os.Getenv("SERVER_RELOAD") != ""
}

信道处理，2/15 直接关闭服务。如果是 1 则创建子进程，并把当前进程文件描述符传递给子进程。

// fork
func (r *Server) reload() error {
    listener, ok := r.listener.(*net.TCPListener)
    if !ok {
        return errors.New("listener is not tcp listener")
    }
    f, err := listener.File()
    if err != nil {
        return err
    }
    cmd := exec.Command(os.Args[0])
    cmd.Env = []string{
        "SERVER_RELOAD=1",
    }
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr
    // 文件描述
    cmd.ExtraFiles = []*os.File{f}
    // 执行
    return cmd.Start()
}

// 停机
func (r *Server) shutdown() {
    // 关闭监听
    r.listener.Close()
    done := make(chan bool, 1)
    go func() {
        for {
            if len(r.conns) > 0 {
                continue
            }
            break
        }
        done <- true
    }()
    select {
    case <-done:
        log.Printf("连接池已清空")
    case <-time.After(60 * time.Second):
        wg := sync.WaitGroup{}
        for _, conn := range r.conns {
            wg.Add(1)
            go func(conn *network.WsConn) {
                defer wg.Done()
                conn.Close()
            }(conn)
        }
        wg.Wait()
        log.Printf("超时关闭连接")
    }
    // 关闭服务
    r.http.Close()
    r.exit <- true
}

测试效果

版本 1 服务

版本 2 服务

附上示例：server-hot-update

参考

Graceful Restart in Golang
Florian von Bock/endless