pax_global_header00006660000000000000000000000064143600267730014522gustar00rootroot0000000000000052 comment=bc7f94f1368291f6a83dcace2eea2292d4b00a8c notify-0.9.3/000077500000000000000000000000001436002677300130435ustar00rootroot00000000000000notify-0.9.3/.gitignore000066400000000000000000000017671436002677300150460ustar00rootroot00000000000000# Created by https://www.gitignore.io ### OSX ### .DS_Store .AppleDouble .LSOverride # Icon must end with two \r Icon # Thumbnails ._* # Files that might appear on external disk .Spotlight-V100 .Trashes # Directories potentially created on remote AFP share .AppleDB .AppleDesktop Network Trash Folder Temporary Items .apdisk ### Windows ### # Windows image file caches Thumbs.db ehthumbs.db # Folder config file Desktop.ini # Recycle Bin used on file shares $RECYCLE.BIN/ # Windows Installer files *.cab *.msi *.msm *.msp # Windows shortcuts *.lnk ### Linux ### *~ # KDE directory preferences .directory ### Go ### # Compiled Object files, Static and Dynamic libs (Shared Objects) *.o *.a *.so # Folders _obj _test # Architecture specific extensions/prefixes *.[568vq] [568vq].out *.cgo1.go *.cgo2.c _cgo_defun.c _cgo_gotypes.go _cgo_export.* _testmain.go *.exe *.test *.prof ### vim ### [._]*.s[a-w][a-z] [._]s[a-w][a-z] *.un~ Session.vim .netrwhist *~ ### JetBrains files ### .idea/ *.imlnotify-0.9.3/.travis.yml000066400000000000000000000006501436002677300151550ustar00rootroot00000000000000language: go go: - 1.10.x - 1.11.x - master os: - linux - osx matrix: include: - os: osx go: 1.7.5 env: - GOFLAGS="-tags kqueue" allow_failures: - go: tip env: global: - GOBIN=$HOME/bin - PATH=$HOME/bin:$PATH install: - go get -t -v ./... script: - "(go version | grep -q 1.4) || go tool vet -all ." - go install $GOFLAGS ./... - go test -v -timeout 60s -race $GOFLAGS ./... notify-0.9.3/AUTHORS000066400000000000000000000004561436002677300141200ustar00rootroot00000000000000# List of individuals who contributed to the Notify package. # # The up-to-date list of the authors one may obtain with: # # ~ $ git shortlog -es | cut -f2 | rev | uniq -f1 | rev # Pawel Blaszczyk Pawel Knap Rafal Jeczalik notify-0.9.3/LICENSE000066400000000000000000000021021436002677300140430ustar00rootroot00000000000000The MIT License (MIT) Copyright (c) 2014-2015 The Notify Authors Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. notify-0.9.3/README.md000066400000000000000000000023651436002677300143300ustar00rootroot00000000000000notify [![GoDoc](https://godoc.org/github.com/rjeczalik/notify?status.svg)](https://godoc.org/github.com/rjeczalik/notify) [![Build Status](https://img.shields.io/travis/rjeczalik/notify/master.svg)](https://travis-ci.org/rjeczalik/notify "inotify + FSEvents + kqueue") [![Build status](https://img.shields.io/appveyor/ci/rjeczalik/notify-246.svg)](https://ci.appveyor.com/project/rjeczalik/notify-246 "ReadDirectoryChangesW") [![Coverage Status](https://img.shields.io/coveralls/rjeczalik/notify/master.svg)](https://coveralls.io/r/rjeczalik/notify?branch=master) ====== Filesystem event notification library on steroids. (under active development) *Documentation* [godoc.org/github.com/rjeczalik/notify](https://godoc.org/github.com/rjeczalik/notify) *Installation* ``` ~ $ go get -u github.com/rjeczalik/notify ``` *Projects using notify* - [github.com/rjeczalik/cmd/notify](https://godoc.org/github.com/rjeczalik/cmd/notify) - [github.com/cortesi/devd](https://github.com/cortesi/devd) - [github.com/cortesi/modd](https://github.com/cortesi/modd) - [github.com/syncthing/syncthing](https://github.com/syncthing/syncthing) - [github.com/OrlovEvgeny/TinyJPG](https://github.com/OrlovEvgeny/TinyJPG) - [github.com/mitranim/gow](https://github.com/mitranim/gow) notify-0.9.3/appveyor.yml000066400000000000000000000010261436002677300154320ustar00rootroot00000000000000version: "{build}" os: Windows Server 2012 R2 clone_folder: c:\projects\src\github.com\rjeczalik\notify environment: PATH: c:\projects\bin;%PATH% GOPATH: c:\projects NOTIFY_TIMEOUT: 10s GOVERSION: 1.10.3 install: - rmdir c:\go /s /q - appveyor DownloadFile https://storage.googleapis.com/golang/go%GOVERSION%.windows-amd64.zip - 7z x go%GOVERSION%.windows-amd64.zip -y -oC:\ > NUL - cd %APPVEYOR_BUILD_FOLDER% - go version build_script: - go build ./... - go test -v -timeout 120s -race ./... test: off deploy: off notify-0.9.3/debug.go000066400000000000000000000024611436002677300144630ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. package notify import ( "log" "os" "runtime" "strings" ) var dbgprint func(...interface{}) var dbgprintf func(string, ...interface{}) var dbgcallstack func(max int) []string func init() { if _, ok := os.LookupEnv("NOTIFY_DEBUG"); ok || debugTag { log.SetOutput(os.Stdout) log.SetFlags(log.Ldate | log.Ltime | log.Lmicroseconds) dbgprint = func(v ...interface{}) { v = append([]interface{}{"[D] "}, v...) log.Println(v...) } dbgprintf = func(format string, v ...interface{}) { format = "[D] " + format log.Printf(format, v...) } dbgcallstack = func(max int) []string { pc, stack := make([]uintptr, max), make([]string, 0, max) runtime.Callers(2, pc) for _, pc := range pc { if f := runtime.FuncForPC(pc); f != nil { fname := f.Name() idx := strings.LastIndex(fname, string(os.PathSeparator)) if idx != -1 { stack = append(stack, fname[idx+1:]) } else { stack = append(stack, fname) } } } return stack } return } dbgprint = func(v ...interface{}) {} dbgprintf = func(format string, v ...interface{}) {} dbgcallstack = func(max int) []string { return nil } } notify-0.9.3/debug_debug.go000066400000000000000000000003571436002677300156330ustar00rootroot00000000000000// Copyright (c) 2014-2018 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build debug // +build debug package notify var debugTag = true notify-0.9.3/debug_nodebug.go000066400000000000000000000003621436002677300161640ustar00rootroot00000000000000// Copyright (c) 2014-2018 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build !debug // +build !debug package notify var debugTag = false notify-0.9.3/doc.go000066400000000000000000000040701436002677300141400ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. // Package notify implements access to filesystem events. // // Notify is a high-level abstraction over filesystem watchers like inotify, // kqueue, FSEvents, FEN or ReadDirectoryChangesW. Watcher implementations are // split into two groups: ones that natively support recursive notifications // (FSEvents and ReadDirectoryChangesW) and ones that do not (inotify, kqueue, FEN). // For more details see watcher and recursiveWatcher interfaces in watcher.go // source file. // // On top of filesystem watchers notify maintains a watchpoint tree, which provides // a strategy for creating and closing filesystem watches and dispatching filesystem // events to user channels. // // An event set is just an event list joint using bitwise OR operator // into a single event value. // Both the platform-independent (see Constants) and specific events can be used. // Refer to the event_*.go source files for information about the available // events. // // A filesystem watch or just a watch is platform-specific entity which represents // a single path registered for notifications for specific event set. Setting a watch // means using platform-specific API calls for creating / initializing said watch. // For each watcher the API call is: // // - FSEvents: FSEventStreamCreate // - inotify: notify_add_watch // - kqueue: kevent // - ReadDirectoryChangesW: CreateFile+ReadDirectoryChangesW // - FEN: port_get // // To rewatch means to either shrink or expand an event set that was previously // registered during watch operation for particular filesystem watch. // // A watchpoint is a list of user channel and event set pairs for particular // path (watchpoint tree's node). A single watchpoint can contain multiple // different user channels registered to listen for one or more events. A single // user channel can be registered in one or more watchpoints, recursive and // non-recursive ones as well. package notify notify-0.9.3/event.go000066400000000000000000000107701436002677300145200ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. package notify import ( "fmt" "strings" ) // Event represents the type of filesystem action. // // Number of available event values is dependent on the target system or the // watcher implmenetation used (e.g. it's possible to use either kqueue or // FSEvents on Darwin). // // Please consult documentation for your target platform to see list of all // available events. type Event uint32 // Create, Remove, Write and Rename are the only event values guaranteed to be // present on all platforms. const ( Create = osSpecificCreate Remove = osSpecificRemove Write = osSpecificWrite Rename = osSpecificRename // All is handful alias for all platform-independent event values. All = Create | Remove | Write | Rename ) const internal = recursive | omit // String implements fmt.Stringer interface. func (e Event) String() string { var s []string for _, strmap := range []map[Event]string{estr, osestr} { for ev, str := range strmap { if e&ev == ev { s = append(s, str) } } } return strings.Join(s, "|") } // EventInfo describes an event reported by the underlying filesystem notification // subsystem. // // It always describes single event, even if the OS reported a coalesced action. // Reported path is absolute and clean. // // For non-recursive watchpoints its base is always equal to the path passed // to corresponding Watch call. // // The value of Sys if system-dependent and can be nil. // // # Sys // // Under Darwin (FSEvents) Sys() always returns a non-nil *notify.FSEvent value, // which is defined as: // // type FSEvent struct { // Path string // real path of the file or directory // ID uint64 // ID of the event (FSEventStreamEventId) // Flags uint32 // joint FSEvents* flags (FSEventStreamEventFlags) // } // // For possible values of Flags see Darwin godoc for notify or FSEvents // documentation for FSEventStreamEventFlags constants: // // https://developer.apple.com/library/mac/documentation/Darwin/Reference/FSEvents_Ref/index.html#//apple_ref/doc/constant_group/FSEventStreamEventFlags // // Under Linux (inotify) Sys() always returns a non-nil *unix.InotifyEvent // value, defined as: // // type InotifyEvent struct { // Wd int32 // Watch descriptor // Mask uint32 // Mask describing event // Cookie uint32 // Unique cookie associating related events (for rename(2)) // Len uint32 // Size of name field // Name [0]uint8 // Optional null-terminated name // } // // More information about inotify masks and the usage of inotify_event structure // can be found at: // // http://man7.org/linux/man-pages/man7/inotify.7.html // // Under Darwin, DragonFlyBSD, FreeBSD, NetBSD, OpenBSD (kqueue) Sys() always // returns a non-nil *notify.Kevent value, which is defined as: // // type Kevent struct { // Kevent *syscall.Kevent_t // Kevent is a kqueue specific structure // FI os.FileInfo // FI describes file/dir // } // // More information about syscall.Kevent_t can be found at: // // https://www.freebsd.org/cgi/man.cgi?query=kqueue // // Under Windows (ReadDirectoryChangesW) Sys() always returns nil. The documentation // of watcher's WinAPI function can be found at: // // https://msdn.microsoft.com/en-us/library/windows/desktop/aa365465%28v=vs.85%29.aspx type EventInfo interface { Event() Event // event value for the filesystem action Path() string // real path of the file or directory Sys() interface{} // underlying data source (can return nil) } type isDirer interface { isDir() (bool, error) } var _ fmt.Stringer = (*event)(nil) var _ isDirer = (*event)(nil) // String implements fmt.Stringer interface. func (e *event) String() string { return e.Event().String() + `: "` + e.Path() + `"` } var estr = map[Event]string{ Create: "notify.Create", Remove: "notify.Remove", Write: "notify.Write", Rename: "notify.Rename", // Display name for recursive event is added only for debugging // purposes. It's an internal event after all and won't be exposed to the // user. Having Recursive event printable is helpful, e.g. for reading // testing failure messages: // // --- FAIL: TestWatchpoint (0.00 seconds) // watchpoint_test.go:64: want diff=[notify.Remove notify.Create|notify.Remove]; // got [notify.Remove notify.Remove|notify.Create] (i=1) // // Yup, here the diff have Recursive event inside. Go figure. recursive: "recursive", omit: "omit", } notify-0.9.3/event_fen.go000066400000000000000000000041201436002677300153400ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build solaris || illumos // +build solaris illumos package notify const ( osSpecificCreate Event = 0x00000100 << iota osSpecificRemove osSpecificWrite osSpecificRename // internal // recursive is used to distinguish recursive eventsets from non-recursive ones recursive // omit is used for dispatching internal events; only those events are sent // for which both the event and the watchpoint has omit in theirs event sets. omit ) const ( // FileAccess is an event reported when monitored file/directory was accessed. FileAccess = fileAccess // FileModified is an event reported when monitored file/directory was modified. FileModified = fileModified // FileAttrib is an event reported when monitored file/directory's ATTRIB // was changed. FileAttrib = fileAttrib // FileDelete is an event reported when monitored file/directory was deleted. FileDelete = fileDelete // FileRenameTo to is an event reported when monitored file/directory was renamed. FileRenameTo = fileRenameTo // FileRenameFrom is an event reported when monitored file/directory was renamed. FileRenameFrom = fileRenameFrom // FileTrunc is an event reported when monitored file/directory was truncated. FileTrunc = fileTrunc // FileNoFollow is an flag to indicate not to follow symbolic links. FileNoFollow = fileNoFollow // Unmounted is an event reported when monitored filesystem was unmounted. Unmounted = unmounted // MountedOver is an event reported when monitored file/directory was mounted on. MountedOver = mountedOver ) var osestr = map[Event]string{ FileAccess: "notify.FileAccess", FileModified: "notify.FileModified", FileAttrib: "notify.FileAttrib", FileDelete: "notify.FileDelete", FileRenameTo: "notify.FileRenameTo", FileRenameFrom: "notify.FileRenameFrom", FileTrunc: "notify.FileTrunc", FileNoFollow: "notify.FileNoFollow", Unmounted: "notify.Unmounted", MountedOver: "notify.MountedOver", } notify-0.9.3/event_fsevents.go000066400000000000000000000053071436002677300164350ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build darwin && !kqueue && cgo // +build darwin,!kqueue,cgo package notify const ( osSpecificCreate = Event(FSEventsCreated) osSpecificRemove = Event(FSEventsRemoved) osSpecificWrite = Event(FSEventsModified) osSpecificRename = Event(FSEventsRenamed) // internal = Event(0x100000) // recursive is used to distinguish recursive eventsets from non-recursive ones recursive = Event(0x200000) // omit is used for dispatching internal events; only those events are sent // for which both the event and the watchpoint has omit in theirs event sets. omit = Event(0x400000) ) // FSEvents specific event values. const ( FSEventsMustScanSubDirs Event = 0x00001 FSEventsUserDropped = 0x00002 FSEventsKernelDropped = 0x00004 FSEventsEventIdsWrapped = 0x00008 FSEventsHistoryDone = 0x00010 FSEventsRootChanged = 0x00020 FSEventsMount = 0x00040 FSEventsUnmount = 0x00080 FSEventsCreated = 0x00100 FSEventsRemoved = 0x00200 FSEventsInodeMetaMod = 0x00400 FSEventsRenamed = 0x00800 FSEventsModified = 0x01000 FSEventsFinderInfoMod = 0x02000 FSEventsChangeOwner = 0x04000 FSEventsXattrMod = 0x08000 FSEventsIsFile = 0x10000 FSEventsIsDir = 0x20000 FSEventsIsSymlink = 0x40000 ) var osestr = map[Event]string{ FSEventsMustScanSubDirs: "notify.FSEventsMustScanSubDirs", FSEventsUserDropped: "notify.FSEventsUserDropped", FSEventsKernelDropped: "notify.FSEventsKernelDropped", FSEventsEventIdsWrapped: "notify.FSEventsEventIdsWrapped", FSEventsHistoryDone: "notify.FSEventsHistoryDone", FSEventsRootChanged: "notify.FSEventsRootChanged", FSEventsMount: "notify.FSEventsMount", FSEventsUnmount: "notify.FSEventsUnmount", FSEventsInodeMetaMod: "notify.FSEventsInodeMetaMod", FSEventsFinderInfoMod: "notify.FSEventsFinderInfoMod", FSEventsChangeOwner: "notify.FSEventsChangeOwner", FSEventsXattrMod: "notify.FSEventsXattrMod", FSEventsIsFile: "notify.FSEventsIsFile", FSEventsIsDir: "notify.FSEventsIsDir", FSEventsIsSymlink: "notify.FSEventsIsSymlink", } type event struct { fse FSEvent event Event } func (ei *event) Event() Event { return ei.event } func (ei *event) Path() string { return ei.fse.Path } func (ei *event) Sys() interface{} { return &ei.fse } func (ei *event) isDir() (bool, error) { return ei.fse.Flags&FSEventsIsDir != 0, nil } notify-0.9.3/event_inotify.go000066400000000000000000000052671436002677300162660ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build linux // +build linux package notify import "golang.org/x/sys/unix" // Platform independent event values. const ( osSpecificCreate Event = 0x100000 << iota osSpecificRemove osSpecificWrite osSpecificRename // internal // recursive is used to distinguish recursive eventsets from non-recursive ones recursive // omit is used for dispatching internal events; only those events are sent // for which both the event and the watchpoint has omit in theirs event sets. omit ) // Inotify specific masks are legal, implemented events that are guaranteed to // work with notify package on linux-based systems. const ( InAccess = Event(unix.IN_ACCESS) // File was accessed InModify = Event(unix.IN_MODIFY) // File was modified InAttrib = Event(unix.IN_ATTRIB) // Metadata changed InCloseWrite = Event(unix.IN_CLOSE_WRITE) // Writtable file was closed InCloseNowrite = Event(unix.IN_CLOSE_NOWRITE) // Unwrittable file closed InOpen = Event(unix.IN_OPEN) // File was opened InMovedFrom = Event(unix.IN_MOVED_FROM) // File was moved from X InMovedTo = Event(unix.IN_MOVED_TO) // File was moved to Y InCreate = Event(unix.IN_CREATE) // Subfile was created InDelete = Event(unix.IN_DELETE) // Subfile was deleted InDeleteSelf = Event(unix.IN_DELETE_SELF) // Self was deleted InMoveSelf = Event(unix.IN_MOVE_SELF) // Self was moved ) var osestr = map[Event]string{ InAccess: "notify.InAccess", InModify: "notify.InModify", InAttrib: "notify.InAttrib", InCloseWrite: "notify.InCloseWrite", InCloseNowrite: "notify.InCloseNowrite", InOpen: "notify.InOpen", InMovedFrom: "notify.InMovedFrom", InMovedTo: "notify.InMovedTo", InCreate: "notify.InCreate", InDelete: "notify.InDelete", InDeleteSelf: "notify.InDeleteSelf", InMoveSelf: "notify.InMoveSelf", } // Inotify behavior events are not **currently** supported by notify package. const ( inDontFollow = Event(unix.IN_DONT_FOLLOW) inExclUnlink = Event(unix.IN_EXCL_UNLINK) inMaskAdd = Event(unix.IN_MASK_ADD) inOneshot = Event(unix.IN_ONESHOT) inOnlydir = Event(unix.IN_ONLYDIR) ) type event struct { sys unix.InotifyEvent path string event Event } func (e *event) Event() Event { return e.event } func (e *event) Path() string { return e.path } func (e *event) Sys() interface{} { return &e.sys } func (e *event) isDir() (bool, error) { return e.sys.Mask&unix.IN_ISDIR != 0, nil } notify-0.9.3/event_kqueue.go000066400000000000000000000042211436002677300160710ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build (darwin && kqueue) || (darwin && !cgo) || dragonfly || freebsd || netbsd || openbsd // +build darwin,kqueue darwin,!cgo dragonfly freebsd netbsd openbsd package notify import "syscall" // TODO(pblaszczyk): ensure in runtime notify built-in event values do not // overlap with platform-defined ones. // Platform independent event values. const ( osSpecificCreate Event = 0x0100 << iota osSpecificRemove osSpecificWrite osSpecificRename // internal // recursive is used to distinguish recursive eventsets from non-recursive ones recursive // omit is used for dispatching internal events; only those events are sent // for which both the event and the watchpoint has omit in theirs event sets. omit ) const ( // NoteDelete is an event reported when the unlink() system call was called // on the file referenced by the descriptor. NoteDelete = Event(syscall.NOTE_DELETE) // NoteWrite is an event reported when a write occurred on the file // referenced by the descriptor. NoteWrite = Event(syscall.NOTE_WRITE) // NoteExtend is an event reported when the file referenced by the // descriptor was extended. NoteExtend = Event(syscall.NOTE_EXTEND) // NoteAttrib is an event reported when the file referenced // by the descriptor had its attributes changed. NoteAttrib = Event(syscall.NOTE_ATTRIB) // NoteLink is an event reported when the link count on the file changed. NoteLink = Event(syscall.NOTE_LINK) // NoteRename is an event reported when the file referenced // by the descriptor was renamed. NoteRename = Event(syscall.NOTE_RENAME) // NoteRevoke is an event reported when access to the file was revoked via // revoke(2) or the underlying file system was unmounted. NoteRevoke = Event(syscall.NOTE_REVOKE) ) var osestr = map[Event]string{ NoteDelete: "notify.NoteDelete", NoteWrite: "notify.NoteWrite", NoteExtend: "notify.NoteExtend", NoteAttrib: "notify.NoteAttrib", NoteLink: "notify.NoteLink", NoteRename: "notify.NoteRename", NoteRevoke: "notify.NoteRevoke", } notify-0.9.3/event_readdcw.go000066400000000000000000000104221436002677300162030ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build windows // +build windows package notify import ( "os" "path/filepath" "syscall" ) // Platform independent event values. const ( osSpecificCreate Event = 1 << (20 + iota) osSpecificRemove osSpecificWrite osSpecificRename // recursive is used to distinguish recursive eventsets from non-recursive ones recursive // omit is used for dispatching internal events; only those events are sent // for which both the event and the watchpoint has omit in theirs event sets. omit // dirmarker TODO(pknap) dirmarker ) // ReadDirectoryChangesW filters // On Windows the following events can be passed to Watch. A different set of // events (see actions below) are received on the channel passed to Watch. // For more information refer to // https://msdn.microsoft.com/en-us/library/windows/desktop/aa365465(v=vs.85).aspx const ( FileNotifyChangeFileName = Event(syscall.FILE_NOTIFY_CHANGE_FILE_NAME) FileNotifyChangeDirName = Event(syscall.FILE_NOTIFY_CHANGE_DIR_NAME) FileNotifyChangeAttributes = Event(syscall.FILE_NOTIFY_CHANGE_ATTRIBUTES) FileNotifyChangeSize = Event(syscall.FILE_NOTIFY_CHANGE_SIZE) FileNotifyChangeLastWrite = Event(syscall.FILE_NOTIFY_CHANGE_LAST_WRITE) FileNotifyChangeLastAccess = Event(syscall.FILE_NOTIFY_CHANGE_LAST_ACCESS) FileNotifyChangeCreation = Event(syscall.FILE_NOTIFY_CHANGE_CREATION) FileNotifyChangeSecurity = Event(syscallFileNotifyChangeSecurity) ) const ( fileNotifyChangeAll = 0x17f // logical sum of all FileNotifyChange* events. fileNotifyChangeModified = fileNotifyChangeAll &^ (FileNotifyChangeFileName | FileNotifyChangeDirName) ) // according to: http://msdn.microsoft.com/en-us/library/windows/desktop/aa365465(v=vs.85).aspx // this flag should be declared in: http://golang.org/src/pkg/syscall/ztypes_windows.go const syscallFileNotifyChangeSecurity = 0x00000100 // ReadDirectoryChangesW actions // The following events are returned on the channel passed to Watch, but cannot // be passed to Watch itself (see filters above). You can find a table showing // the relation between actions and filteres at // https://github.com/rjeczalik/notify/issues/10#issuecomment-66179535 // The msdn documentation on actions is part of // https://msdn.microsoft.com/en-us/library/windows/desktop/aa364391(v=vs.85).aspx const ( FileActionAdded = Event(syscall.FILE_ACTION_ADDED) << 12 FileActionRemoved = Event(syscall.FILE_ACTION_REMOVED) << 12 FileActionModified = Event(syscall.FILE_ACTION_MODIFIED) << 14 FileActionRenamedOldName = Event(syscall.FILE_ACTION_RENAMED_OLD_NAME) << 15 FileActionRenamedNewName = Event(syscall.FILE_ACTION_RENAMED_NEW_NAME) << 16 ) const fileActionAll = 0x7f000 // logical sum of all FileAction* events. var osestr = map[Event]string{ FileNotifyChangeFileName: "notify.FileNotifyChangeFileName", FileNotifyChangeDirName: "notify.FileNotifyChangeDirName", FileNotifyChangeAttributes: "notify.FileNotifyChangeAttributes", FileNotifyChangeSize: "notify.FileNotifyChangeSize", FileNotifyChangeLastWrite: "notify.FileNotifyChangeLastWrite", FileNotifyChangeLastAccess: "notify.FileNotifyChangeLastAccess", FileNotifyChangeCreation: "notify.FileNotifyChangeCreation", FileNotifyChangeSecurity: "notify.FileNotifyChangeSecurity", FileActionAdded: "notify.FileActionAdded", FileActionRemoved: "notify.FileActionRemoved", FileActionModified: "notify.FileActionModified", FileActionRenamedOldName: "notify.FileActionRenamedOldName", FileActionRenamedNewName: "notify.FileActionRenamedNewName", } const ( fTypeUnknown uint8 = iota fTypeFile fTypeDirectory ) // TODO(ppknap) : doc. type event struct { pathw []uint16 name string ftype uint8 action uint32 filter uint32 e Event } func (e *event) Event() Event { return e.e } func (e *event) Path() string { return filepath.Join(syscall.UTF16ToString(e.pathw), e.name) } func (e *event) Sys() interface{} { return e.ftype } func (e *event) isDir() (bool, error) { if e.ftype != fTypeUnknown { return e.ftype == fTypeDirectory, nil } fi, err := os.Stat(e.Path()) if err != nil { return false, err } return fi.IsDir(), nil } notify-0.9.3/event_stub.go000066400000000000000000000020671436002677300155550ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build !darwin && !linux && !freebsd && !dragonfly && !netbsd && !openbsd && !windows && !kqueue && !solaris && !illumos // +build !darwin,!linux,!freebsd,!dragonfly,!netbsd,!openbsd,!windows,!kqueue,!solaris,!illumos package notify // Platform independent event values. const ( osSpecificCreate Event = 1 << iota osSpecificRemove osSpecificWrite osSpecificRename // internal // recursive is used to distinguish recursive eventsets from non-recursive ones recursive // omit is used for dispatching internal events; only those events are sent // for which both the event and the watchpoint has omit in theirs event sets. omit ) var osestr = map[Event]string{} type event struct{} func (e *event) Event() (_ Event) { return } func (e *event) Path() (_ string) { return } func (e *event) Sys() (_ interface{}) { return } func (e *event) isDir() (_ bool, _ error) { return } notify-0.9.3/event_test.go000066400000000000000000000016071436002677300155560ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. package notify import ( "sort" "strings" "testing" ) // S is a workaround for random event strings concatenation order. func s(s string) string { z := strings.Split(s, "|") sort.StringSlice(z).Sort() return strings.Join(z, "|") } // This test is not safe to run in parallel with others. func TestEventString(t *testing.T) { cases := map[Event]string{ Create: "notify.Create", Create | Remove: "notify.Create|notify.Remove", Create | Remove | Write: "notify.Create|notify.Remove|notify.Write", Create | Write | Rename: "notify.Create|notify.Rename|notify.Write", } for e, str := range cases { if s := s(e.String()); s != str { t.Errorf("want s=%s; got %s (e=%#x)", str, s, e) } } } notify-0.9.3/event_trigger.go000066400000000000000000000012221436002677300162330ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build (darwin && kqueue) || (darwin && !cgo) || dragonfly || freebsd || netbsd || openbsd || solaris || illumos // +build darwin,kqueue darwin,!cgo dragonfly freebsd netbsd openbsd solaris illumos package notify type event struct { p string e Event d bool pe interface{} } func (e *event) Event() Event { return e.e } func (e *event) Path() string { return e.p } func (e *event) Sys() interface{} { return e.pe } func (e *event) isDir() (bool, error) { return e.d, nil } notify-0.9.3/example_fsevents_test.go000066400000000000000000000100521436002677300177770ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build darwin && !kqueue && cgo // +build darwin,!kqueue,cgo package notify_test import ( "log" "github.com/rjeczalik/notify" ) // This example shows how to use FSEvents-specifc event values. func ExampleWatch_darwin() { // Make the channel buffered to ensure no event is dropped. Notify will drop // an event if the receiver is not able to keep up the sending pace. c := make(chan notify.EventInfo, 1) // Set up a watchpoint listening for FSEvents-specific events within a // current working directory. Dispatch each FSEventsChangeOwner and FSEventsMount // events separately to c. if err := notify.Watch(".", c, notify.FSEventsChangeOwner, notify.FSEventsMount); err != nil { log.Fatal(err) } defer notify.Stop(c) // Block until an event is received. switch ei := <-c; ei.Event() { case notify.FSEventsChangeOwner: log.Println("The owner of", ei.Path(), "has changed.") case notify.FSEventsMount: log.Println("The path", ei.Path(), "has been mounted.") } } // This example shows how to work with EventInfo's underlying FSEvent struct. // Investigating notify.(*FSEvent).Flags field we are able to say whether // the event's path is a file or a directory and many more. func ExampleWatch_darwinDirFileSymlink() { var must = func(err error) { if err != nil { log.Fatal(err) } } var stop = func(c ...chan<- notify.EventInfo) { for _, c := range c { notify.Stop(c) } } // Make the channels buffered to ensure no event is dropped. Notify will drop // an event if the receiver is not able to keep up the sending pace. dir := make(chan notify.EventInfo, 1) file := make(chan notify.EventInfo, 1) symlink := make(chan notify.EventInfo, 1) all := make(chan notify.EventInfo, 1) // Set up a single watchpoint listening for FSEvents-specific events on // multiple user-provided channels. must(notify.Watch(".", dir, notify.FSEventsIsDir)) must(notify.Watch(".", file, notify.FSEventsIsFile)) must(notify.Watch(".", symlink, notify.FSEventsIsSymlink)) must(notify.Watch(".", all, notify.All)) defer stop(dir, file, symlink, all) // Block until an event is received. select { case ei := <-dir: log.Println("The directory", ei.Path(), "has changed") case ei := <-file: log.Println("The file", ei.Path(), "has changed") case ei := <-symlink: log.Println("The symlink", ei.Path(), "has changed") case ei := <-all: var kind string // Investigate underlying *notify.FSEvent struct to access more // information about the event. switch flags := ei.Sys().(*notify.FSEvent).Flags; { case flags¬ify.FSEventsIsFile != 0: kind = "file" case flags¬ify.FSEventsIsDir != 0: kind = "dir" case flags¬ify.FSEventsIsSymlink != 0: kind = "symlink" } log.Printf("The %s under path %s has been %sd\n", kind, ei.Path(), ei.Event()) } } // FSEvents may report multiple filesystem actions with one, coalesced event. // Notify unscoalesces such event and dispatches series of single events // back to the user. // // This example shows how to coalesce events by investigating notify.(*FSEvent).ID // field, for the science. func ExampleWatch_darwinCoalesce() { // Make the channels buffered to ensure no event is dropped. Notify will drop // an event if the receiver is not able to keep up the sending pace. c := make(chan notify.EventInfo, 4) // Set up a watchpoint listetning for events within current working directory. // Dispatch all platform-independent separately to c. if err := notify.Watch(".", c, notify.All); err != nil { log.Fatal(err) } defer notify.Stop(c) var id uint64 var coalesced []notify.EventInfo for ei := range c { switch n := ei.Sys().(*notify.FSEvent).ID; { case id == 0: id = n coalesced = []notify.EventInfo{ei} case id == n: coalesced = append(coalesced, ei) default: log.Printf("FSEvents reported a filesystem action with the following"+ " coalesced events %v groupped by %d ID\n", coalesced, id) return } } } notify-0.9.3/example_inotify_test.go000066400000000000000000000051601436002677300176270ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build linux // +build linux package notify_test import ( "log" "golang.org/x/sys/unix" "github.com/rjeczalik/notify" ) // This example shows how to watch changes made on file-system by text editor // when saving a file. Usually, either InCloseWrite or InMovedTo (when swapping // with a temporary file) event is created. func ExampleWatch_linux() { // Make the channel buffered to ensure no event is dropped. Notify will drop // an event if the receiver is not able to keep up the sending pace. c := make(chan notify.EventInfo, 1) // Set up a watchpoint listening for inotify-specific events within a // current working directory. Dispatch each InCloseWrite and InMovedTo // events separately to c. if err := notify.Watch(".", c, notify.InCloseWrite, notify.InMovedTo); err != nil { log.Fatal(err) } defer notify.Stop(c) // Block until an event is received. switch ei := <-c; ei.Event() { case notify.InCloseWrite: log.Println("Editing of", ei.Path(), "file is done.") case notify.InMovedTo: log.Println("File", ei.Path(), "was swapped/moved into the watched directory.") } } // This example shows how to use Sys() method from EventInfo interface to tie // two separate events generated by rename(2) function. func ExampleWatch_linuxMove() { // Make the channel buffered to ensure no event is dropped. Notify will drop // an event if the receiver is not able to keep up the sending pace. c := make(chan notify.EventInfo, 2) // Set up a watchpoint listening for inotify-specific events within a // current working directory. Dispatch each InMovedFrom and InMovedTo // events separately to c. if err := notify.Watch(".", c, notify.InMovedFrom, notify.InMovedTo); err != nil { log.Fatal(err) } defer notify.Stop(c) // Inotify reports move filesystem action by sending two events tied with // unique cookie value (uint32): one of the events is of InMovedFrom type // carrying move source path, while the second one is of InMoveTo type // carrying move destination path. moves := make(map[uint32]struct { From string To string }) // Wait for moves. for ei := range c { cookie := ei.Sys().(*unix.InotifyEvent).Cookie info := moves[cookie] switch ei.Event() { case notify.InMovedFrom: info.From = ei.Path() case notify.InMovedTo: info.To = ei.Path() } moves[cookie] = info if cookie != 0 && info.From != "" && info.To != "" { log.Println("File:", info.From, "was renamed to", info.To) delete(moves, cookie) } } } notify-0.9.3/example_readdcw_test.go000066400000000000000000000023351436002677300175600ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build windows // +build windows package notify_test import ( "log" "github.com/rjeczalik/notify" ) // This example shows how to watch directory-name changes in the working directory subtree. func ExampleWatch_windows() { // Make the channel buffered to ensure no event is dropped. Notify will drop // an event if the receiver is not able to keep up the sending pace. c := make(chan notify.EventInfo, 4) // Since notify package behaves exactly like ReadDirectoryChangesW function, // we must register notify.FileNotifyChangeDirName filter and wait for one // of FileAction* events. if err := notify.Watch("./...", c, notify.FileNotifyChangeDirName); err != nil { log.Fatal(err) } defer notify.Stop(c) // Wait for actions. for ei := range c { switch ei.Event() { case notify.FileActionAdded, notify.FileActionRenamedNewName: log.Println("Created:", ei.Path()) case notify.FileActionRemoved, notify.FileActionRenamedOldName: log.Println("Removed:", ei.Path()) case notify.FileActionModified: panic("notify: unexpected action") } } } notify-0.9.3/example_test.go000066400000000000000000000046511436002677300160720ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. package notify_test import ( "log" "path/filepath" "time" "github.com/rjeczalik/notify" ) // This is a basic example showing how to work with notify.Watch function. func ExampleWatch() { // Make the channel buffered to ensure no event is dropped. Notify will drop // an event if the receiver is not able to keep up the sending pace. c := make(chan notify.EventInfo, 1) // Set up a watchpoint listening on events within current working directory. // Dispatch each create and remove events separately to c. if err := notify.Watch(".", c, notify.Create, notify.Remove); err != nil { log.Fatal(err) } defer notify.Stop(c) // Block until an event is received. ei := <-c log.Println("Got event:", ei) } // This example shows how to set up a recursive watchpoint. func ExampleWatch_recursive() { // Make the channel buffered to ensure no event is dropped. Notify will drop // an event if the receiver is not able to keep up the sending pace. c := make(chan notify.EventInfo, 1) // Set up a watchpoint listening for events within a directory tree rooted // at current working directory. Dispatch remove events to c. if err := notify.Watch("./...", c, notify.Remove); err != nil { log.Fatal(err) } defer notify.Stop(c) // Block until an event is received. ei := <-c log.Println("Got event:", ei) } // This example shows why it is important to not create leaks by stoping // a channel when it's no longer being used. func ExampleStop() { waitfor := func(path string, e notify.Event, timeout time.Duration) bool { dir, file := filepath.Split(path) c := make(chan notify.EventInfo, 1) if err := notify.Watch(dir, c, e); err != nil { log.Fatal(err) } // Clean up watchpoint associated with c. If Stop was not called upon // return the channel would be leaked as notify holds the only reference // to it and does not release it on its own. defer notify.Stop(c) t := time.After(timeout) for { select { case ei := <-c: if filepath.Base(ei.Path()) == file { return true } case <-t: return false } } } if waitfor("index.lock", notify.Create, 5*time.Second) { log.Println("The git repository was locked") } if waitfor("index.lock", notify.Remove, 5*time.Second) { log.Println("The git repository was unlocked") } } notify-0.9.3/go.mod000066400000000000000000000001511436002677300141460ustar00rootroot00000000000000module github.com/rjeczalik/notify go 1.11 require golang.org/x/sys v0.0.0-20180926160741-c2ed4eda69e7 notify-0.9.3/go.sum000066400000000000000000000003171436002677300141770ustar00rootroot00000000000000golang.org/x/sys v0.0.0-20180926160741-c2ed4eda69e7 h1:bit1t3mgdR35yN0cX0G8orgLtOuyL9Wqxa1mccLB0ig= golang.org/x/sys v0.0.0-20180926160741-c2ed4eda69e7/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= notify-0.9.3/node.go000066400000000000000000000125531436002677300143250ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. package notify import ( "errors" "io/fs" "os" "path/filepath" ) var errSkip = errors.New("notify: skip") type walkPathFunc func(nd node, isbase bool) error type walkFunc func(node) error func errnotexist(name string) error { return &os.PathError{ Op: "Node", Path: name, Err: os.ErrNotExist, } } type node struct { Name string Watch watchpoint Child map[string]node } func newnode(name string) node { return node{ Name: name, Watch: make(watchpoint), Child: make(map[string]node), } } func (nd node) addchild(name, base string) node { child, ok := nd.Child[base] if !ok { child = newnode(name) nd.Child[base] = child } return child } func (nd node) Add(name string) node { i := indexrel(nd.Name, name) if i == -1 { return node{} } for j := indexSep(name[i:]); j != -1; j = indexSep(name[i:]) { nd = nd.addchild(name[:i+j], name[i:i+j]) i += j + 1 } return nd.addchild(name, name[i:]) } func (nd node) AddDir(fn walkFunc) error { stack := []node{nd} Traverse: for n := len(stack); n != 0; n = len(stack) { nd, stack = stack[n-1], stack[:n-1] switch err := fn(nd); err { case nil: case errSkip: continue Traverse default: return &os.PathError{ Op: "error while traversing", Path: nd.Name, Err: err, } } // TODO(rjeczalik): tolerate open failures - add failed names to // AddDirError and notify users which names are not added to the tree. fi, err := os.ReadDir(nd.Name) if err != nil { return err } for _, fi := range fi { if fi.Type()&(fs.ModeSymlink|fs.ModeDir) == fs.ModeDir { name := filepath.Join(nd.Name, fi.Name()) stack = append(stack, nd.addchild(name, name[len(nd.Name)+1:])) } } } return nil } func (nd node) Get(name string) (node, error) { i := indexrel(nd.Name, name) if i == -1 { return node{}, errnotexist(name) } ok := false for j := indexSep(name[i:]); j != -1; j = indexSep(name[i:]) { if nd, ok = nd.Child[name[i:i+j]]; !ok { return node{}, errnotexist(name) } i += j + 1 } if nd, ok = nd.Child[name[i:]]; !ok { return node{}, errnotexist(name) } return nd, nil } func (nd node) Del(name string) error { i := indexrel(nd.Name, name) if i == -1 { return errnotexist(name) } stack := []node{nd} ok := false for j := indexSep(name[i:]); j != -1; j = indexSep(name[i:]) { if nd, ok = nd.Child[name[i:i+j]]; !ok { return errnotexist(name[:i+j]) } stack = append(stack, nd) i += j + 1 } if _, ok = nd.Child[name[i:]]; !ok { return errnotexist(name) } delete(nd.Child, name[i:]) for name, i = name[i:], len(stack); i != 0; name, i = base(nd.Name), i-1 { nd = stack[i-1] if nd := nd.Child[name]; len(nd.Watch) > 1 || len(nd.Child) != 0 { break } else { nd.Child = nil nd.Watch = nil } delete(nd.Child, name) } return nil } func (nd node) Walk(fn walkFunc) error { stack := []node{nd} Traverse: for n := len(stack); n != 0; n = len(stack) { nd, stack = stack[n-1], stack[:n-1] switch err := fn(nd); err { case nil: case errSkip: continue Traverse default: return err } for name, nd := range nd.Child { if name == "" { // Node storing inactive watchpoints has empty name, skip it // form traversing. Root node has also an empty name, but it // never has a parent node. continue } stack = append(stack, nd) } } return nil } func (nd node) WalkPath(name string, fn walkPathFunc) error { i := indexrel(nd.Name, name) if i == -1 { return errnotexist(name) } ok := false for j := indexSep(name[i:]); j != -1; j = indexSep(name[i:]) { switch err := fn(nd, false); err { case nil: case errSkip: return nil default: return err } if nd, ok = nd.Child[name[i:i+j]]; !ok { return errnotexist(name[:i+j]) } i += j + 1 } switch err := fn(nd, false); err { case nil: case errSkip: return nil default: return err } if nd, ok = nd.Child[name[i:]]; !ok { return errnotexist(name) } switch err := fn(nd, true); err { case nil, errSkip: return nil default: return err } } type root struct { nd node } func (r root) addroot(name string) node { if vol := filepath.VolumeName(name); vol != "" { root, ok := r.nd.Child[vol] if !ok { root = r.nd.addchild(vol, vol) } return root } return r.nd } func (r root) root(name string) (node, error) { if vol := filepath.VolumeName(name); vol != "" { nd, ok := r.nd.Child[vol] if !ok { return node{}, errnotexist(name) } return nd, nil } return r.nd, nil } func (r root) Add(name string) node { return r.addroot(name).Add(name) } func (r root) AddDir(dir string, fn walkFunc) error { return r.Add(dir).AddDir(fn) } func (r root) Del(name string) error { nd, err := r.root(name) if err != nil { return err } return nd.Del(name) } func (r root) Get(name string) (node, error) { nd, err := r.root(name) if err != nil { return node{}, err } if nd.Name != name { if nd, err = nd.Get(name); err != nil { return node{}, err } } return nd, nil } func (r root) Walk(name string, fn walkFunc) error { nd, err := r.Get(name) if err != nil { return err } return nd.Walk(fn) } func (r root) WalkPath(name string, fn walkPathFunc) error { nd, err := r.root(name) if err != nil { return err } return nd.WalkPath(name, fn) } notify-0.9.3/notify.go000066400000000000000000000066621436002677300147140ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. // BUG(rjeczalik): Notify does not collect watchpoints, when underlying watches // were removed by their os-specific watcher implementations. Instead users are // advised to listen on persistent paths to have guarantee they receive events // for the whole lifetime of their applications (to discuss see #69). // BUG(ppknap): Linux (inotify) does not support watcher behavior masks like // InOneshot, InOnlydir etc. Instead users are advised to perform the filtering // themselves (to discuss see #71). // BUG(ppknap): Notify was not tested for short path name support under Windows // (ReadDirectoryChangesW). // BUG(ppknap): Windows (ReadDirectoryChangesW) cannot recognize which notification // triggers FileActionModified event. (to discuss see #75). package notify var defaultTree = newTree() // Watch sets up a watchpoint on path listening for events given by the events // argument. // // File or directory given by the path must exist, otherwise Watch will fail // with non-nil error. Notify resolves, for its internal purpose, any symlinks // the provided path may contain, so it may fail if the symlinks form a cycle. // It does so, since not all watcher implementations treat passed paths as-is. // E.g. FSEvents reports a real path for every event, setting a watchpoint // on /tmp will report events with paths rooted at /private/tmp etc. // // The c almost always is a buffered channel. Watch will not block sending to c // - the caller must ensure that c has sufficient buffer space to keep up with // the expected event rate. // // It is allowed to pass the same channel multiple times with different event // list or different paths. Calling Watch with different event lists for a single // watchpoint expands its event set. The only way to shrink it, is to call // Stop on its channel. // // Calling Watch with empty event list does not expand nor shrink watchpoint's // event set. If c is the first channel to listen for events on the given path, // Watch will seamlessly create a watch on the filesystem. // // Notify dispatches copies of single filesystem event to all channels registered // for each path. If a single filesystem event contains multiple coalesced events, // each of them is dispatched separately. E.g. the following filesystem change: // // ~ $ echo Hello > Notify.txt // // dispatches two events - notify.Create and notify.Write. However, it may depend // on the underlying watcher implementation whether OS reports both of them. // // # Windows and recursive watches // // If a directory which path was used to create recursive watch under Windows // gets deleted, the OS will not report such event. It is advised to keep in // mind this limitation while setting recursive watchpoints for your application, // e.g. use persistent paths like %userprofile% or watch additionally parent // directory of a recursive watchpoint in order to receive delete events for it. func Watch(path string, c chan<- EventInfo, events ...Event) error { return defaultTree.Watch(path, c, events...) } // Stop removes all watchpoints registered for c. All underlying watches are // also removed, for which c was the last channel listening for events. // // Stop does not close c. When Stop returns, it is guaranteed that c will // receive no more signals. func Stop(c chan<- EventInfo) { defaultTree.Stop(c) } notify-0.9.3/notify_inotify_test.go000066400000000000000000000014541436002677300175060ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build linux // +build linux package notify import "testing" func TestNotifySystemAndGlobalMix(t *testing.T) { n := NewNotifyTest(t, "testdata/vfs.txt") ch := NewChans(2) n.Watch("src/github.com/rjeczalik/fs", ch[0], Create) n.Watch("src/github.com/rjeczalik/fs", ch[1], InCreate) cases := []NCase{ { Event: icreate(n.W(), "src/github.com/rjeczalik/fs/.main.cc.swr"), Receiver: Chans{ch[0], ch[1]}, }, } n.ExpectNotifyEvents(cases, ch) } func TestUnknownEvent(t *testing.T) { n := NewNotifyTest(t, "testdata/vfs.txt") ch := NewChans(1) n.WatchErr("src/github.com/rjeczalik/fs", ch[0], nil, inExclUnlink) } notify-0.9.3/notify_readdcw_test.go000066400000000000000000000025661436002677300174430ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build windows // +build windows package notify import "testing" func TestNotifySystemSpecificEvent(t *testing.T) { n := NewNotifyTest(t, "testdata/vfs.txt") ch := NewChans(1) n.Watch("src/github.com/rjeczalik/fs", ch[0], FileNotifyChangeFileName, FileNotifyChangeSize) cases := []NCase{ { Event: rremove(n.W(), "src/github.com/rjeczalik/fs/fs.go"), Receiver: Chans{ch[0]}, }, { Event: rwrite(n.W(), "src/github.com/rjeczalik/fs/README.md", []byte("XD")), Receiver: Chans{ch[0]}, }, } n.ExpectNotifyEvents(cases, ch) } func TestUnknownEvent(t *testing.T) { n := NewNotifyTest(t, "testdata/vfs.txt") ch := NewChans(1) n.WatchErr("src/github.com/rjeczalik/fs", ch[0], nil, FileActionAdded) } func TestNotifySystemAndGlobalMix(t *testing.T) { n := NewNotifyTest(t, "testdata/vfs.txt") ch := NewChans(3) n.Watch("src/github.com/rjeczalik/fs", ch[0], Create) n.Watch("src/github.com/rjeczalik/fs", ch[1], FileNotifyChangeFileName) n.Watch("src/github.com/rjeczalik/fs", ch[2], FileNotifyChangeDirName) cases := []NCase{ { Event: rcreate(n.W(), "src/github.com/rjeczalik/fs/.main.cc.swr"), Receiver: Chans{ch[0], ch[1]}, }, } n.ExpectNotifyEvents(cases, ch) } notify-0.9.3/notify_test.go000066400000000000000000000122551436002677300157460ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build darwin || linux || freebsd || dragonfly || netbsd || openbsd || windows || solaris // +build darwin linux freebsd dragonfly netbsd openbsd windows solaris package notify import ( "errors" "os" "path/filepath" "testing" "time" ) func TestNotifyExample(t *testing.T) { n := NewNotifyTest(t, "testdata/vfs.txt") ch := NewChans(3) // Watch-points can be set explicitly via Watch/Stop calls... n.Watch("src/github.com/rjeczalik/fs", ch[0], Write) n.Watch("src/github.com/pblaszczyk/qttu", ch[0], Write) n.Watch("src/github.com/pblaszczyk/qttu/...", ch[1], Create) n.Watch("src/github.com/rjeczalik/fs/cmd/...", ch[2], Remove) cases := []NCase{ // i=0 { Event: write(n.W(), "src/github.com/rjeczalik/fs/fs.go", []byte("XD")), Receiver: Chans{ch[0]}, }, // TODO(rjeczalik): #62 // i=1 // { // Event: write(n.W(), "src/github.com/pblaszczyk/qttu/README.md", []byte("XD")), // Receiver: Chans{ch[0]}, // }, // i=2 { Event: write(n.W(), "src/github.com/rjeczalik/fs/cmd/gotree/go.go", []byte("XD")), Receiver: nil, }, // i=3 { Event: create(n.W(), "src/github.com/pblaszczyk/qttu/src/.main.cc.swp"), Receiver: Chans{ch[1]}, }, // i=4 { Event: create(n.W(), "src/github.com/pblaszczyk/qttu/src/.main.cc.swo"), Receiver: Chans{ch[1]}, }, // i=5 { Event: remove(n.W(), "src/github.com/rjeczalik/fs/cmd/gotree/go.go"), Receiver: Chans{ch[2]}, }, } n.ExpectNotifyEvents(cases, ch) // ...or using Call structures. stops := [...]Call{ // i=0 { F: FuncStop, C: ch[0], }, // i=1 { F: FuncStop, C: ch[1], }, } n.Call(stops[:]...) cases = []NCase{ // i=0 { Event: write(n.W(), "src/github.com/rjeczalik/fs/fs.go", []byte("XD")), Receiver: nil, }, // i=1 { Event: write(n.W(), "src/github.com/pblaszczyk/qttu/README.md", []byte("XD")), Receiver: nil, }, // i=2 { Event: create(n.W(), "src/github.com/pblaszczyk/qttu/src/.main.cc.swr"), Receiver: nil, }, // i=3 { Event: remove(n.W(), "src/github.com/rjeczalik/fs/cmd/gotree/main.go"), Receiver: Chans{ch[2]}, }, } n.ExpectNotifyEvents(cases, ch) } func TestStop(t *testing.T) { t.Skip("TODO(rjeczalik)") } func TestRenameInRoot(t *testing.T) { tmpDir := t.TempDir() c := make(chan EventInfo, 100) first := filepath.Join(tmpDir, "foo") second := filepath.Join(tmpDir, "bar") file := filepath.Join(second, "file") mustT(t, os.Mkdir(first, 0777)) if err := Watch(tmpDir+"/...", c, All); err != nil { t.Fatal(err) } defer Stop(c) mustT(t, os.Rename(first, second)) time.Sleep(50 * time.Millisecond) // Need some time to process rename. fd, err := os.Create(file) mustT(t, err) fd.Close() timeout := time.After(time.Second) for { select { case ev := <-c: if samefile(t, ev.Path(), file) { return } t.Log(ev.Path()) case <-timeout: t.Fatal("timed out before receiving event") } } } func TestRecreated(t *testing.T) { tmpDir := t.TempDir() dir := filepath.Join(tmpDir, "folder") file := filepath.Join(dir, "file") // Start watching eventChan := make(chan EventInfo, 1000) mustT(t, Watch(tmpDir+"/...", eventChan, All)) defer Stop(eventChan) recreateFolder := func() { // Give the sync some time to process events mustT(t, os.RemoveAll(dir)) mustT(t, os.Mkdir(dir, 0777)) time.Sleep(100 * time.Millisecond) // Create a file mustT(t, os.WriteFile(file, []byte("abc"), 0666)) } timeout := time.After(5 * time.Second) checkCreated := func() { for { select { case ev := <-eventChan: t.Log(ev.Path(), ev.Event()) if samefile(t, ev.Path(), file) && ev.Event() == Create { return } case <-timeout: t.Fatal("timed out before receiving event") } } } // 1. Create a folder and a file within it // This will create a node in the internal tree for the subfolder test/folder // Will create a new inotify watch for the folder t.Log("######## First ########") recreateFolder() checkCreated() // 2. Create a folder and a file within it again // This will set the events for the subfolder test/folder in the internal tree // Will create a new inotify watch for the folder because events differ t.Log("######## Second ########") recreateFolder() checkCreated() // 3. Create a folder and a file within it yet again // This time no new inotify watch will be created, because the events // and node already exist in the internal tree and all subsequent events // are lost, hence there is no event for the created file here anymore t.Log("######## Third ########") recreateFolder() checkCreated() } func mustT(t testing.TB, err error) { t.Helper() if err != nil { t.Fatal(err) } } func samefile(t *testing.T, p1, p2 string) bool { // The tests sometimes delete files shortly after creating them. // That's expected; ignore stat failures. fi1, err := os.Stat(p1) if errors.Is(err, os.ErrNotExist) { return false } mustT(t, err) fi2, err := os.Stat(p2) if errors.Is(err, os.ErrNotExist) { return false } mustT(t, err) return os.SameFile(fi1, fi2) } notify-0.9.3/sync_readdcw_test.go000066400000000000000000000017051436002677300171010ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build windows // +build windows package notify import ( "syscall" "time" "unsafe" ) var modkernel32 = syscall.NewLazyDLL("kernel32.dll") var procSetSystemFileCacheSize = modkernel32.NewProc("SetSystemFileCacheSize") var zero = uintptr(1<<(unsafe.Sizeof(uintptr(0))*8) - 1) func Sync() { // TODO(pknap): does not work without admin privileges, but I'm going // to hack it. // r, _, err := procSetSystemFileCacheSize.Call(none, none, 0) // if r == 0 { // dbgprint("SetSystemFileCacheSize error:", err) // } } // UpdateWait pauses the program for some minimal amount of time. This function // is required only by implementations which work asynchronously. It gives // watcher structure time to update its internal state. func UpdateWait() { time.Sleep(50 * time.Millisecond) } notify-0.9.3/sync_unix_test.go000066400000000000000000000006451436002677300164550ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build !windows // +build !windows package notify import "golang.org/x/sys/unix" func Sync() { unix.Sync() } // UpdateWait is required only by windows watcher implementation. On other // platforms this function is no-op. func UpdateWait() { } notify-0.9.3/testdata/000077500000000000000000000000001436002677300146545ustar00rootroot00000000000000notify-0.9.3/testdata/vfs.txt000066400000000000000000000054221436002677300162160ustar00rootroot00000000000000src/github.com/pblaszczyk/qttu/.travis.yml src/github.com/pblaszczyk/qttu/include/qttu/detail/registrator.hh src/github.com/pblaszczyk/qttu/include/qttu/detail/registry.hh src/github.com/pblaszczyk/qttu/include/qttu/runner.hh src/github.com/pblaszczyk/qttu/LICENSE src/github.com/pblaszczyk/qttu/qttu.pri src/github.com/pblaszczyk/qttu/qttu.pro src/github.com/pblaszczyk/qttu/README.md src/github.com/pblaszczyk/qttu/src/main.cc src/github.com/pblaszczyk/qttu/src/reg.cc src/github.com/ppknap/link/.travis.yml src/github.com/ppknap/link/include/coost/link/definitions.hpp src/github.com/ppknap/link/include/coost/link/detail/bundle.hpp src/github.com/ppknap/link/include/coost/link/detail/container_invoker.hpp src/github.com/ppknap/link/include/coost/link/detail/container_value_trait.hpp src/github.com/ppknap/link/include/coost/link/detail/dummy_type.hpp src/github.com/ppknap/link/include/coost/link/detail/function_trait.hpp src/github.com/ppknap/link/include/coost/link/detail/immediate_invoker.hpp src/github.com/ppknap/link/include/coost/link/detail/stdhelpers/always_same.hpp src/github.com/ppknap/link/include/coost/link/detail/stdhelpers/make_unique.hpp src/github.com/ppknap/link/include/coost/link/detail/vertex.hpp src/github.com/ppknap/link/include/coost/link/detail/wire.hpp src/github.com/ppknap/link/include/coost/link/link.hpp src/github.com/ppknap/link/include/coost/link.hpp src/github.com/ppknap/link/Jamroot.jam src/github.com/ppknap/link/LICENSE.md src/github.com/ppknap/link/README.md src/github.com/ppknap/link/test/counter_helper.hpp src/github.com/ppknap/link/test/Jamfile.jam src/github.com/ppknap/link/test/test_circular_calls.cpp src/github.com/ppknap/link/test/test_container.cpp src/github.com/ppknap/link/test/test_copy.cpp src/github.com/ppknap/link/test/test_destructor.cpp src/github.com/ppknap/link/test/test_immediate.cpp src/github.com/ppknap/link/test/test_initialize.cpp src/github.com/rjeczalik/fs/.travis.yml src/github.com/rjeczalik/fs/appveyor.yml src/github.com/rjeczalik/fs/cmd/gotree/go.go src/github.com/rjeczalik/fs/cmd/gotree/main.go src/github.com/rjeczalik/fs/cmd/mktree/main.go src/github.com/rjeczalik/fs/fs.go src/github.com/rjeczalik/fs/fsutil/fixture_test.go src/github.com/rjeczalik/fs/fsutil/fsutil.go src/github.com/rjeczalik/fs/fsutil/fsutil_test.go src/github.com/rjeczalik/fs/fsutil/rel.go src/github.com/rjeczalik/fs/fsutil/rel_test.go src/github.com/rjeczalik/fs/fsutil/tee.go src/github.com/rjeczalik/fs/fsutil/tee_test.go src/github.com/rjeczalik/fs/LICENSE src/github.com/rjeczalik/fs/memfs/memfs.go src/github.com/rjeczalik/fs/memfs/memfs_test.go src/github.com/rjeczalik/fs/memfs/tree.go src/github.com/rjeczalik/fs/memfs/tree_test.go src/github.com/rjeczalik/fs/memfs/util.go src/github.com/rjeczalik/fs/memfs/util_test.go src/github.com/rjeczalik/fs/README.md notify-0.9.3/testing_test.go000066400000000000000000000561771436002677300161260ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. package notify import ( "bufio" "fmt" "os" "path/filepath" "reflect" "runtime" "sort" "strconv" "strings" "testing" "time" ) // NOTE(rjeczalik): some useful environment variables: // // - NOTIFY_DEBUG gives some extra information about generated events // - NOTIFY_TIMEOUT allows for changing default wait time for watcher's // events // - NOTIFY_TMP allows for changing location of temporary directory trees // created for test purpose var wd string func init() { var err error if wd, err = os.Getwd(); err != nil { panic("Getwd()=" + err.Error()) } } func timeout() time.Duration { if s := os.Getenv("NOTIFY_TIMEOUT"); s != "" { if t, err := time.ParseDuration(s); err == nil { return t } } return 2 * time.Second } func vfs() (string, string) { if s := os.Getenv("NOTIFY_TMP"); s != "" { return filepath.Split(s) } return "testdata", "" } func isDir(path string) bool { r := path[len(path)-1] return r == '\\' || r == '/' } func tmpcreateall(tmp string, path string) error { isdir := isDir(path) path = filepath.Join(tmp, filepath.FromSlash(path)) if isdir { if err := os.MkdirAll(path, 0755); err != nil { return err } } else { if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil { return err } f, err := os.Create(path) if err != nil { return err } if err := nonil(f.Sync(), f.Close()); err != nil { return err } } return nil } func tmpcreate(root, path string) (bool, error) { isdir := isDir(path) path = filepath.Join(root, filepath.FromSlash(path)) if isdir { if err := os.Mkdir(path, 0755); err != nil { return false, err } } else { f, err := os.Create(path) if err != nil { return false, err } if err := nonil(f.Sync(), f.Close()); err != nil { return false, err } } return isdir, nil } func tmptree(root, list string) (string, error) { f, err := os.Open(list) if err != nil { return "", err } defer f.Close() if root == "" { if root, err = os.MkdirTemp(vfs()); err != nil { return "", err } } scanner := bufio.NewScanner(f) for scanner.Scan() { if err := tmpcreateall(root, scanner.Text()); err != nil { return "", err } } if err := scanner.Err(); err != nil { return "", err } return root, nil } func callern(n int) string { _, file, line, ok := runtime.Caller(n) if !ok { return "" } return filepath.Base(file) + ":" + strconv.Itoa(line) } func caller() string { return callern(3) } type WCase struct { Action func() Events []EventInfo } func (cas WCase) String() string { s := make([]string, 0, len(cas.Events)) for _, ei := range cas.Events { s = append(s, "Event("+ei.Event().String()+")@"+filepath.FromSlash(ei.Path())) } return strings.Join(s, ", ") } type W struct { Watcher watcher C chan EventInfo Timeout time.Duration t *testing.T root string } func newWatcherTest(t *testing.T, tree string) *W { root, err := tmptree("", filepath.FromSlash(tree)) if err != nil { t.Fatalf(`tmptree("", %q)=%v`, tree, err) } root, _, err = cleanpath(root) if err != nil { t.Fatalf(`cleanpath(%q)=%v`, root, err) } Sync() return &W{ t: t, root: root, } } func NewWatcherTest(t *testing.T, tree string, events ...Event) *W { w := newWatcherTest(t, tree) if len(events) == 0 { events = []Event{Create, Remove, Write, Rename} } if rw, ok := w.watcher().(recursiveWatcher); ok { if err := rw.RecursiveWatch(w.root, joinevents(events)); err != nil { t.Fatalf("RecursiveWatch(%q, All)=%v", w.root, err) } } else { fn := func(path string, fi os.FileInfo, err error) error { if err != nil { return err } if fi.IsDir() { if err := w.watcher().Watch(path, joinevents(events)); err != nil { return err } } return nil } if err := filepath.Walk(w.root, fn); err != nil { t.Fatalf("Walk(%q, fn)=%v", w.root, err) } } drainall(w.C) return w } func (w *W) clean(path string) string { path, isrec, err := cleanpath(filepath.Join(w.root, path)) if err != nil { w.Fatalf("cleanpath(%q)=%v", path, err) } if isrec { path = path + "..." } return path } func (w *W) Fatal(v interface{}) { w.t.Fatalf("%s: %v", caller(), v) } func (w *W) Fatalf(format string, v ...interface{}) { w.t.Fatalf("%s: %s", caller(), fmt.Sprintf(format, v...)) } func (w *W) Watch(path string, e Event) { if err := w.watcher().Watch(w.clean(path), e); err != nil { w.Fatalf("Watch(%s, %v)=%v", path, e, err) } } func (w *W) Rewatch(path string, olde, newe Event) { if err := w.watcher().Rewatch(w.clean(path), olde, newe); err != nil { w.Fatalf("Rewatch(%s, %v, %v)=%v", path, olde, newe, err) } } func (w *W) Unwatch(path string) { if err := w.watcher().Unwatch(w.clean(path)); err != nil { w.Fatalf("Unwatch(%s)=%v", path, err) } } func (w *W) RecursiveWatch(path string, e Event) { rw, ok := w.watcher().(recursiveWatcher) if !ok { w.Fatal("watcher does not implement recursive watching on this platform") } if err := rw.RecursiveWatch(w.clean(path), e); err != nil { w.Fatalf("RecursiveWatch(%s, %v)=%v", path, e, err) } } func (w *W) RecursiveRewatch(oldp, newp string, olde, newe Event) { rw, ok := w.watcher().(recursiveWatcher) if !ok { w.Fatal("watcher does not implement recursive watching on this platform") } if err := rw.RecursiveRewatch(w.clean(oldp), w.clean(newp), olde, newe); err != nil { w.Fatalf("RecursiveRewatch(%s, %s, %v, %v)=%v", oldp, newp, olde, newe, err) } } func (w *W) RecursiveUnwatch(path string) { rw, ok := w.watcher().(recursiveWatcher) if !ok { w.Fatal("watcher does not implement recursive watching on this platform") } if err := rw.RecursiveUnwatch(w.clean(path)); err != nil { w.Fatalf("RecursiveUnwatch(%s)=%v", path, err) } } func (w *W) initwatcher(buffer int) { c := make(chan EventInfo, buffer) w.Watcher = newWatcher(c) w.C = c } func (w *W) watcher() watcher { if w.Watcher == nil { w.initwatcher(512) } return w.Watcher } func (w *W) c() chan EventInfo { if w.C == nil { w.initwatcher(512) } return w.C } func (w *W) timeout() time.Duration { if w.Timeout != 0 { return w.Timeout } return timeout() } func (w *W) Close() error { defer os.RemoveAll(w.root) if err := w.watcher().Close(); err != nil { w.Fatalf("w.Watcher.Close()=%v", err) } return nil } func EqualEventInfo(want, got EventInfo) error { if got.Event() != want.Event() { return fmt.Errorf("want Event()=%v; got %v (path=%s)", want.Event(), got.Event(), want.Path()) } path := strings.TrimRight(filepath.FromSlash(want.Path()), `/\`) if !strings.HasSuffix(got.Path(), path) { return fmt.Errorf("want Path()=%s; got %s (event=%v)", path, got.Path(), want.Event()) } return nil } func HasEventInfo(want, got Event, p string) error { if got&want != want { return fmt.Errorf("want Event=%v; got %v (path=%s)", want, got, p) } return nil } func EqualCall(want, got Call) error { if want.F != got.F { return fmt.Errorf("want F=%v; got %v (want.P=%q, got.P=%q)", want.F, got.F, want.P, got.P) } if got.E != want.E { return fmt.Errorf("want E=%v; got %v (want.P=%q, got.P=%q)", want.E, got.E, want.P, got.P) } if got.NE != want.NE { return fmt.Errorf("want NE=%v; got %v (want.P=%q, got.P=%q)", want.NE, got.NE, want.P, got.P) } if want.C != got.C { return fmt.Errorf("want C=%p; got %p (want.P=%q, got.P=%q)", want.C, got.C, want.P, got.P) } if want := filepath.FromSlash(want.P); !strings.HasSuffix(got.P, want) { return fmt.Errorf("want P=%s; got %s", want, got.P) } if want := filepath.FromSlash(want.NP); !strings.HasSuffix(got.NP, want) { return fmt.Errorf("want NP=%s; got %s", want, got.NP) } return nil } func create(w *W, path string) WCase { return WCase{ Action: func() { isdir, err := tmpcreate(w.root, filepath.FromSlash(path)) if err != nil { w.Fatalf("tmpcreate(%q, %q)=%v", w.root, path, err) } if isdir { dbgprintf("[FS] os.Mkdir(%q)\n", path) } else { dbgprintf("[FS] os.Create(%q)\n", path) } }, Events: []EventInfo{ &Call{P: path, E: Create}, }, } } func remove(w *W, path string) WCase { return WCase{ Action: func() { if err := os.RemoveAll(filepath.Join(w.root, filepath.FromSlash(path))); err != nil { w.Fatal(err) } dbgprintf("[FS] os.Remove(%q)\n", path) }, Events: []EventInfo{ &Call{P: path, E: Remove}, }, } } func rename(w *W, oldpath, newpath string) WCase { return WCase{ Action: func() { err := os.Rename(filepath.Join(w.root, filepath.FromSlash(oldpath)), filepath.Join(w.root, filepath.FromSlash(newpath))) if err != nil { w.Fatal(err) } dbgprintf("[FS] os.Rename(%q, %q)\n", oldpath, newpath) }, Events: []EventInfo{ &Call{P: newpath, E: Rename}, }, } } func write(w *W, path string, p []byte) WCase { return WCase{ Action: func() { f, err := os.OpenFile(filepath.Join(w.root, filepath.FromSlash(path)), os.O_WRONLY, 0644) if err != nil { w.Fatalf("OpenFile(%q)=%v", path, err) } if _, err := f.Write(p); err != nil { w.Fatalf("Write(%q)=%v", path, err) } if err := nonil(f.Sync(), f.Close()); err != nil { w.Fatalf("Sync(%q)/Close(%q)=%v", path, path, err) } dbgprintf("[FS] Write(%q)\n", path) }, Events: []EventInfo{ &Call{P: path, E: Write}, }, } } func drainall(c chan EventInfo) (ei []EventInfo) { time.Sleep(50 * time.Millisecond) for { select { case e := <-c: ei = append(ei, e) runtime.Gosched() default: return } } } type WCaseFunc func(i int, cas WCase, ei EventInfo) error func (w *W) ExpectAnyFunc(cases []WCase, fn WCaseFunc) { UpdateWait() // Wait some time before starting the test. Test: for i, cas := range cases { dbgprintf("ExpectAny: i=%d\n", i) cas.Action() Sync() switch cas.Events { case nil: if ei := drainall(w.C); len(ei) != 0 { w.Fatalf("unexpected dangling events: %v (i=%d)", ei, i) } default: select { case ei := <-w.C: dbgprintf("received: path=%q, event=%v, sys=%v (i=%d)", ei.Path(), ei.Event(), ei.Sys(), i) for j, want := range cas.Events { if err := EqualEventInfo(want, ei); err != nil { dbgprint(err, j) continue } if fn != nil { if err := fn(i, cas, ei); err != nil { w.Fatalf("ExpectAnyFunc(%d, %v)=%v", i, ei, err) } } drainall(w.C) // TODO(rjeczalik): revisit continue Test } w.Fatalf("ExpectAny received an event which does not match any of "+ "the expected ones (i=%d): want one of %v; got %v", i, cas.Events, ei) case <-time.After(w.timeout()): w.Fatalf("timed out after %v waiting for one of %v (i=%d)", w.timeout(), cas.Events, i) } drainall(w.C) // TODO(rjeczalik): revisit } } } func (w *W) ExpectAny(cases []WCase) { w.ExpectAnyFunc(cases, nil) } func (w *W) aggregate(ei []EventInfo, pf string) (evs map[string]Event) { evs = make(map[string]Event) for _, cas := range ei { p := cas.Path() if pf != "" { p = filepath.Join(pf, p) } evs[p] |= cas.Event() } return } func (w *W) ExpectAllFunc(cases []WCase) { UpdateWait() // Wait some time before starting the test. for i, cas := range cases { exp := w.aggregate(cas.Events, w.root) dbgprintf("ExpectAll: i=%d\n", i) cas.Action() Sync() got := w.aggregate(drainall(w.C), "") for ep, ee := range exp { ge, ok := got[ep] if !ok { w.Fatalf("missing events for %q (%v)", ep, ee) continue } delete(got, ep) if err := HasEventInfo(ee, ge, ep); err != nil { w.Fatalf("ExpectAll received an event which does not match "+ "the expected ones for %q: want %v; got %v", ep, ee, ge) continue } } if len(got) != 0 { w.Fatalf("ExpectAll received unexpected events: %v", got) } } } // ExpectAll requires all requested events to be send. // It does not require events to be send in the same order or in the same // chunks (e.g. NoteWrite and NoteExtend reported as independent events are // treated the same as one NoteWrite|NoteExtend event). func (w *W) ExpectAll(cases []WCase) { w.ExpectAllFunc(cases) } // FuncType represents enums for Watcher interface. type FuncType string const ( FuncWatch = FuncType("Watch") FuncUnwatch = FuncType("Unwatch") FuncRewatch = FuncType("Rewatch") FuncRecursiveWatch = FuncType("RecursiveWatch") FuncRecursiveUnwatch = FuncType("RecursiveUnwatch") FuncRecursiveRewatch = FuncType("RecursiveRewatch") FuncStop = FuncType("Stop") ) type Chans []chan EventInfo func NewChans(n int) Chans { ch := make([]chan EventInfo, n) for i := range ch { ch[i] = make(chan EventInfo, buffer) } return ch } func (c Chans) Foreach(fn func(chan<- EventInfo, node)) { for i, ch := range c { fn(ch, node{Name: strconv.Itoa(i)}) } } func (c Chans) Drain() (ei []EventInfo) { n := len(c) stop := make(chan struct{}) eich := make(chan EventInfo, n*buffer) go func() { defer close(eich) cases := make([]reflect.SelectCase, n+1) for i := range c { cases[i].Chan = reflect.ValueOf(c[i]) cases[i].Dir = reflect.SelectRecv } cases[n].Chan = reflect.ValueOf(stop) cases[n].Dir = reflect.SelectRecv for { i, v, ok := reflect.Select(cases) if i == n { return } if !ok { panic("(Chans).Drain(): unexpected chan close") } eich <- v.Interface().(EventInfo) } }() <-time.After(50 * time.Duration(n) * time.Millisecond) close(stop) for e := range eich { ei = append(ei, e) } return } // Call represents single call to Watcher issued by the Tree // and recorded by a spy Watcher mock. type Call struct { F FuncType // denotes type of function to call, for both watcher and notifier interface C chan EventInfo // user channel being an argument to either Watch or Stop function P string // regular Path argument and old path from RecursiveRewatch call NP string // new Path argument from RecursiveRewatch call E Event // regular Event argument and old Event from a Rewatch call NE Event // new Event argument from Rewatch call S interface{} // when Call is used as EventInfo, S is a value of Sys() Dir bool // when Call is used as EventInfo, Dir is a value of isDir() } // Call implements the EventInfo interface. func (c *Call) Event() Event { return c.E } func (c *Call) Path() string { return c.P } func (c *Call) String() string { return fmt.Sprintf("%#v", c) } func (c *Call) Sys() interface{} { return c.S } func (c *Call) isDir() (bool, error) { return c.Dir, nil } // CallSlice is a convenient wrapper for a slice of Call values, which allows // to sort them in ascending order. type CallSlice []Call // CallSlice implements sort.Interface inteface. func (cs CallSlice) Len() int { return len(cs) } func (cs CallSlice) Less(i, j int) bool { return cs[i].P < cs[j].P } func (cs CallSlice) Swap(i, j int) { cs[i], cs[j] = cs[j], cs[i] } func (cs CallSlice) Sort() { sort.Sort(cs) } // Spy is a mock for Watcher interface, which records every call. type Spy []Call func (s *Spy) Close() (_ error) { return } func (s *Spy) Watch(p string, e Event) (_ error) { dbgprintf("%s: (*Spy).Watch(%q, %v)", caller(), p, e) *s = append(*s, Call{F: FuncWatch, P: p, E: e}) return } func (s *Spy) Unwatch(p string) (_ error) { dbgprintf("%s: (*Spy).Unwatch(%q)", caller(), p) *s = append(*s, Call{F: FuncUnwatch, P: p}) return } func (s *Spy) Rewatch(p string, olde, newe Event) (_ error) { dbgprintf("%s: (*Spy).Rewatch(%q, %v, %v)", caller(), p, olde, newe) *s = append(*s, Call{F: FuncRewatch, P: p, E: olde, NE: newe}) return } func (s *Spy) RecursiveWatch(p string, e Event) (_ error) { dbgprintf("%s: (*Spy).RecursiveWatch(%q, %v)", caller(), p, e) *s = append(*s, Call{F: FuncRecursiveWatch, P: p, E: e}) return } func (s *Spy) RecursiveUnwatch(p string) (_ error) { dbgprintf("%s: (*Spy).RecursiveUnwatch(%q)", caller(), p) *s = append(*s, Call{F: FuncRecursiveUnwatch, P: p}) return } func (s *Spy) RecursiveRewatch(oldp, newp string, olde, newe Event) (_ error) { dbgprintf("%s: (*Spy).RecursiveRewatch(%q, %q, %v, %v)", caller(), oldp, newp, olde, newe) *s = append(*s, Call{F: FuncRecursiveRewatch, P: oldp, NP: newp, E: olde, NE: newe}) return } type RCase struct { Call Call Record []Call } type TCase struct { Event Call Receiver Chans } type NCase struct { Event WCase Receiver Chans } type N struct { Timeout time.Duration t *testing.T tree tree w *W spy *Spy c chan EventInfo j int // spy offset realroot string } func newN(t *testing.T, tree string) *N { n := &N{ t: t, w: newWatcherTest(t, tree), } realroot, err := canonical(n.w.root) if err != nil { t.Fatalf("%s: unexpected fixture failure: %v", caller(), err) } n.realroot = realroot return n } func newTreeN(t *testing.T, tree string) *N { c := make(chan EventInfo, buffer) n := newN(t, tree) n.spy = &Spy{} n.w.Watcher = n.spy n.w.C = c n.c = c return n } func NewNotifyTest(t *testing.T, tree string) *N { n := newN(t, tree) if rw, ok := n.w.watcher().(recursiveWatcher); ok { n.tree = newRecursiveTree(rw, n.w.c()) } else { n.tree = newNonrecursiveTree(n.w.watcher(), n.w.c(), nil) } t.Cleanup(n.Close) return n } func NewRecursiveTreeTest(t *testing.T, tree string) *N { n := newTreeN(t, tree) n.tree = newRecursiveTree(n.spy, n.c) t.Cleanup(n.Close) return n } func NewNonrecursiveTreeTest(t *testing.T, tree string) *N { n := newTreeN(t, tree) n.tree = newNonrecursiveTree(n.spy, n.c, nil) t.Cleanup(n.Close) return n } func NewNonrecursiveTreeTestC(t *testing.T, tree string) (*N, chan EventInfo) { rec := make(chan EventInfo, buffer) recinternal := make(chan EventInfo, buffer) recuser := make(chan EventInfo, buffer) go func() { for ei := range rec { select { case recinternal <- ei: default: t.Fatalf("failed to send ei to recinternal: not ready") } select { case recuser <- ei: default: t.Fatalf("failed to send ei to recuser: not ready") } } }() n := newTreeN(t, tree) tr := newNonrecursiveTree(n.spy, n.c, recinternal) tr.rec = rec n.tree = tr t.Cleanup(n.Close) return n, recuser } func (n *N) timeout() time.Duration { if n.Timeout != 0 { return n.Timeout } return n.w.timeout() } func (n *N) W() *W { return n.w } func (n *N) Close() { err := n.tree.Close() os.RemoveAll(n.w.root) if err != nil { n.w.Fatalf("(notifier).Close()=%v", err) } } func (n *N) Watch(path string, c chan<- EventInfo, events ...Event) { UpdateWait() // we need to wait on Windows because of its asynchronous watcher. path = filepath.Join(n.w.root, path) if err := n.tree.Watch(path, c, events...); err != nil { n.t.Errorf("Watch(%s, %p, %v)=%v", path, c, events, err) } } func (n *N) WatchErr(path string, c chan<- EventInfo, err error, events ...Event) { path = filepath.Join(n.w.root, path) switch e := n.tree.Watch(path, c, events...); { case err == nil && e == nil: n.t.Errorf("Watch(%s, %p, %v)=nil", path, c, events) case err != nil && e != err: n.t.Errorf("Watch(%s, %p, %v)=%v != %v", path, c, events, e, err) } } func (n *N) Stop(c chan<- EventInfo) { n.tree.Stop(c) } func (n *N) Call(calls ...Call) { for i := range calls { switch calls[i].F { case FuncWatch: n.Watch(calls[i].P, calls[i].C, calls[i].E) case FuncStop: n.Stop(calls[i].C) default: panic("unsupported call type: " + string(calls[i].F)) } } } func (n *N) expectDry(ch Chans, i int) { if ei := ch.Drain(); len(ei) != 0 { n.w.Fatalf("unexpected dangling events: %v (i=%d)", ei, i) } } func (n *N) ExpectRecordedCalls(cases []RCase) { for i, cas := range cases { dbgprintf("ExpectRecordedCalls: i=%d\n", i) n.Call(cas.Call) record := (*n.spy)[n.j:] if len(cas.Record) == 0 && len(record) == 0 { continue } n.j = len(*n.spy) if len(record) != len(cas.Record) { n.t.Fatalf("%s: want len(record)=%d; got %d [%+v] (i=%d)", caller(), len(cas.Record), len(record), record, i) } CallSlice(record).Sort() for j := range cas.Record { if err := EqualCall(cas.Record[j], record[j]); err != nil { n.t.Fatalf("%s: %v (i=%d, j=%d)", caller(), err, i, j) } } } } func (n *N) collect(ch Chans) <-chan []EventInfo { done := make(chan []EventInfo) go func() { cases := make([]reflect.SelectCase, len(ch)) unique := make(map[<-chan EventInfo]EventInfo, len(ch)) for i := range ch { cases[i].Chan = reflect.ValueOf(ch[i]) cases[i].Dir = reflect.SelectRecv } for i := len(cases); i != 0; i = len(cases) { j, v, ok := reflect.Select(cases) if !ok { n.t.Fatal("unexpected chan close") } ch := cases[j].Chan.Interface().(chan EventInfo) got := v.Interface().(EventInfo) if ei, ok := unique[ch]; ok { n.t.Fatalf("duplicated event %v (previous=%v) received on collect", got, ei) } unique[ch] = got cases[j], cases = cases[i-1], cases[:i-1] } collected := make([]EventInfo, 0, len(ch)) for _, ch := range unique { collected = append(collected, ch) } done <- collected }() return done } func (n *N) abs(rel Call) *Call { rel.P = filepath.Join(n.realroot, filepath.FromSlash(rel.P)) if !filepath.IsAbs(rel.P) { rel.P = filepath.Join(wd, rel.P) } return &rel } func (n *N) ExpectTreeEvents(cases []TCase, all Chans) { for i, cas := range cases { dbgprintf("ExpectTreeEvents: i=%d\n", i) // Ensure there're no dangling event left by previous test-case. n.expectDry(all, i) n.c <- n.abs(cas.Event) switch cas.Receiver { case nil: n.expectDry(all, i) default: ch := n.collect(cas.Receiver) select { case collected := <-ch: for _, got := range collected { if err := EqualEventInfo(&cas.Event, got); err != nil { n.w.Fatalf("%s: %s (i=%d)", caller(), err, i) } } case <-time.After(n.timeout()): n.w.Fatalf("ExpectTreeEvents has timed out after %v waiting for"+ " %v on %s (i=%d)", n.timeout(), cas.Event.E, cas.Event.P, i) } } } n.expectDry(all, -1) } func (n *N) ExpectNotifyEvents(cases []NCase, all Chans) { UpdateWait() // Wait some time before starting the test. for i, cas := range cases { dbgprintf("ExpectNotifyEvents: i=%d\n", i) cas.Event.Action() Sync() switch cas.Receiver { case nil: n.expectDry(all, i) default: ch := n.collect(cas.Receiver) select { case collected := <-ch: Compare: for j, ei := range collected { dbgprintf("received: path=%q, event=%v, sys=%v (i=%d, j=%d)", ei.Path(), ei.Event(), ei.Sys(), i, j) for _, want := range cas.Event.Events { if err := EqualEventInfo(want, ei); err != nil { dbgprint(err, j) continue } continue Compare } n.w.Fatalf("ExpectNotifyEvents received an event which does not"+ " match any of the expected ones (i=%d): want one of %v; got %v", i, cas.Event.Events, ei) } case <-time.After(n.timeout()): n.w.Fatalf("ExpectNotifyEvents did not receive any of the expected events [%v] "+ "after %v (i=%d)", cas.Event, n.timeout(), i) } } } n.expectDry(all, -1) } func (n *N) Walk(fn walkFunc) { switch t := n.tree.(type) { case *recursiveTree: if err := t.root.Walk("", fn); err != nil { n.w.Fatal(err) } case *nonrecursiveTree: if err := t.root.Walk("", fn); err != nil { n.w.Fatal(err) } default: n.t.Fatal("unknown tree type") } } notify-0.9.3/tree.go000066400000000000000000000010321436002677300143250ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. package notify const buffer = 128 type tree interface { Watch(string, chan<- EventInfo, ...Event) error Stop(chan<- EventInfo) Close() error } func newTree() tree { c := make(chan EventInfo, buffer) w := newWatcher(c) if rw, ok := w.(recursiveWatcher); ok { return newRecursiveTree(rw, c) } return newNonrecursiveTree(w, c, make(chan EventInfo, buffer)) } notify-0.9.3/tree_nonrecursive.go000066400000000000000000000166101436002677300171370ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. package notify import "sync" // nonrecursiveTree TODO(rjeczalik) type nonrecursiveTree struct { rw sync.RWMutex // protects root root root w watcher c chan EventInfo rec chan EventInfo } // newNonrecursiveTree TODO(rjeczalik) func newNonrecursiveTree(w watcher, c, rec chan EventInfo) *nonrecursiveTree { if rec == nil { rec = make(chan EventInfo, buffer) } t := &nonrecursiveTree{ root: root{nd: newnode("")}, w: w, c: c, rec: rec, } go t.dispatch(c) go t.internal(rec) return t } // dispatch TODO(rjeczalik) func (t *nonrecursiveTree) dispatch(c <-chan EventInfo) { for ei := range c { dbgprintf("dispatching %v on %q", ei.Event(), ei.Path()) go func(ei EventInfo) { var nd node var isrec bool dir, base := split(ei.Path()) fn := func(it node, isbase bool) error { isrec = isrec || it.Watch.IsRecursive() if isbase { nd = it } else { it.Watch.Dispatch(ei, recursive) } return nil } t.rw.RLock() // Notify recursive watchpoints found on the path. if err := t.root.WalkPath(dir, fn); err != nil { dbgprint("dispatch did not reach leaf:", err) t.rw.RUnlock() return } // Notify parent watchpoint. nd.Watch.Dispatch(ei, 0) isrec = isrec || nd.Watch.IsRecursive() // If leaf watchpoint exists, notify it. if nd, ok := nd.Child[base]; ok { isrec = isrec || nd.Watch.IsRecursive() nd.Watch.Dispatch(ei, 0) } t.rw.RUnlock() // If the event describes newly leaf directory created within if !isrec || ei.Event()&(Create|Remove) == 0 { return } if ok, err := ei.(isDirer).isDir(); !ok || err != nil { return } t.rec <- ei }(ei) } } // internal TODO(rjeczalik) func (t *nonrecursiveTree) internal(rec <-chan EventInfo) { for ei := range rec { t.rw.Lock() if ei.Event() == Remove { nd, err := t.root.Get(ei.Path()) if err != nil { t.rw.Unlock() continue } t.walkWatchpoint(nd, func(_ Event, nd node) error { t.w.Unwatch(nd.Name) return nil }) t.root.Del(ei.Path()) t.rw.Unlock() continue } var nd node var eset = internal t.root.WalkPath(ei.Path(), func(it node, _ bool) error { if e := it.Watch[t.rec]; e != 0 && e > eset { eset = e } nd = it return nil }) if eset == internal { t.rw.Unlock() continue } if ei.Path() != nd.Name { nd = nd.Add(ei.Path()) } err := nd.AddDir(t.recFunc(eset)) t.rw.Unlock() if err != nil { dbgprintf("internal(%p) error: %v", rec, err) } } } // watchAdd TODO(rjeczalik) func (t *nonrecursiveTree) watchAdd(nd node, c chan<- EventInfo, e Event) eventDiff { if e&recursive != 0 { diff := nd.Watch.Add(t.rec, e|Create|omit) nd.Watch.Add(c, e) return diff } return nd.Watch.Add(c, e) } // watchDelMin TODO(rjeczalik) func (t *nonrecursiveTree) watchDelMin(min Event, nd node, c chan<- EventInfo, e Event) eventDiff { old, ok := nd.Watch[t.rec] if ok { nd.Watch[t.rec] = min } diff := nd.Watch.Del(c, e) if ok { switch old &^= diff[0] &^ diff[1]; { case old|internal == internal: delete(nd.Watch, t.rec) if set, ok := nd.Watch[nil]; ok && len(nd.Watch) == 1 && set == 0 { delete(nd.Watch, nil) } default: nd.Watch.Add(t.rec, old|Create) switch { case diff == none: case diff[1]|Create == diff[0]: diff = none default: diff[1] |= Create } } } return diff } // watchDel TODO(rjeczalik) func (t *nonrecursiveTree) watchDel(nd node, c chan<- EventInfo, e Event) eventDiff { return t.watchDelMin(0, nd, c, e) } // Watch TODO(rjeczalik) func (t *nonrecursiveTree) Watch(path string, c chan<- EventInfo, events ...Event) error { if c == nil { panic("notify: Watch using nil channel") } // Expanding with empty event set is a nop. if len(events) == 0 { return nil } path, isrec, err := cleanpath(path) if err != nil { return err } eset := joinevents(events) t.rw.Lock() defer t.rw.Unlock() nd := t.root.Add(path) if isrec { return t.watchrec(nd, c, eset|recursive) } return t.watch(nd, c, eset) } func (t *nonrecursiveTree) watch(nd node, c chan<- EventInfo, e Event) (err error) { diff := nd.Watch.Add(c, e) switch { case diff == none: return nil case diff[1] == 0: // TODO(rjeczalik): cleanup this panic after implementation is stable panic("eset is empty: " + nd.Name) case diff[0] == 0: err = t.w.Watch(nd.Name, diff[1]) default: err = t.w.Rewatch(nd.Name, diff[0], diff[1]) } if err != nil { nd.Watch.Del(c, diff.Event()) return err } return nil } func (t *nonrecursiveTree) recFunc(e Event) walkFunc { return func(nd node) error { switch diff := nd.Watch.Add(t.rec, e|omit|Create); { case diff == none: case diff[1] == 0: // TODO(rjeczalik): cleanup this panic after implementation is stable panic("eset is empty: " + nd.Name) case diff[0] == 0: t.w.Watch(nd.Name, diff[1]) default: t.w.Rewatch(nd.Name, diff[0], diff[1]) } return nil } } func (t *nonrecursiveTree) watchrec(nd node, c chan<- EventInfo, e Event) error { var traverse func(walkFunc) error // Non-recursive tree listens on Create event for every recursive // watchpoint in order to automagically set a watch for every // created directory. switch diff := nd.Watch.dryAdd(t.rec, e|Create); { case diff == none: t.watchAdd(nd, c, e) nd.Watch.Add(t.rec, e|omit|Create) return nil case diff[1] == 0: // TODO(rjeczalik): cleanup this panic after implementation is stable panic("eset is empty: " + nd.Name) case diff[0] == 0: // TODO(rjeczalik): BFS into directories and skip subtree as soon as first // recursive watchpoint is encountered. traverse = nd.AddDir default: traverse = nd.Walk } // TODO(rjeczalik): account every path that failed to be (re)watched // and retry. if err := traverse(t.recFunc(e)); err != nil { return err } t.watchAdd(nd, c, e) return nil } type walkWatchpointFunc func(Event, node) error func (t *nonrecursiveTree) walkWatchpoint(nd node, fn walkWatchpointFunc) error { type minode struct { min Event nd node } mnd := minode{nd: nd} stack := []minode{mnd} Traverse: for n := len(stack); n != 0; n = len(stack) { mnd, stack = stack[n-1], stack[:n-1] // There must be no recursive watchpoints if the node has no watchpoints // itself (every node in subtree rooted at recursive watchpoints must // have at least nil (total) and t.rec watchpoints). if len(mnd.nd.Watch) != 0 { switch err := fn(mnd.min, mnd.nd); err { case nil: case errSkip: continue Traverse default: return err } } for _, nd := range mnd.nd.Child { stack = append(stack, minode{mnd.nd.Watch[t.rec], nd}) } } return nil } // Stop TODO(rjeczalik) func (t *nonrecursiveTree) Stop(c chan<- EventInfo) { fn := func(min Event, nd node) error { // TODO(rjeczalik): aggregate watcher errors and retry; in worst case // forward to the user. switch diff := t.watchDelMin(min, nd, c, all); { case diff == none: return nil case diff[1] == 0: t.w.Unwatch(nd.Name) default: t.w.Rewatch(nd.Name, diff[0], diff[1]) } return nil } t.rw.Lock() err := t.walkWatchpoint(t.root.nd, fn) // TODO(rjeczalik): store max root per c t.rw.Unlock() dbgprintf("Stop(%p) error: %v\n", c, err) } // Close TODO(rjeczalik) func (t *nonrecursiveTree) Close() error { err := t.w.Close() close(t.c) return err } notify-0.9.3/tree_nonrecursive_test.go000066400000000000000000000245161436002677300202020ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. package notify import ( "fmt" "testing" ) func TestNonrecursiveTree(t *testing.T) { n := NewNonrecursiveTreeTest(t, "testdata/vfs.txt") ch := NewChans(5) watches := [...]RCase{ // i=0 { Call: Call{ F: FuncWatch, P: "src/github.com/rjeczalik/fs/fs.go", C: ch[0], E: Rename, }, Record: []Call{ { F: FuncWatch, P: "src/github.com/rjeczalik/fs/fs.go", E: Rename, }, }, }, // i=1 { Call: Call{ F: FuncWatch, P: "src/github.com/rjeczalik/fs/cmd/...", C: ch[1], E: Remove, }, Record: []Call{ { F: FuncWatch, P: "src/github.com/rjeczalik/fs/cmd", E: Create | Remove, }, { F: FuncWatch, P: "src/github.com/rjeczalik/fs/cmd/gotree", E: Create | Remove, }, { F: FuncWatch, P: "src/github.com/rjeczalik/fs/cmd/mktree", E: Create | Remove, }, }, }, // i=2 { Call: Call{ F: FuncWatch, P: "src/github.com/rjeczalik/fs/cmd/...", C: ch[2], E: Rename, }, Record: []Call{ { F: FuncRewatch, P: "src/github.com/rjeczalik/fs/cmd", E: Create | Remove, NE: Create | Remove | Rename, }, { F: FuncRewatch, P: "src/github.com/rjeczalik/fs/cmd/gotree", E: Create | Remove, NE: Create | Remove | Rename, }, { F: FuncRewatch, P: "src/github.com/rjeczalik/fs/cmd/mktree", E: Create | Remove, NE: Create | Remove | Rename, }, }, }, // i=3 { Call: Call{ F: FuncWatch, P: "src/github.com/rjeczalik/fs/cmd/mktree/...", C: ch[2], E: Write, }, Record: []Call{ { F: FuncRewatch, P: "src/github.com/rjeczalik/fs/cmd/mktree", E: Create | Remove | Rename, NE: Create | Remove | Rename | Write, }, }, }, // i=4 { Call: Call{ F: FuncWatch, P: "src/github.com/pblaszczyk/qttu/include", C: ch[3], E: Create, }, Record: []Call{ { F: FuncWatch, P: "src/github.com/pblaszczyk/qttu/include", E: Create, }, }, }, // i=5 { Call: Call{ F: FuncWatch, P: "src/github.com/pblaszczyk/qttu/include/qttu/detail/...", C: ch[3], E: Write, }, Record: []Call{ { F: FuncWatch, P: "src/github.com/pblaszczyk/qttu/include/qttu/detail", E: Create | Write, }, }, }, // i=6 { Call: Call{ F: FuncWatch, P: "src/github.com/pblaszczyk/qttu/include/...", C: ch[0], E: Rename, }, Record: []Call{ { F: FuncRewatch, P: "src/github.com/pblaszczyk/qttu/include", E: Create, NE: Create | Rename, }, { F: FuncWatch, P: "src/github.com/pblaszczyk/qttu/include/qttu", E: Create | Rename, }, { F: FuncRewatch, P: "src/github.com/pblaszczyk/qttu/include/qttu/detail", E: Create | Write, NE: Create | Write | Rename, }, }, }, // i=7 { Call: Call{ F: FuncWatch, P: "src/github.com/pblaszczyk/...", C: ch[1], E: Write, }, Record: []Call{ { F: FuncWatch, P: "src/github.com/pblaszczyk", E: Create | Write, }, { F: FuncWatch, P: "src/github.com/pblaszczyk/qttu", E: Create | Write, }, { F: FuncRewatch, P: "src/github.com/pblaszczyk/qttu/include", E: Create | Rename, NE: Create | Rename | Write, }, { F: FuncRewatch, P: "src/github.com/pblaszczyk/qttu/include/qttu", E: Create | Rename, NE: Create | Rename | Write, }, { F: FuncWatch, P: "src/github.com/pblaszczyk/qttu/src", E: Create | Write, }, }, }, // i=8 { Call: Call{ F: FuncWatch, P: "src/github.com/pblaszczyk/qttu/include/...", C: ch[4], E: Write, }, Record: nil, }, // i=9 { Call: Call{ F: FuncWatch, P: "src/github.com/pblaszczyk/qttu", C: ch[3], E: Remove, }, Record: []Call{ { F: FuncRewatch, P: "src/github.com/pblaszczyk/qttu", E: Create | Write, NE: Create | Write | Remove, }, }, }, } n.ExpectRecordedCalls(watches[:]) events := [...]TCase{ // i=0 { Event: Call{P: "src/github.com/rjeczalik/fs/fs.go", E: Rename}, Receiver: Chans{ch[0]}, }, // i=1 { Event: Call{P: "src/github.com/rjeczalik/fs/fs.go", E: Create}, Receiver: nil, }, // i=2 { Event: Call{P: "src/github.com/rjeczalik/fs/cmd/cmd.go", E: Remove}, Receiver: Chans{ch[1]}, }, // i=3 { Event: Call{P: "src/github.com/rjeczalik/fs/cmd/doc.go", E: Write}, Receiver: nil, }, // i=4 { Event: Call{P: "src/github.com/rjeczalik/fs/cmd/mktree/main.go", E: Write}, Receiver: Chans{ch[2]}, }, // i=5 { Event: Call{P: "src/github.com/rjeczalik/fs/cmd/mktree/tree.go", E: Create}, Receiver: nil, }, // i=6 { Event: Call{P: "src/github.com/pblaszczyk/qttu/include/.lock", E: Create}, Receiver: Chans{ch[3]}, }, // i=7 { Event: Call{P: "src/github.com/pblaszczyk/qttu/include/qttu/detail/registry.hh", E: Write}, Receiver: Chans{ch[3], ch[1], ch[4]}, }, // i=8 { Event: Call{P: "src/github.com/pblaszczyk/qttu/include/qttu", E: Remove}, Receiver: nil, }, // i=9 { Event: Call{P: "src/github.com/pblaszczyk/qttu/include", E: Remove}, Receiver: Chans{ch[3]}, }, } n.ExpectTreeEvents(events[:], ch) stops := [...]RCase{ // i=0 { Call: Call{ F: FuncStop, C: ch[4], }, Record: nil, }, // i=1 { Call: Call{ F: FuncStop, C: ch[3], }, Record: []Call{ { F: FuncRewatch, P: "src/github.com/pblaszczyk/qttu", E: Create | Write | Remove, NE: Create | Write, }, }, }, // i=2 { Call: Call{ F: FuncStop, C: ch[2], }, Record: []Call{ { F: FuncRewatch, P: "src/github.com/rjeczalik/fs/cmd", E: Create | Remove | Rename, NE: Create | Remove, }, { F: FuncRewatch, P: "src/github.com/rjeczalik/fs/cmd/gotree", E: Create | Remove | Rename, NE: Create | Remove, }, { F: FuncRewatch, P: "src/github.com/rjeczalik/fs/cmd/mktree", E: Create | Remove | Rename | Write, NE: Create | Remove, }, }, }, // i=3 { Call: Call{ F: FuncStop, C: ch[1], }, Record: []Call{ { F: FuncUnwatch, P: "src/github.com/pblaszczyk", }, { F: FuncUnwatch, P: "src/github.com/pblaszczyk/qttu", }, { F: FuncRewatch, P: "src/github.com/pblaszczyk/qttu/include", E: Create | Rename | Write, NE: Create | Rename, }, { F: FuncRewatch, P: "src/github.com/pblaszczyk/qttu/include/qttu", E: Create | Rename | Write, NE: Create | Rename, }, { F: FuncRewatch, P: "src/github.com/pblaszczyk/qttu/include/qttu/detail", E: Create | Rename | Write, NE: Create | Rename, }, { F: FuncUnwatch, P: "src/github.com/pblaszczyk/qttu/src", }, { F: FuncUnwatch, P: "src/github.com/rjeczalik/fs/cmd", }, { F: FuncUnwatch, P: "src/github.com/rjeczalik/fs/cmd/gotree", }, { F: FuncUnwatch, P: "src/github.com/rjeczalik/fs/cmd/mktree", }, }, }, // i=4 { Call: Call{ F: FuncStop, C: ch[0], }, Record: []Call{ { F: FuncUnwatch, P: "src/github.com/pblaszczyk/qttu/include", }, { F: FuncUnwatch, P: "src/github.com/pblaszczyk/qttu/include/qttu", }, { F: FuncUnwatch, P: "src/github.com/pblaszczyk/qttu/include/qttu/detail", }, { F: FuncUnwatch, P: "src/github.com/rjeczalik/fs/fs.go", }, }, }, } n.ExpectRecordedCalls(stops[:]) n.Walk(func(nd node) error { if len(nd.Watch) != 0 { return fmt.Errorf("unexpected watchpoint: name=%s, eventset=%v (len=%d)", nd.Name, nd.Watch.Total(), len(nd.Watch)) } return nil }) } func TestNonrecursiveTreeInternal(t *testing.T) { n, c := NewNonrecursiveTreeTestC(t, "testdata/vfs.txt") ch := NewChans(5) watches := [...]RCase{ // i=0 { Call: Call{ F: FuncWatch, P: "src/github.com/rjeczalik/fs/cmd/...", C: ch[0], E: Remove, }, Record: []Call{ { F: FuncWatch, P: "src/github.com/rjeczalik/fs/cmd", E: Create | Remove, }, { F: FuncWatch, P: "src/github.com/rjeczalik/fs/cmd/gotree", E: Create | Remove, }, { F: FuncWatch, P: "src/github.com/rjeczalik/fs/cmd/mktree", E: Create | Remove, }, }, }, // i=1 { Call: Call{ F: FuncWatch, P: "src/github.com/ppknap/link/include/coost/...", C: ch[1], E: Create, }, Record: []Call{ { F: FuncWatch, P: "src/github.com/ppknap/link/include/coost", E: Create, }, { F: FuncWatch, P: "src/github.com/ppknap/link/include/coost/link", E: Create, }, { F: FuncWatch, P: "src/github.com/ppknap/link/include/coost/link/detail", E: Create, }, { F: FuncWatch, P: "src/github.com/ppknap/link/include/coost/link/detail/stdhelpers", E: Create, }, }, }, } n.ExpectRecordedCalls(watches[:]) events := [...]TCase{ // i=0 { Event: Call{P: "src/github.com/rjeczalik/fs/cmd/dir", E: Create, Dir: true}, Receiver: Chans{c}, }, // i=1 { Event: Call{P: "src/github.com/rjeczalik/fs/cmd/dir/another", E: Create, Dir: true}, Receiver: Chans{c}, }, // i=2 { Event: Call{P: "src/github.com/rjeczalik/fs/cmd/file", E: Create, Dir: false}, Receiver: nil, }, // i=3 { Event: Call{P: "src/github.com/ppknap/link/include/coost/dir", E: Create, Dir: true}, Receiver: Chans{ch[1], c}, }, // i=4 { Event: Call{P: "src/github.com/ppknap/link/include/coost/dir/another", E: Create, Dir: true}, Receiver: Chans{ch[1], c}, }, // i=5 { Event: Call{P: "src/github.com/ppknap/link/include/coost/file", E: Create, Dir: false}, Receiver: Chans{ch[1]}, }, // i=6 { Event: Call{P: "src/github.com/rjeczalik/fs/cmd/mktree", E: Remove}, Receiver: Chans{ch[0]}, }, // i=7 { Event: Call{P: "src/github.com/rjeczalik/fs/cmd/rmtree", E: Create, Dir: true}, Receiver: Chans{c}, }, } n.ExpectTreeEvents(events[:], ch) } notify-0.9.3/tree_recursive.go000066400000000000000000000213461436002677300164260ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. package notify import "sync" // watchAdd TODO(rjeczalik) func watchAdd(nd node, c chan<- EventInfo, e Event) eventDiff { diff := nd.Watch.Add(c, e) if wp := nd.Child[""].Watch; len(wp) != 0 { e = wp.Total() diff[0] |= e diff[1] |= e if diff[0] == diff[1] { return none } } return diff } // watchAddInactive TODO(rjeczalik) func watchAddInactive(nd node, c chan<- EventInfo, e Event) eventDiff { wp := nd.Child[""].Watch if wp == nil { wp = make(watchpoint) nd.Child[""] = node{Watch: wp} } diff := wp.Add(c, e) e = nd.Watch.Total() diff[0] |= e diff[1] |= e if diff[0] == diff[1] { return none } return diff } // watchCopy TODO(rjeczalik) func watchCopy(src, dst node) { for c, e := range src.Watch { if c == nil { continue } watchAddInactive(dst, c, e) } if wpsrc := src.Child[""].Watch; len(wpsrc) != 0 { wpdst := dst.Child[""].Watch for c, e := range wpsrc { if c == nil { continue } wpdst.Add(c, e) } } } // watchDel TODO(rjeczalik) func watchDel(nd node, c chan<- EventInfo, e Event) eventDiff { diff := nd.Watch.Del(c, e) if wp := nd.Child[""].Watch; len(wp) != 0 { diffInactive := wp.Del(c, e) e = wp.Total() // TODO(rjeczalik): add e if e != all? diff[0] |= diffInactive[0] | e diff[1] |= diffInactive[1] | e if diff[0] == diff[1] { return none } } return diff } // watchTotal TODO(rjeczalik) func watchTotal(nd node) Event { e := nd.Watch.Total() if wp := nd.Child[""].Watch; len(wp) != 0 { e |= wp.Total() } return e } // watchIsRecursive TODO(rjeczalik) func watchIsRecursive(nd node) bool { ok := nd.Watch.IsRecursive() // TODO(rjeczalik): add a test for len(wp) != 0 change the condition. if wp := nd.Child[""].Watch; len(wp) != 0 { // If a watchpoint holds inactive watchpoints, it means it's a parent // one, which is recursive by nature even though it may be not recursive // itself. ok = true } return ok } // recursiveTree TODO(rjeczalik) type recursiveTree struct { rw sync.RWMutex // protects root root root // TODO(rjeczalik): merge watcher + recursiveWatcher after #5 and #6 w interface { watcher recursiveWatcher } c chan EventInfo } // newRecursiveTree TODO(rjeczalik) func newRecursiveTree(w recursiveWatcher, c chan EventInfo) *recursiveTree { t := &recursiveTree{ root: root{nd: newnode("")}, w: struct { watcher recursiveWatcher }{w.(watcher), w}, c: c, } go t.dispatch() return t } // dispatch TODO(rjeczalik) func (t *recursiveTree) dispatch() { for ei := range t.c { dbgprintf("dispatching %v on %q", ei.Event(), ei.Path()) go func(ei EventInfo) { nd, ok := node{}, false dir, base := split(ei.Path()) fn := func(it node, isbase bool) error { if isbase { nd = it } else { it.Watch.Dispatch(ei, recursive) } return nil } t.rw.RLock() defer t.rw.RUnlock() // Notify recursive watchpoints found on the path. if err := t.root.WalkPath(dir, fn); err != nil { dbgprint("dispatch did not reach leaf:", err) return } // Notify parent watchpoint. nd.Watch.Dispatch(ei, 0) // If leaf watchpoint exists, notify it. if nd, ok = nd.Child[base]; ok { nd.Watch.Dispatch(ei, 0) } }(ei) } } // Watch TODO(rjeczalik) func (t *recursiveTree) Watch(path string, c chan<- EventInfo, events ...Event) error { if c == nil { panic("notify: Watch using nil channel") } // Expanding with empty event set is a nop. if len(events) == 0 { return nil } path, isrec, err := cleanpath(path) if err != nil { return err } eventset := joinevents(events) if isrec { eventset |= recursive } t.rw.Lock() defer t.rw.Unlock() // case 1: cur is a child // // Look for parent watch which already covers the given path. parent := node{} self := false err = t.root.WalkPath(path, func(nd node, isbase bool) error { if watchTotal(nd) != 0 { parent = nd self = isbase return errSkip } return nil }) cur := t.root.Add(path) // add after the walk, so it's less to traverse if err == nil && parent.Watch != nil { // Parent watch found. Register inactive watchpoint, so we have enough // information to shrink the eventset on eventual Stop. // return t.resetwatchpoint(parent, parent, c, eventset|inactive) var diff eventDiff if self { diff = watchAdd(cur, c, eventset) } else { diff = watchAddInactive(parent, c, eventset) } switch { case diff == none: // the parent watchpoint already covers requested subtree with its // eventset case diff[0] == 0: // TODO(rjeczalik): cleanup this panic after implementation is stable panic("dangling watchpoint: " + parent.Name) default: if isrec || watchIsRecursive(parent) { err = t.w.RecursiveRewatch(parent.Name, parent.Name, diff[0], diff[1]) } else { err = t.w.Rewatch(parent.Name, diff[0], diff[1]) } if err != nil { watchDel(parent, c, diff.Event()) return err } watchAdd(cur, c, eventset) // TODO(rjeczalik): account top-most path for c return nil } if !self { watchAdd(cur, c, eventset) } return nil } // case 2: cur is new parent // // Look for children nodes, unwatch n-1 of them and rewatch the last one. var children []node fn := func(nd node) error { if len(nd.Watch) == 0 { return nil } children = append(children, nd) return errSkip } switch must(cur.Walk(fn)); len(children) { case 0: // no child watches, cur holds a new watch case 1: watchAdd(cur, c, eventset) // TODO(rjeczalik): update cache c subtree root? watchCopy(children[0], cur) err = t.w.RecursiveRewatch(children[0].Name, cur.Name, watchTotal(children[0]), watchTotal(cur)) if err != nil { // Clean inactive watchpoint. The c chan did not exist before. cur.Child[""] = node{} delete(cur.Watch, c) return err } return nil default: watchAdd(cur, c, eventset) // Copy children inactive watchpoints to the new parent. for _, nd := range children { watchCopy(nd, cur) } // Watch parent subtree. if err = t.w.RecursiveWatch(cur.Name, watchTotal(cur)); err != nil { // Clean inactive watchpoint. The c chan did not exist before. cur.Child[""] = node{} delete(cur.Watch, c) return err } // Unwatch children subtrees. var e error for _, nd := range children { if watchIsRecursive(nd) { e = t.w.RecursiveUnwatch(nd.Name) } else { e = t.w.Unwatch(nd.Name) } if e != nil { err = nonil(err, e) // TODO(rjeczalik): child is still watched, warn all its watchpoints // about possible duplicate events via Error event } } return err } // case 3: cur is new, alone node switch diff := watchAdd(cur, c, eventset); { case diff == none: // TODO(rjeczalik): cleanup this panic after implementation is stable panic("watch requested but no parent watchpoint found: " + cur.Name) case diff[0] == 0: if isrec { err = t.w.RecursiveWatch(cur.Name, diff[1]) } else { err = t.w.Watch(cur.Name, diff[1]) } if err != nil { watchDel(cur, c, diff.Event()) return err } default: // TODO(rjeczalik): cleanup this panic after implementation is stable panic("watch requested but no parent watchpoint found: " + cur.Name) } return nil } // Stop TODO(rjeczalik) // // TODO(rjeczalik): Split parent watchpoint - transfer watches to children // if parent is no longer needed. This carries a risk that underlying // watcher calls could fail - reconsider if it's worth the effort. func (t *recursiveTree) Stop(c chan<- EventInfo) { var err error fn := func(nd node) (e error) { diff := watchDel(nd, c, all) switch { case diff == none && watchTotal(nd) == 0: // TODO(rjeczalik): There's no watchpoints deeper in the tree, // probably we should remove the nodes as well. return nil case diff == none: // Removing c from nd does not require shrinking its eventset. case diff[1] == 0: if watchIsRecursive(nd) { e = t.w.RecursiveUnwatch(nd.Name) } else { e = t.w.Unwatch(nd.Name) } default: if watchIsRecursive(nd) { e = t.w.RecursiveRewatch(nd.Name, nd.Name, diff[0], diff[1]) } else { e = t.w.Rewatch(nd.Name, diff[0], diff[1]) } } fn := func(nd node) error { watchDel(nd, c, all) return nil } err = nonil(err, e, nd.Walk(fn)) // TODO(rjeczalik): if e != nil store dummy chan in nd.Watch just to // retry un/rewatching next time and/or let the user handle the failure // vie Error event? return errSkip } t.rw.Lock() e := t.root.Walk("", fn) // TODO(rjeczalik): use max root per c t.rw.Unlock() if e != nil { err = nonil(err, e) } dbgprintf("Stop(%p) error: %v\n", c, err) } // Close TODO(rjeczalik) func (t *recursiveTree) Close() error { err := t.w.Close() close(t.c) return err } notify-0.9.3/tree_recursive_test.go000066400000000000000000000225021436002677300174600ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. package notify import "testing" func TestRecursiveTree(t *testing.T) { n := NewRecursiveTreeTest(t, "testdata/vfs.txt") ch := NewChans(5) watches := [...]RCase{ // i=0 { Call: Call{ F: FuncWatch, P: "src/github.com/rjeczalik/fs/fs.go", C: ch[0], E: Create, }, Record: []Call{ { F: FuncWatch, P: "src/github.com/rjeczalik/fs/fs.go", E: Create, }, }, }, // i=1 { Call: Call{ F: FuncWatch, P: "src/github.com/rjeczalik/fs/cmd/...", C: ch[1], E: Remove, }, Record: []Call{ { F: FuncRecursiveWatch, P: "src/github.com/rjeczalik/fs/cmd", E: Remove, }, }, }, // i=2 { Call: Call{ F: FuncWatch, P: "src/github.com/rjeczalik/fs", C: ch[2], E: Rename, }, Record: []Call{ { F: FuncRecursiveWatch, P: "src/github.com/rjeczalik/fs", E: Create | Remove | Rename, }, { F: FuncRecursiveUnwatch, P: "src/github.com/rjeczalik/fs/cmd", }, { F: FuncUnwatch, P: "src/github.com/rjeczalik/fs/fs.go", }, }, }, // i=3 { Call: Call{ F: FuncWatch, P: "src/github.com/ppknap/link/README.md", C: ch[0], E: Create, }, Record: []Call{ { F: FuncWatch, P: "src/github.com/ppknap/link/README.md", E: Create, }, }, }, // i=4 { Call: Call{ F: FuncWatch, P: "src/github.com/ppknap/link/include/...", C: ch[3], E: Remove, }, Record: []Call{ { F: FuncRecursiveWatch, P: "src/github.com/ppknap/link/include", E: Remove, }, }, }, // i=5 { Call: Call{ F: FuncWatch, P: "src/github.com/ppknap/link/include", C: ch[0], E: Write, }, Record: []Call{ { F: FuncRecursiveRewatch, P: "src/github.com/ppknap/link/include", NP: "src/github.com/ppknap/link/include", E: Remove, NE: Remove | Write, }, }, }, // i=6 { Call: Call{ F: FuncWatch, P: "src/github.com/ppknap/link/test/Jamfile.jam", C: ch[0], E: Rename, }, Record: []Call{ { F: FuncWatch, P: "src/github.com/ppknap/link/test/Jamfile.jam", E: Rename, }, }, }, // i=7 { Call: Call{ F: FuncWatch, P: "src/github.com/ppknap/link/test/Jamfile.jam", C: ch[0], E: Create, }, Record: []Call{ { F: FuncRewatch, P: "src/github.com/ppknap/link/test/Jamfile.jam", E: Rename, NE: Rename | Create, }, }, }, // i=8 { Call: Call{ F: FuncWatch, P: "src/github.com/ppknap/...", C: ch[0], E: Create, }, Record: []Call{ { F: FuncRecursiveWatch, P: "src/github.com/ppknap", E: Create | Remove | Write | Rename, }, { F: FuncUnwatch, P: "src/github.com/ppknap/link/README.md", }, { F: FuncRecursiveUnwatch, P: "src/github.com/ppknap/link/include", }, { F: FuncUnwatch, P: "src/github.com/ppknap/link/test/Jamfile.jam", }, }, }, // i=9 { Call: Call{ F: FuncWatch, P: "src/github.com/rjeczalik/fs/README.md", C: ch[0], E: Rename, }, Record: nil, }, // i=10 { Call: Call{ F: FuncWatch, P: "src/github.com/rjeczalik/fs/cmd/gotree", C: ch[2], E: Create | Remove, }, Record: nil, }, // i=11 { Call: Call{ F: FuncWatch, P: "src/github.com/pblaszczyk/qttu/src/main.cc", C: ch[0], E: Create, }, Record: []Call{ { F: FuncWatch, P: "src/github.com/pblaszczyk/qttu/src/main.cc", E: Create, }, }, }, // i=12 { Call: Call{ F: FuncWatch, P: "src/github.com/pblaszczyk/qttu/src/main.cc", C: ch[0], E: Remove, }, Record: []Call{ { F: FuncRewatch, P: "src/github.com/pblaszczyk/qttu/src/main.cc", E: Create, NE: Create | Remove, }, }, }, // i=13 { Call: Call{ F: FuncWatch, P: "src/github.com/pblaszczyk/qttu/src/main.cc", C: ch[0], E: Create | Remove, }, Record: nil, }, // i=14 { Call: Call{ F: FuncWatch, P: "src/github.com/pblaszczyk/qttu/src", C: ch[0], E: Create, }, Record: []Call{ { F: FuncRecursiveRewatch, P: "src/github.com/pblaszczyk/qttu/src/main.cc", NP: "src/github.com/pblaszczyk/qttu/src", E: Create | Remove, NE: Create | Remove, }, }, }, // i=15 { Call: Call{ F: FuncWatch, P: "src/github.com/pblaszczyk/qttu", C: ch[4], E: Write, }, Record: []Call{ { F: FuncRecursiveRewatch, P: "src/github.com/pblaszczyk/qttu/src", NP: "src/github.com/pblaszczyk/qttu", E: Create | Remove, NE: Create | Remove | Write, }, }, }, // i=16 { Call: Call{ F: FuncWatch, P: "src/github.com/rjeczalik/fs/fs.go", C: ch[3], E: Rename, }, Record: nil, }, } n.ExpectRecordedCalls(watches[:]) events := [...]TCase{ // i=0 { Event: Call{P: "src/github.com/rjeczalik/fs/fs.go", E: Rename}, Receiver: Chans{ch[2], ch[3]}, }, // i=1 { Event: Call{P: "src/github.com/rjeczalik/fs/fs.go", E: Create}, Receiver: Chans{ch[0]}, }, // i=2 { Event: Call{P: "src/github.com/rjeczalik/fs/fs.go/file", E: Create}, Receiver: Chans{ch[0]}, }, // i=3 { Event: Call{P: "src/github.com/rjeczalik/fs", E: Rename}, Receiver: Chans{ch[2]}, }, // i=4 { Event: Call{P: "src/github.com/rjeczalik/fs/fs_test.go", E: Rename}, Receiver: Chans{ch[2]}, }, // i=5 { Event: Call{P: "src/github.com/rjeczalik/fs/cmd/mktree/main.go", E: Remove}, Receiver: Chans{ch[1]}, }, // i=6 { Event: Call{P: "src/github.com/rjeczalik/fs/cmd/gotree", E: Remove}, Receiver: Chans{ch[1], ch[2]}, }, // i=7 { Event: Call{P: "src/github.com/rjeczalik/fs/cmd", E: Remove}, Receiver: Chans{ch[1]}, }, // i=8 { Event: Call{P: "src/github.com/rjeczalik/fs/fs.go/file", E: Write}, Receiver: nil, }, // i=9 { Event: Call{P: "src/github.com/rjeczalik/fs/fs.go/file", E: Write}, Receiver: nil, }, // i=10 { Event: Call{P: "src/github.com/rjeczalik/fs", E: Remove}, Receiver: nil, }, // i=11 { Event: Call{P: "src/github.com/rjeczalik/fs/cmd", E: Rename}, Receiver: Chans{ch[2]}, }, // i=12 { Event: Call{P: "src/github.com/rjeczalik/fs/cmd/mktree/main.go", E: Write}, Receiver: nil, }, // i=13 { Event: Call{P: "src/github.com/rjeczalik/fs/cmd/gotree", E: Rename}, Receiver: nil, }, // i=14 { Event: Call{P: "src/github.com/rjeczalik/fs/cmd/file", E: Rename}, Receiver: nil, }, // i=15 { Event: Call{P: "src/github.com/rjeczalik/fs/fs.go", E: Rename}, Receiver: Chans{ch[2], ch[3]}, }, } n.ExpectTreeEvents(events[:], ch) stops := [...]RCase{ // i=0 { Call: Call{ F: FuncStop, C: ch[1], }, Record: nil, }, { Call: Call{ F: FuncStop, C: ch[4], }, Record: []Call{ { F: FuncRecursiveRewatch, P: "src/github.com/pblaszczyk/qttu", NP: "src/github.com/pblaszczyk/qttu", E: Create | Remove | Write, NE: Create | Remove, }, }, }, } n.ExpectRecordedCalls(stops[:]) } func TestRecursiveTreeWatchInactiveMerge(t *testing.T) { n := NewRecursiveTreeTest(t, "testdata/vfs.txt") ch := NewChans(1) watches := [...]RCase{ // i=0 { Call: Call{ F: FuncWatch, P: "src/github.com/rjeczalik/fs", C: ch[0], E: Create, }, Record: []Call{ { F: FuncWatch, P: "src/github.com/rjeczalik/fs", E: Create, }, }, }, // i=1 { Call: Call{ F: FuncWatch, P: "src/github.com/rjeczalik/fs/cmd/gotree/...", C: ch[0], E: Remove, }, Record: []Call{ { F: FuncRecursiveRewatch, P: "src/github.com/rjeczalik/fs", NP: "src/github.com/rjeczalik/fs", E: Create, NE: Create | Remove, }, }, }, } n.ExpectRecordedCalls(watches[:]) events := [...]TCase{ // i=0 { Event: Call{P: "src/github.com/rjeczalik/fs/.fs.go.swp", E: Create}, Receiver: Chans{ch[0]}, }, // i=1 { Event: Call{P: "src/github.com/rjeczalik/fs/.fs.go.swp", E: Remove}, Receiver: nil, }, // i=2 { Event: Call{P: "src/github.com/rjeczalik/fs", E: Remove}, Receiver: nil, }, // i=3 { Event: Call{P: "src/github.com/rjeczalik/fs/cmd/gotree/main.go", E: Remove}, Receiver: Chans{ch[0]}, }, } n.ExpectTreeEvents(events[:], ch) } func TestRecursiveTree_Windows(t *testing.T) { n := NewRecursiveTreeTest(t, "testdata/vfs.txt") const ChangeFileName = Event(0x1) ch := NewChans(1) watches := [...]RCase{ // i=0 { Call: Call{ F: FuncWatch, P: "src/github.com/rjeczalik/fs", C: ch[0], E: ChangeFileName, }, Record: []Call{ { F: FuncWatch, P: "src/github.com/rjeczalik/fs", E: ChangeFileName, }, }, }, } n.ExpectRecordedCalls(watches[:]) events := [...]TCase{ // i=0 { Event: Call{P: "src/github.com/rjeczalik/fs", E: ChangeFileName}, Receiver: Chans{ch[0]}, }, // i=1 { Event: Call{P: "src/github.com/rjeczalik/fs/fs.go", E: ChangeFileName}, Receiver: Chans{ch[0]}, }, } n.ExpectTreeEvents(events[:], ch) } notify-0.9.3/util.go000066400000000000000000000056711436002677300143600ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. package notify import ( "errors" "os" "path/filepath" "strings" ) const all = ^Event(0) const sep = string(os.PathSeparator) var errDepth = errors.New("exceeded allowed iteration count (circular symlink?)") func min(i, j int) int { if i > j { return j } return i } func max(i, j int) int { if i < j { return j } return i } // must panics if err is non-nil. func must(err error) { if err != nil { panic(err) } } // nonil gives first non-nil error from the given arguments. func nonil(err ...error) error { for _, err := range err { if err != nil { return err } } return nil } func cleanpath(path string) (realpath string, isrec bool, err error) { if strings.HasSuffix(path, "...") { isrec = true path = path[:len(path)-3] } if path, err = filepath.Abs(path); err != nil { return "", false, err } if path, err = canonical(path); err != nil { return "", false, err } return path, isrec, nil } // canonical resolves any symlink in the given path and returns it in a clean form. // It expects the path to be absolute. It fails to resolve circular symlinks by // maintaining a simple iteration limit. func canonical(p string) (string, error) { p, err := filepath.Abs(p) if err != nil { return "", err } for i, j, depth := 1, 0, 1; i < len(p); i, depth = i+1, depth+1 { if depth > 128 { return "", &os.PathError{Op: "canonical", Path: p, Err: errDepth} } if j = strings.IndexRune(p[i:], '/'); j == -1 { j, i = i, len(p) } else { j, i = i, i+j } fi, err := os.Lstat(p[:i]) if err != nil { return "", err } if fi.Mode()&os.ModeSymlink == os.ModeSymlink { s, err := os.Readlink(p[:i]) if err != nil { return "", err } if filepath.IsAbs(s) { p = "/" + s + p[i:] } else { p = p[:j] + s + p[i:] } i = 1 // no guarantee s is canonical, start all over } } return filepath.Clean(p), nil } func joinevents(events []Event) (e Event) { if len(events) == 0 { e = All } else { for _, event := range events { e |= event } } return } func split(s string) (string, string) { if i := lastIndexSep(s); i != -1 { return s[:i], s[i+1:] } return "", s } func base(s string) string { if i := lastIndexSep(s); i != -1 { return s[i+1:] } return s } // indexrel returns the index of the first char of name that is // below/relative to root. It returns -1 if name is not a child of root. func indexrel(root, name string) int { if n, m := len(root), len(name); m > n && name[:n] == root && name[n] == os.PathSeparator { return n + 1 } return -1 } func indexSep(s string) int { for i := 0; i < len(s); i++ { if s[i] == os.PathSeparator { return i } } return -1 } func lastIndexSep(s string) int { for i := len(s) - 1; i >= 0; i-- { if s[i] == os.PathSeparator { return i } } return -1 } notify-0.9.3/util_darwin_test.go000066400000000000000000000016531436002677300167570ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build darwin // +build darwin package notify import ( "os" "testing" ) func TestCanonicalDarwin(t *testing.T) { cases := [...]caseCanonical{ {"/etc", "/private/etc"}, {"/etc/defaults", "/private/etc/defaults"}, {"/etc/hosts", "/private/etc/hosts"}, {"/tmp", "/private/tmp"}, {"/var", "/private/var"}, } testCanonical(t, cases[:]) } func TestCanonicalDarwinMultiple(t *testing.T) { etcsym, err := symlink("/etc", "") if err != nil { t.Fatal(err) } tmpsym, err := symlink("/tmp", "") if err != nil { t.Fatal(nonil(err, os.Remove(etcsym))) } defer removeall(etcsym, tmpsym) cases := [...]caseCanonical{ {etcsym, "/private/etc"}, {etcsym + "/hosts", "/private/etc/hosts"}, {tmpsym, "/private/tmp"}, } testCanonical(t, cases[:]) } notify-0.9.3/util_test.go000066400000000000000000000072641436002677300154170ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. package notify import ( "path/filepath" "testing" ) type caseCanonical struct { path string full string } func testCanonical(t *testing.T, cases []caseCanonical) { for i, cas := range cases { full, err := canonical(cas.path) if err != nil { t.Errorf("want err=nil; got %v (i=%d)", err, i) continue } if full != cas.full { t.Errorf("want full=%q; got %q (i=%d)", cas.full, full, i) continue } } } func TestCanonicalNoSymlink(t *testing.T) { td := filepath.Join(wd, "testdata") cases := [...]caseCanonical{ {".", wd}, {"testdata", td}, {filepath.Join("testdata", ".."), wd}, } testCanonical(t, cases[:]) } func TestJoinevents(t *testing.T) { cases := [...]struct { evs []Event ev Event }{ 0: {nil, All}, 1: {[]Event{}, All}, 2: {[]Event{Create}, Create}, 3: {[]Event{Rename}, Rename}, 4: {[]Event{Create, Write, Remove}, Create | Write | Remove}, } for i, cas := range cases { if ev := joinevents(cas.evs); ev != cas.ev { t.Errorf("want event=%v; got %v (i=%d)", cas.ev, ev, i) } } } func TestTreeSplit(t *testing.T) { cases := [...]struct { path string dir string base string }{ {"/github.com/rjeczalik/fakerpc", "/github.com/rjeczalik", "fakerpc"}, {"/home/rjeczalik/src", "/home/rjeczalik", "src"}, {"/Users/pknap/porn/gopher.avi", "/Users/pknap/porn", "gopher.avi"}, {"C:/Documents and Users", "C:", "Documents and Users"}, {"C:/Documents and Users/pblaszczyk/wiertarka.exe", "C:/Documents and Users/pblaszczyk", "wiertarka.exe"}, {"/home/(╯°□°）╯︵ ┻━┻", "/home", "(╯°□°）╯︵ ┻━┻"}, } for i, cas := range cases { dir, base := split(filepath.FromSlash(cas.path)) if want := filepath.FromSlash(cas.dir); dir != want { t.Errorf("want dir=%s; got %s (i=%d)", want, dir, i) } if want := filepath.FromSlash(cas.base); base != want { t.Errorf("want base=%s; got %s (i=%d)", want, base, i) } } } func TestTreeBase(t *testing.T) { cases := [...]struct { path string base string }{ {"/github.com/rjeczalik/fakerpc", "fakerpc"}, {"/home/rjeczalik/src", "src"}, {"/Users/pknap/porn/gopher.avi", "gopher.avi"}, {"C:/Documents and Users", "Documents and Users"}, {"C:/Documents and Users/pblaszczyk/wiertarka.exe", "wiertarka.exe"}, {"/home/(╯°□°）╯︵ ┻━┻", "(╯°□°）╯︵ ┻━┻"}, } for i, cas := range cases { if base := base(filepath.FromSlash(cas.path)); base != cas.base { t.Errorf("want base=%s; got %s (i=%d)", cas.base, base, i) } } } func TestTreeIndexSep(t *testing.T) { cases := [...]struct { path string n int }{ {"github.com/rjeczalik/fakerpc", 10}, {"home/rjeczalik/src", 4}, {"Users/pknap/porn/gopher.avi", 5}, {"C:/Documents and Users", 2}, {"Documents and Users/pblaszczyk/wiertarka.exe", 19}, {"(╯°□°）╯︵ ┻━┻/Downloads", 30}, } for i, cas := range cases { if n := indexSep(filepath.FromSlash(cas.path)); n != cas.n { t.Errorf("want n=%d; got %d (i=%d)", cas.n, n, i) } } } func TestTreeLastIndexSep(t *testing.T) { cases := [...]struct { path string n int }{ {"github.com/rjeczalik/fakerpc", 20}, {"home/rjeczalik/src", 14}, {"Users/pknap/porn/gopher.avi", 16}, {"C:/Documents and Users", 2}, {"Documents and Users/pblaszczyk/wiertarka.exe", 30}, {"/home/(╯°□°）╯︵ ┻━┻", 5}, } for i, cas := range cases { if n := lastIndexSep(filepath.FromSlash(cas.path)); n != cas.n { t.Errorf("want n=%d; got %d (i=%d)", cas.n, n, i) } } } func TestCleanpath(t *testing.T) { t.Skip("TODO(rjeczalik)") } notify-0.9.3/util_unix_test.go000066400000000000000000000057321436002677300164600ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build !windows // +build !windows package notify import ( "os" "path/filepath" "testing" ) func tmpfile(s string) (string, error) { f, err := os.CreateTemp(filepath.Split(s)) if err != nil { return "", err } if err = nonil(f.Sync(), f.Close()); err != nil { return "", err } return f.Name(), nil } func symlink(src, dst string) (string, error) { name, err := tmpfile(dst) if err != nil { return "", err } if err = nonil(os.Remove(name), os.Symlink(src, name)); err != nil { return "", err } return name, nil } func removeall(s ...string) { for _, s := range s { os.Remove(s) } } func TestCanonical(t *testing.T) { wd, err := os.Getwd() if err != nil { t.Fatalf("os.Getwd()=%v", err) } wdsym, err := symlink(wd, "") if err != nil { t.Fatalf(`symlink(%q, "")=%v`, wd, err) } td := filepath.Join(wd, "testdata") tdsym, err := symlink(td, td) if err != nil { t.Errorf("symlink(%q, %q)=%v", td, td, nonil(err, os.Remove(wdsym))) } defer removeall(wdsym, tdsym) vfstxt := filepath.Join(td, "vfs.txt") cases := [...]caseCanonical{ {wdsym, wd}, {tdsym, td}, {filepath.Join(wdsym, "notify.go"), filepath.Join(wd, "notify.go")}, {filepath.Join(tdsym, "vfs.txt"), vfstxt}, {filepath.Join(wdsym, filepath.Base(tdsym), "vfs.txt"), vfstxt}, } testCanonical(t, cases[:]) } func TestCanonicalCircular(t *testing.T) { tmp1, err := tmpfile("circular") if err != nil { t.Fatal(err) } tmp2, err := tmpfile("circular") if err != nil { t.Fatal(nonil(err, os.Remove(tmp1))) } defer removeall(tmp1, tmp2) // Symlink tmp1 -> tmp2. if err = nonil(os.Remove(tmp1), os.Symlink(tmp2, tmp1)); err != nil { t.Fatal(err) } // Symlnik tmp2 -> tmp1. if err = nonil(os.Remove(tmp2), os.Symlink(tmp1, tmp2)); err != nil { t.Fatal(err) } if _, err = canonical(tmp1); err == nil { t.Fatalf("want canonical(%q)!=nil", tmp1) } if _, ok := err.(*os.PathError); !ok { t.Fatalf("want canonical(%q)=os.PathError; got %T", tmp1, err) } } // issue #83 func TestCanonical_RelativeSymlink(t *testing.T) { dir, err := os.MkdirTemp(wd, "") if err != nil { t.Fatalf("TempDir()=%v", err) } var ( path = filepath.Join(dir, filepath.FromSlash("a/b/c/d/e/f")) realpath = filepath.Join(dir, filepath.FromSlash("a/b/x/y/z/d/e/f")) rel = filepath.FromSlash("x/y/z/../z/../z") chdir = filepath.Join(dir, filepath.FromSlash("a/b")) ) defer os.RemoveAll(dir) if err = os.MkdirAll(realpath, 0755); err != nil { t.Fatalf("MkdirAll()=%v", err) } if err := os.Chdir(chdir); err != nil { t.Fatalf("Chdir()=%v", err) } if err := nonil(os.Symlink(rel, "c"), os.Chdir(wd)); err != nil { t.Fatalf("Symlink()=%v", err) } got, err := canonical(path) if err != nil { t.Fatalf("canonical(%s)=%v", path, err) } if got != realpath { t.Fatalf("want canonical()=%s; got %s", realpath, got) } } notify-0.9.3/watcher.go000066400000000000000000000071341436002677300150340ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. package notify import "errors" var ( errAlreadyWatched = errors.New("path is already watched") errNotWatched = errors.New("path is not being watched") errInvalidEventSet = errors.New("invalid event set provided") ) // Watcher is a intermediate interface for wrapping inotify, ReadDirChangesW, // FSEvents, kqueue and poller implementations. // // The watcher implementation is expected to do its own mapping between paths and // create watchers if underlying event notification does not support it. For // the ease of implementation it is guaranteed that paths provided via Watch and // Unwatch methods are absolute and clean. type watcher interface { // Watch requests a watcher creation for the given path and given event set. Watch(path string, event Event) error // Unwatch requests a watcher deletion for the given path and given event set. Unwatch(path string) error // Rewatch provides a functionality for modifying existing watch-points, like // expanding its event set. // // Rewatch modifies existing watch-point under for the given path. It passes // the existing event set currently registered for the given path, and the // new, requested event set. // // It is guaranteed that Tree will not pass to Rewatch zero value for any // of its arguments. If old == new and watcher can be upgraded to // recursiveWatcher interface, a watch for the corresponding path is expected // to be changed from recursive to the non-recursive one. Rewatch(path string, old, new Event) error // Close unwatches all paths that are registered. When Close returns, it // is expected it will report no more events. Close() error } // RecursiveWatcher is an interface for a Watcher for those OS, which do support // recursive watching over directories. type recursiveWatcher interface { RecursiveWatch(path string, event Event) error // RecursiveUnwatch removes a recursive watch-point given by the path. For // native recursive implementation there is no difference in functionality // between Unwatch and RecursiveUnwatch, however for those platforms, that // requires emulation for recursive watch-points, the implementation differs. RecursiveUnwatch(path string) error // RecursiveRewatcher provides a functionality for modifying and/or relocating // existing recursive watch-points. // // To relocate a watch-point means to unwatch oldpath and set a watch-point on // newpath. // // To modify a watch-point means either to expand or shrink its event set. // // Tree can want to either relocate, modify or relocate and modify a watch-point // via single RecursiveRewatch call. // // If oldpath == newpath, the watch-point is expected to change its event set value // from oldevent to newevent. // // If oldevent == newevent, the watch-point is expected to relocate from oldpath // to the newpath. // // If oldpath != newpath and oldevent != newevent, the watch-point is expected // to relocate from oldpath to the newpath first and then change its event set // value from oldevent to the newevent. In other words the end result must be // a watch-point set on newpath with newevent value of its event set. // // It is guaranteed that Tree will not pass to RecurisveRewatcha zero value // for any of its arguments. If oldpath == newpath and oldevent == newevent, // a watch for the corresponding path is expected to be changed for // non-recursive to the recursive one. RecursiveRewatch(oldpath, newpath string, oldevent, newevent Event) error } notify-0.9.3/watcher_fen.go000066400000000000000000000100501436002677300156530ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build solaris || illumos // +build solaris illumos package notify import ( "fmt" "os" "syscall" ) // newTrigger returns implementation of trigger. func newTrigger(pthLkp map[string]*watched) trigger { return &fen{ pthLkp: pthLkp, cf: newCfen(), } } // fen is a structure implementing trigger for FEN. type fen struct { // p is a FEN port identifier p int // pthLkp is a structure mapping monitored files/dir with data about them, // shared with parent trg structure pthLkp map[string]*watched // cf wraps C operations for FEN cf cfen } // watched is a data structure representing watched file/directory. type watched struct { trgWatched } // Stop implements trigger. func (f *fen) Stop() error { return f.cf.portAlert(f.p) } // Close implements trigger. func (f *fen) Close() (err error) { return syscall.Close(f.p) } // NewWatched implements trigger. func (*fen) NewWatched(p string, fi os.FileInfo) (*watched, error) { return &watched{trgWatched{p: p, fi: fi}}, nil } // Record implements trigger. func (f *fen) Record(w *watched) { f.pthLkp[w.p] = w } // Del implements trigger. func (f *fen) Del(w *watched) { delete(f.pthLkp, w.p) } func inter2pe(n interface{}) PortEvent { pe, ok := n.(PortEvent) if !ok { panic(fmt.Sprintf("fen: type should be PortEvent, %T instead", n)) } return pe } // Watched implements trigger. func (f *fen) Watched(n interface{}) (*watched, int64, error) { pe := inter2pe(n) fo, ok := pe.PortevObject.(*FileObj) if !ok || fo == nil { panic(fmt.Sprintf("fen: type should be *FileObj, %T instead", fo)) } w, ok := f.pthLkp[fo.Name] if !ok { return nil, 0, errNotWatched } return w, int64(pe.PortevEvents), nil } // init initializes FEN. func (f *fen) Init() (err error) { f.p, err = f.cf.portCreate() return } func fi2fo(fi os.FileInfo, p string) FileObj { st, ok := fi.Sys().(*syscall.Stat_t) if !ok { panic(fmt.Sprintf("fen: type should be *syscall.Stat_t, %T instead", st)) } return FileObj{Name: p, Atim: st.Atim, Mtim: st.Mtim, Ctim: st.Ctim} } // Unwatch implements trigger. func (f *fen) Unwatch(w *watched) error { return f.cf.portDissociate(f.p, FileObj{Name: w.p}) } // Watch implements trigger. func (f *fen) Watch(fi os.FileInfo, w *watched, e int64) error { return f.cf.portAssociate(f.p, fi2fo(fi, w.p), int(e)) } // Wait implements trigger. func (f *fen) Wait() (interface{}, error) { var ( pe PortEvent err error ) err = f.cf.portGet(f.p, &pe) return pe, err } // IsStop implements trigger. func (f *fen) IsStop(n interface{}, err error) bool { return err == syscall.EBADF || inter2pe(n).PortevSource == srcAlert } func init() { encode = func(e Event, dir bool) (o int64) { // Create event is not supported by FEN. Instead FileModified event will // be registered. If this event will be reported on dir which is to be // monitored for Create, dir will be rescanned and Create events will // be generated and returned for new files. In case of files, // if not requested FileModified event is reported, it will be ignored. o = int64(e &^ Create) if (e&Create != 0 && dir) || e&Write != 0 { o = (o &^ int64(Write)) | int64(FileModified) } // Following events are 'exception events' and as such cannot be requested // explicitly for monitoring or filtered out. If the will be reported // by FEN and not subscribed with by user, they will be filtered out by // watcher's logic. o &= int64(^Rename & ^Remove &^ FileDelete &^ FileRenameTo &^ FileRenameFrom &^ Unmounted &^ MountedOver) return } nat2not = map[Event]Event{ FileModified: Write, FileRenameFrom: Rename, FileDelete: Remove, FileAccess: Event(0), FileAttrib: Event(0), FileRenameTo: Event(0), FileTrunc: Event(0), FileNoFollow: Event(0), Unmounted: Event(0), MountedOver: Event(0), } not2nat = map[Event]Event{ Write: FileModified, Rename: FileRenameFrom, Remove: FileDelete, } } notify-0.9.3/watcher_fen_cgo.go000066400000000000000000000101411436002677300165040ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build solaris || illumos // +build solaris illumos package notify // #include // #include // #include // struct file_obj* newFo() { return (struct file_obj*) malloc(sizeof(struct file_obj)); } // port_event_t* newPe() { return (port_event_t*) malloc(sizeof(port_event_t)); } // uintptr_t conv(struct file_obj* fo) { return (uintptr_t) fo; } // struct file_obj* dconv(uintptr_t fo) { return (struct file_obj*) fo; } import "C" import ( "syscall" "unsafe" ) const ( fileAccess = Event(C.FILE_ACCESS) fileModified = Event(C.FILE_MODIFIED) fileAttrib = Event(C.FILE_ATTRIB) fileDelete = Event(C.FILE_DELETE) fileRenameTo = Event(C.FILE_RENAME_TO) fileRenameFrom = Event(C.FILE_RENAME_FROM) fileTrunc = Event(C.FILE_TRUNC) fileNoFollow = Event(C.FILE_NOFOLLOW) unmounted = Event(C.UNMOUNTED) mountedOver = Event(C.MOUNTEDOVER) ) // PortEvent is a notify's equivalent of port_event_t. type PortEvent struct { PortevEvents int // PortevEvents is an equivalent of portev_events. PortevSource uint8 // PortevSource is an equivalent of portev_source. PortevPad uint8 // Portevpad is an equivalent of portev_pad. PortevObject interface{} // PortevObject is an equivalent of portev_object. PortevUser uintptr // PortevUser is an equivalent of portev_user. } // FileObj is a notify's equivalent of file_obj. type FileObj struct { Atim syscall.Timespec // Atim is an equivalent of fo_atime. Mtim syscall.Timespec // Mtim is an equivalent of fo_mtime. Ctim syscall.Timespec // Ctim is an equivalent of fo_ctime. Pad [3]uintptr // Pad is an equivalent of fo_pad. Name string // Name is an equivalent of fo_name. } type cfen struct { p2pe map[string]*C.port_event_t p2fo map[string]*C.struct_file_obj } func newCfen() cfen { return cfen{ p2pe: make(map[string]*C.port_event_t), p2fo: make(map[string]*C.struct_file_obj), } } func unix2C(sec int64, nsec int64) (C.time_t, C.long) { return C.time_t(sec), C.long(nsec) } func (c *cfen) portAssociate(p int, fo FileObj, e int) (err error) { cfo := C.newFo() cfo.fo_atime.tv_sec, cfo.fo_atime.tv_nsec = unix2C(fo.Atim.Unix()) cfo.fo_mtime.tv_sec, cfo.fo_mtime.tv_nsec = unix2C(fo.Mtim.Unix()) cfo.fo_ctime.tv_sec, cfo.fo_ctime.tv_nsec = unix2C(fo.Ctim.Unix()) cfo.fo_name = C.CString(fo.Name) c.p2fo[fo.Name] = cfo _, err = C.port_associate(C.int(p), srcFile, C.conv(cfo), C.int(e), nil) return } func (c *cfen) portDissociate(port int, fo FileObj) (err error) { cfo, ok := c.p2fo[fo.Name] if !ok { return errNotWatched } _, err = C.port_dissociate(C.int(port), srcFile, C.conv(cfo)) C.free(unsafe.Pointer(cfo.fo_name)) C.free(unsafe.Pointer(cfo)) delete(c.p2fo, fo.Name) return } const srcAlert = C.PORT_SOURCE_ALERT const srcFile = C.PORT_SOURCE_FILE const alertSet = C.PORT_ALERT_SET func cfo2fo(cfo *C.struct_file_obj) *FileObj { // Currently remaining attributes are not used. if cfo == nil { return nil } var fo FileObj fo.Name = C.GoString(cfo.fo_name) return &fo } func (c *cfen) portGet(port int, pe *PortEvent) (err error) { cpe := C.newPe() if _, err = C.port_get(C.int(port), cpe, nil); err != nil { C.free(unsafe.Pointer(cpe)) return } pe.PortevEvents, pe.PortevSource, pe.PortevPad = int(cpe.portev_events), uint8(cpe.portev_source), uint8(cpe.portev_pad) pe.PortevObject = cfo2fo(C.dconv(cpe.portev_object)) pe.PortevUser = uintptr(cpe.portev_user) C.free(unsafe.Pointer(cpe)) return } func (c *cfen) portCreate() (int, error) { p, err := C.port_create() return int(p), err } func (c *cfen) portAlert(p int) (err error) { _, err = C.port_alert(C.int(p), alertSet, C.int(666), nil) return } func (c *cfen) free() { for i := range c.p2fo { C.free(unsafe.Pointer(c.p2fo[i].fo_name)) C.free(unsafe.Pointer(c.p2fo[i])) } for i := range c.p2pe { C.free(unsafe.Pointer(c.p2pe[i])) } c.p2fo = make(map[string]*C.struct_file_obj) c.p2pe = make(map[string]*C.port_event_t) } notify-0.9.3/watcher_fen_test.go000066400000000000000000000055551436002677300167300ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build solaris || illumos // +build solaris illumos package notify import ( "os" "path/filepath" "testing" ) func fremove(w *W, path string, files []string) WCase { cas := remove(w, path) cas.Events[0] = &Call{P: path, E: FileDelete} for _, f := range files { cas.Events = append(cas.Events, &Call{P: f, E: FileDelete}) } return cas } func fwrite(w *W, path string, p []byte) WCase { cas := write(w, path, p) path = cas.Events[0].Path() cas.Events[0] = &Call{P: path, E: FileModified} return cas } func frename(w *W, path string, files []string) WCase { const ext = ".notify" cas := WCase{ Action: func() { file := filepath.Join(w.root, path) if err := os.Rename(file, file+ext); err != nil { w.Fatalf("Rename(%q, %q)=%v", path, path+ext, err) } }, Events: []EventInfo{ &Call{P: path + ext, E: osSpecificCreate}, &Call{P: path, E: FileRenameFrom}, }, } for _, f := range files { cas.Events = append(cas.Events, &Call{P: f, E: FileRenameFrom}) } return cas } var events = []Event{ FileModified, FileAttrib, FileRenameFrom, osSpecificCreate, FileDelete, } func TestWatcherFen(t *testing.T) { w := NewWatcherTest(t, "testdata/vfs.txt", events...) defer w.Close() cases := [...]WCase{ fremove(w, "src/github.com/ppknap/link/include/coost/link", []string{ "src/github.com/ppknap/link/include/coost/link/definitions.hpp", "src/github.com/ppknap/link/include/coost/link/detail/bundle.hpp", "src/github.com/ppknap/link/include/coost/link/detail/container_invoker.hpp", "src/github.com/ppknap/link/include/coost/link/detail/container_value_trait.hpp", "src/github.com/ppknap/link/include/coost/link/detail/dummy_type.hpp", "src/github.com/ppknap/link/include/coost/link/detail/function_trait.hpp", "src/github.com/ppknap/link/include/coost/link/detail/immediate_invoker.hpp", "src/github.com/ppknap/link/include/coost/link/detail/stdhelpers/always_same.hpp", "src/github.com/ppknap/link/include/coost/link/detail/stdhelpers/make_unique.hpp", "src/github.com/ppknap/link/include/coost/link/detail/stdhelpers", "src/github.com/ppknap/link/include/coost/link/detail/vertex.hpp", "src/github.com/ppknap/link/include/coost/link/detail/wire.hpp", "src/github.com/ppknap/link/include/coost/link/detail", "src/github.com/ppknap/link/include/coost/link/link.hpp", }, ), fwrite(w, "src/github.com/rjeczalik/fs/fs.go", []byte("XD")), fremove(w, "src/github.com/ppknap/link/README.md", nil), frename(w, "src/github.com/rjeczalik/fs/fs.go", nil), frename(w, "src/github.com/rjeczalik/fs/cmd/gotree", []string{ "src/github.com/rjeczalik/fs/cmd/gotree/go.go", "src/github.com/rjeczalik/fs/cmd/gotree/main.go", }, ), } w.ExpectAll(cases[:]) } notify-0.9.3/watcher_fsevents.go000066400000000000000000000215321436002677300167470ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build darwin && !kqueue && cgo // +build darwin,!kqueue,cgo package notify import ( "errors" "strings" "sync/atomic" ) const ( failure = uint32(FSEventsMustScanSubDirs | FSEventsUserDropped | FSEventsKernelDropped) filter = uint32(FSEventsCreated | FSEventsRemoved | FSEventsRenamed | FSEventsModified | FSEventsInodeMetaMod) ) // FSEvent represents single file event. It is created out of values passed by // FSEvents to FSEventStreamCallback function. type FSEvent struct { Path string // real path of the file or directory ID uint64 // ID of the event (FSEventStreamEventId) Flags uint32 // joint FSEvents* flags (FSEventStreamEventFlags) } // splitflags separates event flags from single set into slice of flags. func splitflags(set uint32) (e []uint32) { for i := uint32(1); set != 0; i, set = i<<1, set>>1 { if (set & 1) != 0 { e = append(e, i) } } return } // watch represents a filesystem watchpoint. It is a higher level abstraction // over FSEvents' stream, which implements filtering of file events based // on path and event set. It emulates non-recursive watch-point by filtering out // events which paths are more than 1 level deeper than the watched path. type watch struct { // prev stores last event set per path in order to filter out old flags // for new events, which appratenly FSEvents likes to retain. It's a disgusting // hack, it should be researched how to get rid of it. prev map[string]uint32 c chan<- EventInfo stream *stream path string events uint32 isrec int32 flushed bool } // Example format: // // ~ $ (trigger command) # (event set) -> (effective event set) // // Heuristics: // // 1. Create event is removed when it was present in previous event set. // Example: // // ~ $ echo > file # Create|Write -> Create|Write // ~ $ echo > file # Create|Write|InodeMetaMod -> Write|InodeMetaMod // // 2. Remove event is removed if it was present in previouse event set. // Example: // // ~ $ touch file # Create -> Create // ~ $ rm file # Create|Remove -> Remove // ~ $ touch file # Create|Remove -> Create // // 3. Write event is removed if not followed by InodeMetaMod on existing // file. Example: // // ~ $ echo > file # Create|Write -> Create|Write // ~ $ chmod +x file # Create|Write|ChangeOwner -> ChangeOwner // // 4. Write&InodeMetaMod is removed when effective event set contain Remove event. // Example: // // ~ $ echo > file # Write|InodeMetaMod -> Write|InodeMetaMod // ~ $ rm file # Remove|Write|InodeMetaMod -> Remove func (w *watch) strip(base string, set uint32) uint32 { const ( write = FSEventsModified | FSEventsInodeMetaMod both = FSEventsCreated | FSEventsRemoved ) switch w.prev[base] { case FSEventsCreated: set &^= FSEventsCreated if set&FSEventsRemoved != 0 { w.prev[base] = FSEventsRemoved set &^= write } case FSEventsRemoved: set &^= FSEventsRemoved if set&FSEventsCreated != 0 { w.prev[base] = FSEventsCreated } default: switch set & both { case FSEventsCreated: w.prev[base] = FSEventsCreated case FSEventsRemoved: w.prev[base] = FSEventsRemoved set &^= write } } dbgprintf("split()=%v\n", Event(set)) return set } // Dispatch is a stream function which forwards given file events for the watched // path to underlying FileInfo channel. func (w *watch) Dispatch(ev []FSEvent) { events := atomic.LoadUint32(&w.events) isrec := (atomic.LoadInt32(&w.isrec) == 1) for i := range ev { if ev[i].Flags&FSEventsHistoryDone != 0 { w.flushed = true continue } if !w.flushed { continue } dbgprintf("%v (0x%x) (%s, i=%d, ID=%d, len=%d)\n", Event(ev[i].Flags), ev[i].Flags, ev[i].Path, i, ev[i].ID, len(ev)) if ev[i].Flags&failure != 0 && failure&events == 0 { // TODO(rjeczalik): missing error handling continue } if !strings.HasPrefix(ev[i].Path, w.path) { continue } n := len(w.path) base := "" if len(ev[i].Path) > n { if ev[i].Path[n] != '/' { continue } base = ev[i].Path[n+1:] if !isrec && strings.IndexByte(base, '/') != -1 { continue } } // TODO(rjeczalik): get diff only from filtered events? e := w.strip(string(base), ev[i].Flags) & events if e == 0 { continue } for _, e := range splitflags(e) { dbgprintf("%d: single event: %v", ev[i].ID, Event(e)) w.c <- &event{ fse: ev[i], event: Event(e), } } } } // Stop closes underlying FSEvents stream and stops dispatching events. func (w *watch) Stop() { w.stream.Stop() // TODO(rjeczalik): make (*stream).Stop flush synchronously undelivered events, // so the following hack can be removed. It should flush all the streams // concurrently as we care not to block too much here. atomic.StoreUint32(&w.events, 0) atomic.StoreInt32(&w.isrec, 0) } // fsevents implements Watcher and RecursiveWatcher interfaces backed by FSEvents // framework. type fsevents struct { watches map[string]*watch c chan<- EventInfo } func newWatcher(c chan<- EventInfo) watcher { return &fsevents{ watches: make(map[string]*watch), c: c, } } func (fse *fsevents) watch(path string, event Event, isrec int32) (err error) { if _, ok := fse.watches[path]; ok { return errAlreadyWatched } w := &watch{ prev: make(map[string]uint32), c: fse.c, path: path, events: uint32(event), isrec: isrec, } w.stream = newStream(path, w.Dispatch) if err = w.stream.Start(); err != nil { return err } fse.watches[path] = w return nil } func (fse *fsevents) unwatch(path string) (err error) { w, ok := fse.watches[path] if !ok { return errNotWatched } w.stream.Stop() delete(fse.watches, path) return nil } // Watch implements Watcher interface. It fails with non-nil error when setting // the watch-point by FSEvents fails or with errAlreadyWatched error when // the given path is already watched. func (fse *fsevents) Watch(path string, event Event) error { return fse.watch(path, event, 0) } // Unwatch implements Watcher interface. It fails with errNotWatched when // the given path is not being watched. func (fse *fsevents) Unwatch(path string) error { return fse.unwatch(path) } // Rewatch implements Watcher interface. It fails with errNotWatched when // the given path is not being watched or with errInvalidEventSet when oldevent // does not match event set the watch-point currently holds. func (fse *fsevents) Rewatch(path string, oldevent, newevent Event) error { w, ok := fse.watches[path] if !ok { return errNotWatched } if !atomic.CompareAndSwapUint32(&w.events, uint32(oldevent), uint32(newevent)) { return errInvalidEventSet } atomic.StoreInt32(&w.isrec, 0) return nil } // RecursiveWatch implements RecursiveWatcher interface. It fails with non-nil // error when setting the watch-point by FSEvents fails or with errAlreadyWatched // error when the given path is already watched. func (fse *fsevents) RecursiveWatch(path string, event Event) error { return fse.watch(path, event, 1) } // RecursiveUnwatch implements RecursiveWatcher interface. It fails with // errNotWatched when the given path is not being watched. // // TODO(rjeczalik): fail if w.isrec == 0? func (fse *fsevents) RecursiveUnwatch(path string) error { return fse.unwatch(path) } // RecursiveRewatch implements RecursiveWatcher interface. It fails: // // - with errNotWatched when the given path is not being watched // - with errInvalidEventSet when oldevent does not match the current event set // - with errAlreadyWatched when watch-point given by the oldpath was meant to // be relocated to newpath, but the newpath is already watched // - a non-nil error when setting the watch-point with FSEvents fails // // TODO(rjeczalik): Improve handling of watch-point relocation? See two TODOs // that follows. func (fse *fsevents) RecursiveRewatch(oldpath, newpath string, oldevent, newevent Event) error { switch [2]bool{oldpath == newpath, oldevent == newevent} { case [2]bool{true, true}: w, ok := fse.watches[oldpath] if !ok { return errNotWatched } atomic.StoreInt32(&w.isrec, 1) return nil case [2]bool{true, false}: w, ok := fse.watches[oldpath] if !ok { return errNotWatched } if !atomic.CompareAndSwapUint32(&w.events, uint32(oldevent), uint32(newevent)) { return errors.New("invalid event state diff") } atomic.StoreInt32(&w.isrec, 1) return nil default: // TODO(rjeczalik): rewatch newpath only if exists? // TODO(rjeczalik): migrate w.prev to new watch? if _, ok := fse.watches[newpath]; ok { return errAlreadyWatched } if err := fse.Unwatch(oldpath); err != nil { return err } // TODO(rjeczalik): revert unwatch if watch fails? return fse.watch(newpath, newevent, 1) } } // Close unwatches all watch-points. func (fse *fsevents) Close() error { for _, w := range fse.watches { w.Stop() } fse.watches = nil return nil } notify-0.9.3/watcher_fsevents_cgo.go000066400000000000000000000105661436002677300176040ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build darwin && !kqueue && cgo // +build darwin,!kqueue,cgo package notify /* #include #include void gostream(uintptr_t, uintptr_t, size_t, uintptr_t, uintptr_t, uintptr_t); static FSEventStreamRef EventStreamCreate(FSEventStreamContext * context, uintptr_t info, CFArrayRef paths, FSEventStreamEventId since, CFTimeInterval latency, FSEventStreamCreateFlags flags) { context->info = (void*) info; return FSEventStreamCreate(NULL, (FSEventStreamCallback) gostream, context, paths, since, latency, flags); } #cgo LDFLAGS: -framework CoreServices */ import "C" import ( "errors" "os" "sync" "sync/atomic" "unsafe" ) var nilstream C.FSEventStreamRef // Default arguments for FSEventStreamCreate function. var ( latency C.CFTimeInterval flags = C.FSEventStreamCreateFlags(C.kFSEventStreamCreateFlagFileEvents | C.kFSEventStreamCreateFlagNoDefer) since = uint64(C.FSEventsGetCurrentEventId()) ) // global dispatch queue which all streams are registered with var q C.dispatch_queue_t = C.dispatch_queue_create( C.CString("com.github.rjeczalik.notify"), (C.dispatch_queue_attr_t)(C.DISPATCH_QUEUE_SERIAL), ) // Errors returned when FSEvents functions fail. var ( errCreate = os.NewSyscallError("FSEventStreamCreate", errors.New("NULL")) errStart = os.NewSyscallError("FSEventStreamStart", errors.New("false")) ) //export gostream func gostream(_, info uintptr, n C.size_t, paths, flags, ids uintptr) { const ( offchar = unsafe.Sizeof((*C.char)(nil)) offflag = unsafe.Sizeof(C.FSEventStreamEventFlags(0)) offid = unsafe.Sizeof(C.FSEventStreamEventId(0)) ) if n == 0 { return } fn := streamFuncs.get(info) if fn == nil { return } ev := make([]FSEvent, 0, int(n)) for i := uintptr(0); i < uintptr(n); i++ { switch flags := *(*uint32)(unsafe.Pointer((flags + i*offflag))); { case flags&uint32(FSEventsEventIdsWrapped) != 0: atomic.StoreUint64(&since, uint64(C.FSEventsGetCurrentEventId())) default: ev = append(ev, FSEvent{ Path: C.GoString(*(**C.char)(unsafe.Pointer(paths + i*offchar))), Flags: flags, ID: *(*uint64)(unsafe.Pointer(ids + i*offid)), }) } } fn(ev) } // StreamFunc is a callback called when stream receives file events. type streamFunc func([]FSEvent) var streamFuncs = streamFuncRegistry{m: map[uintptr]streamFunc{}} type streamFuncRegistry struct { mu sync.Mutex m map[uintptr]streamFunc i uintptr } func (r *streamFuncRegistry) get(id uintptr) streamFunc { r.mu.Lock() defer r.mu.Unlock() return r.m[id] } func (r *streamFuncRegistry) add(fn streamFunc) uintptr { r.mu.Lock() defer r.mu.Unlock() r.i++ r.m[r.i] = fn return r.i } func (r *streamFuncRegistry) delete(id uintptr) { r.mu.Lock() defer r.mu.Unlock() delete(r.m, id) } // Stream represents a single watch-point which listens for events scheduled on the global dispatch queue. type stream struct { path string ref C.FSEventStreamRef info uintptr } // NewStream creates a stream for given path, listening for file events and // calling fn upon receiving any. func newStream(path string, fn streamFunc) *stream { return &stream{ path: path, info: streamFuncs.add(fn), } } // Start creates a FSEventStream for the given path and schedules on the global dispatch queue. // It's a nop if the stream was already started. func (s *stream) Start() error { if s.ref != nilstream { return nil } p := C.CFStringCreateWithCStringNoCopy(C.kCFAllocatorDefault, C.CString(s.path), C.kCFStringEncodingUTF8, C.kCFAllocatorDefault) path := C.CFArrayCreate(C.kCFAllocatorDefault, (*unsafe.Pointer)(unsafe.Pointer(&p)), 1, nil) ctx := C.FSEventStreamContext{} ref := C.EventStreamCreate(&ctx, C.uintptr_t(s.info), path, C.FSEventStreamEventId(atomic.LoadUint64(&since)), latency, flags) if ref == nilstream { return errCreate } C.FSEventStreamSetDispatchQueue(ref, q) if C.FSEventStreamStart(ref) == C.Boolean(0) { C.FSEventStreamInvalidate(ref) return errStart } s.ref = ref return nil } // Stop stops underlying FSEventStream and unregisters it from the global dispatch queue. func (s *stream) Stop() { if s.ref == nilstream { return } C.FSEventStreamStop(s.ref) C.FSEventStreamInvalidate(s.ref) s.ref = nilstream streamFuncs.delete(s.info) } notify-0.9.3/watcher_fsevents_test.go000066400000000000000000000052521436002677300200070ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build darwin && !kqueue && cgo // +build darwin,!kqueue,cgo package notify import ( "reflect" "testing" ) func TestSplitflags(t *testing.T) { cases := [...]struct { set uint32 flags []uint32 }{ {0, nil}, {0xD, []uint32{0x1, 0x4, 0x8}}, {0x0010 | 0x0040 | 0x0080 | 0x01000, []uint32{0x0010, 0x0040, 0x0080, 0x01000}}, {0x40000 | 0x00100 | 0x00200, []uint32{0x00100, 0x00200, 0x40000}}, } for i, cas := range cases { if flags := splitflags(cas.set); !reflect.DeepEqual(flags, cas.flags) { t.Errorf("want flags=%v; got %v (i=%d)", cas.flags, flags, i) } } } func TestWatchStrip(t *testing.T) { const ( create = uint32(FSEventsCreated) remove = uint32(FSEventsRemoved) rename = uint32(FSEventsRenamed) write = uint32(FSEventsModified) inode = uint32(FSEventsInodeMetaMod) owner = uint32(FSEventsChangeOwner) ) cases := [...][]struct { path string flag uint32 diff uint32 }{ // 1. { {"file", create | write, create | write}, {"file", create | write | inode, write | inode}, }, // 2. { {"file", create, create}, {"file", create | remove, remove}, {"file", create | remove, create}, }, // 3. { {"file", create | write, create | write}, {"file", create | write | owner, write | owner}, }, // 4. { {"file", create | write, create | write}, {"file", write | inode, write | inode}, {"file", remove | write | inode, remove}, }, { {"file", remove | write | inode, remove}, }, } Test: for i, cas := range cases { if len(cas) == 0 { t.Log("skipped") continue } w := &watch{prev: make(map[string]uint32)} for j, cas := range cas { if diff := w.strip(cas.path, cas.flag); diff != cas.diff { t.Errorf("want diff=%v; got %v (i=%d, j=%d)", Event(cas.diff), Event(diff), i, j) continue Test } } } } // Test for cases 3) and 5) with shadowed write&create events. // // See comment for (flagdiff).diff method. func TestWatcherShadowedWriteCreate(t *testing.T) { w := NewWatcherTest(t, "testdata/vfs.txt") defer w.Close() cases := [...]WCase{ // i=0 create(w, "src/github.com/rjeczalik/fs/.fs.go.swp"), // i=1 write(w, "src/github.com/rjeczalik/fs/.fs.go.swp", []byte("XD")), // i=2 write(w, "src/github.com/rjeczalik/fs/.fs.go.swp", []byte("XD")), // i=3 remove(w, "src/github.com/rjeczalik/fs/.fs.go.swp"), // i=4 create(w, "src/github.com/rjeczalik/fs/.fs.go.swp"), // i=5 write(w, "src/github.com/rjeczalik/fs/.fs.go.swp", []byte("XD")), } w.ExpectAny(cases[:5]) // BUG(rjeczalik): #62 } notify-0.9.3/watcher_inotify.go000066400000000000000000000266721436002677300166050ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build linux // +build linux package notify import ( "bytes" "errors" "path/filepath" "runtime" "sync" "sync/atomic" "unsafe" "golang.org/x/sys/unix" ) // eventBufferSize defines the size of the buffer given to read(2) function. One // should not depend on this value, since it was arbitrary chosen and may be // changed in the future. const eventBufferSize = 64 * (unix.SizeofInotifyEvent + unix.PathMax + 1) // consumersCount defines the number of consumers in producer-consumer based // implementation. Each consumer is run in a separate goroutine and has read // access to watched files map. const consumersCount = 2 const invalidDescriptor = -1 // watched is a pair of file path and inotify mask used as a value in // watched files map. type watched struct { path string mask uint32 } // inotify implements Watcher interface. type inotify struct { sync.RWMutex // protects inotify.m map m map[int32]*watched // watch descriptor to watched object fd int32 // inotify file descriptor pipefd []int // pipe's read and write descriptors epfd int // epoll descriptor epes []unix.EpollEvent // epoll events buffer [eventBufferSize]byte // inotify event buffer wg sync.WaitGroup // wait group used to close main loop c chan<- EventInfo // event dispatcher channel } // NewWatcher creates new non-recursive inotify backed by inotify. func newWatcher(c chan<- EventInfo) watcher { i := &inotify{ m: make(map[int32]*watched), fd: invalidDescriptor, pipefd: []int{invalidDescriptor, invalidDescriptor}, epfd: invalidDescriptor, epes: make([]unix.EpollEvent, 0), c: c, } runtime.SetFinalizer(i, func(i *inotify) { i.epollclose() if i.fd != invalidDescriptor { unix.Close(int(i.fd)) } }) return i } // Watch implements notify.watcher interface. func (i *inotify) Watch(path string, e Event) error { return i.watch(path, e) } // Rewatch implements notify.watcher interface. func (i *inotify) Rewatch(path string, _, newevent Event) error { return i.watch(path, newevent) } // watch adds a new watcher to the set of watched objects or modifies the existing // one. If called for the first time, this function initializes inotify filesystem // monitor and starts producer-consumers goroutines. func (i *inotify) watch(path string, e Event) (err error) { if e&^(All|Event(unix.IN_ALL_EVENTS)) != 0 { return errors.New("notify: unknown event") } if err = i.lazyinit(); err != nil { return } iwd, err := unix.InotifyAddWatch(int(i.fd), path, encode(e)) if err != nil { return } i.Lock() if wd, ok := i.m[int32(iwd)]; !ok { i.m[int32(iwd)] = &watched{path: path, mask: uint32(e)} } else { wd.path = path wd.mask = uint32(e) } i.Unlock() return nil } // lazyinit sets up all required file descriptors and starts 1+consumersCount // goroutines. The producer goroutine blocks until file-system notifications // occur. Then, all events are read from system buffer and sent to consumer // goroutines which construct valid notify events. This method uses // Double-Checked Locking optimization. func (i *inotify) lazyinit() error { if atomic.LoadInt32(&i.fd) == invalidDescriptor { i.Lock() defer i.Unlock() if atomic.LoadInt32(&i.fd) == invalidDescriptor { fd, err := unix.InotifyInit1(unix.IN_CLOEXEC) if err != nil { return err } i.fd = int32(fd) if err = i.epollinit(); err != nil { _, _ = i.epollclose(), unix.Close(int(fd)) // Ignore errors. i.fd = invalidDescriptor return err } esch := make(chan []*event) go i.loop(esch) i.wg.Add(consumersCount) for n := 0; n < consumersCount; n++ { go i.send(esch) } } } return nil } // epollinit opens an epoll file descriptor and creates a pipe which will be // used to wake up the epoll_wait(2) function. Then, file descriptor associated // with inotify event queue and the read end of the pipe are added to epoll set. // Note that `fd` member must be set before this function is called. func (i *inotify) epollinit() (err error) { if i.epfd, err = unix.EpollCreate1(0); err != nil { return } if err = unix.Pipe(i.pipefd); err != nil { return } i.epes = []unix.EpollEvent{ {Events: unix.EPOLLIN, Fd: i.fd}, {Events: unix.EPOLLIN, Fd: int32(i.pipefd[0])}, } if err = unix.EpollCtl(i.epfd, unix.EPOLL_CTL_ADD, int(i.fd), &i.epes[0]); err != nil { return } return unix.EpollCtl(i.epfd, unix.EPOLL_CTL_ADD, i.pipefd[0], &i.epes[1]) } // epollclose closes the file descriptor created by the call to epoll_create(2) // and two file descriptors opened by pipe(2) function. func (i *inotify) epollclose() (err error) { if i.epfd != invalidDescriptor { if err = unix.Close(i.epfd); err == nil { i.epfd = invalidDescriptor } } for n, fd := range i.pipefd { if fd != invalidDescriptor { switch e := unix.Close(fd); { case e != nil && err == nil: err = e case e == nil: i.pipefd[n] = invalidDescriptor } } } return } // loop blocks until either inotify or pipe file descriptor is ready for I/O. // All read operations triggered by filesystem notifications are forwarded to // one of the event's consumers. If pipe fd became ready, loop function closes // all file descriptors opened by lazyinit method and returns afterwards. func (i *inotify) loop(esch chan<- []*event) { epes := make([]unix.EpollEvent, 1) fd := atomic.LoadInt32(&i.fd) for { switch _, err := unix.EpollWait(i.epfd, epes, -1); err { case nil: switch epes[0].Fd { case fd: esch <- i.read() epes[0].Fd = 0 case int32(i.pipefd[0]): i.Lock() defer i.Unlock() if err = unix.Close(int(fd)); err != nil && err != unix.EINTR { panic("notify: close(2) error " + err.Error()) } atomic.StoreInt32(&i.fd, invalidDescriptor) if err = i.epollclose(); err != nil && err != unix.EINTR { panic("notify: epollclose error " + err.Error()) } close(esch) return } case unix.EINTR: continue default: // We should never reach this line. panic("notify: epoll_wait(2) error " + err.Error()) } } } // read reads events from an inotify file descriptor. It does not handle errors // returned from read(2) function since they are not critical to watcher logic. func (i *inotify) read() (es []*event) { n, err := unix.Read(int(i.fd), i.buffer[:]) if err != nil || n < unix.SizeofInotifyEvent { return } var sys *unix.InotifyEvent nmin := n - unix.SizeofInotifyEvent for pos, path := 0, ""; pos <= nmin; { sys = (*unix.InotifyEvent)(unsafe.Pointer(&i.buffer[pos])) pos += unix.SizeofInotifyEvent if path = ""; sys.Len > 0 { endpos := pos + int(sys.Len) path = string(bytes.TrimRight(i.buffer[pos:endpos], "\x00")) pos = endpos } es = append(es, &event{ sys: unix.InotifyEvent{ Wd: sys.Wd, Mask: sys.Mask, Cookie: sys.Cookie, }, path: path, }) } return } // send is a consumer function which sends events to event dispatcher channel. // It is run in a separate goroutine in order to not block loop method when // possibly expensive write operations are performed on inotify map. func (i *inotify) send(esch <-chan []*event) { for es := range esch { for _, e := range i.transform(es) { if e != nil { i.c <- e } } } i.wg.Done() } // transform prepares events read from inotify file descriptor for sending to // user. It removes invalid events and these which are no longer present in // inotify map. This method may also split one raw event into two different ones // when system-dependent result is required. func (i *inotify) transform(es []*event) []*event { var multi []*event i.RLock() for idx, e := range es { if e.sys.Mask&(unix.IN_IGNORED|unix.IN_Q_OVERFLOW) != 0 { es[idx] = nil continue } wd, ok := i.m[e.sys.Wd] if !ok || e.sys.Mask&encode(Event(wd.mask)) == 0 { es[idx] = nil continue } if e.path == "" { e.path = wd.path } else { e.path = filepath.Join(wd.path, e.path) } multi = append(multi, decode(Event(wd.mask), e)) if e.event == 0 { es[idx] = nil } } i.RUnlock() es = append(es, multi...) return es } // encode converts notify system-independent events to valid inotify mask // which can be passed to inotify_add_watch(2) function. func encode(e Event) uint32 { if e&Create != 0 { e = (e ^ Create) | InCreate | InMovedTo } if e&Remove != 0 { e = (e ^ Remove) | InDelete | InDeleteSelf } if e&Write != 0 { e = (e ^ Write) | InModify } if e&Rename != 0 { e = (e ^ Rename) | InMovedFrom | InMoveSelf } return uint32(e) } // decode uses internally stored mask to distinguish whether system-independent // or system-dependent event is requested. The first one is created by modifying // `e` argument. decode method sets e.event value to 0 when an event should be // skipped. System-dependent event is set as the function's return value which // can be nil when the event should not be passed on. func decode(mask Event, e *event) (syse *event) { if sysmask := uint32(mask) & e.sys.Mask; sysmask != 0 { syse = &event{sys: unix.InotifyEvent{ Wd: e.sys.Wd, Mask: e.sys.Mask, Cookie: e.sys.Cookie, }, event: Event(sysmask), path: e.path} } imask := encode(mask) switch { case mask&Create != 0 && imask&uint32(InCreate|InMovedTo)&e.sys.Mask != 0: e.event = Create case mask&Remove != 0 && imask&uint32(InDelete|InDeleteSelf)&e.sys.Mask != 0: e.event = Remove case mask&Write != 0 && imask&uint32(InModify)&e.sys.Mask != 0: e.event = Write case mask&Rename != 0 && imask&uint32(InMovedFrom|InMoveSelf)&e.sys.Mask != 0: e.event = Rename default: e.event = 0 } return } // Unwatch implements notify.watcher interface. It looks for watch descriptor // related to registered path and if found, calls inotify_rm_watch(2) function. // This method is allowed to return EINVAL error when concurrently requested to // delete identical path. func (i *inotify) Unwatch(path string) (err error) { iwd := int32(invalidDescriptor) i.RLock() for iwdkey, wd := range i.m { if wd.path == path { iwd = iwdkey break } } i.RUnlock() if iwd == invalidDescriptor { return errors.New("notify: path " + path + " is already watched") } fd := atomic.LoadInt32(&i.fd) if err = removeInotifyWatch(fd, iwd); err != nil { return } i.Lock() delete(i.m, iwd) i.Unlock() return nil } // Close implements notify.watcher interface. It removes all existing watch // descriptors and wakes up producer goroutine by sending data to the write end // of the pipe. The function waits for a signal from producer which means that // all operations on current monitoring instance are done. func (i *inotify) Close() (err error) { i.Lock() if fd := atomic.LoadInt32(&i.fd); fd == invalidDescriptor { i.Unlock() return nil } for iwd := range i.m { if e := removeInotifyWatch(i.fd, iwd); e != nil && err == nil { err = e } delete(i.m, iwd) } switch _, errwrite := unix.Write(i.pipefd[1], []byte{0x00}); { case errwrite != nil && err == nil: err = errwrite fallthrough case errwrite != nil: i.Unlock() default: i.Unlock() i.wg.Wait() } return } // if path was removed, notify already removed the watch and returns EINVAL error func removeInotifyWatch(fd int32, iwd int32) (err error) { if _, err = unix.InotifyRmWatch(int(fd), uint32(iwd)); err != nil && err != unix.EINVAL { return } return nil } notify-0.9.3/watcher_inotify_test.go000066400000000000000000000055301436002677300176320ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build linux // +build linux package notify import ( "os" "path/filepath" "testing" ) func icreate(w *W, path string) WCase { cas := create(w, path) cas.Events = append(cas.Events, &Call{P: path, E: InCreate}, ) return cas } func iremove(w *W, path string) WCase { cas := remove(w, path) cas.Events = append(cas.Events, &Call{P: path, E: InDelete}, ) return cas } func iopen(w *W, path string) WCase { return WCase{ Action: func() { f, err := os.OpenFile(filepath.Join(w.root, path), os.O_RDWR, 0644) if err != nil { w.Fatalf("OpenFile(%q)=%v", path, err) } if err := f.Close(); err != nil { w.Fatalf("Close(%q)=%v", path, err) } }, Events: []EventInfo{ &Call{P: path, E: InAccess}, &Call{P: path, E: InOpen}, &Call{P: path, E: InCloseNowrite}, }, } } func iread(w *W, path string, p []byte) WCase { return WCase{ Action: func() { f, err := os.OpenFile(filepath.Join(w.root, path), os.O_RDWR, 0644) if err != nil { w.Fatalf("OpenFile(%q)=%v", path, err) } if _, err := f.Read(p); err != nil { w.Fatalf("Read(%q)=%v", path, err) } if err := f.Close(); err != nil { w.Fatalf("Close(%q)=%v", path, err) } }, Events: []EventInfo{ &Call{P: path, E: InAccess}, &Call{P: path, E: InOpen}, &Call{P: path, E: InModify}, &Call{P: path, E: InCloseNowrite}, }, } } func iwrite(w *W, path string, p []byte) WCase { cas := write(w, path, p) path = cas.Events[0].Path() cas.Events = append(cas.Events, &Call{P: path, E: InAccess}, &Call{P: path, E: InOpen}, &Call{P: path, E: InModify}, &Call{P: path, E: InCloseWrite}, ) return cas } func irename(w *W, path string) WCase { const ext = ".notify" return WCase{ Action: func() { file := filepath.Join(w.root, path) if err := os.Rename(file, file+ext); err != nil { w.Fatalf("Rename(%q, %q)=%v", path, path+ext, err) } }, Events: []EventInfo{ &Call{P: path, E: InMovedFrom}, &Call{P: path + ext, E: InMovedTo}, &Call{P: path, E: InOpen}, &Call{P: path, E: InAccess}, &Call{P: path, E: InCreate}, }, } } var events = []Event{ InAccess, InModify, InAttrib, InCloseWrite, InCloseNowrite, InOpen, InMovedFrom, InMovedTo, InCreate, InDelete, InDeleteSelf, InMoveSelf, } func TestWatcherInotify(t *testing.T) { w := NewWatcherTest(t, "testdata/vfs.txt", events...) defer w.Close() cases := [...]WCase{ iopen(w, "src/github.com/rjeczalik/fs/fs.go"), iwrite(w, "src/github.com/rjeczalik/fs/fs.go", []byte("XD")), iread(w, "src/github.com/rjeczalik/fs/fs.go", []byte("XD")), iremove(w, "src/github.com/ppknap/link/README.md"), irename(w, "src/github.com/rjeczalik/fs/LICENSE"), } w.ExpectAny(cases[:]) } notify-0.9.3/watcher_kqueue.go000066400000000000000000000127611436002677300164150ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build (darwin && kqueue) || (darwin && !cgo) || dragonfly || freebsd || netbsd || openbsd // +build darwin,kqueue darwin,!cgo dragonfly freebsd netbsd openbsd package notify import ( "errors" "fmt" "os" "syscall" ) // newTrigger returns implementation of trigger. func newTrigger(pthLkp map[string]*watched) trigger { return &kq{ pthLkp: pthLkp, idLkp: make(map[int]*watched), } } // kq is a structure implementing trigger for kqueue. type kq struct { // fd is a kqueue file descriptor fd int // pipefds are file descriptors used to stop `Kevent` call. pipefds [2]int // idLkp is a data structure mapping file descriptors with data about watching // represented by them files/directories. idLkp map[int]*watched // pthLkp is a structure mapping monitored files/dir with data about them, // shared with parent trg structure pthLkp map[string]*watched } // watched is a data structure representing watched file/directory. type watched struct { trgWatched // fd is a file descriptor for watched file/directory. fd int } // Stop implements trigger. func (k *kq) Stop() (err error) { // trigger event used to interrupt Kevent call. _, err = syscall.Write(k.pipefds[1], []byte{0x00}) return } // Close implements trigger. func (k *kq) Close() error { return syscall.Close(k.fd) } // NewWatched implements trigger. func (*kq) NewWatched(p string, fi os.FileInfo) (*watched, error) { fd, err := syscall.Open(p, syscall.O_NONBLOCK|syscall.O_RDONLY, 0) if err != nil { // BSDs can't open symlinks and return an error if the symlink // cannot be followed - ignore it instead of failing. See e.g. // https://github.com/libinotify-kqueue/libinotify-kqueue/blob/a822c8f1d75404fe3132f695a898dcd42fe8afbc/patches/freebsd11-O_SYMLINK.patch if os.IsNotExist(err) && fi.Mode()&os.ModeSymlink == os.ModeSymlink { return nil, errSkip } // FreeBSD can't open unix domain sockets and returns "operation not supported" error. // Ignore it instead of failing. if errors.Is(err, syscall.ENOTSUP) && fi.Mode()&os.ModeSocket == os.ModeSocket { return nil, errSkip } return nil, err } return &watched{ trgWatched: trgWatched{p: p, fi: fi}, fd: fd, }, nil } // Record implements trigger. func (k *kq) Record(w *watched) { k.idLkp[w.fd], k.pthLkp[w.p] = w, w } // Del implements trigger. func (k *kq) Del(w *watched) { syscall.Close(w.fd) delete(k.idLkp, w.fd) delete(k.pthLkp, w.p) } func inter2kq(n interface{}) syscall.Kevent_t { kq, ok := n.(syscall.Kevent_t) if !ok { panic(fmt.Sprintf("kqueue: type should be Kevent_t, %T instead", n)) } return kq } // Init implements trigger. func (k *kq) Init() (err error) { if k.fd, err = syscall.Kqueue(); err != nil { return } // Creates pipe used to stop `Kevent` call by registering it, // watching read end and writing to other end of it. if err = syscall.Pipe(k.pipefds[:]); err != nil { return nonil(err, k.Close()) } var kevn [1]syscall.Kevent_t syscall.SetKevent(&kevn[0], k.pipefds[0], syscall.EVFILT_READ, syscall.EV_ADD) if _, err = syscall.Kevent(k.fd, kevn[:], nil, nil); err != nil { return nonil(err, k.Close()) } return } // Unwatch implements trigger. func (k *kq) Unwatch(w *watched) (err error) { var kevn [1]syscall.Kevent_t syscall.SetKevent(&kevn[0], w.fd, syscall.EVFILT_VNODE, syscall.EV_DELETE) _, err = syscall.Kevent(k.fd, kevn[:], nil, nil) return } // Watch implements trigger. func (k *kq) Watch(fi os.FileInfo, w *watched, e int64) (err error) { var kevn [1]syscall.Kevent_t syscall.SetKevent(&kevn[0], w.fd, syscall.EVFILT_VNODE, syscall.EV_ADD|syscall.EV_CLEAR) kevn[0].Fflags = uint32(e) _, err = syscall.Kevent(k.fd, kevn[:], nil, nil) return } // Wait implements trigger. func (k *kq) Wait() (interface{}, error) { var ( kevn [1]syscall.Kevent_t err error ) kevn[0] = syscall.Kevent_t{} _, err = syscall.Kevent(k.fd, nil, kevn[:], nil) return kevn[0], err } // Watched implements trigger. func (k *kq) Watched(n interface{}) (*watched, int64, error) { kevn, ok := n.(syscall.Kevent_t) if !ok { panic(fmt.Sprintf("kq: type should be syscall.Kevent_t, %T instead", kevn)) } if _, ok = k.idLkp[int(kevn.Ident)]; !ok { return nil, 0, errNotWatched } return k.idLkp[int(kevn.Ident)], int64(kevn.Fflags), nil } // IsStop implements trigger. func (k *kq) IsStop(n interface{}, err error) bool { return int(inter2kq(n).Ident) == k.pipefds[0] } func init() { encode = func(e Event, dir bool) (o int64) { // Create event is not supported by kqueue. Instead NoteWrite event will // be registered for a directory. If this event will be reported on dir // which is to be monitored for Create, dir will be rescanned // and Create events will be generated and returned for new files. // In case of files, if not requested NoteRename event is reported, // it will be ignored. o = int64(e &^ Create) if (e&Create != 0 && dir) || e&Write != 0 { o = (o &^ int64(Write)) | int64(NoteWrite) } if e&Rename != 0 { o = (o &^ int64(Rename)) | int64(NoteRename) } if e&Remove != 0 { o = (o &^ int64(Remove)) | int64(NoteDelete) } return } nat2not = map[Event]Event{ NoteWrite: Write, NoteRename: Rename, NoteDelete: Remove, NoteExtend: Event(0), NoteAttrib: Event(0), NoteRevoke: Event(0), NoteLink: Event(0), } not2nat = map[Event]Event{ Write: NoteWrite, Rename: NoteRename, Remove: NoteDelete, } } notify-0.9.3/watcher_kqueue_test.go000066400000000000000000000066241436002677300174550ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build (darwin && kqueue) || (darwin && !cgo) || dragonfly || freebsd || netbsd || openbsd // +build darwin,kqueue darwin,!cgo dragonfly freebsd netbsd openbsd package notify import ( "os" "path/filepath" "testing" ) func kqremove(w *W, path string, files []string) WCase { cas := remove(w, path) cas.Events[0] = &Call{P: path, E: NoteDelete} for _, f := range files { cas.Events = append(cas.Events, &Call{P: f, E: NoteDelete}) } return cas } func kqwrite(w *W, path string, p []byte) WCase { cas := write(w, path, p) path = cas.Events[0].Path() cas.Events[0] = &Call{P: path, E: NoteExtend | NoteWrite} return cas } func kqrename(w *W, path string, files []string) WCase { const ext = ".notify" cas := WCase{ Action: func() { file := filepath.Join(w.root, path) if err := os.Rename(file, file+ext); err != nil { w.Fatalf("Rename(%q, %q)=%v", path, path+ext, err) } }, Events: []EventInfo{ &Call{P: path + ext, E: osSpecificCreate}, &Call{P: path, E: NoteRename}, }, } for _, f := range files { cas.Events = append(cas.Events, &Call{P: f, E: NoteRename}) } return cas } func kqlink(w *W, path string) WCase { const ext = ".notify" return WCase{ Action: func() { file := filepath.Join(w.root, path) if err := os.Link(file, file+ext); err != nil { w.Fatalf("Link(%q, %q)=%v", path, path+ext, err) } }, Events: []EventInfo{ &Call{P: path, E: NoteLink}, &Call{P: path + ext, E: osSpecificCreate}, }, } } var events = []Event{ NoteWrite, NoteAttrib, NoteRename, osSpecificCreate, NoteDelete, NoteExtend, NoteLink, } func TestWatcherKqueue(t *testing.T) { w := NewWatcherTest(t, "testdata/vfs.txt", events...) defer w.Close() cases := [...]WCase{ kqremove(w, "src/github.com/ppknap/link/include/coost/link", []string{ "src/github.com/ppknap/link/include/coost/link/definitions.hpp", "src/github.com/ppknap/link/include/coost/link/detail/bundle.hpp", "src/github.com/ppknap/link/include/coost/link/detail/container_invoker.hpp", "src/github.com/ppknap/link/include/coost/link/detail/container_value_trait.hpp", "src/github.com/ppknap/link/include/coost/link/detail/dummy_type.hpp", "src/github.com/ppknap/link/include/coost/link/detail/function_trait.hpp", "src/github.com/ppknap/link/include/coost/link/detail/immediate_invoker.hpp", "src/github.com/ppknap/link/include/coost/link/detail/stdhelpers/always_same.hpp", "src/github.com/ppknap/link/include/coost/link/detail/stdhelpers/make_unique.hpp", "src/github.com/ppknap/link/include/coost/link/detail/stdhelpers", "src/github.com/ppknap/link/include/coost/link/detail/vertex.hpp", "src/github.com/ppknap/link/include/coost/link/detail/wire.hpp", "src/github.com/ppknap/link/include/coost/link/detail", "src/github.com/ppknap/link/include/coost/link/link.hpp", }, ), kqwrite(w, "src/github.com/rjeczalik/fs/fs.go", []byte("XD")), kqremove(w, "src/github.com/ppknap/link/README.md", nil), kqlink(w, "src/github.com/rjeczalik/fs/LICENSE"), kqrename(w, "src/github.com/rjeczalik/fs/fs.go", nil), kqrename(w, "src/github.com/rjeczalik/fs/cmd/gotree", []string{ "src/github.com/rjeczalik/fs/cmd/gotree/go.go", "src/github.com/rjeczalik/fs/cmd/gotree/main.go", }, ), } w.ExpectAll(cases[:]) } notify-0.9.3/watcher_notimplemented.go000066400000000000000000000010461436002677300201340ustar00rootroot00000000000000// Copyright (c) 2014-2018 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build !darwin && !linux && !freebsd && !dragonfly && !netbsd && !openbsd && !windows && !kqueue && !solaris && !illumos // +build !darwin,!linux,!freebsd,!dragonfly,!netbsd,!openbsd,!windows,!kqueue,!solaris,!illumos package notify import "errors" // newWatcher stub. func newWatcher(chan<- EventInfo) watcher { return watcherStub{errors.New("notify: not implemented")} } notify-0.9.3/watcher_readdcw.go000066400000000000000000000416321436002677300165260ustar00rootroot00000000000000// Copyright (c) 2014-2020 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build windows // +build windows package notify import ( "errors" "runtime" "sync" "sync/atomic" "syscall" "unsafe" ) // readBufferSize defines the size of an array in which read statuses are stored. // The buffer have to be DWORD-aligned and, if notify is used in monitoring a // directory over the network, its size must not be greater than 64KB. Each of // watched directories uses its own buffer for storing events. const readBufferSize = 4096 // Since all operations which go through the Windows completion routine are done // asynchronously, filter may set one of the constants below. They were defined // in order to distinguish whether current folder should be re-registered in // ReadDirectoryChangesW function or some control operations need to be executed. const ( stateRewatch uint32 = 1 << (28 + iota) stateUnwatch stateCPClose ) // Filter used in current implementation was split into four segments: // - bits 0-11 store ReadDirectoryChangesW filters, // - bits 12-19 store File notify actions, // - bits 20-27 store notify specific events and flags, // - bits 28-31 store states which are used in loop's FSM. // // Constants below are used as masks to retrieve only specific filter parts. const ( onlyNotifyChanges uint32 = 0x00000FFF onlyNGlobalEvents uint32 = 0x0FF00000 onlyMachineStates uint32 = 0xF0000000 ) // grip represents a single watched directory. It stores the data required by // ReadDirectoryChangesW function. Only the filter, recursive, and handle members // may by modified by watcher implementation. Rest of the them have to remain // constant since they are used by Windows completion routine. This indicates that // grip can be removed only when all operations on the file handle are finished. type grip struct { handle syscall.Handle filter uint32 recursive bool pathw []uint16 buffer [readBufferSize]byte parent *watched ovlapped *overlappedEx } // overlappedEx stores information used in asynchronous input and output. // Additionally, overlappedEx contains a pointer to 'grip' item which is used in // order to gather the structure in which the overlappedEx object was created. type overlappedEx struct { syscall.Overlapped parent *grip } // newGrip creates a new file handle that can be used in overlapped operations. // Then, the handle is associated with I/O completion port 'cph' and its value // is stored in newly created 'grip' object. func newGrip(cph syscall.Handle, parent *watched, filter uint32) (*grip, error) { g := &grip{ handle: syscall.InvalidHandle, filter: filter, recursive: parent.recursive, pathw: parent.pathw, parent: parent, ovlapped: &overlappedEx{}, } if err := g.register(cph); err != nil { return nil, err } g.ovlapped.parent = g return g, nil } // NOTE : Thread safe func (g *grip) register(cph syscall.Handle) (err error) { if g.handle, err = syscall.CreateFile( &g.pathw[0], syscall.FILE_LIST_DIRECTORY, syscall.FILE_SHARE_READ|syscall.FILE_SHARE_WRITE|syscall.FILE_SHARE_DELETE, nil, syscall.OPEN_EXISTING, syscall.FILE_FLAG_BACKUP_SEMANTICS|syscall.FILE_FLAG_OVERLAPPED, 0, ); err != nil { return } if _, err = syscall.CreateIoCompletionPort(g.handle, cph, 0, 0); err != nil { syscall.CloseHandle(g.handle) return } return g.readDirChanges() } // readDirChanges tells the system to store file change information in grip's // buffer. Directory changes that occur between calls to this function are added // to the buffer and then, returned with the next call. func (g *grip) readDirChanges() error { handle := syscall.Handle(atomic.LoadUintptr((*uintptr)(&g.handle))) if handle == syscall.InvalidHandle { return nil // Handle was closed. } return syscall.ReadDirectoryChanges( handle, &g.buffer[0], uint32(unsafe.Sizeof(g.buffer)), g.recursive, encode(g.filter), nil, (*syscall.Overlapped)(unsafe.Pointer(g.ovlapped)), 0, ) } // encode transforms a generic filter, which contains platform independent and // implementation specific bit fields, to value that can be used as NotifyFilter // parameter in ReadDirectoryChangesW function. func encode(filter uint32) uint32 { e := Event(filter & (onlyNGlobalEvents | onlyNotifyChanges)) if e&dirmarker != 0 { return uint32(FileNotifyChangeDirName) } if e&Create != 0 { e = (e ^ Create) | FileNotifyChangeFileName } if e&Remove != 0 { e = (e ^ Remove) | FileNotifyChangeFileName } if e&Write != 0 { e = (e ^ Write) | FileNotifyChangeAttributes | FileNotifyChangeSize | FileNotifyChangeCreation | FileNotifyChangeSecurity } if e&Rename != 0 { e = (e ^ Rename) | FileNotifyChangeFileName } return uint32(e) } // watched is made in order to check whether an action comes from a directory or // file. This approach requires two file handlers per single monitored folder. The // second grip handles actions which include creating or deleting a directory. If // these processes are not monitored, only the first grip is created. type watched struct { filter uint32 recursive bool count uint8 pathw []uint16 digrip [2]*grip } // newWatched creates a new watched instance. It splits the filter variable into // two parts. The first part is responsible for watching all events which can be // created for a file in watched directory structure and the second one watches // only directory Create/Remove actions. If all operations succeed, the Create // message is sent to I/O completion port queue for further processing. func newWatched(cph syscall.Handle, filter uint32, recursive bool, path string) (wd *watched, err error) { wd = &watched{ filter: filter, recursive: recursive, } if wd.pathw, err = syscall.UTF16FromString(path); err != nil { return } if err = wd.recreate(cph); err != nil { return } return wd, nil } // TODO : doc func (wd *watched) recreate(cph syscall.Handle) (err error) { filefilter := wd.filter &^ uint32(FileNotifyChangeDirName) if err = wd.updateGrip(0, cph, filefilter == 0, filefilter); err != nil { return } dirfilter := wd.filter & uint32(FileNotifyChangeDirName|Create|Remove) if err = wd.updateGrip(1, cph, dirfilter == 0, wd.filter|uint32(dirmarker)); err != nil { return } wd.filter &^= onlyMachineStates return } // TODO : doc func (wd *watched) updateGrip(idx int, cph syscall.Handle, reset bool, newflag uint32) (err error) { if reset { wd.digrip[idx] = nil } else { if wd.digrip[idx] == nil { if wd.digrip[idx], err = newGrip(cph, wd, newflag); err != nil { wd.closeHandle() return } } else { wd.digrip[idx].filter = newflag wd.digrip[idx].recursive = wd.recursive if err = wd.digrip[idx].register(cph); err != nil { wd.closeHandle() return } } wd.count++ } return } // closeHandle closes handles that are stored in digrip array. Function always // tries to close all of the handlers before it exits, even when there are errors // returned from the operating system kernel. func (wd *watched) closeHandle() (err error) { for _, g := range wd.digrip { if g == nil { continue } for { handle := syscall.Handle(atomic.LoadUintptr((*uintptr)(&g.handle))) if handle == syscall.InvalidHandle { break // Already closed. } e := syscall.CloseHandle(handle) if e != nil && err == nil { err = e } // Set invalid handle even when CloseHandle fails. This will leak // the handle but, since we can't close it anyway, there won't be // any difference. if atomic.CompareAndSwapUintptr((*uintptr)(&g.handle), (uintptr)(handle), (uintptr)(syscall.InvalidHandle)) { break } } } return } // watcher implements Watcher interface. It stores a set of watched directories. // All operations which remove watched objects from map `m` must be performed in // loop goroutine since these structures are used internally by operating system. type readdcw struct { sync.Mutex m map[string]*watched cph syscall.Handle start bool wg sync.WaitGroup c chan<- EventInfo } // NewWatcher creates new non-recursive watcher backed by ReadDirectoryChangesW. func newWatcher(c chan<- EventInfo) watcher { r := &readdcw{ m: make(map[string]*watched), cph: syscall.InvalidHandle, c: c, } runtime.SetFinalizer(r, func(r *readdcw) { if r.cph != syscall.InvalidHandle { syscall.CloseHandle(r.cph) } }) return r } // Watch implements notify.Watcher interface. func (r *readdcw) Watch(path string, event Event) error { return r.watch(path, event, false) } // RecursiveWatch implements notify.RecursiveWatcher interface. func (r *readdcw) RecursiveWatch(path string, event Event) error { return r.watch(path, event, true) } // watch inserts a directory to the group of watched folders. If watched folder // already exists, function tries to rewatch it with new filters(NOT VALID). Moreover, // watch starts the main event loop goroutine when called for the first time. func (r *readdcw) watch(path string, event Event, recursive bool) error { if event&^(All|fileNotifyChangeAll) != 0 { return errors.New("notify: unknown event") } r.Lock() defer r.Unlock() if wd, ok := r.m[path]; ok { dbgprint("watch: already exists") wd.filter &^= stateUnwatch return nil } if err := r.lazyinit(); err != nil { return err } wd, err := newWatched(r.cph, uint32(event), recursive, path) if err != nil { return err } r.m[path] = wd dbgprint("watch: new watch added") return nil } // lazyinit creates an I/O completion port and starts the main event loop. func (r *readdcw) lazyinit() (err error) { invalid := uintptr(syscall.InvalidHandle) if atomic.LoadUintptr((*uintptr)(&r.cph)) == invalid { cph := syscall.InvalidHandle if cph, err = syscall.CreateIoCompletionPort(cph, 0, 0, 0); err != nil { return } r.cph, r.start = cph, true go r.loop() } return } // TODO(pknap) : doc func (r *readdcw) loop() { var n, key uint32 var overlapped *syscall.Overlapped for { err := syscall.GetQueuedCompletionStatus(r.cph, &n, &key, &overlapped, syscall.INFINITE) if key == stateCPClose { r.Lock() handle := r.cph r.cph = syscall.InvalidHandle r.Unlock() syscall.CloseHandle(handle) r.wg.Done() return } if overlapped == nil { // TODO: check key == rewatch delete or 0(panic) continue } overEx := (*overlappedEx)(unsafe.Pointer(overlapped)) if overEx == nil || overEx.parent == nil { dbgprintf("incomplete completion status transferred=%d, overlapped=%#v, key=%#b", n, overEx, key) continue } else if n != 0 { r.loopevent(n, overEx) } if err = overEx.parent.readDirChanges(); err != nil { // TODO: error handling } r.loopstate(overEx) } } // TODO(pknap) : doc func (r *readdcw) loopstate(overEx *overlappedEx) { r.Lock() defer r.Unlock() filter := overEx.parent.parent.filter if filter&onlyMachineStates == 0 { return } if overEx.parent.parent.count--; overEx.parent.parent.count == 0 { switch filter & onlyMachineStates { case stateRewatch: dbgprint("loopstate rewatch") overEx.parent.parent.recreate(r.cph) case stateUnwatch: dbgprint("loopstate unwatch") overEx.parent.parent.closeHandle() delete(r.m, syscall.UTF16ToString(overEx.parent.pathw)) case stateCPClose: default: panic(`notify: windows loopstate logic error`) } } } // TODO(pknap) : doc func (r *readdcw) loopevent(n uint32, overEx *overlappedEx) { events := []*event{} var currOffset uint32 for { raw := (*syscall.FileNotifyInformation)(unsafe.Pointer(&overEx.parent.buffer[currOffset])) name := syscall.UTF16ToString((*[syscall.MAX_LONG_PATH]uint16)(unsafe.Pointer(&raw.FileName))[:raw.FileNameLength>>1]) events = append(events, &event{ pathw: overEx.parent.pathw, filter: overEx.parent.filter, action: raw.Action, name: name, }) if raw.NextEntryOffset == 0 { break } if currOffset += raw.NextEntryOffset; currOffset >= n { break } } r.send(events) } // TODO(pknap) : doc func (r *readdcw) send(es []*event) { for _, e := range es { var syse Event if e.e, syse = decode(e.filter, e.action); e.e == 0 && syse == 0 { continue } switch { case e.action == syscall.FILE_ACTION_MODIFIED: e.ftype = fTypeUnknown case e.filter&uint32(dirmarker) != 0: e.ftype = fTypeDirectory default: e.ftype = fTypeFile } switch { case e.e == 0: e.e = syse case syse != 0: r.c <- &event{ pathw: e.pathw, name: e.name, ftype: e.ftype, action: e.action, filter: e.filter, e: syse, } } r.c <- e } } // Rewatch implements notify.Rewatcher interface. func (r *readdcw) Rewatch(path string, oldevent, newevent Event) error { return r.rewatch(path, uint32(oldevent), uint32(newevent), false) } // RecursiveRewatch implements notify.RecursiveRewatcher interface. func (r *readdcw) RecursiveRewatch(oldpath, newpath string, oldevent, newevent Event) error { if oldpath != newpath { if err := r.unwatch(oldpath); err != nil { return err } return r.watch(newpath, newevent, true) } return r.rewatch(newpath, uint32(oldevent), uint32(newevent), true) } // TODO : (pknap) doc. func (r *readdcw) rewatch(path string, oldevent, newevent uint32, recursive bool) (err error) { if Event(newevent)&^(All|fileNotifyChangeAll) != 0 { return errors.New("notify: unknown event") } var wd *watched r.Lock() defer r.Unlock() if wd, err = r.nonStateWatchedLocked(path); err != nil { return } if wd.filter&(onlyNotifyChanges|onlyNGlobalEvents) != oldevent { panic(`notify: windows re-watcher logic error`) } wd.filter = stateRewatch | newevent wd.recursive, recursive = recursive, wd.recursive if err = wd.closeHandle(); err != nil { wd.filter = oldevent wd.recursive = recursive return } return } // TODO : pknap func (r *readdcw) nonStateWatchedLocked(path string) (wd *watched, err error) { wd, ok := r.m[path] if !ok || wd == nil { err = errors.New(`notify: ` + path + ` path is unwatched`) return } if wd.filter&onlyMachineStates != 0 { err = errors.New(`notify: another re/unwatching operation in progress`) return } return } // Unwatch implements notify.Watcher interface. func (r *readdcw) Unwatch(path string) error { return r.unwatch(path) } // RecursiveUnwatch implements notify.RecursiveWatcher interface. func (r *readdcw) RecursiveUnwatch(path string) error { return r.unwatch(path) } // TODO : pknap func (r *readdcw) unwatch(path string) (err error) { var wd *watched r.Lock() defer r.Unlock() if wd, err = r.nonStateWatchedLocked(path); err != nil { return } wd.filter |= stateUnwatch dbgprint("unwatch: set unwatch state") if _, attrErr := syscall.GetFileAttributes(&wd.pathw[0]); attrErr != nil { for _, g := range wd.digrip { if g == nil { continue } dbgprint("unwatch: posting") if err = syscall.PostQueuedCompletionStatus(r.cph, 0, 0, (*syscall.Overlapped)(unsafe.Pointer(g.ovlapped))); err != nil { wd.filter &^= stateUnwatch return } } } return } // Close resets the whole watcher object, closes all existing file descriptors, // and sends stateCPClose state as completion key to the main watcher's loop. func (r *readdcw) Close() (err error) { r.Lock() if !r.start { r.Unlock() return nil } for _, wd := range r.m { wd.filter &^= onlyMachineStates wd.filter |= stateCPClose if e := wd.closeHandle(); e != nil && err == nil { err = e } } r.start = false r.Unlock() r.wg.Add(1) if e := syscall.PostQueuedCompletionStatus(r.cph, 0, stateCPClose, nil); e != nil && err == nil { return e } r.wg.Wait() return } // decode creates a notify event from both non-raw filter and action which was // returned from completion routine. Function may return Event(0) in case when // filter was replaced by a new value which does not contain fields that are // valid with passed action. func decode(filter, action uint32) (Event, Event) { switch action { case syscall.FILE_ACTION_ADDED: return gensys(filter, Create, FileActionAdded) case syscall.FILE_ACTION_REMOVED: return gensys(filter, Remove, FileActionRemoved) case syscall.FILE_ACTION_MODIFIED: return gensys(filter, Write, FileActionModified) case syscall.FILE_ACTION_RENAMED_OLD_NAME: return gensys(filter, Rename, FileActionRenamedOldName) case syscall.FILE_ACTION_RENAMED_NEW_NAME: return gensys(filter, Rename, FileActionRenamedNewName) } dbgprintf("cannot decode internal mask: %d", action) return 0, 0 } // gensys decides whether the Windows action, system-independent event or both // of them should be returned. Since the grip's filter may be atomically changed // during watcher lifetime, it is possible that neither Windows nor notify masks // are watched by the user when this function is called. func gensys(filter uint32, ge, se Event) (gene, syse Event) { isdir := filter&uint32(dirmarker) != 0 if isdir && filter&uint32(FileNotifyChangeDirName) != 0 || !isdir && filter&uint32(FileNotifyChangeFileName) != 0 || filter&uint32(fileNotifyChangeModified) != 0 { syse = se } if filter&uint32(ge) != 0 { gene = ge } return } notify-0.9.3/watcher_readdcw_test.go000066400000000000000000000033241436002677300175610ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build windows // +build windows package notify import "testing" // TODO(ppknap) : remove notify.Create event. func rcreate(w *W, path string) WCase { cas := create(w, path) cas.Events = append(cas.Events, &Call{P: path, E: FileActionAdded}, ) return cas } // TODO(ppknap) : remove notify.Remove event. func rremove(w *W, path string) WCase { cas := remove(w, path) cas.Events = append(cas.Events, &Call{P: path, E: FileActionRemoved}, ) return cas } // TODO(ppknap) : remove notify.Rename event. func rrename(w *W, oldpath, newpath string) WCase { cas := rename(w, oldpath, newpath) cas.Events = append(cas.Events, &Call{P: oldpath, E: FileActionRenamedOldName}, &Call{P: newpath, E: FileActionRenamedNewName}, ) return cas } // TODO(ppknap) : remove notify.Write event. func rwrite(w *W, path string, p []byte) WCase { cas := write(w, path, p) cas.Events = append(cas.Events, &Call{P: path, E: FileActionModified}, ) return cas } var events = []Event{ FileNotifyChangeFileName, FileNotifyChangeDirName, FileNotifyChangeSize, } func TestWatcherReadDirectoryChangesW(t *testing.T) { w := NewWatcherTest(t, "testdata/vfs.txt", events...) defer w.Close() cases := [...]WCase{ rcreate(w, "src/github.com/rjeczalik/fs/fs_windows.go"), rcreate(w, "src/github.com/rjeczalik/fs/subdir/"), rremove(w, "src/github.com/rjeczalik/fs/fs.go"), rrename(w, "src/github.com/rjeczalik/fs/LICENSE", "src/github.com/rjeczalik/fs/COPYLEFT"), rwrite(w, "src/github.com/rjeczalik/fs/cmd/gotree/go.go", []byte("XD")), } w.ExpectAny(cases[:]) } notify-0.9.3/watcher_recursive_test.go000066400000000000000000000054251436002677300201630ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build (darwin && !kqueue && cgo) || windows // +build darwin,!kqueue,cgo windows package notify import ( "fmt" "testing" ) // noevent stripts test-case from expected event list, used when action is not // expected to trigger any events. func noevent(cas WCase) WCase { return WCase{Action: cas.Action} } func TestWatcherRecursiveRewatch(t *testing.T) { w := newWatcherTest(t, "testdata/vfs.txt") defer w.Close() cases := []WCase{ create(w, "src/github.com/rjeczalik/file"), create(w, "src/github.com/rjeczalik/dir/"), noevent(create(w, "src/github.com/rjeczalik/fs/dir/")), noevent(create(w, "src/github.com/dir/")), noevent(write(w, "src/github.com/rjeczalik/file", []byte("XD"))), noevent(rename(w, "src/github.com/rjeczalik/fs/LICENSE", "src/LICENSE")), } w.Watch("src/github.com/rjeczalik", Create) w.ExpectAny(cases) cases = []WCase{ create(w, "src/github.com/rjeczalik/fs/file"), create(w, "src/github.com/rjeczalik/fs/cmd/gotree/file"), create(w, "src/github.com/rjeczalik/fs/cmd/dir/"), create(w, "src/github.com/rjeczalik/fs/cmd/gotree/dir/"), noevent(write(w, "src/github.com/rjeczalik/fs/file", []byte("XD"))), noevent(create(w, "src/github.com/anotherdir/")), } w.RecursiveRewatch("src/github.com/rjeczalik", "src/github.com/rjeczalik", Create, Create) w.ExpectAny(cases) cases = []WCase{ create(w, "src/github.com/rjeczalik/1"), create(w, "src/github.com/rjeczalik/2/"), noevent(create(w, "src/github.com/rjeczalik/fs/cmd/1")), noevent(create(w, "src/github.com/rjeczalik/fs/1/")), noevent(write(w, "src/github.com/rjeczalik/fs/file", []byte("XD"))), } w.Rewatch("src/github.com/rjeczalik", Create, Create) w.ExpectAny(cases) } // TODO(rjeczalik): move to watcher_test.go after #5 func TestIsDirCreateEvent(t *testing.T) { w := NewWatcherTest(t, "testdata/vfs.txt") defer w.Close() cases := [...]WCase{ // i=0 create(w, "src/github.com/jszwec/"), // i=1 create(w, "src/github.com/jszwec/gojunitxml/"), // i=2 create(w, "src/github.com/jszwec/gojunitxml/README.md"), // i=3 create(w, "src/github.com/jszwec/gojunitxml/LICENSE"), // i=4 create(w, "src/github.com/jszwec/gojunitxml/cmd/"), } dirs := [...]bool{ true, // i=0 true, // i=1 false, // i=2 false, // i=3 true, // i=4 } fn := func(i int, _ WCase, ei EventInfo) error { d, ok := ei.(isDirer) if !ok { return fmt.Errorf("received EventInfo does not implement isDirer") } switch ok, err := d.isDir(); { case err != nil: return err case ok != dirs[i]: return fmt.Errorf("want ok=%v; got %v", dirs[i], ok) default: return nil } } w.ExpectAnyFunc(cases[:], fn) } notify-0.9.3/watcher_stub.go000066400000000000000000000010541436002677300160640ustar00rootroot00000000000000// Copyright (c) 2014-2018 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. package notify type watcherStub struct{ error } // Following methods implement notify.watcher interface. func (s watcherStub) Watch(string, Event) error { return s } func (s watcherStub) Rewatch(string, Event, Event) error { return s } func (s watcherStub) Unwatch(string) (err error) { return s } func (s watcherStub) Close() error { return s } notify-0.9.3/watcher_test.go000066400000000000000000000044471436002677300160770ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build darwin || linux || freebsd || dragonfly || netbsd || openbsd || windows || solaris // +build darwin linux freebsd dragonfly netbsd openbsd windows solaris package notify import ( "os" "testing" "time" ) // NOTE Set NOTIFY_DEBUG env var or debug build tag for extra debugging info. func TestWatcher(t *testing.T) { w := NewWatcherTest(t, "testdata/vfs.txt") defer w.Close() cases := [...]WCase{ create(w, "src/github.com/ppknap/link/include/coost/.link.hpp.swp"), create(w, "src/github.com/rjeczalik/fs/fs_test.go"), create(w, "src/github.com/rjeczalik/fs/binfs/"), create(w, "src/github.com/rjeczalik/fs/binfs.go"), create(w, "src/github.com/rjeczalik/fs/binfs_test.go"), remove(w, "src/github.com/rjeczalik/fs/binfs/"), create(w, "src/github.com/rjeczalik/fs/binfs/"), create(w, "src/github.com/rjeczalik/fs/virfs"), remove(w, "src/github.com/rjeczalik/fs/virfs"), create(w, "file"), create(w, "dir/"), } w.ExpectAny(cases[:]) } // Simulates the scenario, where outside of the programs control the base dir // is removed. This is detected and the watch removed. Then the directory is // restored and a new watch set up. func TestStopPathNotExists(t *testing.T) { w := NewWatcherTest(t, "testdata/vfs.txt") defer w.Close() if err := os.RemoveAll(w.root); err != nil { panic(err) } Sync() // Don't check the returned error, as the public function (notify.Stop) // does not return a potential error. As long as everything later on // works as inteded, that's fine time.Sleep(time.Duration(100) * time.Millisecond) w.Watcher.Unwatch(w.root) time.Sleep(time.Duration(100) * time.Millisecond) if err := os.Mkdir(w.root, 0777); err != nil { panic(err) } Sync() w.Watch("", All) drainall(w.C) cases := [...]WCase{ create(w, "file"), create(w, "dir/"), } w.ExpectAny(cases[:]) } func TestWatcherUnwatch(t *testing.T) { w := NewWatcherTest(t, "testdata/vfs.txt") defer w.Close() remove(w, "src/github.com/ppknap/link/test/test_circular_calls.cpp").Action() w.Unwatch("") w.Watch("", All) drainall(w.C) cases := [...]WCase{ create(w, "file"), create(w, "dir/"), } w.ExpectAny(cases[:]) } notify-0.9.3/watcher_trigger.go000066400000000000000000000262601436002677300165600ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build (darwin && kqueue) || (darwin && !cgo) || dragonfly || freebsd || netbsd || openbsd || solaris || illumos // +build darwin,kqueue darwin,!cgo dragonfly freebsd netbsd openbsd solaris illumos // watcher_trigger is used for FEN and kqueue which behave similarly: // only files and dirs can be watched directly, but not files inside dirs. // As a result Create events have to be generated by implementation when // after Write event is returned for watched dir, it is rescanned and Create // event is returned for new files and these are automatically added // to watchlist. In case of removal of watched directory, native system returns // events for all files, but for Rename, they also need to be generated. // As a result native system works as something like trigger for rescan, // but contains additional data about dir in which changes occurred. For files // detailed data is returned. // Usage of watcher_trigger requires: // - trigger implementation, // - encode func, // - not2nat, nat2not maps. // Required manual operations on filesystem can lead to loss of precision. package notify import ( "fmt" "os" "path/filepath" "strings" "sync" "syscall" ) // trigger is to be implemented by platform implementation like FEN or kqueue. type trigger interface { // Close closes watcher's main native file descriptor. Close() error // Stop waiting for new events. Stop() error // Create new instance of watched. NewWatched(string, os.FileInfo) (*watched, error) // Record internally new *watched instance. Record(*watched) // Del removes internal copy of *watched instance. Del(*watched) // Watched returns *watched instance and native events for native type. Watched(interface{}) (*watched, int64, error) // Init initializes native watcher call. Init() error // Watch starts watching provided file/dir. Watch(os.FileInfo, *watched, int64) error // Unwatch stops watching provided file/dir. Unwatch(*watched) error // Wait for new events. Wait() (interface{}, error) // IsStop checks if Wait finished because of request watcher's stop. IsStop(n interface{}, err error) bool } // trgWatched is a the base data structure representing watched file/directory. // The platform specific full data structure (watched) must embed this type. type trgWatched struct { // p is a path to watched file/directory. p string // fi provides information about watched file/dir. fi os.FileInfo // eDir represents events watched directly. eDir Event // eNonDir represents events watched indirectly. eNonDir Event } // encode Event to native representation. Implementation is to be provided by // platform specific implementation. var encode func(Event, bool) int64 var ( // nat2not matches native events to notify's ones. To be initialized by // platform dependent implementation. nat2not map[Event]Event // not2nat matches notify's events to native ones. To be initialized by // platform dependent implementation. not2nat map[Event]Event ) // trg is a main structure implementing watcher. type trg struct { sync.Mutex // s is a channel used to stop monitoring. s chan struct{} // c is a channel used to pass events further. c chan<- EventInfo // pthLkp is a data structure mapping file names with data about watching // represented by them files/directories. pthLkp map[string]*watched // t is a platform dependent implementation of trigger. t trigger } // newWatcher returns new watcher's implementation. func newWatcher(c chan<- EventInfo) watcher { t := &trg{ s: make(chan struct{}, 1), pthLkp: make(map[string]*watched, 0), c: c, } t.t = newTrigger(t.pthLkp) if err := t.t.Init(); err != nil { t.Close() return watcherStub{fmt.Errorf("failed setting up watcher: %v", err)} } go t.monitor() return t } // Close implements watcher. func (t *trg) Close() (err error) { t.Lock() if err = t.t.Stop(); err != nil { t.Unlock() return } <-t.s var e error for _, w := range t.pthLkp { if e = t.unwatch(w.p, w.fi); e != nil { dbgprintf("trg: unwatch %q failed: %q\n", w.p, e) err = nonil(err, e) } } if e = t.t.Close(); e != nil { dbgprintf("trg: closing native watch failed: %q\n", e) err = nonil(err, e) } if remaining := len(t.pthLkp); remaining != 0 { err = nonil(err, fmt.Errorf("Not all watches were removed: len(t.pthLkp) == %v", len(t.pthLkp))) } t.Unlock() return } // send reported events one by one through chan. func (t *trg) send(evn []event) { for i := range evn { t.c <- &evn[i] } } // singlewatch starts to watch given p file/directory. func (t *trg) singlewatch(p string, e Event, direct mode, fi os.FileInfo) (err error) { w, ok := t.pthLkp[p] if !ok { if w, err = t.t.NewWatched(p, fi); err != nil { if err == errSkip { err = nil } return } } switch direct { case dir: w.eDir |= e case ndir: w.eNonDir |= e case both: w.eDir |= e w.eNonDir |= e } if err = t.t.Watch(fi, w, encode(w.eDir|w.eNonDir, fi.IsDir())); err != nil { return } if !ok { t.t.Record(w) return nil } return errAlreadyWatched } // decode converts event received from native to notify.Event // representation taking into account requested events (w). func decode(o int64, w Event) (e Event) { for f, n := range nat2not { if o&int64(f) != 0 { if w&f != 0 { e |= f } if w&n != 0 { e |= n } } } return } func (t *trg) watch(p string, e Event, fi os.FileInfo) error { if err := t.singlewatch(p, e, dir, fi); err != nil { if err != errAlreadyWatched { return err } } if fi.IsDir() { err := t.walk(p, func(fi os.FileInfo) (err error) { if err = t.singlewatch(filepath.Join(p, fi.Name()), e, ndir, fi); err != nil { if err != errAlreadyWatched { return } } return nil }) if err != nil { return err } } return nil } // walk runs f func on each file/dir from p directory. func (t *trg) walk(p string, fn func(os.FileInfo) error) error { fp, err := os.Open(p) if err != nil { return err } ls, err := fp.Readdir(0) fp.Close() if err != nil { return err } for i := range ls { if err := fn(ls[i]); err != nil { return err } } return nil } func (t *trg) unwatch(p string, fi os.FileInfo) error { if fi.IsDir() { err := t.walk(p, func(fi os.FileInfo) error { err := t.singleunwatch(filepath.Join(p, fi.Name()), ndir) if err != errNotWatched { return err } return nil }) if err != nil { return err } } return t.singleunwatch(p, dir) } // Watch implements Watcher interface. func (t *trg) Watch(p string, e Event) error { fi, err := os.Stat(p) if err != nil { return err } t.Lock() err = t.watch(p, e, fi) t.Unlock() return err } // Unwatch implements Watcher interface. func (t *trg) Unwatch(p string) error { fi, err := os.Stat(p) if err != nil { return err } t.Lock() err = t.unwatch(p, fi) t.Unlock() return err } // Rewatch implements Watcher interface. // // TODO(rjeczalik): This is a naive hack. Rewrite might help. func (t *trg) Rewatch(p string, _, e Event) error { fi, err := os.Stat(p) if err != nil { return err } t.Lock() if err = t.unwatch(p, fi); err == nil { // TODO(rjeczalik): If watch fails then we leave trigger in inconsistent // state. Handle? Panic? Native version of rewatch? err = t.watch(p, e, fi) } t.Unlock() return nil } func (*trg) file(w *watched, n interface{}, e Event) (evn []event) { evn = append(evn, event{w.p, e, w.fi.IsDir(), n}) return } func (t *trg) dir(w *watched, n interface{}, e, ge Event) (evn []event) { // If it's dir and delete we have to send it and continue, because // other processing relies on opening (in this case not existing) dir. // Events for contents of this dir are reported by native impl. // However events for rename must be generated for all monitored files // inside of moved directory, because native impl does not report it independently // for each file descriptor being moved in result of move action on // parent directory. if (ge & (not2nat[Rename] | not2nat[Remove])) != 0 { // Write is reported also for Remove on directory. Because of that // we have to filter it out explicitly. evn = append(evn, event{w.p, e & ^Write & ^not2nat[Write], true, n}) if ge¬2nat[Rename] != 0 { for p := range t.pthLkp { if strings.HasPrefix(p, w.p+string(os.PathSeparator)) { if err := t.singleunwatch(p, both); err != nil && err != errNotWatched && !os.IsNotExist(err) { dbgprintf("trg: failed stop watching moved file (%q): %q\n", p, err) } if (w.eDir|w.eNonDir)&(not2nat[Rename]|Rename) != 0 { evn = append(evn, event{ p, (w.eDir | w.eNonDir) & e &^ Write &^ not2nat[Write], w.fi.IsDir(), nil, }) } } } } t.t.Del(w) return } if (ge & not2nat[Write]) != 0 { switch err := t.walk(w.p, func(fi os.FileInfo) error { p := filepath.Join(w.p, fi.Name()) switch err := t.singlewatch(p, w.eDir, ndir, fi); { case os.IsNotExist(err) && ((w.eDir & Remove) != 0): evn = append(evn, event{p, Remove, fi.IsDir(), n}) case err == errAlreadyWatched: case err != nil: dbgprintf("trg: watching %q failed: %q", p, err) case (w.eDir & Create) != 0: evn = append(evn, event{p, Create, fi.IsDir(), n}) default: } return nil }); { case os.IsNotExist(err): return case err != nil: dbgprintf("trg: dir processing failed: %q", err) default: } } return } type mode uint const ( dir mode = iota ndir both ) // unwatch stops watching p file/directory. func (t *trg) singleunwatch(p string, direct mode) error { w, ok := t.pthLkp[p] if !ok { return errNotWatched } switch direct { case dir: w.eDir = 0 case ndir: w.eNonDir = 0 case both: w.eDir, w.eNonDir = 0, 0 } if err := t.t.Unwatch(w); err != nil { return err } if w.eNonDir|w.eDir != 0 { mod := dir if w.eNonDir != 0 { mod = ndir } if err := t.singlewatch(p, w.eNonDir|w.eDir, mod, w.fi); err != nil && err != errAlreadyWatched { return err } } else { t.t.Del(w) } return nil } func (t *trg) monitor() { var ( n interface{} err error ) for { switch n, err = t.t.Wait(); { case err == syscall.EINTR: case t.t.IsStop(n, err): t.s <- struct{}{} return case err != nil: dbgprintf("trg: failed to read events: %q\n", err) default: t.send(t.process(n)) } } } // process event returned by native call. func (t *trg) process(n interface{}) (evn []event) { t.Lock() w, ge, err := t.t.Watched(n) if err != nil { t.Unlock() dbgprintf("trg: %v event lookup failed: %q", Event(ge), err) return } e := decode(ge, w.eDir|w.eNonDir) if ge&int64(not2nat[Remove]|not2nat[Rename]) == 0 { switch fi, err := os.Stat(w.p); { case err != nil: default: if err = t.t.Watch(fi, w, encode(w.eDir|w.eNonDir, fi.IsDir())); err != nil { dbgprintf("trg: %q is no longer watched: %q", w.p, err) t.t.Del(w) } } } if e == Event(0) && (!w.fi.IsDir() || (ge&int64(not2nat[Write])) == 0) { t.Unlock() return } if w.fi.IsDir() { evn = append(evn, t.dir(w, n, e, Event(ge))...) } else { evn = append(evn, t.file(w, n, e)...) } if Event(ge)&(not2nat[Remove]|not2nat[Rename]) != 0 { t.t.Del(w) } t.Unlock() return } notify-0.9.3/watcher_trigger_test.go000066400000000000000000000011451436002677300176120ustar00rootroot00000000000000// Copyright (c) 2014-2017 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build (darwin && kqueue) || (darwin && !cgo) || dragonfly || freebsd || netbsd || openbsd || solaris || illumos // +build darwin,kqueue darwin,!cgo dragonfly freebsd netbsd openbsd solaris illumos package notify import "testing" func TestWatcherCreateOnly(t *testing.T) { w := NewWatcherTest(t, "testdata/vfs.txt", Create) defer w.Close() cases := [...]WCase{ create(w, "dir/"), create(w, "dir2/"), } w.ExpectAny(cases[:]) } notify-0.9.3/watchpoint.go000066400000000000000000000046531436002677300155620ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. package notify // EventDiff describes a change to an event set - EventDiff[0] is an old state, // while EventDiff[1] is a new state. If event set has not changed (old == new), // functions typically return the None value. type eventDiff [2]Event func (diff eventDiff) Event() Event { return diff[1] &^ diff[0] } // Watchpoint // // The nil key holds total event set - logical sum for all registered events. // It speeds up computing EventDiff for Add method. // // The rec key holds an event set for a watchpoints created by RecursiveWatch // for a Watcher implementation which is not natively recursive. type watchpoint map[chan<- EventInfo]Event // None is an empty event diff, think null object. var none eventDiff // rec is just a placeholder var rec = func() (ch chan<- EventInfo) { ch = make(chan<- EventInfo) close(ch) return }() func (wp watchpoint) dryAdd(ch chan<- EventInfo, e Event) eventDiff { if e &^= internal; wp[ch]&e == e { return none } total := wp[ch] &^ internal return eventDiff{total, total | e} } // Add assumes neither c nor e are nil or zero values. func (wp watchpoint) Add(c chan<- EventInfo, e Event) (diff eventDiff) { wp[c] |= e diff[0] = wp[nil] diff[1] = diff[0] | e wp[nil] = diff[1] &^ omit // Strip diff from internal events. diff[0] &^= internal diff[1] &^= internal if diff[0] == diff[1] { return none } return } func (wp watchpoint) Del(c chan<- EventInfo, e Event) (diff eventDiff) { wp[c] &^= e if wp[c] == 0 { delete(wp, c) } diff[0] = wp[nil] delete(wp, nil) if len(wp) != 0 { // Recalculate total event set. for _, e := range wp { diff[1] |= e } wp[nil] = diff[1] &^ omit } // Strip diff from internal events. diff[0] &^= internal diff[1] &^= internal if diff[0] == diff[1] { return none } return } func (wp watchpoint) Dispatch(ei EventInfo, extra Event) { e := eventmask(ei, extra) if !matches(wp[nil], e) { return } for ch, eset := range wp { if ch != nil && matches(eset, e) { select { case ch <- ei: default: // Drop event if receiver is too slow dbgprintf("dropped %s on %q: receiver too slow", ei.Event(), ei.Path()) } } } } func (wp watchpoint) Total() Event { return wp[nil] &^ internal } func (wp watchpoint) IsRecursive() bool { return wp[nil]&recursive != 0 } notify-0.9.3/watchpoint_other.go000066400000000000000000000014011436002677300167470ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build !windows // +build !windows package notify // eventmask uses ei to create a new event which contains internal flags used by // notify package logic. func eventmask(ei EventInfo, extra Event) Event { return ei.Event() | extra } // matches reports a match only when: // // - for user events, when event is present in the given set // - for internal events, when additionally both event and set have omit bit set // // Internal events must not be sent to user channels and vice versa. func matches(set, event Event) bool { return (set&omit)^(event&omit) == 0 && set&event == event } notify-0.9.3/watchpoint_readdcw.go000066400000000000000000000023761436002677300172530ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. //go:build windows // +build windows package notify // eventmask uses ei to create a new event which contains internal flags used by // notify package logic. If one of FileAction* masks is detected, this function // adds corresponding FileNotifyChange* values. This allows non registered // FileAction* events to be passed on. func eventmask(ei EventInfo, extra Event) (e Event) { if e = ei.Event() | extra; e&fileActionAll != 0 { if ev, ok := ei.(*event); ok { switch ev.ftype { case fTypeFile: e |= FileNotifyChangeFileName case fTypeDirectory: e |= FileNotifyChangeDirName case fTypeUnknown: e |= fileNotifyChangeModified } return e &^ fileActionAll } } return } // matches reports a match only when: // // - for user events, when event is present in the given set // - for internal events, when additionally both event and set have omit bit set // // Internal events must not be sent to user channels and vice versa. func matches(set, event Event) bool { return (set&omit)^(event&omit) == 0 && (set&event == event || set&fileNotifyChangeModified&event != 0) } notify-0.9.3/watchpoint_test.go000066400000000000000000000071511436002677300166150ustar00rootroot00000000000000// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. package notify import ( "fmt" "reflect" "testing" ) func call(wp watchpoint, fn interface{}, args []interface{}) eventDiff { vals := []reflect.Value{reflect.ValueOf(wp)} for _, arg := range args { vals = append(vals, reflect.ValueOf(arg)) } res := reflect.ValueOf(fn).Call(vals) if n := len(res); n != 1 { panic(fmt.Sprintf("unexpected len(res)=%d", n)) } diff, ok := res[0].Interface().(eventDiff) if !ok { panic(fmt.Sprintf("want typeof(diff)=EventDiff; got %T", res[0].Interface())) } return diff } func TestWatchpoint(t *testing.T) { ch := NewChans(5) all := All | recursive cases := [...]struct { fn interface{} args []interface{} diff eventDiff total Event }{ // i=0 { watchpoint.Add, []interface{}{ch[0], Remove}, eventDiff{0, Remove}, Remove, }, // i=1 { watchpoint.Add, []interface{}{ch[1], Create | Remove | recursive}, eventDiff{Remove, Remove | Create}, Create | Remove | recursive, }, // i=2 { watchpoint.Add, []interface{}{ch[2], Create | Rename}, eventDiff{Create | Remove, Create | Remove | Rename}, Create | Remove | Rename | recursive, }, // i=3 { watchpoint.Add, []interface{}{ch[0], Write | recursive}, eventDiff{Create | Remove | Rename, Create | Remove | Rename | Write}, Create | Remove | Rename | Write | recursive, }, // i=4 { watchpoint.Add, []interface{}{ch[2], Remove | recursive}, none, Create | Remove | Rename | Write | recursive, }, // i=5 { watchpoint.Del, []interface{}{ch[0], all}, eventDiff{Create | Remove | Rename | Write, Create | Remove | Rename}, Create | Remove | Rename | recursive, }, // i=6 { watchpoint.Del, []interface{}{ch[2], all}, eventDiff{Create | Remove | Rename, Create | Remove}, Create | Remove | recursive, }, // i=7 { watchpoint.Add, []interface{}{ch[3], Create | Remove}, none, Create | Remove | recursive, }, // i=8 { watchpoint.Del, []interface{}{ch[1], all}, none, Create | Remove, }, // i=9 { watchpoint.Add, []interface{}{ch[3], recursive | Write}, eventDiff{Create | Remove, Create | Remove | Write}, Create | Remove | Write | recursive, }, // i=10 { watchpoint.Del, []interface{}{ch[3], Create}, eventDiff{Create | Remove | Write, Remove | Write}, Remove | Write | recursive, }, // i=11 { watchpoint.Add, []interface{}{ch[3], Create | Rename}, eventDiff{Remove | Write, Create | Remove | Rename | Write}, Create | Remove | Rename | Write | recursive, }, // i=12 { watchpoint.Add, []interface{}{ch[2], Remove | Write}, none, Create | Remove | Rename | Write | recursive, }, // i=13 { watchpoint.Del, []interface{}{ch[3], Create | Remove | Write}, eventDiff{Create | Remove | Rename | Write, Remove | Rename | Write}, Remove | Rename | Write | recursive, }, // i=14 { watchpoint.Del, []interface{}{ch[2], Remove}, eventDiff{Remove | Rename | Write, Rename | Write}, Rename | Write | recursive, }, // i=15 { watchpoint.Del, []interface{}{ch[3], Rename | recursive}, eventDiff{Rename | Write, Write}, Write, }, } wp := watchpoint{} for i, cas := range cases { if diff := call(wp, cas.fn, cas.args); diff != cas.diff { t.Errorf("want diff=%v; got %v (i=%d)", cas.diff, diff, i) continue } if total := wp[nil]; total != cas.total { t.Errorf("want total=%v; got %v (i=%d)", cas.total, total, i) continue } } }