franklin/agent/server_router.go

package main

import (
	"git.wanbits.io/joe/franklin/mod"
	pb "git.wanbits.io/joe/franklin/protos"
	"git.wanbits.io/joe/kettle/log"
	"git.wanbits.io/joe/nnet"
	"github.com/go-redis/redis"
	"github.com/golang/protobuf/proto"
	"go.uber.org/zap"
	"time"
)

var (
	routes = map[string]fnCSHandler{
		"C_Heartbeat":  on_C_Heartbeat,
		"C_Login":      on_C_Login,
		"C_Logout":     on_C_Logout,
		"C_EnterGame":  on_C_EnterGame,
		"C_LeaveGame":  on_C_LeaveGame,
		"C_EnterRoom":  on_C_EnterRoom,
		"C_EnterTable": on_C_EnterTable,
		"C_LeaveRoom":  on_C_LeaveRoom,
		"C_LeaveTable": on_C_LeaveTable,
	}
)

type fnCSHandler func(nnet.ISession, *CSPacket)

func dispatch(ses nnet.ISession, pkt *CSPacket) {
	handler, ok := routes[pkt.MsgName]
	if !ok {
		// route to lobbies
		if pkt.MsgId <= 5000 {
			PostLobby(pkt.UserId, pkt)
			return
		}
		logicId, err:= mod.LoadUserLogic(pkt.UserId)
		if err != nil {
			if err != redis.Nil {
				log.Error("user logic", zap.Error(err))
			}
			return
		}
		PostLogic(logicId, pkt)
		return
	}
	handler(ses, pkt)
}

func on_C_Heartbeat(ses nnet.ISession, p *CSPacket) {
	resp := &pb.S_Heartbeat{
		Ts: time.Now().Unix(),
	}
	SendToClient(ses, ses.Id(), pb.ErrCode_OK, resp)
}

func on_C_Login(ses nnet.ISession, p *CSPacket) {
	prm := &pb.C_Login{}
	ses.SetId(p.UserId)
	err := proto.Unmarshal(p.Req, prm)
	if err != nil {
		response_c_login(ses, pb.ErrCode_BAD_FORMAT, nil)
		return
	}
	// verify by rabbit
	seq := time.Now().UnixNano()
	err = g_rabbitProto.Send(NewReqPacket("bl_login_verify", seq, &pb.VerifyParams{
		UserId:   p.UserId,
		Username: prm.Username,
		Token:    prm.Token,
	}), ses)
	if err != nil {
		response_c_login(ses, pb.ErrCode_FAILED, nil)
	}
}

func response_c_login(ses nnet.ISession, errCode pb.ErrCode, res *pb.S_Login) {
	var ec = pb.ErrCode_OK
	var reason = pb.NetCloseReason_KICK

	defer func() {
		p := []int32{}
		if ec != pb.ErrCode_OK {
			p = append(p, 1)
			p = append(p, int32(reason))
			res = &pb.S_Login{}
			//SendToClient(ses, ses.Id(), ec, &pb.S_Login{})
			//KillUserSession(ses, ses.Id(), pb.NetCloseReason_ERR_AUTH)
		}
		SendToClient(ses, ses.Id(), ec, res, p...)
	}()

	if errCode != pb.ErrCode_OK {
		ec = errCode
		reason = pb.NetCloseReason_ERR_AUTH
		return
	}
	// check agent offline
	if g_offline {
		ec = pb.ErrCode_MAINTAINING
		reason = pb.NetCloseReason_KICK
		return
	}
	// check user status
	// check user kicked off
	if mod.LoadKick(ses.Id()) {
		ec = pb.ErrCode_FORBIDDEN
		reason = pb.NetCloseReason_KICK
		return
	}
	//TODO: check if have logged in any agents already

	// check reconnect state
	logicId, err := mod.LoadOffline(ses.Id())
	if err == nil {
		// route to logic
		PostLogic(logicId, ses.Id(), &pb.Q_Online{UserId: ses.Id()})
	} else {
		if err != redis.Nil {
			log.Error("", zap.Error(err))
		}
		// route to a lobby
		PostLobby(ses.Id(), &pb.Q_Online{UserId: ses.Id()})
	}
	// update user location
	err = mod.SaveUserLogin(ses.Id(), g_conf.Id)
	if err != nil {
		log.Error("", zap.Error(err))
	}
	// update session id
	ses.UpdateId(ses.Id())
}

func on_C_Logout(ses nnet.ISession, p *CSPacket) {
	//
	if err := mod.SaveUserLogout(ses.Id()); err != nil {
		log.Error("logout", zap.Error(err))
	}
}

func on_C_EnterGame(ses nnet.ISession, p *CSPacket) {

}

func on_C_LeaveGame(ses nnet.ISession, p *CSPacket) {

}

func on_C_EnterRoom(ses nnet.ISession, p *CSPacket) {

}

func on_C_EnterTable(ses nnet.ISession, p *CSPacket) {

}

func on_C_LeaveRoom(ses nnet.ISession, p *CSPacket) {

}

func on_C_LeaveTable(ses nnet.ISession, p *CSPacket) {

}