Skip to Content

Golang-Open-File

Posted on

很久之前遇到的问题了,清任务的时候这个write排第一,就写一下。

起因

要做一个临时的告警系统,又不想引入DB,也不想用bolt,不想引入额外的包,所以就傻了吧唧的自己用文件实现一个简单的DB。

(现在回想起来真的很没必要,老老实实用boltdb多好,简单快速搞得定)

每一条告警都有自己的hash,如果在文件中没有发现这条hash,则发送告警并将hash写入文件,如果发现了则跳过,目的是防止重复告警。

很简单的逻辑,但bug是,还是会发送重复的告警,也就是说,如果这条告警半小时之前发过了,那么半小时之后还会再发。(程序是用cron job跑的,每半小时跑一次,查询各个状态,如果指标低于阈值则告警)

经过

程序的某个部分是这样写的:

	fileName := "/tmp/alert-history.txt"
	f, err := os.OpenFile(fileName, os.O_RDWR, 0644)
	if err != os.ErrNotExist {
		panic(fmt.Sprintf("open file %s error: %s", fileName, err))
	} else {
		f, err = os.Create(fileName)
		if err != nil {
			panic(fmt.Sprintf("create file %s error: %s", fileName, err))
		}
	}
	defer f.Close()

	// detect alarm
	// ...

	// if alarm not in file
	// then send alarm and
	// write its hash to the file
	// ...
	// f.WriteString("alarm-hash\n")

乍一看没毛病吧,就是简简单单的读文件写文件嘛。

但是问题来了,这样的代码并不生效。就是虽然每次运行都会发送告警并写入文件,但是并没有完全达到检查去重的效果。说没有完全达到是因为,在两次运行周期内的告警能被过滤掉,但运行一段时间以后,发现某些曾经被告警过的消息也被发了出来,更具体一点是:

  1. 程序检测到警报A、B、C,并发送A、B、C,写入A、B、C到文件
  2. 程序再次检测到A、B,发现文件中已经有过A、B,则不再告警
  3. 程序检测到警报D,发现文件中没有D,告警D并写入文件
  4. 程序再次检测到A,发现文件中没有A,告警A并写入文件
  5. 程序再次检测到警报D,发现文件中没有D,告警D并写入文件
  6. 如此循环

很坑爹啊是不是!

结果

排查问题比较恶心,而且代码写的也完全没有问题,完全能够满足初始设计要求,也就是上述的 1,2 部分。然而诡异的地方是4,5,6。

已经忘记当时是怎么排查的了,但结果是一定的,没有append,也就是说,新写入的内容会覆盖曾经的内容,从0开始seek写。就现象而言,如果能发现4.5.6这个规律,也能很简单的定位到是D把A覆盖了(当时没有考虑到这一点,总结上面的4,5,6,是现编的),而且写入的时候是警报的哈希,毫无规律的MD5,也没有特别注意。

其实是一个很简单的问题,但如果没踩过的话,就容易被自己坑了。

我记得一开始的版本还不是用的os.OpenFile(),而是 os.Create(),这样就更坑自己了。

且看注释:

// Open opens the named file for reading. If successful, methods on
// the returned file can be used for reading; the associated file
// descriptor has mode O_RDONLY.
// If there is an error, it will be of type *PathError.
func Open(name string) (*File, error) {
	return OpenFile(name, O_RDONLY, 0)
}

// Create creates the named file with mode 0666 (before umask), truncating
// it if it already exists. If successful, methods on the returned
// File can be used for I/O; the associated file descriptor has mode
// O_RDWR.
// If there is an error, it will be of type *PathError.
func Create(name string) (*File, error) {
	return OpenFile(name, O_RDWR|O_CREATE|O_TRUNC, 0666)
}

// OpenFile is the generalized open call; most users will use Open
// or Create instead. It opens the named file with specified flag
// (O_RDONLY etc.) and perm (before umask), if applicable. If successful,
// methods on the returned File can be used for I/O.
// If there is an error, it will be of type *PathError.
func OpenFile(name string, flag int, perm FileMode) (*File, error) {
	testlog.Open(name)
	return openFileNolog(name, flag, perm)
}

os.Create的时候会truncate这个文件并从头写入!

感觉有时候太高级了也不好,容易漏掉很多细节。(其实就是自己不仔细,没认真看人家的注释!)

再copy一下其他的注释:

// Flags to OpenFile wrapping those of the underlying system. Not all
// flags may be implemented on a given system.
const (
	// Exactly one of O_RDONLY, O_WRONLY, or O_RDWR must be specified.
	O_RDONLY int = syscall.O_RDONLY // open the file read-only.
	O_WRONLY int = syscall.O_WRONLY // open the file write-only.
	O_RDWR   int = syscall.O_RDWR   // open the file read-write.
	// The remaining values may be or'ed in to control behavior.
	O_APPEND int = syscall.O_APPEND // append data to the file when writing.
	O_CREATE int = syscall.O_CREAT  // create a new file if none exists.
	O_EXCL   int = syscall.O_EXCL   // used with O_CREATE, file must not exist.
	O_SYNC   int = syscall.O_SYNC   // open for synchronous I/O.
	O_TRUNC  int = syscall.O_TRUNC  // truncate regular writable file when opened.
)

最后,修改之后的代码是这样的:

	fileName := "/tmp/alert-history.txt"
	f, err := os.OpenFile(fileName, os.O_RDWR|os.O_APPEND|os.O_CREATE, 0644)
	if err != nil {
		panic(fmt.Sprintf("open file %s error: %s", fileName, err))
	}
	defer f.Close()
	...
comments powered by Disqus