Go程序崩溃调试

// ws/ws.go
package ws

import (
"context"
"encoding/json"
"live-command-middleware/chrome"
"live-command-middleware/gopool"
"live-command-middleware/instruction"
"live-command-middleware/mylog/wlog"
"live-command-middleware/setting"
"live-command-middleware/trigger"
"live-command-middleware/websocket/messenger"
"time"

"github.com/gorilla/websocket"
hook "github.com/robotn/gohook"
)

const wsUrl = "ws://localhost:5000/ws"

var StopFlag = false // 停止标志，五秒内不接收Stop消息（因为stop之后前端会又广播一个）

var (
WsClient *wsClient
)

type wsClient struct {
conn *websocket.Conn
url string
}

type WsMessage = messenger.WsMessage // 引用 messenger 中的 WsMessage 类型

// NewWsClient 创建一个新的 WebSocket 客户端实例
func NewWsClient() error {
var err error
client := &wsClient{
url: wsUrl,
}
err = client.connect()
if err == nil {
WsClient = client
}
return err
}

// 连接到 WebSocket 服务器
func (c *wsClient) connect() error {
var dialer *websocket.Dialer
conn, _, err := dialer.Dial(c.url, nil)
if err != nil {
return err
}
c.conn = conn

// 初始化 messenger
messenger.InitMessenger(c.conn)

// 开始监听服务器消息
go c.listen()
return nil
}

func isUnexpectedEOF(err error) bool {
return websocket.IsCloseError(err, websocket.CloseAbnormalClosure)
}

// 监听服务器发送的消息
func (c *wsClient) listen() {
for {
_, message, err := c.conn.ReadMessage()
if err != nil {
if isUnexpectedEOF(err) {
wlog.Infof("智能中控客户端已关闭，正在尝试重新连接...")
// 在此处理特定的错误, 例如尝试重新连接
} else {
wlog.Errorf("读取消息出错:", err)
}
// 尝试重连
for {
err := c.connect()
if err == nil {
wlog.Infof("重连成功")
break
}
wlog.Errorf("重连失败，稍后重试:", err)
time.Sleep(5 * time.Second)
}
continue
}
// 处理接收到的消息
c.handleMessage(message)
}
}

// 处理接收到的消息
func (c *wsClient) handleMessage(message []byte) {
var msg WsMessage
err := json.Unmarshal(message, &msg)
if err != nil {
wlog.Errorf("JSON 解析错误:", err)
return
}

// 检查消息是否为自己发送的
if isSelfMessage(msg) {
return
}

switch msg.Type {
case "start":
wlog.Infod("收到启动指令: ", msg.Data, true)
c.handleStart(msg.Data, false)
case "reStart":
wlog.Infod("收到重启指令: ", msg.Data, true)
c.handleRestart(msg.Data)
case "stop":
if StopFlag {
return
}
wlog.Infof("收到停止指令")
c.HandleStop()
case "heartBeat":
c.handleHeartBeat(msg.Data)
default:
wlog.Warnf("未知的消息: %v", msg)
}
}

// 辅助函数，判断是否为自己发送的消息
func isSelfMessage(msg WsMessage) bool {
if dataMap, ok := msg.Data.(map[string]interface{}); ok {
if fromClient, exists := dataMap["fromClient"].(bool); exists && fromClient {
return true
}
}
return false
}

// 处理 "start" 消息
func (c *wsClient) handleStart(data interface{}, isRestart bool) {
if !isRestart {
chrome.Init()
}
if msgMap, ok := data.(map[string]interface{}); ok {
platform, _ := msgMap["platform"].(string)
token, _ := msgMap["token"].(string)
setting.UserToken = token

if !isRestart {
instruction.SetCurrentPlatformAndOpen(platform)
}

// 这里暂时还有问题，浏览器如果刚打开就关不了会的不到session，还没有监听就被关闭了，前端无法感知
go instruction.MonitorTargetClosed(chrome.Ctx)

if !setting.LoadRemoteConfig() || !setting.LoadRemoteKeyboardSetting() {
wlog.Errorf("加载远程配置失败，启动失败")
return
}

chrome.ChildCtx, chrome.ChildCancelCtx = context.WithCancel(chrome.Ctx)

go trigger.ListenKeyBoard()
} else {
wlog.Errorf("类型断言失败，无法转换为 map[string]interface{}，当前data为: %v", data)
}
}

// 处理 "restart" 消息
func (c *wsClient) handleRestart(data interface{}) {

instruction.GracefulShutdownAll()
chrome.ChildCancelCtx()
hook.End()

time.Sleep(2 * time.Second)
// 保证其他goroutine尽可能退出
wlog.Infof("正在重启，等待2秒...")

// 如果当前浏览器已经被关闭了，则直接打开浏览器
c.handleStart(data, true)
}

// 处理 "stop" 消息
func (c *wsClient) HandleStop() {
if chrome.Ctx == nil || chrome.Ctx.Err() != nil {
return
}
if StopFlag {
return
}
StopFlag = true
// Note： 这里Stop之后服务端还会广播一个STOP消息，加一个延时等待，5秒内不接收Stop消息
go func() {
time.Sleep(5 * time.Second)
StopFlag = false
}()

instruction.GracefulShutdownAll()
chrome.CancelCtx()

// 通知前端调整为关闭按钮状态
messenger.SendMessage(
WsMessage{
Type: "stop",
Data: "null",
},
)
hook.End()

wlog.Infof("chrome被客户端关闭")
wlog.Infof("当前Goroutine数量: %d", gopool.GlobalPool.Running())
go func() {
time.Sleep(1 * time.Second)
if gopool.GlobalPool.Running() != 0 {
// 有一个是监听关闭状态的goroutine，在allocator.go中
wlog.Errorf("当前Gopool中Goroutine数量异常，请检查")
}
}()
}

// 处理 "heartBeat" 消息
func (c *wsClient) handleHeartBeat(data interface{}) {
wlog.Infof("收到心跳消息: %s", data.(string))
}

// 开始定时发送心跳
func (c *wsClient) StartHeartBeat() {
ticker := time.NewTicker(3 * time.Second)
go func() {
for range ticker.C {
err := messenger.SendHeartBeat("ping")
if err != nil {
wlog.Errorf("发送Ping消息出错:", err)
}
data := map[string]interface{}{
"instruction": "heartbeat",
"operateNo": 1,
"action": "on",
}
err = messenger.SendKeepAlive(data)
if err != nil {
wlog.Errorf("发送键盘保活状态失败:", err)
}
}
}()
}


上面是我跟前端进行通信的websocket连接的代码，
var startCmd = &cobra.Command{
Use: "start",
Short: "开始服务",
Long: `会开始监听操作`,
Run: func(cmd *cobra.Command, args []string) {
wlog.Info("程序开始")

err := ws.NewWsClient()
if err != nil {
// 重试连接
reTryNum := 100
for i := 0; i < reTryNum; i++ {
time.Sleep(1 * time.Second)
wlog.Infof("第 %d 次重试连接", i+1)
err = ws.NewWsClient()
if err == nil {
break
}
}
wlog.Errorf("ws连接失败 Error: %v", err)
os.Exit(10002)
}
ws.WsClient.StartHeartBeat()
wlog.Infof("ws连接成功，等待接受信号...")

select {}
},
}

func init() {
rootCmd.AddCommand(startCmd)
}

现在遇到了很奇怪的事情，就是我在vscode以调试模式启动，是一切正常的，但是我打包成exe之后，当我在进行了一系列的通信之后，突然程序就会死掉，然后日志也不会输出，我不知道是哪里错了，我应该怎么排查？用中文给我回答

所以是不是每次都 go build -gcflags "all=-N -l" 比直接go build好？