gf/g/os/gfsnotify/gfsnotify_watcher_loop.go

// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.

package gfsnotify

import (
    "github.com/gogf/gf/g/container/glist"
)

// 监听循环
func (w *Watcher) startWatchLoop() {
    go func() {
        for {
            select {
                // 关闭事件
                case <- w.closeChan: return

                // 监听事件
                case ev := <- w.watcher.Events:
                    //fmt.Println("ev:", ev.String())
                    w.cache.SetIfNotExist(ev.String(), func() interface{} {
                        w.events.Push(&Event{
                            event   : ev,
                            Path    : ev.Name,
                            Op      : Op(ev.Op),
                            Watcher : w,
                        })
                        return struct {}{}
                    }, REPEAT_EVENT_FILTER_INTERVAL)

                case <- w.watcher.Errors:
                    //fmt.Fprintf(os.Stderr, "[gfsnotify] error: %s\n", err.Error())
            }
        }
    }()
}

// 获得文件路径的监听回调，包括层级的监听回调。
func (w *Watcher) getCallbacks(path string) (callbacks []*Callback) {
    // 首先检索path对应的回调函数
    if v := w.callbacks.Get(path); v != nil {
        for _, v := range v.(*glist.List).FrontAll() {
            callback := v.(*Callback)
            callbacks = append(callbacks, callback)
        }
    }
    // 其次查找父级目录有无回调注册
    dirPath := fileDir(path)
    if v := w.callbacks.Get(dirPath); v != nil {
        for _, v := range v.(*glist.List).FrontAll() {
            callback := v.(*Callback)
            callbacks = append(callbacks, callback)
        }
    }
    // 最后回溯查找递归回调函数
    for {
        parentDirPath := fileDir(dirPath)
        if parentDirPath == dirPath {
            break
        }
        if v := w.callbacks.Get(parentDirPath); v != nil {
            for _, v := range v.(*glist.List).FrontAll() {
                callback := v.(*Callback)
                if callback.recursive {
                    callbacks = append(callbacks, callback)
                }
            }
        }
        dirPath = parentDirPath
    }
    return
}

// 事件循环(核心逻辑)
func (w *Watcher) startEventLoop() {
    go func() {
        for {
            if v := w.events.Pop(); v != nil {
                event := v.(*Event)
                // 如果该路径一个回调也没有，那么没有必要执行后续逻辑，删除对该文件的监听
                callbacks := w.getCallbacks(event.Path)
                if len(callbacks) == 0 {
                    w.watcher.Remove(event.Path)
                    continue
                }
                switch {
                    // 如果是删除操作，那么需要判断是否文件真正不存在了，如果存在，那么将此事件认为“假删除”
                    case event.IsRemove():
                        if fileExists(event.Path) {
                            // 底层重新添加监控(不用担心重复添加)
                            w.watcher.Add(event.Path)
                            // 修改事件操作为重命名(相当于重命名为自身名称，最终名称没变)
                            event.Op = RENAME
                        }

                    // 如果是重命名操作，那么需要判断是否文件真正不存在了，如果存在，那么将此事件认为“假命名”
                    // (特别是某些编辑器在编辑文件时会先对文件RENAME再CHMOD)
                    case event.IsRename():
                        if fileExists(event.Path) {
                            // 底层有可能去掉了监控, 这里重新添加监控(不用担心重复添加)
                            w.watcher.Add(event.Path)
                            // 修改事件操作为修改属性
                            event.Op = CHMOD
                        }

                    // 创建文件/目录
                    case event.IsCreate():
                        // =========================================
                        // 注意这里只是添加底层监听，并没有注册任何的回调函数，
                        // 默认的回调函数为父级的递归回调
                        // =========================================
                        if fileIsDir(event.Path) {
                            // 递归添加
                            for _, subPath := range fileAllDirs(event.Path) {
                                if fileIsDir(subPath) {
                                    w.watcher.Add(subPath)
                                }
                            }
                        } else {
                            // 添加文件监听
                            w.watcher.Add(event.Path)
                        }

                }
                // 执行回调处理，异步处理
                for _, v := range callbacks {
                    go func(callback *Callback) {
                        defer func() {
                            // 是否退出监控
                            if err := recover(); err != nil {
                                switch err {
                                    case gFSNOTIFY_EVENT_EXIT:
                                        w.RemoveCallback(callback.Id)
                                    default:
                                        panic(err)
                                }
                            }
                        }()
                        callback.Func(event)
                    }(v)
                }
            } else {
                break
            }
        }
    }()
}