piframe-go/vendor/github.com/knadh/koanf/providers/file/file.go
2020-09-02 23:46:55 -04:00

129 lines
3 KiB
Go

// Package file implements a koanf.Provider that reads raw bytes
// from files on disk to be used with a koanf.Parser to parse
// into conf maps.
package file
import (
"errors"
"fmt"
"io/ioutil"
"path/filepath"
"time"
"github.com/fsnotify/fsnotify"
)
// File implements a File provider.
type File struct {
path string
}
// Provider returns a file provider.
func Provider(path string) *File {
return &File{path: filepath.Clean(path)}
}
// ReadBytes reads the contents of a file on disk and returns the bytes.
func (f *File) ReadBytes() ([]byte, error) {
return ioutil.ReadFile(f.path)
}
// Read is not supported by the file provider.
func (f *File) Read() (map[string]interface{}, error) {
return nil, errors.New("file provider does not support this method")
}
// Watch watches the file and triggers a callback when it changes. It is a
// blocking function that internally spawns a goroutine to watch for changes.
func (f *File) Watch(cb func(event interface{}, err error)) error {
// Resolve symlinks and save the original path so that changes to symlinks
// can be detected.
realPath, err := filepath.EvalSymlinks(f.path)
if err != nil {
return err
}
realPath = filepath.Clean(realPath)
// Although only a single file is being watched, fsnotify has to watch
// the whole parent directory to pick up all events such as symlink changes.
fDir, _ := filepath.Split(f.path)
w, err := fsnotify.NewWatcher()
if err != nil {
return err
}
var (
lastEvent string
lastEventTime time.Time
)
go func() {
loop:
for {
select {
case event, ok := <-w.Events:
if !ok {
cb(nil, errors.New("fsnotify watch channel closed"))
break loop
}
// Use a simple timer to buffer events as certain events fire
// multiple times on some platforms.
if event.String() == lastEvent && time.Since(lastEventTime) < time.Millisecond*5 {
continue
}
lastEvent = event.String()
lastEventTime = time.Now()
evFile := filepath.Clean(event.Name)
// Since the event is triggered on a directory, is this
// one on the file being watched?
if evFile != realPath && evFile != f.path {
continue
}
// The file was removed.
if event.Op&fsnotify.Remove != 0 {
cb(nil, fmt.Errorf("file %s was removed", event.Name))
break loop
}
// Resolve symlink to get the real path, in case the symlink's
// target has changed.
curPath, err := filepath.EvalSymlinks(f.path)
if err != nil {
cb(nil, err)
break loop
}
realPath = filepath.Clean(curPath)
// Finally, we only care about create and write.
if event.Op&(fsnotify.Write|fsnotify.Create) == 0 {
continue
}
// Trigger event.
cb(nil, nil)
// There's an error.
case err, ok := <-w.Errors:
if !ok {
cb(nil, errors.New("fsnotify err channel closed"))
break loop
}
// Pass the error to the callback.
cb(nil, err)
break loop
}
}
w.Close()
}()
// Watch the directory for changes.
return w.Add(fDir)
}