golang API開發過程的中的自動重啟(基於gin框架)

• 概要
• 實現方式
• 補充
  • syscall.Exec

概要

基於 golang Gin 框架開發 web 服務時, 需要時不時的 go build , 然后重啟服務查看運行結果.
go build 的過程集成在編輯器中(emacs), 可以通過快捷鍵迅速完成, 但是每次重啟服務都切換到命令行中操作.
因此, 希望能夠編譯通過之后自動重啟服務.

這里並不是部署階段的服務重啟, 所以不用過多考慮是否正常退出其中的協程.

實現方式

在開源的 illuminant 項目中, 已經將相應的代碼集成到 gin 的 debug mode 中.

代碼文件: https://gitee.com/wangyubin/illuminant/blob/dev/server_cmd.go

 1  func setupWatcher() (chan struct{}, error) {
 2    file, err := osext.Executable()
 3    if err != nil {
 4      return nil, err
 5    }
 6    log.Printf("watching %q\n", file)
 7    w, err := fsnotify.NewWatcher()
 8    if err != nil {
 9      return nil, err
10    }
11    done := make(chan struct{})
12    go func() {
13      select {
14      case e := <-w.Events:
15        log.Printf("watcher received: %+v", e)
16        err := syscall.Exec(file, os.Args, os.Environ())
17        if err != nil {
18          log.Fatal(err)
19        }
20      case err := <-w.Errors:
21        log.Printf("watcher error: %+v", err)
22      case <-done:
23        log.Print("watcher shutting down")
24        return
25      }
26    }()
27    err = w.Add(file)
28    if err != nil {
29      return nil, err
30    }
31    return done, nil
32  }

在 gin debug mode 下, 使用此方法自動重啟服務

 1  if c.Bool("prod") {
 2    gin.SetMode(gin.ReleaseMode)
 3    // start route
 4    return routes.Routes(cnf.Server.Port)
 5  } else {
 6    gin.SetMode(gin.DebugMode)
 7    watcher, err := setupWatcher()
 8    if err != nil {
 9      // do something sensible
10      log.Fatal(err)
11    }
12    defer close(watcher)
13    return routes.Routes(cnf.Server.Port)
14  }

補充

上面函數的核心有以下兩點:

1. w, err := fsnotify.NewWatcher(): 創建監控文件變化的 watcher, err = w.Add(file) 並將當前二進制文件加入到監控文件列表中
2. err := syscall.Exec(file, os.Args, os.Environ()) 接受到文件變化的事件時, 重新調用一次自己, 使用上次一樣的參數和環境變量

syscall.Exec

對於這個函數, 一般可能用的比較少, 這里稍微介紹下. 它有 3 個參數:

1. args[0]: 可執行文件的路徑(相對路徑, 絕對路徑或者 PATH 中的路徑都可以)
2. args[1]: 命令的參數
3. args[2]: 命令的執行的環境變量, os.Environ() 表示繼承 caller 的環境變量

當 syscall.Exec 執行時, 在它之前的所有未執行完的程序都會被中止(包括在 go routine 中執行的程序),
然后執行 syscall.Exec 調用的命令, 該命令還保持在之前程序的 PID 下執行.

syscall.Exec 是最后一條執行的代碼, 重啟時在它之后可以有代碼, 但是都不會被執行到, 包括 defer 中的代碼.

下面是個小例子(通過這個例子可以驗證上面的結論):

 1  package main
 2  
 3  import (
 4   "fmt"
 5   "log"
 6   "os"
 7   "syscall"
 8   "time"
 9  
10   "github.com/fsnotify/fsnotify"
11   "github.com/kardianos/osext"
12  )
13  
14  func syscallExec() {
15   watcher, err := setupWatcher()
16   if err != nil {
17     log.Fatal(err)
18   }
19   defer finally(watcher)
20  
21   fmt.Printf("current pid: %d\n", os.Getpid())
22   var count = 0
23  
24   go func(count int) {
25     for {
26       fmt.Printf(">>> count in GO ROUTINE: %d\n", count)
27       count++
28       time.Sleep(1 * time.Second)
29     }
30   }(count)
31  
32   for {
33     fmt.Printf(">>> count in MAIN: %d\n", count)
34     count++
35     time.Sleep(1 * time.Second)
36   }
37  }
38  
39  func finally(watcher chan struct{}) {
40   // 重啟時沒有執行此函數
41   fmt.Println("exit original exec")
42   close(watcher)
43  }
44  
45  func setupWatcher() (chan struct{}, error) {
46   file, err := osext.Executable()
47   if err != nil {
48     return nil, err
49   }
50   log.Printf("watching %q\n", file)
51   w, err := fsnotify.NewWatcher()
52   if err != nil {
53     return nil, err
54   }
55   done := make(chan struct{})
56   go func() {
57     select {
58     case e := <-w.Events:
59       log.Printf("watcher received: %v", e)
60       err := syscall.Exec(file, os.Args, os.Environ())
61       if err != nil {
62         log.Fatal(err)
63       }
64     case err := <-w.Errors:
65       log.Printf("watcher error: %+v", err)
66     case <-done:
67       log.Print("watcher shutting down")
68       return
69     }
70   }()
71   err = w.Add(file)
72   if err != nil {
73     return nil, err
74   }
75   return done, nil
76  }