golang monitor file modification

With the continuous development of computer technology, file operations have become an essential part of our daily work and life. However, for some important files, we need to monitor them regularly to ensure their security and integrity. So, how to implement file monitoring and modification detection in golang?

1. System file monitoring

1.1 FSnotify

Golang provides a very excellent file system monitoring library-FSnotify. By adding a listener in the monitoring directory, developers can be notified when files are created, modified, deleted and other operations occur, and handle them accordingly.

The advantages of FSnotify include: cross-platform support, high-performance event capture, monitoring files without blocking the program, etc. Therefore, it is widely used in file synchronization, log analysis, file backup and other scenarios.

The following is the basic usage of FSnotify:

package main

import (
    "github.com/fsnotify/fsnotify"
    "log"
)

func main() {
    // 创建文件系统监控器
    watcher, err := fsnotify.NewWatcher()
    if err != nil {
        log.Fatal(err)
    }
    defer watcher.Close()

    // 添加需要监控的目录
    err = watcher.Add("/path/to/monitor")
    if err != nil {
        log.Fatal(err)
    }

    // 开始监听文件更改事件
    for {
        select {
        case event := <-watcher.Events:
            log.Println("event:", event)
        case err := <-watcher.Errors:
            log.Println("error:", err)
        }
    }
}

In the above sample code, we created a file system monitor and specified the directory that needs to be monitored. Then, we use a for loop to continuously listen for file change events.

By parsing the event, we can know whether the file is created, modified or deleted. For example, if we need to know the event when a file is created, we can make the following judgment:

if event.Op&fsnotify.Create == fsnotify.Create {
    log.Println("File created:", event.Name)
}

Similarly, we can judge by other operation identifiers (such as Write, Remove, Rename, Chmod, etc.) File modification, deletion, renaming, permission changes and other events.

1.2 Regularly detect file modifications

In addition to using FSnotify, we can also implement file modification detection by regularly detecting files. Although this method is not as good as FSnotify's real-time response performance, it may be more suitable in certain scenarios.

The following is a sample code:

package main

import (
    "log"
    "os"
    "time"
)

func main() {
    for {
        fileInfo, err := os.Stat("/path/to/file")
        if err != nil {
            log.Fatal(err)
        }

        // 检查文件的修改时间是否变化
        if fileInfo.ModTime() != lastModified {
            log.Println("File modified!")
            lastModified = fileInfo.ModTime()
        }

        // 等待一段时间后再次检测
        time.Sleep(1 * time.Second)
    }
}

In the above sample code, we detect whether the file has been modified by regularly reading the modification time of the file. Since the frequency of timing detection is relatively low, each time the modification time of a file is read, it must be judged whether it is the same as the last modification time to avoid repeating the same operation.

Although this method is not as good as FSnotify's real-time performance, in some scenarios that do not require high real-time performance, this method may be more concise and easier to understand.

2. File modification detection

Although we have been able to monitor files, there is no guarantee that the monitored files must have been modified. Therefore, we also need to compare the contents of the files to ensure the security and integrity of the files.

2.1 Calculate the MD5 value of the file

MD5 is a message digest algorithm that calculates input data of any length and obtains a 128-bit digest output. It has the following characteristics: irreversibility, uniqueness, non-conflict, etc. Therefore, we can determine whether the content of the file has changed by calculating the MD5 value of the file.

The following is a sample code:

package main

import (
    "crypto/md5"
    "encoding/hex"
    "io/ioutil"
    "log"
)

func main() {
    fileData, err := ioutil.ReadFile("/path/to/file")
    if err != nil {
        log.Fatal(err)
    }

    md5Sum := md5.Sum(fileData)
    md5SumString := hex.EncodeToString(md5Sum[:])
    log.Println("File MD5:", md5SumString)
}

In the above sample code, we read the contents of the file through the ioutil.ReadFile function, and then use the crypto/md5 library to calculate the MD5 value of the file, and Convert it into string form for output. Since the MD5 value is unique, we can compare the calculated MD5 value with the previous MD5 value to determine whether the content of the file has changed.

2.2 Real-time comparison of file content

In addition to calculating the MD5 value of the file, we can also compare the file content in real time to determine whether it has changed. The specific method is to read the content of the file and then compare it with the last read content.

The following is a sample code:

package main

import (
    "io/ioutil"
    "log"
)

var lastContent []byte

func main() {
    for {
        fileData, err := ioutil.ReadFile("/path/to/file")
        if err != nil {
            log.Fatal(err)
        }

        // 检查文件的内容是否变化
        if string(fileData) != string(lastContent) {
            log.Println("File modified!")
            lastContent = fileData
        }
    }
}

In the above sample code, we read the content of the file and then convert it into a string for comparison to determine whether the content of the file is changes occur. Since each time the file content is read, it needs to be compared with the last read content, so the real-time performance of this method will be lower, but it can still play a better role in some scenarios.

Summary

This article introduces how to implement file monitoring and modification detection in golang. For file monitoring, we can choose to use FSnotify or scheduled detection. For file modification detection, it can be achieved by calculating the MD5 value of the file or comparing the contents of the file in real time. In actual work, we can choose appropriate methods to implement based on specific needs to ensure the security and integrity of files.

The above is the detailed content of golang monitor file modification. For more information, please follow other related articles on the PHP Chinese website!