fsnotify監控文件

下載

$ go get github.com/fsnotify/fsnotify

使用fsnotify監控文件

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 {};
}

監控配置文件修改重啟服務

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);
    }
}

使用用例

package main

import (
  "log"

  "github.com/fsnotify/fsnotify"
)

func main() {
  watcher, err := fsnotify.NewWatcher()
  if err != nil {
    log.Fatal("NewWatcher failed: ", err)
  }
  defer watcher.Close()

  done := make(chan bool)
  go func() {
    defer close(done)

    for {
      select {
      case event, ok := <-watcher.Events:
        if !ok {
          return
        }
        log.Printf("%s %s\n", event.Name, event.Op)
      case err, ok := <-watcher.Errors:
        if !ok {
          return
        }
        log.Println("error:", err)
      }
    }
  }()

  err = watcher.Add("./")
  if err != nil {
    log.Fatal("Add failed:", err)
  }
  <-done
}

fsnotify的使用比較簡單：

• 先調用NewWatcher創建一個監聽器；
• 然后調用監聽器的Add增加監聽的文件或目錄；
• 如果目錄或文件有事件產生，監聽器中的通道Events可以取出事件。如果出現錯誤，監聽器中的通道Errors可以取出錯誤信息。

上面示例中，我們在另一個 goroutine 中循環讀取發生的事件及錯誤，然后輸出它們。
編譯、運行程序。在當前目錄創建一個新建文本文檔.txt，然后重命名為file1.txt文件，輸入內容some test text，然后刪除它。觀察控制台輸出：

2020/01/20 08:41:17 新建文本文檔.txt CREATE
2020/01/20 08:41:25 新建文本文檔.txt RENAME
2020/01/20 08:41:25 file1.txt CREATE
2020/01/20 08:42:28 file1.txt REMOVE

其實，重命名時會產生兩個事件，一個是原文件的RENAME事件，一個是新文件的CREATE事件。
注意，fsnotify使用了操作系統接口，監聽器中保存了系統資源的句柄，所以使用后需要關閉。

事件

上面示例中的事件是fsnotify.Event類型

// fsnotify/fsnotify.go
type Event struct {
  Name string
  Op   Op
}

事件只有兩個字段，Name表示發生變化的文件或目錄名，Op表示具體的變化。Op有 5 種取值：

// fsnotify/fsnotify.go
type Op uint32

const (
  Create Op = 1 << iota
  Write
  Remove
  Rename
  Chmod
)

在快速使用中，我們已經演示了前 4 種事件。Chmod事件在文件或目錄的屬性發生變化時觸發，在 Linux 系統中可以通過chmod命令改變文件或目錄屬性。

事件中的Op是按照位來存儲的，可以存儲多個，可以通過&操作判斷對應事件是不是發生了。

if event.Op & fsnotify.Write != 0 {
  fmt.Println("Op has Write")
}

我們在代碼中不需要這樣判斷，因為Op的String()方法已經幫我們處理了這種情況了：

// fsnotify.go
func (op Op) String() string {
  // Use a buffer for efficient string concatenation
  var buffer bytes.Buffer

  if op&Create == Create {
    buffer.WriteString("|CREATE")
  }
  if op&Remove == Remove {
    buffer.WriteString("|REMOVE")
  }
  if op&Write == Write {
    buffer.WriteString("|WRITE")
  }
  if op&Rename == Rename {
    buffer.WriteString("|RENAME")
  }
  if op&Chmod == Chmod {
    buffer.WriteString("|CHMOD")
  }
  if buffer.Len() == 0 {
    return ""
  }
  return buffer.String()[1:] // Strip leading pipe
}

viper監聽示例

// viper/viper.go
func WatchConfig() { v.WatchConfig() }

func (v *Viper) WatchConfig() {
  initWG := sync.WaitGroup{}
  initWG.Add(1)
  go func() {
    watcher, err := fsnotify.NewWatcher()
    if err != nil {
      log.Fatal(err)
    }
    defer watcher.Close()
    // we have to watch the entire directory to pick up renames/atomic saves in a cross-platform way
    filename, err := v.getConfigFile()
    if err != nil {
      log.Printf("error: %v\n", err)
      initWG.Done()
      return
    }

    configFile := filepath.Clean(filename)
    configDir, _ := filepath.Split(configFile)
    realConfigFile, _ := filepath.EvalSymlinks(filename)

    eventsWG := sync.WaitGroup{}
    eventsWG.Add(1)
    go func() {
      for {
        select {
        case event, ok := <-watcher.Events:
          if !ok { // 'Events' channel is closed
            eventsWG.Done()
            return
          }
          currentConfigFile, _ := filepath.EvalSymlinks(filename)
          // we only care about the config file with the following cases:
          // 1 - if the config file was modified or created
          // 2 - if the real path to the config file changed (eg: k8s ConfigMap replacement)
          const writeOrCreateMask = fsnotify.Write | fsnotify.Create
          if (filepath.Clean(event.Name) == configFile &&
            event.Op&writeOrCreateMask != 0) ||
            (currentConfigFile != "" && currentConfigFile != realConfigFile) {
            realConfigFile = currentConfigFile
            err := v.ReadInConfig()
            if err != nil {
              log.Printf("error reading config file: %v\n", err)
            }
            if v.onConfigChange != nil {
              v.onConfigChange(event)
            }
          } else if filepath.Clean(event.Name) == configFile &&
            event.Op&fsnotify.Remove&fsnotify.Remove != 0 {
            eventsWG.Done()
            return
          }

        case err, ok := <-watcher.Errors:
          if ok { // 'Errors' channel is not closed
            log.Printf("watcher error: %v\n", err)
          }
          eventsWG.Done()
          return
        }
      }
    }()
    watcher.Add(configDir)
    initWG.Done()   // done initializing the watch in this go routine, so the parent routine can move on...
    eventsWG.Wait() // now, wait for event loop to end in this go-routine...
  }()
  initWG.Wait() // make sure that the go routine above fully ended before returning
}

其實流程是相似的：

• 首先，調用NewWatcher創建一個監聽器；
• 調用v.getConfigFile()獲取配置文件路徑，抽出文件名、目錄，配置文件如果是一個符號鏈接，獲得鏈接指向的路徑；
• 調用watcher.Add(configDir)監聽配置文件所在目錄，另起一個 goroutine 處理事件。

WatchConfig不能阻塞主 goroutine，所以創建監聽器也是新起 goroutine 進行的。代碼中有兩個sync.WaitGroup變量，initWG是為了保證監聽器初始化，
eventsWG是在事件通道關閉，或配置被刪除了，或遇到錯誤時退出事件處理循環。

然后就是核心事件循環：

• 有事件發生時，判斷變化的文件是否是在 viper 中設置的配置文件，發生的是否是創建或修改事件（只處理這兩個事件）；
• 如果配置文件為符號鏈接，若符合鏈接的指向修改了，也需要重新加載配置；
• 如果需要重新加載配置，調用v.ReadInConfig()讀取新的配置；
• 如果注冊了事件回調，以發生的事件為參數執行回調。