func (t *Theme) handleEvent(ev *fsnotify.FileEvent) {
if ev == nil {
return
}
if ok, _ := regexp.MatchString(`\.swa?px?$`, ev.Name); ok {
return
}
if ev.IsDelete() {
t.watcher.ResetFileListWatch()
return
}
info, err := getThemeInfoFromFile(path.Join(t.filePath, "theme.ini"))
if err != nil {
return
}
if isThemeInfoSame(t, &info) {
return
}
t.setPropsFromFile()
t.setPropPreview(t.getPreviewList())
if t.eventHandler != nil {
//apply the change
t.eventHandler(t.Name)
}
}
func (this *Watcher) handlecb(v *triggered, ev *fsnotify.FileEvent) {
if !v.canrun() {
return
}
defer v.setLastUpdate()
// in windows some events are sent 3 times
c := time.Tick(g_cooldown)
<-c
var t EvType
// execute
if ev.IsModify() {
t = C_Modify
} else if ev.IsCreate() {
t = C_Create
} else if ev.IsDelete() {
t = C_Delete
} else if ev.IsRename() {
t = C_Rename
} else if ev.IsAttrib() {
t = C_Attrib
} else {
fmt.Fprintln(os.Stderr, "unknown event")
return
}
this.cb(&WatchEvent{
Type: t,
Fpath: ev.Name,
})
}
func (t *templateManager) processTemplateEvent(ev *fsnotify.FileEvent) {
ext := strings.ToLower(filepath.Ext(ev.Name))
switch ext {
case ".gohtml":
case ".tmpl":
default:
t.brog.Debug("Templates ignore files in '%s': %s", ext, ev.Name)
return
}
if ev.IsCreate() {
// Nothing to do, all usefull templates files MUST exist at this
// time or brog would not have started.
return
}
if ev.IsModify() {
t.processTemplateModify(ev)
return
}
if ev.IsRename() || ev.IsDelete() {
t.processTemplateDelete(ev)
return
}
t.brog.Err("FileEvent '%s' is not recognized", ev.String())
}
func (p *postManager) processPostEvent(ev *fsnotify.FileEvent) {
ext := strings.ToLower(filepath.Ext(ev.Name))
switch ext {
case p.brog.Config.PostFileExt:
case ".md":
case ".markdown":
case ".mkd":
default:
p.brog.Debug("Posts ignore files in '%s': %s", ext, ev.Name)
return
}
if ev.IsCreate() {
p.processPostCreate(ev)
return
}
if ev.IsModify() {
p.processPostModify(ev)
return
}
if ev.IsRename() {
p.processPostRename(ev)
return
}
if ev.IsDelete() {
p.processPostDelete(ev)
return
}
p.brog.Err("FileEvent '%s' is not recognized", ev.String())
}
func (m *Manager) handleUserFileChanged(ev *fsnotify.FileEvent, handler func()) {
if !ev.IsDelete() || handler == nil {
return
}
m.watcher.ResetFileListWatch()
<-time.After(time.Millisecond * 200)
handler()
}
// Listen for FS events and signal work when something changes.
// Will send errors over e.
func (w *Watcher) Handle(work chan bool, e chan error) {
var (
evt *fsnotify.FileEvent
err error
)
for {
select {
case evt = <-w.watcher.Event:
w.gw.log.Printf("Filesystem changed: %v\n", evt.String())
isNewDir := evt.IsCreate() && w.gw.isDir(evt.Name)
if isNewDir || evt.IsDelete() || evt.IsRename() {
err = w.WatchDirs()
if err != nil {
e <- err
return
}
}
select {
case work <- true:
// gw.log.Printf("Work queued\n")
// Queued work.
default:
// gw.log.Printf("Work queue full\n")
// Work queue full, no worries.
}
case err = <-w.watcher.Error:
e <- err
return
}
}
}
func (watcher RecursiveWatcher) Handle(ev *fsnotify.FileEvent) {
if ev.IsCreate() {
info, err := os.Stat(ev.Name)
if err == nil {
if info.IsDir() {
watcher.WatchRecursive(ev.Name)
}
}
} else if ev.IsDelete() {
watcher.RemoveWatch(ev.Name)
}
}
func (sr *stalker) processEvent(event *fsnotify.FileEvent) {
em, ok := sr.req[event.Name]
if !ok {
return //yawn
}
switch {
case event.IsCreate():
sr.fs.Watch(event.Name)
}
if em {
sr.ch <- event.Name
}
}
func (dapp *DefaultApps) handleMimeFileChanged(ev *fsnotify.FileEvent) {
if ev == nil {
return
}
if ev.IsDelete() {
if dapp.watcher != nil {
dapp.watcher.ResetFileListWatch()
}
} else {
dbus.Emit(dapp, "DefaultAppChanged")
}
}
func watchChange(ev *fsnotify.FileEvent) {
if strings.HasPrefix(ev.Name, Config.GetAbsPath(Config.StaticDir)) {
fmt.Println("Static file changed, syncing\n")
utils.CheckErr(copyStatic(), fmt.Sprintf("Error copying static files to %s", Config.GetAbsPath(Config.PublishDir)))
} else {
if !ev.IsRename() { // Rename is always accompanied by a create or modify
// Ignoring temp files created by editors (vim)
if !strings.HasSuffix(ev.Name, "~") && !strings.HasSuffix(ev.Name, ".swp") {
fmt.Println("Change detected, rebuilding site\n")
utils.StopOnErr(buildSite(true))
}
}
}
}
func handleChange(channel *amqp.Channel, ev *fsnotify.FileEvent) error {
// check to see if the file is locked. If it is then break
path, _ := filepath.Rel(rootDir, ev.Name)
if FileIsLocked(path) {
return nil
}
log.Printf("PUBLISHER: publishing %dB path (%q)", len(path), path)
var change = &Change{
IsCreate: ev.IsCreate(),
IsDelete: ev.IsDelete(),
IsMod: ev.IsModify(),
IsMove: ev.IsRename(),
ModDate: time.Now().UTC(),
Path: path,
Source: hostname,
Checksum: Checksum(ev.Name),
}
msg, err := json.Marshal(change)
if err != nil {
log.Fatalf("ERROR marshaling msg %s", change)
}
if err := channel.Publish(
"changes", // publish to an exchange
"", // routing to 0 or more queues
false, // mandatory
false, // immediate
amqp.Publishing{
Headers: amqp.Table{},
ContentType: "application/json",
ContentEncoding: "",
Body: msg,
DeliveryMode: amqp.Transient, // 1=non-persistent, 2=persistent
Priority: 0, // 0-9
// a bunch of application/implementation-specific fields
/*
ContentType string // MIME content type
ContentEncoding string // MIME content encoding
DeliveryMode uint8 // Transient (0 or 1) or Persistent (2)
Priority uint8 // 0 to 9
CorrelationId string // correlation identifier
ReplyTo string // address to to reply to (ex: RPC)
Expiration string // message expiration spec
MessageId string // message identifier
Timestamp time.Time // message timestamp
Type string // message type name
UserId string // creating user id - ex: "guest"
AppId string // creating application id
*/
},
); err != nil {
log.Fatalf("Exchange Publish: %s", err)
panic(err)
}
return nil
}
func (fw *InotifyFileWatcher) ChangeEvents(t tomb.Tomb, fi os.FileInfo) chan bool {
w, err := fsnotify.NewWatcher()
if err != nil {
panic(err)
}
err = w.Watch(fw.Filename)
if err != nil {
panic(err)
}
ch := make(chan bool)
fw.Size = fi.Size()
go func() {
defer w.Close()
defer w.RemoveWatch(fw.Filename)
defer close(ch)
for {
prevSize := fw.Size
var evt *fsnotify.FileEvent
select {
case evt = <-w.Event:
case <-t.Dying():
return
}
switch {
case evt.IsDelete():
fallthrough
case evt.IsRename():
return
case evt.IsModify():
fi, err := os.Stat(fw.Filename)
if err != nil {
// XXX: no panic here
panic(err)
}
fw.Size = fi.Size()
if prevSize > 0 && prevSize > fw.Size {
return
}
// send only if channel is empty.
select {
case ch <- true:
default:
}
}
}
}()
return ch
}
func (fw *InotifyFileWatcher) ChangeEvents(t tomb.Tomb, fi os.FileInfo) *FileChanges {
changes := NewFileChanges()
w, err := fsnotify.NewWatcher()
if err != nil {
panic(err)
}
err = w.Watch(fw.Filename)
if err != nil {
panic(err)
}
fw.Size = fi.Size()
go func() {
defer w.Close()
defer w.RemoveWatch(fw.Filename)
defer changes.Close()
for {
prevSize := fw.Size
var evt *fsnotify.FileEvent
select {
case evt = <-w.Event:
case <-t.Dying():
return
}
switch {
case evt.IsDelete():
fallthrough
case evt.IsRename():
changes.NotifyDeleted()
return
case evt.IsModify():
fi, err := os.Stat(fw.Filename)
if err != nil {
// XXX: no panic here
panic(err)
}
fw.Size = fi.Size()
if prevSize > 0 && prevSize > fw.Size {
changes.NotifyTruncated()
} else {
changes.NotifyModified()
}
prevSize = fw.Size
}
}
}()
return changes
}
func processSubdir(watcher *fsnotify.Watcher, ev *fsnotify.FileEvent) {
if ev.IsModify() {
return
}
if ev.IsDelete() {
log.Println("remove watch", ev.Name)
// FIXME: what to do with err?
watcher.RemoveWatch(ev.Name)
return
}
// FIXME: Lstat or Stat?
// TODO: what to do with err? can we safely ignore?
mode, err := os.Lstat(ev.Name)
if err != nil {
log.Println("error processing subdir:", err.Error())
return
}
if !mode.IsDir() {
return
}
// FIXME: handle renames
if ev.IsCreate() {
log.Println("add watch", ev.Name)
// FIXME: what to do with err?
watcher.Watch(ev.Name)
}
}
func eventDesc(ev *fsnotify.FileEvent) string {
switch {
case ev.IsCreate():
return "created"
case ev.IsDelete():
return "removed"
case ev.IsModify():
return "modified"
case ev.IsRename():
return "renamed"
default:
return ""
}
}
func watch() {
var event *fsnotify.FileEvent
var open bool
for {
if event, open = <-watcher.Event; open == false {
break
} else if event.IsModify() {
go fileModified(event)
} else if event.IsDelete() {
out("DELETED", event.Name)
} else if event.IsCreate() {
go fileCreated(event)
} else if event.IsRename() {
}
}
}
func handleEvent(evt *fsnotify.FileEvent, errChan chan error) {
// we cannot use filepath.Join here because if it is a windows client
// the remote paths will be wrong because the machine is linux
filePath := fmt.Sprintf("%s/%s", destPath, evt.Name)
if evt.IsDelete() {
log.Infof("deleting %s", filePath)
if err := rsftp.Remove(filePath); err != nil {
log.Error(err)
return
}
} else {
// this can probably be more efficient
log.Infof("updating %s", filePath)
localFile, err := os.Open(evt.Name)
if err != nil {
log.Error(err)
return
}
// don't alert on missing remote files
_ = rsftp.Remove(filePath)
remoteFile, err := rsftp.Create(filePath)
if err != nil {
log.Error(err)
return
}
// TODO: is not copying binaries correctly
data, err := ioutil.ReadAll(localFile)
if err != nil {
log.Error(err)
return
}
if _, err := remoteFile.Write(data); err != nil {
log.Error(err)
return
}
}
}
func handleEvent(ev *fsnotify.FileEvent) {
if len(ev.Name) > 0 {
switch {
case ev.IsCreate():
handleCreate(ev.Name)
case ev.IsDelete():
handleDelete(ev.Name)
case ev.IsModify():
handleModify(ev.Name)
}
}
}
func PreprocessEvent(event *fsnotify.FileEvent) {
path := event.Name
//ignore 5 root dir
for _, p := range dir_list {
if p == path {
return
}
}
if event.IsDelete() {
ProcessDeleteEvent(event)
} else {
if isDir, err := pathutil.IsDir(path); isDir && err == nil {
if event.IsCreate() {
ProcessCreateEvent(event)
} else if event.IsModify() {
ProcessModifyEvent(event)
} else if event.IsRename() {
ProcessRenameEvent(event)
}
}
}
}
func (r Rule) MatchedCommand(ev *fsnotify.FileEvent) (string, bool) {
if r.eventName == "MODIFY" && !ev.IsModify() {
return "", false
}
if r.eventName == "CREATE" && !ev.IsCreate() {
return "", false
}
if r.eventName == "DELETE" && !ev.IsDelete() {
return "", false
}
match := r.match.FindStringSubmatch(ev.Name)
if match == nil {
return "", false
}
if len(match) == 1 {
return r.cmd, true
}
return r.match.ReplaceAllString(ev.Name, r.cmd), true
}
func (fw *InotifyFileWatcher) ChangeEvents(t *tomb.Tomb, fi os.FileInfo) *FileChanges {
changes := NewFileChanges()
w, err := inotifyTracker.NewWatcher()
if err != nil {
util.Fatal("Error creating fsnotify watcher: %v", err)
}
err = w.Watch(fw.Filename)
if err != nil {
util.Fatal("Error watching %v: %v", fw.Filename, err)
}
fw.Size = fi.Size()
go func() {
defer inotifyTracker.CloseWatcher(w)
for {
prevSize := fw.Size
var evt *fsnotify.FileEvent
var ok bool
select {
case evt, ok = <-w.Event:
if !ok {
return
}
case <-t.Dying():
return
}
switch {
case evt.IsDelete():
fallthrough
case evt.IsRename():
changes.NotifyDeleted()
return
case evt.IsModify():
fi, err := os.Stat(fw.Filename)
if err != nil {
if os.IsNotExist(err) {
changes.NotifyDeleted()
return
}
// XXX: report this error back to the user
util.Fatal("Failed to stat file %v: %v", fw.Filename, err)
}
fw.Size = fi.Size()
if prevSize > 0 && prevSize > fw.Size {
changes.NotifyTruncated()
} else {
changes.NotifyModified()
}
prevSize = fw.Size
}
}
}()
return changes
}
func (self *Launcher) itemChangedHandler(ev *fsnotify.FileEvent, name string, info map[string]ItemChangedStatus) {
if _, ok := info[name]; !ok {
info[name] = ItemChangedStatus{
make(chan bool),
make(chan bool),
make(chan bool),
make(chan bool),
0,
}
}
if ev.IsRename() {
logger.Info("renamed")
select {
case <-info[name].renamed:
default:
}
go func() {
select {
case <-info[name].notRenamed:
return
case <-time.After(time.Second):
<-info[name].renamed
if true {
self.emitItemChanged(name, SoftwareStatusDeleted, info)
}
}
}()
info[name].renamed <- true
} else if ev.IsCreate() {
self.emitItemChanged(name, SoftwareStatusCreated, info)
go func() {
select {
case <-info[name].renamed:
// logger.Info("not renamed")
info[name].notRenamed <- true
info[name].renamed <- true
default:
// logger.Info("default")
}
select {
case <-info[name].notCreated:
return
case <-time.After(time.Second):
<-info[name].created
}
}()
info[name].created <- true
} else if ev.IsModify() && !ev.IsAttrib() {
go func() {
select {
case <-info[name].created:
info[name].notCreated <- true
}
select {
case <-info[name].renamed:
self.emitItemChanged(name, SoftwareStatusModified, info)
default:
}
}()
} else if ev.IsAttrib() {
go func() {
select {
case <-info[name].renamed:
<-info[name].created
info[name].notCreated <- true
default:
}
}()
} else if ev.IsDelete() {
if true {
self.emitItemChanged(name, SoftwareStatusDeleted, info)
}
}
}
func goFileTouched(event *fsnotify.FileEvent) bool {
return (event.IsModify() || event.IsRename()) && strings.HasSuffix(event.Name, ".go")
}
func watchRemoved(event *fsnotify.FileEvent) bool {
return event.IsDelete() && watching(event.Name)
}