mirror of
https://github.com/beego/bee.git
synced 2024-11-25 20:10:55 +00:00
305 lines
9.6 KiB
Go
305 lines
9.6 KiB
Go
// Copyright 2010 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// +build linux
|
|
|
|
package fsnotify
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"strings"
|
|
"sync"
|
|
"syscall"
|
|
"unsafe"
|
|
)
|
|
|
|
const (
|
|
// Options for inotify_init() are not exported
|
|
// sys_IN_CLOEXEC uint32 = syscall.IN_CLOEXEC
|
|
// sys_IN_NONBLOCK uint32 = syscall.IN_NONBLOCK
|
|
|
|
// Options for AddWatch
|
|
sys_IN_DONT_FOLLOW uint32 = syscall.IN_DONT_FOLLOW
|
|
sys_IN_ONESHOT uint32 = syscall.IN_ONESHOT
|
|
sys_IN_ONLYDIR uint32 = syscall.IN_ONLYDIR
|
|
|
|
// The "sys_IN_MASK_ADD" option is not exported, as AddWatch
|
|
// adds it automatically, if there is already a watch for the given path
|
|
// sys_IN_MASK_ADD uint32 = syscall.IN_MASK_ADD
|
|
|
|
// Events
|
|
sys_IN_ACCESS uint32 = syscall.IN_ACCESS
|
|
sys_IN_ALL_EVENTS uint32 = syscall.IN_ALL_EVENTS
|
|
sys_IN_ATTRIB uint32 = syscall.IN_ATTRIB
|
|
sys_IN_CLOSE uint32 = syscall.IN_CLOSE
|
|
sys_IN_CLOSE_NOWRITE uint32 = syscall.IN_CLOSE_NOWRITE
|
|
sys_IN_CLOSE_WRITE uint32 = syscall.IN_CLOSE_WRITE
|
|
sys_IN_CREATE uint32 = syscall.IN_CREATE
|
|
sys_IN_DELETE uint32 = syscall.IN_DELETE
|
|
sys_IN_DELETE_SELF uint32 = syscall.IN_DELETE_SELF
|
|
sys_IN_MODIFY uint32 = syscall.IN_MODIFY
|
|
sys_IN_MOVE uint32 = syscall.IN_MOVE
|
|
sys_IN_MOVED_FROM uint32 = syscall.IN_MOVED_FROM
|
|
sys_IN_MOVED_TO uint32 = syscall.IN_MOVED_TO
|
|
sys_IN_MOVE_SELF uint32 = syscall.IN_MOVE_SELF
|
|
sys_IN_OPEN uint32 = syscall.IN_OPEN
|
|
|
|
sys_AGNOSTIC_EVENTS = sys_IN_MOVED_TO | sys_IN_MOVED_FROM | sys_IN_CREATE | sys_IN_ATTRIB | sys_IN_MODIFY | sys_IN_MOVE_SELF | sys_IN_DELETE | sys_IN_DELETE_SELF
|
|
|
|
// Special events
|
|
sys_IN_ISDIR uint32 = syscall.IN_ISDIR
|
|
sys_IN_IGNORED uint32 = syscall.IN_IGNORED
|
|
sys_IN_Q_OVERFLOW uint32 = syscall.IN_Q_OVERFLOW
|
|
sys_IN_UNMOUNT uint32 = syscall.IN_UNMOUNT
|
|
)
|
|
|
|
type FileEvent struct {
|
|
mask uint32 // Mask of events
|
|
cookie uint32 // Unique cookie associating related events (for rename(2))
|
|
Name string // File name (optional)
|
|
}
|
|
|
|
// IsCreate reports whether the FileEvent was triggered by a creation
|
|
func (e *FileEvent) IsCreate() bool {
|
|
return (e.mask&sys_IN_CREATE) == sys_IN_CREATE || (e.mask&sys_IN_MOVED_TO) == sys_IN_MOVED_TO
|
|
}
|
|
|
|
// IsDelete reports whether the FileEvent was triggered by a delete
|
|
func (e *FileEvent) IsDelete() bool {
|
|
return (e.mask&sys_IN_DELETE_SELF) == sys_IN_DELETE_SELF || (e.mask&sys_IN_DELETE) == sys_IN_DELETE
|
|
}
|
|
|
|
// IsModify reports whether the FileEvent was triggered by a file modification or attribute change
|
|
func (e *FileEvent) IsModify() bool {
|
|
return ((e.mask&sys_IN_MODIFY) == sys_IN_MODIFY || (e.mask&sys_IN_ATTRIB) == sys_IN_ATTRIB)
|
|
}
|
|
|
|
// IsRename reports whether the FileEvent was triggered by a change name
|
|
func (e *FileEvent) IsRename() bool {
|
|
return ((e.mask&sys_IN_MOVE_SELF) == sys_IN_MOVE_SELF || (e.mask&sys_IN_MOVED_FROM) == sys_IN_MOVED_FROM)
|
|
}
|
|
|
|
// IsAttrib reports whether the FileEvent was triggered by a change in the file metadata.
|
|
func (e *FileEvent) IsAttrib() bool {
|
|
return (e.mask & sys_IN_ATTRIB) == sys_IN_ATTRIB
|
|
}
|
|
|
|
type watch struct {
|
|
wd uint32 // Watch descriptor (as returned by the inotify_add_watch() syscall)
|
|
flags uint32 // inotify flags of this watch (see inotify(7) for the list of valid flags)
|
|
}
|
|
|
|
type Watcher struct {
|
|
mu sync.Mutex // Map access
|
|
fd int // File descriptor (as returned by the inotify_init() syscall)
|
|
watches map[string]*watch // Map of inotify watches (key: path)
|
|
fsnFlags map[string]uint32 // Map of watched files to flags used for filter
|
|
fsnmut sync.Mutex // Protects access to fsnFlags.
|
|
paths map[int]string // Map of watched paths (key: watch descriptor)
|
|
Error chan error // Errors are sent on this channel
|
|
internalEvent chan *FileEvent // Events are queued on this channel
|
|
Event chan *FileEvent // Events are returned on this channel
|
|
done chan bool // Channel for sending a "quit message" to the reader goroutine
|
|
isClosed bool // Set to true when Close() is first called
|
|
}
|
|
|
|
// NewWatcher creates and returns a new inotify instance using inotify_init(2)
|
|
func NewWatcher() (*Watcher, error) {
|
|
fd, errno := syscall.InotifyInit()
|
|
if fd == -1 {
|
|
return nil, os.NewSyscallError("inotify_init", errno)
|
|
}
|
|
w := &Watcher{
|
|
fd: fd,
|
|
watches: make(map[string]*watch),
|
|
fsnFlags: make(map[string]uint32),
|
|
paths: make(map[int]string),
|
|
internalEvent: make(chan *FileEvent),
|
|
Event: make(chan *FileEvent),
|
|
Error: make(chan error),
|
|
done: make(chan bool, 1),
|
|
}
|
|
|
|
go w.readEvents()
|
|
go w.purgeEvents()
|
|
return w, nil
|
|
}
|
|
|
|
// Close closes an inotify watcher instance
|
|
// It sends a message to the reader goroutine to quit and removes all watches
|
|
// associated with the inotify instance
|
|
func (w *Watcher) Close() error {
|
|
if w.isClosed {
|
|
return nil
|
|
}
|
|
w.isClosed = true
|
|
|
|
// Remove all watches
|
|
for path := range w.watches {
|
|
w.RemoveWatch(path)
|
|
}
|
|
|
|
// Send "quit" message to the reader goroutine
|
|
w.done <- true
|
|
|
|
return nil
|
|
}
|
|
|
|
// AddWatch adds path to the watched file set.
|
|
// The flags are interpreted as described in inotify_add_watch(2).
|
|
func (w *Watcher) addWatch(path string, flags uint32) error {
|
|
if w.isClosed {
|
|
return errors.New("inotify instance already closed")
|
|
}
|
|
|
|
w.mu.Lock()
|
|
watchEntry, found := w.watches[path]
|
|
w.mu.Unlock()
|
|
if found {
|
|
watchEntry.flags |= flags
|
|
flags |= syscall.IN_MASK_ADD
|
|
}
|
|
wd, errno := syscall.InotifyAddWatch(w.fd, path, flags)
|
|
if wd == -1 {
|
|
return errno
|
|
}
|
|
|
|
w.mu.Lock()
|
|
w.watches[path] = &watch{wd: uint32(wd), flags: flags}
|
|
w.paths[wd] = path
|
|
w.mu.Unlock()
|
|
|
|
return nil
|
|
}
|
|
|
|
// Watch adds path to the watched file set, watching all events.
|
|
func (w *Watcher) watch(path string) error {
|
|
return w.addWatch(path, sys_AGNOSTIC_EVENTS)
|
|
}
|
|
|
|
// RemoveWatch removes path from the watched file set.
|
|
func (w *Watcher) removeWatch(path string) error {
|
|
w.mu.Lock()
|
|
defer w.mu.Unlock()
|
|
watch, ok := w.watches[path]
|
|
if !ok {
|
|
return errors.New(fmt.Sprintf("can't remove non-existent inotify watch for: %s", path))
|
|
}
|
|
success, errno := syscall.InotifyRmWatch(w.fd, watch.wd)
|
|
if success == -1 {
|
|
return os.NewSyscallError("inotify_rm_watch", errno)
|
|
}
|
|
delete(w.watches, path)
|
|
return nil
|
|
}
|
|
|
|
// readEvents reads from the inotify file descriptor, converts the
|
|
// received events into Event objects and sends them via the Event channel
|
|
func (w *Watcher) readEvents() {
|
|
var (
|
|
buf [syscall.SizeofInotifyEvent * 4096]byte // Buffer for a maximum of 4096 raw events
|
|
n int // Number of bytes read with read()
|
|
errno error // Syscall errno
|
|
)
|
|
|
|
for {
|
|
// See if there is a message on the "done" channel
|
|
select {
|
|
case <-w.done:
|
|
syscall.Close(w.fd)
|
|
close(w.internalEvent)
|
|
close(w.Error)
|
|
return
|
|
default:
|
|
}
|
|
|
|
n, errno = syscall.Read(w.fd, buf[:])
|
|
|
|
// If EOF is received
|
|
if n == 0 {
|
|
syscall.Close(w.fd)
|
|
close(w.internalEvent)
|
|
close(w.Error)
|
|
return
|
|
}
|
|
|
|
if n < 0 {
|
|
w.Error <- os.NewSyscallError("read", errno)
|
|
continue
|
|
}
|
|
if n < syscall.SizeofInotifyEvent {
|
|
w.Error <- errors.New("inotify: short read in readEvents()")
|
|
continue
|
|
}
|
|
|
|
var offset uint32 = 0
|
|
// We don't know how many events we just read into the buffer
|
|
// While the offset points to at least one whole event...
|
|
for offset <= uint32(n-syscall.SizeofInotifyEvent) {
|
|
// Point "raw" to the event in the buffer
|
|
raw := (*syscall.InotifyEvent)(unsafe.Pointer(&buf[offset]))
|
|
event := new(FileEvent)
|
|
event.mask = uint32(raw.Mask)
|
|
event.cookie = uint32(raw.Cookie)
|
|
nameLen := uint32(raw.Len)
|
|
// If the event happened to the watched directory or the watched file, the kernel
|
|
// doesn't append the filename to the event, but we would like to always fill the
|
|
// the "Name" field with a valid filename. We retrieve the path of the watch from
|
|
// the "paths" map.
|
|
w.mu.Lock()
|
|
event.Name = w.paths[int(raw.Wd)]
|
|
w.mu.Unlock()
|
|
watchedName := event.Name
|
|
if nameLen > 0 {
|
|
// Point "bytes" at the first byte of the filename
|
|
bytes := (*[syscall.PathMax]byte)(unsafe.Pointer(&buf[offset+syscall.SizeofInotifyEvent]))
|
|
// The filename is padded with NUL bytes. TrimRight() gets rid of those.
|
|
event.Name += "/" + strings.TrimRight(string(bytes[0:nameLen]), "\000")
|
|
}
|
|
|
|
// Send the events that are not ignored on the events channel
|
|
if !event.ignoreLinux() {
|
|
// Setup FSNotify flags (inherit from directory watch)
|
|
w.fsnmut.Lock()
|
|
if _, fsnFound := w.fsnFlags[event.Name]; !fsnFound {
|
|
if fsnFlags, watchFound := w.fsnFlags[watchedName]; watchFound {
|
|
w.fsnFlags[event.Name] = fsnFlags
|
|
} else {
|
|
w.fsnFlags[event.Name] = FSN_ALL
|
|
}
|
|
}
|
|
w.fsnmut.Unlock()
|
|
|
|
w.internalEvent <- event
|
|
}
|
|
|
|
// Move to the next event in the buffer
|
|
offset += syscall.SizeofInotifyEvent + nameLen
|
|
}
|
|
}
|
|
}
|
|
|
|
// Certain types of events can be "ignored" and not sent over the Event
|
|
// channel. Such as events marked ignore by the kernel, or MODIFY events
|
|
// against files that do not exist.
|
|
func (e *FileEvent) ignoreLinux() bool {
|
|
// Ignore anything the inotify API says to ignore
|
|
if e.mask&sys_IN_IGNORED == sys_IN_IGNORED {
|
|
return true
|
|
}
|
|
|
|
// If the event is not a DELETE or RENAME, the file must exist.
|
|
// Otherwise the event is ignored.
|
|
// *Note*: this was put in place because it was seen that a MODIFY
|
|
// event was sent after the DELETE. This ignores that MODIFY and
|
|
// assumes a DELETE will come or has come if the file doesn't exist.
|
|
if !(e.IsDelete() || e.IsRename()) {
|
|
_, statErr := os.Lstat(e.Name)
|
|
return os.IsNotExist(statErr)
|
|
}
|
|
return false
|
|
}
|