gin-优雅的停止&热更新

优雅的停止

不中断正常的请求，等所有请求处理完才停止服务
如果你使用的是　Go 1.8，你可能不需要使用这些库！考虑使用　http.Server　内置的　Shutdown()　方法正常关闭。查看 Gin 中完整的　graceful-shutdown 示例。

package main
import (
    "context"
    "github.com/gin-gonic/gin"
    "log"
    "net/http"
    "os"
    "os/signal"
    "time"
)
func main() {
    router := gin.Default()
    router.GET("/", func(c *gin.Context) {
        time.Sleep(5 * time.Second)
        c.String(http.StatusOK, "Welcome Gin Server")
        //c.String(http.StatusOK, "Welcome Gin Server")
    })
    router.NoMethod()
    srv := &http.Server{
        Addr:    ":8080",
        Handler: router,
    }
    go func() {
        // 连接服务器
        if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatalf("listen: %s\n", err)
        }
    }()
    // 等待信号处理完正常关闭服务
    quit := make(chan os.Signal)
    signal.Notify(quit, os.Interrupt)
    <-quit
    log.Println("Shutdown Server ...")
    // 在这里也可以设定超时，就算有存活的链接也强制关闭服务
    if err := srv.Shutdown(context.Background()); err != nil {
        log.Fatal("Server Shutdown:", err)
    }
    log.Println("Server exiting")
}

Shutdown源码如下：
它会定期的(500毫秒)，检查当前连接状态，如果连接全部处于空闲状态，那么将停止服务

func (srv *Server) Shutdown(ctx context.Context) error {
    atomic.StoreInt32(&srv.inShutdown, 1)
    srv.mu.Lock()
    lnerr := srv.closeListenersLocked()
    srv.closeDoneChanLocked()
    for _, f := range srv.onShutdown {
        go f()
    }
    srv.mu.Unlock()
    ticker := time.NewTicker(shutdownPollInterval) // 这里是500毫秒
    defer ticker.Stop()
    for {
        if srv.closeIdleConns() {
            return lnerr
        }
        select {
        case <-ctx.Done():
            return ctx.Err()
        case <-ticker.C:
        }
    }
}

热更新

你想正常的重启或停止你的 web 服务器吗？
有一些方法可以做到。
我们能使用 fvbock/endless 去替换默认的 ListenAndServe. 参考 issue #296 了解更多细节。

router := gin.Default()
router.GET("/", handler)
// [...]
endless.ListenAndServe(":4242", router)

另外一些替代方案：

• manners　： 一个有礼貌的 Go HTTP 服务器，它可以正常的关闭。
• graceful　：　Graceful 是一个 Go 包，它可以正常的关闭一个　http.Handler 服务器。
• grace　：　正常的重启 & Go　服务器零停机部署。

endless使用与原理

文档：https://godoc.org/github.com/fvbock/endless

var (
    DefaultReadTimeOut    time.Duration
    DefaultWriteTimeOut   time.Duration
    DefaultMaxHeaderBytes int
    DefaultHammerTime     time.Duration
)

func ListenAndServe(addr string, handler http.Handler) error
func ListenAndServeTLS(addr string, certFile string, keyFile string, handler http.Handler) error
func NewServer(addr string, handler http.Handler) (srv *endlessServer)

package main
import (
    "github.com/fvbock/endless"
    "github.com/gin-gonic/gin"
    "log"
    "net/http"
    "time"
)
func main() {
    router := gin.Default()
    router.GET("/", func(c *gin.Context) {
        time.Sleep(10 * time.Second)
        c.String(http.StatusOK, "111111111")
        // c.String(http.StatusOK, "222222222")
    })
    endless.DefaultReadTimeOut = readTimeout
    endless.DefaultWriteTimeOut = writeTimeout
    endless.DefaultMaxHeaderBytes = maxHeaderBytes
    s := endless.NewServer(":8080", router)
    err := s.ListenAndServe()
    if err != nil {
        log.Printf("server err: %v", err)
    }
}

1. 开启服务，删除可执行的文件
2. 访问 等10s 得到111111111
3. 将返回改为222222222，编译——上传——-赋予执行权限
4. 访问 ps到服务的进程 xxx kill -l xxx 手速快点，10s内完成，依然得到111111111
5. 访问，等10s222222222

• Received SIGHUP. forking. : 接收到kill -l xxx的信号
• Waiting for connections to finish… ：父进程等待连接处理完成
• [::]:8080 Listener closed.：当前的服务已关闭，这里的关闭是准备准备的意思，如果当前的服务还没处理完,例如处理A时又来了个B，最后返回时A与B都会返回111111111
• Serve() returning… ：此时表示旧服务中的请求都已处理完，新的服务已经运行起来
• accept tcp [::]:8080: use of closed network connection ： 提示新的请求将进入新程序

其使用非常简单，实现代码也很少，但是很强大，下面我们看看实现：
kill -1
endless的使用方法是先编译新程序，并执行”kill -1 旧进程id”，我们看看旧程序接收到-1信号之后作了什么：

func (srv *endlessServer) handleSignals() {
    ...
    for {
        sig = <-srv.sigChan
        srv.signalHooks(PRE_SIGNAL, sig)
        switch sig {
        case syscall.SIGHUP:    //接收到-1信号之后，fork一个进程，并运行新编译的程序
            log.Println(pid, "Received SIGHUP. forking.")
            err := srv.fork()
            if err != nil {
                log.Println("Fork err:", err)
            }
        ...
        default:
            log.Printf("Received %v: nothing i care about...\n", sig)
        }
        srv.signalHooks(POST_SIGNAL, sig)
    }
}
func (srv *endlessServer) fork() (err error) {
    ...
    path := os.Args[0]    //获取当前程序的路径，在子进程执行。所以要保证新编译的程序路径和旧程序的一致。
    var args []string
    if len(os.Args) > 1 {
        args = os.Args[1:]
    }
    cmd := exec.Command(path, args...)
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr
    //socket在此处传给子进程，windows系统不支持获取socket文件，所以endless无法在windows上用。
    //windows获取socket文件时报错：file tcp [::]:9999: not supported by windows。
    cmd.ExtraFiles = files    
    cmd.Env = env    //env有一个ENDLESS_SOCKET_ORDER变量存储了socket传递的顺序（如果有多个socket）
    ...
    err = cmd.Start()    //运行新程序
    if err != nil {
        log.Fatalf("Restart: Failed to launch, error: %v", err)
    }
    return
}

接下来我们看看程序启动之后做了什么

ListenAndServe**
新进程启动之后会执行ListenAndServe这个方法，这个方法主要做了系统信号监听，并且判断自己所在进程是否是子进程，如果是，则发送中断信号给父进程，让其退出。最后调用Serve方法给socket提供新的服务。

func (srv *endlessServer) ListenAndServe() (err error) {
    ...
    go srv.handleSignals()
    l, err := srv.getListener(addr)
    if err != nil {
        log.Println(err)
        return
    }
    srv.EndlessListener = newEndlessListener(l, srv)
    if srv.isChild {
        syscall.Kill(syscall.Getppid(), syscall.SIGTERM)        //给父进程发出中断信号
    }
    ...
    return srv.Serve()    //为socket提供新的服务
}

复用socket**
前面提到复用socket是endless的核心，必须在Serve前准备好，否则会导致端口已使用的异常。复用socket的实现在上面的getListener方法中：

func (srv *endlessServer) getListener(laddr string) (l net.Listener, err error) {
    if srv.isChild {//如果此方法运行在子进程中，则复用socket
        var ptrOffset uint = 0
        runningServerReg.RLock()
        defer runningServerReg.RUnlock()
        if len(socketPtrOffsetMap) > 0 {
            ptrOffset = socketPtrOffsetMap[laddr]//获取和addr相对应的socket的位置
        }
        f := os.NewFile(uintptr(3+ptrOffset), "")//创建socket文件描述符
        l, err = net.FileListener(f)//创建socket文件监听器
        if err != nil {
            err = fmt.Errorf("net.FileListener error: %v", err)
            return
        }
    } else {//如果此方法不是运行在子进程中，则新建一个socket
        l, err = net.Listen("tcp", laddr)
        if err != nil {
            err = fmt.Errorf("net.Listen error: %v", err)
            return
        }
    }
    return
}

但是父进程关闭socket和子进程绑定socket并不可能同时进行，如果这段时间有请求进来，这个请求会到哪里去呢？

• 第一种情况：如果某个终端跟服务器建立了长连接（应该是设置了keepalive属性），那么该终端的所有请求都会发到建立长连接的进程去，即父进程
• 第二种情况：如果有新的请求进来，当父进程没结束(与新服务启动是对立的)，会被分配的父进程
• 第三种情况，父进程或者子进程任意一个退出之后，所有请求都会转发到另一个进程进行处理

从以上三种情况看，endless的做法不会落下任何请求，因为请求不是被父进程处理了就是被子进程处理了，所以endless是个可放心使用的热更新方案