refactor: slog替换logrus、日志操作统一、支持json、text格式等

server/internal/machine/infrastructure/machine/machine.go

@@ -7,7 +7,7 @@ import (
 	"mayfly-go/internal/machine/domain/entity"
 	"mayfly-go/pkg/biz"
 	"mayfly-go/pkg/cache"
-	"mayfly-go/pkg/global"
+	"mayfly-go/pkg/logx"
 	"net"
 	"time"
 
@@ -72,7 +72,7 @@ func (c *Cli) connect() error {
 // 关闭client并从缓存中移除，如果使用隧道则也关闭
 func (c *Cli) Close() {
 	m := c.machine
-	global.Log.Info(fmt.Sprintf("关闭机器客户端连接-> id: %d, name: %s, ip: %s", m.Id, m.Name, m.Ip))
+	logx.Info(fmt.Sprintf("关闭机器客户端连接-> id: %d, name: %s, ip: %s", m.Id, m.Name, m.Ip))
 	if c.client != nil {
 		c.client.Close()
 		c.client = nil
@@ -173,25 +173,24 @@ func DeleteCli(id uint64) {
 
 // 从缓存中获取客户端信息，不存在则回调获取机器信息函数，并新建
 func GetCli(machineId uint64, getMachine func(uint64) *Info) (*Cli, error) {
-	cli, err := cliCache.ComputeIfAbsent(machineId, func(_ any) (any, error) {
-		me := getMachine(machineId)
-		err := IfUseSshTunnelChangeIpPort(me, getMachine)
-		if err != nil {
-			return nil, fmt.Errorf("ssh隧道连接失败: %s", err.Error())
-		}
-		c, err := newClient(me)
-		if err != nil {
-			CloseSshTunnelMachine(me.SshTunnelMachineId, me.Id)
-			return nil, err
-		}
-		c.sshTunnelMachineId = me.SshTunnelMachineId
-		return c, nil
-	})
-
-	if cli != nil {
-		return cli.(*Cli), err
+	if load, ok := cliCache.Get(machineId); ok {
+		return load.(*Cli), nil
 	}
-	return nil, err
+
+	me := getMachine(machineId)
+	err := IfUseSshTunnelChangeIpPort(me, getMachine)
+	if err != nil {
+		return nil, fmt.Errorf("ssh隧道连接失败: %s", err.Error())
+	}
+	c, err := newClient(me)
+	if err != nil {
+		CloseSshTunnelMachine(me.SshTunnelMachineId, me.Id)
+		return nil, err
+	}
+	c.sshTunnelMachineId = me.SshTunnelMachineId
+
+	cliCache.Put(machineId, c)
+	return c, nil
 }
 
 // 测试连接，使用传值的方式，而非引用。因为如果使用了ssh隧道，则ip和端口会变为本地映射地址与端口
@@ -276,7 +275,7 @@ func newClient(machine *Info) (*Cli, error) {
 		return nil, errors.New("机器不存在")
 	}
 
-	global.Log.Infof("[%s]机器连接：%s:%d", machine.Name, machine.Ip, machine.Port)
+	logx.Infof("[%s]机器连接：%s:%d", machine.Name, machine.Ip, machine.Port)
 	cli := new(Cli)
 	cli.machine = machine
 	err := cli.connect()

server/internal/machine/infrastructure/machine/sshtunnel.go

@@ -3,7 +3,7 @@ package machine
 import (
 	"fmt"
 	"io"
-	"mayfly-go/pkg/global"
+	"mayfly-go/pkg/logx"
 	"mayfly-go/pkg/scheduler"
 	"mayfly-go/pkg/utils/netx"
 	"net"
@@ -29,7 +29,7 @@ var (
 type CheckSshTunnelMachineHasUseFunc func(int) bool
 
 func startCheckUse() {
-	global.Log.Info("开启定时检测ssh隧道机器是否还有被使用")
+	logx.Info("开启定时检测ssh隧道机器是否还有被使用")
 	// 每十分钟检查一次隧道机器是否还有被使用
 	scheduler.AddFun("@every 10m", func() {
 		if !mutex.TryLock() {
@@ -38,7 +38,7 @@ func startCheckUse() {
 		defer mutex.Unlock()
 		// 遍历隧道机器，都未被使用将会被关闭
 		for mid, sshTunnelMachine := range sshTunnelMachines {
-			global.Log.Debugf("开始定时检查ssh隧道机器[%d]是否还有被使用...", mid)
+			logx.Debugf("开始定时检查ssh隧道机器[%d]是否还有被使用...", mid)
 			hasUse := false
 			for _, checkUseFunc := range checkSshTunnelMachineHasUseFuncs {
 				// 如果一个在使用则返回不关闭，不继续后续检查
@@ -126,10 +126,10 @@ func (stm *SshTunnelMachine) Close() {
 	}
 
 	if stm.SshClient != nil {
-		global.Log.Infof("ssh隧道机器[%d]未被使用, 关闭隧道...", stm.machineId)
+		logx.Infof("ssh隧道机器[%d]未被使用, 关闭隧道...", stm.machineId)
 		err := stm.SshClient.Close()
 		if err != nil {
-			global.Log.Errorf("关闭ssh隧道机器[%d]发生错误: %s", stm.machineId, err.Error())
+			logx.Errorf("关闭ssh隧道机器[%d]发生错误: %s", stm.machineId, err.Error())
 		}
 	}
 	delete(sshTunnelMachines, stm.machineId)
@@ -152,7 +152,7 @@ func GetSshTunnelMachine(machineId int, getMachine func(uint64) *Info) (*SshTunn
 	}
 	sshTunnelMachine = &SshTunnelMachine{SshClient: sshClient, machineId: machineId, tunnels: map[uint64]*Tunnel{}}
 
-	global.Log.Infof("初次连接ssh隧道机器[%d][%s:%d]", machineId, me.Ip, me.Port)
+	logx.Infof("初次连接ssh隧道机器[%d][%s:%d]", machineId, me.Ip, me.Port)
 	sshTunnelMachines[machineId] = sshTunnelMachine
 
 	// 如果实用了隧道机器且还没开始定时检查是否还被实用，则执行定时任务检测隧道是否还被使用
@@ -195,31 +195,31 @@ func (r *Tunnel) Open(sshClient *ssh.Client) {
 	localAddr := fmt.Sprintf("%s:%d", r.localHost, r.localPort)
 
 	for {
-		global.Log.Debugf("隧道 %v 等待客户端访问 %v", r.id, localAddr)
+		logx.Debugf("隧道 %v 等待客户端访问 %v", r.id, localAddr)
 		localConn, err := r.listener.Accept()
 		if err != nil {
-			global.Log.Debugf("隧道 %v 接受连接失败 %v, 退出循环", r.id, err.Error())
-			global.Log.Debug("-------------------------------------------------")
+			logx.Debugf("隧道 %v 接受连接失败 %v, 退出循环", r.id, err.Error())
+			logx.Debug("-------------------------------------------------")
 			return
 		}
 		r.localConnections = append(r.localConnections, localConn)
 
-		global.Log.Debugf("隧道 %v 新增本地连接 %v", r.id, localConn.RemoteAddr().String())
+		logx.Debugf("隧道 %v 新增本地连接 %v", r.id, localConn.RemoteAddr().String())
 		remoteAddr := fmt.Sprintf("%s:%d", r.remoteHost, r.remotePort)
-		global.Log.Debugf("隧道 %v 连接远程地址 %v ...", r.id, remoteAddr)
+		logx.Debugf("隧道 %v 连接远程地址 %v ...", r.id, remoteAddr)
 		remoteConn, err := sshClient.Dial("tcp", remoteAddr)
 		if err != nil {
-			global.Log.Debugf("隧道 %v 连接远程地址 %v, 退出循环", r.id, err.Error())
-			global.Log.Debug("-------------------------------------------------")
+			logx.Debugf("隧道 %v 连接远程地址 %v, 退出循环", r.id, err.Error())
+			logx.Debug("-------------------------------------------------")
 			return
 		}
 		r.remoteConnections = append(r.remoteConnections, remoteConn)
 
-		global.Log.Debugf("隧道 %v 连接远程主机成功", r.id)
+		logx.Debugf("隧道 %v 连接远程主机成功", r.id)
 		go copyConn(localConn, remoteConn)
 		go copyConn(remoteConn, localConn)
-		global.Log.Debugf("隧道 %v 开始转发数据 [%v]->[%v]", r.id, localAddr, remoteAddr)
-		global.Log.Debug("~~~~~~~~~~~~~~~~~~~~分割线~~~~~~~~~~~~~~~~~~~~~~~~")
+		logx.Debugf("隧道 %v 开始转发数据 [%v]->[%v]", r.id, localAddr, remoteAddr)
+		logx.Debug("~~~~~~~~~~~~~~~~~~~~分割线~~~~~~~~~~~~~~~~~~~~~~~~")
 	}
 }
 
@@ -233,7 +233,7 @@ func (r *Tunnel) Close() {
 	}
 	r.remoteConnections = nil
 	_ = r.listener.Close()
-	global.Log.Debugf("隧道 %d 监听器关闭", r.id)
+	logx.Debugf("隧道 %d 监听器关闭", r.id)
 }
 
 func copyConn(writer, reader net.Conn) {

server/internal/machine/infrastructure/machine/terminal_session.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"io"
-	"mayfly-go/pkg/global"
+	"mayfly-go/pkg/logx"
 	"time"
 	"unicode/utf8"
 
@@ -68,12 +68,12 @@ func (r TerminalSession) Start() {
 }
 
 func (r TerminalSession) Stop() {
-	global.Log.Debug("close machine ssh terminal session")
+	logx.Debug("close machine ssh terminal session")
 	r.tick.Stop()
 	r.cancel()
 	if r.terminal != nil {
 		if err := r.terminal.Close(); err != nil {
-			global.Log.Errorf("关闭机器ssh终端失败: %s", err.Error())
+			logx.Errorf("关闭机器ssh终端失败: %s", err.Error())
 		}
 	}
 }
@@ -87,7 +87,7 @@ func (ts TerminalSession) readFormTerminal() {
 			rn, size, err := ts.terminal.ReadRune()
 			if err != nil {
 				if err != io.EOF {
-					global.Log.Error("机器ssh终端读取消息失败: ", err)
+					logx.Error("机器ssh终端读取消息失败: ", err)
 				}
 				return
 			}
@@ -108,7 +108,7 @@ func (ts TerminalSession) writeToWebsocket() {
 			if len(buf) > 0 {
 				s := string(buf)
 				if err := WriteMessage(ts.wsConn, s); err != nil {
-					global.Log.Error("机器ssh终端发送消息至websocket失败: ", err)
+					logx.Error("机器ssh终端发送消息至websocket失败: ", err)
 					return
 				}
 				// 如果记录器存在，则记录操作回放信息
@@ -148,25 +148,25 @@ func (ts *TerminalSession) receiveWsMsg() {
 			// read websocket msg
 			_, wsData, err := wsConn.ReadMessage()
 			if err != nil {
-				global.Log.Debug("机器ssh终端读取websocket消息失败: ", err)
+				logx.Debugf("机器ssh终端读取websocket消息失败: %s", err.Error())
 				return
 			}
 			// 解析消息
 			msgObj := WsMsg{}
 			if err := json.Unmarshal(wsData, &msgObj); err != nil {
-				global.Log.Error("机器ssh终端消息解析失败: ", err)
+				logx.Error("机器ssh终端消息解析失败: ", err)
 			}
 			switch msgObj.Type {
 			case Resize:
 				if msgObj.Cols > 0 && msgObj.Rows > 0 {
 					if err := ts.terminal.WindowChange(msgObj.Rows, msgObj.Cols); err != nil {
-						global.Log.Error("ssh pty change windows size failed")
+						logx.Error("ssh pty change windows size failed")
 					}
 				}
 			case Data:
 				_, err := ts.terminal.Write([]byte(msgObj.Msg))
 				if err != nil {
-					global.Log.Debugf("机器ssh终端写入消息失败: %s", err)
+					logx.Debugf("机器ssh终端写入消息失败: %s", err)
 				}
 			case Ping:
 				_, err := ts.terminal.SshSession.SendRequest("ping", true, nil)

server/internal/machine/infrastructure/persistence/machine_file.go

@@ -40,9 +40,9 @@ func (m *machineFileRepoImpl) Delete(id uint64) {
 }
 
 func (m *machineFileRepoImpl) Create(entity *entity.MachineFile) {
-	gormx.Insert(entity)
+	biz.ErrIsNil(gormx.Insert(entity), "新增机器文件配置失败")
 }
 
 func (m *machineFileRepoImpl) UpdateById(entity *entity.MachineFile) {
-	gormx.UpdateById(entity)
+	biz.ErrIsNil(gormx.UpdateById(entity), "更新机器文件失败")
 }