优雅重启Go服务——gracehttp详解
前言
grace是facebook公司为golang服务开发的优雅重启和零停机部署的开源库。可以实现服务重启时，旧有连接不断，新服务启动后，新连接连入新服务，如此客户端无感知。
使用方法
（1）获取
go get github.com/facebookgo/grace/gracehttp
mod可以使用如下方式引入：
require github.com/facebookgo/grace latest
（2）使用
gracehttp.Serve(
&http.Server{Addr: *address0, Handler: newHandler("Zero ")},
&http.Server{Addr: *address1, Handler: newHandler("First ")},
&http.Server{Addr: *address2, Handler: newHandler("Second")},
)
（3）重启命令
sudo kill -USR2
pidof yourservername
pidof yourservername是指需要重启的服务进程id
源码解析
启动服务
// Serve will serve the given http.Servers and will monitor for signals
// allowing for graceful termination (SIGTERM) or restart (SIGUSR2).
func Serve(servers ...*http.Server) error {
a := newApp(servers)
return a.run()
}
func newApp(servers []*http.Server) *app {
return &app{
servers: servers,
http: &httpdown.HTTP{},
net: &gracenet.Net{},
listeners: make([]net.Listener, 0, len(servers)),
sds: make([]httpdown.Server, 0, len(servers)),
preStartProcess: func() error { return nil },
// 2x num servers for possible Close or Stop errors + 1 for possible
// StartProcess error.
errors: make(chan error, 1+(len(servers)*2)),
}
}
构造app，具体的处理逻辑均在app中进行。
注意：
此处注释说明了Serve会启动指定的http.Servers，并且会监听系统信号以允许优雅结束（SIGTERM）或重启服务（SIGUSR2），实际代码中还支持SIGINT结束服务进程，我们可以根据需求指定信号来决定是结束还是重启服务。
func (a *app) run() error {
// Acquire Listeners
//获取所有http.Server服务地址的Listeners
if err := a.listen(); err != nil {
return err
}
// Some useful logging.
// logger的处理
if logger != nil {
if didInherit {
if ppid == 1 {
logger.Printf("Listening on init activated %s", pprintAddr(a.listeners))
} else {
const msg = "Graceful handoff of %s with new pid %d and old pid %d"
logger.Printf(msg, pprintAddr(a.listeners), os.Getpid(), ppid)
}
} else {
const msg = "Serving %s with pid %d"
logger.Printf(msg, pprintAddr(a.listeners), os.Getpid())
}
}
// Start serving.
// 启动各http服务
a.serve()
// Close the parent if we inherited and it wasn't init that started us.
// 如果已经继承，并且不是从init启动，就说明是重启进程，需要将原进程关闭。
if didInherit && ppid != 1 {
if err := syscall.Kill(ppid, syscall.SIGTERM); err != nil {
return fmt.Errorf("failed to close parent: %s", err)
}
}
// 此处为最核心处理部分
waitdone := make(chan struct{})
go func() {
defer close(waitdone)
a.wait()
}()
select {
case err := <-a.errors://原有服务处理及关闭时发生错误
if err == nil {
panic("unexpected nil error")
}
return err
case <-waitdone://waitdone close后即可取值，此时意味着原有服务已完成且关闭
if logger != nil {
logger.Printf("Exiting pid %d.", os.Getpid())
}
return nil
}
}
//依次启动指定的http.Servers
func (a *app) serve() {
for i, s := range a.servers {
a.sds = append(a.sds, a.http.Serve(s, a.listeners[i]))
}
}
具体服务启动过程
过程如下：
-
构造server
-
设置ConnState，监听各连接的状态变化
-
启动新协程，manage server的各chan信号
-
在新协程中正式启动服务
Serve总入口
// 具体服务启动管理
func (h HTTP) Serve(s *http.Server, l net.Listener) Server {
stopTimeout := h.StopTimeout
if stopTimeout == 0 {
stopTimeout = defaultStopTimeout
}
killTimeout := h.KillTimeout
if killTimeout == 0 {
killTimeout = defaultKillTimeout
}
klock := h.Clock
if klock == nil {
klock = clock.New()
}
ss := &server{
stopTimeout: stopTimeout,//stop超时时间
killTimeout: killTimeout,//kill超时时间
stats: h.Stats,//数据统计
clock: klock,//数据统计的定时器
oldConnState: s.ConnState,//原ConnState hook
listener: l,//服务listener
server: s,//具体服务
serveDone: make(chan struct{}),//服务启动结束
serveErr: make(chan error, 1),//服务启动错误
new: make(chan net.Conn),//新连接
active: make(chan net.Conn),//连接状态Active
idle: make(chan net.Conn),//连接状态Idle
closed: make(chan net.Conn),//连接状态Closed
stop: make(chan chan struct{}),//stop通知
kill: make(chan chan struct{}),//kill通知
}
s.ConnState = ss.connState
// 管理连接conns
go ss.manage()
// 启动http服务
go ss.serve()
return ss
}
ConnState注入hook
设置ConnState，注入hook监听各连接的状态变化，发送至server的各统计状态的chan中。
// 处理服务的连接状态变化
func (s *server) connState(c net.Conn, cs http.ConnState) {
if s.oldConnState != nil {
s.oldConnState(c, cs)
}
switch cs {
case http.StateNew:
s.new <- c
case http.StateActive:
s.active <- c
case http.StateIdle:
s.idle <- c
case http.StateHijacked, http.StateClosed:
s.closed <- c
}
}
manage管理各种chan信号的处理
manage处理了所有connState中监听的连接变化，所有的连接会存储在conns map中，随着conn的变化进行增加、修改、删除。
stop chan信号确认所有连接是否关闭，如存在未关闭的连接，则先关闭处理Idle状态的连接，然后等待其他的状态的连接继续处理。
kill chan信号则强制关闭所有连接。
stop、kill chan信号及stopTimeout、killTimeout的使用均来自于Stop（结束服务）过程，后面会详细分析。
stop chan信号在服务Stop时触发，stop会优先关闭处于idle状态的连接，然后等待其他状态的连接继续处理。当killTimeout触发时，意味着
stop、kill chan信号对应stopTimeout、killTimeout参数。初始化中stopTimeout、killTimeout，如果有设置参数则使用设置的参数，没有则使用默认参数（一分钟）。stopTimeout是处理服务stop的超时时间，超时后，会触发kill，killTimeout就是处理kill的超时时间。
特别说明：s.stats一直为nil，其相关的代码并不会执行，阅读时可略过相关代码。
// 管理各种chan信号的处理
// 说明：s.stats一直为nil，此参数仅用来测试时使用，其相关的代码可以略过
func (s *server) manage() {
defer func() {
close(s.new)
close(s.active)
close(s.idle)
close(s.closed)
close(s.stop)
close(s.kill)
}()
var stopDone chan struct{}
// 存储服务的各连接的状态
conns := map[net.Conn]http.ConnState{}
var countNew, countActive, countIdle float64
// decConn decrements the count associated with the current state of the
// given connection.
// 更新计数
decConn := func(c net.Conn) {
switch conns[c] {
default:
panic(fmt.Errorf("unknown existing connection: %s", c))
case http.StateNew:
countNew--
case http.StateActive:
countActive--
case http.StateIdle:
countIdle--
}
}
// setup a ticker to report various values every minute. if we don't have a
// Stats implementation provided, we Stop it so it never ticks.
// 仅在有使用Stats实现接口的情况开始定时器统计数据，实际代码中并未使用，此处开启后会被关闭
statsTicker := s.clock.Ticker(time.Minute)
if s.stats == nil {
statsTicker.Stop()
}
// 等待所有连接处理
for {
select {
case <-statsTicker.C: //每分钟统计各状态的连接数量，此项仅在测试源码时生效，正式使用时，不生效
// we'll only get here when s.stats is not nil
s.stats.BumpAvg("http-state.new", countNew)
s.stats.BumpAvg("http-state.active", countActive)
s.stats.BumpAvg("http-state.idle", countIdle)
s.stats.BumpAvg("http-state.total", countNew+countActive+countIdle)
case c := <-s.new:
conns[c] = http.StateNew //存入New状态连接
countNew++
case c := <-s.active:
decConn(c)
countActive++
conns[c] = http.StateActive //存入Active状态连接
case c := <-s.idle:
decConn(c)
countIdle++
conns[c] = http.StateIdle //存入Idle状态连接
// if we're already stopping, close it
if stopDone != nil { //已经完成stop，直接关闭连接
c.Close()
}
case c := <-s.closed:
stats.BumpSum(s.stats, "conn.closed", 1)
decConn(c)
delete(conns, c) //移除关闭的连接
// if we're waiting to stop and are all empty, we just closed the last
// connection and we're done.
if stopDone != nil && len(conns) == 0 {
close(stopDone)
return
}
case stopDone = <-s.stop:
// if we're already all empty, we're already done
// 如果连接处理完毕，关闭chan，
if len(conns) == 0 {
close(stopDone)
return
}
// close current idle connections right away
// 先关闭idle状态的连接
for c, cs := range conns {
if cs == http.StateIdle {
c.Close()
}
}
// continue the loop and wait for all the ConnState updates which will
// eventually close(stopDone) and return from this goroutine.
case killDone := <-s.kill://强杀，超时时使用
// force close all connections
stats.BumpSum(s.stats, "kill.conn.count", float64(len(conns)))
for c := range conns {//强制关闭所有连接
c.Close()
}
// don't block the kill.
close(killDone)
// continue the loop and we wait for all the ConnState updates and will
// return from this goroutine when we're all done. otherwise we'll try to
// send those ConnState updates on closed channels.
}
}
}
正式的服务，则在新协程中调用http.Server的Serve启动，启动的错误发送至serveErr供启动协程处理，如发生错误，则panic。若无错误，通知服务启动结束。若存在Stop，则必须等server启动结束后才能进行，这是必然的逻辑，因为不可能stop一个未启动的server。
// 正式启动服务
func (s *server) serve() {
stats.BumpSum(s.stats, "serve", 1)
s.serveErr <- s.server.Serve(s.listener)
close(s.serveDone)
close(s.serveErr)
}
系统信号监听
这部分是核心处理部分：
-
启动信号监听协程
-
监听当前服务启动及stop状态，如有服务启动及stop发生错误，则通过a.errors，通知启动协程。
wait
// 等待原有http.Servers的连接处理完后，结束服务
func (a *app) wait() {
var wg sync.WaitGroup
wg.Add(len(a.sds) * 2) // Wait & Stop
// 监听信号
go a.signalHandler(&wg)
for _, s := range a.sds {
go func(s httpdown.Server) {
defer wg.Done()
if err := s.Wait(); err != nil {
a.errors <- err
}
}(s)
}
wg.Wait()
}
wait内的WaitGroup包含了Wait & Stop的处理，Wait用以等待各服务的启动状态结果监听，Stop则是用以结束进程（包含重启）状态监听，只有Wait & Stop均完成后，wait才能真正结束。结合之前的代码，此时启动协程才能算处理结束。
signalHandler
// 系统信号监听服务
func (a *app) signalHandler(wg *sync.WaitGroup) {
ch := make(chan os.Signal, 10)
signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM, syscall.SIGUSR2)
for {
sig := <-ch
switch sig {
case syscall.SIGINT, syscall.SIGTERM:
// this ensures a subsequent INT/TERM will trigger standard go behaviour of
// terminating.
// 停止接收信号
signal.Stop(ch)
// 结束原有服务
a.term(wg)
return
case syscall.SIGUSR2:
err := a.preStartProcess()
if err != nil {
a.errors <- err
}
// we only return here if there's an error, otherwise the new process
// will send us a TERM when it's ready to trigger the actual shutdown.
if _, err := a.net.StartProcess(); err != nil {
a.errors <- err
}
}
}
}
gracehttp默认监听的信号为：SIGINT、SIGTERM、SIGUSR2。其中SIGINT、SIGTERM用以优雅结束服务，SIGUSR2用以优雅重启服务。
关闭服务
关闭服务，目前由两种形式：
-
我们通过kill命令操作
-
进程重启时发现父进程时，主动调用syscall.Kill命令
这两种形式实际结果是一致的，只是调用者不同。
//此处的term使用的WaitGroup就是wait中的wg
func (a *app) term(wg *sync.WaitGroup) {
for _, s := range a.sds {
go func(s httpdown.Server) {
defer wg.Done()
if err := s.Stop(); err != nil {
a.errors <- err
}
}(s)
}
}
func (s *server) Stop() error {
s.stopOnce.Do(func() {
defer stats.BumpTime(s.stats, "stop.time").End()
stats.BumpSum(s.stats, "stop", 1)
// first disable keep-alive for new connections
// 关闭keep-alive，让原conn处理完关闭
s.server.SetKeepAlivesEnabled(false)
// then close the listener so new connections can't connect come thru
// 关闭listener，让新连接无法连入
closeErr := s.listener.Close()
<-s.serveDone//等待服务启动完毕，避免未启动完成调用Stop
// then trigger the background goroutine to stop and wait for it
stopDone := make(chan struct{})
s.stop <- stopDone//通知stop下的连接处理
// wait for stop
select {
case <-stopDone://conn全部处理完毕
case <-s.clock.After(s.stopTimeout)://触发超时
defer stats.BumpTime(s.stats, "kill.time").End()
stats.BumpSum(s.stats, "kill", 1)
// stop timed out, wait for kill
killDone := make(chan struct{})
s.kill <- killDone
select {
case <-killDone:
case <-s.clock.After(s.killTimeout):
// kill timed out, give up
stats.BumpSum(s.stats, "kill.timeout", 1)
}
}
if closeErr != nil && !isUseOfClosedError(closeErr) {
stats.BumpSum(s.stats, "listener.close.error", 1)
s.stopErr = closeErr
}
})
return s.stopErr
}
term会关闭所有的服务，并将关闭服务发生的错误发送至s.erros供启动协程处理。
Stop的处理流程如下：
-
关闭keep-alive，新连接不再保持长连接
-
关闭listener，不再接受新连接
-
等待新服务进程启动完毕
-
发送stop信号，确定连接是否处理完毕，未处理完则先关闭处理IDLE的连接
-
全部连接处理完，处理closeErr后返回
-
stopTimeout超时，则发送kill信号，强制关闭全部连接
-
全部连接强制关闭后，处理closeErr后返回
-
killTimeout超时，不再继续处理，处理closeErr后返回
-
term会在关闭发生错误则通知启动协程，所有服务全部正常退出后，wait结束，原进程结束。
启动新进程
重启的逻辑整体上就是，新服务进程启动后，会主动发送TERM信号结束原进程，原进程会在处理完原有连接或超时后退出。
func (n *Net) StartProcess() (int, error) {
// 获取http.Servers的Listeners
listeners, err := n.activeListeners()
if err != nil {
return 0, err
}
// Extract the fds from the listeners.
// 提取文件描述fds
files := make([]*os.File, len(listeners))
for i, l := range listeners {
files[i], err = l.(filer).File()
if err != nil {
return 0, err
}
defer files[i].Close()
}
// Use the original binary location. This works with symlinks such that if
// the file it points to has been changed we will use the updated symlink.
// 使用原执行文件路径
argv0, err := exec.LookPath(os.Args[0])
if err != nil {
return 0, err
}
// Pass on the environment and replace the old count key with the new one.
// env添加listeners的数量
var env []string
for _, v := range os.Environ() {
if !strings.HasPrefix(v, envCountKeyPrefix) {
env = append(env, v)
}
}
env = append(env, fmt.Sprintf("%s%d", envCountKeyPrefix, len(listeners)))
allFiles := append([]*os.File{os.Stdin, os.Stdout, os.Stderr}, files...)
// 利用原参数（原执行文件路径、参数、打开的文件描述等）启动新进程
process, err := os.StartProcess(argv0, os.Args, &os.ProcAttr{
Dir: originalWD,
Env: env,
Files: allFiles,
})
if err != nil {
return 0, err
}
return process.Pid, nil
}
总结
最后，我们对gracehttp的实现原理及过程做个总结。
原理
gracehttp实现优雅重启的原理：
当前进程接收到重启信号后，启动新进程接收并处理新连接，原进程不再接收新的连接，只接着处理未处理完的连接，处理完（或超时）后原进程退出，仅留下新进程，实现优雅重启。
过程
正常启动程序（非重启）到重启：
-
所有服务启动，进程监听系统信号，启动协程通过wait监听服务协程启动及stop状态。
-
监听到USR2信号，标识环境变量LISTEN_FDS，获取服务执行文件路径、参数、打开的文件描述及新增加的环境变量标识LISTEN_FDS，调用StartProcess启动新进程
-
新进程启动，处理新连接。新进程检测到环境变量LISTEN_FDS及进程的父进程id，调用syscall.Kill结束原进程，新进程等待父进程（原服务进程）的退出。
-
父进程检测到TERM信号，先停止接收系统信号，开始准备结束进程。若父进程存在未关闭的连接，则先关闭keep-alive，再关闭listener以阻止新连接连入。全部连接处理完关闭或超时后强制关闭所有连接后，wait内wg全部done。
-
wait处理结束，协程结束，父进程结束，仅留下新启动的子进程服务。