常量

三个 error

  1. var (
  2.     // ErrDurationTooShort occurs when calling the watcher's Start
  3.     // method with a duration that's less than 1 nanosecond.
  4.     ErrDurationTooShort = errors.New("error: duration is less than 1ns")
  6.     // ErrWatcherRunning occurs when trying to call the watcher's
  7.     // Start method and the polling cycle is still already running
  8.     // from previously calling Start and not yet calling Close.
  9.     ErrWatcherRunning = errors.New("error: watcher is already running")
  11.     // ErrWatchedFileDeleted is an error that occurs when a file or folder that was
  12.     // being watched has been deleted.
  13.     ErrWatchedFileDeleted = errors.New("error: watched file or folder deleted")
  14. )

六个可以检测的操作

  1. // An Op is a type that is used to describe what type
  2. // of event has occurred during the watching process.
  3. type Op uint32
  5. // Ops
  6. const (
  7.     Create Op = iota
  8.     Write
  9.     Remove
  10.     Rename
  11.     Chmod
  12.     Move
  13. )
  15. var ops = map[Op]string{
  16.     Create: "CREATE",
  17.     Write:  "WRITE",
  18.     Remove: "REMOVE",
  19.     Rename: "RENAME",
  20.     Chmod:  "CHMOD",
  21.     Move:   "MOVE",
  22. }
  24. // String prints the string version of the Op consts
  25. func (e Op) String() string {
  26.     if op, found := ops[e]; found {
  27.         return op
  28.     }
  29.     return "???"
  30. }

结构

Event

  1. // An Event describes an event that is received when files or directory
  2. // changes occur. It includes the os.FileInfo of the changed file or
  3. // directory and the type of event that's occurred and the full path of the file.
  4. type Event struct {
  5.     Op
  6.     Path string
  7.     os.FileInfo
  8. }
  10. // String returns a string depending on what type of event occurred and the
  11. // file name associated with the event.
  12. func (e Event) String() string {
  13.     if e.FileInfo != nil {
  14.         pathType := "FILE"
  15.         if e.IsDir() {
  16.             pathType = "DIRECTORY"
  17.         }
  18.         return fmt.Sprintf("%s %q %s [%s]", pathType, e.Name(), e.Op, e.Path)
  19.     }
  20.     return "???"
  21. }

Watcher

  1. // Watcher describes a process that watches files for changes.
  2. type Watcher struct {
  3.     Event  chan Event
  4.     Error  chan error
  5.     Closed chan struct{}
  6.     close  chan struct{}
  7.     wg     *sync.WaitGroup
  9.     // mu protects the following.
  10.     mu           *sync.Mutex
  11.     running      bool
  12.     names        map[string]bool        // bool for recursive or not.
  13.     files        map[string]os.FileInfo // map of files.
  14.     ignored      map[string]struct{}    // ignored files or directories.
  15.     ops          map[Op]struct{}        // Op filtering.
  16.     ignoreHidden bool                   // ignore hidden files or not.
  17.     maxEvents    int                    // max sent events per cycle
  18. }

fileInfo

  1. // fileInfo is an implementation of os.FileInfo that can be used
  2. // as a mocked os.FileInfo when triggering an event when the specified
  3. // os.FileInfo is nil.
  4. type fileInfo struct {
  5.     name    string
  6.     size    int64
  7.     mode    os.FileMode
  8.     modTime time.Time
  9.     sys     interface{}
  10.     dir     bool
  11. }
  13. func (fs *fileInfo) IsDir() bool {
  14.     return fs.dir
  15. }
  16. func (fs *fileInfo) ModTime() time.Time {
  17.     return fs.modTime
  18. }
  19. func (fs *fileInfo) Mode() os.FileMode {
  20.     return fs.mode
  21. }
  22. func (fs *fileInfo) Name() string {
  23.     return fs.name
  24. }
  25. func (fs *fileInfo) Size() int64 {
  26.     return fs.size
  27. }
  28. func (fs *fileInfo) Sys() interface{} {
  29.     return fs.sys
  30. }