chenyh
/
vRp.CD2g_test
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

other: 日志字段调用由 zap.Field 更改为 log.Field

This commit is contained in:
kercylan98 2023-07-15 09:36:24 +08:00
parent 25ed712fc9
commit 8e2b4ebc89
15 changed files with 80 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
config/config.go
View File

@ -4,7 +4,6 @@ import (
jsonIter "github.com/json-iterator/go" jsonIter "github.com/json-iterator/go"
"github.com/kercylan98/minotaur/utils/log" "github.com/kercylan98/minotaur/utils/log"
"github.com/kercylan98/minotaur/utils/timer" "github.com/kercylan98/minotaur/utils/timer"
"go.uber.org/zap"
"os" "os"
"path/filepath" "path/filepath"
"sync" "sync"
@ -51,7 +50,7 @@ func Load() {
return err return err
} }
if err = json.Unmarshal(bytes, &config); err == nil && isInit { if err = json.Unmarshal(bytes, &config); err == nil && isInit {
log.Info("Config", zap.String("Name", filename), zap.Bool("LoadSuccess", true)) log.Info("Config", log.String("Name", filename), log.Bool("LoadSuccess", true))
} }
return err return err
}) })

5
game/builtin/room.go
View File

@ -5,7 +5,6 @@ import (
"github.com/kercylan98/minotaur/utils/asynchronous" "github.com/kercylan98/minotaur/utils/asynchronous"
"github.com/kercylan98/minotaur/utils/hash" "github.com/kercylan98/minotaur/utils/hash"
"github.com/kercylan98/minotaur/utils/log" "github.com/kercylan98/minotaur/utils/log"
"go.uber.org/zap"
) )
// NewRoom 创建一个默认的内置游戏房间 Room // NewRoom 创建一个默认的内置游戏房间 Room
@ -90,7 +89,7 @@ func (slf *Room[PlayerID, Player]) Join(player Player) error {
} }
slf.players.Set(playerId, player) slf.players.Set(playerId, player)
if !exist { if !exist {
log.Debug("Room.Join", zap.Any("guid", slf.GetGuid()), zap.Any("player", playerId)) log.Debug("Room.Join", log.Any("guid", slf.GetGuid()), log.Any("player", playerId))
if slf.players.Size() == 1 && !slf.noMaster { if slf.players.Size() == 1 && !slf.noMaster {
slf.owner = playerId slf.owner = playerId
} }
@ -105,7 +104,7 @@ func (slf *Room[PlayerID, Player]) Leave(id PlayerID) {
if !exist { if !exist {
return return
} }
log.Debug("Room.Leave", zap.Any("guid", slf.GetGuid()), zap.Any("player", id)) log.Debug("Room.Leave", log.Any("guid", slf.GetGuid()), log.Any("player", id))
slf.OnPlayerLeaveRoomEvent(player) slf.OnPlayerLeaveRoomEvent(player)
slf.players.Delete(id) slf.players.Delete(id)
} }

9
game/builtin/world.go
View File

@ -5,7 +5,6 @@ import (
"github.com/kercylan98/minotaur/utils/hash" "github.com/kercylan98/minotaur/utils/hash"
"github.com/kercylan98/minotaur/utils/log" "github.com/kercylan98/minotaur/utils/log"
"github.com/kercylan98/minotaur/utils/synchronization" "github.com/kercylan98/minotaur/utils/synchronization"
"go.uber.org/zap"
"sync/atomic" "sync/atomic"
) )
@ -103,7 +102,7 @@ func (slf *World[PlayerID, Player]) Join(player Player) error {
if slf.players.Size() >= slf.playerLimit && slf.playerLimit > 0 { if slf.players.Size() >= slf.playerLimit && slf.playerLimit > 0 {
return ErrWorldPlayerLimit return ErrWorldPlayerLimit
} }
log.Debug("World.Join", zap.Int64("guid", slf.GetGuid()), zap.Any("player", player.GetID())) log.Debug("World.Join", log.Int64("guid", slf.GetGuid()), log.Any("player", player.GetID()))
slf.players.Set(player.GetID(), player) slf.players.Set(player.GetID(), player)
if actors := slf.playerActors.Get(player.GetID()); actors == nil { if actors := slf.playerActors.Get(player.GetID()); actors == nil {
actors = synchronization.NewMap[int64, game.Actor]() actors = synchronization.NewMap[int64, game.Actor]()
@ -118,7 +117,7 @@ func (slf *World[PlayerID, Player]) Leave(id PlayerID) {
if !exist { if !exist {
return return
} }
log.Debug("World.Leave", zap.Int64("guid", slf.GetGuid()), zap.Any("player", player.GetID())) log.Debug("World.Leave", log.Int64("guid", slf.GetGuid()), log.Any("player", player.GetID()))
slf.OnPlayerLeaveWorldEvent(player) slf.OnPlayerLeaveWorldEvent(player)
slf.playerActors.Get(player.GetID()).Range(func(guid int64, actor game.Actor) { slf.playerActors.Get(player.GetID()).Range(func(guid int64, actor game.Actor) {
slf.OnActorAnnihilationEvent(actor) slf.OnActorAnnihilationEvent(actor)
@ -170,7 +169,7 @@ func (slf *World[PlayerID, Player]) RemoveActorOwner(guid int64) {
} }
func (slf *World[PlayerID, Player]) Reset() { func (slf *World[PlayerID, Player]) Reset() {
log.Debug("World", zap.Int64("Reset", slf.guid)) log.Debug("World", log.Int64("Reset", slf.guid))
slf.players.Clear() slf.players.Clear()
slf.playerActors.Range(func(id PlayerID, actors hash.Map[int64, game.Actor]) { slf.playerActors.Range(func(id PlayerID, actors hash.Map[int64, game.Actor]) {
actors.Clear() actors.Clear()
@ -184,7 +183,7 @@ func (slf *World[PlayerID, Player]) Reset() {
func (slf *World[PlayerID, Player]) Release() { func (slf *World[PlayerID, Player]) Release() {
if !slf.released.Swap(true) { if !slf.released.Swap(true) {
log.Debug("World", zap.Int64("Release", slf.guid)) log.Debug("World", log.Int64("Release", slf.guid))
slf.OnWorldReleaseEvent() slf.OnWorldReleaseEvent()
slf.Reset() slf.Reset()
slf.players = nil slf.players = nil

7
notify/manager.go
View File

@ -2,7 +2,6 @@ package notify
import ( import (
"github.com/kercylan98/minotaur/utils/log" "github.com/kercylan98/minotaur/utils/log"
"go.uber.org/zap"
"reflect" "reflect"
) )
@ -20,19 +19,19 @@ func NewManager(senders ...Sender) *Manager {
case <-manager.closeChannel: case <-manager.closeChannel:
close(manager.closeChannel) close(manager.closeChannel)
close(manager.notifyChannel) close(manager.notifyChannel)
log.Info("Manager", zap.String("state", "release")) log.Info("Manager", log.String("state", "release"))
return return
case notify := <-manager.notifyChannel: case notify := <-manager.notifyChannel:
for _, sender := range manager.senders { for _, sender := range manager.senders {
if err := sender.Push(notify); err != nil { if err := sender.Push(notify); err != nil {
log.Error("Manager", zap.String("sender", reflect.TypeOf(sender).String()), zap.Error(err)) log.Error("Manager", log.String("sender", reflect.TypeOf(sender).String()), log.Err(err))
} }
} }
} }
} }
}() }()
log.Info("Manager", zap.String("state", "running")) log.Info("Manager", log.String("state", "running"))
return manager return manager
} }

31
planner/configexport/configexport.go
View File

@ -8,7 +8,6 @@ import (
"github.com/kercylan98/minotaur/utils/log" "github.com/kercylan98/minotaur/utils/log"
"github.com/kercylan98/minotaur/utils/str" "github.com/kercylan98/minotaur/utils/str"
"github.com/tealeg/xlsx" "github.com/tealeg/xlsx"
"go.uber.org/zap"
"os/exec" "os/exec"
"path/filepath" "path/filepath"
"runtime/debug" "runtime/debug"
@ -29,21 +28,21 @@ func New(xlsxPath string) *ConfigExport {
switch err { switch err {
case internal.ErrReadConfigFailedSame: case internal.ErrReadConfigFailedSame:
log.Warn("ConfigExport", log.Warn("ConfigExport",
zap.String("File", xlsxPath), log.String("File", xlsxPath),
zap.String("Sheet", sheet.Name), log.String("Sheet", sheet.Name),
zap.String("Info", "A configuration with the same name exists, skipped"), log.String("Info", "A configuration with the same name exists, skipped"),
) )
case internal.ErrReadConfigFailedIgnore: case internal.ErrReadConfigFailedIgnore:
log.Info("ConfigExport", log.Info("ConfigExport",
zap.String("File", xlsxPath), log.String("File", xlsxPath),
zap.String("Sheet", sheet.Name), log.String("Sheet", sheet.Name),
zap.String("Info", "Excluded non-configuration table files"), log.String("Info", "Excluded non-configuration table files"),
) )
default: default:
log.Error("ConfigExport", log.Error("ConfigExport",
zap.String("File", xlsxPath), log.String("File", xlsxPath),
zap.String("Sheet", sheet.Name), log.String("Sheet", sheet.Name),
zap.String("Info", "Excluded non-configuration table files"), log.String("Info", "Excluded non-configuration table files"),
) )
debug.PrintStack() debug.PrintStack()
} }
@ -55,9 +54,9 @@ func New(xlsxPath string) *ConfigExport {
ce.exist[config.Name] = true ce.exist[config.Name] = true
log.Info("ConfigExport", log.Info("ConfigExport",
zap.String("File", xlsxPath), log.String("File", xlsxPath),
zap.String("Sheet", sheet.Name), log.String("Sheet", sheet.Name),
zap.String("Info", "Export successfully"), log.String("Info", "Export successfully"),
) )
} }
} }
@ -84,9 +83,9 @@ func Merge(exports ...*ConfigExport) *ConfigExport {
for _, config := range ce.configs { for _, config := range ce.configs {
if _, ok := export.exist[config.Name]; ok { if _, ok := export.exist[config.Name]; ok {
log.Warn("ConfigExport", log.Warn("ConfigExport",
zap.String("File", ce.xlsxPath), log.String("File", ce.xlsxPath),
zap.String("Sheet", config.Name), log.String("Sheet", config.Name),
zap.String("Info", "A configuration with the same name exists, skipped"), log.String("Info", "A configuration with the same name exists, skipped"),
) )
continue continue
} }

4
planner/configexport/example/config.go
View File

@ -25,12 +25,12 @@ func LoadConfig(handle func(filename string, config any) error) {
var err error var err error
_IndexConfig = make(map[int]map[string]*IndexConfigDefine) _IndexConfig = make(map[int]map[string]*IndexConfigDefine)
if err = handle("IndexConfig.json", &_IndexConfig); err != nil { if err = handle("IndexConfig.json", &_IndexConfig); err != nil {
log.Error("Config", zap.String("Name", "IndexConfig"), zap.Bool("Invalid", true), zap.Error(err)) log.Err("Config", log.String("Name", "IndexConfig"), log.Bool("Invalid", true), log.Err(err))
} }
_EasyConfig = new(EasyConfigDefine) _EasyConfig = new(EasyConfigDefine)
if err = handle("EasyConfig.json", _EasyConfig); err != nil { if err = handle("EasyConfig.json", _EasyConfig); err != nil {
log.Error("Config", zap.String("Name", "EasyConfig"), zap.Bool("Invalid", true), zap.Error(err)) log.Err("Config", log.String("Name", "EasyConfig"), log.Bool("Invalid", true), log.Err(err))
} }
} }

4
planner/configexport/internal/template.go
View File

@ -59,11 +59,11 @@ func LoadConfig(handle func(filename string, config any) error) {
_{{$config.Name}} = {{$config.GetVariableGen}} _{{$config.Name}} = {{$config.GetVariableGen}}
{{if eq $config.IndexCount 0}} {{if eq $config.IndexCount 0}}
if err = handle("{{$config.Prefix}}{{$config.Name}}.json", _{{$config.Name}}); err != nil { if err = handle("{{$config.Prefix}}{{$config.Name}}.json", _{{$config.Name}}); err != nil {
log.Error("Config", zap.String("Name", "{{$config.Name}}"), zap.Bool("Invalid", true), zap.Error(err)) log.Err("Config", log.String("Name", "{{$config.Name}}"), log.Bool("Invalid", true), log.Err(err))
} }
{{else}} {{else}}
if err = handle("{{$config.Prefix}}{{$config.Name}}.json", &_{{$config.Name}}); err != nil { if err = handle("{{$config.Prefix}}{{$config.Name}}.json", &_{{$config.Name}}); err != nil {
log.Error("Config", zap.String("Name", "{{$config.Name}}"), zap.Bool("Invalid", true), zap.Error(err)) log.Err("Config", log.String("Name", "{{$config.Name}}"), log.Bool("Invalid", true), log.Err(err))
} }
{{end}} {{end}}
{{end}} {{end}}

7
server/cross/nats.go
View File

@ -7,7 +7,6 @@ import (
"github.com/kercylan98/minotaur/utils/log" "github.com/kercylan98/minotaur/utils/log"
"github.com/kercylan98/minotaur/utils/synchronization" "github.com/kercylan98/minotaur/utils/synchronization"
"github.com/nats-io/nats.go" "github.com/nats-io/nats.go"
"go.uber.org/zap"
"time" "time"
) )
@ -47,10 +46,10 @@ func (slf *Nats) Init(server *server.Server, packetHandle func(serverId int64, p
nats.ReconnectWait(time.Second*5), nats.ReconnectWait(time.Second*5),
nats.MaxReconnects(-1), nats.MaxReconnects(-1),
nats.DisconnectErrHandler(func(conn *nats.Conn, err error) { nats.DisconnectErrHandler(func(conn *nats.Conn, err error) {
log.Error(nasMark, zap.String("info", "disconnect"), zap.Error(err)) log.Error(nasMark, log.String("info", "disconnect"), log.Err(err))
}), }),
nats.ReconnectHandler(func(conn *nats.Conn) { nats.ReconnectHandler(func(conn *nats.Conn) {
log.Info(nasMark, zap.String("info", "reconnect")) log.Info(nasMark, log.String("info", "reconnect"))
}), }),
) )
} }
@ -63,7 +62,7 @@ func (slf *Nats) Init(server *server.Server, packetHandle func(serverId int64, p
message := slf.messagePool.Get() message := slf.messagePool.Get()
defer slf.messagePool.Release(message) defer slf.messagePool.Release(message)
if err := json.Unmarshal(msg.Data, &message); err != nil { if err := json.Unmarshal(msg.Data, &message); err != nil {
log.Error(nasMark, zap.Error(err)) log.Error(nasMark, log.Err(err))
return return
} }
packetHandle(message.ServerId, message.Packet) packetHandle(message.ServerId, message.Packet)

31
server/event.go
View File

@ -4,7 +4,6 @@ import (
"fmt" "fmt"
"github.com/kercylan98/minotaur/utils/log" "github.com/kercylan98/minotaur/utils/log"
"github.com/kercylan98/minotaur/utils/runtimes" "github.com/kercylan98/minotaur/utils/runtimes"
"go.uber.org/zap"
"reflect" "reflect"
"runtime/debug" "runtime/debug"
"sync" "sync"
@ -42,7 +41,7 @@ type event struct {
// RegStopEvent 服务器停止时将立即执行被注册的事件处理函数 // RegStopEvent 服务器停止时将立即执行被注册的事件处理函数
func (slf *event) RegStopEvent(handle StopEventHandle) { func (slf *event) RegStopEvent(handle StopEventHandle) {
slf.stopEventHandles = append(slf.stopEventHandles, handle) slf.stopEventHandles = append(slf.stopEventHandles, handle)
log.Info("Server", zap.String("RegEvent", runtimes.CurrentRunningFuncName()), zap.String("handle", reflect.TypeOf(handle).String())) log.Info("Server", log.String("RegEvent", runtimes.CurrentRunningFuncName()), log.String("handle", reflect.TypeOf(handle).String()))
} }
func (slf *event) OnStopEvent() { func (slf *event) OnStopEvent() {
@ -68,7 +67,7 @@ func (slf *event) RegConsoleCommandEvent(command string, handle ConsoleCommandEv
}() }()
}) })
slf.consoleCommandEventHandles[command] = append(slf.consoleCommandEventHandles[command], handle) slf.consoleCommandEventHandles[command] = append(slf.consoleCommandEventHandles[command], handle)
log.Info("Server", zap.String("RegEvent", runtimes.CurrentRunningFuncName()), zap.String("handle", reflect.TypeOf(handle).String())) log.Info("Server", log.String("RegEvent", runtimes.CurrentRunningFuncName()), log.String("handle", reflect.TypeOf(handle).String()))
} }
func (slf *event) OnConsoleCommandEvent(command string) { func (slf *event) OnConsoleCommandEvent(command string) {
@ -77,11 +76,11 @@ func (slf *event) OnConsoleCommandEvent(command string) {
if !exist { if !exist {
switch command { switch command {
case "exit", "quit", "close", "shutdown", "EXIT", "QUIT", "CLOSE", "SHUTDOWN": case "exit", "quit", "close", "shutdown", "EXIT", "QUIT", "CLOSE", "SHUTDOWN":
log.Info("Console", zap.String("Receive", command), zap.String("Action", "Shutdown")) log.Info("Console", log.String("Receive", command), log.String("Action", "Shutdown"))
slf.Server.shutdown(nil) slf.Server.shutdown(nil)
return return
} }
log.Warn("Server", zap.String("Command", "unregistered")) log.Warn("Server", log.String("Command", "unregistered"))
} else { } else {
for _, handle := range handles { for _, handle := range handles {
handle(slf.Server) handle(slf.Server)
@ -93,13 +92,13 @@ func (slf *event) OnConsoleCommandEvent(command string) {
// RegStartBeforeEvent 在服务器初始化完成启动前立刻执行被注册的事件处理函数 // RegStartBeforeEvent 在服务器初始化完成启动前立刻执行被注册的事件处理函数
func (slf *event) RegStartBeforeEvent(handle StartBeforeEventHandle) { func (slf *event) RegStartBeforeEvent(handle StartBeforeEventHandle) {
slf.startBeforeEventHandles = append(slf.startBeforeEventHandles, handle) slf.startBeforeEventHandles = append(slf.startBeforeEventHandles, handle)
log.Info("Server", zap.String("RegEvent", runtimes.CurrentRunningFuncName()), zap.String("handle", reflect.TypeOf(handle).String())) log.Info("Server", log.String("RegEvent", runtimes.CurrentRunningFuncName()), log.String("handle", reflect.TypeOf(handle).String()))
} }
func (slf *event) OnStartBeforeEvent() { func (slf *event) OnStartBeforeEvent() {
defer func() { defer func() {
if err := recover(); err != nil { if err := recover(); err != nil {
log.Error("Server", zap.String("OnStartBeforeEvent", fmt.Sprintf("%v", err))) log.Error("Server", log.String("OnStartBeforeEvent", fmt.Sprintf("%v", err)))
debug.PrintStack() debug.PrintStack()
} }
}() }()
@ -111,7 +110,7 @@ func (slf *event) OnStartBeforeEvent() {
// RegStartFinishEvent 在服务器启动完成时将立刻执行被注册的事件处理函数 // RegStartFinishEvent 在服务器启动完成时将立刻执行被注册的事件处理函数
func (slf *event) RegStartFinishEvent(handle StartFinishEventHandle) { func (slf *event) RegStartFinishEvent(handle StartFinishEventHandle) {
slf.startFinishEventHandles = append(slf.startFinishEventHandles, handle) slf.startFinishEventHandles = append(slf.startFinishEventHandles, handle)
log.Info("Server", zap.String("RegEvent", runtimes.CurrentRunningFuncName()), zap.String("handle", reflect.TypeOf(handle).String())) log.Info("Server", log.String("RegEvent", runtimes.CurrentRunningFuncName()), log.String("handle", reflect.TypeOf(handle).String()))
} }
func (slf *event) OnStartFinishEvent() { func (slf *event) OnStartFinishEvent() {
@ -128,7 +127,7 @@ func (slf *event) RegConnectionClosedEvent(handle ConnectionClosedEventHandle) {
panic(ErrNetworkIncompatibleHttp) panic(ErrNetworkIncompatibleHttp)
} }
slf.connectionClosedEventHandles = append(slf.connectionClosedEventHandles, handle) slf.connectionClosedEventHandles = append(slf.connectionClosedEventHandles, handle)
log.Info("Server", zap.String("RegEvent", runtimes.CurrentRunningFuncName()), zap.String("handle", reflect.TypeOf(handle).String())) log.Info("Server", log.String("RegEvent", runtimes.CurrentRunningFuncName()), log.String("handle", reflect.TypeOf(handle).String()))
} }
func (slf *event) OnConnectionClosedEvent(conn *Conn, err any) { func (slf *event) OnConnectionClosedEvent(conn *Conn, err any) {
@ -147,7 +146,7 @@ func (slf *event) RegConnectionOpenedEvent(handle ConnectionOpenedEventHandle) {
panic(ErrNetworkIncompatibleHttp) panic(ErrNetworkIncompatibleHttp)
} }
slf.connectionOpenedEventHandles = append(slf.connectionOpenedEventHandles, handle) slf.connectionOpenedEventHandles = append(slf.connectionOpenedEventHandles, handle)
log.Info("Server", zap.String("RegEvent", runtimes.CurrentRunningFuncName()), zap.String("handle", reflect.TypeOf(handle).String())) log.Info("Server", log.String("RegEvent", runtimes.CurrentRunningFuncName()), log.String("handle", reflect.TypeOf(handle).String()))
} }
func (slf *event) OnConnectionOpenedEvent(conn *Conn) { func (slf *event) OnConnectionOpenedEvent(conn *Conn) {
@ -165,7 +164,7 @@ func (slf *event) RegConnectionReceivePacketEvent(handle ConnectionReceivePacket
panic(ErrNetworkIncompatibleHttp) panic(ErrNetworkIncompatibleHttp)
} }
slf.connectionReceivePacketEventHandles = append(slf.connectionReceivePacketEventHandles, handle) slf.connectionReceivePacketEventHandles = append(slf.connectionReceivePacketEventHandles, handle)
log.Info("Server", zap.String("RegEvent", runtimes.CurrentRunningFuncName()), zap.String("handle", reflect.TypeOf(handle).String())) log.Info("Server", log.String("RegEvent", runtimes.CurrentRunningFuncName()), log.String("handle", reflect.TypeOf(handle).String()))
} }
func (slf *event) OnConnectionReceivePacketEvent(conn *Conn, packet Packet) { func (slf *event) OnConnectionReceivePacketEvent(conn *Conn, packet Packet) {
@ -177,7 +176,7 @@ func (slf *event) OnConnectionReceivePacketEvent(conn *Conn, packet Packet) {
// RegReceiveCrossPacketEvent 在接收到跨服数据包时将立即执行被注册的事件处理函数 // RegReceiveCrossPacketEvent 在接收到跨服数据包时将立即执行被注册的事件处理函数
func (slf *event) RegReceiveCrossPacketEvent(handle ReceiveCrossPacketEventHandle) { func (slf *event) RegReceiveCrossPacketEvent(handle ReceiveCrossPacketEventHandle) {
slf.receiveCrossPacketEventHandles = append(slf.receiveCrossPacketEventHandles, handle) slf.receiveCrossPacketEventHandles = append(slf.receiveCrossPacketEventHandles, handle)
log.Info("Server", zap.String("RegEvent", runtimes.CurrentRunningFuncName()), zap.String("handle", reflect.TypeOf(handle).String())) log.Info("Server", log.String("RegEvent", runtimes.CurrentRunningFuncName()), log.String("handle", reflect.TypeOf(handle).String()))
} }
func (slf *event) OnReceiveCrossPacketEvent(serverId int64, packet []byte) { func (slf *event) OnReceiveCrossPacketEvent(serverId int64, packet []byte) {
@ -189,7 +188,7 @@ func (slf *event) OnReceiveCrossPacketEvent(serverId int64, packet []byte) {
// RegMessageErrorEvent 在处理消息发生错误时将立即执行被注册的事件处理函数 // RegMessageErrorEvent 在处理消息发生错误时将立即执行被注册的事件处理函数
func (slf *event) RegMessageErrorEvent(handle MessageErrorEventHandle) { func (slf *event) RegMessageErrorEvent(handle MessageErrorEventHandle) {
slf.messageErrorEventHandles = append(slf.messageErrorEventHandles, handle) slf.messageErrorEventHandles = append(slf.messageErrorEventHandles, handle)
log.Info("Server", zap.String("RegEvent", runtimes.CurrentRunningFuncName()), zap.String("handle", reflect.TypeOf(handle).String())) log.Info("Server", log.String("RegEvent", runtimes.CurrentRunningFuncName()), log.String("handle", reflect.TypeOf(handle).String()))
} }
func (slf *event) OnMessageErrorEvent(message *Message, err error) { func (slf *event) OnMessageErrorEvent(message *Message, err error) {
@ -203,7 +202,7 @@ func (slf *event) OnMessageErrorEvent(message *Message, err error) {
// RegMessageLowExecEvent 在处理消息缓慢时将立即执行被注册的事件处理函数 // RegMessageLowExecEvent 在处理消息缓慢时将立即执行被注册的事件处理函数
func (slf *event) RegMessageLowExecEvent(handle MessageLowExecEventHandle) { func (slf *event) RegMessageLowExecEvent(handle MessageLowExecEventHandle) {
slf.messageLowExecEventHandles = append(slf.messageLowExecEventHandles, handle) slf.messageLowExecEventHandles = append(slf.messageLowExecEventHandles, handle)
log.Info("Server", zap.String("RegEvent", runtimes.CurrentRunningFuncName()), zap.String("handle", reflect.TypeOf(handle).String())) log.Info("Server", log.String("RegEvent", runtimes.CurrentRunningFuncName()), log.String("handle", reflect.TypeOf(handle).String()))
} }
func (slf *event) OnMessageLowExecEvent(message *Message, cost time.Duration) { func (slf *event) OnMessageLowExecEvent(message *Message, cost time.Duration) {
@ -219,12 +218,12 @@ func (slf *event) check() {
case NetworkHttp, NetworkGRPC: case NetworkHttp, NetworkGRPC:
default: default:
if len(slf.connectionReceivePacketEventHandles) == 0 { if len(slf.connectionReceivePacketEventHandles) == 0 {
log.Warn("Server", zap.String("ConnectionReceivePacketEvent", "invalid server, no packets processed")) log.Warn("Server", log.String("ConnectionReceivePacketEvent", "invalid server, no packets processed"))
} }
} }
if len(slf.receiveCrossPacketEventHandles) > 0 && slf.cross == nil { if len(slf.receiveCrossPacketEventHandles) > 0 && slf.cross == nil {
log.Warn("Server", zap.String("ReceiveCrossPacketEvent", "invalid server, not register cross server")) log.Warn("Server", log.String("ReceiveCrossPacketEvent", "invalid server, not register cross server"))
} }
} }

3
server/gnet.go
View File

@ -6,7 +6,6 @@ import (
"fmt" "fmt"
"github.com/kercylan98/minotaur/utils/log" "github.com/kercylan98/minotaur/utils/log"
"github.com/panjf2000/gnet" "github.com/panjf2000/gnet"
"go.uber.org/zap"
"time" "time"
) )
@ -23,7 +22,7 @@ func (slf *gNet) OnShutdown(server gnet.Server) {
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel() defer cancel()
if err := gnet.Stop(ctx, fmt.Sprintf("%s://%s", slf.network, slf.addr)); err != nil { if err := gnet.Stop(ctx, fmt.Sprintf("%s://%s", slf.network, slf.addr)); err != nil {
log.Error("Server", zap.String("Minotaur GNet Server", "Shutdown"), zap.Error(err)) log.Error("Server", log.String("Minotaur GNet Server", "Shutdown"), log.Err(err))
} }
} }

11
server/multiple.go
View File

@ -2,7 +2,6 @@ package server
import ( import (
"github.com/kercylan98/minotaur/utils/log" "github.com/kercylan98/minotaur/utils/log"
"go.uber.org/zap"
"os" "os"
"os/signal" "os/signal"
"sync" "sync"
@ -60,14 +59,14 @@ func (slf *MultipleServer) Run() {
} }
wait.Wait() wait.Wait()
log.Info("Server", zap.String(serverMultipleMark, "====================================================================")) log.Info("Server", log.String(serverMultipleMark, "===================================================================="))
for _, server := range slf.servers { for _, server := range slf.servers {
log.Info("Server", zap.String(serverMultipleMark, "RunningInfo"), log.Info("Server", log.String(serverMultipleMark, "RunningInfo"),
zap.Any("network", server.network), log.Any("network", server.network),
zap.String("listen", server.addr), log.String("listen", server.addr),
) )
} }
log.Info("Server", zap.String(serverMultipleMark, "====================================================================")) log.Info("Server", log.String(serverMultipleMark, "===================================================================="))
systemSignal := make(chan os.Signal, 1) systemSignal := make(chan os.Signal, 1)
signal.Notify(systemSignal, syscall.SIGHUP, syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT) signal.Notify(systemSignal, syscall.SIGHUP, syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT)

7
server/options.go
View File

@ -4,7 +4,6 @@ import (
"github.com/gin-contrib/pprof" "github.com/gin-contrib/pprof"
"github.com/kercylan98/minotaur/utils/log" "github.com/kercylan98/minotaur/utils/log"
"github.com/kercylan98/minotaur/utils/timer" "github.com/kercylan98/minotaur/utils/timer"
"go.uber.org/zap"
"google.golang.org/grpc" "google.golang.org/grpc"
"reflect" "reflect"
"time" "time"
@ -87,7 +86,7 @@ func WithDeadlockDetect(t time.Duration) Option {
return func(srv *Server) { return func(srv *Server) {
if t > 0 { if t > 0 {
srv.deadlockDetect = t srv.deadlockDetect = t
log.Info("DeadlockDetect", zap.String("Time", t.String())) log.Info("DeadlockDetect", log.String("Time", t.String()))
} }
} }
} }
@ -153,11 +152,11 @@ func WithCross(crossName string, serverId int64, cross Cross) Option {
srv.pushMessage(msg) srv.pushMessage(msg)
}) })
if err != nil { if err != nil {
log.Info("Cross", zap.Int64("ServerID", serverId), zap.String("Cross", reflect.TypeOf(cross).String()), zap.String("State", "WaitNatsRun")) log.Info("Cross", log.Int64("ServerID", serverId), log.String("Cross", reflect.TypeOf(cross).String()), log.String("State", "WaitNatsRun"))
time.Sleep(1 * time.Second) time.Sleep(1 * time.Second)
goto start goto start
} }
log.Info("Cross", zap.Int64("ServerID", serverId), zap.String("Cross", reflect.TypeOf(cross).String())) log.Info("Cross", log.Int64("ServerID", serverId), log.String("Cross", reflect.TypeOf(cross).String()))
} }
} }
} }

41
server/server.go
View File

@ -14,7 +14,6 @@ import (
"github.com/panjf2000/gnet" "github.com/panjf2000/gnet"
"github.com/panjf2000/gnet/pkg/logging" "github.com/panjf2000/gnet/pkg/logging"
"github.com/xtaci/kcp-go/v5" "github.com/xtaci/kcp-go/v5"
"go.uber.org/zap"
"google.golang.org/grpc" "google.golang.org/grpc"
"net" "net"
"net/http" "net/http"
@ -318,12 +317,12 @@ func (slf *Server) Run(addr string) error {
close(messageInitFinish) close(messageInitFinish)
messageInitFinish = nil messageInitFinish = nil
if slf.multiple == nil { if slf.multiple == nil {
log.Info("Server", zap.String(serverMark, "====================================================================")) log.Info("Server", log.String(serverMark, "===================================================================="))
log.Info("Server", zap.String(serverMark, "RunningInfo"), log.Info("Server", log.String(serverMark, "RunningInfo"),
zap.Any("network", slf.network), log.Any("network", slf.network),
zap.String("listen", slf.addr), log.String("listen", slf.addr),
) )
log.Info("Server", zap.String(serverMark, "====================================================================")) log.Info("Server", log.String(serverMark, "===================================================================="))
slf.OnStartFinishEvent() slf.OnStartFinishEvent()
signal.Notify(slf.systemSignal, syscall.SIGHUP, syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT) signal.Notify(slf.systemSignal, syscall.SIGHUP, syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT)
@ -422,15 +421,15 @@ func (slf *Server) shutdown(err error) {
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel() defer cancel()
if shutdownErr := slf.httpServer.Shutdown(ctx); shutdownErr != nil { if shutdownErr := slf.httpServer.Shutdown(ctx); shutdownErr != nil {
log.Error("Server", zap.Error(shutdownErr)) log.Error("Server", log.Err(shutdownErr))
} }
} }
if err != nil { if err != nil {
if slf.multiple != nil { if slf.multiple != nil {
slf.multiple.RegExitEvent(func() { slf.multiple.RegExitEvent(func() {
log.Panic("Server", zap.Any("network", slf.network), zap.String("listen", slf.addr), log.Panic("Server", log.Any("network", slf.network), log.String("listen", slf.addr),
zap.String("action", "shutdown"), zap.String("state", "exception"), zap.Error(err)) log.String("action", "shutdown"), log.String("state", "exception"), log.Err(err))
}) })
for i, server := range slf.multiple.servers { for i, server := range slf.multiple.servers {
if server.addr == slf.addr { if server.addr == slf.addr {
@ -439,12 +438,12 @@ func (slf *Server) shutdown(err error) {
} }
} }
} else { } else {
log.Panic("Server", zap.Any("network", slf.network), zap.String("listen", slf.addr), log.Panic("Server", log.Any("network", slf.network), log.String("listen", slf.addr),
zap.String("action", "shutdown"), zap.String("state", "exception"), zap.Error(err)) log.String("action", "shutdown"), log.String("state", "exception"), log.Err(err))
} }
} else { } else {
log.Info("Server", zap.Any("network", slf.network), zap.String("listen", slf.addr), log.Info("Server", log.Any("network", slf.network), log.String("listen", slf.addr),
zap.String("action", "shutdown"), zap.String("state", "normal")) log.String("action", "shutdown"), log.String("state", "normal"))
} }
if slf.gServer == nil { if slf.gServer == nil {
slf.closeChannel <- struct{}{} slf.closeChannel <- struct{}{}
@ -479,7 +478,7 @@ func (slf *Server) pushMessage(message *Message) {
func (slf *Server) low(message *Message, present time.Time, expect time.Duration) { func (slf *Server) low(message *Message, present time.Time, expect time.Duration) {
cost := time.Since(present) cost := time.Since(present)
if cost > expect { if cost > expect {
log.Warn("Server", zap.String("type", "low-message"), zap.String("cost", cost.String()), zap.String("message", message.String()), zap.Stack("stack")) log.Warn("Server", log.String("type", "low-message"), log.String("cost", cost.String()), log.String("message", message.String()), log.Stack("stack"))
slf.OnMessageLowExecEvent(message, cost) slf.OnMessageLowExecEvent(message, cost)
} }
} }
@ -496,7 +495,7 @@ func (slf *Server) dispatchMessage(msg *Message) {
select { select {
case <-ctx.Done(): case <-ctx.Done():
if err := ctx.Err(); err == context.DeadlineExceeded { if err := ctx.Err(); err == context.DeadlineExceeded {
log.Warn("Server", zap.String("MessageType", messageNames[msg.t]), zap.Any("SuspectedDeadlock", msg.attrs)) log.Warn("Server", log.String("MessageType", messageNames[msg.t]), log.Any("SuspectedDeadlock", msg.attrs))
} }
} }
}() }()
@ -506,7 +505,7 @@ func (slf *Server) dispatchMessage(msg *Message) {
defer func() { defer func() {
if err := recover(); err != nil { if err := recover(); err != nil {
stack := string(debug.Stack()) stack := string(debug.Stack())
log.Error("Server", zap.String("MessageType", messageNames[msg.t]), zap.Any("MessageAttrs", msg.attrs), zap.Any("error", err), zap.String("stack", stack)) log.Error("Server", log.String("MessageType", messageNames[msg.t]), log.Any("MessageAttrs", msg.attrs), log.Any("error", err), log.String("stack", stack))
fmt.Println(stack) fmt.Println(stack)
if e, ok := err.(error); ok { if e, ok := err.(error); ok {
slf.OnMessageErrorEvent(msg, e) slf.OnMessageErrorEvent(msg, e)
@ -535,11 +534,11 @@ func (slf *Server) dispatchMessage(msg *Message) {
err, action := attrs[0].(error), attrs[1].(MessageErrorAction) err, action := attrs[0].(error), attrs[1].(MessageErrorAction)
switch action { switch action {
case MessageErrorActionNone: case MessageErrorActionNone:
log.Panic("Server", zap.Error(err)) log.Panic("Server", log.Err(err))
case MessageErrorActionShutdown: case MessageErrorActionShutdown:
slf.shutdown(err) slf.shutdown(err)
default: default:
log.Warn("Server", zap.String("not support message error action", action.String())) log.Warn("Server", log.String("not support message error action", action.String()))
} }
case MessageTypeCross: case MessageTypeCross:
slf.OnReceiveCrossPacketEvent(attrs[0].(int64), attrs[1].([]byte)) slf.OnReceiveCrossPacketEvent(attrs[0].(int64), attrs[1].([]byte))
@ -552,7 +551,7 @@ func (slf *Server) dispatchMessage(msg *Message) {
defer func() { defer func() {
if err := recover(); err != nil { if err := recover(); err != nil {
stack := string(debug.Stack()) stack := string(debug.Stack())
log.Error("Server", zap.String("MessageType", messageNames[msg.t]), zap.Any("error", err), zap.String("stack", stack)) log.Error("Server", log.String("MessageType", messageNames[msg.t]), log.Any("error", err), log.String("stack", stack))
fmt.Println(stack) fmt.Println(stack)
if e, ok := err.(error); ok { if e, ok := err.(error); ok {
slf.OnMessageErrorEvent(msg, e) slf.OnMessageErrorEvent(msg, e)
@ -569,7 +568,7 @@ func (slf *Server) dispatchMessage(msg *Message) {
if cb { if cb {
callback(err) callback(err)
} else { } else {
log.Error("Server", zap.String("MessageType", messageNames[msg.t]), zap.Any("error", err), zap.String("stack", string(debug.Stack()))) log.Error("Server", log.String("MessageType", messageNames[msg.t]), log.Any("error", err), log.String("stack", string(debug.Stack())))
} }
}); err != nil { }); err != nil {
panic(err) panic(err)
@ -577,6 +576,6 @@ func (slf *Server) dispatchMessage(msg *Message) {
case MessageTypeSystem: case MessageTypeSystem:
attrs[0].(func())() attrs[0].(func())()
default: default:
log.Warn("Server", zap.String("not support message type", msg.t.String())) log.Warn("Server", log.String("not support message type", msg.t.String()))
} }
} }

3
utils/log/field.go
View File

@ -156,4 +156,7 @@ var (
// Any 接受一个键和一个任意值，并选择将它们表示为字段的最佳方式，仅在必要时才回退到基于反射的方法。 // Any 接受一个键和一个任意值，并选择将它们表示为字段的最佳方式，仅在必要时才回退到基于反射的方法。
// 由于 byteuint8 和 runeint32 是别名，Any 无法区分它们。为了尽量减少意外情况，[]byte 值被视为二进制 blob，字节值被视为 uint8，而 runes 始终被视为整数 // 由于 byteuint8 和 runeint32 是别名，Any 无法区分它们。为了尽量减少意外情况，[]byte 值被视为二进制 blob，字节值被视为 uint8，而 runes 始终被视为整数
Any = zap.Any Any = zap.Any
// Err 是常见习语 NamedError("error", err) 的简写
Err = zap.Error
) )

3
utils/synchronization/pool.go
View File

@ -2,7 +2,6 @@ package synchronization
import ( import (
"github.com/kercylan98/minotaur/utils/log" "github.com/kercylan98/minotaur/utils/log"
"go.uber.org/zap"
"sync" "sync"
) )
@ -42,7 +41,7 @@ func (slf *Pool[T]) Get() T {
slf.mutex.Unlock() slf.mutex.Unlock()
slf.warn++ slf.warn++
if slf.warn >= 100 { if slf.warn >= 100 {
log.Warn("Pool", zap.String("Get", "the number of buffer members is insufficient, consider whether it is due to unreleased or inappropriate buffer size")) log.Warn("Pool", log.String("Get", "the number of buffer members is insufficient, consider whether it is due to unreleased or inappropriate buffer size"))
slf.warn = 0 slf.warn = 0
} }
return slf.generator() return slf.generator()