ft: 升级go 1.24.2 fsnotify1.9

.gitignore

@@ -1,6 +1,4 @@
 # Binaries for programs and plugins
-*.exe
-*.exe~
 *.dll
 *.so
 *.dylib

README.md

@@ -1,5 +1,16 @@
 # fileSync 同步文件更改相关
 
 # go windows下程序运行隐藏dos窗口
-    go build -ldflags -H=windowsgui 
+    go build -ldflags  "-a -s -w -H=windowsgui"
+    start ./upx396/upx.exe --best fileSync.exe
+    
+# linux 编译
+    go build -ldflags "-a -s -w"    
+    ./upx396/upx --best fileSync
+
+# 升级版本
+ 先删除 go.mod  go.sum  然后执行go  mod init fileSync go mod tidy 然后编译
+
+
+    
     

fileSync.go

@@ -1,94 +1,92 @@
 package main
 
 import (
-	"bufio"
 	"bytes"
 	"encoding/binary"
-	//"fmt"
-	"github.com/fsnotify/fsnotify"
 	"io"
-	"net"
+	"io/fs"
 	"os"
 	"path/filepath"
 	"strings"
 	"time"
+
+	"github.com/fsnotify/fsnotify"
 )
 
 const (
-	SendDur  = 2
-	SleepDur = 86400
+	SendDur  = 1111     // 发送时间间隔毫秒
+	SleepDur = 86400000 // 定期器初始睡眠时间
 )
 
 var CollectFiles map[string]struct{}
+var CollectExt map[string]struct{}
 var SendTimer *time.Timer
 var Str bytes.Buffer
-var Msg *bytes.Buffer
-var AddDirs []string
+var AddExtraDirs []string
+var AddOnlyDirs []string
 var OnlyDirs []string
 var DelDirs []string
-var Conn net.Conn
+var LenBuff []byte
+
+type Watch struct {
+	watch *fsnotify.Watcher
+}
 
 const (
-	hrl  = ".hrl"
-	erl  = ".erl"
-	beam = ".beam"
-	dtl  = ".dtl"
-	lfe  = "lfe"
-	ex   = "ex"
-	idea = ".idea"
-	svn = ".svn"
-	git = ".git"
-	lock = ".lock"
-	bea = ".bea"
+	//LOGPATH  LOGPATH/time.Now().Format(FORMAT)/*.log
+	LOGPATH = "./"
+	//FORMAT .
+	FORMAT = "20060102"
+	//LineFeed 换行
+	LineFeed = "\r\n"
+	FileName = "fileSync.log"
 )
 
-type Watch struct {
-	watch *fsnotify.Watcher
+//以天为基准,存日志
+var path = LOGPATH + time.Now().Format(FORMAT) + "_"
+
+//WriteLog return error
+func WriteLog(msg string) error {
+	var (
+		err error
+		f   *os.File
+	)
+
+	f, err = os.OpenFile(path+FileName, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
+	_, err = io.WriteString(f, "Tag"+"::"+msg+LineFeed)
+
+	defer f.Close()
+	return err
+}
+
+//IsExist  判断文件夹/文件是否存在  存在返回 true
+func IsExist(f string) bool {
+	_, err := os.Stat(f)
+	return err == nil || os.IsExist(err)
 }
 
 // 收集更改了的文件
 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) {
+	if _, ok := CollectExt[ext]; ok{
 		CollectFiles[File] = struct{}{}
-		SendTimer.Reset(time.Second * SendDur)
+		SendTimer.Reset(time.Millisecond * 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
+    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 {
@@ -119,195 +117,193 @@ func isDelDir(dirs []string, curDirs string) bool {
 	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
-			})
+// 判断所给路径文件/文件夹是否存在
+func existPath(path string) bool {
+	_, err := os.Stat(path) //os.Stat获取文件信息
+	if err != nil {
+		if os.IsNotExist(err) {
+			return false
 		}
+		return true
 	}
+	return true
+}
 
+//监控目录
+func (w *Watch) watchDir(dir string) {
 	// 启动文件监听goroutine
 	go func() {
 		for {
 			select {
 			case ev := <-w.watch.Events:
 				{
-					if ev.Op&fsnotify.Create == fsnotify.Create {
+					if ev.Has(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 {
+					if ev.Has(fsnotify.Write) {
 						CollectFile(ev.Name)
-						// fmt.Println("写入文件 : ", ev.Name)
 					}
-					if ev.Op&fsnotify.Remove == fsnotify.Remove {
-						// fmt.Println("删除文件 : ", ev.Name)
+					if ev.Has(fsnotify.Remove) {
 						//如果删除文件是目录，则移除监控
 						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)
+					if ev.Has(fsnotify.Rename) {
 						//如果重命名文件是目录，则移除监控
 						//注意这里无法使用os.Stat来判断是否是目录了
 						//因为重命名后，go已经无法找到原文件来获取信息了
 						//所以这里就简单粗爆的直接remove好了
 						w.watch.Remove(ev.Name)
 					}
-					if ev.Op&fsnotify.Chmod == fsnotify.Chmod {
-						// fmt.Println("修改权限 : ", ev.Name)
+					if ev.Has(fsnotify.Chmod) {
 					}
 				}
 			case <-w.watch.Errors:
 				{
-					// fmt.Println("error : ", err)
-					return
+					continue
 				}
 			case <-SendTimer.C:
 				SendToErl()
 			}
 		}
 	}()
+
+	//通过Walk来遍历目录下的所有子目录
+	filepath.WalkDir(dir, func(path string, info fs.DirEntry, err error) error {
+		//这里判断是否为目录，只需监控目录即可 目录下的文件也在监控范围内，不需要我们一个一个加
+
+		if err == nil && info.IsDir() {
+			path, err := filepath.Abs(path)
+			if err != nil {
+				return err
+			}
+			if !isHidden(path) && isOnlyDir(OnlyDirs, path) && !isDelDir(DelDirs, path) {
+				err = w.watch.Add(path)
+				if err != nil {
+					return err
+				}
+			}
+		}
+		return nil
+	})
+
+	for _, v := range AddExtraDirs {
+		if v != "" && existPath(v) {
+			//通过Walk来遍历目录下的所有子目录
+			filepath.WalkDir(v, func(path string, info fs.DirEntry, err error) error {
+				//这里判断是否为目录，只需监控目录即可 目录下的文件也在监控范围内，不需要我们一个一个加
+				if err == nil && info.IsDir() {
+					path, err := filepath.Abs(path)
+					if err != nil {
+						return err
+					}
+					if !isHidden(path) {
+						err = w.watch.Add(path)
+						if err != nil {
+							return err
+						}
+					}
+				}
+				return nil
+			})
+		}
+	}
+
+	for _, v := range AddOnlyDirs {
+		if v != "" && existPath(v) {
+			w.watch.Add(v)
+		}
+	}
 }
 
-func read(reader *bufio.Reader) ([]byte, error) {
-	// Peek 返回缓存的一个切片，该切片引用缓存中前 n 个字节的数据，
-	// 该操作不会将数据读出，只是引用，引用的数据在下一次读取操作之
-	// 前是有效的。如果切片长度小于 n，则返回一个错误信息说明原因。
-	// 如果 n 大于缓存的总大小，则返回 ErrBufferFull。
-	lengthByte, err := reader.Peek(4)
-	if err != nil {
-		return nil, err
+//********************************************** port start ************************************************************
+func ReadLen() (int32, error) {
+	if _, err := io.ReadFull(os.Stdin, LenBuff); err != nil {
+		return 0, err
 	}
-	//创建 Buffer缓冲器
-	lengthBuff := bytes.NewBuffer(lengthByte)
-	var length int32
-	// 通过Read接口可以将buf中得内容填充到data参数表示的数据结构中
-	err = binary.Read(lengthBuff, binary.BigEndian, &length)
+	size := int32(binary.BigEndian.Uint32(LenBuff))
+
+	return size, nil
+}
+
+func Read() ([]byte, error) {
+	len, err := ReadLen()
 	if err != nil {
 		return nil, err
+	} else if len == 0 {
+		return []byte{}, nil
 	}
-	// Buffered 返回缓存中未读取的数据的长度
-	if int32(reader.Buffered()) < length+4 {
-		return nil, err
+	data := make([]byte, len)
+	size, err := io.ReadFull(os.Stdin, data)
+	return data[:size], err
+}
+
+func Write(data []byte) (int, error) {
+	size := len(data)
+	binary.BigEndian.PutUint32(LenBuff, uint32(size))
+
+	if _, err := os.Stdout.Write(LenBuff); err != nil {
+		return 0, 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 os.Stdout.Write(data)
+}
+
+// 发送文件列表到erl层
+func SendToErl() {
+	for k := range CollectFiles {
+		Str.WriteString(k)
+		Str.WriteString("\r\n")
 	}
-	return pack[4:], nil
+	CollectFiles = map[string]struct{}{}
+	Write(Str.Bytes())
+	Str.Reset()
 }
 
+//********************************************** port end   ************************************************************
+
 func main() {
 	CollectFiles = map[string]struct{}{}
-	SendTimer = time.NewTimer(time.Second * SleepDur)
+	CollectExt = map[string]struct{}{}
+	LenBuff = make([]byte, 4)
+
+	SendTimer = time.NewTimer(time.Millisecond * 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
-	}
+	Write([]byte("init"))
 
-	// 建立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
+	args := os.Args
+
+	ExtList := strings.Split(args[2], "|")
+	for _, v := range ExtList {
+		CollectExt[v] = struct{}{}
 	}
-	//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)
+
+	dirs := strings.Split(args[3], "\r\n")
+	AddExtraDirs = strings.Split(dirs[0], "|")
+	AddOnlyDirs = strings.Split(dirs[1], "|")
+	OnlyDirs = strings.Split(dirs[2], "|")
+	DelDirs = strings.Split(dirs[3], "|")
+
 	watch, _ := fsnotify.NewWatcher()
+	defer watch.Close()
 	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])
+	w.watchDir(args[1])
+	Read()
 }

go.mod

@@ -1,5 +0,0 @@
-module fileSync
-
-go 1.15
-
-require github.com/fsnotify/fsnotify v1.4.9