Question

我正在尝试解析一些日志文件，因为它们是在Go中编写的，但我不确定如何在不检查更改的情况下反复重读文件时如何实现此目的。

我希望能够读到EOF，等到写下一行并再次读到EOF等等。感觉有点像tail -f看起来。

Answer 1

我写了一个Go包 - github.com/ActiveState/tail - 正是这样做的。

t, err := tail.TailFile("/var/log/nginx.log", tail.Config{Follow: true})
for line := range t.Lines {
    fmt.Println(line.Text)
}

...

引用kostix的回答：

现实生活中的
文件可能会被截断，替换或重命名（因为这就像logrotate这样的工具应该这样做。）

如果文件被截断，它将自动重新打开。要支持重新打开重命名的文件（由于logrotate等），您可以设置Config.ReOpen，即：

t, err := tail.TailFile("/var/log/nginx.log", tail.Config{
    Follow: true,
    ReOpen: true})
for line := range t.Lines {
    fmt.Println(line.Text)
}

Config.ReOpen类似于tail -F（大写字母F）：

 -F      The -F option implies the -f option, but tail will also check to see if the file being followed has been
         renamed or rotated.  The file is closed and reopened when tail detects that the filename being read from
         has a new inode number.  The -F option is ignored if reading from standard input rather than a file.

Answer 2

您必须要查看文件以进行更改（使用特定于操作系统的子系统来完成此操作），或者定期将其轮询到see whether its modification time (and size) changed。在任何一种情况下，在读取另一块数据后，您会在检测到更改后记住文件偏移量和restore it before reading另一个块。

但请注意，这似乎只是在纸面上很简单：在现实生活中，文件可能会被截断，替换或重命名（因为这就像logrotate这样的工具应该这样做。）

有关此问题的更多讨论，请参阅this question。

Answer 3

我也有兴趣这样做，但还没有（还）有时间解决它。我遇到的一种方法是让“尾巴”完成繁重的工作。它可能会使您的工具特定于平台，但这可能没问题。基本思路是使用“os / exec”包中的Cmd来跟踪文件。您可以分叉一个相当于“tail --retry --follow = name prog.log”的进程，然后使用Cmd对象上的Stdout reader读取它的Stdout。

抱歉，我知道这只是一个草图，但也许它很有帮助。

Answer 4

一个简单的例子：

package main

import (
    "bufio"
    "fmt"
    "io"
    "os"
    "time"
)

func tail(filename string, out io.Writer) {
    f, err := os.Open(filename)
    if err != nil {
        panic(err)
    }
    defer f.Close()
    r := bufio.NewReader(f)
    info, err := f.Stat()
    if err != nil {
        panic(err)
    }
    oldSize := info.Size()
    for {
        for line, prefix, err := r.ReadLine(); err != io.EOF; line, prefix, err = r.ReadLine() {
            if prefix {
                fmt.Fprint(out, string(line))
            } else {
                fmt.Fprintln(out, string(line))
            }
        }
        pos, err := f.Seek(0, io.SeekCurrent)
        if err != nil {
            panic(err)
        }
        for {
            time.Sleep(time.Second)
            newinfo, err := f.Stat()
            if err != nil {
                panic(err)
            }
            newSize := newinfo.Size()
            if newSize != oldSize {
                if newSize < oldSize {
                    f.Seek(0, 0)
                } else {
                    f.Seek(pos, io.SeekStart)
                }
                r = bufio.NewReader(f)
                oldSize = newSize
                break
            }
        }
    }
}

func main() {
    tail("x.txt", os.Stdout)
}

Answer 5

有很多方法可以做到这一点。在现代基于POSIX的操作系统中，可以使用inotify接口来执行此操作。

可以使用此软件包：https://github.com/fsnotify/fsnotify

示例代码：

watcher, err := fsnotify.NewWatcher()
if err != nil {
    log.Fatal(err)
}

done := make(chan bool)

err = watcher.Add(fileName)
if err != nil {
    log.Fatal(err)
}
for {
    select {
    case event := <-watcher.Events:
        if event.Op&fsnotify.Write == fsnotify.Write {
            log.Println("modified file:", event.Name)

        }
}

希望这有帮助！

读取Go中更新的日志文件

5 个答案: