feat: runtime manager
This commit is contained in:
Ilia Denisov
@@ -0,0 +1,256 @@
|
||||
package transcoder
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
lobbymodel "galaxy/model/lobby"
|
||||
lobbyfbs "galaxy/schema/fbs/lobby"
|
||||
|
||||
flatbuffers "github.com/google/flatbuffers/go"
|
||||
)
|
||||
|
||||
// MyGamesListRequestToPayload converts a typed lobbymodel.MyGamesListRequest
|
||||
// to FlatBuffers bytes suitable for the authenticated gateway transport.
|
||||
func MyGamesListRequestToPayload(request *lobbymodel.MyGamesListRequest) ([]byte, error) {
|
||||
if request == nil {
|
||||
return nil, errors.New("encode my games list request payload: request is nil")
|
||||
}
|
||||
|
||||
builder := flatbuffers.NewBuilder(32)
|
||||
lobbyfbs.MyGamesListRequestStart(builder)
|
||||
offset := lobbyfbs.MyGamesListRequestEnd(builder)
|
||||
lobbyfbs.FinishMyGamesListRequestBuffer(builder, offset)
|
||||
|
||||
return builder.FinishedBytes(), nil
|
||||
}
|
||||
|
||||
// PayloadToMyGamesListRequest converts FlatBuffers payload bytes into
|
||||
// lobbymodel.MyGamesListRequest.
|
||||
func PayloadToMyGamesListRequest(data []byte) (result *lobbymodel.MyGamesListRequest, err error) {
|
||||
if len(data) == 0 {
|
||||
return nil, errors.New("decode my games list request payload: data is empty")
|
||||
}
|
||||
|
||||
defer recoverLobbyDecodePanic("decode my games list request payload", &result, &err)
|
||||
|
||||
_ = lobbyfbs.GetRootAsMyGamesListRequest(data, 0)
|
||||
return &lobbymodel.MyGamesListRequest{}, nil
|
||||
}
|
||||
|
||||
// MyGamesListResponseToPayload converts lobbymodel.MyGamesListResponse to
|
||||
// FlatBuffers bytes suitable for the authenticated gateway transport.
|
||||
func MyGamesListResponseToPayload(response *lobbymodel.MyGamesListResponse) ([]byte, error) {
|
||||
if response == nil {
|
||||
return nil, errors.New("encode my games list response payload: response is nil")
|
||||
}
|
||||
|
||||
builder := flatbuffers.NewBuilder(512)
|
||||
|
||||
itemOffsets := make([]flatbuffers.UOffsetT, len(response.Items))
|
||||
for index := range response.Items {
|
||||
itemOffsets[index] = encodeGameSummary(builder, response.Items[index])
|
||||
}
|
||||
|
||||
var itemsVector flatbuffers.UOffsetT
|
||||
if len(itemOffsets) > 0 {
|
||||
lobbyfbs.MyGamesListResponseStartItemsVector(builder, len(itemOffsets))
|
||||
for index := len(itemOffsets) - 1; index >= 0; index-- {
|
||||
builder.PrependUOffsetT(itemOffsets[index])
|
||||
}
|
||||
itemsVector = builder.EndVector(len(itemOffsets))
|
||||
}
|
||||
|
||||
lobbyfbs.MyGamesListResponseStart(builder)
|
||||
if itemsVector != 0 {
|
||||
lobbyfbs.MyGamesListResponseAddItems(builder, itemsVector)
|
||||
}
|
||||
offset := lobbyfbs.MyGamesListResponseEnd(builder)
|
||||
lobbyfbs.FinishMyGamesListResponseBuffer(builder, offset)
|
||||
|
||||
return builder.FinishedBytes(), nil
|
||||
}
|
||||
|
||||
// PayloadToMyGamesListResponse converts FlatBuffers payload bytes into
|
||||
// lobbymodel.MyGamesListResponse.
|
||||
func PayloadToMyGamesListResponse(data []byte) (result *lobbymodel.MyGamesListResponse, err error) {
|
||||
if len(data) == 0 {
|
||||
return nil, errors.New("decode my games list response payload: data is empty")
|
||||
}
|
||||
|
||||
defer recoverLobbyDecodePanic("decode my games list response payload", &result, &err)
|
||||
|
||||
response := lobbyfbs.GetRootAsMyGamesListResponse(data, 0)
|
||||
out := &lobbymodel.MyGamesListResponse{
|
||||
Items: make([]lobbymodel.GameSummary, 0, response.ItemsLength()),
|
||||
}
|
||||
|
||||
summary := new(lobbyfbs.GameSummary)
|
||||
for index := 0; index < response.ItemsLength(); index++ {
|
||||
if !response.Items(summary, index) {
|
||||
return nil, fmt.Errorf("decode my games list response payload: items[%d] is missing", index)
|
||||
}
|
||||
out.Items = append(out.Items, decodeGameSummary(summary))
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// OpenEnrollmentRequestToPayload converts lobbymodel.OpenEnrollmentRequest to
|
||||
// FlatBuffers bytes suitable for the authenticated gateway transport.
|
||||
func OpenEnrollmentRequestToPayload(request *lobbymodel.OpenEnrollmentRequest) ([]byte, error) {
|
||||
if request == nil {
|
||||
return nil, errors.New("encode open enrollment request payload: request is nil")
|
||||
}
|
||||
|
||||
builder := flatbuffers.NewBuilder(64)
|
||||
gameID := builder.CreateString(request.GameID)
|
||||
|
||||
lobbyfbs.OpenEnrollmentRequestStart(builder)
|
||||
lobbyfbs.OpenEnrollmentRequestAddGameId(builder, gameID)
|
||||
offset := lobbyfbs.OpenEnrollmentRequestEnd(builder)
|
||||
lobbyfbs.FinishOpenEnrollmentRequestBuffer(builder, offset)
|
||||
|
||||
return builder.FinishedBytes(), nil
|
||||
}
|
||||
|
||||
// PayloadToOpenEnrollmentRequest converts FlatBuffers payload bytes into
|
||||
// lobbymodel.OpenEnrollmentRequest.
|
||||
func PayloadToOpenEnrollmentRequest(data []byte) (result *lobbymodel.OpenEnrollmentRequest, err error) {
|
||||
if len(data) == 0 {
|
||||
return nil, errors.New("decode open enrollment request payload: data is empty")
|
||||
}
|
||||
|
||||
defer recoverLobbyDecodePanic("decode open enrollment request payload", &result, &err)
|
||||
|
||||
request := lobbyfbs.GetRootAsOpenEnrollmentRequest(data, 0)
|
||||
return &lobbymodel.OpenEnrollmentRequest{
|
||||
GameID: string(request.GameId()),
|
||||
}, nil
|
||||
}
|
||||
|
||||
// OpenEnrollmentResponseToPayload converts lobbymodel.OpenEnrollmentResponse to
|
||||
// FlatBuffers bytes suitable for the authenticated gateway transport.
|
||||
func OpenEnrollmentResponseToPayload(response *lobbymodel.OpenEnrollmentResponse) ([]byte, error) {
|
||||
if response == nil {
|
||||
return nil, errors.New("encode open enrollment response payload: response is nil")
|
||||
}
|
||||
|
||||
builder := flatbuffers.NewBuilder(64)
|
||||
gameID := builder.CreateString(response.GameID)
|
||||
status := builder.CreateString(response.Status)
|
||||
|
||||
lobbyfbs.OpenEnrollmentResponseStart(builder)
|
||||
lobbyfbs.OpenEnrollmentResponseAddGameId(builder, gameID)
|
||||
lobbyfbs.OpenEnrollmentResponseAddStatus(builder, status)
|
||||
offset := lobbyfbs.OpenEnrollmentResponseEnd(builder)
|
||||
lobbyfbs.FinishOpenEnrollmentResponseBuffer(builder, offset)
|
||||
|
||||
return builder.FinishedBytes(), nil
|
||||
}
|
||||
|
||||
// PayloadToOpenEnrollmentResponse converts FlatBuffers payload bytes into
|
||||
// lobbymodel.OpenEnrollmentResponse.
|
||||
func PayloadToOpenEnrollmentResponse(data []byte) (result *lobbymodel.OpenEnrollmentResponse, err error) {
|
||||
if len(data) == 0 {
|
||||
return nil, errors.New("decode open enrollment response payload: data is empty")
|
||||
}
|
||||
|
||||
defer recoverLobbyDecodePanic("decode open enrollment response payload", &result, &err)
|
||||
|
||||
response := lobbyfbs.GetRootAsOpenEnrollmentResponse(data, 0)
|
||||
return &lobbymodel.OpenEnrollmentResponse{
|
||||
GameID: string(response.GameId()),
|
||||
Status: string(response.Status()),
|
||||
}, nil
|
||||
}
|
||||
|
||||
// LobbyErrorResponseToPayload converts lobbymodel.ErrorResponse to FlatBuffers
|
||||
// bytes suitable for the authenticated gateway transport.
|
||||
func LobbyErrorResponseToPayload(response *lobbymodel.ErrorResponse) ([]byte, error) {
|
||||
if response == nil {
|
||||
return nil, errors.New("encode lobby error response payload: response is nil")
|
||||
}
|
||||
|
||||
builder := flatbuffers.NewBuilder(128)
|
||||
code := builder.CreateString(response.Error.Code)
|
||||
message := builder.CreateString(response.Error.Message)
|
||||
|
||||
lobbyfbs.ErrorBodyStart(builder)
|
||||
lobbyfbs.ErrorBodyAddCode(builder, code)
|
||||
lobbyfbs.ErrorBodyAddMessage(builder, message)
|
||||
errorOffset := lobbyfbs.ErrorBodyEnd(builder)
|
||||
|
||||
lobbyfbs.ErrorResponseStart(builder)
|
||||
lobbyfbs.ErrorResponseAddError(builder, errorOffset)
|
||||
offset := lobbyfbs.ErrorResponseEnd(builder)
|
||||
lobbyfbs.FinishErrorResponseBuffer(builder, offset)
|
||||
|
||||
return builder.FinishedBytes(), nil
|
||||
}
|
||||
|
||||
// PayloadToLobbyErrorResponse converts FlatBuffers payload bytes into
|
||||
// lobbymodel.ErrorResponse.
|
||||
func PayloadToLobbyErrorResponse(data []byte) (result *lobbymodel.ErrorResponse, err error) {
|
||||
if len(data) == 0 {
|
||||
return nil, errors.New("decode lobby error response payload: data is empty")
|
||||
}
|
||||
|
||||
defer recoverLobbyDecodePanic("decode lobby error response payload", &result, &err)
|
||||
|
||||
response := lobbyfbs.GetRootAsErrorResponse(data, 0)
|
||||
body := response.Error(nil)
|
||||
if body == nil {
|
||||
return nil, errors.New("decode lobby error response payload: error is missing")
|
||||
}
|
||||
|
||||
return &lobbymodel.ErrorResponse{
|
||||
Error: lobbymodel.ErrorBody{
|
||||
Code: string(body.Code()),
|
||||
Message: string(body.Message()),
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
|
||||
func encodeGameSummary(builder *flatbuffers.Builder, summary lobbymodel.GameSummary) flatbuffers.UOffsetT {
|
||||
gameID := builder.CreateString(summary.GameID)
|
||||
gameName := builder.CreateString(summary.GameName)
|
||||
gameType := builder.CreateString(summary.GameType)
|
||||
status := builder.CreateString(summary.Status)
|
||||
ownerUserID := builder.CreateString(summary.OwnerUserID)
|
||||
|
||||
lobbyfbs.GameSummaryStart(builder)
|
||||
lobbyfbs.GameSummaryAddGameId(builder, gameID)
|
||||
lobbyfbs.GameSummaryAddGameName(builder, gameName)
|
||||
lobbyfbs.GameSummaryAddGameType(builder, gameType)
|
||||
lobbyfbs.GameSummaryAddStatus(builder, status)
|
||||
lobbyfbs.GameSummaryAddOwnerUserId(builder, ownerUserID)
|
||||
lobbyfbs.GameSummaryAddMinPlayers(builder, int32(summary.MinPlayers))
|
||||
lobbyfbs.GameSummaryAddMaxPlayers(builder, int32(summary.MaxPlayers))
|
||||
lobbyfbs.GameSummaryAddEnrollmentEndsAtMs(builder, summary.EnrollmentEndsAt.UTC().UnixMilli())
|
||||
lobbyfbs.GameSummaryAddCreatedAtMs(builder, summary.CreatedAt.UTC().UnixMilli())
|
||||
lobbyfbs.GameSummaryAddUpdatedAtMs(builder, summary.UpdatedAt.UTC().UnixMilli())
|
||||
return lobbyfbs.GameSummaryEnd(builder)
|
||||
}
|
||||
|
||||
func decodeGameSummary(summary *lobbyfbs.GameSummary) lobbymodel.GameSummary {
|
||||
return lobbymodel.GameSummary{
|
||||
GameID: string(summary.GameId()),
|
||||
GameName: string(summary.GameName()),
|
||||
GameType: string(summary.GameType()),
|
||||
Status: string(summary.Status()),
|
||||
OwnerUserID: string(summary.OwnerUserId()),
|
||||
MinPlayers: int(summary.MinPlayers()),
|
||||
MaxPlayers: int(summary.MaxPlayers()),
|
||||
EnrollmentEndsAt: time.UnixMilli(summary.EnrollmentEndsAtMs()).UTC(),
|
||||
CreatedAt: time.UnixMilli(summary.CreatedAtMs()).UTC(),
|
||||
UpdatedAt: time.UnixMilli(summary.UpdatedAtMs()).UTC(),
|
||||
}
|
||||
}
|
||||
|
||||
func recoverLobbyDecodePanic[T any](message string, result **T, err *error) {
|
||||
if recovered := recover(); recovered != nil {
|
||||
*result = nil
|
||||
*err = fmt.Errorf("%s: panic recovered: %v", message, recovered)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user