Nie możesz wybrać więcej, niż 25 tematów
Tematy muszą się zaczynać od litery lub cyfry, mogą zawierać myślniki ('-') i mogą mieć do 35 znaków.
313 wiersze
7.8 KiB
313 wiersze
7.8 KiB
package main
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"encoding/binary"
|
|
//"fmt"
|
|
"github.com/fsnotify/fsnotify"
|
|
"io"
|
|
"net"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
const (
|
|
SendDur = 2
|
|
SleepDur = 86400
|
|
)
|
|
|
|
var CollectFiles map[string]struct{}
|
|
var SendTimer *time.Timer
|
|
var Str bytes.Buffer
|
|
var Msg *bytes.Buffer
|
|
var AddDirs []string
|
|
var OnlyDirs []string
|
|
var DelDirs []string
|
|
var Conn net.Conn
|
|
|
|
const (
|
|
hrl = ".hrl"
|
|
erl = ".erl"
|
|
beam = ".beam"
|
|
dtl = ".dtl"
|
|
lfe = "lfe"
|
|
ex = "ex"
|
|
idea = ".idea"
|
|
svn = ".svn"
|
|
git = ".git"
|
|
lock = ".lock"
|
|
bea = ".bea"
|
|
)
|
|
|
|
type Watch struct {
|
|
watch *fsnotify.Watcher
|
|
}
|
|
|
|
// 收集更改了的文件
|
|
func CollectFile(File string) {
|
|
ext := filepath.Ext(File)
|
|
if ext != idea && ext != git && ext != svn && ext != lock && ext != bea && ext != "" && ext != idea && (ext == erl || ext == beam || ext == hrl || ext == ex || ext == dtl || ext == lfe) {
|
|
CollectFiles[File] = struct{}{}
|
|
SendTimer.Reset(time.Second * SendDur)
|
|
}
|
|
}
|
|
|
|
// 发送文件列表到erl层
|
|
func SendToErl() {
|
|
// 拼写数据
|
|
for k := range CollectFiles {
|
|
Str.WriteString(k)
|
|
Str.WriteString("\r\n")
|
|
}
|
|
CollectFiles = map[string]struct{}{}
|
|
|
|
var length = int32(len(Str.Bytes()))
|
|
//写入消息头
|
|
_ = binary.Write(Msg, binary.BigEndian, length)
|
|
//写入消息体
|
|
_ = binary.Write(Msg, binary.BigEndian, Str.Bytes())
|
|
Conn.Write(Msg.Bytes())
|
|
Str.Reset()
|
|
Msg.Reset()
|
|
|
|
SendTimer.Reset(time.Second * SleepDur)
|
|
}
|
|
|
|
func isHidden(path string) bool {
|
|
for i := len(path) - 1; i > 0; i-- {
|
|
if path[i] != '.' {
|
|
continue
|
|
}
|
|
if os.IsPathSeparator(path[i-1]) {
|
|
return true
|
|
}
|
|
}
|
|
if path[0] == '.' {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func isOnlyDir(dirs []string, curDirs string) bool {
|
|
cnt := 0
|
|
for _, v := range dirs {
|
|
if v != "" {
|
|
cnt += 1
|
|
if strings.Contains(curDirs[1:], v[1:]) {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
if cnt == 0 {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func isDelDir(dirs []string, curDirs string) bool {
|
|
for _, v := range dirs {
|
|
if v != "" {
|
|
if strings.Contains(curDirs[1:], v[1:]) {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
//监控目录
|
|
func (w *Watch) watchDir(dir string) {
|
|
//通过Walk来遍历目录下的所有子目录
|
|
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
|
|
}
|
|
if !isHidden(path) {
|
|
if isOnlyDir(OnlyDirs, path) {
|
|
if !isDelDir(DelDirs, path) {
|
|
err = w.watch.Add(path)
|
|
if err != nil {
|
|
// fmt.Println("watch err : ", path, err)
|
|
return err
|
|
}
|
|
// fmt.Println("watch success : ", path)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
|
|
for _, v := range AddDirs {
|
|
if v != "" {
|
|
//通过Walk来遍历目录下的所有子目录
|
|
filepath.Walk(v, func(path string, info os.FileInfo, err error) error {
|
|
//这里判断是否为目录，只需监控目录即可 目录下的文件也在监控范围内，不需要我们一个一个加
|
|
if info.IsDir() {
|
|
path, err := filepath.Abs(path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !isHidden(path) {
|
|
err = w.watch.Add(path)
|
|
if err != nil {
|
|
// fmt.Println("watch AddDirs err : ", err)
|
|
return err
|
|
}
|
|
// fmt.Println("watch AddDirs success : ", path)
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
}
|
|
|
|
// 启动文件监听goroutine
|
|
go func() {
|
|
for {
|
|
select {
|
|
case ev := <-w.watch.Events:
|
|
{
|
|
if ev.Op&fsnotify.Create == fsnotify.Create {
|
|
//这里获取新创建文件的信息，如果是目录，则加入监控中
|
|
fi, err := os.Stat(ev.Name)
|
|
if err == nil && fi.IsDir() {
|
|
// 新建了文件夹
|
|
// fmt.Println("创建文件夹 : ", ev.Name)
|
|
if !isHidden(ev.Name) {
|
|
if isOnlyDir(OnlyDirs, ev.Name) {
|
|
if !isDelDir(DelDirs, ev.Name) {
|
|
w.watch.Add(ev.Name)
|
|
// fmt.Println("添加监控 : ", ev.Name)
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// 新建了文件
|
|
CollectFile(ev.Name)
|
|
// fmt.Println("创建文件 : ", ev.Name)
|
|
}
|
|
}
|
|
if ev.Op&fsnotify.Write == fsnotify.Write {
|
|
CollectFile(ev.Name)
|
|
// fmt.Println("写入文件 : ", ev.Name)
|
|
}
|
|
if ev.Op&fsnotify.Remove == fsnotify.Remove {
|
|
// fmt.Println("删除文件 : ", ev.Name)
|
|
//如果删除文件是目录，则移除监控
|
|
fi, err := os.Stat(ev.Name)
|
|
if err == nil && fi.IsDir() {
|
|
w.watch.Remove(ev.Name)
|
|
// fmt.Println("删除监控 : ", ev.Name)
|
|
}
|
|
}
|
|
if ev.Op&fsnotify.Rename == fsnotify.Rename {
|
|
// fmt.Println("重命名文件 : ", ev.Name)
|
|
//如果重命名文件是目录，则移除监控
|
|
//注意这里无法使用os.Stat来判断是否是目录了
|
|
//因为重命名后，go已经无法找到原文件来获取信息了
|
|
//所以这里就简单粗爆的直接remove好了
|
|
w.watch.Remove(ev.Name)
|
|
}
|
|
if ev.Op&fsnotify.Chmod == fsnotify.Chmod {
|
|
// fmt.Println("修改权限 : ", ev.Name)
|
|
}
|
|
}
|
|
case <-w.watch.Errors:
|
|
{
|
|
// fmt.Println("error : ", err)
|
|
return
|
|
}
|
|
case <-SendTimer.C:
|
|
SendToErl()
|
|
}
|
|
}
|
|
}()
|
|
}
|
|
|
|
func read(reader *bufio.Reader) ([]byte, error) {
|
|
// Peek 返回缓存的一个切片，该切片引用缓存中前 n 个字节的数据，
|
|
// 该操作不会将数据读出，只是引用，引用的数据在下一次读取操作之
|
|
// 前是有效的。如果切片长度小于 n，则返回一个错误信息说明原因。
|
|
// 如果 n 大于缓存的总大小，则返回 ErrBufferFull。
|
|
lengthByte, err := reader.Peek(4)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
//创建 Buffer缓冲器
|
|
lengthBuff := bytes.NewBuffer(lengthByte)
|
|
var length int32
|
|
// 通过Read接口可以将buf中得内容填充到data参数表示的数据结构中
|
|
err = binary.Read(lengthBuff, binary.BigEndian, &length)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// Buffered 返回缓存中未读取的数据的长度
|
|
if int32(reader.Buffered()) < length+4 {
|
|
return nil, err
|
|
}
|
|
// 读取消息真正的内容
|
|
pack := make([]byte, int(4+length))
|
|
// Read 从 b 中读出数据到 p 中，返回读出的字节数和遇到的错误。
|
|
// 如果缓存不为空，则只能读出缓存中的数据，不会从底层 io.Reader
|
|
// 中提取数据，如果缓存为空，则：
|
|
// 1、len(p) >= 缓存大小，则跳过缓存，直接从底层 io.Reader 中读
|
|
// 出到 p 中。
|
|
// 2、len(p) < 缓存大小，则先将数据从底层 io.Reader 中读取到缓存
|
|
// 中，再从缓存读取到 p 中。
|
|
_, err = reader.Read(pack)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return pack[4:], nil
|
|
}
|
|
|
|
func main() {
|
|
CollectFiles = map[string]struct{}{}
|
|
SendTimer = time.NewTimer(time.Second * SleepDur)
|
|
defer SendTimer.Stop()
|
|
|
|
Addr := "localhost:" + os.Args[2]
|
|
var err error
|
|
Conn, err = net.Dial("tcp", Addr)
|
|
if err != nil {
|
|
//fmt.Println("IMY****************建立tcp失败 : ", Addr)
|
|
return
|
|
}
|
|
|
|
// 建立tcp 连接后需要从erlSync 接受监听目录相关配置
|
|
var reader *bufio.Reader
|
|
reader = bufio.NewReader(Conn)
|
|
data, err := read(reader)
|
|
if err == io.EOF {
|
|
//fmt.Println("IMY****************Tcp 断开链接 : ", Addr)
|
|
return
|
|
}
|
|
if err != nil {
|
|
//fmt.Println("IMY****************Tcp read err : ", err)
|
|
return
|
|
}
|
|
//fmt.Println("IMY****************建立tcp成功 : ", os.Args[0])
|
|
//fmt.Println("IMY****************Tcp read data : ", string(data))
|
|
dirs := strings.Split(string(data), "\r\n")
|
|
AddDirs = strings.Split(dirs[0], "|")
|
|
OnlyDirs = strings.Split(dirs[1], "|")
|
|
DelDirs = strings.Split(dirs[2], "|")
|
|
|
|
Msg = new(bytes.Buffer)
|
|
watch, _ := fsnotify.NewWatcher()
|
|
w := Watch{watch: watch}
|
|
w.watchDir(os.Args[1])
|
|
|
|
data = make([]byte, 10)
|
|
_, _ = Conn.Read(data)
|
|
Conn.Close()
|
|
// fmt.Println("IMY****************tcp关闭了 : ", os.Args[0])
|
|
}
|