站长资讯网
最全最丰富的资讯网站

golang怎么实现文件监控

在golang中,可以利用fsnotify来实现文件监控。fsnotify是go语言跨平台文件系统监控工具,实现了一个基于channel的、跨平台的实时监听接口;golang通过fsnotify可监控文件,并通过文件变化重启程序。

golang怎么实现文件监控

本教程操作环境:windows10系统、GO 1.18版本、Dell G3电脑。

在golang中,可以利用fsnotify来实现文件监控。

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

go语言跨平台文件系统监控工具 — fsnotify

在 linux 内核中,Inotify 是一种用于通知用户空间程序文件系统变化的机制。它监控文件系统的变化,如文件新建、修改、删除等,并可以将相应的事件通知给应用程序。

Inotify 既可以监控文件,也可以监控目录。当监控目录时,它可以同时监控目录及目录中的各子目录及文件。Golang 的标准库 syscall 实现了该机制。

为了进一步扩展和抽象, github.com/fsnotify/fsnotify 包实现了一个基于 channel 的、跨平台的实时监听接口。

fsnotify工具的使用

一、下载我们需要的包

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

}

测试结果如下:

golang怎么实现文件监控

我们在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 {};

}

测试结果如下:

golang怎么实现文件监控

经过上面的例子,我们通过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("hellon"));

}(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文件来监控我们的配置文件

golang怎么实现文件监控

通过上面的图可以看到,当我们修改配置文件中的端口号时,会先kill掉进程,然后再启动一个进程。

golang怎么实现文件监控

推荐学习:Golang教程

赞(0)
分享到: 更多 (0)
网站地图   沪ICP备18035694号-2    沪公网安备31011702889846号