golang監聽文件變化的實例

package main
import (
	"log"
	"github.com/fsnotify/fsnotify"
)
func main() {
	watcher, err := fsnotify.NewWatcher()
	if err != nil {
		log.Fatal(err)
	}
	defer watcher.Close()
	done := make(chan bool)
	go func() {
		for {
			select {
			case event, ok := <-watcher.Events:
				if !ok {
					return
				}
				log.Println("event:", event)
				if event.Op&fsnotify.Write == fsnotify.Write {
					log.Println("modified file:", event.Name)
				}
			case err, ok := <-watcher.Errors:
				if !ok {
					return
				}
				log.Println("error:", err)
			}
		}
	}()
	err = watcher.Add("/tmp/foo")
	if err != nil {
		log.Fatal(err)
	}
	<-done
}

package main 
import (
 "fmt"
 _ "fmt"
 "github.com/fsnotify/fsnotify"
 "log"
 "os"
 "os/exec"
 "path/filepath"
 "time"
)
 
//if the conditions are met, execute the shell script
func execCmd() {
 cmd := exec.Command("/root/nfs_bak_pro/nfs.git.sh")
 err := cmd.Run()
 if err != nil {
 fmt.Println("Execute Command failed:" + err.Error())
 return
 }
 fmt.Println("Execute Command finished.")
}
 
//handle folder files changed event
func watchFiles(watcher *fsnotify.Watcher, ch chan int64) {
 for {
 select {
  case ev := <-watcher.Events: {
  isNotify := false
 
  if ev.Op & fsnotify.Create == fsnotify.Create {
   log.Println("create : ", ev.Name)
   isNotify = true
 
   file, err := os.Stat(ev.Name)
   if err == nil && file.IsDir() {
   watcher.Add(ev.Name)
   fmt.Println("add watch : ", ev.Name)
   }
  }
 
  if ev.Op & fsnotify.Remove == fsnotify.Remove {
   log.Println("delete : ", ev.Name)
   isNotify = true
   err := watcher.Remove(ev.Name)
   fmt.Printf("remove watch: %s, err: %v\n", ev.Name, err)
  }
 
  if ev.Op & fsnotify.Rename == fsnotify.Rename {
   log.Println("rename : ", ev.Name)
   if "" != ev.Name {
   isNotify = true
   err := watcher.Remove(ev.Name)
   fmt.Printf("remove watch: %s, err: %v\n", ev.Name, err)
   }
  }
 
  if isNotify {
   ch <- time.Now().Unix()
  }
  }
  case err := <-watcher.Errors: {
  log.Println("watcher error : ", err)
  return
  }
 }
 }
}
 
//if folder event met, execute the shell script after 10minutes
func watchTime(ch chan int64) {
 var timer *time.Timer
 for {
 select {
  case <- ch:{
  if nil != timer {
   log.Printf("reset timer")
   timer.Stop()
  }
  timer = time.NewTimer(10 * 60 * time.Second)
  go func() {
   <-timer.C
   execCmd()
  }()
  }
 }
 }
}
 
//watch the folder and sub folders
func WatchDir(watcher *fsnotify.Watcher, dir string) {
 filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
 if info.IsDir() {
  path, err := filepath.Abs(path)
  if err != nil {
  return err
  }
  err = watcher.Add(path)
  if err != nil {
  return err
  }
 }
 return nil
 })
} 
 
func main() {
 notifyCh := make(chan int64)
 watcher, err := fsnotify.NewWatcher()
 if err != nil {
 log.Fatal(err)
 }
 defer watcher.Close()
 
 WatchDir(watcher, "/data/nfs")
 go watchFiles(watcher, notifyCh)
 go watchTime(notifyCh)
 select {}
}

#!/bin/bash
 
cd /root/nfs_bak_pro/nfs.git
log_file=/root/nfs_bak_pro/nfs_git_`date +"%Y%m%d"`.log
 
git add --all . >> $log_file
git commit -a -m "`date +"%Y-%m-%d %H:%M:%S"`" >> $log_file
git push origin master >> $log_file