Mirror/Erupe
1
0
Fork 0
mirror of https://github.com/Mezeporta/Erupe.git synced 2025-12-13 07:25:03 +01:00
Code Issues Packages Projects Releases Wiki Activity

rework logging code

Browse Source
This commit is contained in:
wish
2023-03-09 22:05:32 +11:00
parent b6fcc1ca14
commit dcab41a6c7
6 changed files with 86 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files

58
main.go
View File

@@ -43,7 +43,14 @@ var Commit = func() string {
func main() { func main() {
var err error var err error
zapLogger, _ := zap.NewDevelopment()
var zapLogger *zap.Logger
if config.ErupeConfig.DevMode {
zapLogger, _ = zap.NewDevelopment()
} else {
zapLogger, _ = zap.NewProduction()
}
defer zapLogger.Sync() defer zapLogger.Sync()
logger := zapLogger.Named("main") logger := zapLogger.Named("main")
@@ -76,20 +83,20 @@ func main() {
}) })
if err != nil { if err != nil {
preventClose(fmt.Sprintf("Failed to create Discord bot: %s", err.Error())) preventClose(fmt.Sprintf("Discord: Failed to start, %s", err.Error()))
} }
// Discord bot // Discord bot
err = bot.Start() err = bot.Start()
if err != nil { if err != nil {
preventClose(fmt.Sprintf("Failed to start Discord bot: %s", err.Error())) preventClose(fmt.Sprintf("Discord: Failed to start, %s", err.Error()))
} }
discordBot = bot discordBot = bot
logger.Info("Discord bot is enabled") logger.Info("Discord: Started successfully")
} else { } else {
logger.Info("Discord bot is disabled") logger.Info("Discord: Disabled")
} }
// Create the postgres DB pool. // Create the postgres DB pool.
@@ -104,15 +111,15 @@ func main() {
db, err := sqlx.Open("postgres", connectString) db, err := sqlx.Open("postgres", connectString)
if err != nil { if err != nil {
preventClose(fmt.Sprintf("Failed to open SQL database: %s", err.Error())) preventClose(fmt.Sprintf("Database: Failed to open, %s", err.Error()))
} }
// Test the DB connection. // Test the DB connection.
err = db.Ping() err = db.Ping()
if err != nil { if err != nil {
preventClose(fmt.Sprintf("Failed to ping database: %s", err.Error())) preventClose(fmt.Sprintf("Database: Failed to ping, %s", err.Error()))
} }
logger.Info("Connected to database") logger.Info("Database: Started successfully")
// Clear stale data // Clear stale data
_ = db.MustExec("DELETE FROM sign_sessions") _ = db.MustExec("DELETE FROM sign_sessions")
@@ -120,9 +127,9 @@ func main() {
// Clean the DB if the option is on. // Clean the DB if the option is on.
if config.ErupeConfig.DevMode && config.ErupeConfig.DevModeOptions.CleanDB { if config.ErupeConfig.DevMode && config.ErupeConfig.DevModeOptions.CleanDB {
logger.Info("Cleaning DB") logger.Info("Database: Started clearing...")
cleanDB(db) cleanDB(db)
logger.Info("Done cleaning DB") logger.Info("Database: Finished clearing")
} }
logger.Info(fmt.Sprintf("Server Time: %s", channelserver.TimeAdjusted().String())) logger.Info(fmt.Sprintf("Server Time: %s", channelserver.TimeAdjusted().String()))
@@ -141,9 +148,11 @@ func main() {
}) })
err = entranceServer.Start() err = entranceServer.Start()
if err != nil { if err != nil {
preventClose(fmt.Sprintf("Failed to start entrance server: %s", err.Error())) preventClose(fmt.Sprintf("Entrance: Failed to start, %s", err.Error()))
} }
logger.Info("Started entrance server") logger.Info("Entrance: Started successfully")
} else {
logger.Info("Entrance: Disabled")
} }
// Sign server. // Sign server.
@@ -158,9 +167,11 @@ func main() {
}) })
err = signServer.Start() err = signServer.Start()
if err != nil { if err != nil {
preventClose(fmt.Sprintf("Failed to start sign server: %s", err.Error())) preventClose(fmt.Sprintf("Sign: Failed to start, %s", err.Error()))
} }
logger.Info("Started sign server") logger.Info("Sign: Started successfully")
} else {
logger.Info("Sign: Disabled")
} }
// New Sign server // New Sign server
@@ -174,9 +185,11 @@ func main() {
}) })
err = newSignServer.Start() err = newSignServer.Start()
if err != nil { if err != nil {
preventClose(fmt.Sprintf("Failed to start sign-v2 server: %s", err.Error())) preventClose(fmt.Sprintf("SignV2: Failed to start, %s", err.Error()))
} }
logger.Info("Started new sign server") logger.Info("SignV2: Started successfully")
} else {
logger.Info("SignV2: Disabled")
} }
var channels []*channelserver.Server var channels []*channelserver.Server
@@ -205,11 +218,11 @@ func main() {
c.GlobalID = fmt.Sprintf("%02d%02d", j+1, i+1) c.GlobalID = fmt.Sprintf("%02d%02d", j+1, i+1)
err = c.Start() err = c.Start()
if err != nil { if err != nil {
preventClose(fmt.Sprintf("Failed to start channel server: %s", err.Error())) preventClose(fmt.Sprintf("Channel: Failed to start, %s", err.Error()))
} else { } else {
channelQuery += fmt.Sprintf(`INSERT INTO servers (server_id, season, current_players, world_name, world_description, land) VALUES (%d, %d, 0, '%s', '%s', %d);`, sid, si%3, ee.Name, ee.Description, i+1) channelQuery += fmt.Sprintf(`INSERT INTO servers (server_id, season, current_players, world_name, world_description, land) VALUES (%d, %d, 0, '%s', '%s', %d);`, sid, si%3, ee.Name, ee.Description, i+1)
channels = append(channels, &c) channels = append(channels, &c)
logger.Info(fmt.Sprintf("Started channel server %d on port %d", count, ce.Port)) logger.Info(fmt.Sprintf("Channel %d (%d): Started successfully", count, ce.Port))
ci++ ci++
count++ count++
} }
@@ -233,7 +246,14 @@ func main() {
signal.Notify(c, os.Interrupt, syscall.SIGTERM) signal.Notify(c, os.Interrupt, syscall.SIGTERM)
<-c <-c
logger.Info("Shutting down...") for i := 0; i < 10; i++ {
message := fmt.Sprintf("Shutting down in %d...", 10-i)
for _, c := range channels {
c.BroadcastChatMessage(message)
}
logger.Info(message)
time.Sleep(time.Second)
}
if config.ErupeConfig.Channel.Enabled { if config.ErupeConfig.Channel.Enabled {
for _, c := range channels { for _, c := range channels {

8
server/channelserver/handlers_cast_binary.go
View File

@@ -38,16 +38,18 @@ var commands map[string]config.Command
func init() { func init() {
commands = make(map[string]config.Command) commands = make(map[string]config.Command)
zapLogger, _ := zap.NewDevelopment() zapConfig := zap.NewDevelopmentConfig()
zapConfig.DisableCaller = true
zapLogger, _ := zapConfig.Build()
defer zapLogger.Sync() defer zapLogger.Sync()
logger := zapLogger.Named("commands") logger := zapLogger.Named("commands")
cmds := config.ErupeConfig.Commands cmds := config.ErupeConfig.Commands
for _, cmd := range cmds { for _, cmd := range cmds {
commands[cmd.Name] = cmd commands[cmd.Name] = cmd
if cmd.Enabled { if cmd.Enabled {
logger.Info(fmt.Sprintf("%s command is enabled, prefix: %s", cmd.Name, cmd.Prefix)) logger.Info(fmt.Sprintf("Command %s: Enabled, prefix: %s", cmd.Name, cmd.Prefix))
} else { } else {
logger.Info(fmt.Sprintf("%s command is disabled", cmd.Name)) logger.Info(fmt.Sprintf("Command %s: Disabled", cmd.Name))
} }
} }
} }

4
server/entranceserver/entrance_server.go
View File

@@ -111,7 +111,9 @@ func (s *Server) handleEntranceServerConnection(conn net.Conn) {
return return
} }
s.logger.Debug("Got entrance server command:\n", zap.String("raw", hex.Dump(pkt))) if s.erupeConfig.DevMode && s.erupeConfig.DevModeOptions.LogInboundMessages {
fmt.Printf("[Client] -> [Server]\nData [%d bytes]:\n%s\n", len(pkt), hex.Dump(pkt))
}
local := false local := false
if strings.Split(conn.RemoteAddr().String(), ":")[0] == "127.0.0.1" { if strings.Split(conn.RemoteAddr().String(), ":")[0] == "127.0.0.1" {

13
server/entranceserver/make_resp.go
View File

@@ -2,6 +2,8 @@ package entranceserver
import ( import (
"encoding/binary" "encoding/binary"
"encoding/hex"
"fmt"
"net" "net"
"erupe-ce/common/stringsupport" "erupe-ce/common/stringsupport"
@@ -92,6 +94,11 @@ func makeHeader(data []byte, respType string, entryCount uint16, key byte) []byt
func makeSv2Resp(config *config.Config, s *Server, local bool) []byte { func makeSv2Resp(config *config.Config, s *Server, local bool) []byte {
serverInfos := config.Entrance.Entries serverInfos := config.Entrance.Entries
rawServerData := encodeServerInfo(config, s, local) rawServerData := encodeServerInfo(config, s, local)
if s.erupeConfig.DevMode && s.erupeConfig.DevModeOptions.LogOutboundMessages {
fmt.Printf("[Server] -> [Client]\nData [%d bytes]:\n%s\n", len(rawServerData), hex.Dump(rawServerData))
}
bf := byteframe.NewByteFrame() bf := byteframe.NewByteFrame()
bf.WriteBytes(makeHeader(rawServerData, "SV2", uint16(len(serverInfos)), 0x00)) bf.WriteBytes(makeHeader(rawServerData, "SV2", uint16(len(serverInfos)), 0x00))
return bf.Data() return bf.Data()
@@ -109,11 +116,15 @@ func makeUsrResp(pkt []byte, s *Server) []byte {
err := s.db.QueryRow("SELECT(SELECT server_id FROM sign_sessions WHERE char_id=$1) AS _", cid).Scan(&sid) err := s.db.QueryRow("SELECT(SELECT server_id FROM sign_sessions WHERE char_id=$1) AS _", cid).Scan(&sid)
if err != nil { if err != nil {
resp.WriteBytes(make([]byte, 4)) resp.WriteBytes(make([]byte, 4))
continue
} else { } else {
resp.WriteUint16(sid) resp.WriteUint16(sid)
resp.WriteUint16(0) resp.WriteUint16(0)
} }
} }
if s.erupeConfig.DevMode && s.erupeConfig.DevModeOptions.LogOutboundMessages {
fmt.Printf("[Server] -> [Client]\nData [%d bytes]:\n%s\n", len(resp.Data()), hex.Dump(resp.Data()))
}
return makeHeader(resp.Data(), "USR", userEntries, 0x00) return makeHeader(resp.Data(), "USR", userEntries, 0x00)
} }

44
server/signserver/session.go
View File

@@ -3,6 +3,7 @@ package signserver
import ( import (
"database/sql" "database/sql"
"encoding/hex" "encoding/hex"
"fmt"
"net" "net"
"sync" "sync"
@@ -23,6 +24,11 @@ type Session struct {
func (s *Session) work() { func (s *Session) work() {
pkt, err := s.cryptConn.ReadPacket() pkt, err := s.cryptConn.ReadPacket()
if s.server.erupeConfig.DevMode && s.server.erupeConfig.DevModeOptions.LogInboundMessages {
fmt.Printf("\n[Client] -> [Server]\nData [%d bytes]:\n%s\n", len(pkt), hex.Dump(pkt))
}
if err != nil { if err != nil {
return return
} }
@@ -33,8 +39,6 @@ func (s *Session) work() {
} }
func (s *Session) handlePacket(pkt []byte) error { func (s *Session) handlePacket(pkt []byte) error {
sugar := s.logger.Sugar()
bf := byteframe.NewByteFrameFromBytes(pkt) bf := byteframe.NewByteFrameFromBytes(pkt)
reqType := string(bf.ReadNullTerminatedBytes()) reqType := string(bf.ReadNullTerminatedBytes())
switch reqType { switch reqType {
@@ -50,13 +54,16 @@ func (s *Session) handlePacket(pkt []byte) error {
characterID := int(bf.ReadUint32()) characterID := int(bf.ReadUint32())
_ = int(bf.ReadUint32()) // login_token_number _ = int(bf.ReadUint32()) // login_token_number
s.server.deleteCharacter(characterID, loginTokenString) s.server.deleteCharacter(characterID, loginTokenString)
sugar.Infof("Deleted character ID: %v\n", characterID) s.logger.Info("Deleted character", zap.Int("CharacterID", characterID))
err := s.cryptConn.SendPacket([]byte{0x01}) // DEL_SUCCESS err := s.cryptConn.SendPacket([]byte{0x01}) // DEL_SUCCESS
if err != nil { if err != nil {
return nil return nil
} }
default: default:
sugar.Infof("Got unknown request type %s, data:\n%s\n", reqType, hex.Dump(bf.DataFromCurrent())) s.logger.Warn("Unknown sign request", zap.String("reqType", reqType))
if s.server.erupeConfig.DevMode && s.server.erupeConfig.DevModeOptions.LogInboundMessages {
fmt.Printf("\n[Client] -> [Server]\nData [%d bytes]:\n%s\n", len(pkt), hex.Dump(pkt))
}
} }
return nil return nil
@@ -66,14 +73,7 @@ func (s *Session) handleDSGNRequest(bf *byteframe.ByteFrame) error {
reqUsername := string(bf.ReadNullTerminatedBytes()) reqUsername := string(bf.ReadNullTerminatedBytes())
reqPassword := string(bf.ReadNullTerminatedBytes()) reqPassword := string(bf.ReadNullTerminatedBytes())
reqSkey := string(bf.ReadNullTerminatedBytes()) _ = string(bf.ReadNullTerminatedBytes()) // Unk
s.server.logger.Info(
"Got sign in request",
zap.String("reqUsername", reqUsername),
zap.String("reqPassword", reqPassword),
zap.String("reqSkey", reqSkey),
)
newCharaReq := false newCharaReq := false
@@ -90,14 +90,14 @@ func (s *Session) handleDSGNRequest(bf *byteframe.ByteFrame) error {
var serverRespBytes []byte var serverRespBytes []byte
switch { switch {
case err == sql.ErrNoRows: case err == sql.ErrNoRows:
s.logger.Info("Account not found", zap.String("reqUsername", reqUsername)) s.logger.Info("User not found", zap.String("Username", reqUsername))
serverRespBytes = makeSignInFailureResp(SIGN_EAUTH) serverRespBytes = makeSignInFailureResp(SIGN_EAUTH)
if s.server.erupeConfig.DevMode && s.server.erupeConfig.DevModeOptions.AutoCreateAccount { if s.server.erupeConfig.DevMode && s.server.erupeConfig.DevModeOptions.AutoCreateAccount {
s.logger.Info("Creating account", zap.String("reqUsername", reqUsername), zap.String("reqPassword", reqPassword)) s.logger.Info("Creating user", zap.String("Username", reqUsername))
err = s.server.registerDBAccount(reqUsername, reqPassword) err = s.server.registerDBAccount(reqUsername, reqPassword)
if err != nil { if err != nil {
s.logger.Info("Error on creating new account", zap.Error(err)) s.logger.Error("Error registering new user", zap.Error(err))
serverRespBytes = makeSignInFailureResp(SIGN_EABORT) serverRespBytes = makeSignInFailureResp(SIGN_EABORT)
break break
} }
@@ -108,7 +108,7 @@ func (s *Session) handleDSGNRequest(bf *byteframe.ByteFrame) error {
var id int var id int
err = s.server.db.QueryRow("SELECT id FROM users WHERE username = $1", reqUsername).Scan(&id) err = s.server.db.QueryRow("SELECT id FROM users WHERE username = $1", reqUsername).Scan(&id)
if err != nil { if err != nil {
s.logger.Info("Error on querying account id", zap.Error(err)) s.logger.Error("Error getting new user ID", zap.Error(err))
serverRespBytes = makeSignInFailureResp(SIGN_EABORT) serverRespBytes = makeSignInFailureResp(SIGN_EABORT)
break break
} }
@@ -117,15 +117,15 @@ func (s *Session) handleDSGNRequest(bf *byteframe.ByteFrame) error {
break break
case err != nil: case err != nil:
serverRespBytes = makeSignInFailureResp(SIGN_EABORT) serverRespBytes = makeSignInFailureResp(SIGN_EABORT)
s.logger.Warn("Got error on SQL query", zap.Error(err)) s.logger.Error("Error getting user details", zap.Error(err))
break break
default: default:
if bcrypt.CompareHashAndPassword([]byte(password), []byte(reqPassword)) == nil { if bcrypt.CompareHashAndPassword([]byte(password), []byte(reqPassword)) == nil {
s.logger.Info("Passwords match!") s.logger.Debug("Passwords match!")
if newCharaReq { if newCharaReq {
err = s.server.newUserChara(reqUsername) err = s.server.newUserChara(reqUsername)
if err != nil { if err != nil {
s.logger.Info("Error on adding new character to account", zap.Error(err)) s.logger.Error("Error adding new character to user", zap.Error(err))
serverRespBytes = makeSignInFailureResp(SIGN_EABORT) serverRespBytes = makeSignInFailureResp(SIGN_EABORT)
break break
} }
@@ -139,12 +139,16 @@ func (s *Session) handleDSGNRequest(bf *byteframe.ByteFrame) error {
// } // }
serverRespBytes = s.makeSignInResp(id) serverRespBytes = s.makeSignInResp(id)
} else { } else {
s.logger.Info("Passwords don't match!") s.logger.Warn("Incorrect password")
serverRespBytes = makeSignInFailureResp(SIGN_EPASS) serverRespBytes = makeSignInFailureResp(SIGN_EPASS)
} }
} }
if s.server.erupeConfig.DevMode && s.server.erupeConfig.DevModeOptions.LogOutboundMessages {
fmt.Printf("\n[Server] -> [Client]\nData [%d bytes]:\n%s\n", len(serverRespBytes), hex.Dump(serverRespBytes))
}
err = s.cryptConn.SendPacket(serverRespBytes) err = s.cryptConn.SendPacket(serverRespBytes)
if err != nil { if err != nil {
return err return err

6
server/signserver/sign_server.go
View File

@@ -55,7 +55,7 @@ func (s *Server) Start() error {
// Shutdown exits the server gracefully. // Shutdown exits the server gracefully.
func (s *Server) Shutdown() { func (s *Server) Shutdown() {
s.logger.Debug("Shutting down") s.logger.Debug("Shutting down...")
s.Lock() s.Lock()
s.isShuttingDown = true s.isShuttingDown = true
@@ -86,14 +86,14 @@ func (s *Server) acceptClients() {
} }
func (s *Server) handleConnection(conn net.Conn) { func (s *Server) handleConnection(conn net.Conn) {
s.logger.Info("Got connection to sign server", zap.String("remoteaddr", conn.RemoteAddr().String())) s.logger.Debug("New connection", zap.String("RemoteAddr", conn.RemoteAddr().String()))
defer conn.Close() defer conn.Close()
// Client initalizes the connection with a one-time buffer of 8 NULL bytes. // Client initalizes the connection with a one-time buffer of 8 NULL bytes.
nullInit := make([]byte, 8) nullInit := make([]byte, 8)
_, err := io.ReadFull(conn, nullInit) _, err := io.ReadFull(conn, nullInit)
if err != nil { if err != nil {
s.logger.Error("Error initialising sign server connection", zap.Error(err)) s.logger.Error("Error initializing connection", zap.Error(err))
return return
} }