anygatecloud/strom
2
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor server modules into main package and improve error handling

Browse Source
This commit is contained in:
adman
2026-02-24 23:27:56 +01:00
parent 85529b965b
commit bd83b9689e
18 changed files with 137 additions and 508 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/server.go
+7 -3
View File
@@ -6,7 +6,6 @@ import (
"github.com/admin-else/strom/proto"
"github.com/admin-else/strom/proto_base"
"github.com/admin-else/strom/server/server_modules"
"github.com/admin-else/strom/text"
)
@@ -43,7 +42,12 @@ func StartServerWithFactory(listenAddr string, factory func(c *proto.Conn) (h an
if err != nil {
return
}
go ServeClient(cNet, factory)
go func() {
err := ServeClient(cNet, factory)
if err != nil {
slog.Error("error while serving client", "error", err, "client", cNet.RemoteAddr())
}
}()
}
}
@@ -67,7 +71,7 @@ func StartServerWithOnConn(listenAddr string, onConn func(c *proto.Conn) (err er
return // we dont care about status packets
}
slog.Error("Error while handling client", "error", connErr, "client", c.Conn.RemoteAddr())
connErr = server_modules.Kick(c, text.Pretty(connErr.Error()))
connErr = Kick(c, text.Pretty(connErr.Error()))
if connErr != nil {
slog.Error("Error while kicking client", "error", connErr, "client", c.Conn.RemoteAddr())
}
server/server_modules/kicker.go
-39
View File
@@ -1,39 +0,0 @@
package server_modules
import (
"errors"
"github.com/admin-else/strom/nbt"
"github.com/admin-else/strom/proto"
"github.com/admin-else/strom/proto_base"
"github.com/admin-else/strom/proto_generated/v1_21_8"
"github.com/admin-else/strom/text"
)
var (
NotClientErr = errors.New("not a servee")
CantKickInStateErr = errors.New("cant kick in this state")
)
func Kick(c *proto.Conn, reason *text.Component) (err error) {
if c.Actor != proto_base.Servee {
err = NotClientErr
return
}
switch c.State() {
case proto_base.Handshaking, proto_base.Status:
err = CantKickInStateErr
case proto_base.Login:
var b []byte
b, err = reason.MarshalJSON()
if err != nil {
return
}
err = c.Send(&v1_21_8.LoginToClientPacketDisconnect{Reason: string(b)})
case proto_base.Configuration:
err = c.Send(&v1_21_8.ConfigurationToClientPacketDisconnect{Reason: nbt.Anon{Value: reason.ToNBT()}})
case proto_base.Play:
err = c.Send(&v1_21_8.PlayToClientPacketKickDisconnect{Reason: nbt.Anon{Value: reason.ToNBT()}})
}
return
}
server/server_modules/login_server.go
-181
View File
@@ -1,181 +0,0 @@
package server_modules
import (
"encoding/json"
"errors"
"fmt"
"log/slog"
"slices"
"github.com/admin-else/strom/api"
"github.com/admin-else/strom/event"
"github.com/admin-else/strom/proto"
"github.com/admin-else/strom/proto_base"
"github.com/admin-else/strom/proto_generated/v1_21_8"
"github.com/google/uuid"
)
var StatusServedError = errors.New("status served")
var UnexpectedStatusRequest = UnexpectedNextStateError{proto_base.Status}
type NameAndUUID struct {
Name string
UUID uuid.UUID
}
type UnexpectedNextStateError struct {
NextState proto_base.State
}
func (u UnexpectedNextStateError) Error() string {
return fmt.Sprintf("unexpected next state: %v", u.NextState)
}
type LoginServer struct {
*proto.Conn
//OnlineMode bool FIXME: implement this
ServerHost string
ServerPort uint16
Requested NameAndUUID
Given *NameAndUUID
CompressionThreshold int32
Status []byte
CompatibleVersions []int32
}
func (l *LoginServer) OnHandshake(packet *v1_21_8.HandshakingToServerPacketSetProtocol) (err error) {
l.SetState(proto_base.State(packet.NextState))
l.ServerHost = packet.ServerHost
l.ServerPort = packet.ServerPort
if packet.NextState != int32(proto_base.Login) && !(l.Status != nil && packet.NextState == int32(proto_base.Status)) {
err = UnexpectedNextStateError{proto_base.State(packet.NextState)}
}
if len(l.CompatibleVersions) != 0 {
if !slices.Contains(l.CompatibleVersions, packet.ProtocolVersion) {
err = fmt.Errorf("incompatible protocol version please use one of %v you can look up the real coresponding version at https://minecraft.wiki/w/Minecraft_Wiki:Projects/wiki.vg_merge/Protocol_version_numbers", l.CompatibleVersions)
return
}
}
return
}
func (l *LoginServer) OnStatusRequest(_ *v1_21_8.StatusToServerPacketPingStart) (err error) {
err = l.Send(&v1_21_8.StatusToClientPacketServerInfo{Response: string(l.Status)})
return
}
func (l *LoginServer) OnStatusPing(packet *v1_21_8.StatusToServerPacketPing) (err error) {
err = l.Send(&v1_21_8.StatusToClientPacketPing{Time: packet.Time})
if err != nil {
return
}
return event.HandlerDoneErr{Return: StatusServedError}
}
func (l *LoginServer) SetCompressionThreshold(threshold int32) (err error) {
err = l.Send(&v1_21_8.LoginToClientPacketCompress{Threshold: threshold})
if err != nil {
return
}
l.CompressionThreshold = threshold
return
}
func (l *LoginServer) OnLoginStart(packet *v1_21_8.LoginToServerPacketLoginStart) (err error) {
l.Requested = NameAndUUID{packet.Username, packet.PlayerUUID}
//err = l.SetCompressionThreshold(l.CompressionThreshold)
//if err != nil {
// return
//}
if l.Given == nil {
l.Given = &l.Requested
}
err = l.Send(&v1_21_8.LoginToClientPacketSuccess{
Uuid: l.Given.UUID,
Username: l.Given.Name,
Properties: nil,
})
return
}
func (l *LoginServer) OnLoginAcknowledged(_ *v1_21_8.LoginToServerPacketLoginAcknowledged) (err error) {
l.SetState(proto_base.Configuration)
err = event.HandlerDoneErr{}
return
}
func (l *LoginServer) OnDefault(event event.Unhandled) (err error) {
err = fmt.Errorf("unexpected event during login: %#v", event)
fmt.Println(err)
return
}
func (l *LoginServer) OnStart(_ event.OnStart) (err error) {
return
}
func (l *LoginServer) OnCycle(_ event.Tick) (err error) {
return
}
type LoginServerSetting func(*LoginServer)
func WithOtherAccount(a *api.Account) LoginServerSetting {
return func(s *LoginServer) {
if s.Given == nil {
return
}
s.Given = &NameAndUUID{
Name: a.Name,
UUID: a.Uuid,
}
}
}
func WithRawStatus(status []byte) LoginServerSetting {
return func(s *LoginServer) {
s.Status = status
}
}
func WithStatus(response StatusResponse) LoginServerSetting {
var status []byte
status, err := json.Marshal(response)
if err != nil {
panic(err)
}
slog.Debug("With status", "status", status)
return WithRawStatus(status)
}
func WithCompatibleVersion(versions int32) LoginServerSetting {
return WithCompatibleVersions([]int32{versions})
}
func WithCompatibleVersionsRange(start, end int32) LoginServerSetting {
var versions []int32
for i := start; i <= end; i++ {
versions = append(versions, i)
}
return WithCompatibleVersions(versions)
}
func WithCompatibleVersions(versions []int32) LoginServerSetting {
return func(s *LoginServer) {
s.CompatibleVersions = versions
}
}
func ServeLogin(c *proto.Conn, settings ...LoginServerSetting) (ret *LoginServer, err error) {
ret = &LoginServer{Conn: c}
for _, s := range settings {
s(ret)
}
ret.CompressionThreshold = 256
err = ret.Start(ret)
return
}
server/server_modules/status.go
-58
View File
@@ -1,58 +0,0 @@
package server_modules
import (
"encoding/json"
"github.com/admin-else/strom/proto"
"github.com/admin-else/strom/proto_generated/v1_21_8"
"github.com/admin-else/strom/text"
)
// StatusResponse here is the structure I used: https://minecraft.wiki/w/Java_Edition_protocol/Server_List_Ping#Status_Response
type StatusResponse struct {
Version struct {
Name *text.Component `json:"name"`
Protocol int `json:"protocol"`
} `json:"version"`
Players struct {
Max int `json:"max"`
Online int `json:"online"`
Sample []struct {
Name *text.Component `json:"name"`
ID string `json:"id"`
} `json:"sample"`
} `json:"players"`
Description *text.Component `json:"description"`
Favicon string `json:"favicon"`
EnforcesSecureChat bool `json:"enforcesSecureChat"`
}
type StatusServer struct {
*proto.Conn
Status string
}
func (p *StatusServer) Default(_ any) (err error) {
return
}
func (p *StatusServer) OnStatusRequest(_ *v1_21_8.StatusToServerPacketPingStart) (err error) {
return p.Send(&v1_21_8.StatusToClientPacketServerInfo{Response: p.Status})
}
func (p *StatusServer) OnStatusPing(packet *v1_21_8.StatusToServerPacketPing) (err error) {
return p.Send(&v1_21_8.StatusToClientPacketPing{Time: packet.Time})
}
func ServeStatus(c *proto.Conn, s StatusResponse) (err error) {
status, err := json.Marshal(s)
if err != nil {
return
}
server := &StatusServer{
Conn: c,
Status: string(status),
}
err = server.Start(server)
return
}