falloutBot/go-mc
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

adjust PlayerList and KeepAlive in go-mc/server

Browse Source
This commit is contained in:
Tnze
2022-06-21 01:12:55 +08:00
parent d94993f34f
commit 59caded2ef
6 changed files with 70 additions and 263 deletions
Download Patch File Download Diff File Expand all files Collapse all files

107
server/keepalive.go
View File

@ -4,10 +4,8 @@ import (
"container/list"
"context"
"errors"
"github.com/Tnze/go-mc/chat"
"time"
"github.com/Tnze/go-mc/data/packetid"
pk "github.com/Tnze/go-mc/net/packet"
)
// keepAliveInterval represents the interval when the server sends keep alive
@ -16,59 +14,49 @@ const keepAliveInterval = time.Second * 15
// keepAliveWaitInterval represents how long does the player expired
const keepAliveWaitInterval = time.Second * 30
type ClientDelay struct {
Delay time.Duration
type KeepAliveClient interface {
SendKeepAlive(id int64)
SendDisconnect(reason chat.Message)
}
type KeepAlive struct {
join chan *Client
quit chan *Client
tick chan *Client
join chan KeepAliveClient
quit chan KeepAliveClient
tick chan KeepAliveClient
pingList *list.List
waitList *list.List
listIndex map[*Client]*list.Element
listIndex map[KeepAliveClient]*list.Element
listTimer *time.Timer
waitTimer *time.Timer
// The Notchian server uses a system-dependent time in milliseconds to generate the keep alive ID value.
// We don't do that here for security reason.
keepAliveID int64
updatePlayerDelay []func(p *Client, delay time.Duration)
updatePlayerDelay []func(p KeepAliveClient, delay time.Duration)
}
func NewKeepAlive() (k *KeepAlive) {
func NewKeepAlive[C KeepAliveClient]() (k *KeepAlive) {
return &KeepAlive{
join: make(chan *Client),
quit: make(chan *Client),
tick: make(chan *Client),
join: make(chan KeepAliveClient),
quit: make(chan KeepAliveClient),
tick: make(chan KeepAliveClient),
pingList: list.New(),
waitList: list.New(),
listIndex: make(map[*Client]*list.Element),
listIndex: make(map[KeepAliveClient]*list.Element),
listTimer: time.NewTimer(keepAliveInterval),
waitTimer: time.NewTimer(keepAliveWaitInterval),
keepAliveID: 0,
}
}
func (k *KeepAlive) AddPlayerDelayUpdateHandler(f func(p *Client, delay time.Duration)) {
func (k *KeepAlive) AddPlayerDelayUpdateHandler(f func(c KeepAliveClient, delay time.Duration)) {
k.updatePlayerDelay = append(k.updatePlayerDelay, f)
}
// Init implement Component for KeepAlive
func (k *KeepAlive) Init(g *Game) {
g.AddHandler(&PacketHandler{
ID: packetid.ServerboundKeepAlive,
F: func(client *Client, player *Player, packet Packet758) error {
var KeepAliveID pk.Long
if err := pk.Packet(packet).Scan(&KeepAliveID); err != nil {
return err
}
k.tick <- client
return nil
},
})
}
func (k *KeepAlive) ClientJoin(client KeepAliveClient) { k.join <- client }
func (k *KeepAlive) ClientTick(client KeepAliveClient) { k.tick <- client }
func (k *KeepAlive) ClientLeft(client KeepAliveClient) { k.quit <- client }
// Run implement Component for KeepAlive
func (k *KeepAlive) Run(ctx context.Context) {
@ -76,35 +64,29 @@ func (k *KeepAlive) Run(ctx context.Context) {
select {
case <-ctx.Done():
return
case p := <-k.join:
k.pushPlayer(p)
case p := <-k.quit:
k.removePlayer(p)
case c := <-k.join:
k.pushPlayer(c)
case c := <-k.quit:
k.removePlayer(c)
case now := <-k.listTimer.C:
k.pingPlayer(now)
case <-k.waitTimer.C:
k.kickPlayer()
case p := <-k.tick:
k.tickPlayer(p)
case c := <-k.tick:
k.tickPlayer(c)
}
}
}
// ClientJoin implement Component for KeepAlive
func (k *KeepAlive) ClientJoin(client *Client, _ *Player) { k.join <- client }
// ClientLeft implement Component for KeepAlive
func (k *KeepAlive) ClientLeft(client *Client, _ *Player, _ error) { k.quit <- client }
func (k KeepAlive) pushPlayer(p *Client) {
k.listIndex[p] = k.pingList.PushBack(
keepAliveItem{player: p, t: time.Now()},
func (k KeepAlive) pushPlayer(c KeepAliveClient) {
k.listIndex[c] = k.pingList.PushBack(
keepAliveItem{player: c, t: time.Now()},
)
}
func (k *KeepAlive) removePlayer(p *Client) {
elem := k.listIndex[p]
delete(k.listIndex, p)
func (k *KeepAlive) removePlayer(c KeepAliveClient) {
elem := k.listIndex[c]
delete(k.listIndex, c)
if elem.Prev() == nil {
// At present, it is difficult to distinguish
// which linked list the player is in,
@ -118,26 +100,23 @@ func (k *KeepAlive) removePlayer(p *Client) {
func (k *KeepAlive) pingPlayer(now time.Time) {
if elem := k.pingList.Front(); elem != nil {
p := k.pingList.Remove(elem).(keepAliveItem).player
c := k.pingList.Remove(elem).(keepAliveItem).player
// Send Clientbound KeepAlive packet.
p.WritePacket(Packet758(pk.Marshal(
packetid.ClientboundKeepAlive,
pk.Long(k.keepAliveID),
)))
c.SendKeepAlive(k.keepAliveID)
k.keepAliveID++
// Clientbound KeepAlive packet is sent, move the player to waiting list.
k.listIndex[p] = k.waitList.PushBack(
keepAliveItem{player: p, t: now},
k.listIndex[c] = k.waitList.PushBack(
keepAliveItem{player: c, t: now},
)
}
// Wait for next earliest player
keepAliveSetTimer(k.pingList, k.listTimer, keepAliveInterval)
}
func (k *KeepAlive) tickPlayer(p *Client) {
elem, ok := k.listIndex[p]
func (k *KeepAlive) tickPlayer(c KeepAliveClient) {
elem, ok := k.listIndex[c]
if !ok {
p.PutErr(errors.New("keepalive: fail to tick player: client not found"))
panic(errors.New("keepalive: fail to tick player: client not found"))
return
}
if elem.Prev() == nil {
@ -150,19 +129,19 @@ func (k *KeepAlive) tickPlayer(p *Client) {
now := time.Now()
delay := now.Sub(k.waitList.Remove(elem).(keepAliveItem).t)
for _, f := range k.updatePlayerDelay {
f(p, delay)
f(c, delay)
}
// move the player to ping list
k.listIndex[p] = k.pingList.PushBack(
keepAliveItem{player: p, t: now},
k.listIndex[c] = k.pingList.PushBack(
keepAliveItem{player: c, t: now},
)
}
func (k *KeepAlive) kickPlayer() {
if elem := k.waitList.Front(); elem != nil {
player := k.waitList.Remove(elem).(keepAliveItem).player
c := k.waitList.Remove(elem).(keepAliveItem).player
k.waitList.Remove(elem)
player.PutErr(errors.New("keepalive: client did not response"))
c.SendDisconnect(chat.TranslateMsg("disconnect.timeout"))
}
keepAliveSetTimer(k.waitList, k.waitTimer, keepAliveWaitInterval)
}
@ -180,6 +159,6 @@ func keepAliveSetTimer(l *list.List, timer *time.Timer, interval time.Duration)
}
type keepAliveItem struct {
player *Client
player KeepAliveClient
t time.Time
}