// WatchDirectoryChanges watches a directory and fires the callback with the changed name, receives a logger just to print with red letters any errors, no need for second callback.
func WatchDirectoryChanges(rootPath string, evt func(filename string), logger *logger.Logger) {
isWindows := runtime.GOOS == "windows"
watcher, werr := fsnotify.NewWatcher()
if werr != nil {
logger.Dangerf(werr.Error())
return
}
go func() {
var lastChange = time.Now()
var i = 0
for {
select {
case event := <-watcher.Events:
if event.Op&fsnotify.Write == fsnotify.Write {
//this is received two times, the last time is the real changed file, so
i++
if i%2 == 0 || !isWindows { // this 'hack' works for windows but I dont know if works for linux too, we can wait for issue reports here.
if time.Now().After(lastChange.Add(time.Duration(1) * time.Second)) {
lastChange = time.Now()
evt(event.Name)
}
}
}
case err := <-watcher.Errors:
logger.Dangerf(err.Error())
}
}
}()
werr = watcher.Add(rootPath)
if werr != nil {
logger.Dangerf(werr.Error())
}
}
func (s *shardedSearcher) watch() error {
watcher, err := fsnotify.NewWatcher()
if err != nil {
return err
}
if err := watcher.Add(s.dir); err != nil {
return err
}
go func() {
for {
select {
case <-watcher.Events:
s.scan()
case err := <-watcher.Errors:
if err != nil {
log.Println("watcher error:", err)
}
case <-s.quit:
watcher.Close()
return
}
}
}()
return nil
}
// New creates a new Watcher and begins watching events
func New() (*Watcher, error) {
watcher, err := fsnotify.NewWatcher()
if err != nil {
return nil, err
}
w := &Watcher{
watcher: watcher,
watches: make(map[string][]chan<- Event),
stop: make(chan struct{}, 1),
}
go w.run()
return w, nil
}
func (e *CodeEditor) watcherSetup() {
var err error
e.watcher, err = fsnotify.NewWatcher()
if err != nil {
log.Printf("Error creating new fsnotify watcher: %s", err)
}
}
func ExampleNewWatcher() {
watcher, err := fsnotify.NewWatcher()
if err != nil {
log.Fatal(err)
}
defer watcher.Close()
done := make(chan bool)
go func() {
for {
select {
case event := <-watcher.Events:
log.Println("event:", event)
if event.Op&fsnotify.Write == fsnotify.Write {
log.Println("modified file:", event.Name)
}
case err := <-watcher.Errors:
log.Println("error:", err)
}
}
}()
err = watcher.Add("/tmp/foo")
if err != nil {
log.Fatal(err)
}
<-done
}
func NewWatcher(file string) {
watcher, err := fsnotify.NewWatcher()
if err != nil {
log.Fatal(err)
}
defer watcher.Close()
done := make(chan bool)
go func() {
for {
select {
case event := <-watcher.Events:
if event.Op&fsnotify.Write == fsnotify.Write {
log.Println("modified file:", event.Name)
} else if event.Op&fsnotify.Rename == fsnotify.Rename {
log.Println("rename file:", event.Name)
} else {
log.Println("event:", event)
}
case err := <-watcher.Errors:
log.Println("error:", err)
}
}
}()
err = watcher.Add(file)
if err != nil {
log.Fatal(err)
}
<-done
}
// NewEventWatcher returns an fs-event based file watcher
func NewEventWatcher() (FileWatcher, error) {
watcher, err := fsnotify.NewWatcher()
if err != nil {
return nil, err
}
return &fsNotifyWatcher{watcher}, nil
}
func NewSession(options *Options) *Session {
if options.GOROOT == "" {
options.GOROOT = build.Default.GOROOT
}
if options.GOPATH == "" {
options.GOPATH = build.Default.GOPATH
}
options.Verbose = options.Verbose || options.Watch
s := &Session{
options: options,
Archives: make(map[string]*compiler.Archive),
}
s.Types = make(map[string]*types.Package)
if options.Watch {
if out, err := exec.Command("ulimit", "-n").Output(); err == nil {
if n, err := strconv.Atoi(strings.TrimSpace(string(out))); err == nil && n < 1024 {
fmt.Printf("Warning: The maximum number of open file descriptors is very low (%d). Change it with 'ulimit -n 8192'.\n", n)
}
}
var err error
s.Watcher, err = fsnotify.NewWatcher()
if err != nil {
panic(err)
}
}
return s
}
func startFileWatcher(file string) *fsnotify.Watcher {
watcher, err := fsnotify.NewWatcher()
if err != nil {
log.Fatal(err)
}
go func() {
for {
select {
case event := <-watcher.Events:
log.Println("evt:", event)
if event.Op&fsnotify.Write == fsnotify.Write {
log.Println("modified file:", event.Name)
}
case err := <-watcher.Errors:
log.Println("error:", err)
}
}
}()
err = watcher.Add(file)
if err != nil {
log.Fatal(err)
}
return watcher
}
func registerVM(vm *modules.JsVm) otto.Value {
watcher, err := fsnotify.NewWatcher()
//defer watcher.Close()
if err != nil {
log.Println(pluginName + " " + err.Error())
}
obj, _ := vm.Object("({})")
obj.Set("watchDir", func(c otto.FunctionCall) otto.Value {
path, _ := c.Argument(0).ToString()
err := watcher.Add(path)
return modules.ToResult(vm, true, err)
})
obj.Set("start", func(c otto.FunctionCall) otto.Value {
log.Println(pluginName + " start")
go func() {
for {
select {
case ev := <-watcher.Events:
log.Println("event:", ev.String())
case err := <-watcher.Errors:
log.Println("error:", err)
}
}
}()
return otto.TrueValue()
})
return obj.Value()
}
func (p *ProjectTree) SetRoot(path string) {
p.layout.RemoveAll()
p.SetTOC(nil)
p.tocCtl = nil
if p.watcher != nil {
p.watcher.Close()
}
watcher, err := fsnotify.NewWatcher()
if err != nil {
log.Printf("Error creating project tree watcher: %s", err)
}
p.watcher = watcher
p.startWatch(path)
p.dirs = newDirectory(p, path)
scrollable := p.theme.CreateScrollLayout()
// Disable horiz scrolling until we can figure out an accurate
// way to calculate our width.
scrollable.SetScrollAxis(false, true)
scrollable.SetChild(p.dirs)
p.layout.AddChild(scrollable)
p.layout.SetChildWeight(p.dirs, 1)
// Expand the top level
p.dirs.button.Click(gxui.MouseEvent{})
}
func (jitome *Jitome) Start() error {
// check init task
// register watchers
for name, target := range jitome.config.Targets {
if name == "init" {
continue
}
target.Name = name
target.events = make(chan *Event, 30)
target.jitome = jitome
log.Print("evaluating target '" + FgCB(name) + "'.")
// register watched directories
for i, watchConfig := range target.Watch {
watchConfig.InitPatterns()
w, err := fsnotify.NewWatcher()
if err != nil {
return err
}
err = watch(watchConfig.Base, watchConfig.ignoreRegs, w)
if err != nil {
return err
}
watcher, err := NewWatcher(jitome, target, watchConfig, w, i)
if err != nil {
return err
}
jitome.watchers = append(jitome.watchers, watcher)
go watcher.Wait()
}
go target.Wait()
}
defer jitome.Close()
go func() {
log.Print("watching files...")
for {
event := <-jitome.events
runTarget(event)
}
}()
go func() {
err := jitome.restartCommand()
if err != nil {
log.Print(FgRB(fmt.Sprintf("[warning] %v", err)))
}
}()
// wait infinitely.
select {}
}
func newDispatcher() (*dispatcher, error) {
watcher, err := fsnotify.NewWatcher()
if err != nil {
return nil, err
}
d := &dispatcher{watcher: watcher, closer: make(chan struct{}), routes: map[string]chan struct{}{}}
go d.listen()
return d, nil
}
func main() {
flag.Parse()
file, err := ioutil.ReadFile(*configFile)
if err != nil {
log.Fatal("unable to read config file, exiting...")
}
if err := json.Unmarshal(file, &parsedConfig); err != nil {
log.Fatal("unable to marshal config file, exiting...")
}
// fire up filesystem watcher
mywatcher, err = fsnotify.NewWatcher()
if err != nil {
log.Fatal("error creating fswatcher: ", err)
}
if err := createDirs(parsedConfig); err != nil {
log.Println(err)
log.Fatalf("error creating directory structure, exiting")
}
go func() {
for {
select {
case event := <-mywatcher.Events:
if (event.Op&fsnotify.Write == fsnotify.Write) || (event.Op&fsnotify.Create == fsnotify.Create) || (event.Op&fsnotify.Remove == fsnotify.Remove) {
log.Println("modified file:", event.Name)
mutex.Lock()
log.Println("got lock, updating package list...")
distroArch := destructPath(event.Name)
if filepath.Base(event.Name) != "Packages.gz" {
if err := createPackagesGz(parsedConfig, distroArch[0], distroArch[1]); err != nil {
log.Println("error creating package: %s", err)
}
}
mutex.Unlock()
}
case err := <-mywatcher.Errors:
log.Println("error:", err)
}
}
}()
http.Handle("/", http.StripPrefix("/", http.FileServer(http.Dir(parsedConfig.RootRepoPath))))
http.Handle("/upload", uploadHandler(parsedConfig))
http.Handle("/delete", deleteHandler(parsedConfig))
if parsedConfig.EnableSSL {
log.Println("running with SSL enabled")
log.Fatal(http.ListenAndServeTLS(":"+parsedConfig.ListenPort, parsedConfig.SSLCert, parsedConfig.SSLKey, nil))
} else {
log.Println("running without SSL enabled")
log.Fatal(http.ListenAndServe(":"+parsedConfig.ListenPort, nil))
}
}
// NewWatcher create the new watcher
func NewWatcher() (*FileWatcher, error) {
tmpWatcher, err := fsnotify.NewWatcher()
if err != nil {
return nil, err
}
w := &FileWatcher{
watcher: tmpWatcher,
}
return w, nil
}
func newLql(c *Cli) *lql {
watcher, err := fsnotify.NewWatcher()
if err != nil {
panic(err.Error())
}
return &lql{
c: c,
w: watcher,
files: make(map[string]*datafile),
}
}
//start filesystem watcher
func (engine *Engine) StartFSWatcher() error {
var err error
engine.watcher, err = fsnotify.NewWatcher()
if err != nil {
return err
}
go func() {
for {
select {
case event := <-engine.watcher.Events:
if event.Op&fsnotify.Write == fsnotify.Write {
if strings.HasSuffix(event.Name, engine.sqlTemplate.Extension) {
err = engine.reloadSqlTemplate(event.Name)
if err != nil {
engine.logger.Error(err)
}
}
if strings.HasSuffix(event.Name, engine.sqlMap.Extension) {
err = engine.reloadSqlMap(event.Name)
if err != nil {
engine.logger.Error(err)
}
}
}
case err := <-engine.watcher.Errors:
if err != nil {
engine.logger.Error(err)
}
}
}
}()
if engine.sqlMap.SqlMapRootDir != "" {
err = engine.watcher.Add(engine.sqlMap.SqlMapRootDir)
if err != nil {
return err
}
}
if engine.sqlTemplate.SqlTemplateRootDir != "" {
err = engine.watcher.Add(engine.sqlTemplate.SqlTemplateRootDir)
if err != nil {
return err
}
}
return nil
}
func New(flagSet *flag.FlagSet, dirPath string, logger loggerCompatible) (*Updater, error) {
watcher, err := fsnotify.NewWatcher()
if err != nil {
return nil, fmt.Errorf("flagz: error initializing fsnotify watcher.")
}
return &Updater{
flagSet: flagSet,
logger: logger,
dirPath: dirPath,
watcher: watcher,
}, nil
}
// waitForSockets will monitor socketFolder and return a channel that is closed
// when vncSocketFile and qmpSocketFile have been created.
func (vm *VirtualMachine) waitForSockets() (<-chan error, error) {
done := make(chan error)
// Cache socket folder here to avoid race conditions
socketFolder := vm.socketFolder
// Setup file monitoring, if there is an error here we panic, this should
// always be reliable.
w, err := fsnotify.NewWatcher()
if err != nil {
return nil, fmt.Errorf("Failed to setup file system monitoring, error: %s", err)
}
err = w.Add(socketFolder)
if err != nil {
return nil, fmt.Errorf("Failed to monitor socket folder, error: %s", err)
}
// Handle events, and close the done channel when sockets are ready
go func() {
vncReady := false
qmpReady := false
for !vncReady || !qmpReady {
select {
case e := <-w.Events:
debug("fs-event: %s", e)
if e.Op == fsnotify.Create {
if e.Name == filepath.Join(socketFolder, vncSocketFile) {
vncReady = true
}
if e.Name == filepath.Join(socketFolder, qmpSocketFile) {
qmpReady = true
}
}
case <-vm.Done:
// Stop monitoring if QEMU has crashed
w.Close()
return
case <-time.After(90 * time.Second):
done <- fmt.Errorf("vnc and qmp sockets didn't show up in 90s")
w.Close()
return
case err := <-w.Errors:
done <- fmt.Errorf("Error monitoring file system, error: %s", err)
w.Close()
return
}
}
w.Close()
close(done)
}()
return done, nil
}
func ExampleNewWatcher(paths []string) {
watcher, err := fsnotify.NewWatcher()
if err != nil {
fmt.Println(err.Error())
}
defer watcher.Close()
done := make(chan bool)
go func() {
for {
select {
case event := <-watcher.Events:
if event.Op&fsnotify.Write == fsnotify.Write || event.Op&fsnotify.Create == fsnotify.Create {
iscompress := true
if !checkIfWatchExt(event.Name) {
continue
}
mt := getFileModTime(event.Name)
if t := eventTime[event.Name]; mt == t {
//fmt.Println("[SKIP] # %s #", event.String())
iscompress = false
}
//fmt.Println("file:", event.Name, iscompress, event.Op, fsnotify.Write, event.Op&fsnotify.Write)
if iscompress {
fmt.Println("modified file:", event.Name)
icmd := exec.Command("uglifyjs", event.Name, "-m", "-o", event.Name)
err1 := icmd.Run()
if err1 != nil {
fmt.Println(err1.Error())
} else {
eventTime[event.Name] = time.Now().Unix()
}
}
}
case err := <-watcher.Errors:
fmt.Println("error:", err)
}
}
}()
for _, path := range paths {
fmt.Println("[TRAC] Directory( %s )", path)
err = watcher.Add(path)
if err != nil {
fmt.Println("[ERRO] Fail to watch directory[ %s ]", err.Error())
//os.Exit(2)
}
}
<-done
}
func New(interval time.Duration) (*Batcher, error) {
watcher, err := fsnotify.NewWatcher()
batcher := &Batcher{}
batcher.Watcher = watcher
batcher.interval = interval
batcher.done = make(chan struct{}, 1)
batcher.Events = make(chan []fsnotify.Event, 1)
if err == nil {
go batcher.run()
}
return batcher, err
}
func TestCreateDirs(t *testing.T) {
pwd, err := os.Getwd()
if err != nil {
t.Errorf("Unable to get current working directory: %s", err)
}
config := Conf{ListenPort: "9666", RootRepoPath: pwd + "/testing", SupportArch: []string{"cats", "dogs"}, DistroNames: []string{"stable"}, EnableSSL: false}
// sanity check...
if config.RootRepoPath != pwd+"/testing" {
t.Errorf("RootRepoPath is %s, should be %s\n ", config.RootRepoPath, pwd+"/testing")
}
mywatcher, err = fsnotify.NewWatcher()
if err != nil {
log.Fatal("error creating fswatcher: ", err)
}
t.Log("creating temp dirs in ", config.RootRepoPath)
if err := createDirs(config); err != nil {
t.Errorf("createDirs() failed ")
}
for _, archDir := range config.SupportArch {
if _, err := os.Stat(config.RootRepoPath + "/dists/stable/main/binary-" + archDir); err != nil {
if os.IsNotExist(err) {
t.Errorf("Directory for %s does not exist", archDir)
}
}
}
// cleanup
if err := os.RemoveAll(config.RootRepoPath); err != nil {
t.Errorf("error cleaning up after createDirs(): %s", err)
}
// create temp file
tempFile, err := os.Create(pwd + "/tempFile")
if err != nil {
t.Fatalf("create %s: %s", pwd+"/tempFile", err)
}
defer tempFile.Close()
config.RootRepoPath = pwd + "/tempFile"
// Can't make directory named after file.
if err := createDirs(config); err == nil {
t.Errorf("createDirs() should have failed but did not")
}
// cleanup
if err := os.RemoveAll(pwd + "/tempFile"); err != nil {
t.Errorf("error cleaning up after createDirs(): %s", err)
}
}
// Init 初始化文件监听
func (fw *fWatcher) Init(debug ...bool) error {
var err error = nil
if len(debug) > 0 {
debug = make([]bool, 1)
debug[0] = false
}
fw.status = STATUS_INIT
fw.watcher, err = fsnotify.NewWatcher()
fw.debug = debug[0]
if err != nil {
return errors.New("初始化filewatcher失败,失败原因:" + err.Error())
}
return nil
}
func NewFileMonitor(fileChangeDelay time.Duration) (FileMonitor, error) {
watcher, err := fsnotify.NewWatcher()
if err != nil {
return nil, err
}
f := fsnotifyMonitor{
watcher: watcher,
}
f.fileChangeDelay = fileChangeDelay
f.changes = make(chan string)
go f.serveListeners()
go f.watch()
return &f, nil
}
func (z *Zone) Reload(shutdown chan bool) error {
if z.NoReload {
return nil
}
watcher, err := fsnotify.NewWatcher()
if err != nil {
return err
}
err = watcher.Add(path.Dir(z.file))
if err != nil {
return err
}
go func() {
// TODO(miek): needs to be killed on reload.
for {
select {
case event := <-watcher.Events:
if path.Clean(event.Name) == z.file {
reader, err := os.Open(z.file)
if err != nil {
log.Printf("[ERROR] Failed to open `%s' for `%s': %v", z.file, z.origin, err)
continue
}
z.reloadMu.Lock()
zone, err := Parse(reader, z.origin, z.file)
if err != nil {
log.Printf("[ERROR] Failed to parse `%s': %v", z.origin, err)
z.reloadMu.Unlock()
continue
}
// copy elements we need
z.Apex = zone.Apex
z.Tree = zone.Tree
z.reloadMu.Unlock()
log.Printf("[INFO] Successfully reloaded zone `%s'", z.origin)
z.Notify()
}
case <-shutdown:
watcher.Close()
return
}
}
}()
return nil
}
func NewRecursiveWatcher(path string, recursive bool) (*RecursiveWatcher, error) {
watcher, err := fsnotify.NewWatcher()
if err != nil {
return nil, err
}
rw := &RecursiveWatcher{watcher, make(map[string]bool)}
if recursive {
if err = rw.AddPath(path); err != nil {
return nil, err
}
} else {
if err := rw.watcher.Add(path); err != nil {
return nil, err
}
rw.paths[path] = true
}
return rw, nil
}
// Init creates a new `fsnotify` watcher observing `path`.
func (w *Watcher) Init() error {
watcher, err := fsnotify.NewWatcher()
if err != nil {
return err
}
err = watcher.Add(w.path)
if err != nil {
return err
}
w.mu.Lock()
defer w.mu.Unlock()
w.watcher = watcher
return nil
}
func (v *Viper) WatchConfig() {
go func() {
watcher, err := fsnotify.NewWatcher()
if err != nil {
log.Fatal(err)
}
defer watcher.Close()
// we have to watch the entire directory to pick up renames/atomic saves in a cross-platform way
filename, err := v.getConfigFile()
if err != nil {
log.Println("error:", err)
return
}
configFile := filepath.Clean(filename)
configDir, _ := filepath.Split(configFile)
done := make(chan bool)
go func() {
for {
select {
case event := <-watcher.Events:
// we only care about the config file
if filepath.Clean(event.Name) == configFile {
if event.Op&fsnotify.Write == fsnotify.Write || event.Op&fsnotify.Create == fsnotify.Create {
err := v.ReadInConfig()
if err != nil {
log.Println("error:", err)
}
v.onConfigChange(event)
}
}
case err := <-watcher.Errors:
log.Println("error:", err)
}
}
}()
watcher.Add(configDir)
<-done
}()
}
func NewRecursiveWatcher(path string) (*RecursiveWatcher, error) {
folders := Subfolders(path)
if len(folders) == 0 {
return nil, errors.New("No folder to watch.")
}
watcher, err := fsnotify.NewWatcher()
if err != nil {
return nil, err
}
rw := &RecursiveWatcher{Watcher: watcher}
rw.Files = make(chan string, 10)
rw.Folders = make(chan string, len(folders))
for _, folder := range folders {
if err = rw.AddFolder(folder); err != nil {
return nil, err
}
}
return rw, nil
}
// Watch starts watching the sources of the given labels for changes and triggers
// rebuilds whenever they change.
// It never returns successfully, it will either watch forever or die.
func Watch(state *core.BuildState, labels []core.BuildLabel) {
watcher, err := fsnotify.NewWatcher()
if err != nil {
log.Fatalf("Error setting up watcher: %s", err)
}
// This sets up the actual watches. It must be done in a separate goroutine.
files := cmap.New()
go startWatching(watcher, state, labels, files)
// If any of the targets are tests, we'll run plz test, otherwise just plz build.
command := "build"
for _, label := range labels {
if state.Graph.TargetOrDie(label).IsTest {
command = "test"
break
}
}
log.Notice("Command: %s", command)
for {
select {
case event := <-watcher.Events:
log.Info("Event: %s", event)
if !files.Has(event.Name) {
log.Notice("Skipping notification for %s", event.Name)
continue
}
// Quick debounce; poll and discard all events for the next brief period.
outer:
for {
select {
case <-watcher.Events:
case <-time.After(debounceInterval):
break outer
}
}
runBuild(state, command, labels)
case err := <-watcher.Errors:
log.Error("Error watching files:", err)
}
}
}
