holy refactor

started out as me making a service abstraction..

- db.Player exists again, and entity.Player uses it as an embedded struct
- chunk.ForEachEntity() lets you add/remove entities during iteration now
- removed account related fields from CNPeer
- protocol/pool has been merged with protocol.
use protocol.GetBuffer() and protocol.PutBuffer().
- new protocol/internal/service!
service.Service is an abstraction layer to handle multiple CNPeer*
connections and allows you to associate each with an interface{} uData.
In the future it might also handle a task queue for jobs that
modify/interact with the player's uData, called from service.handleEvents()
- PacketHandler callback type has a new param! uData is passed as well now
- much of loginserver/shardserver is now handled by the shared service
abstraction
- SHARD: NPC_ENTER packets are now sent on player loading complete
rather than on enter.

login/login.go

@@ -25,8 +25,6 @@ const (
 )
 
 func (server *LoginServer) AcceptLogin(peer *protocol.CNPeer, SzID string, IClientVerC int32, ISlotNum int8, data []protocol.SP_LS2CL_REP_CHAR_INFO) error {
-	peer.SzID = SzID
-
 	resp := protocol.SP_LS2CL_REP_LOGIN_SUCC{
 		SzID:          SzID,
 		ICharCount:    int8(len(data)),
@@ -62,7 +60,7 @@ func (server *LoginServer) AcceptLogin(peer *protocol.CNPeer, SzID string, IClie
 	return nil
 }
 
-func (server *LoginServer) Login(peer *protocol.CNPeer, pkt protocol.Packet) error {
+func (server *LoginServer) Login(peer *protocol.CNPeer, _account interface{}, pkt protocol.Packet) error {
 	var loginPkt protocol.SP_CL2LS_REQ_LOGIN
 	pkt.Decode(&loginPkt)
 
@@ -74,9 +72,9 @@ func (server *LoginServer) Login(peer *protocol.CNPeer, pkt protocol.Packet) err
 	}
 
 	// client is resending a login packet??
-	if peer.AccountID != -1 {
+	if _account != nil {
 		SendError(LOGIN_ERROR)
-		return fmt.Errorf("out of order P_CL2LS_REQ_LOGIN")
+		return fmt.Errorf("out of order P_CL2LS_REQ_LOGIN: %v", _account)
 	}
 
 	// attempt login
@@ -99,7 +97,7 @@ func (server *LoginServer) Login(peer *protocol.CNPeer, pkt protocol.Packet) err
 	}
 
 	// grab player data
-	peer.AccountID = account.AccountID
+	server.service.SetPeerData(peer, account)
 	plrs, err := server.dbHndlr.GetPlayers(account.AccountID)
 	if err != nil {
 		SendError(LOGIN_DATABASE_ERROR)
@@ -138,7 +136,7 @@ func (server *LoginServer) Login(peer *protocol.CNPeer, pkt protocol.Packet) err
 	return server.AcceptLogin(peer, loginPkt.SzID, loginPkt.IClientVerC, 1, charInfo[:len(plrs)])
 }
 
-func (server *LoginServer) CheckCharacterName(peer *protocol.CNPeer, pkt protocol.Packet) error {
+func (server *LoginServer) CheckCharacterName(peer *protocol.CNPeer, account interface{}, pkt protocol.Packet) error {
 	var charPkt protocol.SP_CL2LS_REQ_CHECK_CHAR_NAME
 	pkt.Decode(&charPkt)
 
@@ -149,17 +147,17 @@ func (server *LoginServer) CheckCharacterName(peer *protocol.CNPeer, pkt protoco
 	})
 }
 
-func (server *LoginServer) SaveCharacterName(peer *protocol.CNPeer, pkt protocol.Packet) error {
+func (server *LoginServer) SaveCharacterName(peer *protocol.CNPeer, account interface{}, pkt protocol.Packet) error {
 	var charPkt protocol.SP_CL2LS_REQ_SAVE_CHAR_NAME
 	pkt.Decode(&charPkt)
 
-	if peer.AccountID == -1 {
+	if account == nil {
 		peer.Send(protocol.P_LS2CL_REP_SAVE_CHAR_NAME_FAIL, protocol.SP_LS2CL_REP_SAVE_CHAR_NAME_FAIL{})
 		return fmt.Errorf("out of order P_LS2CL_REP_SAVE_CHAR_NAME_FAIL")
 	}
 
 	// TODO: sanity check SzFirstName && SzLastName
-	PlayerID, err := server.dbHndlr.NewPlayer(peer.AccountID, charPkt.SzFirstName, charPkt.SzLastName, int(charPkt.ISlotNum))
+	PlayerID, err := server.dbHndlr.NewPlayer(account.(*db.Account).AccountID, charPkt.SzFirstName, charPkt.SzLastName, int(charPkt.ISlotNum))
 	if err != nil {
 		peer.Send(protocol.P_LS2CL_REP_SAVE_CHAR_NAME_FAIL, protocol.SP_LS2CL_REP_SAVE_CHAR_NAME_FAIL{})
 		return err
@@ -211,16 +209,20 @@ func SendFail(peer *protocol.CNPeer) error {
 	return nil
 }
 
-func (server *LoginServer) CharacterCreate(peer *protocol.CNPeer, pkt protocol.Packet) error {
+func (server *LoginServer) CharacterCreate(peer *protocol.CNPeer, account interface{}, pkt protocol.Packet) error {
 	var charPkt protocol.SP_CL2LS_REQ_CHAR_CREATE
 	pkt.Decode(&charPkt)
 
+	if account == nil {
+		return SendFail(peer)
+	}
+
 	if !validateCharacterCreation(&charPkt) {
 		log.Printf("Invalid character creation packet: %+v", charPkt)
 		return SendFail(peer)
 	}
 
-	if err := server.dbHndlr.FinishPlayer(&charPkt, peer.AccountID); err != nil {
+	if err := server.dbHndlr.FinishPlayer(&charPkt, account.(*db.Account).AccountID); err != nil {
 		log.Printf("Error finishing player: %v", err)
 		return SendFail(peer)
 	}
@@ -239,11 +241,15 @@ func (server *LoginServer) CharacterCreate(peer *protocol.CNPeer, pkt protocol.P
 	})
 }
 
-func (server *LoginServer) CharacterDelete(peer *protocol.CNPeer, pkt protocol.Packet) error {
+func (server *LoginServer) CharacterDelete(peer *protocol.CNPeer, account interface{}, pkt protocol.Packet) error {
 	var charPkt protocol.SP_CL2LS_REQ_CHAR_DELETE
 	pkt.Decode(&charPkt)
 
-	slot, err := server.dbHndlr.DeletePlayer(int(charPkt.IPC_UID), peer.AccountID)
+	if account == nil {
+		return SendFail(peer)
+	}
+
+	slot, err := server.dbHndlr.DeletePlayer(int(charPkt.IPC_UID), account.(*db.Account).AccountID)
 	if err != nil {
 		return SendFail(peer)
 	}
@@ -253,10 +259,14 @@ func (server *LoginServer) CharacterDelete(peer *protocol.CNPeer, pkt protocol.P
 	})
 }
 
-func (server *LoginServer) ShardSelect(peer *protocol.CNPeer, pkt protocol.Packet) error {
+func (server *LoginServer) ShardSelect(peer *protocol.CNPeer, account interface{}, pkt protocol.Packet) error {
 	var selection protocol.SP_CL2LS_REQ_CHAR_SELECT
 	pkt.Decode(&selection)
 
+	if account == nil {
+		return SendFail(peer)
+	}
+
 	shards := server.redisHndlr.GetShards()
 	if len(shards) == 0 {
 		SendFail(peer)
@@ -278,9 +288,10 @@ func (server *LoginServer) ShardSelect(peer *protocol.CNPeer, pkt protocol.Packe
 		log.Printf("Error getting player: %v", err)
 		return SendFail(peer)
 	}
+	accountID := account.(*db.Account).AccountID
 
-	if plr.AccountID != peer.AccountID {
-		log.Printf("HACK: player %d tried to join shard as player %d", peer.AccountID, plr.AccountID)
+	if plr.AccountID != accountID {
+		log.Printf("HACK: player %d tried to join shard as player %d", accountID, plr.AccountID)
 		return SendFail(peer)
 	}
 
@@ -288,7 +299,7 @@ func (server *LoginServer) ShardSelect(peer *protocol.CNPeer, pkt protocol.Packe
 	server.redisHndlr.QueueLogin(key, redis.LoginMetadata{
 		FEKey:     peer.FE_key,
 		PlayerID:  int32(selection.IPC_UID),
-		AccountID: peer.AccountID,
+		AccountID: accountID,
 	})
 
 	// craft response
@@ -303,11 +314,15 @@ func (server *LoginServer) ShardSelect(peer *protocol.CNPeer, pkt protocol.Packe
 	return peer.Send(protocol.P_LS2CL_REP_SHARD_SELECT_SUCC, resp)
 }
 
-func (server *LoginServer) FinishTutorial(peer *protocol.CNPeer, pkt protocol.Packet) error {
+func (server *LoginServer) FinishTutorial(peer *protocol.CNPeer, account interface{}, pkt protocol.Packet) error {
 	var charPkt protocol.SP_CL2LS_REQ_SAVE_CHAR_TUTOR
 	pkt.Decode(&charPkt)
 
-	if err := server.dbHndlr.FinishTutorial(int(charPkt.IPC_UID), peer.AccountID); err != nil {
+	if account == nil {
+		return SendFail(peer)
+	}
+
+	if err := server.dbHndlr.FinishTutorial(int(charPkt.IPC_UID), account.(*db.Account).AccountID); err != nil {
 		return SendFail(peer)
 	}
 

login/loginserver.go

@@ -1,126 +1,52 @@
 package login
 
 import (
-	"fmt"
-	"log"
-	"net"
-	"sync"
-
-	"github.com/CPunch/gopenfusion/config"
 	"github.com/CPunch/gopenfusion/internal/db"
 	"github.com/CPunch/gopenfusion/internal/protocol"
-	"github.com/CPunch/gopenfusion/internal/protocol/pool"
 	"github.com/CPunch/gopenfusion/internal/redis"
+	"github.com/CPunch/gopenfusion/internal/service"
 )
 
-type PacketHandler func(peer *protocol.CNPeer, pkt protocol.Packet) error
-
-func stubbedPacket(_ *protocol.CNPeer, _ protocol.Packet) error { /* stubbed */ return nil }
-
 type LoginServer struct {
-	listener       net.Listener
-	port           int
-	dbHndlr        *db.DBHandler
-	redisHndlr     *redis.RedisHandler
-	eRecv          chan *protocol.Event
-	peers          map[*protocol.CNPeer]bool
-	packetHandlers map[uint32]PacketHandler
-	peerLock       sync.Mutex
+	service    *service.Service
+	dbHndlr    *db.DBHandler
+	redisHndlr *redis.RedisHandler
 }
 
 func NewLoginServer(dbHndlr *db.DBHandler, redisHndlr *redis.RedisHandler, port int) (*LoginServer, error) {
-	listener, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
+	srvc, err := service.NewService("LOGIN", port)
 	if err != nil {
 		return nil, err
 	}
 
 	server := &LoginServer{
-		listener:   listener,
-		port:       port,
+		service:    srvc,
 		dbHndlr:    dbHndlr,
 		redisHndlr: redisHndlr,
-		peers:      make(map[*protocol.CNPeer]bool),
-		eRecv:      make(chan *protocol.Event),
 	}
 
-	server.packetHandlers = map[uint32]PacketHandler{
-		protocol.P_CL2LS_REQ_LOGIN:             server.Login,
-		protocol.P_CL2LS_REQ_CHECK_CHAR_NAME:   server.CheckCharacterName,
-		protocol.P_CL2LS_REQ_SAVE_CHAR_NAME:    server.SaveCharacterName,
-		protocol.P_CL2LS_REQ_CHAR_CREATE:       server.CharacterCreate,
-		protocol.P_CL2LS_REQ_CHAR_SELECT:       server.ShardSelect,
-		protocol.P_CL2LS_REQ_CHAR_DELETE:       server.CharacterDelete,
-		protocol.P_CL2LS_REQ_SHARD_SELECT:      stubbedPacket,
-		protocol.P_CL2LS_REQ_SHARD_LIST_INFO:   stubbedPacket,
-		protocol.P_CL2LS_CHECK_NAME_LIST:       stubbedPacket,
-		protocol.P_CL2LS_REQ_SAVE_CHAR_TUTOR:   server.FinishTutorial,
-		protocol.P_CL2LS_REQ_PC_EXIT_DUPLICATE: stubbedPacket,
-		protocol.P_CL2LS_REP_LIVE_CHECK:        stubbedPacket,
-		protocol.P_CL2LS_REQ_CHANGE_CHAR_NAME:  stubbedPacket,
-		protocol.P_CL2LS_REQ_SERVER_SELECT:     stubbedPacket,
+	srvc.AddPacketHandler(protocol.P_CL2LS_REQ_LOGIN, server.Login)
+	srvc.AddPacketHandler(protocol.P_CL2LS_REQ_CHECK_CHAR_NAME, server.CheckCharacterName)
+	srvc.AddPacketHandler(protocol.P_CL2LS_REQ_SAVE_CHAR_NAME, server.SaveCharacterName)
+	srvc.AddPacketHandler(protocol.P_CL2LS_REQ_CHAR_CREATE, server.CharacterCreate)
+	srvc.AddPacketHandler(protocol.P_CL2LS_REQ_CHAR_SELECT, server.ShardSelect)
+	srvc.AddPacketHandler(protocol.P_CL2LS_REQ_CHAR_DELETE, server.CharacterDelete)
+	srvc.AddPacketHandler(protocol.P_CL2LS_REQ_SHARD_SELECT, service.StubbedPacket)
+	srvc.AddPacketHandler(protocol.P_CL2LS_REQ_SHARD_LIST_INFO, service.StubbedPacket)
+	srvc.AddPacketHandler(protocol.P_CL2LS_CHECK_NAME_LIST, service.StubbedPacket)
+	srvc.AddPacketHandler(protocol.P_CL2LS_REQ_SAVE_CHAR_TUTOR, server.FinishTutorial)
+	srvc.AddPacketHandler(protocol.P_CL2LS_REQ_PC_EXIT_DUPLICATE, service.StubbedPacket)
+	srvc.AddPacketHandler(protocol.P_CL2LS_REP_LIVE_CHECK, service.StubbedPacket)
+	srvc.AddPacketHandler(protocol.P_CL2LS_REQ_CHANGE_CHAR_NAME, service.StubbedPacket)
+	srvc.AddPacketHandler(protocol.P_CL2LS_REQ_SERVER_SELECT, service.StubbedPacket)
+
+	srvc.OnConnect = func(peer *protocol.CNPeer) interface{} {
+		return nil
 	}
 
 	return server, nil
 }
 
 func (server *LoginServer) Start() {
-	log.Printf("Login service hosted on %s:%d\n", config.GetAnnounceIP(), server.port)
-
-	go server.handleEvents()
-	for {
-		conn, err := server.listener.Accept()
-		if err != nil {
-			log.Println("Connection error: ", err)
-			return
-		}
-
-		client := protocol.NewCNPeer(server.eRecv, conn)
-		server.connect(client)
-		go client.Handler()
-	}
-}
-
-func (server *LoginServer) handleEvents() {
-	for event := range server.eRecv {
-		switch event.Type {
-		case protocol.EVENT_CLIENT_DISCONNECT:
-			server.disconnect(event.Peer)
-		case protocol.EVENT_CLIENT_PACKET:
-			if err := server.handlePacket(event.Peer, event.PktID, protocol.NewPacket(event.Pkt)); err != nil {
-				log.Printf("Error handling packet: %v", err)
-				event.Peer.Kill()
-			}
-
-			// the packet is given to us by the event, so we'll need to make sure to return it to the pool
-			pool.Put(event.Pkt)
-		}
-	}
-}
-
-func (server *LoginServer) handlePacket(peer *protocol.CNPeer, typeID uint32, pkt protocol.Packet) error {
-	if hndlr, ok := server.packetHandlers[typeID]; ok {
-		if err := hndlr(peer, pkt); err != nil {
-			return err
-		}
-	} else {
-		log.Printf("[WARN] unknown packet ID: %x\n", typeID)
-	}
-
-	return nil
-}
-
-func (server *LoginServer) disconnect(peer *protocol.CNPeer) {
-	server.peerLock.Lock()
-	defer server.peerLock.Unlock()
-
-	log.Printf("Peer %p disconnected from LOGIN\n", peer)
-	delete(server.peers, peer)
-}
-
-func (server *LoginServer) connect(peer *protocol.CNPeer) {
-	server.peerLock.Lock()
-	defer server.peerLock.Unlock()
-
-	log.Printf("New peer %p connected to LOGIN\n", peer)
-	server.peers[peer] = true
+	server.service.Start()
 }