golang 通過fsnotify監控文件，並通過文件變化重啟程序

一、下載我們需要的包

> go get github.com/fsnotify/fsnotify

二、使用fsnotify監控文件

package main;

import (
	"github.com/fsnotify/fsnotify"
	"log"
	"fmt"
)

func main() {
	//創建一個監控對象
	watch, err := fsnotify.NewWatcher();
	if err != nil {
		log.Fatal(err);
	}
	defer watch.Close();
	//添加要監控的對象，文件或文件夾
	err = watch.Add("./tmp");
	if err != nil {
		log.Fatal(err);
	}
	//我們另啟一個goroutine來處理監控對象的事件
	go func() {
		for {
			select {
			case ev := <-watch.Events:
				{
					//判斷事件發生的類型，如下5種
					// Create 創建
					// Write 寫入
					// Remove 刪除
					// Rename 重命名
					// Chmod 修改權限
					if ev.Op&fsnotify.Create == fsnotify.Create {
						log.Println("創建文件 : ", ev.Name);
					}
					if ev.Op&fsnotify.Write == fsnotify.Write {
						log.Println("寫入文件 : ", ev.Name);
					}
					if ev.Op&fsnotify.Remove == fsnotify.Remove {
						log.Println("刪除文件 : ", ev.Name);
					}
					if ev.Op&fsnotify.Rename == fsnotify.Rename {
						log.Println("重命名文件 : ", ev.Name);
					}
					if ev.Op&fsnotify.Chmod == fsnotify.Chmod {
						log.Println("修改權限 : ", ev.Name);
					}
				}
			case err := <-watch.Errors:
				{
					log.Println("error : ", err);
					return;
				}
			}
		}
	}();

	//循環
	select {};
}

測試結果如下：

我們在tmp目錄下的操作都被捕捉到了，但是fsnotify有一個問題，它無法遞歸的幫我們捕捉子目錄、孫子目錄的操作事件，這需要我們自已來實現。

還有一個問題就是當們修改文件夾名稱時，fsnotify中event.Name仍然是原來的文件名，這就需要我們在重命名事件中，先移除之前的監控，然后添加新的監控。

修改如下：

package main;

import (
	"github.com/fsnotify/fsnotify"
	"fmt"
	"path/filepath"
	"os"
)

type Watch struct {
	watch *fsnotify.Watcher;
}

//監控目錄
func (w *Watch) watchDir(dir string) {
	//通過Walk來遍歷目錄下的所有子目錄
	filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
		//這里判斷是否為目錄，只需監控目錄即可
		//目錄下的文件也在監控范圍內，不需要我們一個一個加
		if info.IsDir() {
			path, err := filepath.Abs(path);
			if err != nil {
				return err;
			}
			err = w.watch.Add(path);
			if err != nil {
				return err;
			}
			fmt.Println("監控 : ", path);
		}
		return nil;
	});
	go func() {
		for {
			select {
			case ev := <-w.watch.Events:
				{
					if ev.Op&fsnotify.Create == fsnotify.Create {
						fmt.Println("創建文件 : ", ev.Name);
						//這里獲取新創建文件的信息，如果是目錄，則加入監控中
						fi, err := os.Stat(ev.Name);
						if err == nil && fi.IsDir() {
							w.watch.Add(ev.Name);
							fmt.Println("添加監控 : ", ev.Name);
						}
					}
					if ev.Op&fsnotify.Write == fsnotify.Write {
						fmt.Println("寫入文件 : ", ev.Name);
					}
					if ev.Op&fsnotify.Remove == fsnotify.Remove {
						fmt.Println("刪除文件 : ", ev.Name);
						//如果刪除文件是目錄，則移除監控
						fi, err := os.Stat(ev.Name);
						if err == nil && fi.IsDir() {
							w.watch.Remove(ev.Name);
							fmt.Println("刪除監控 : ", ev.Name);
						}
					}
					if ev.Op&fsnotify.Rename == fsnotify.Rename {
						fmt.Println("重命名文件 : ", ev.Name);
						//如果重命名文件是目錄，則移除監控
						//注意這里無法使用os.Stat來判斷是否是目錄了
						//因為重命名后，go已經無法找到原文件來獲取信息了
						//所以這里就簡單粗爆的直接remove好了
						w.watch.Remove(ev.Name);
					}
					if ev.Op&fsnotify.Chmod == fsnotify.Chmod {
						fmt.Println("修改權限 : ", ev.Name);
					}
				}
			case err := <-w.watch.Errors:
				{
					fmt.Println("error : ", err);
					return;
				}
			}
		}
	}();
}

func main() {
	watch, _ := fsnotify.NewWatcher()
	w := Watch{
		watch: watch,
	}
	w.watchDir("./tmp");
	select {};
}

測試結果如下：

經過上面的例子，我們通過fsnotify來寫一個監控配置文件，如果配置文件有修改，就重新啟動服務。

我們先寫一個可以運行的exe程序，server.go代碼如下：

package main;

import (
	"io/ioutil"
	"log"
	"encoding/json"
	"net"
	"fmt"
	"os"
	"os/signal"
)

const (
	confFilePath = "./conf/conf.json";
)

//我們這里只是演示，配置項只設置一個
type Conf struct {
	Port int `json:port`;
}

func main() {
	//讀取文件內容
	data, err := ioutil.ReadFile(confFilePath);
	if err != nil {
		log.Fatal(err);
	}
	var c Conf;
	//解析配置文件
	err = json.Unmarshal(data, &c);
	if err != nil {
		log.Fatal(err);
	}
	//根據配置項來監聽端口
	lis, err := net.Listen("tcp", fmt.Sprintf(":%d", c.Port));
	if err != nil {
		log.Fatal(err);
	}
	log.Println("server start");
	go func() {
		ch := make(chan os.Signal);
		//獲取程序退出信號
		signal.Notify(ch, os.Interrupt, os.Kill);
		<-ch;
		log.Println("server exit");
		os.Exit(1);
	}();
	for {
		conn, err := lis.Accept();
		if err != nil {
			continue;
		}
		go func(conn net.Conn) {
			defer conn.Close();
			conn.Write([]byte("hello\n"));
		}(conn);
	}
}

使用如下命令，編譯成exe文件

> go build server.go

監控文件fsnotify3.go代碼如下：

package main;

import (
	"github.com/fsnotify/fsnotify"
	"log"
	"fmt"
	"os/exec"
	"regexp"
	"strconv"
	"bytes"
	"errors"
	"os"
	"path/filepath"
)

const (
	confFilePath = "./conf";
)

//獲取進程ID
func getPid(processName string) (int, error) {
	//通過wmic process get name,processid | findstr server.exe獲取進程ID
	buf := bytes.Buffer{};
	cmd := exec.Command("wmic", "process", "get", "name,processid");
	cmd.Stdout = &buf;
	cmd.Run();
	cmd2 := exec.Command("findstr", processName);
	cmd2.Stdin = &buf;
	data, _ := cmd2.CombinedOutput();
	if len(data) == 0 {
		return -1, errors.New("not find");
	}
	info := string(data);
	//這里通過正則把進程id提取出來
	reg := regexp.MustCompile(`[0-9]+`);
	pid := reg.FindString(info);
	return strconv.Atoi(pid);
}

//啟動進程
func startProcess(exePath string, args []string) error {
	attr := &os.ProcAttr{
		//files指定新進程繼承的活動文件對象
		//前三個分別為，標准輸入、標准輸出、標准錯誤輸出
		Files: []*os.File{os.Stdin, os.Stdout, os.Stderr},
		//新進程的環境變量
		Env: os.Environ(),
	}

	p, err := os.StartProcess(exePath, args, attr);
	if err != nil {
		return err;
	}
	fmt.Println(exePath, "進程啟動");
	p.Wait();
	return nil;
}

func main() {
	//創建一個監控對象
	watch, err := fsnotify.NewWatcher();
	if err != nil {
		log.Fatal(err);
	}
	defer watch.Close();
	//添加要監控的文件
	err = watch.Add(confFilePath);
	if err != nil {
		log.Fatal(err);
	}
	//我們另啟一個goroutine來處理監控對象的事件
	go func() {
		for {
			select {
			case ev := <-watch.Events:
				{
					//我們只需關心文件的修改
					if ev.Op&fsnotify.Write == fsnotify.Write {
						fmt.Println(ev.Name, "文件寫入");
						//查找進程
						pid, err := getPid("server.exe");
						//獲取運行文件的絕對路徑
						exePath, _ := filepath.Abs("./server.exe")
						if err != nil {
							//啟動進程
							go startProcess(exePath, []string{});
						} else {
							//找到進程，並退出
							process, err := os.FindProcess(pid);
							if err == nil {
								//讓進程退出
								process.Kill();
								fmt.Println(exePath, "進程退出");
							}
							//啟動進程
							go startProcess(exePath, []string{});
						}
					}
				}
			case err := <-watch.Errors:
				{
					fmt.Println("error : ", err);
					return;
				}
			}
		}
	}();

	//循環
	select {};
}

我們運行fsnotify3.go文件來監控我們的配置文件

通過上面的圖可以看到，當我們修改配置文件中的端口號時，會先kill掉進程，然后再啟動一個進程。