654 lines
21 KiB
Go
Raw Normal View History

2025-06-04 18:17:39 +08:00
package handler
import (
"ecs/proto"
"ecs/proto/old"
"github.com/oylshe1314/framework/client"
"github.com/oylshe1314/framework/client/rpc"
"github.com/oylshe1314/framework/errors"
"github.com/oylshe1314/framework/http"
"github.com/oylshe1314/framework/message"
"github.com/oylshe1314/framework/server"
"github.com/oylshe1314/framework/util"
"net/url"
)
type InnerHandler struct {
*Handler
httpRpcClient *rpc.HttpRpcClient
}
func NewInnerHandler(srv server.Server, httpRpcClient *rpc.HttpRpcClient) *InnerHandler {
return &InnerHandler{Handler: newHandler(srv), httpRpcClient: httpRpcClient}
}
func (this *InnerHandler) ServerDetect(msg *http.Message) {
var req = new(old.MsgServerDetectReq)
var err = msg.Read(req)
if err != nil {
this.logger.Error("Read message error, ", err)
_ = msg.Reply(proto.RawErrMessageError)
return
}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] <- ServerDetect, req: %s", msg.R.RemoteAddr, util.ToJsonString(req))
}
var list []*old.ServerDetectData
for _, serverDetect := range req.List {
var detectAck = new(message.MsgServerDetectAck)
reply, err := this.httpRpcClient.AppIdGet(serverDetect.Name, serverDetect.AppId, "/server/detect", nil, detectAck)
if err != nil {
this.logger.Warnf("[%s:%d] -> Server detect error, %v", serverDetect.Name, serverDetect.AppId, err)
continue
}
if reply.Status != errors.StatusSuccessful {
this.logger.Warnf("[%s:%d] -> Server detect failed, %v", serverDetect.Name, serverDetect.AppId, reply.Message)
continue
}
var detectData = &old.ServerDetectData{
ServerDetect: old.ServerDetect{
Name: serverDetect.Name,
AppId: serverDetect.AppId,
},
ProgramHash: detectAck.ProgramHash,
DataHash: detectAck.DataHash,
ConfigHash: detectAck.ConfigHash,
Pid: detectAck.Pid,
CPU: detectAck.CPU,
Memory: detectAck.Memory,
Coroutine: uint32(detectAck.Coroutine),
Info: detectAck.Info,
}
if serverDetect.Name == "game_1" {
var onlineAck = new(old.MsgServerOnlineAck)
reply, err = this.httpRpcClient.AppIdGet(serverDetect.Name, serverDetect.AppId, "/server/online", nil, onlineAck)
if err != nil {
this.logger.Warnf("[%s:%d:/server/online] -> Get server online error, %v", serverDetect.Name, serverDetect.AppId, err)
} else {
if reply.Status != errors.StatusSuccessful {
this.logger.Warnf("[%s:%d] -> Get server online failed, %v", serverDetect.Name, serverDetect.AppId, reply.Message)
} else {
detectData.Online = onlineAck.Online
}
}
}
list = append(list, detectData)
}
var ack = &old.MsgServerDetectAck{List: list}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] -> ServerDetect, ack: %s", msg.R.RemoteAddr, util.ToJsonString(ack))
}
_ = msg.Reply(ack)
}
func (this *InnerHandler) GateSettingGet(msg *http.Message) {
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] <- GateSettingGet, req: %s", msg.R.RemoteAddr, util.ToJsonString(nil))
}
var ack = new(old.MsgGateSettingGetAck)
reply, err := this.httpRpcClient.RandGet("gate", "/setting/get", nil, ack)
if err != nil {
this.logger.Error("[gate:0] -> Get setting error, ", err)
_ = msg.Reply(proto.RawErrInternalError)
return
}
if reply.Status != errors.StatusSuccessful {
this.logger.Error("[gate:0] -> Get setting error, ", reply.Message)
_ = msg.Reply(proto.RawErrInternalError)
return
}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] -> GateSettingGet, ack: %s", msg.R.RemoteAddr, util.ToJsonString(ack))
}
_ = msg.Reply(ack)
}
func (this *InnerHandler) GateSettingSave(msg *http.Message) {
var req = new(old.MsgGateSettingSaveReq)
var err = msg.Read(req)
if err != nil {
this.logger.Error("Read message error, ", err)
_ = msg.Reply(proto.RawErrMessageError)
return
}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] <- GateSettingGet, req: %s", msg.R.RemoteAddr, util.ToJsonString(req))
}
reply, err := this.httpRpcClient.RandPost("gate", "/setting/save", nil, req, nil)
if err != nil {
this.logger.Error("[gate:0] -> Save setting error, ", err)
_ = msg.Reply(proto.RawErrInternalError)
return
}
if reply.Status != errors.StatusSuccessful {
this.logger.Error("[gate:0] -> Save setting error, ", reply.Message)
_ = msg.Reply(proto.RawErrInternalError)
return
}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] -> GateSettingGet, ack: %s", msg.R.RemoteAddr, util.ToJsonString(nil))
}
_ = msg.Reply(nil)
}
func (this *InnerHandler) GateUserQuery(msg *http.Message) {
var req = new(old.MsgUserQueryReq)
var err = msg.Read(req)
if err != nil {
this.logger.Error("Read message error, ", err)
_ = msg.Reply(proto.RawErrMessageError)
return
}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] <- GateUserQuery, req: %s", msg.R.RemoteAddr, util.ToJsonString(req))
}
var query = url.Values{}
query.Add("pageNo", util.IntegerToString(req.PageNo))
query.Add("pageSize", util.IntegerToString(req.PageSize))
if req.Channel != 0 {
query.Add("channel", util.IntegerToString(req.Channel))
}
if req.UserId > 0 {
query.Add("userId", util.IntegerToString(req.UserId))
}
reply, err := this.httpRpcClient.RandGet("gate", "/user/query", query, new(old.MsgUserQueryAck))
if err != nil {
this.logger.Error("Gate get cdkey error, ", err)
_ = msg.Reply(proto.RawErrInternalError)
return
}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] -> GateUserQuery, reply: %s", msg.R.RemoteAddr, util.ToJsonString(reply))
}
_ = msg.Reply(reply)
}
func (this *InnerHandler) GateUserOperate(msg *http.Message) {
var req = new(old.MsgUserOperateReq)
var err = msg.Read(req)
if err != nil {
this.logger.Error("Read message error, ", err)
_ = msg.Reply(proto.RawErrMessageError)
return
}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] <- GateUserOperate, req: %s", msg.R.RemoteAddr, util.ToJsonString(req))
}
reply, err := this.httpRpcClient.RandPost("gate", "/user/operate", nil, req, new(old.MsgUserQueryAck))
if err != nil {
this.logger.Error("Gate get cdkey error, ", err)
_ = msg.Reply(proto.RawErrInternalError)
return
}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] -> GateUserOperate, reply: %s", msg.R.RemoteAddr, util.ToJsonString(reply))
}
_ = msg.Reply(reply)
}
func (this *InnerHandler) GateCdkeyGet(msg *http.Message) {
var req = new(old.MsgCdkeyGetReq)
var err = msg.Read(req)
if err != nil {
this.logger.Error("Read message error, ", err)
_ = msg.Reply(proto.RawErrMessageError)
return
}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] <- GateCdkeyGet, req: %s", msg.R.RemoteAddr, util.ToJsonString(req))
}
var query = url.Values{}
query.Add("key", req.Key)
var ack = new(old.MsgCdkeyGetAck)
reply, err := this.httpRpcClient.RandGet("gate", "/cdkey/get", query, ack)
if err != nil {
this.logger.Error("Gate get cdkey error, ", err)
_ = msg.Reply(proto.RawErrInternalError)
return
}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] -> GateCdkeyGet, reply: %s", msg.R.RemoteAddr, util.ToJsonString(reply))
}
_ = msg.Reply(reply)
}
func (this *InnerHandler) GateCdkeyList(msg *http.Message) {
var req = new(old.MsgCdkeyListReq)
var err = msg.Read(req)
if err != nil {
this.logger.Error("Read message error, ", err)
_ = msg.Reply(proto.RawErrMessageError)
return
}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] <- GateCdkeyList, req: %s", msg.R.RemoteAddr, util.ToJsonString(req))
}
var query = url.Values{}
query.Add("pageNo", util.IntegerToString(req.PageNo))
query.Add("pageSize", util.IntegerToString(req.PageSize))
if req.Channel != 0 {
query.Add("channel", util.IntegerToString(req.Channel))
}
reply, err := this.httpRpcClient.RandGet("gate", "/cdkey/list", query, new(old.MsgCdkeyListAck))
if err != nil {
this.logger.Error("Gate get cdkey error, ", err)
_ = msg.Reply(proto.RawErrInternalError)
return
}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] -> GateCdkeyList, reply: %s", msg.R.RemoteAddr, util.ToJsonString(reply))
}
_ = msg.Reply(reply)
}
func (this *InnerHandler) GateCdkeyAdd(msg *http.Message) {
var req = new(old.MsgCdkeyAddReq)
var err = msg.Read(req)
if err != nil {
this.logger.Error("Read message error, ", err)
_ = msg.Reply(proto.RawErrMessageError)
return
}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] <- GateCdkeyAdd, req: %s", msg.R.RemoteAddr, util.ToJsonString(req))
}
reply, err := this.httpRpcClient.RandPost("gate", "/cdkey/add", nil, req, new(old.MsgCdkeyAddAck))
if err != nil {
this.logger.Error("Gate get cdkey error, ", err)
_ = msg.Reply(proto.RawErrInternalError)
return
}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] -> GateCdkeyAdd, reply: %s", msg.R.RemoteAddr, util.ToJsonString(reply))
}
_ = msg.Reply(reply)
}
func (this *InnerHandler) GateCdkeyGenerate(msg *http.Message) {
var req = new(old.MsgCdkeyGenerateReq)
var err = msg.Read(req)
if err != nil {
this.logger.Error("Read message error, ", err)
_ = msg.Reply(proto.RawErrMessageError)
return
}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] <- GateCdkeyAdd, req: %s", msg.R.RemoteAddr, util.ToJsonString(req))
}
reply, err := this.httpRpcClient.RandPost("gate", "/cdkey/generate", nil, req, new(old.MsgCdkeyGenerateAck))
if err != nil {
this.logger.Error("Gate get cdkey error, ", err)
_ = msg.Reply(proto.RawErrInternalError)
return
}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] -> GateCdkeyAdd, reply: %s", msg.R.RemoteAddr, util.ToJsonString(reply))
}
_ = msg.Reply(reply)
}
func (this *InnerHandler) GateCdkeyDelete(msg *http.Message) {
var req = new(old.MsgCdkeyDeleteReq)
var err = msg.Read(req)
if err != nil {
this.logger.Error("Read message error, ", err)
_ = msg.Reply(proto.RawErrMessageError)
return
}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] <- GateCdkeyAdd, req: %s", msg.R.RemoteAddr, util.ToJsonString(req))
}
reply, err := this.httpRpcClient.RandPost("gate", "/cdkey/delete", nil, req, nil)
if err != nil {
this.logger.Error("Gate get cdkey error, ", err)
_ = msg.Reply(proto.RawErrInternalError)
return
}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] -> GateCdkeyDelete, reply: %s", msg.R.RemoteAddr, util.ToJsonString(reply))
}
_ = msg.Reply(reply)
}
func (this *InnerHandler) GameDataReload(msg *http.Message) {
var serverReplies []*old.ServerReply
ar, err := this.httpRpcClient.AllPost("game_1", "/server/data/reload", nil, nil, nil)
if err != nil {
this.logger.Errorf("Http get error, error: %v", err)
_ = msg.Reply(proto.RawErrInternalError)
return
}
for appId, result := range ar {
if result.Err != nil {
this.logger.Errorf("Http post error, appId: %d, error: %v", appId, result.Err)
serverReplies = append(serverReplies, &old.ServerReply{AppId: appId, Status: -1, Message: result.Err.Error()})
} else {
if result.Res.Status != errors.StatusSuccessful {
this.logger.Errorf("Http post failed, appId: %d, message: %s", appId, result.Res.Message)
}
serverReplies = append(serverReplies, &old.ServerReply{AppId: appId, Status: 0, Message: result.Res.Message})
}
}
var ack = &old.MsgGameDataReloadAck{ServerReplies: serverReplies}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] -> GameDataReload, ack: %s", msg.R.RemoteAddr, util.ToJsonString(ack))
}
_ = msg.Reply(ack)
}
func (this *InnerHandler) GameMailList(msg *http.Message) {
var req = new(old.MsgGameMailListReq)
var err = msg.Read(req)
if err != nil {
this.logger.Error("Read message error, ", err)
_ = msg.Reply(proto.RawErrMessageError)
return
}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] <- GameMailList, req: %s", msg.R.RemoteAddr, util.ToJsonString(req))
}
var serverReplies []*old.ServerMailList
if req.AppId == 0 {
ar, err := this.httpRpcClient.AllGet("game_1", "/server/mail/list", nil, new(old.MsgRegionMailListAck))
if err != nil {
this.logger.Errorf("Http get error, error: %v", err)
_ = msg.Reply(proto.RawErrInternalError)
return
}
for appId, result := range ar {
if result.Err != nil {
this.logger.Errorf("Http get error, appId: %d, error: %v", appId, err)
serverReplies = append(serverReplies, &old.ServerMailList{ServerReply: old.ServerReply{AppId: appId, Status: -1, Message: result.Err.Error()}})
continue
}
if result.Res.Status != errors.StatusSuccessful {
this.logger.Errorf("Http get failed, appId: %d, message: %s", appId, result.Res.Message)
serverReplies = append(serverReplies, &old.ServerMailList{ServerReply: old.ServerReply{AppId: appId, Status: result.Res.Status, Message: result.Res.Message}})
continue
}
serverReplies = append(serverReplies, &old.ServerMailList{
ServerReply: old.ServerReply{AppId: appId, Status: 0, Message: result.Res.Message},
MailList: result.Res.Data.(*old.MsgRegionMailListAck).List,
})
}
} else {
reply, err := this.httpRpcClient.AppIdGet("game_1", req.AppId, "/server/mail/list", nil, new(old.MsgRegionMailListAck))
if err != nil {
this.logger.Errorf("Http get error, appId: %d, error: %v", req.AppId, err)
_ = msg.Reply(proto.RawErrInternalError)
return
} else {
if reply.Status != errors.StatusSuccessful {
this.logger.Errorf("Http get failed, appId: %d, message: %s", req.AppId, reply.Message)
serverReplies = append(serverReplies, &old.ServerMailList{ServerReply: old.ServerReply{AppId: req.AppId, Status: reply.Status, Message: reply.Message}})
} else {
serverReplies = append(serverReplies, &old.ServerMailList{
ServerReply: old.ServerReply{AppId: req.AppId, Status: 0, Message: reply.Message},
MailList: reply.Data.(*old.MsgRegionMailListAck).List,
})
}
}
}
var ack = &old.MsgGameMailListAck{ServerReplies: serverReplies}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] -> GameMailList, ack: %s", msg.R.RemoteAddr, util.ToJsonString(ack))
}
_ = msg.Reply(ack)
}
func (this *InnerHandler) GameMailSend(msg *http.Message) {
var req = new(old.MsgGameMailSendReq)
var err = msg.Read(req)
if err != nil {
this.logger.Error("Read message error, ", err)
_ = msg.Reply(err)
return
}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] <- GameMailSend, req: %s", msg.R.RemoteAddr, util.ToJsonString(req))
}
var serverReplies []*old.ServerReply
if len(req.PlayerIds) == 0 { //没有玩家ID发全服邮件
if len(req.AppIds) == 0 {
ar, err := this.httpRpcClient.AllPost("game_1", "/server/mail/send", nil, &old.MsgRegionMailSendReq{BackMail: req.BackMail}, new(old.MsgRegionMailSendAck))
if err != nil {
this.logger.Errorf("Http get error, error: %v", err)
_ = msg.Reply(proto.RawErrInternalError)
return
}
for appId, result := range ar {
if result.Err != nil {
this.logger.Errorf("Http post error, appId: %d, error: %v", appId, result.Err)
serverReplies = append(serverReplies, &old.ServerReply{AppId: appId, Status: -1, Message: result.Err.Error()})
} else {
if result.Res.Status != errors.StatusSuccessful {
this.logger.Errorf("Http post failed, appId: %d, message: %s", appId, result.Res.Message)
}
serverReplies = append(serverReplies, &old.ServerReply{AppId: appId, Status: 0, Message: result.Res.Message})
}
}
} else {
for _, appId := range req.AppIds {
reply, err := this.httpRpcClient.AppIdPost("game_1", appId, "/server/mail/send", nil, &old.MsgRegionMailSendReq{BackMail: req.BackMail}, nil)
if err != nil {
this.logger.Errorf("Http post error, appId: %d, error: %v", appId, err)
serverReplies = append(serverReplies, &old.ServerReply{AppId: appId, Status: -1, Message: err.Error()})
return
} else {
if reply.Status != errors.StatusSuccessful {
this.logger.Errorf("Http post failed, appId: %d, message: %s", appId, reply.Message)
}
serverReplies = append(serverReplies, &old.ServerReply{AppId: appId, Status: 0, Message: reply.Message})
}
}
}
} else { //发送玩家邮件
if len(req.AppIds) == 0 {
this.logger.Error("Parameter error, len(req.AppIds) == 0")
_ = msg.Reply(proto.RawErrParameterError)
return
}
var header = client.HttpHeader{}
for _, playerId := range req.PlayerIds {
header.Add("PlayerId", util.IntegerToString(playerId))
}
for _, appId := range req.AppIds {
reply, err := this.httpRpcClient.AppIdPost("game_1", appId, "/player/mail/send", nil, &old.MsgRegionMailSendReq{BackMail: req.BackMail}, nil, header)
if err != nil {
this.logger.Errorf("Http post error, appId: %d, error: %v", appId, err)
serverReplies = append(serverReplies, &old.ServerReply{AppId: appId, Status: -1, Message: err.Error()})
return
} else {
if reply.Status != errors.StatusSuccessful {
this.logger.Errorf("Http post failed, appId: %d, message: %s", appId, reply.Message)
}
serverReplies = append(serverReplies, &old.ServerReply{AppId: appId, Status: reply.Status, Message: reply.Message})
}
}
}
var ack = &old.MsgGameMailSendAck{ServerReplies: serverReplies}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] -> GameMailSend, ack: %s", msg.R.RemoteAddr, util.ToJsonString(ack))
}
_ = msg.Reply(ack)
}
func (this *InnerHandler) GameMailDelete(msg *http.Message) {
var req = new(old.MsgGameMailDeleteReq)
var err = msg.Read(req)
if err != nil {
this.logger.Error("Read message error, ", err)
_ = msg.Reply(err)
return
}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] <- GameMailDelete, req: %s", msg.R.RemoteAddr, util.ToJsonString(req))
}
var serverReplies []*old.ServerReply
for _, selectedIds := range req.SelectedLists {
reply, err := this.httpRpcClient.AppIdPost("game_1", selectedIds.AppId, "/server/mail/delete", nil, &old.MsgRegionMailDeleteReq{Ids: selectedIds.Ids}, nil)
if err != nil {
this.logger.Errorf("Http post error, appId: %d, error: %v", selectedIds.AppId, err)
serverReplies = append(serverReplies, &old.ServerReply{AppId: selectedIds.AppId, Status: -1, Message: err.Error()})
return
} else {
if reply.Status != errors.StatusSuccessful {
this.logger.Errorf("Http post failed, appId: %d, message: %s", selectedIds.AppId, reply.Message)
}
serverReplies = append(serverReplies, &old.ServerReply{AppId: selectedIds.AppId, Status: reply.Status, Message: reply.Message})
}
}
var ack = &old.MsgGameMailDeleteAck{ServerReplies: serverReplies}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] -> GameMailDelete, ack: %s", msg.R.RemoteAddr, util.ToJsonString(ack))
}
_ = msg.Reply(ack)
}
func (this *InnerHandler) GamePlayerQuery(msg *http.Message) {
var req = new(old.MsgGamePlayerQueryReq)
var err = msg.Read(req)
if err != nil {
this.logger.Error("Read message error, ", err)
_ = msg.Reply(proto.RawErrMessageError)
return
}
if this.logger.IsDebugEnabled() {
this.logger.Debug("[%s] <- ServerPlayerQuery, req: ", msg.R.RemoteAddr, util.ToJsonString(req))
}
if req.AppId == 0 || req.PlayerId == 0 {
this.logger.Error("Parameter error, req.AppId == 0 || req.PlayerId == 0")
_ = msg.Reply(proto.RawErrParameterError)
return
}
var query = url.Values{}
query.Add("playerId", util.IntegerToString(req.PlayerId))
reply, err := this.httpRpcClient.AppIdGet("game_1", req.AppId, "/server/player/query", query, new(old.MsgPlayerQueryAck))
if err != nil {
this.logger.Error("Game player query error, ", err)
_ = msg.Reply(proto.RawErrInternalError)
return
}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] -> ServerPlayerQuery, reply: %s", msg.R.RemoteAddr, util.ToJsonString(reply))
}
_ = msg.Reply(reply)
}
func (this *InnerHandler) GamePlayerOperate(msg *http.Message) {
var req = new(old.MsgGamePlayerOperateReq)
var err = msg.Read(req)
if err != nil {
this.logger.Error("Read message error, ", err)
_ = msg.Reply(proto.RawErrMessageError)
return
}
if this.logger.IsDebugEnabled() {
this.logger.Debug("[%s] <- GamePlayerOperate, req: ", msg.R.RemoteAddr, util.ToJsonString(req))
}
if req.AppId == 0 || req.PlayerId == 0 || (req.OperateType != 1 && req.OperateType != 2 && req.OperateType != 3) {
this.logger.Error("Parameter error, req.AppId == 0 || req.PlayerId == 0")
_ = msg.Reply(proto.RawErrParameterError)
return
}
reply, err := this.httpRpcClient.AppIdPost("game_1", req.AppId, "/server/player/operate", nil, &old.MsgPlayerOperateReq{PlayerId: req.PlayerId, OperateType: req.OperateType, OperateArg: req.OperateArg}, new(old.MsgPlayerOperateAck))
if err != nil {
this.logger.Error("Game player operate error, ", err)
_ = msg.Reply(proto.RawErrInternalError)
return
}
if this.logger.IsDebugEnabled() {
this.logger.Debugf("[%s] -> GamePlayerOperate, reply: %s", msg.R.RemoteAddr, util.ToJsonString(reply))
}
_ = msg.Reply(reply)
}