Home >Backend Development >Golang >How to implement file monitoring in golang

How to implement file monitoring in golang

青灯夜游Original: 2023-02-20 10:15:374730browse

In golang, you can use fsnotify to implement file monitoring. fsnotify is a cross-platform file system monitoring tool in the Go language, which implements a channel-based, cross-platform real-time monitoring interface; golang can monitor files through fsnotify and restart the program through file changes.

The operating environment of this tutorial: Windows 10 system, GO version 1.18, Dell G3 computer.

In golang, you can use fsnotify to implement file monitoring.

golang monitors files through fsnotify and restarts the program through file changes.

Go language cross-platform file system monitoring tool - fsnotify

In the Linux kernel, Inotify is a tool used to notify users Mechanism of spatial program file system changes. It monitors file system changes, such as file creation, modification, deletion, etc., and can notify applications of corresponding events.

Inotify can monitor both files and directories. When monitoring a directory, it can monitor the directory and each subdirectory and file in the directory at the same time. Golang's standard library syscall implements this mechanism.

In order to further expand and abstract, the github.com/fsnotify/fsnotify package implements a channel-based, cross-platform real-time monitoring interface.

Usage of fsnotify tool

1. Download the packages we need

go get github.com/fsnotify/fsnotify

2. Use fsnotify to monitor files

##package main ;

import (

"github.com/ fsnotify/fsnotify"

"log"

"fmt"

)

func main() {

#//Create a monitoring object

watch, err := fsnotify.NewWatcher();

if err != nil {

log.Fatal(err);

}

defer watch.Close();

//Add objects, files or folders to be monitored

err = watch.Add(". /tmp");

if err != nil {

log.Fatal(err);##

//We start another goroutine to handle the events of the monitored object

go func() {

for

{##

case

ev := <code class="js keyword">## # through ## // Rename Rename

## ev.Op&fsnotify.Create == fsnotify.Create {

log.Println("Create file: ", ev.Name);

}

## log.Println("Write file: "

, ev.Name); }

# log.Println(

"Delete file: ", ev.Name);

} # log.Println(

"Rename file: ", ev.Name);

}

Log.println ( "Modification permissions:" , Ev.name);

through #err :=

#return;##

//Loop

select {};}

The test results are as follows:

How to implement file monitoring in golang

All our operations in the tmp directory were captured, but there is a problem with fsnotify. It cannot help us capture subdirectories recursively. The operation events of the Sun Tzu directory need to be implemented by ourselves.

Another problem is that when we modify the folder name, the event.Name in fsnotify is still the original file name. This requires us to first remove the previous monitoring in the rename event, and then add New monitoring.

Modify as follows:

##1

##59

package main;
 
import (<p class="line number4 index3 alt1"><code class="js spaces">     "github.com/fsnotify/fsnotify"
      "fmt"
 "path/filepath"
 "os"
)
  
type Watch struct {
 watch *fsnotify.Watcher ;
}
  
//Monitoring directory
func (w *Watch) watchDir(dir string) {
 //Traverse all subdirectories under the directory through Walk
                                                                                                                                                   //To determine whether it is a directory, you only need to monitor the directory
           //The files in the directory are also within the monitoring range, we do not need it Add one by one 
                                                       ##path, err := filepath.Abs(path);##                    
if err != nil {                                                                                                                                                                   ##                                                                                                                                            
##                                                                                                                                             return err; 
#                                                                                                                                                            ##}                                                                         #});
 go func() {<p class="line number34 index33 alt1"><code class="js spaces">                                                                                                                                                             ##                                                                                                                      ev := 
#                                                                                                                                                                                                    through fmt.Println("Create file: ", ev.Name);
##                                                                                                   Information about creating files, if it is a directory, it will be added to the monitoring                             
#                                                                                                                                                                                                                                                                                                   in the .watch.Add(ev.Name);##                                     fmt.Println(
"Add monitoring: ", EV.NAME); 
#} #} ##                                                                                                                                                                                                                                       through ("Write file: "
, ev.Name);
##                      if ev.Op&fsnotify.Remove == fsnotify.Remove {
                   fmt.Println("Delete file: ", ev.Name);
               //If the deleted file is a directory, remove the monitoring
                                                                                                                                                                                                                     since ;
                                                                                                                                       ​ ##w.watch.Remove(ev.Name);##                                                                                  ##, ev.Name);
##                                                                                                     ##                                                                                                                                                                                                                                                              through fmt.Println(
"Rename file: ", ev.Name);                                                    /If the renamed file is a directory, remove the monitoring
//Note that os.Stat cannot be used here to determine whether it is a directory
# // Because after the rename, Go can no longer find the original file to get information 
#// So here is a simple and crude way to remove it                                           ##               }
                    if ev.Op&fsnotify.Chmod == fsnotify.Chmod {
                        fmt.Println("修改权限 : ", ev.Name);
                    }
                }
            case err := 
                {
                    fmt.Println("error : ", err);
                    return;
                }
            }
        }
    }();
}
  
func main() {
    watch, _ := fsnotify.NewWatcher()
    w := Watch{
        watch: watch,
    }
    w.watchDir("./tmp");
    select {};
}

The test results are as follows:

How to implement file monitoring in golang

After the above example, we use fsnotify to write a monitoring configuration file. If the configuration file is modified, the service will be restarted.

We first write an exe program that can be run. The server.go code is as follows:

##> ; go build server.go

package main;
  
import (
​ "io/ioutil"
 "log"
 " encoding/json"
   "net"
     "fmt"
      "os"
        "os/signal"
)
##const (
 confFilePath = "./conf/conf.json";
)
  
//We are just demonstrating here, the configuration item only sets one
type Conf struct {
​ Port int `json:port`;
}
  
func main( ) {
 //Read file content
 data, err := ioutil .ReadFile(confFilePath);
       if err != nil {
             #log.Fatal(err);
 }
 var c Conf;
 //Parse the configuration file
 err = json.Unmarshal(data, &c);
 if err != nil {
        log.Fatal(err);
##                                                                                                  ##//Listen to the port according to the configuration items 
lis, err := net.Listen("tcp", fmt.Sprintf(
":%d", c.Port)); if  err != nil {##                                                                                           
#} log.Println(
"server start");
go func() {
                                                                                                                                                                                                                                                        . .Kill);                                                                     ##"server exit"
);##                os.Exit(1);
 }();
     #for {
##                 conn, err := lis.Accept();
                                                                                                                                                  #;               
}##                       go func(conn net.Conn) {
# steer conn.close (); 
# Conn.write ([] byte("hello\n"
));##          }(conn);
     }}
Use the following command to compile into an exe file
##1

The monitoring file fsnotify3.go code is as follows:

Golang tutorial

##53

##87

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);
 //Here the process id is extracted through regular expression
 ​ reg := regexp.MustCompile(`[0-9] `);
 ​  pid := reg.FindString(info);
 return strconv.Atoi(pid);
}
  
//Start the process
func startProcess(exePath string , args []string) error {
##                                                                                   #//files specifies the active file object inherited by the new process          
//The first three are standard input, standard output, and standard error output                                                                                                                       
##//Environment variables of the new process          
Env: os.Environ(), 
}  
 p, err := os.StartProcess(exePath, args, attr);
            if 
err != nil {##                          #return
err; 
} fmt.Println (exePath, 
"Process Start"); 
p.Wait(); 
return nil;}
##func main() {
​ //Create a monitoring object
watch, err := fsnotify.NewWatcher();
 
if err != nil { 
                                                                                                 defer watch.Close();
 //Add the file to be monitored
 err = watch.Add(confFilePath);
           if err != nil {
##                                                                                                    ; 
} 
//We start another goroutine to handle the monitoring object Event                                                                                                        
                                                                                                                                                                                                         -watch.Events:
                                                                                            Modify     ##fmt.Println(ev.Name, 
"File writing");##                                                      //Find process
# // Get the absolute path for running files 
# EXEPATH, _: = filepath.abs ("./server.exe")
##                                                 {                                                                                                                                                                                                                                                                                     through });
                                                                                                                                                                                                                                                                                            through And exit                                                                                                                                                          if err == nil {
                                                                                                     process.Kill();
##                                                                                  
#} // #                                                                                                                                                                                                                   
go startProcess(exePath, []string{});                                                                                                                                                                    through 
#err := ##                                                                                                   #fmt.Println("error : ", err);##                                                 ;<p class="line number104 index103 alt1"><code class="js spaces">                                                                                                                                                                                                                 through }##   
}(); 
    //Loop
 select {};
}
 
We run the fsnotify3.go file to monitor our configuration file
As you can see from the above picture, When we modify the port number in the configuration file, the process will be killed first and then a process will be started. 

Recommended learning:

The above is the detailed content of How to implement file monitoring in golang. For more information, please follow other related articles on the PHP Chinese website!

golang json String if for select Error const continue 递归 int 循环继承接口 signal Struct Event Go语言 var len nil channel regexp 对象事件 github linux

Statement：

The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn

How to implement file monitoring in golang

Related articles