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()读取新的配置；
- 如果注册了事件回调，以发生的事件为参数执行回调。
Songzhibin
