Fork me on GitHub
随笔 - 215  文章 - 13  trackbacks - 0
<2017年5月>
30123456
78910111213
14151617181920
21222324252627
28293031123
45678910


专注即时通讯及网游服务端编程
------------------------------------
Openresty 官方模块
Openresty 标准模块(Opm)
Openresty 三方模块
------------------------------------
本博收藏大部分文章为转载,并在文章开头给出了原文出处,如有再转,敬请保留相关信息,这是大家对原创作者劳动成果的自觉尊重!!如为您带来不便,请于本博下留言,谢谢配合。

常用链接

留言簿(1)

随笔分类

随笔档案

相册

Awesome

Blog

Book

GitHub

Link

搜索

  •  

积分与排名

  • 积分 - 211162
  • 排名 - 118

最新评论

阅读排行榜

golang 通过fsnotify监控文件,并通过文件变化重启程序


一、下载我们需要的包

1
go get github.com/fsnotify/fsnotify

二、使用fsnotify监控文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
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仍然是原来的文件名,这就需要我们在重命名事件中,先移除之前的监控,然后添加新的监控。

修改如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
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代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
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文件

1
go build server.go

监控文件fsnotify3.go代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
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掉进程,然后再启动一个进程。

posted on 2018-07-31 10:17 思月行云 阅读(1084) 评论(0)  编辑 收藏 引用 所属分类: Golang

只有注册用户登录后才能发表评论。
网站导航: 博客园   IT新闻   BlogJava   博问   Chat2DB   管理