developer/galaxy-game
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

docs: reorder & testing

Browse Source
This commit is contained in:
Ilia Denisov
2026-05-07 00:58:53 +03:00
committed by GitHub
parent f446c6a2ac
commit 604fe40bcf
148 changed files with 9150 additions and 2757 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/model/order/order.go
+42
View File
@@ -2,8 +2,50 @@ package order
import (
"encoding/json"
"github.com/google/uuid"
)
// MessageTypeUserGamesCommand is the authenticated gateway message type
// used to send a batch of in-game commands to the engine through
// `POST /api/v1/user/games/{game_id}/commands`. The signed payload is
// a FlatBuffers `order.UserGamesCommand`.
const MessageTypeUserGamesCommand = "user.games.command"
// MessageTypeUserGamesOrder is the authenticated gateway message type
// used to validate / store a batch of in-game orders through
// `POST /api/v1/user/games/{game_id}/orders`. The signed payload is a
// FlatBuffers `order.UserGamesOrder`.
const MessageTypeUserGamesOrder = "user.games.order"
// UserGamesCommand is the typed payload of MessageTypeUserGamesCommand.
// `GameID` selects the running engine container; `Commands` is the
// player command batch executed atomically by the engine. The `Actor`
// field present in the engine's JSON shape is rebuilt by backend from
// the runtime player mapping — clients never carry it.
type UserGamesCommand struct {
// GameID identifies the running game for this batch.
GameID uuid.UUID `json:"game_id"`
// Commands is the player command batch.
Commands []DecodableCommand `json:"cmd"`
}
// UserGamesOrder is the typed payload of MessageTypeUserGamesOrder.
// Mirrors `UserGamesCommand` plus an `UpdatedAt` field that lets the
// engine reject stale order submissions.
type UserGamesOrder struct {
// GameID identifies the running game for this batch.
GameID uuid.UUID `json:"game_id"`
// UpdatedAt is the client-side timestamp used for stale-order
// detection on the engine side.
UpdatedAt int `json:"updatedAt"`
// Commands is the player order batch.
Commands []DecodableCommand `json:"cmd"`
}
type Order struct {
// TODO: check with already stored order, if any, and generate an error, if newer order exists
UpdatedAt int `json:"updatedAt"`
pkg/model/report/messages.go
+22
View File
@@ -0,0 +1,22 @@
package report
import "github.com/google/uuid"
// MessageTypeUserGamesReport is the authenticated gateway message type
// used to fetch a per-player turn report through
// `GET /api/v1/user/games/{game_id}/reports/{turn}`. The signed payload
// is a FlatBuffers `GameReportRequest`; the response is a FlatBuffers
// `Report`.
const MessageTypeUserGamesReport = "user.games.report"
// GameReportRequest is the typed payload of MessageTypeUserGamesReport.
// `GameID` selects the target game (the message_type alone is not
// enough; this scope is per-game) and `Turn` selects the requested
// turn number. Both fields are required.
type GameReportRequest struct {
// GameID identifies the game whose report is fetched.
GameID uuid.UUID `json:"game_id"`
// Turn is the zero-based turn number whose report is requested.
Turn uint `json:"turn"`
}
pkg/model/user/user.go
+88
View File
@@ -16,6 +16,19 @@ const (
// MessageTypeUpdateMySettings is the authenticated gateway message type used
// to mutate self-service settings fields.
MessageTypeUpdateMySettings = "user.settings.update"
// MessageTypeListMySessions is the authenticated gateway message type used
// to read the caller's active device sessions.
MessageTypeListMySessions = "user.sessions.list"
// MessageTypeRevokeMySession is the authenticated gateway message type used
// to revoke one of the caller's device sessions.
MessageTypeRevokeMySession = "user.sessions.revoke"
// MessageTypeRevokeAllMySessions is the authenticated gateway message type
// used to revoke every device session belonging to the caller (logout
// everywhere).
MessageTypeRevokeAllMySessions = "user.sessions.revoke_all"
)
// GetMyAccountRequest stores the authenticated self-service read request for
@@ -198,3 +211,78 @@ type ErrorResponse struct {
// Error stores the mirrored error envelope body.
Error ErrorBody `json:"error"`
}
// DeviceSession stores the transport-ready snapshot of one device session
// served by the authenticated user-surface session endpoints.
type DeviceSession struct {
// DeviceSessionID stores the durable device-session identifier.
DeviceSessionID string `json:"device_session_id"`
// UserID stores the authenticated user identity bound to the session.
UserID string `json:"user_id"`
// Status stores the lifecycle state of the session
// (`active` or `revoked`).
Status string `json:"status"`
// ClientPublicKey stores the standard base64-encoded raw 32-byte
// Ed25519 client public key, when populated.
ClientPublicKey string `json:"client_public_key,omitempty"`
// CreatedAt stores when the session was created.
CreatedAt time.Time `json:"created_at"`
// RevokedAt stores when the session was revoked, if revoked.
RevokedAt *time.Time `json:"revoked_at,omitempty"`
// LastSeenAt stores when gateway last resolved this session.
LastSeenAt *time.Time `json:"last_seen_at,omitempty"`
}
// ListMySessionsRequest stores the authenticated self-service "list my
// active sessions" command. The body is intentionally empty.
type ListMySessionsRequest struct{}
// ListMySessionsResponse stores the success payload of MessageTypeListMySessions.
type ListMySessionsResponse struct {
// Items stores the caller's currently active device sessions.
Items []DeviceSession `json:"items"`
}
// RevokeMySessionRequest stores the authenticated self-service single
// session revocation request.
type RevokeMySessionRequest struct {
// DeviceSessionID identifies the device session to revoke. The
// session must belong to the caller; otherwise the response carries
// the same error shape as a missing session so foreign session ids
// cannot be probed.
DeviceSessionID string `json:"device_session_id"`
}
// RevokeMySessionResponse stores the success payload of
// MessageTypeRevokeMySession.
type RevokeMySessionResponse struct {
// Session stores the post-revoke snapshot of the affected session.
Session DeviceSession `json:"session"`
}
// RevokeAllMySessionsRequest stores the authenticated self-service
// "logout everywhere" command. The body is intentionally empty.
type RevokeAllMySessionsRequest struct{}
// DeviceSessionRevocationSummary stores the count of sessions revoked by a
// bulk operation.
type DeviceSessionRevocationSummary struct {
// UserID identifies the user whose sessions were affected.
UserID string `json:"user_id"`
// RevokedCount stores how many sessions transitioned to revoked.
RevokedCount int `json:"revoked_count"`
}
// RevokeAllMySessionsResponse stores the success payload of
// MessageTypeRevokeAllMySessions.
type RevokeAllMySessionsResponse struct {
// Summary stores the user_id and revoked_count snapshot.
Summary DeviceSessionRevocationSummary `json:"summary"`
}
pkg/schema/fbs/common.fbs
+14
View File
@@ -0,0 +1,14 @@
// common contains FlatBuffers types shared across multiple schemas
// (order, report, …). Files that need these types include this one
// via `include "common.fbs";` and reference them through the `common.`
// namespace.
namespace common;
// UUID is a 128-bit RFC 4122 identifier encoded as two big-endian
// uint64 halves (`hi` carries bytes 0..7, `lo` carries bytes 8..15).
// Transcoders use the helpers in `pkg/transcoder/uuid.go` to convert
// between this layout and `github.com/google/uuid.UUID`.
struct UUID {
hi:uint64;
lo:uint64;
}
pkg/schema/fbs/report/UUID.go → pkg/schema/fbs/common/UUID.go
+1 -1
View File
@@ -1,6 +1,6 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package report
package common
import (
flatbuffers "github.com/google/flatbuffers/go"
pkg/schema/fbs/notification.fbs
+44 -31
View File
@@ -1,54 +1,67 @@
// notification contains shared FlatBuffers payloads published by
// Notification Service toward the gateway client event stream.
// Notification Service toward the gateway client event stream. Each
// table mirrors one catalog kind defined in
// `backend/internal/notification/catalog.go`; the table name is the
// camel-case form of the kind with the `Event` suffix.
include "common.fbs";
namespace notification;
table GameTurnReadyEvent {
game_id:string;
turn_number:int64;
table LobbyInviteReceivedEvent {
game_id:common.UUID (required);
inviter_user_id:common.UUID (required);
}
table GameFinishedEvent {
game_id:string;
final_turn_number:int64;
table LobbyInviteRevokedEvent {
game_id:common.UUID (required);
}
table LobbyApplicationSubmittedEvent {
game_id:string;
applicant_user_id:string;
game_id:common.UUID (required);
application_id:common.UUID (required);
}
table LobbyMembershipApprovedEvent {
game_id:string;
table LobbyApplicationApprovedEvent {
game_id:common.UUID (required);
}
table LobbyMembershipRejectedEvent {
game_id:string;
table LobbyApplicationRejectedEvent {
game_id:common.UUID (required);
}
table LobbyMembershipBlockedEvent {
game_id:string;
membership_user_id:string;
table LobbyMembershipRemovedEvent {
reason:string;
}
table LobbyInviteCreatedEvent {
game_id:string;
inviter_user_id:string;
}
table LobbyInviteRedeemedEvent {
game_id:string;
invitee_user_id:string;
}
table LobbyRaceNameRegistrationEligibleEvent {
game_id:string;
race_name:string;
eligible_until_ms:int64;
table LobbyMembershipBlockedEvent {
game_id:common.UUID (required);
reason:string;
}
table LobbyRaceNameRegisteredEvent {
race_name:string;
}
root_type GameTurnReadyEvent;
table LobbyRaceNamePendingEvent {
race_name:string;
expires_at:string;
}
table LobbyRaceNameExpiredEvent {
race_name:string;
}
table RuntimeImagePullFailedEvent {
game_id:common.UUID (required);
image_ref:string;
}
table RuntimeContainerStartFailedEvent {
game_id:common.UUID (required);
}
table RuntimeStartConfigInvalidEvent {
game_id:common.UUID (required);
reason:string;
}
pkg/schema/fbs/notification/GameFinishedEvent.go
-75
View File
@@ -1,75 +0,0 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package notification
import (
flatbuffers "github.com/google/flatbuffers/go"
)
type GameFinishedEvent struct {
_tab flatbuffers.Table
}
func GetRootAsGameFinishedEvent(buf []byte, offset flatbuffers.UOffsetT) *GameFinishedEvent {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &GameFinishedEvent{}
x.Init(buf, n+offset)
return x
}
func FinishGameFinishedEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsGameFinishedEvent(buf []byte, offset flatbuffers.UOffsetT) *GameFinishedEvent {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &GameFinishedEvent{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedGameFinishedEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *GameFinishedEvent) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *GameFinishedEvent) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *GameFinishedEvent) GameId() []byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
}
return nil
}
func (rcv *GameFinishedEvent) FinalTurnNumber() int64 {
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
if o != 0 {
return rcv._tab.GetInt64(o + rcv._tab.Pos)
}
return 0
}
func (rcv *GameFinishedEvent) MutateFinalTurnNumber(n int64) bool {
return rcv._tab.MutateInt64Slot(6, n)
}
func GameFinishedEventStart(builder *flatbuffers.Builder) {
builder.StartObject(2)
}
func GameFinishedEventAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(gameId), 0)
}
func GameFinishedEventAddFinalTurnNumber(builder *flatbuffers.Builder, finalTurnNumber int64) {
builder.PrependInt64Slot(1, finalTurnNumber, 0)
}
func GameFinishedEventEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/notification/GameTurnReadyEvent.go
-75
View File
@@ -1,75 +0,0 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package notification
import (
flatbuffers "github.com/google/flatbuffers/go"
)
type GameTurnReadyEvent struct {
_tab flatbuffers.Table
}
func GetRootAsGameTurnReadyEvent(buf []byte, offset flatbuffers.UOffsetT) *GameTurnReadyEvent {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &GameTurnReadyEvent{}
x.Init(buf, n+offset)
return x
}
func FinishGameTurnReadyEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsGameTurnReadyEvent(buf []byte, offset flatbuffers.UOffsetT) *GameTurnReadyEvent {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &GameTurnReadyEvent{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedGameTurnReadyEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *GameTurnReadyEvent) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *GameTurnReadyEvent) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *GameTurnReadyEvent) GameId() []byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
}
return nil
}
func (rcv *GameTurnReadyEvent) TurnNumber() int64 {
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
if o != 0 {
return rcv._tab.GetInt64(o + rcv._tab.Pos)
}
return 0
}
func (rcv *GameTurnReadyEvent) MutateTurnNumber(n int64) bool {
return rcv._tab.MutateInt64Slot(6, n)
}
func GameTurnReadyEventStart(builder *flatbuffers.Builder) {
builder.StartObject(2)
}
func GameTurnReadyEventAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(gameId), 0)
}
func GameTurnReadyEventAddTurnNumber(builder *flatbuffers.Builder, turnNumber int64) {
builder.PrependInt64Slot(1, turnNumber, 0)
}
func GameTurnReadyEventEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/notification/LobbyApplicationApprovedEvent.go
+67
View File
@@ -0,0 +1,67 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package notification
import (
flatbuffers "github.com/google/flatbuffers/go"
common "galaxy/schema/fbs/common"
)
type LobbyApplicationApprovedEvent struct {
_tab flatbuffers.Table
}
func GetRootAsLobbyApplicationApprovedEvent(buf []byte, offset flatbuffers.UOffsetT) *LobbyApplicationApprovedEvent {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &LobbyApplicationApprovedEvent{}
x.Init(buf, n+offset)
return x
}
func FinishLobbyApplicationApprovedEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsLobbyApplicationApprovedEvent(buf []byte, offset flatbuffers.UOffsetT) *LobbyApplicationApprovedEvent {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &LobbyApplicationApprovedEvent{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedLobbyApplicationApprovedEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *LobbyApplicationApprovedEvent) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *LobbyApplicationApprovedEvent) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *LobbyApplicationApprovedEvent) GameId(obj *common.UUID) *common.UUID {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
x := o + rcv._tab.Pos
if obj == nil {
obj = new(common.UUID)
}
obj.Init(rcv._tab.Bytes, x)
return obj
}
return nil
}
func LobbyApplicationApprovedEventStart(builder *flatbuffers.Builder) {
builder.StartObject(1)
}
func LobbyApplicationApprovedEventAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
builder.PrependStructSlot(0, flatbuffers.UOffsetT(gameId), 0)
}
func LobbyApplicationApprovedEventEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/notification/LobbyApplicationRejectedEvent.go
+67
View File
@@ -0,0 +1,67 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package notification
import (
flatbuffers "github.com/google/flatbuffers/go"
common "galaxy/schema/fbs/common"
)
type LobbyApplicationRejectedEvent struct {
_tab flatbuffers.Table
}
func GetRootAsLobbyApplicationRejectedEvent(buf []byte, offset flatbuffers.UOffsetT) *LobbyApplicationRejectedEvent {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &LobbyApplicationRejectedEvent{}
x.Init(buf, n+offset)
return x
}
func FinishLobbyApplicationRejectedEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsLobbyApplicationRejectedEvent(buf []byte, offset flatbuffers.UOffsetT) *LobbyApplicationRejectedEvent {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &LobbyApplicationRejectedEvent{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedLobbyApplicationRejectedEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *LobbyApplicationRejectedEvent) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *LobbyApplicationRejectedEvent) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *LobbyApplicationRejectedEvent) GameId(obj *common.UUID) *common.UUID {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
x := o + rcv._tab.Pos
if obj == nil {
obj = new(common.UUID)
}
obj.Init(rcv._tab.Bytes, x)
return obj
}
return nil
}
func LobbyApplicationRejectedEventStart(builder *flatbuffers.Builder) {
builder.StartObject(1)
}
func LobbyApplicationRejectedEventAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
builder.PrependStructSlot(0, flatbuffers.UOffsetT(gameId), 0)
}
func LobbyApplicationRejectedEventEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/notification/LobbyApplicationSubmittedEvent.go
+19 -7
View File
@@ -4,6 +4,8 @@ package notification
import (
flatbuffers "github.com/google/flatbuffers/go"
common "galaxy/schema/fbs/common"
)
type LobbyApplicationSubmittedEvent struct {
@@ -41,18 +43,28 @@ func (rcv *LobbyApplicationSubmittedEvent) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *LobbyApplicationSubmittedEvent) GameId() []byte {
func (rcv *LobbyApplicationSubmittedEvent) GameId(obj *common.UUID) *common.UUID {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
x := o + rcv._tab.Pos
if obj == nil {
obj = new(common.UUID)
}
obj.Init(rcv._tab.Bytes, x)
return obj
}
return nil
}
func (rcv *LobbyApplicationSubmittedEvent) ApplicantUserId() []byte {
func (rcv *LobbyApplicationSubmittedEvent) ApplicationId(obj *common.UUID) *common.UUID {
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
x := o + rcv._tab.Pos
if obj == nil {
obj = new(common.UUID)
}
obj.Init(rcv._tab.Bytes, x)
return obj
}
return nil
}
@@ -61,10 +73,10 @@ func LobbyApplicationSubmittedEventStart(builder *flatbuffers.Builder) {
builder.StartObject(2)
}
func LobbyApplicationSubmittedEventAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(gameId), 0)
builder.PrependStructSlot(0, flatbuffers.UOffsetT(gameId), 0)
}
func LobbyApplicationSubmittedEventAddApplicantUserId(builder *flatbuffers.Builder, applicantUserId flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(applicantUserId), 0)
func LobbyApplicationSubmittedEventAddApplicationId(builder *flatbuffers.Builder, applicationId flatbuffers.UOffsetT) {
builder.PrependStructSlot(1, flatbuffers.UOffsetT(applicationId), 0)
}
func LobbyApplicationSubmittedEventEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
pkg/schema/fbs/notification/LobbyInviteCreatedEvent.go
-71
View File
@@ -1,71 +0,0 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package notification
import (
flatbuffers "github.com/google/flatbuffers/go"
)
type LobbyInviteCreatedEvent struct {
_tab flatbuffers.Table
}
func GetRootAsLobbyInviteCreatedEvent(buf []byte, offset flatbuffers.UOffsetT) *LobbyInviteCreatedEvent {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &LobbyInviteCreatedEvent{}
x.Init(buf, n+offset)
return x
}
func FinishLobbyInviteCreatedEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsLobbyInviteCreatedEvent(buf []byte, offset flatbuffers.UOffsetT) *LobbyInviteCreatedEvent {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &LobbyInviteCreatedEvent{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedLobbyInviteCreatedEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *LobbyInviteCreatedEvent) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *LobbyInviteCreatedEvent) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *LobbyInviteCreatedEvent) GameId() []byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
}
return nil
}
func (rcv *LobbyInviteCreatedEvent) InviterUserId() []byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
}
return nil
}
func LobbyInviteCreatedEventStart(builder *flatbuffers.Builder) {
builder.StartObject(2)
}
func LobbyInviteCreatedEventAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(gameId), 0)
}
func LobbyInviteCreatedEventAddInviterUserId(builder *flatbuffers.Builder, inviterUserId flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(inviterUserId), 0)
}
func LobbyInviteCreatedEventEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/notification/LobbyInviteReceivedEvent.go
+83
View File
@@ -0,0 +1,83 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package notification
import (
flatbuffers "github.com/google/flatbuffers/go"
common "galaxy/schema/fbs/common"
)
type LobbyInviteReceivedEvent struct {
_tab flatbuffers.Table
}
func GetRootAsLobbyInviteReceivedEvent(buf []byte, offset flatbuffers.UOffsetT) *LobbyInviteReceivedEvent {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &LobbyInviteReceivedEvent{}
x.Init(buf, n+offset)
return x
}
func FinishLobbyInviteReceivedEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsLobbyInviteReceivedEvent(buf []byte, offset flatbuffers.UOffsetT) *LobbyInviteReceivedEvent {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &LobbyInviteReceivedEvent{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedLobbyInviteReceivedEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *LobbyInviteReceivedEvent) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *LobbyInviteReceivedEvent) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *LobbyInviteReceivedEvent) GameId(obj *common.UUID) *common.UUID {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
x := o + rcv._tab.Pos
if obj == nil {
obj = new(common.UUID)
}
obj.Init(rcv._tab.Bytes, x)
return obj
}
return nil
}
func (rcv *LobbyInviteReceivedEvent) InviterUserId(obj *common.UUID) *common.UUID {
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
if o != 0 {
x := o + rcv._tab.Pos
if obj == nil {
obj = new(common.UUID)
}
obj.Init(rcv._tab.Bytes, x)
return obj
}
return nil
}
func LobbyInviteReceivedEventStart(builder *flatbuffers.Builder) {
builder.StartObject(2)
}
func LobbyInviteReceivedEventAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
builder.PrependStructSlot(0, flatbuffers.UOffsetT(gameId), 0)
}
func LobbyInviteReceivedEventAddInviterUserId(builder *flatbuffers.Builder, inviterUserId flatbuffers.UOffsetT) {
builder.PrependStructSlot(1, flatbuffers.UOffsetT(inviterUserId), 0)
}
func LobbyInviteReceivedEventEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/notification/LobbyInviteRedeemedEvent.go
-71
View File
@@ -1,71 +0,0 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package notification
import (
flatbuffers "github.com/google/flatbuffers/go"
)
type LobbyInviteRedeemedEvent struct {
_tab flatbuffers.Table
}
func GetRootAsLobbyInviteRedeemedEvent(buf []byte, offset flatbuffers.UOffsetT) *LobbyInviteRedeemedEvent {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &LobbyInviteRedeemedEvent{}
x.Init(buf, n+offset)
return x
}
func FinishLobbyInviteRedeemedEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsLobbyInviteRedeemedEvent(buf []byte, offset flatbuffers.UOffsetT) *LobbyInviteRedeemedEvent {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &LobbyInviteRedeemedEvent{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedLobbyInviteRedeemedEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *LobbyInviteRedeemedEvent) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *LobbyInviteRedeemedEvent) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *LobbyInviteRedeemedEvent) GameId() []byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
}
return nil
}
func (rcv *LobbyInviteRedeemedEvent) InviteeUserId() []byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
}
return nil
}
func LobbyInviteRedeemedEventStart(builder *flatbuffers.Builder) {
builder.StartObject(2)
}
func LobbyInviteRedeemedEventAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(gameId), 0)
}
func LobbyInviteRedeemedEventAddInviteeUserId(builder *flatbuffers.Builder, inviteeUserId flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(inviteeUserId), 0)
}
func LobbyInviteRedeemedEventEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/notification/LobbyInviteRevokedEvent.go
+67
View File
@@ -0,0 +1,67 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package notification
import (
flatbuffers "github.com/google/flatbuffers/go"
common "galaxy/schema/fbs/common"
)
type LobbyInviteRevokedEvent struct {
_tab flatbuffers.Table
}
func GetRootAsLobbyInviteRevokedEvent(buf []byte, offset flatbuffers.UOffsetT) *LobbyInviteRevokedEvent {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &LobbyInviteRevokedEvent{}
x.Init(buf, n+offset)
return x
}
func FinishLobbyInviteRevokedEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsLobbyInviteRevokedEvent(buf []byte, offset flatbuffers.UOffsetT) *LobbyInviteRevokedEvent {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &LobbyInviteRevokedEvent{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedLobbyInviteRevokedEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *LobbyInviteRevokedEvent) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *LobbyInviteRevokedEvent) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *LobbyInviteRevokedEvent) GameId(obj *common.UUID) *common.UUID {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
x := o + rcv._tab.Pos
if obj == nil {
obj = new(common.UUID)
}
obj.Init(rcv._tab.Bytes, x)
return obj
}
return nil
}
func LobbyInviteRevokedEventStart(builder *flatbuffers.Builder) {
builder.StartObject(1)
}
func LobbyInviteRevokedEventAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
builder.PrependStructSlot(0, flatbuffers.UOffsetT(gameId), 0)
}
func LobbyInviteRevokedEventEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/notification/LobbyMembershipApprovedEvent.go
-60
View File
@@ -1,60 +0,0 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package notification
import (
flatbuffers "github.com/google/flatbuffers/go"
)
type LobbyMembershipApprovedEvent struct {
_tab flatbuffers.Table
}
func GetRootAsLobbyMembershipApprovedEvent(buf []byte, offset flatbuffers.UOffsetT) *LobbyMembershipApprovedEvent {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &LobbyMembershipApprovedEvent{}
x.Init(buf, n+offset)
return x
}
func FinishLobbyMembershipApprovedEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsLobbyMembershipApprovedEvent(buf []byte, offset flatbuffers.UOffsetT) *LobbyMembershipApprovedEvent {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &LobbyMembershipApprovedEvent{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedLobbyMembershipApprovedEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *LobbyMembershipApprovedEvent) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *LobbyMembershipApprovedEvent) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *LobbyMembershipApprovedEvent) GameId() []byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
}
return nil
}
func LobbyMembershipApprovedEventStart(builder *flatbuffers.Builder) {
builder.StartObject(1)
}
func LobbyMembershipApprovedEventAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(gameId), 0)
}
func LobbyMembershipApprovedEventEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/notification/LobbyMembershipBlockedEvent.go
+13 -17
View File
@@ -4,6 +4,8 @@ package notification
import (
flatbuffers "github.com/google/flatbuffers/go"
common "galaxy/schema/fbs/common"
)
type LobbyMembershipBlockedEvent struct {
@@ -41,15 +43,20 @@ func (rcv *LobbyMembershipBlockedEvent) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *LobbyMembershipBlockedEvent) GameId() []byte {
func (rcv *LobbyMembershipBlockedEvent) GameId(obj *common.UUID) *common.UUID {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
x := o + rcv._tab.Pos
if obj == nil {
obj = new(common.UUID)
}
obj.Init(rcv._tab.Bytes, x)
return obj
}
return nil
}
func (rcv *LobbyMembershipBlockedEvent) MembershipUserId() []byte {
func (rcv *LobbyMembershipBlockedEvent) Reason() []byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
@@ -57,25 +64,14 @@ func (rcv *LobbyMembershipBlockedEvent) MembershipUserId() []byte {
return nil
}
func (rcv *LobbyMembershipBlockedEvent) Reason() []byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
}
return nil
}
func LobbyMembershipBlockedEventStart(builder *flatbuffers.Builder) {
builder.StartObject(3)
builder.StartObject(2)
}
func LobbyMembershipBlockedEventAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(gameId), 0)
}
func LobbyMembershipBlockedEventAddMembershipUserId(builder *flatbuffers.Builder, membershipUserId flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(membershipUserId), 0)
builder.PrependStructSlot(0, flatbuffers.UOffsetT(gameId), 0)
}
func LobbyMembershipBlockedEventAddReason(builder *flatbuffers.Builder, reason flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(reason), 0)
builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(reason), 0)
}
func LobbyMembershipBlockedEventEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
pkg/schema/fbs/notification/LobbyMembershipRejectedEvent.go
-60
View File
@@ -1,60 +0,0 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package notification
import (
flatbuffers "github.com/google/flatbuffers/go"
)
type LobbyMembershipRejectedEvent struct {
_tab flatbuffers.Table
}
func GetRootAsLobbyMembershipRejectedEvent(buf []byte, offset flatbuffers.UOffsetT) *LobbyMembershipRejectedEvent {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &LobbyMembershipRejectedEvent{}
x.Init(buf, n+offset)
return x
}
func FinishLobbyMembershipRejectedEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsLobbyMembershipRejectedEvent(buf []byte, offset flatbuffers.UOffsetT) *LobbyMembershipRejectedEvent {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &LobbyMembershipRejectedEvent{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedLobbyMembershipRejectedEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *LobbyMembershipRejectedEvent) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *LobbyMembershipRejectedEvent) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *LobbyMembershipRejectedEvent) GameId() []byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
}
return nil
}
func LobbyMembershipRejectedEventStart(builder *flatbuffers.Builder) {
builder.StartObject(1)
}
func LobbyMembershipRejectedEventAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(gameId), 0)
}
func LobbyMembershipRejectedEventEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/notification/LobbyMembershipRemovedEvent.go
+60
View File
@@ -0,0 +1,60 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package notification
import (
flatbuffers "github.com/google/flatbuffers/go"
)
type LobbyMembershipRemovedEvent struct {
_tab flatbuffers.Table
}
func GetRootAsLobbyMembershipRemovedEvent(buf []byte, offset flatbuffers.UOffsetT) *LobbyMembershipRemovedEvent {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &LobbyMembershipRemovedEvent{}
x.Init(buf, n+offset)
return x
}
func FinishLobbyMembershipRemovedEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsLobbyMembershipRemovedEvent(buf []byte, offset flatbuffers.UOffsetT) *LobbyMembershipRemovedEvent {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &LobbyMembershipRemovedEvent{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedLobbyMembershipRemovedEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *LobbyMembershipRemovedEvent) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *LobbyMembershipRemovedEvent) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *LobbyMembershipRemovedEvent) Reason() []byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
}
return nil
}
func LobbyMembershipRemovedEventStart(builder *flatbuffers.Builder) {
builder.StartObject(1)
}
func LobbyMembershipRemovedEventAddReason(builder *flatbuffers.Builder, reason flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(reason), 0)
}
func LobbyMembershipRemovedEventEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/notification/LobbyRaceNameExpiredEvent.go
+60
View File
@@ -0,0 +1,60 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package notification
import (
flatbuffers "github.com/google/flatbuffers/go"
)
type LobbyRaceNameExpiredEvent struct {
_tab flatbuffers.Table
}
func GetRootAsLobbyRaceNameExpiredEvent(buf []byte, offset flatbuffers.UOffsetT) *LobbyRaceNameExpiredEvent {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &LobbyRaceNameExpiredEvent{}
x.Init(buf, n+offset)
return x
}
func FinishLobbyRaceNameExpiredEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsLobbyRaceNameExpiredEvent(buf []byte, offset flatbuffers.UOffsetT) *LobbyRaceNameExpiredEvent {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &LobbyRaceNameExpiredEvent{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedLobbyRaceNameExpiredEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *LobbyRaceNameExpiredEvent) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *LobbyRaceNameExpiredEvent) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *LobbyRaceNameExpiredEvent) RaceName() []byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
}
return nil
}
func LobbyRaceNameExpiredEventStart(builder *flatbuffers.Builder) {
builder.StartObject(1)
}
func LobbyRaceNameExpiredEventAddRaceName(builder *flatbuffers.Builder, raceName flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(raceName), 0)
}
func LobbyRaceNameExpiredEventEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/notification/LobbyRaceNamePendingEvent.go
+71
View File
@@ -0,0 +1,71 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package notification
import (
flatbuffers "github.com/google/flatbuffers/go"
)
type LobbyRaceNamePendingEvent struct {
_tab flatbuffers.Table
}
func GetRootAsLobbyRaceNamePendingEvent(buf []byte, offset flatbuffers.UOffsetT) *LobbyRaceNamePendingEvent {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &LobbyRaceNamePendingEvent{}
x.Init(buf, n+offset)
return x
}
func FinishLobbyRaceNamePendingEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsLobbyRaceNamePendingEvent(buf []byte, offset flatbuffers.UOffsetT) *LobbyRaceNamePendingEvent {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &LobbyRaceNamePendingEvent{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedLobbyRaceNamePendingEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *LobbyRaceNamePendingEvent) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *LobbyRaceNamePendingEvent) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *LobbyRaceNamePendingEvent) RaceName() []byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
}
return nil
}
func (rcv *LobbyRaceNamePendingEvent) ExpiresAt() []byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
}
return nil
}
func LobbyRaceNamePendingEventStart(builder *flatbuffers.Builder) {
builder.StartObject(2)
}
func LobbyRaceNamePendingEventAddRaceName(builder *flatbuffers.Builder, raceName flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(raceName), 0)
}
func LobbyRaceNamePendingEventAddExpiresAt(builder *flatbuffers.Builder, expiresAt flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(expiresAt), 0)
}
func LobbyRaceNamePendingEventEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/notification/LobbyRaceNameRegistrationEligibleEvent.go
-86
View File
@@ -1,86 +0,0 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package notification
import (
flatbuffers "github.com/google/flatbuffers/go"
)
type LobbyRaceNameRegistrationEligibleEvent struct {
_tab flatbuffers.Table
}
func GetRootAsLobbyRaceNameRegistrationEligibleEvent(buf []byte, offset flatbuffers.UOffsetT) *LobbyRaceNameRegistrationEligibleEvent {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &LobbyRaceNameRegistrationEligibleEvent{}
x.Init(buf, n+offset)
return x
}
func FinishLobbyRaceNameRegistrationEligibleEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsLobbyRaceNameRegistrationEligibleEvent(buf []byte, offset flatbuffers.UOffsetT) *LobbyRaceNameRegistrationEligibleEvent {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &LobbyRaceNameRegistrationEligibleEvent{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedLobbyRaceNameRegistrationEligibleEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *LobbyRaceNameRegistrationEligibleEvent) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *LobbyRaceNameRegistrationEligibleEvent) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *LobbyRaceNameRegistrationEligibleEvent) GameId() []byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
}
return nil
}
func (rcv *LobbyRaceNameRegistrationEligibleEvent) RaceName() []byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
}
return nil
}
func (rcv *LobbyRaceNameRegistrationEligibleEvent) EligibleUntilMs() int64 {
o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
if o != 0 {
return rcv._tab.GetInt64(o + rcv._tab.Pos)
}
return 0
}
func (rcv *LobbyRaceNameRegistrationEligibleEvent) MutateEligibleUntilMs(n int64) bool {
return rcv._tab.MutateInt64Slot(8, n)
}
func LobbyRaceNameRegistrationEligibleEventStart(builder *flatbuffers.Builder) {
builder.StartObject(3)
}
func LobbyRaceNameRegistrationEligibleEventAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(gameId), 0)
}
func LobbyRaceNameRegistrationEligibleEventAddRaceName(builder *flatbuffers.Builder, raceName flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(raceName), 0)
}
func LobbyRaceNameRegistrationEligibleEventAddEligibleUntilMs(builder *flatbuffers.Builder, eligibleUntilMs int64) {
builder.PrependInt64Slot(2, eligibleUntilMs, 0)
}
func LobbyRaceNameRegistrationEligibleEventEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/notification/RuntimeContainerStartFailedEvent.go
+67
View File
@@ -0,0 +1,67 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package notification
import (
flatbuffers "github.com/google/flatbuffers/go"
common "galaxy/schema/fbs/common"
)
type RuntimeContainerStartFailedEvent struct {
_tab flatbuffers.Table
}
func GetRootAsRuntimeContainerStartFailedEvent(buf []byte, offset flatbuffers.UOffsetT) *RuntimeContainerStartFailedEvent {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &RuntimeContainerStartFailedEvent{}
x.Init(buf, n+offset)
return x
}
func FinishRuntimeContainerStartFailedEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsRuntimeContainerStartFailedEvent(buf []byte, offset flatbuffers.UOffsetT) *RuntimeContainerStartFailedEvent {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &RuntimeContainerStartFailedEvent{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedRuntimeContainerStartFailedEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *RuntimeContainerStartFailedEvent) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *RuntimeContainerStartFailedEvent) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *RuntimeContainerStartFailedEvent) GameId(obj *common.UUID) *common.UUID {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
x := o + rcv._tab.Pos
if obj == nil {
obj = new(common.UUID)
}
obj.Init(rcv._tab.Bytes, x)
return obj
}
return nil
}
func RuntimeContainerStartFailedEventStart(builder *flatbuffers.Builder) {
builder.StartObject(1)
}
func RuntimeContainerStartFailedEventAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
builder.PrependStructSlot(0, flatbuffers.UOffsetT(gameId), 0)
}
func RuntimeContainerStartFailedEventEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/notification/RuntimeImagePullFailedEvent.go
+78
View File
@@ -0,0 +1,78 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package notification
import (
flatbuffers "github.com/google/flatbuffers/go"
common "galaxy/schema/fbs/common"
)
type RuntimeImagePullFailedEvent struct {
_tab flatbuffers.Table
}
func GetRootAsRuntimeImagePullFailedEvent(buf []byte, offset flatbuffers.UOffsetT) *RuntimeImagePullFailedEvent {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &RuntimeImagePullFailedEvent{}
x.Init(buf, n+offset)
return x
}
func FinishRuntimeImagePullFailedEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsRuntimeImagePullFailedEvent(buf []byte, offset flatbuffers.UOffsetT) *RuntimeImagePullFailedEvent {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &RuntimeImagePullFailedEvent{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedRuntimeImagePullFailedEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *RuntimeImagePullFailedEvent) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *RuntimeImagePullFailedEvent) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *RuntimeImagePullFailedEvent) GameId(obj *common.UUID) *common.UUID {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
x := o + rcv._tab.Pos
if obj == nil {
obj = new(common.UUID)
}
obj.Init(rcv._tab.Bytes, x)
return obj
}
return nil
}
func (rcv *RuntimeImagePullFailedEvent) ImageRef() []byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
}
return nil
}
func RuntimeImagePullFailedEventStart(builder *flatbuffers.Builder) {
builder.StartObject(2)
}
func RuntimeImagePullFailedEventAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
builder.PrependStructSlot(0, flatbuffers.UOffsetT(gameId), 0)
}
func RuntimeImagePullFailedEventAddImageRef(builder *flatbuffers.Builder, imageRef flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(imageRef), 0)
}
func RuntimeImagePullFailedEventEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/notification/RuntimeStartConfigInvalidEvent.go
+78
View File
@@ -0,0 +1,78 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package notification
import (
flatbuffers "github.com/google/flatbuffers/go"
common "galaxy/schema/fbs/common"
)
type RuntimeStartConfigInvalidEvent struct {
_tab flatbuffers.Table
}
func GetRootAsRuntimeStartConfigInvalidEvent(buf []byte, offset flatbuffers.UOffsetT) *RuntimeStartConfigInvalidEvent {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &RuntimeStartConfigInvalidEvent{}
x.Init(buf, n+offset)
return x
}
func FinishRuntimeStartConfigInvalidEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsRuntimeStartConfigInvalidEvent(buf []byte, offset flatbuffers.UOffsetT) *RuntimeStartConfigInvalidEvent {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &RuntimeStartConfigInvalidEvent{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedRuntimeStartConfigInvalidEventBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *RuntimeStartConfigInvalidEvent) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *RuntimeStartConfigInvalidEvent) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *RuntimeStartConfigInvalidEvent) GameId(obj *common.UUID) *common.UUID {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
x := o + rcv._tab.Pos
if obj == nil {
obj = new(common.UUID)
}
obj.Init(rcv._tab.Bytes, x)
return obj
}
return nil
}
func (rcv *RuntimeStartConfigInvalidEvent) Reason() []byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
}
return nil
}
func RuntimeStartConfigInvalidEventStart(builder *flatbuffers.Builder) {
builder.StartObject(2)
}
func RuntimeStartConfigInvalidEventAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
builder.PrependStructSlot(0, flatbuffers.UOffsetT(gameId), 0)
}
func RuntimeStartConfigInvalidEventAddReason(builder *flatbuffers.Builder, reason flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(reason), 0)
}
func RuntimeStartConfigInvalidEventEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/order.fbs
+26 -2
View File
@@ -1,4 +1,6 @@
// order reflects model/order/Order data object
include "common.fbs";
namespace order;
enum Relation : byte {
@@ -193,9 +195,31 @@ table CommandItem {
payload: CommandPayload (required);
}
table Order {
// UserGamesCommand is the signed-gRPC request payload for
// `MessageTypeUserGamesCommand`. game_id selects the target running
// game; gateway re-encodes commands into the engine JSON shape and
// forwards through `POST /api/v1/user/games/{game_id}/commands`.
table UserGamesCommand {
game_id: common.UUID (required);
commands: [CommandItem];
}
// UserGamesOrder is the signed-gRPC request payload for
// `MessageTypeUserGamesOrder`. Identical to UserGamesCommand but
// carries `updated_at` so the order-validate path can reject stale
// submissions.
table UserGamesOrder {
game_id: common.UUID (required);
updated_at: int64;
commands: [CommandItem];
}
root_type Order;
// UserGamesCommandResponse is the success acknowledgement returned
// for `MessageTypeUserGamesCommand`. The engine answers with
// `204 No Content` on success, so the FB shape is intentionally empty
// — kept as a typed envelope for future extension.
table UserGamesCommandResponse {}
// UserGamesOrderResponse is the success acknowledgement returned for
// `MessageTypeUserGamesOrder`. Mirrors `UserGamesCommandResponse`.
table UserGamesOrderResponse {}
pkg/schema/fbs/order/Order.go
-90
View File
@@ -1,90 +0,0 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package order
import (
flatbuffers "github.com/google/flatbuffers/go"
)
type Order struct {
_tab flatbuffers.Table
}
func GetRootAsOrder(buf []byte, offset flatbuffers.UOffsetT) *Order {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &Order{}
x.Init(buf, n+offset)
return x
}
func FinishOrderBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsOrder(buf []byte, offset flatbuffers.UOffsetT) *Order {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &Order{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedOrderBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *Order) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *Order) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *Order) UpdatedAt() int64 {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
return rcv._tab.GetInt64(o + rcv._tab.Pos)
}
return 0
}
func (rcv *Order) MutateUpdatedAt(n int64) bool {
return rcv._tab.MutateInt64Slot(4, n)
}
func (rcv *Order) Commands(obj *CommandItem, j int) bool {
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
if o != 0 {
x := rcv._tab.Vector(o)
x += flatbuffers.UOffsetT(j) * 4
x = rcv._tab.Indirect(x)
obj.Init(rcv._tab.Bytes, x)
return true
}
return false
}
func (rcv *Order) CommandsLength() int {
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
if o != 0 {
return rcv._tab.VectorLen(o)
}
return 0
}
func OrderStart(builder *flatbuffers.Builder) {
builder.StartObject(2)
}
func OrderAddUpdatedAt(builder *flatbuffers.Builder, updatedAt int64) {
builder.PrependInt64Slot(0, updatedAt, 0)
}
func OrderAddCommands(builder *flatbuffers.Builder, commands flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(commands), 0)
}
func OrderStartCommandsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
return builder.StartVector(4, numElems, 4)
}
func OrderEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/order/UserGamesCommand.go
+93
View File
@@ -0,0 +1,93 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package order
import (
flatbuffers "github.com/google/flatbuffers/go"
common "galaxy/schema/fbs/common"
)
type UserGamesCommand struct {
_tab flatbuffers.Table
}
func GetRootAsUserGamesCommand(buf []byte, offset flatbuffers.UOffsetT) *UserGamesCommand {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &UserGamesCommand{}
x.Init(buf, n+offset)
return x
}
func FinishUserGamesCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsUserGamesCommand(buf []byte, offset flatbuffers.UOffsetT) *UserGamesCommand {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &UserGamesCommand{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedUserGamesCommandBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *UserGamesCommand) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *UserGamesCommand) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *UserGamesCommand) GameId(obj *common.UUID) *common.UUID {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
x := o + rcv._tab.Pos
if obj == nil {
obj = new(common.UUID)
}
obj.Init(rcv._tab.Bytes, x)
return obj
}
return nil
}
func (rcv *UserGamesCommand) Commands(obj *CommandItem, j int) bool {
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
if o != 0 {
x := rcv._tab.Vector(o)
x += flatbuffers.UOffsetT(j) * 4
x = rcv._tab.Indirect(x)
obj.Init(rcv._tab.Bytes, x)
return true
}
return false
}
func (rcv *UserGamesCommand) CommandsLength() int {
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
if o != 0 {
return rcv._tab.VectorLen(o)
}
return 0
}
func UserGamesCommandStart(builder *flatbuffers.Builder) {
builder.StartObject(2)
}
func UserGamesCommandAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
builder.PrependStructSlot(0, flatbuffers.UOffsetT(gameId), 0)
}
func UserGamesCommandAddCommands(builder *flatbuffers.Builder, commands flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(commands), 0)
}
func UserGamesCommandStartCommandsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
return builder.StartVector(4, numElems, 4)
}
func UserGamesCommandEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/order/UserGamesCommandResponse.go
+49
View File
@@ -0,0 +1,49 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package order
import (
flatbuffers "github.com/google/flatbuffers/go"
)
type UserGamesCommandResponse struct {
_tab flatbuffers.Table
}
func GetRootAsUserGamesCommandResponse(buf []byte, offset flatbuffers.UOffsetT) *UserGamesCommandResponse {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &UserGamesCommandResponse{}
x.Init(buf, n+offset)
return x
}
func FinishUserGamesCommandResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsUserGamesCommandResponse(buf []byte, offset flatbuffers.UOffsetT) *UserGamesCommandResponse {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &UserGamesCommandResponse{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedUserGamesCommandResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *UserGamesCommandResponse) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *UserGamesCommandResponse) Table() flatbuffers.Table {
return rcv._tab
}
func UserGamesCommandResponseStart(builder *flatbuffers.Builder) {
builder.StartObject(0)
}
func UserGamesCommandResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/order/UserGamesOrder.go
+108
View File
@@ -0,0 +1,108 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package order
import (
flatbuffers "github.com/google/flatbuffers/go"
common "galaxy/schema/fbs/common"
)
type UserGamesOrder struct {
_tab flatbuffers.Table
}
func GetRootAsUserGamesOrder(buf []byte, offset flatbuffers.UOffsetT) *UserGamesOrder {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &UserGamesOrder{}
x.Init(buf, n+offset)
return x
}
func FinishUserGamesOrderBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsUserGamesOrder(buf []byte, offset flatbuffers.UOffsetT) *UserGamesOrder {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &UserGamesOrder{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedUserGamesOrderBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *UserGamesOrder) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *UserGamesOrder) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *UserGamesOrder) GameId(obj *common.UUID) *common.UUID {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
x := o + rcv._tab.Pos
if obj == nil {
obj = new(common.UUID)
}
obj.Init(rcv._tab.Bytes, x)
return obj
}
return nil
}
func (rcv *UserGamesOrder) UpdatedAt() int64 {
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
if o != 0 {
return rcv._tab.GetInt64(o + rcv._tab.Pos)
}
return 0
}
func (rcv *UserGamesOrder) MutateUpdatedAt(n int64) bool {
return rcv._tab.MutateInt64Slot(6, n)
}
func (rcv *UserGamesOrder) Commands(obj *CommandItem, j int) bool {
o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
if o != 0 {
x := rcv._tab.Vector(o)
x += flatbuffers.UOffsetT(j) * 4
x = rcv._tab.Indirect(x)
obj.Init(rcv._tab.Bytes, x)
return true
}
return false
}
func (rcv *UserGamesOrder) CommandsLength() int {
o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
if o != 0 {
return rcv._tab.VectorLen(o)
}
return 0
}
func UserGamesOrderStart(builder *flatbuffers.Builder) {
builder.StartObject(3)
}
func UserGamesOrderAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
builder.PrependStructSlot(0, flatbuffers.UOffsetT(gameId), 0)
}
func UserGamesOrderAddUpdatedAt(builder *flatbuffers.Builder, updatedAt int64) {
builder.PrependInt64Slot(1, updatedAt, 0)
}
func UserGamesOrderAddCommands(builder *flatbuffers.Builder, commands flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(commands), 0)
}
func UserGamesOrderStartCommandsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
return builder.StartVector(4, numElems, 4)
}
func UserGamesOrderEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/order/UserGamesOrderResponse.go
+49
View File
@@ -0,0 +1,49 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package order
import (
flatbuffers "github.com/google/flatbuffers/go"
)
type UserGamesOrderResponse struct {
_tab flatbuffers.Table
}
func GetRootAsUserGamesOrderResponse(buf []byte, offset flatbuffers.UOffsetT) *UserGamesOrderResponse {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &UserGamesOrderResponse{}
x.Init(buf, n+offset)
return x
}
func FinishUserGamesOrderResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsUserGamesOrderResponse(buf []byte, offset flatbuffers.UOffsetT) *UserGamesOrderResponse {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &UserGamesOrderResponse{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedUserGamesOrderResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *UserGamesOrderResponse) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *UserGamesOrderResponse) Table() flatbuffers.Table {
return rcv._tab
}
func UserGamesOrderResponseStart(builder *flatbuffers.Builder) {
builder.StartObject(0)
}
func UserGamesOrderResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/report.fbs
+14 -7
View File
@@ -1,10 +1,7 @@
// report reflects model/report/Report data object
namespace report;
include "common.fbs";
struct UUID {
hi:uint64;
lo:uint64;
}
namespace report;
table RouteEntry {
key:uint64;
@@ -184,7 +181,7 @@ table LocalGroup {
range:float32 = null;
speed:float32;
mass:float32;
id:UUID (required);
id:common.UUID (required);
state:string;
fleet:string;
}
@@ -213,7 +210,7 @@ table Report {
other_science:[OtherScience];
local_ship_class:[ShipClass];
other_ship_class:[OthersShipClass];
battle:[UUID];
battle:[common.UUID];
bombing:[Bombing];
incoming_group:[IncomingGroup];
local_planet:[LocalPlanet];
@@ -228,4 +225,14 @@ table Report {
unidentified_group:[UnidentifiedGroup];
}
// GameReportRequest is the signed-gRPC request payload for
// `MessageTypeUserGamesReport`. Gateway transcodes this into the
// engine's `?player=&turn=` query string after resolving the caller's
// race name from the runtime player mapping; only `game_id` and `turn`
// travel on the wire.
table GameReportRequest {
game_id:common.UUID (required);
turn:uint32;
}
root_type Report;
pkg/schema/fbs/report/GameReportRequest.go
+82
View File
@@ -0,0 +1,82 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package report
import (
flatbuffers "github.com/google/flatbuffers/go"
common "galaxy/schema/fbs/common"
)
type GameReportRequest struct {
_tab flatbuffers.Table
}
func GetRootAsGameReportRequest(buf []byte, offset flatbuffers.UOffsetT) *GameReportRequest {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &GameReportRequest{}
x.Init(buf, n+offset)
return x
}
func FinishGameReportRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsGameReportRequest(buf []byte, offset flatbuffers.UOffsetT) *GameReportRequest {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &GameReportRequest{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedGameReportRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *GameReportRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *GameReportRequest) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *GameReportRequest) GameId(obj *common.UUID) *common.UUID {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
x := o + rcv._tab.Pos
if obj == nil {
obj = new(common.UUID)
}
obj.Init(rcv._tab.Bytes, x)
return obj
}
return nil
}
func (rcv *GameReportRequest) Turn() uint32 {
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
if o != 0 {
return rcv._tab.GetUint32(o + rcv._tab.Pos)
}
return 0
}
func (rcv *GameReportRequest) MutateTurn(n uint32) bool {
return rcv._tab.MutateUint32Slot(6, n)
}
func GameReportRequestStart(builder *flatbuffers.Builder) {
builder.StartObject(2)
}
func GameReportRequestAddGameId(builder *flatbuffers.Builder, gameId flatbuffers.UOffsetT) {
builder.PrependStructSlot(0, flatbuffers.UOffsetT(gameId), 0)
}
func GameReportRequestAddTurn(builder *flatbuffers.Builder, turn uint32) {
builder.PrependUint32Slot(1, turn, 0)
}
func GameReportRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/report/LocalGroup.go
+4 -2
View File
@@ -4,6 +4,8 @@ package report
import (
flatbuffers "github.com/google/flatbuffers/go"
common "galaxy/schema/fbs/common"
)
type LocalGroup struct {
@@ -163,12 +165,12 @@ func (rcv *LocalGroup) MutateMass(n float32) bool {
return rcv._tab.MutateFloat32Slot(22, n)
}
func (rcv *LocalGroup) Id(obj *UUID) *UUID {
func (rcv *LocalGroup) Id(obj *common.UUID) *common.UUID {
o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
if o != 0 {
x := o + rcv._tab.Pos
if obj == nil {
obj = new(UUID)
obj = new(common.UUID)
}
obj.Init(rcv._tab.Bytes, x)
return obj
pkg/schema/fbs/report/Report.go
+3 -1
View File
@@ -4,6 +4,8 @@ package report
import (
flatbuffers "github.com/google/flatbuffers/go"
common "galaxy/schema/fbs/common"
)
type Report struct {
@@ -229,7 +231,7 @@ func (rcv *Report) OtherShipClassLength() int {
return 0
}
func (rcv *Report) Battle(obj *UUID, j int) bool {
func (rcv *Report) Battle(obj *common.UUID, j int) bool {
o := flatbuffers.UOffsetT(rcv._tab.Offset(30))
if o != 0 {
x := rcv._tab.Vector(o)
pkg/schema/fbs/user.fbs
+37
View File
@@ -76,4 +76,41 @@ table ErrorResponse {
error:ErrorBody;
}
table DeviceSessionView {
device_session_id:string;
user_id:string;
status:string;
client_public_key:string;
created_at_ms:int64;
revoked_at_ms:int64;
last_seen_at_ms:int64;
}
table ListMySessionsRequest {
}
table ListMySessionsResponse {
items:[DeviceSessionView];
}
table RevokeMySessionRequest {
device_session_id:string;
}
table RevokeMySessionResponse {
session:DeviceSessionView;
}
table RevokeAllMySessionsRequest {
}
table DeviceSessionRevocationSummaryView {
user_id:string;
revoked_count:int32;
}
table RevokeAllMySessionsResponse {
summary:DeviceSessionRevocationSummaryView;
}
root_type AccountResponse;
pkg/schema/fbs/user/DeviceSessionRevocationSummaryView.go
+75
View File
@@ -0,0 +1,75 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package user
import (
flatbuffers "github.com/google/flatbuffers/go"
)
type DeviceSessionRevocationSummaryView struct {
_tab flatbuffers.Table
}
func GetRootAsDeviceSessionRevocationSummaryView(buf []byte, offset flatbuffers.UOffsetT) *DeviceSessionRevocationSummaryView {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &DeviceSessionRevocationSummaryView{}
x.Init(buf, n+offset)
return x
}
func FinishDeviceSessionRevocationSummaryViewBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsDeviceSessionRevocationSummaryView(buf []byte, offset flatbuffers.UOffsetT) *DeviceSessionRevocationSummaryView {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &DeviceSessionRevocationSummaryView{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedDeviceSessionRevocationSummaryViewBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *DeviceSessionRevocationSummaryView) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *DeviceSessionRevocationSummaryView) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *DeviceSessionRevocationSummaryView) UserId() []byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
}
return nil
}
func (rcv *DeviceSessionRevocationSummaryView) RevokedCount() int32 {
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
if o != 0 {
return rcv._tab.GetInt32(o + rcv._tab.Pos)
}
return 0
}
func (rcv *DeviceSessionRevocationSummaryView) MutateRevokedCount(n int32) bool {
return rcv._tab.MutateInt32Slot(6, n)
}
func DeviceSessionRevocationSummaryViewStart(builder *flatbuffers.Builder) {
builder.StartObject(2)
}
func DeviceSessionRevocationSummaryViewAddUserId(builder *flatbuffers.Builder, userId flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(userId), 0)
}
func DeviceSessionRevocationSummaryViewAddRevokedCount(builder *flatbuffers.Builder, revokedCount int32) {
builder.PrependInt32Slot(1, revokedCount, 0)
}
func DeviceSessionRevocationSummaryViewEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/user/DeviceSessionView.go
+138
View File
@@ -0,0 +1,138 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package user
import (
flatbuffers "github.com/google/flatbuffers/go"
)
type DeviceSessionView struct {
_tab flatbuffers.Table
}
func GetRootAsDeviceSessionView(buf []byte, offset flatbuffers.UOffsetT) *DeviceSessionView {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &DeviceSessionView{}
x.Init(buf, n+offset)
return x
}
func FinishDeviceSessionViewBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsDeviceSessionView(buf []byte, offset flatbuffers.UOffsetT) *DeviceSessionView {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &DeviceSessionView{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedDeviceSessionViewBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *DeviceSessionView) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *DeviceSessionView) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *DeviceSessionView) DeviceSessionId() []byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
}
return nil
}
func (rcv *DeviceSessionView) UserId() []byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
}
return nil
}
func (rcv *DeviceSessionView) Status() []byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
}
return nil
}
func (rcv *DeviceSessionView) ClientPublicKey() []byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
}
return nil
}
func (rcv *DeviceSessionView) CreatedAtMs() int64 {
o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
if o != 0 {
return rcv._tab.GetInt64(o + rcv._tab.Pos)
}
return 0
}
func (rcv *DeviceSessionView) MutateCreatedAtMs(n int64) bool {
return rcv._tab.MutateInt64Slot(12, n)
}
func (rcv *DeviceSessionView) RevokedAtMs() int64 {
o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
if o != 0 {
return rcv._tab.GetInt64(o + rcv._tab.Pos)
}
return 0
}
func (rcv *DeviceSessionView) MutateRevokedAtMs(n int64) bool {
return rcv._tab.MutateInt64Slot(14, n)
}
func (rcv *DeviceSessionView) LastSeenAtMs() int64 {
o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
if o != 0 {
return rcv._tab.GetInt64(o + rcv._tab.Pos)
}
return 0
}
func (rcv *DeviceSessionView) MutateLastSeenAtMs(n int64) bool {
return rcv._tab.MutateInt64Slot(16, n)
}
func DeviceSessionViewStart(builder *flatbuffers.Builder) {
builder.StartObject(7)
}
func DeviceSessionViewAddDeviceSessionId(builder *flatbuffers.Builder, deviceSessionId flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(deviceSessionId), 0)
}
func DeviceSessionViewAddUserId(builder *flatbuffers.Builder, userId flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(userId), 0)
}
func DeviceSessionViewAddStatus(builder *flatbuffers.Builder, status flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(status), 0)
}
func DeviceSessionViewAddClientPublicKey(builder *flatbuffers.Builder, clientPublicKey flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(clientPublicKey), 0)
}
func DeviceSessionViewAddCreatedAtMs(builder *flatbuffers.Builder, createdAtMs int64) {
builder.PrependInt64Slot(4, createdAtMs, 0)
}
func DeviceSessionViewAddRevokedAtMs(builder *flatbuffers.Builder, revokedAtMs int64) {
builder.PrependInt64Slot(5, revokedAtMs, 0)
}
func DeviceSessionViewAddLastSeenAtMs(builder *flatbuffers.Builder, lastSeenAtMs int64) {
builder.PrependInt64Slot(6, lastSeenAtMs, 0)
}
func DeviceSessionViewEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/user/ListMySessionsRequest.go
+49
View File
@@ -0,0 +1,49 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package user
import (
flatbuffers "github.com/google/flatbuffers/go"
)
type ListMySessionsRequest struct {
_tab flatbuffers.Table
}
func GetRootAsListMySessionsRequest(buf []byte, offset flatbuffers.UOffsetT) *ListMySessionsRequest {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &ListMySessionsRequest{}
x.Init(buf, n+offset)
return x
}
func FinishListMySessionsRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsListMySessionsRequest(buf []byte, offset flatbuffers.UOffsetT) *ListMySessionsRequest {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &ListMySessionsRequest{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedListMySessionsRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *ListMySessionsRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *ListMySessionsRequest) Table() flatbuffers.Table {
return rcv._tab
}
func ListMySessionsRequestStart(builder *flatbuffers.Builder) {
builder.StartObject(0)
}
func ListMySessionsRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/user/ListMySessionsResponse.go
+75
View File
@@ -0,0 +1,75 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package user
import (
flatbuffers "github.com/google/flatbuffers/go"
)
type ListMySessionsResponse struct {
_tab flatbuffers.Table
}
func GetRootAsListMySessionsResponse(buf []byte, offset flatbuffers.UOffsetT) *ListMySessionsResponse {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &ListMySessionsResponse{}
x.Init(buf, n+offset)
return x
}
func FinishListMySessionsResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsListMySessionsResponse(buf []byte, offset flatbuffers.UOffsetT) *ListMySessionsResponse {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &ListMySessionsResponse{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedListMySessionsResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *ListMySessionsResponse) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *ListMySessionsResponse) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *ListMySessionsResponse) Items(obj *DeviceSessionView, j int) bool {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
x := rcv._tab.Vector(o)
x += flatbuffers.UOffsetT(j) * 4
x = rcv._tab.Indirect(x)
obj.Init(rcv._tab.Bytes, x)
return true
}
return false
}
func (rcv *ListMySessionsResponse) ItemsLength() int {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
return rcv._tab.VectorLen(o)
}
return 0
}
func ListMySessionsResponseStart(builder *flatbuffers.Builder) {
builder.StartObject(1)
}
func ListMySessionsResponseAddItems(builder *flatbuffers.Builder, items flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(items), 0)
}
func ListMySessionsResponseStartItemsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
return builder.StartVector(4, numElems, 4)
}
func ListMySessionsResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/user/RevokeAllMySessionsRequest.go
+49
View File
@@ -0,0 +1,49 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package user
import (
flatbuffers "github.com/google/flatbuffers/go"
)
type RevokeAllMySessionsRequest struct {
_tab flatbuffers.Table
}
func GetRootAsRevokeAllMySessionsRequest(buf []byte, offset flatbuffers.UOffsetT) *RevokeAllMySessionsRequest {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &RevokeAllMySessionsRequest{}
x.Init(buf, n+offset)
return x
}
func FinishRevokeAllMySessionsRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsRevokeAllMySessionsRequest(buf []byte, offset flatbuffers.UOffsetT) *RevokeAllMySessionsRequest {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &RevokeAllMySessionsRequest{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedRevokeAllMySessionsRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *RevokeAllMySessionsRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *RevokeAllMySessionsRequest) Table() flatbuffers.Table {
return rcv._tab
}
func RevokeAllMySessionsRequestStart(builder *flatbuffers.Builder) {
builder.StartObject(0)
}
func RevokeAllMySessionsRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/user/RevokeAllMySessionsResponse.go
+65
View File
@@ -0,0 +1,65 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package user
import (
flatbuffers "github.com/google/flatbuffers/go"
)
type RevokeAllMySessionsResponse struct {
_tab flatbuffers.Table
}
func GetRootAsRevokeAllMySessionsResponse(buf []byte, offset flatbuffers.UOffsetT) *RevokeAllMySessionsResponse {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &RevokeAllMySessionsResponse{}
x.Init(buf, n+offset)
return x
}
func FinishRevokeAllMySessionsResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsRevokeAllMySessionsResponse(buf []byte, offset flatbuffers.UOffsetT) *RevokeAllMySessionsResponse {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &RevokeAllMySessionsResponse{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedRevokeAllMySessionsResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *RevokeAllMySessionsResponse) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *RevokeAllMySessionsResponse) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *RevokeAllMySessionsResponse) Summary(obj *DeviceSessionRevocationSummaryView) *DeviceSessionRevocationSummaryView {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
x := rcv._tab.Indirect(o + rcv._tab.Pos)
if obj == nil {
obj = new(DeviceSessionRevocationSummaryView)
}
obj.Init(rcv._tab.Bytes, x)
return obj
}
return nil
}
func RevokeAllMySessionsResponseStart(builder *flatbuffers.Builder) {
builder.StartObject(1)
}
func RevokeAllMySessionsResponseAddSummary(builder *flatbuffers.Builder, summary flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(summary), 0)
}
func RevokeAllMySessionsResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/user/RevokeMySessionRequest.go
+60
View File
@@ -0,0 +1,60 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package user
import (
flatbuffers "github.com/google/flatbuffers/go"
)
type RevokeMySessionRequest struct {
_tab flatbuffers.Table
}
func GetRootAsRevokeMySessionRequest(buf []byte, offset flatbuffers.UOffsetT) *RevokeMySessionRequest {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &RevokeMySessionRequest{}
x.Init(buf, n+offset)
return x
}
func FinishRevokeMySessionRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsRevokeMySessionRequest(buf []byte, offset flatbuffers.UOffsetT) *RevokeMySessionRequest {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &RevokeMySessionRequest{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedRevokeMySessionRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *RevokeMySessionRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *RevokeMySessionRequest) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *RevokeMySessionRequest) DeviceSessionId() []byte {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
return rcv._tab.ByteVector(o + rcv._tab.Pos)
}
return nil
}
func RevokeMySessionRequestStart(builder *flatbuffers.Builder) {
builder.StartObject(1)
}
func RevokeMySessionRequestAddDeviceSessionId(builder *flatbuffers.Builder, deviceSessionId flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(deviceSessionId), 0)
}
func RevokeMySessionRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/schema/fbs/user/RevokeMySessionResponse.go
+65
View File
@@ -0,0 +1,65 @@
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
package user
import (
flatbuffers "github.com/google/flatbuffers/go"
)
type RevokeMySessionResponse struct {
_tab flatbuffers.Table
}
func GetRootAsRevokeMySessionResponse(buf []byte, offset flatbuffers.UOffsetT) *RevokeMySessionResponse {
n := flatbuffers.GetUOffsetT(buf[offset:])
x := &RevokeMySessionResponse{}
x.Init(buf, n+offset)
return x
}
func FinishRevokeMySessionResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.Finish(offset)
}
func GetSizePrefixedRootAsRevokeMySessionResponse(buf []byte, offset flatbuffers.UOffsetT) *RevokeMySessionResponse {
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
x := &RevokeMySessionResponse{}
x.Init(buf, n+offset+flatbuffers.SizeUint32)
return x
}
func FinishSizePrefixedRevokeMySessionResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
builder.FinishSizePrefixed(offset)
}
func (rcv *RevokeMySessionResponse) Init(buf []byte, i flatbuffers.UOffsetT) {
rcv._tab.Bytes = buf
rcv._tab.Pos = i
}
func (rcv *RevokeMySessionResponse) Table() flatbuffers.Table {
return rcv._tab
}
func (rcv *RevokeMySessionResponse) Session(obj *DeviceSessionView) *DeviceSessionView {
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
if o != 0 {
x := rcv._tab.Indirect(o + rcv._tab.Pos)
if obj == nil {
obj = new(DeviceSessionView)
}
obj.Init(rcv._tab.Bytes, x)
return obj
}
return nil
}
func RevokeMySessionResponseStart(builder *flatbuffers.Builder) {
builder.StartObject(1)
}
func RevokeMySessionResponseAddSession(builder *flatbuffers.Builder, session flatbuffers.UOffsetT) {
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(session), 0)
}
func RevokeMySessionResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
return builder.EndObject()
}
pkg/transcoder/battle.go
+4 -4
View File
@@ -34,7 +34,7 @@ func BattleReportToPayload(report *model.BattleReport) ([]byte, error) {
shipVector := encodeBattleOffsetVector(builder, len(shipOffsets), fbs.BattleReportStartShipsVector, shipOffsets)
protocolVector := encodeBattleOffsetVector(builder, len(protocolOffsets), fbs.BattleReportStartProtocolVector, protocolOffsets)
idHi, idLo := reportUUIDToHiLo(report.ID)
idHi, idLo := uuidToHiLo(report.ID)
fbs.BattleReportStart(builder)
fbs.BattleReportAddId(builder, fbs.CreateUUID(builder, idHi, idLo))
@@ -85,7 +85,7 @@ func PayloadToBattleReport(data []byte) (result *model.BattleReport, err error)
}
result = &model.BattleReport{
ID: reportUUIDFromHiLo(id.Hi(), id.Lo()),
ID: uuidFromHiLo(id.Hi(), id.Lo()),
Planet: planet,
PlanetName: string(flatReport.PlanetName()),
}
@@ -116,7 +116,7 @@ func encodeBattleRaceEntryOffsets(builder *flatbuffers.Builder, races map[int]uu
offsets := make([]flatbuffers.UOffsetT, len(keys))
for i, key := range keys {
hi, lo := reportUUIDToHiLo(races[key])
hi, lo := uuidToHiLo(races[key])
fbs.RaceEntryStart(builder)
fbs.RaceEntryAddKey(builder, int64(key))
fbs.RaceEntryAddValue(builder, fbs.CreateUUID(builder, hi, lo))
@@ -240,7 +240,7 @@ func decodeBattleRaceMap(flatReport *fbs.BattleReport, result *model.BattleRepor
return fmt.Errorf("decode battle report race %d: race value is missing", i)
}
result.Races[key] = reportUUIDFromHiLo(value.Hi(), value.Lo())
result.Races[key] = uuidFromHiLo(value.Hi(), value.Lo())
}
return nil
pkg/transcoder/notification.go
+479 -418
View File
File diff suppressed because it is too large Load Diff
pkg/transcoder/notification_test.go
+153 -241
View File
@@ -5,9 +5,17 @@ import (
"strings"
"testing"
commonfbs "galaxy/schema/fbs/common"
notificationfbs "galaxy/schema/fbs/notification"
flatbuffers "github.com/google/flatbuffers/go"
"github.com/google/uuid"
)
var (
testNotificationGameID = uuid.MustParse("11111111-1111-1111-1111-111111111111")
testNotificationApplicationID = uuid.MustParse("22222222-2222-2222-2222-222222222222")
testNotificationInviterID = uuid.MustParse("33333333-3333-3333-3333-333333333333")
)
func TestNotificationPayloadRoundTrips(t *testing.T) {
@@ -20,94 +28,123 @@ func TestNotificationPayloadRoundTrips(t *testing.T) {
decode func([]byte) (any, error)
}{
{
name: "game turn ready",
source: &GameTurnReadyEvent{GameID: "game-1", TurnNumber: 54},
encode: func(value any) ([]byte, error) { return GameTurnReadyEventToPayload(value.(*GameTurnReadyEvent)) },
decode: func(data []byte) (any, error) { return PayloadToGameTurnReadyEvent(data) },
name: "lobby invite received",
source: &LobbyInviteReceivedEvent{GameID: testNotificationGameID, InviterUserID: testNotificationInviterID},
encode: func(v any) ([]byte, error) {
return LobbyInviteReceivedEventToPayload(v.(*LobbyInviteReceivedEvent))
},
decode: func(data []byte) (any, error) { return PayloadToLobbyInviteReceivedEvent(data) },
},
{
name: "game finished",
source: &GameFinishedEvent{GameID: "game-2", FinalTurnNumber: 99},
encode: func(value any) ([]byte, error) { return GameFinishedEventToPayload(value.(*GameFinishedEvent)) },
decode: func(data []byte) (any, error) { return PayloadToGameFinishedEvent(data) },
name: "lobby invite revoked",
source: &LobbyInviteRevokedEvent{GameID: testNotificationGameID},
encode: func(v any) ([]byte, error) {
return LobbyInviteRevokedEventToPayload(v.(*LobbyInviteRevokedEvent))
},
decode: func(data []byte) (any, error) { return PayloadToLobbyInviteRevokedEvent(data) },
},
{
name: "lobby application submitted",
source: &LobbyApplicationSubmittedEvent{GameID: "game-3", ApplicantUserID: "user-7"},
encode: func(value any) ([]byte, error) {
return LobbyApplicationSubmittedEventToPayload(value.(*LobbyApplicationSubmittedEvent))
source: &LobbyApplicationSubmittedEvent{GameID: testNotificationGameID, ApplicationID: testNotificationApplicationID},
encode: func(v any) ([]byte, error) {
return LobbyApplicationSubmittedEventToPayload(v.(*LobbyApplicationSubmittedEvent))
},
decode: func(data []byte) (any, error) { return PayloadToLobbyApplicationSubmittedEvent(data) },
},
{
name: "lobby membership approved",
source: &LobbyMembershipApprovedEvent{GameID: "game-4"},
encode: func(value any) ([]byte, error) {
return LobbyMembershipApprovedEventToPayload(value.(*LobbyMembershipApprovedEvent))
name: "lobby application approved",
source: &LobbyApplicationApprovedEvent{GameID: testNotificationGameID},
encode: func(v any) ([]byte, error) {
return LobbyApplicationApprovedEventToPayload(v.(*LobbyApplicationApprovedEvent))
},
decode: func(data []byte) (any, error) { return PayloadToLobbyMembershipApprovedEvent(data) },
decode: func(data []byte) (any, error) { return PayloadToLobbyApplicationApprovedEvent(data) },
},
{
name: "lobby membership rejected",
source: &LobbyMembershipRejectedEvent{GameID: "game-5"},
encode: func(value any) ([]byte, error) {
return LobbyMembershipRejectedEventToPayload(value.(*LobbyMembershipRejectedEvent))
name: "lobby application rejected",
source: &LobbyApplicationRejectedEvent{GameID: testNotificationGameID},
encode: func(v any) ([]byte, error) {
return LobbyApplicationRejectedEventToPayload(v.(*LobbyApplicationRejectedEvent))
},
decode: func(data []byte) (any, error) { return PayloadToLobbyMembershipRejectedEvent(data) },
decode: func(data []byte) (any, error) { return PayloadToLobbyApplicationRejectedEvent(data) },
},
{
name: "lobby invite created",
source: &LobbyInviteCreatedEvent{GameID: "game-6", InviterUserID: "user-8"},
encode: func(value any) ([]byte, error) {
return LobbyInviteCreatedEventToPayload(value.(*LobbyInviteCreatedEvent))
name: "lobby membership removed",
source: &LobbyMembershipRemovedEvent{Reason: "deleted"},
encode: func(v any) ([]byte, error) {
return LobbyMembershipRemovedEventToPayload(v.(*LobbyMembershipRemovedEvent))
},
decode: func(data []byte) (any, error) { return PayloadToLobbyInviteCreatedEvent(data) },
decode: func(data []byte) (any, error) { return PayloadToLobbyMembershipRemovedEvent(data) },
},
{
name: "lobby invite redeemed",
source: &LobbyInviteRedeemedEvent{GameID: "game-7", InviteeUserID: "user-9"},
encode: func(value any) ([]byte, error) {
return LobbyInviteRedeemedEventToPayload(value.(*LobbyInviteRedeemedEvent))
name: "lobby membership blocked",
source: &LobbyMembershipBlockedEvent{GameID: testNotificationGameID, Reason: "permanent_blocked"},
encode: func(v any) ([]byte, error) {
return LobbyMembershipBlockedEventToPayload(v.(*LobbyMembershipBlockedEvent))
},
decode: func(data []byte) (any, error) { return PayloadToLobbyInviteRedeemedEvent(data) },
},
{
name: "lobby race name registration eligible",
source: &LobbyRaceNameRegistrationEligibleEvent{
GameID: "game-8",
RaceName: "Skylancer",
EligibleUntilMs: 1775208100000,
},
encode: func(value any) ([]byte, error) {
return LobbyRaceNameRegistrationEligibleEventToPayload(value.(*LobbyRaceNameRegistrationEligibleEvent))
},
decode: func(data []byte) (any, error) { return PayloadToLobbyRaceNameRegistrationEligibleEvent(data) },
decode: func(data []byte) (any, error) { return PayloadToLobbyMembershipBlockedEvent(data) },
},
{
name: "lobby race name registered",
source: &LobbyRaceNameRegisteredEvent{RaceName: "Skylancer"},
encode: func(value any) ([]byte, error) {
return LobbyRaceNameRegisteredEventToPayload(value.(*LobbyRaceNameRegisteredEvent))
encode: func(v any) ([]byte, error) {
return LobbyRaceNameRegisteredEventToPayload(v.(*LobbyRaceNameRegisteredEvent))
},
decode: func(data []byte) (any, error) { return PayloadToLobbyRaceNameRegisteredEvent(data) },
},
{
name: "lobby race name pending",
source: &LobbyRaceNamePendingEvent{RaceName: "Skylancer", ExpiresAt: "2026-05-06T12:00:00Z"},
encode: func(v any) ([]byte, error) {
return LobbyRaceNamePendingEventToPayload(v.(*LobbyRaceNamePendingEvent))
},
decode: func(data []byte) (any, error) { return PayloadToLobbyRaceNamePendingEvent(data) },
},
{
name: "lobby race name expired",
source: &LobbyRaceNameExpiredEvent{RaceName: "Skylancer"},
encode: func(v any) ([]byte, error) {
return LobbyRaceNameExpiredEventToPayload(v.(*LobbyRaceNameExpiredEvent))
},
decode: func(data []byte) (any, error) { return PayloadToLobbyRaceNameExpiredEvent(data) },
},
{
name: "runtime image pull failed",
source: &RuntimeImagePullFailedEvent{GameID: testNotificationGameID, ImageRef: "gcr.io/example:1.0.0"},
encode: func(v any) ([]byte, error) {
return RuntimeImagePullFailedEventToPayload(v.(*RuntimeImagePullFailedEvent))
},
decode: func(data []byte) (any, error) { return PayloadToRuntimeImagePullFailedEvent(data) },
},
{
name: "runtime container start failed",
source: &RuntimeContainerStartFailedEvent{GameID: testNotificationGameID},
encode: func(v any) ([]byte, error) {
return RuntimeContainerStartFailedEventToPayload(v.(*RuntimeContainerStartFailedEvent))
},
decode: func(data []byte) (any, error) { return PayloadToRuntimeContainerStartFailedEvent(data) },
},
{
name: "runtime start config invalid",
source: &RuntimeStartConfigInvalidEvent{GameID: testNotificationGameID, Reason: "missing engine version"},
encode: func(v any) ([]byte, error) {
return RuntimeStartConfigInvalidEventToPayload(v.(*RuntimeStartConfigInvalidEvent))
},
decode: func(data []byte) (any, error) { return PayloadToRuntimeStartConfigInvalidEvent(data) },
},
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
payload, err := tt.encode(tt.source)
if err != nil {
t.Fatalf("encode payload: %v", err)
}
decoded, err := tt.decode(payload)
if err != nil {
t.Fatalf("decode payload: %v", err)
}
if !reflect.DeepEqual(tt.source, decoded) {
t.Fatalf("round-trip mismatch\nsource: %#v\ndecoded:%#v", tt.source, decoded)
}
@@ -122,76 +159,25 @@ func TestNotificationPayloadEncodersRejectNilInputs(t *testing.T) {
name string
call func() error
}{
{
name: "game turn ready",
call: func() error {
_, err := GameTurnReadyEventToPayload(nil)
return err
},
},
{
name: "game finished",
call: func() error {
_, err := GameFinishedEventToPayload(nil)
return err
},
},
{
name: "lobby application submitted",
call: func() error {
_, err := LobbyApplicationSubmittedEventToPayload(nil)
return err
},
},
{
name: "lobby membership approved",
call: func() error {
_, err := LobbyMembershipApprovedEventToPayload(nil)
return err
},
},
{
name: "lobby membership rejected",
call: func() error {
_, err := LobbyMembershipRejectedEventToPayload(nil)
return err
},
},
{
name: "lobby invite created",
call: func() error {
_, err := LobbyInviteCreatedEventToPayload(nil)
return err
},
},
{
name: "lobby invite redeemed",
call: func() error {
_, err := LobbyInviteRedeemedEventToPayload(nil)
return err
},
},
{
name: "lobby race name registration eligible",
call: func() error {
_, err := LobbyRaceNameRegistrationEligibleEventToPayload(nil)
return err
},
},
{
name: "lobby race name registered",
call: func() error {
_, err := LobbyRaceNameRegisteredEventToPayload(nil)
return err
},
},
{"lobby invite received", func() error { _, err := LobbyInviteReceivedEventToPayload(nil); return err }},
{"lobby invite revoked", func() error { _, err := LobbyInviteRevokedEventToPayload(nil); return err }},
{"lobby application submitted", func() error { _, err := LobbyApplicationSubmittedEventToPayload(nil); return err }},
{"lobby application approved", func() error { _, err := LobbyApplicationApprovedEventToPayload(nil); return err }},
{"lobby application rejected", func() error { _, err := LobbyApplicationRejectedEventToPayload(nil); return err }},
{"lobby membership removed", func() error { _, err := LobbyMembershipRemovedEventToPayload(nil); return err }},
{"lobby membership blocked", func() error { _, err := LobbyMembershipBlockedEventToPayload(nil); return err }},
{"lobby race name registered", func() error { _, err := LobbyRaceNameRegisteredEventToPayload(nil); return err }},
{"lobby race name pending", func() error { _, err := LobbyRaceNamePendingEventToPayload(nil); return err }},
{"lobby race name expired", func() error { _, err := LobbyRaceNameExpiredEventToPayload(nil); return err }},
{"runtime image pull failed", func() error { _, err := RuntimeImagePullFailedEventToPayload(nil); return err }},
{"runtime container start failed", func() error { _, err := RuntimeContainerStartFailedEventToPayload(nil); return err }},
{"runtime start config invalid", func() error { _, err := RuntimeStartConfigInvalidEventToPayload(nil); return err }},
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
if err := tt.call(); err == nil {
t.Fatal("expected error")
}
@@ -206,62 +192,25 @@ func TestNotificationPayloadDecodersRejectEmptyPayloads(t *testing.T) {
name string
call func() error
}{
{
name: "game turn ready",
call: func() error {
_, err := PayloadToGameTurnReadyEvent(nil)
return err
},
},
{
name: "game finished",
call: func() error {
_, err := PayloadToGameFinishedEvent(nil)
return err
},
},
{
name: "lobby application submitted",
call: func() error {
_, err := PayloadToLobbyApplicationSubmittedEvent(nil)
return err
},
},
{
name: "lobby membership approved",
call: func() error {
_, err := PayloadToLobbyMembershipApprovedEvent(nil)
return err
},
},
{
name: "lobby membership rejected",
call: func() error {
_, err := PayloadToLobbyMembershipRejectedEvent(nil)
return err
},
},
{
name: "lobby invite created",
call: func() error {
_, err := PayloadToLobbyInviteCreatedEvent(nil)
return err
},
},
{
name: "lobby invite redeemed",
call: func() error {
_, err := PayloadToLobbyInviteRedeemedEvent(nil)
return err
},
},
{"lobby invite received", func() error { _, err := PayloadToLobbyInviteReceivedEvent(nil); return err }},
{"lobby invite revoked", func() error { _, err := PayloadToLobbyInviteRevokedEvent(nil); return err }},
{"lobby application submitted", func() error { _, err := PayloadToLobbyApplicationSubmittedEvent(nil); return err }},
{"lobby application approved", func() error { _, err := PayloadToLobbyApplicationApprovedEvent(nil); return err }},
{"lobby application rejected", func() error { _, err := PayloadToLobbyApplicationRejectedEvent(nil); return err }},
{"lobby membership removed", func() error { _, err := PayloadToLobbyMembershipRemovedEvent(nil); return err }},
{"lobby membership blocked", func() error { _, err := PayloadToLobbyMembershipBlockedEvent(nil); return err }},
{"lobby race name registered", func() error { _, err := PayloadToLobbyRaceNameRegisteredEvent(nil); return err }},
{"lobby race name pending", func() error { _, err := PayloadToLobbyRaceNamePendingEvent(nil); return err }},
{"lobby race name expired", func() error { _, err := PayloadToLobbyRaceNameExpiredEvent(nil); return err }},
{"runtime image pull failed", func() error { _, err := PayloadToRuntimeImagePullFailedEvent(nil); return err }},
{"runtime container start failed", func() error { _, err := PayloadToRuntimeContainerStartFailedEvent(nil); return err }},
{"runtime start config invalid", func() error { _, err := PayloadToRuntimeStartConfigInvalidEvent(nil); return err }},
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
if err := tt.call(); err == nil {
t.Fatal("expected error")
}
@@ -269,7 +218,7 @@ func TestNotificationPayloadDecodersRejectEmptyPayloads(t *testing.T) {
}
}
func TestNotificationPayloadEncodersRejectMissingRequiredStrings(t *testing.T) {
func TestNotificationPayloadEncodersRejectMissingUUIDs(t *testing.T) {
t.Parallel()
tests := []struct {
@@ -278,36 +227,29 @@ func TestNotificationPayloadEncodersRejectMissingRequiredStrings(t *testing.T) {
want string
}{
{
name: "game turn ready",
call: func() error {
_, err := GameTurnReadyEventToPayload(&GameTurnReadyEvent{})
return err
},
name: "lobby invite received game_id",
call: func() error { _, err := LobbyInviteReceivedEventToPayload(&LobbyInviteReceivedEvent{InviterUserID: testNotificationInviterID}); return err },
want: "game_id is empty",
},
{
name: "lobby application submitted",
call: func() error {
_, err := LobbyApplicationSubmittedEventToPayload(&LobbyApplicationSubmittedEvent{GameID: "game-1"})
return err
},
want: "applicant_user_id is empty",
},
{
name: "lobby invite created",
call: func() error {
_, err := LobbyInviteCreatedEventToPayload(&LobbyInviteCreatedEvent{GameID: "game-1"})
return err
},
name: "lobby invite received inviter",
call: func() error { _, err := LobbyInviteReceivedEventToPayload(&LobbyInviteReceivedEvent{GameID: testNotificationGameID}); return err },
want: "inviter_user_id is empty",
},
{
name: "lobby invite redeemed",
call: func() error {
_, err := LobbyInviteRedeemedEventToPayload(&LobbyInviteRedeemedEvent{GameID: "game-1"})
return err
},
want: "invitee_user_id is empty",
name: "lobby application submitted game_id",
call: func() error { _, err := LobbyApplicationSubmittedEventToPayload(&LobbyApplicationSubmittedEvent{ApplicationID: testNotificationApplicationID}); return err },
want: "game_id is empty",
},
{
name: "lobby application submitted application_id",
call: func() error { _, err := LobbyApplicationSubmittedEventToPayload(&LobbyApplicationSubmittedEvent{GameID: testNotificationGameID}); return err },
want: "application_id is empty",
},
{
name: "runtime image pull failed game_id",
call: func() error { _, err := RuntimeImagePullFailedEventToPayload(&RuntimeImagePullFailedEvent{ImageRef: "x"}); return err },
want: "game_id is empty",
},
}
@@ -315,7 +257,6 @@ func TestNotificationPayloadEncodersRejectMissingRequiredStrings(t *testing.T) {
tt := tt
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
err := tt.call()
if err == nil {
t.Fatal("expected error")
@@ -327,7 +268,7 @@ func TestNotificationPayloadEncodersRejectMissingRequiredStrings(t *testing.T) {
}
}
func TestNotificationPayloadDecodersRejectMissingRequiredStrings(t *testing.T) {
func TestNotificationPayloadDecodersRejectMissingUUIDs(t *testing.T) {
t.Parallel()
tests := []struct {
@@ -337,70 +278,42 @@ func TestNotificationPayloadDecodersRejectMissingRequiredStrings(t *testing.T) {
want string
}{
{
name: "game turn ready",
name: "lobby invite received game_id",
payload: func() []byte {
builder := flatbuffers.NewBuilder(32)
notificationfbs.GameTurnReadyEventStart(builder)
offset := notificationfbs.GameTurnReadyEventEnd(builder)
notificationfbs.FinishGameTurnReadyEventBuffer(builder, offset)
notificationfbs.LobbyInviteReceivedEventStart(builder)
offset := notificationfbs.LobbyInviteReceivedEventEnd(builder)
notificationfbs.FinishLobbyInviteReceivedEventBuffer(builder, offset)
return builder.FinishedBytes()
},
decode: func(data []byte) error {
_, err := PayloadToGameTurnReadyEvent(data)
return err
},
want: "game_id is missing",
decode: func(data []byte) error { _, err := PayloadToLobbyInviteReceivedEvent(data); return err },
want: "game_id is missing",
},
{
name: "lobby application submitted",
name: "lobby invite received inviter",
payload: func() []byte {
builder := flatbuffers.NewBuilder(32)
notificationfbs.LobbyInviteReceivedEventStart(builder)
notificationfbs.LobbyInviteReceivedEventAddGameId(builder, commonfbs.CreateUUID(builder, 1, 2))
offset := notificationfbs.LobbyInviteReceivedEventEnd(builder)
notificationfbs.FinishLobbyInviteReceivedEventBuffer(builder, offset)
return builder.FinishedBytes()
},
decode: func(data []byte) error { _, err := PayloadToLobbyInviteReceivedEvent(data); return err },
want: "inviter_user_id is missing",
},
{
name: "lobby application submitted application_id",
payload: func() []byte {
builder := flatbuffers.NewBuilder(32)
gameID := builder.CreateString("game-1")
notificationfbs.LobbyApplicationSubmittedEventStart(builder)
notificationfbs.LobbyApplicationSubmittedEventAddGameId(builder, gameID)
notificationfbs.LobbyApplicationSubmittedEventAddGameId(builder, commonfbs.CreateUUID(builder, 1, 2))
offset := notificationfbs.LobbyApplicationSubmittedEventEnd(builder)
notificationfbs.FinishLobbyApplicationSubmittedEventBuffer(builder, offset)
return builder.FinishedBytes()
},
decode: func(data []byte) error {
_, err := PayloadToLobbyApplicationSubmittedEvent(data)
return err
},
want: "applicant_user_id is missing",
},
{
name: "lobby invite created",
payload: func() []byte {
builder := flatbuffers.NewBuilder(32)
gameID := builder.CreateString("game-1")
notificationfbs.LobbyInviteCreatedEventStart(builder)
notificationfbs.LobbyInviteCreatedEventAddGameId(builder, gameID)
offset := notificationfbs.LobbyInviteCreatedEventEnd(builder)
notificationfbs.FinishLobbyInviteCreatedEventBuffer(builder, offset)
return builder.FinishedBytes()
},
decode: func(data []byte) error {
_, err := PayloadToLobbyInviteCreatedEvent(data)
return err
},
want: "inviter_user_id is missing",
},
{
name: "lobby invite redeemed",
payload: func() []byte {
builder := flatbuffers.NewBuilder(32)
gameID := builder.CreateString("game-1")
notificationfbs.LobbyInviteRedeemedEventStart(builder)
notificationfbs.LobbyInviteRedeemedEventAddGameId(builder, gameID)
offset := notificationfbs.LobbyInviteRedeemedEventEnd(builder)
notificationfbs.FinishLobbyInviteRedeemedEventBuffer(builder, offset)
return builder.FinishedBytes()
},
decode: func(data []byte) error {
_, err := PayloadToLobbyInviteRedeemedEvent(data)
return err
},
want: "invitee_user_id is missing",
decode: func(data []byte) error { _, err := PayloadToLobbyApplicationSubmittedEvent(data); return err },
want: "application_id is missing",
},
}
@@ -408,7 +321,6 @@ func TestNotificationPayloadDecodersRejectMissingRequiredStrings(t *testing.T) {
tt := tt
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
err := tt.decode(tt.payload())
if err == nil {
t.Fatal("expected error")
pkg/transcoder/order.go
+204 -98
View File
@@ -5,109 +5,12 @@ import (
"fmt"
model "galaxy/model/order"
commonfbs "galaxy/schema/fbs/common"
fbs "galaxy/schema/fbs/order"
flatbuffers "github.com/google/flatbuffers/go"
)
// OrderToPayload converts model.Order from the internal representation to
// FlatBuffers bytes that can be sent over network transports.
//
// The function returns an error when the input contains unsupported command
// types or values that cannot be represented by the current FlatBuffers schema.
func OrderToPayload(o *model.Order) ([]byte, error) {
if o == nil {
return nil, errors.New("encode order payload: order is nil")
}
builder := flatbuffers.NewBuilder(1024)
commandOffsets := make([]flatbuffers.UOffsetT, len(o.Commands))
for i := range o.Commands {
encoded, err := encodeOrderCommand(builder, o.Commands[i], i)
if err != nil {
return nil, err
}
cmdID := builder.CreateString(encoded.cmdID)
fbs.CommandItemStart(builder)
fbs.CommandItemAddCmdId(builder, cmdID)
if encoded.cmdApplied != nil {
fbs.CommandItemAddCmdApplied(builder, *encoded.cmdApplied)
}
if encoded.cmdErrCode != nil {
fbs.CommandItemAddCmdErrorCode(builder, int64(*encoded.cmdErrCode))
}
fbs.CommandItemAddPayloadType(builder, encoded.payloadType)
fbs.CommandItemAddPayload(builder, encoded.payloadOffset)
commandOffsets[i] = fbs.CommandItemEnd(builder)
}
var commandsVector flatbuffers.UOffsetT
if len(commandOffsets) > 0 {
fbs.OrderStartCommandsVector(builder, len(commandOffsets))
for i := len(commandOffsets) - 1; i >= 0; i-- {
builder.PrependUOffsetT(commandOffsets[i])
}
commandsVector = builder.EndVector(len(commandOffsets))
}
fbs.OrderStart(builder)
fbs.OrderAddUpdatedAt(builder, int64(o.UpdatedAt))
if len(commandOffsets) > 0 {
fbs.OrderAddCommands(builder, commandsVector)
}
orderOffset := fbs.OrderEnd(builder)
fbs.FinishOrderBuffer(builder, orderOffset)
return builder.FinishedBytes(), nil
}
// PayloadToOrder converts FlatBuffers payload bytes into model.Order.
//
// The function validates payload structure, command payload type, enum values,
// and integer conversions. Malformed payloads are returned as errors.
func PayloadToOrder(data []byte) (result *model.Order, err error) {
if len(data) == 0 {
return nil, errors.New("decode order payload: data is empty")
}
defer func() {
if recovered := recover(); recovered != nil {
result = nil
err = fmt.Errorf("decode order payload: panic recovered: %v", recovered)
}
}()
flatOrder := fbs.GetRootAsOrder(data, 0)
updatedAt, err := int64ToInt(flatOrder.UpdatedAt(), "updated_at")
if err != nil {
return nil, fmt.Errorf("decode order payload: %w", err)
}
result = &model.Order{UpdatedAt: updatedAt}
commandsLen := flatOrder.CommandsLength()
if commandsLen > 0 {
result.Commands = make([]model.DecodableCommand, commandsLen)
}
flatCommand := new(fbs.CommandItem)
for i := 0; i < commandsLen; i++ {
if !flatOrder.Commands(flatCommand, i) {
return nil, fmt.Errorf("decode order command %d: command item is missing", i)
}
command, err := decodeOrderCommand(flatCommand, i)
if err != nil {
return nil, err
}
result.Commands[i] = command
}
return result, nil
}
type encodedCommand struct {
cmdID string
cmdApplied *bool
@@ -701,6 +604,10 @@ func decodeOrderCommand(flatCommand *fbs.CommandItem, index int) (model.Decodabl
}
}
// int64ToInt narrows v to a Go int. Returns an error when v overflows
// the platform `int` range (only possible on 32-bit builds; on 64-bit
// the check is a no-op). fieldName is used in the error for caller
// context.
func int64ToInt(value int64, field string) (int, error) {
maxInt := int64(int(^uint(0) >> 1))
minInt := -maxInt - 1
@@ -897,3 +804,202 @@ func cloneIntPointer(value *int) *int {
cloned := *value
return &cloned
}
// UserGamesCommandToPayload converts model.UserGamesCommand to
// FlatBuffers bytes suitable for the authenticated gateway transport.
// `GameID` is required.
func UserGamesCommandToPayload(req *model.UserGamesCommand) ([]byte, error) {
if req == nil {
return nil, errors.New("encode user games command payload: request is nil")
}
builder := flatbuffers.NewBuilder(1024)
commandsVec, err := encodeCommandItemVector(builder, req.Commands, "user games command")
if err != nil {
return nil, err
}
fbs.UserGamesCommandStart(builder)
hi, lo := uuidToHiLo(req.GameID)
fbs.UserGamesCommandAddGameId(builder, commonfbs.CreateUUID(builder, hi, lo))
if commandsVec != 0 {
fbs.UserGamesCommandAddCommands(builder, commandsVec)
}
offset := fbs.UserGamesCommandEnd(builder)
fbs.FinishUserGamesCommandBuffer(builder, offset)
return builder.FinishedBytes(), nil
}
// PayloadToUserGamesCommand converts FlatBuffers payload bytes into
// model.UserGamesCommand.
func PayloadToUserGamesCommand(data []byte) (result *model.UserGamesCommand, err error) {
if len(data) == 0 {
return nil, errors.New("decode user games command payload: data is empty")
}
defer func() {
if recovered := recover(); recovered != nil {
result = nil
err = fmt.Errorf("decode user games command payload: panic recovered: %v", recovered)
}
}()
flat := fbs.GetRootAsUserGamesCommand(data, 0)
gameID := flat.GameId(nil)
if gameID == nil {
return nil, errors.New("decode user games command payload: game_id is missing")
}
out := &model.UserGamesCommand{
GameID: uuidFromHiLo(gameID.Hi(), gameID.Lo()),
}
count := flat.CommandsLength()
if count > 0 {
out.Commands = make([]model.DecodableCommand, count)
flatCommand := new(fbs.CommandItem)
for i := 0; i < count; i++ {
if !flat.Commands(flatCommand, i) {
return nil, fmt.Errorf("decode user games command %d: command item is missing", i)
}
cmd, decodeErr := decodeOrderCommand(flatCommand, i)
if decodeErr != nil {
return nil, decodeErr
}
out.Commands[i] = cmd
}
}
return out, nil
}
// UserGamesOrderToPayload converts model.UserGamesOrder to FlatBuffers
// bytes suitable for the authenticated gateway transport.
func UserGamesOrderToPayload(req *model.UserGamesOrder) ([]byte, error) {
if req == nil {
return nil, errors.New("encode user games order payload: request is nil")
}
builder := flatbuffers.NewBuilder(1024)
commandsVec, err := encodeCommandItemVector(builder, req.Commands, "user games order")
if err != nil {
return nil, err
}
fbs.UserGamesOrderStart(builder)
hi, lo := uuidToHiLo(req.GameID)
fbs.UserGamesOrderAddGameId(builder, commonfbs.CreateUUID(builder, hi, lo))
fbs.UserGamesOrderAddUpdatedAt(builder, int64(req.UpdatedAt))
if commandsVec != 0 {
fbs.UserGamesOrderAddCommands(builder, commandsVec)
}
offset := fbs.UserGamesOrderEnd(builder)
fbs.FinishUserGamesOrderBuffer(builder, offset)
return builder.FinishedBytes(), nil
}
// PayloadToUserGamesOrder converts FlatBuffers payload bytes into
// model.UserGamesOrder.
func PayloadToUserGamesOrder(data []byte) (result *model.UserGamesOrder, err error) {
if len(data) == 0 {
return nil, errors.New("decode user games order payload: data is empty")
}
defer func() {
if recovered := recover(); recovered != nil {
result = nil
err = fmt.Errorf("decode user games order payload: panic recovered: %v", recovered)
}
}()
flat := fbs.GetRootAsUserGamesOrder(data, 0)
gameID := flat.GameId(nil)
if gameID == nil {
return nil, errors.New("decode user games order payload: game_id is missing")
}
updatedAt, convErr := int64ToInt(flat.UpdatedAt(), "updated_at")
if convErr != nil {
return nil, fmt.Errorf("decode user games order payload: %w", convErr)
}
out := &model.UserGamesOrder{
GameID: uuidFromHiLo(gameID.Hi(), gameID.Lo()),
UpdatedAt: updatedAt,
}
count := flat.CommandsLength()
if count > 0 {
out.Commands = make([]model.DecodableCommand, count)
flatCommand := new(fbs.CommandItem)
for i := 0; i < count; i++ {
if !flat.Commands(flatCommand, i) {
return nil, fmt.Errorf("decode user games order %d: command item is missing", i)
}
cmd, decodeErr := decodeOrderCommand(flatCommand, i)
if decodeErr != nil {
return nil, decodeErr
}
out.Commands[i] = cmd
}
}
return out, nil
}
// EmptyUserGamesCommandResponsePayload returns a FlatBuffers-encoded
// empty `UserGamesCommandResponse` buffer. Used by gateway to ack a
// successful `MessageTypeUserGamesCommand` even though the engine
// returns 204 No Content — the typed envelope keeps the message-type
// contract symmetric with other authenticated routes.
func EmptyUserGamesCommandResponsePayload() []byte {
builder := flatbuffers.NewBuilder(16)
fbs.UserGamesCommandResponseStart(builder)
offset := fbs.UserGamesCommandResponseEnd(builder)
fbs.FinishUserGamesCommandResponseBuffer(builder, offset)
return builder.FinishedBytes()
}
// EmptyUserGamesOrderResponsePayload mirrors
// EmptyUserGamesCommandResponsePayload for `MessageTypeUserGamesOrder`.
func EmptyUserGamesOrderResponsePayload() []byte {
builder := flatbuffers.NewBuilder(16)
fbs.UserGamesOrderResponseStart(builder)
offset := fbs.UserGamesOrderResponseEnd(builder)
fbs.FinishUserGamesOrderResponseBuffer(builder, offset)
return builder.FinishedBytes()
}
// encodeCommandItemVector serialises a slice of DecodableCommand into a
// FlatBuffers vector of CommandItem. Used by UserGamesCommandToPayload
// and UserGamesOrderToPayload to keep the per-command encoding logic in
// one place.
func encodeCommandItemVector(builder *flatbuffers.Builder, commands []model.DecodableCommand, opLabel string) (flatbuffers.UOffsetT, error) {
offsets := make([]flatbuffers.UOffsetT, len(commands))
for i := range commands {
encoded, err := encodeOrderCommand(builder, commands[i], i)
if err != nil {
return 0, fmt.Errorf("encode %s: %w", opLabel, err)
}
cmdID := builder.CreateString(encoded.cmdID)
fbs.CommandItemStart(builder)
fbs.CommandItemAddCmdId(builder, cmdID)
if encoded.cmdApplied != nil {
fbs.CommandItemAddCmdApplied(builder, *encoded.cmdApplied)
}
if encoded.cmdErrCode != nil {
fbs.CommandItemAddCmdErrorCode(builder, int64(*encoded.cmdErrCode))
}
fbs.CommandItemAddPayloadType(builder, encoded.payloadType)
fbs.CommandItemAddPayload(builder, encoded.payloadOffset)
offsets[i] = fbs.CommandItemEnd(builder)
}
if len(offsets) == 0 {
return 0, nil
}
// `UserGamesCommandStartCommandsVector` and the corresponding
// `UserGamesOrderStartCommandsVector` are identical helpers (both
// expand to `builder.StartVector(4, numElems, 4)`); we use the
// command flavour for both message types so the helper has a
// single dependency point.
fbs.UserGamesCommandStartCommandsVector(builder, len(offsets))
for i := len(offsets) - 1; i >= 0; i-- {
builder.PrependUOffsetT(offsets[i])
}
return builder.EndVector(len(offsets)), nil
}
pkg/transcoder/order_test.go
+35 -259
View File
@@ -3,61 +3,32 @@ package transcoder
import (
"reflect"
"strconv"
"strings"
"testing"
model "galaxy/model/order"
fbs "galaxy/schema/fbs/order"
flatbuffers "github.com/google/flatbuffers/go"
"github.com/google/uuid"
)
func TestOrderToPayloadAndPayloadToOrderRoundTrip(t *testing.T) {
func TestUserGamesCommandPayloadRoundTrip(t *testing.T) {
t.Parallel()
appliedTrue := true
appliedFalse := false
errZero := 0
errThree := 3
errSeven := 7
source := &model.Order{
UpdatedAt: 42,
source := &model.UserGamesCommand{
GameID: uuid.MustParse("11111111-2222-3333-4444-555555555555"),
Commands: []model.DecodableCommand{
&model.CommandRaceQuit{CommandMeta: commandMeta("cmd-01", model.CommandTypeRaceQuit, &appliedTrue, &errZero)},
&model.CommandRaceVote{CommandMeta: commandMeta("cmd-02", model.CommandTypeRaceVote, nil, nil), Acceptor: "race-a"},
&model.CommandRaceRelation{CommandMeta: commandMeta("cmd-03", model.CommandTypeRaceRelation, &appliedFalse, nil), Acceptor: "race-b", Relation: "WAR"},
&model.CommandShipClassCreate{CommandMeta: commandMeta("cmd-04", model.CommandTypeShipClassCreate, nil, &errThree), Name: "frigate", Drive: 1.5, Armament: 5, Weapons: 2.5, Shields: 3.5, Cargo: 4.5},
&model.CommandShipClassMerge{CommandMeta: commandMeta("cmd-05", model.CommandTypeShipClassMerge, nil, nil), Name: "alpha", Target: "beta"},
&model.CommandShipClassRemove{CommandMeta: commandMeta("cmd-06", model.CommandTypeShipClassRemove, nil, nil), Name: "obsolete"},
&model.CommandShipGroupBreak{CommandMeta: commandMeta("cmd-07", model.CommandTypeShipGroupBreak, nil, nil), ID: "group-1", NewID: "group-2", Quantity: 12},
&model.CommandShipGroupLoad{CommandMeta: commandMeta("cmd-08", model.CommandTypeShipGroupLoad, nil, nil), ID: "group-3", Cargo: "MAT", Quantity: 7.25},
&model.CommandShipGroupUnload{CommandMeta: commandMeta("cmd-09", model.CommandTypeShipGroupUnload, nil, nil), ID: "group-4", Quantity: 1.75},
&model.CommandShipGroupSend{CommandMeta: commandMeta("cmd-10", model.CommandTypeShipGroupSend, nil, nil), ID: "group-5", Destination: 19},
&model.CommandShipGroupUpgrade{CommandMeta: commandMeta("cmd-11", model.CommandTypeShipGroupUpgrade, nil, nil), ID: "group-6", Tech: "SHIELDS", Level: 2.0},
&model.CommandShipGroupMerge{CommandMeta: commandMeta("cmd-12", model.CommandTypeShipGroupMerge, nil, nil)},
&model.CommandShipGroupDismantle{CommandMeta: commandMeta("cmd-13", model.CommandTypeShipGroupDismantle, nil, nil), ID: "group-7"},
&model.CommandShipGroupTransfer{CommandMeta: commandMeta("cmd-14", model.CommandTypeShipGroupTransfer, nil, &errSeven), ID: "group-8", Acceptor: "race-c"},
&model.CommandShipGroupJoinFleet{CommandMeta: commandMeta("cmd-15", model.CommandTypeShipGroupJoinFleet, nil, nil), ID: "group-9", Name: "fleet-a"},
&model.CommandFleetMerge{CommandMeta: commandMeta("cmd-16", model.CommandTypeFleetMerge, nil, nil), Name: "fleet-b", Target: "fleet-c"},
&model.CommandFleetSend{CommandMeta: commandMeta("cmd-17", model.CommandTypeFleetSend, nil, nil), Name: "fleet-d", Destination: 31},
&model.CommandScienceCreate{CommandMeta: commandMeta("cmd-18", model.CommandTypeScienceCreate, nil, nil), Name: "science-a", Drive: 0.1, Weapons: 0.2, Shields: 0.3, Cargo: 0.4},
&model.CommandScienceRemove{CommandMeta: commandMeta("cmd-19", model.CommandTypeScienceRemove, nil, nil), Name: "science-b"},
&model.CommandPlanetRename{CommandMeta: commandMeta("cmd-20", model.CommandTypePlanetRename, nil, nil), Number: 7, Name: "new-name"},
&model.CommandPlanetProduce{CommandMeta: commandMeta("cmd-21", model.CommandTypePlanetProduce, nil, nil), Number: 8, Production: "SHIP", Subject: "frigate"},
&model.CommandPlanetRouteSet{CommandMeta: commandMeta("cmd-22", model.CommandTypePlanetRouteSet, nil, nil), Origin: 9, Destination: 10, LoadType: "EMP"},
&model.CommandPlanetRouteRemove{CommandMeta: commandMeta("cmd-23", model.CommandTypePlanetRouteRemove, nil, nil), Origin: 11, LoadType: "COL"},
&model.CommandRaceVote{CommandMeta: commandMeta("cmd-01", model.CommandTypeRaceVote, nil, nil), Acceptor: "race-a"},
&model.CommandShipGroupSend{CommandMeta: commandMeta("cmd-02", model.CommandTypeShipGroupSend, nil, nil), ID: "group-1", Destination: 7},
},
}
payload, err := OrderToPayload(source)
payload, err := UserGamesCommandToPayload(source)
if err != nil {
t.Fatalf("encode order payload: %v", err)
t.Fatalf("encode user games command: %v", err)
}
decoded, err := PayloadToOrder(payload)
decoded, err := PayloadToUserGamesCommand(payload)
if err != nil {
t.Fatalf("decode order payload: %v", err)
t.Fatalf("decode user games command: %v", err)
}
if !reflect.DeepEqual(source, decoded) {
@@ -65,213 +36,46 @@ func TestOrderToPayloadAndPayloadToOrderRoundTrip(t *testing.T) {
}
}
func TestOrderToPayloadNilOrder(t *testing.T) {
func TestUserGamesOrderPayloadRoundTrip(t *testing.T) {
t.Parallel()
_, err := OrderToPayload(nil)
if err == nil {
t.Fatal("expected error for nil order")
}
}
func TestOrderToPayloadUnsupportedCommandType(t *testing.T) {
t.Parallel()
source := &model.Order{
Commands: []model.DecodableCommand{unsupportedCommand{}},
}
_, err := OrderToPayload(source)
if err == nil {
t.Fatal("expected error for unsupported command type")
}
if !strings.Contains(err.Error(), "unsupported command type") {
t.Fatalf("unexpected error: %v", err)
}
}
func TestOrderToPayloadTypedNilCommand(t *testing.T) {
t.Parallel()
var typedNil *model.CommandRaceQuit
source := &model.Order{
Commands: []model.DecodableCommand{typedNil},
}
_, err := OrderToPayload(source)
if err == nil {
t.Fatal("expected error for typed nil command")
}
if !strings.Contains(err.Error(), "command is nil") {
t.Fatalf("unexpected error: %v", err)
}
}
func TestOrderToPayloadInvalidEnum(t *testing.T) {
t.Parallel()
source := &model.Order{
source := &model.UserGamesOrder{
GameID: uuid.MustParse("aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"),
UpdatedAt: 12345,
Commands: []model.DecodableCommand{
&model.CommandRaceRelation{
CommandMeta: commandMeta("cmd-1", model.CommandTypeRaceRelation, nil, nil),
Acceptor: "race-a",
Relation: "ALLY",
},
&model.CommandPlanetRename{CommandMeta: commandMeta("cmd-1", model.CommandTypePlanetRename, nil, nil), Number: 5, Name: "alpha"},
},
}
_, err := OrderToPayload(source)
if err == nil {
t.Fatal("expected error for invalid enum value")
payload, err := UserGamesOrderToPayload(source)
if err != nil {
t.Fatalf("encode user games order: %v", err)
}
if !strings.Contains(err.Error(), "unsupported relation value") {
t.Fatalf("unexpected error: %v", err)
decoded, err := PayloadToUserGamesOrder(payload)
if err != nil {
t.Fatalf("decode user games order: %v", err)
}
if !reflect.DeepEqual(source, decoded) {
t.Fatalf("round-trip mismatch\nsource: %#v\ndecoded:%#v", source, decoded)
}
}
func TestPayloadToOrderEmptyData(t *testing.T) {
func TestUserGamesCommandRejectsNilAndEmpty(t *testing.T) {
t.Parallel()
_, err := PayloadToOrder(nil)
if err == nil {
t.Fatal("expected error for empty payload")
if _, err := UserGamesCommandToPayload(nil); err == nil {
t.Fatalf("expected error encoding nil user games command")
}
}
func TestPayloadToOrderGarbageDataDoesNotPanic(t *testing.T) {
t.Parallel()
_, err := PayloadToOrder([]byte{0x01, 0x02, 0x03})
if err == nil {
t.Fatal("expected error for malformed payload")
if _, err := PayloadToUserGamesCommand(nil); err == nil {
t.Fatalf("expected error decoding empty user games command")
}
}
func TestPayloadToOrderUnknownPayloadType(t *testing.T) {
t.Parallel()
payload := buildSingleCommandOrderPayload(func(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
fbs.CommandRaceQuitStart(builder)
commandPayload := fbs.CommandRaceQuitEnd(builder)
cmdID := builder.CreateString("cmd-1")
fbs.CommandItemStart(builder)
fbs.CommandItemAddCmdId(builder, cmdID)
fbs.CommandItemAddPayloadType(builder, fbs.CommandPayload(127))
fbs.CommandItemAddPayload(builder, commandPayload)
return fbs.CommandItemEnd(builder)
})
_, err := PayloadToOrder(payload)
if err == nil {
t.Fatal("expected error for unknown payload type")
if _, err := UserGamesOrderToPayload(nil); err == nil {
t.Fatalf("expected error encoding nil user games order")
}
if !strings.Contains(err.Error(), "unknown command payload type") {
t.Fatalf("unexpected error: %v", err)
}
}
func TestPayloadToOrderMissingPayload(t *testing.T) {
t.Parallel()
payload := buildSingleCommandOrderPayload(func(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
cmdID := builder.CreateString("cmd-1")
fbs.CommandItemStart(builder)
fbs.CommandItemAddCmdId(builder, cmdID)
fbs.CommandItemAddPayloadType(builder, fbs.CommandPayloadCommandRaceQuit)
return fbs.CommandItemEnd(builder)
})
_, err := PayloadToOrder(payload)
if err == nil {
t.Fatal("expected error for missing payload")
}
if !strings.Contains(err.Error(), "payload is missing") {
t.Fatalf("unexpected error: %v", err)
}
}
func TestPayloadToOrderPayloadTypeNone(t *testing.T) {
t.Parallel()
payload := buildSingleCommandOrderPayload(func(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
fbs.CommandRaceQuitStart(builder)
commandPayload := fbs.CommandRaceQuitEnd(builder)
cmdID := builder.CreateString("cmd-1")
fbs.CommandItemStart(builder)
fbs.CommandItemAddCmdId(builder, cmdID)
fbs.CommandItemAddPayload(builder, commandPayload)
return fbs.CommandItemEnd(builder)
})
_, err := PayloadToOrder(payload)
if err == nil {
t.Fatal("expected error for NONE payload type")
}
if !strings.Contains(err.Error(), "payload type is NONE") {
t.Fatalf("unexpected error: %v", err)
}
}
func TestPayloadToOrderUnknownEnum(t *testing.T) {
t.Parallel()
payload := buildSingleCommandOrderPayload(func(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
acceptor := builder.CreateString("race-a")
fbs.CommandRaceRelationStart(builder)
fbs.CommandRaceRelationAddAcceptor(builder, acceptor)
fbs.CommandRaceRelationAddRelation(builder, fbs.RelationUNKNOWN)
commandPayload := fbs.CommandRaceRelationEnd(builder)
cmdID := builder.CreateString("cmd-1")
fbs.CommandItemStart(builder)
fbs.CommandItemAddCmdId(builder, cmdID)
fbs.CommandItemAddPayloadType(builder, fbs.CommandPayloadCommandRaceRelation)
fbs.CommandItemAddPayload(builder, commandPayload)
return fbs.CommandItemEnd(builder)
})
_, err := PayloadToOrder(payload)
if err == nil {
t.Fatal("expected error for UNKNOWN enum")
}
if !strings.Contains(err.Error(), "UNKNOWN") {
t.Fatalf("unexpected error: %v", err)
}
}
func TestPayloadToOrderOverflow(t *testing.T) {
t.Parallel()
if strconv.IntSize == 64 {
t.Skip("int overflow from int64 is not possible on 64-bit runtime")
}
maxInt := int(^uint(0) >> 1)
overflowValue := int64(maxInt) + 1
payload := buildSingleCommandOrderPayload(func(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
name := builder.CreateString("planet-a")
fbs.CommandPlanetRenameStart(builder)
fbs.CommandPlanetRenameAddNumber(builder, overflowValue)
fbs.CommandPlanetRenameAddName(builder, name)
commandPayload := fbs.CommandPlanetRenameEnd(builder)
cmdID := builder.CreateString("cmd-1")
fbs.CommandItemStart(builder)
fbs.CommandItemAddCmdId(builder, cmdID)
fbs.CommandItemAddPayloadType(builder, fbs.CommandPayloadCommandPlanetRename)
fbs.CommandItemAddPayload(builder, commandPayload)
return fbs.CommandItemEnd(builder)
})
_, err := PayloadToOrder(payload)
if err == nil {
t.Fatal("expected overflow error")
}
if !strings.Contains(err.Error(), "overflows int") {
t.Fatalf("unexpected error: %v", err)
if _, err := PayloadToUserGamesOrder(nil); err == nil {
t.Fatalf("expected error decoding empty user games order")
}
}
@@ -295,16 +99,6 @@ func TestInt64ToInt(t *testing.T) {
}
}
type unsupportedCommand struct{}
func (unsupportedCommand) CommandID() string {
return "unsupported"
}
func (unsupportedCommand) CommandType() model.CommandType {
return model.CommandType("unsupported")
}
func commandMeta(id string, cmdType model.CommandType, applied *bool, errCode *int) model.CommandMeta {
return model.CommandMeta{
CmdType: cmdType,
@@ -313,21 +107,3 @@ func commandMeta(id string, cmdType model.CommandType, applied *bool, errCode *i
CmdErrCode: errCode,
}
}
func buildSingleCommandOrderPayload(itemBuilder func(*flatbuffers.Builder) flatbuffers.UOffsetT) []byte {
builder := flatbuffers.NewBuilder(256)
itemOffset := itemBuilder(builder)
fbs.OrderStartCommandsVector(builder, 1)
builder.PrependUOffsetT(itemOffset)
commands := builder.EndVector(1)
fbs.OrderStart(builder)
fbs.OrderAddUpdatedAt(builder, 1)
fbs.OrderAddCommands(builder, commands)
orderOffset := fbs.OrderEnd(builder)
fbs.FinishOrderBuffer(builder, orderOffset)
return builder.FinishedBytes()
}
pkg/transcoder/report.go
+52 -19
View File
@@ -1,12 +1,12 @@
package transcoder
import (
"encoding/binary"
"errors"
"fmt"
"sort"
model "galaxy/model/report"
commonfbs "galaxy/schema/fbs/common"
fbs "galaxy/schema/fbs/report"
flatbuffers "github.com/google/flatbuffers/go"
@@ -521,7 +521,7 @@ func encodeReportLocalGroup(builder *flatbuffers.Builder, group *model.LocalGrou
fleet = builder.CreateString(*group.Fleet)
}
idHi, idLo := reportUUIDToHiLo(group.ID)
idHi, idLo := uuidToHiLo(group.ID)
fbs.LocalGroupStart(builder)
fbs.LocalGroupAddNumber(builder, uint64(group.Number))
@@ -540,7 +540,7 @@ func encodeReportLocalGroup(builder *flatbuffers.Builder, group *model.LocalGrou
}
fbs.LocalGroupAddSpeed(builder, reportFloatToFBS(group.Speed))
fbs.LocalGroupAddMass(builder, reportFloatToFBS(group.Mass))
fbs.LocalGroupAddId(builder, fbs.CreateUUID(builder, idHi, idLo))
fbs.LocalGroupAddId(builder, commonfbs.CreateUUID(builder, idHi, idLo))
fbs.LocalGroupAddState(builder, state)
if group.Fleet != nil {
fbs.LocalGroupAddFleet(builder, fleet)
@@ -735,12 +735,12 @@ func decodeReportBattleVector(flatReport *fbs.Report, result *model.Report) erro
}
result.Battle = make([]uuid.UUID, length)
item := new(fbs.UUID)
item := new(commonfbs.UUID)
for i := 0; i < length; i++ {
if !flatReport.Battle(item, i) {
return fmt.Errorf("decode report battle %d: battle id is missing", i)
}
result.Battle[i] = reportUUIDFromHiLo(item.Hi(), item.Lo())
result.Battle[i] = uuidFromHiLo(item.Hi(), item.Lo())
}
return nil
@@ -1120,7 +1120,7 @@ func decodeReportLocalGroupVector(flatReport *fbs.Report, result *model.Report)
Speed: reportFloatFromFBS(item.Speed()),
Mass: reportFloatFromFBS(item.Mass()),
},
ID: reportUUIDFromHiLo(id.Hi(), id.Lo()),
ID: uuidFromHiLo(id.Hi(), id.Lo()),
State: string(item.State()),
}
@@ -1306,8 +1306,8 @@ func encodeReportUUIDVector(builder *flatbuffers.Builder, ids []uuid.UUID) flatb
fbs.ReportStartBattleVector(builder, len(ids))
for i := len(ids) - 1; i >= 0; i-- {
hi, lo := reportUUIDToHiLo(ids[i])
fbs.CreateUUID(builder, hi, lo)
hi, lo := uuidToHiLo(ids[i])
commonfbs.CreateUUID(builder, hi, lo)
}
return builder.EndVector(len(ids))
}
@@ -1374,17 +1374,6 @@ func reportFloatFromFBS(value float32) model.Float {
return model.Float(float64(value))
}
func reportUUIDToHiLo(value uuid.UUID) (uint64, uint64) {
return binary.BigEndian.Uint64(value[0:8]), binary.BigEndian.Uint64(value[8:16])
}
func reportUUIDFromHiLo(hi uint64, lo uint64) uuid.UUID {
var value uuid.UUID
binary.BigEndian.PutUint64(value[0:8], hi)
binary.BigEndian.PutUint64(value[8:16], lo)
return value
}
func uint64ToUint(value uint64, field string) (uint, error) {
maxUint := uint64(^uint(0))
if value > maxUint {
@@ -1392,3 +1381,47 @@ func uint64ToUint(value uint64, field string) (uint, error) {
}
return uint(value), nil
}
// GameReportRequestToPayload converts model.GameReportRequest to
// FlatBuffers bytes suitable for the authenticated gateway transport.
func GameReportRequestToPayload(req *model.GameReportRequest) ([]byte, error) {
if req == nil {
return nil, errors.New("encode game report request payload: request is nil")
}
builder := flatbuffers.NewBuilder(64)
fbs.GameReportRequestStart(builder)
hi, lo := uuidToHiLo(req.GameID)
fbs.GameReportRequestAddGameId(builder, commonfbs.CreateUUID(builder, hi, lo))
fbs.GameReportRequestAddTurn(builder, uint32(req.Turn))
offset := fbs.GameReportRequestEnd(builder)
fbs.FinishGameReportRequestBuffer(builder, offset)
return builder.FinishedBytes(), nil
}
// PayloadToGameReportRequest converts FlatBuffers payload bytes into
// model.GameReportRequest.
func PayloadToGameReportRequest(data []byte) (result *model.GameReportRequest, err error) {
if len(data) == 0 {
return nil, errors.New("decode game report request payload: data is empty")
}
defer func() {
if recovered := recover(); recovered != nil {
result = nil
err = fmt.Errorf("decode game report request payload: panic recovered: %v", recovered)
}
}()
req := fbs.GetRootAsGameReportRequest(data, 0)
gameID := req.GameId(nil)
if gameID == nil {
return nil, errors.New("decode game report request payload: game_id is missing")
}
return &model.GameReportRequest{
GameID: uuidFromHiLo(gameID.Hi(), gameID.Lo()),
Turn: uint(req.Turn()),
}, nil
}
pkg/transcoder/report_test.go
+34
View File
@@ -14,6 +14,40 @@ import (
"github.com/google/uuid"
)
func TestGameReportRequestPayloadRoundTrip(t *testing.T) {
t.Parallel()
source := &model.GameReportRequest{
GameID: uuid.MustParse("11111111-2222-3333-4444-555555555555"),
Turn: 42,
}
payload, err := GameReportRequestToPayload(source)
if err != nil {
t.Fatalf("encode game report request: %v", err)
}
decoded, err := PayloadToGameReportRequest(payload)
if err != nil {
t.Fatalf("decode game report request: %v", err)
}
if !reflect.DeepEqual(source, decoded) {
t.Fatalf("round-trip mismatch\nsource: %#v\ndecoded: %#v", source, decoded)
}
}
func TestGameReportRequestRejectsEmptyAndNil(t *testing.T) {
t.Parallel()
if _, err := GameReportRequestToPayload(nil); err == nil {
t.Fatalf("expected error encoding nil request")
}
if _, err := PayloadToGameReportRequest(nil); err == nil {
t.Fatalf("expected error decoding empty payload")
}
}
func TestReportToPayloadAndPayloadToReportRoundTrip(t *testing.T) {
t.Parallel()
pkg/transcoder/user.go
+265
View File
@@ -510,3 +510,268 @@ func recoverUserDecodePanic[T any](message string, result **T, err *error) {
*err = fmt.Errorf("%s: panic recovered: %v", message, recovered)
}
}
// ListMySessionsRequestToPayload converts usermodel.ListMySessionsRequest
// to FlatBuffers bytes suitable for the authenticated gateway transport.
func ListMySessionsRequestToPayload(request *usermodel.ListMySessionsRequest) ([]byte, error) {
if request == nil {
return nil, errors.New("encode list my sessions request payload: request is nil")
}
builder := flatbuffers.NewBuilder(32)
userfbs.ListMySessionsRequestStart(builder)
offset := userfbs.ListMySessionsRequestEnd(builder)
userfbs.FinishListMySessionsRequestBuffer(builder, offset)
return builder.FinishedBytes(), nil
}
// PayloadToListMySessionsRequest converts FlatBuffers payload bytes into
// usermodel.ListMySessionsRequest.
func PayloadToListMySessionsRequest(data []byte) (result *usermodel.ListMySessionsRequest, err error) {
if len(data) == 0 {
return nil, errors.New("decode list my sessions request payload: data is empty")
}
defer recoverUserDecodePanic("decode list my sessions request payload", &result, &err)
_ = userfbs.GetRootAsListMySessionsRequest(data, 0)
return &usermodel.ListMySessionsRequest{}, nil
}
// ListMySessionsResponseToPayload converts usermodel.ListMySessionsResponse
// to FlatBuffers bytes suitable for the authenticated gateway transport.
func ListMySessionsResponseToPayload(response *usermodel.ListMySessionsResponse) ([]byte, error) {
if response == nil {
return nil, errors.New("encode list my sessions response payload: response is nil")
}
builder := flatbuffers.NewBuilder(256)
itemOffsets := make([]flatbuffers.UOffsetT, len(response.Items))
for index := range response.Items {
itemOffsets[index] = encodeDeviceSession(builder, response.Items[index])
}
var itemsVector flatbuffers.UOffsetT
if len(itemOffsets) > 0 {
userfbs.ListMySessionsResponseStartItemsVector(builder, len(itemOffsets))
for index := len(itemOffsets) - 1; index >= 0; index-- {
builder.PrependUOffsetT(itemOffsets[index])
}
itemsVector = builder.EndVector(len(itemOffsets))
}
userfbs.ListMySessionsResponseStart(builder)
if itemsVector != 0 {
userfbs.ListMySessionsResponseAddItems(builder, itemsVector)
}
offset := userfbs.ListMySessionsResponseEnd(builder)
userfbs.FinishListMySessionsResponseBuffer(builder, offset)
return builder.FinishedBytes(), nil
}
// PayloadToListMySessionsResponse converts FlatBuffers payload bytes into
// usermodel.ListMySessionsResponse.
func PayloadToListMySessionsResponse(data []byte) (result *usermodel.ListMySessionsResponse, err error) {
if len(data) == 0 {
return nil, errors.New("decode list my sessions response payload: data is empty")
}
defer recoverUserDecodePanic("decode list my sessions response payload", &result, &err)
response := userfbs.GetRootAsListMySessionsResponse(data, 0)
count := response.ItemsLength()
out := &usermodel.ListMySessionsResponse{
Items: make([]usermodel.DeviceSession, 0, count),
}
view := new(userfbs.DeviceSessionView)
for index := 0; index < count; index++ {
if !response.Items(view, index) {
return nil, fmt.Errorf("decode list my sessions response payload: item %d is missing", index)
}
out.Items = append(out.Items, decodeDeviceSession(view))
}
return out, nil
}
// RevokeMySessionRequestToPayload converts usermodel.RevokeMySessionRequest
// to FlatBuffers bytes suitable for the authenticated gateway transport.
func RevokeMySessionRequestToPayload(request *usermodel.RevokeMySessionRequest) ([]byte, error) {
if request == nil {
return nil, errors.New("encode revoke my session request payload: request is nil")
}
builder := flatbuffers.NewBuilder(64)
deviceSessionID := builder.CreateString(request.DeviceSessionID)
userfbs.RevokeMySessionRequestStart(builder)
userfbs.RevokeMySessionRequestAddDeviceSessionId(builder, deviceSessionID)
offset := userfbs.RevokeMySessionRequestEnd(builder)
userfbs.FinishRevokeMySessionRequestBuffer(builder, offset)
return builder.FinishedBytes(), nil
}
// PayloadToRevokeMySessionRequest converts FlatBuffers payload bytes into
// usermodel.RevokeMySessionRequest.
func PayloadToRevokeMySessionRequest(data []byte) (result *usermodel.RevokeMySessionRequest, err error) {
if len(data) == 0 {
return nil, errors.New("decode revoke my session request payload: data is empty")
}
defer recoverUserDecodePanic("decode revoke my session request payload", &result, &err)
request := userfbs.GetRootAsRevokeMySessionRequest(data, 0)
return &usermodel.RevokeMySessionRequest{
DeviceSessionID: string(request.DeviceSessionId()),
}, nil
}
// RevokeMySessionResponseToPayload converts usermodel.RevokeMySessionResponse
// to FlatBuffers bytes suitable for the authenticated gateway transport.
func RevokeMySessionResponseToPayload(response *usermodel.RevokeMySessionResponse) ([]byte, error) {
if response == nil {
return nil, errors.New("encode revoke my session response payload: response is nil")
}
builder := flatbuffers.NewBuilder(128)
sessionOffset := encodeDeviceSession(builder, response.Session)
userfbs.RevokeMySessionResponseStart(builder)
userfbs.RevokeMySessionResponseAddSession(builder, sessionOffset)
offset := userfbs.RevokeMySessionResponseEnd(builder)
userfbs.FinishRevokeMySessionResponseBuffer(builder, offset)
return builder.FinishedBytes(), nil
}
// PayloadToRevokeMySessionResponse converts FlatBuffers payload bytes into
// usermodel.RevokeMySessionResponse.
func PayloadToRevokeMySessionResponse(data []byte) (result *usermodel.RevokeMySessionResponse, err error) {
if len(data) == 0 {
return nil, errors.New("decode revoke my session response payload: data is empty")
}
defer recoverUserDecodePanic("decode revoke my session response payload", &result, &err)
response := userfbs.GetRootAsRevokeMySessionResponse(data, 0)
view := response.Session(nil)
if view == nil {
return nil, errors.New("decode revoke my session response payload: session is missing")
}
return &usermodel.RevokeMySessionResponse{Session: decodeDeviceSession(view)}, nil
}
// RevokeAllMySessionsRequestToPayload converts
// usermodel.RevokeAllMySessionsRequest to FlatBuffers bytes suitable for
// the authenticated gateway transport.
func RevokeAllMySessionsRequestToPayload(request *usermodel.RevokeAllMySessionsRequest) ([]byte, error) {
if request == nil {
return nil, errors.New("encode revoke all my sessions request payload: request is nil")
}
builder := flatbuffers.NewBuilder(32)
userfbs.RevokeAllMySessionsRequestStart(builder)
offset := userfbs.RevokeAllMySessionsRequestEnd(builder)
userfbs.FinishRevokeAllMySessionsRequestBuffer(builder, offset)
return builder.FinishedBytes(), nil
}
// PayloadToRevokeAllMySessionsRequest converts FlatBuffers payload bytes
// into usermodel.RevokeAllMySessionsRequest.
func PayloadToRevokeAllMySessionsRequest(data []byte) (result *usermodel.RevokeAllMySessionsRequest, err error) {
if len(data) == 0 {
return nil, errors.New("decode revoke all my sessions request payload: data is empty")
}
defer recoverUserDecodePanic("decode revoke all my sessions request payload", &result, &err)
_ = userfbs.GetRootAsRevokeAllMySessionsRequest(data, 0)
return &usermodel.RevokeAllMySessionsRequest{}, nil
}
// RevokeAllMySessionsResponseToPayload converts
// usermodel.RevokeAllMySessionsResponse to FlatBuffers bytes suitable
// for the authenticated gateway transport.
func RevokeAllMySessionsResponseToPayload(response *usermodel.RevokeAllMySessionsResponse) ([]byte, error) {
if response == nil {
return nil, errors.New("encode revoke all my sessions response payload: response is nil")
}
builder := flatbuffers.NewBuilder(64)
userID := builder.CreateString(response.Summary.UserID)
userfbs.DeviceSessionRevocationSummaryViewStart(builder)
userfbs.DeviceSessionRevocationSummaryViewAddUserId(builder, userID)
userfbs.DeviceSessionRevocationSummaryViewAddRevokedCount(builder, int32(response.Summary.RevokedCount))
summaryOffset := userfbs.DeviceSessionRevocationSummaryViewEnd(builder)
userfbs.RevokeAllMySessionsResponseStart(builder)
userfbs.RevokeAllMySessionsResponseAddSummary(builder, summaryOffset)
offset := userfbs.RevokeAllMySessionsResponseEnd(builder)
userfbs.FinishRevokeAllMySessionsResponseBuffer(builder, offset)
return builder.FinishedBytes(), nil
}
// PayloadToRevokeAllMySessionsResponse converts FlatBuffers payload bytes
// into usermodel.RevokeAllMySessionsResponse.
func PayloadToRevokeAllMySessionsResponse(data []byte) (result *usermodel.RevokeAllMySessionsResponse, err error) {
if len(data) == 0 {
return nil, errors.New("decode revoke all my sessions response payload: data is empty")
}
defer recoverUserDecodePanic("decode revoke all my sessions response payload", &result, &err)
response := userfbs.GetRootAsRevokeAllMySessionsResponse(data, 0)
summary := response.Summary(nil)
if summary == nil {
return nil, errors.New("decode revoke all my sessions response payload: summary is missing")
}
return &usermodel.RevokeAllMySessionsResponse{
Summary: usermodel.DeviceSessionRevocationSummary{
UserID: string(summary.UserId()),
RevokedCount: int(summary.RevokedCount()),
},
}, nil
}
func encodeDeviceSession(builder *flatbuffers.Builder, sess usermodel.DeviceSession) flatbuffers.UOffsetT {
deviceSessionID := builder.CreateString(sess.DeviceSessionID)
userID := builder.CreateString(sess.UserID)
status := builder.CreateString(sess.Status)
var clientPublicKey flatbuffers.UOffsetT
if sess.ClientPublicKey != "" {
clientPublicKey = builder.CreateString(sess.ClientPublicKey)
}
userfbs.DeviceSessionViewStart(builder)
userfbs.DeviceSessionViewAddDeviceSessionId(builder, deviceSessionID)
userfbs.DeviceSessionViewAddUserId(builder, userID)
userfbs.DeviceSessionViewAddStatus(builder, status)
if clientPublicKey != 0 {
userfbs.DeviceSessionViewAddClientPublicKey(builder, clientPublicKey)
}
userfbs.DeviceSessionViewAddCreatedAtMs(builder, sess.CreatedAt.UTC().UnixMilli())
if sess.RevokedAt != nil {
userfbs.DeviceSessionViewAddRevokedAtMs(builder, sess.RevokedAt.UTC().UnixMilli())
}
if sess.LastSeenAt != nil {
userfbs.DeviceSessionViewAddLastSeenAtMs(builder, sess.LastSeenAt.UTC().UnixMilli())
}
return userfbs.DeviceSessionViewEnd(builder)
}
func decodeDeviceSession(view *userfbs.DeviceSessionView) usermodel.DeviceSession {
return usermodel.DeviceSession{
DeviceSessionID: string(view.DeviceSessionId()),
UserID: string(view.UserId()),
Status: string(view.Status()),
ClientPublicKey: string(view.ClientPublicKey()),
CreatedAt: time.UnixMilli(view.CreatedAtMs()).UTC(),
RevokedAt: optionalUnixMilli(view.RevokedAtMs()),
LastSeenAt: optionalUnixMilli(view.LastSeenAtMs()),
}
}
pkg/transcoder/user_test.go
+107
View File
@@ -61,6 +61,113 @@ func TestUserRequestPayloadRoundTrips(t *testing.T) {
}
}
func TestUserSessionsPayloadRoundTrips(t *testing.T) {
t.Parallel()
emptyList, err := ListMySessionsRequestToPayload(&usermodel.ListMySessionsRequest{})
if err != nil {
t.Fatalf("encode list-my-sessions request: %v", err)
}
if _, err := PayloadToListMySessionsRequest(emptyList); err != nil {
t.Fatalf("decode list-my-sessions request: %v", err)
}
revokeAll, err := RevokeAllMySessionsRequestToPayload(&usermodel.RevokeAllMySessionsRequest{})
if err != nil {
t.Fatalf("encode revoke-all-my-sessions request: %v", err)
}
if _, err := PayloadToRevokeAllMySessionsRequest(revokeAll); err != nil {
t.Fatalf("decode revoke-all-my-sessions request: %v", err)
}
revokeReq := &usermodel.RevokeMySessionRequest{DeviceSessionID: "device-7c8f"}
revokePayload, err := RevokeMySessionRequestToPayload(revokeReq)
if err != nil {
t.Fatalf("encode revoke-my-session request: %v", err)
}
revokeDecoded, err := PayloadToRevokeMySessionRequest(revokePayload)
if err != nil {
t.Fatalf("decode revoke-my-session request: %v", err)
}
if !reflect.DeepEqual(revokeReq, revokeDecoded) {
t.Fatalf("revoke-my-session request mismatch\nsource: %#v\ndecoded:%#v", revokeReq, revokeDecoded)
}
now := time.Date(2026, time.April, 9, 10, 0, 0, 0, time.UTC)
revokedAt := now.Add(time.Minute)
lastSeenAt := now.Add(time.Second)
listResp := &usermodel.ListMySessionsResponse{
Items: []usermodel.DeviceSession{
{
DeviceSessionID: "ds-1",
UserID: "user-1",
Status: "active",
ClientPublicKey: "AAAAAAAAAAA=",
CreatedAt: now,
LastSeenAt: &lastSeenAt,
},
{
DeviceSessionID: "ds-2",
UserID: "user-1",
Status: "revoked",
CreatedAt: now,
RevokedAt: &revokedAt,
},
},
}
listPayload, err := ListMySessionsResponseToPayload(listResp)
if err != nil {
t.Fatalf("encode list-my-sessions response: %v", err)
}
listDecoded, err := PayloadToListMySessionsResponse(listPayload)
if err != nil {
t.Fatalf("decode list-my-sessions response: %v", err)
}
if !reflect.DeepEqual(listResp, listDecoded) {
t.Fatalf("list-my-sessions response mismatch\nsource: %#v\ndecoded:%#v", listResp, listDecoded)
}
revokeResp := &usermodel.RevokeMySessionResponse{
Session: usermodel.DeviceSession{
DeviceSessionID: "ds-1",
UserID: "user-1",
Status: "revoked",
CreatedAt: now,
RevokedAt: &revokedAt,
},
}
revokeRespPayload, err := RevokeMySessionResponseToPayload(revokeResp)
if err != nil {
t.Fatalf("encode revoke-my-session response: %v", err)
}
revokeRespDecoded, err := PayloadToRevokeMySessionResponse(revokeRespPayload)
if err != nil {
t.Fatalf("decode revoke-my-session response: %v", err)
}
if !reflect.DeepEqual(revokeResp, revokeRespDecoded) {
t.Fatalf("revoke-my-session response mismatch\nsource: %#v\ndecoded:%#v", revokeResp, revokeRespDecoded)
}
revokeAllResp := &usermodel.RevokeAllMySessionsResponse{
Summary: usermodel.DeviceSessionRevocationSummary{
UserID: "user-1",
RevokedCount: 3,
},
}
revokeAllPayload, err := RevokeAllMySessionsResponseToPayload(revokeAllResp)
if err != nil {
t.Fatalf("encode revoke-all-my-sessions response: %v", err)
}
revokeAllDecoded, err := PayloadToRevokeAllMySessionsResponse(revokeAllPayload)
if err != nil {
t.Fatalf("decode revoke-all-my-sessions response: %v", err)
}
if !reflect.DeepEqual(revokeAllResp, revokeAllDecoded) {
t.Fatalf("revoke-all-my-sessions response mismatch\nsource: %#v\ndecoded:%#v", revokeAllResp, revokeAllDecoded)
}
}
func TestAccountResponsePayloadRoundTrip(t *testing.T) {
t.Parallel()
pkg/transcoder/uuid.go
+22
View File
@@ -0,0 +1,22 @@
package transcoder
import (
"encoding/binary"
"github.com/google/uuid"
)
// uuidToHiLo splits a 16-byte UUID into the two big-endian uint64
// halves used by the FlatBuffers `common.UUID` struct (`hi` carries
// bytes 0..7, `lo` carries bytes 8..15).
func uuidToHiLo(value uuid.UUID) (uint64, uint64) {
return binary.BigEndian.Uint64(value[0:8]), binary.BigEndian.Uint64(value[8:16])
}
// uuidFromHiLo reverses uuidToHiLo.
func uuidFromHiLo(hi, lo uint64) uuid.UUID {
var value uuid.UUID
binary.BigEndian.PutUint64(value[0:8], hi)
binary.BigEndian.PutUint64(value[8:16], lo)
return value
}