Fsnotify interface of go language to monitor file modification

Catalog

Preface

Installation tools

Key types

Event Structure

Op type

Watcher Structure

Channel

function

Watcher Factory function

Complete example

Preface

In the development process , It is often necessary to observe changes in the local file system . After Google for a few hours , To a simple tool to do this .

The tool is fsnotify It's a Go Cross platform file system notification tool . It provides a simple interface to monitor changes in the local file system .

In this article, we will take a look at how to use this tool .

Installation tools $ go get github.com/fsnotify/fsnotify Key types

Let's get to know fsnotify All types of tools .

Event Structure

Event The struct represents a single file system notification .

function String() Return to one “file: REMOVE|WRITE|…” The format string represents the string of the event .

type Event struct { Name string // The relative path of a file or directory Op Op // File change event }func (e Event) String() stringOp type

This tool describes a set of file operations . They are generic file operations that trigger notifications .

type Op uint32const ( Create Op = 1 << iota Write Remove Rename Chmod)Watcher Structure

Watcher The structure is the core of the tool . Contains two channel And three functions .

type Watcher struct { Events chan Event Errors chan error ...}func (w *Watcher) Add(name string) errorfunc (w *Watcher) Remove(name string) error func NewWatcher() (*Watcher, error)Channel

Events passageway

Errors passageway

function

Add： Non recursive monitoring of file or directory changes .

Remove： Stop monitoring files or directories .

Close： Turn off the monitoring of all files or directories and close Events passageway .

Watcher Factory function

function NewWatcher Create by calling the underlying operating system watcher object , And wait for the event notification .

func NewWatcher() (*Watcher, error) Complete example import ( "log" "github.com/fsnotify/fsnotify")func main() { watcher, err := fsnotify.NewWatcher() if err != nil { log.Fatal("new watcher 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}

The above code starts a goroutine Monitoring changes in directories or files in the background , Call function watcher.Add("./") The directory added for monitoring is the current directory , That is to say main.go File directory .
After running the program , If you modify the current main.go The file will produce the following results ：

Output

2022/06/09 07:01:15 main.go~ CREATE
2022/06/09 07:01:15 main.go WRITE|CHMOD
2022/06/09 07:01:15 main.go~ CREATE
2022/06/09 07:01:15 main.go CHMOD
2022/06/09 07:01:15 main.go WRITE
2022/06/09 07:01:15 main.go~ REMOVE
2022/06/09 07:01:16 main.go CHMOD

The output process above shows that , Modifying the file and saving it will trigger the following actions ：

CREATE Action is the creation of temporary files

WRITE Write file action

CHMOD Modify file properties

REMOVE Delete temporary files .

That's all Go Language fsnotify Interface implementation monitors the details of file modification , More about Go fsnotify For information on modification of interface monitoring files, please pay attention to other relevant articles of software development network ！