Lbenedar/Foundry-Scrapping-API
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add init world data

Browse Source
This commit is contained in:
lbenedar
2026-04-08 18:19:20 +03:00
parent e5deb5d76d
commit 468e027418
9 changed files with 464 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files

252
internal/foundry/websocket.go
View File

@@ -3,6 +3,8 @@ package foundry
import (
"context"
"database/sql"
"encoding/json"
"errors"
"fmt"
"log/slog"
"strconv"
@@ -17,19 +19,29 @@ import (
"github.com/gorilla/websocket"
)
//TODO: refactor all code
type TransportCode int
type FoundryMode int
const (
WriterCode = TransportCode(0)
ReaderCode = TransportCode(1)
)
// const (
// SetupMode = FoundryMode(0)
// WorldMode = FoundryMode(1)
// )
// var
const (
RespSessionData = "0"
RespPingCode = "2"
RespSessionId = "40"
RespCreateSessionCode = "42"
RespDataCode = "43"
RespSessionData = "0"
RespPingCode = "2"
RespSessionId = "40"
RespServerChangeCode = "42"
RespDataCode = "43"
ReqPongCode = "3"
ReqCreateSessionCode = "40"
@@ -40,15 +52,15 @@ var RequestCodes = []string{
RespSessionData,
RespPingCode,
RespSessionId,
RespCreateSessionCode,
RespServerChangeCode,
RespDataCode,
}
var CodesRespToReq = map[string]string{
RespSessionData: ReqCreateSessionCode,
RespPingCode: ReqPongCode,
RespCreateSessionCode: ReqDataCode,
//ReqDataCode: RespCreateSessionCode,
RespSessionData: ReqCreateSessionCode,
RespPingCode: ReqPongCode,
RespServerChangeCode: ReqDataCode,
//ReqDataCode: RespServerChangeCode,
}
type webSocketUtil struct {
@@ -56,15 +68,23 @@ type webSocketUtil struct {
currWsId int
isReadReady bool
logger *slog.Logger
config requests.Config
msgMap map[int](chan []byte)
chanMutex sync.Mutex
channels types.Channels
models db_model.Models
chanMutex sync.Mutex
readChan types.ReadChannels
exchangeChan types.ExchangeChannels
models db_model.Models
}
func NewWebSocketUtil() *webSocketUtil {
return &webSocketUtil{currWsId: 0, isReadReady: false, msgMap: make(map[int]chan []byte)}
return &webSocketUtil{
currWsId: 0,
isReadReady: false,
exchangeChan: types.ExchangeChannels{
Msgs: make(map[int]chan []byte),
ProgressMsg: map[string]chan struct{}{},
},
config: requests.Config{SessionID: ""}}
}
func parseCode(msg *string) string {
@@ -100,9 +120,6 @@ func parseWsRespMessage(msg string) (*types.WsMessage, error) {
data := &types.WsMessage{}
data.Code = parseCode(&msg)
if data.Code != RespDataCode {
return data, nil
}
i := len(data.Code)
if i == 0 {
@@ -111,8 +128,11 @@ func parseWsRespMessage(msg string) (*types.WsMessage, error) {
data.Id, i = parseId(&msg, i)
if i == 0 {
return nil, ErrorMsgNotHaveNumber
i = len(data.Code)
}
// if i == 0 {
// return nil, ErrorMsgNotHaveNumber
// }
data.MsgJson = msg[i:]
return data, nil
@@ -125,7 +145,7 @@ func (ws *webSocketUtil) ReceiveMessage(id int) ([]byte, error) {
for {
select {
case msg, ok := <-ws.msgMap[id]:
case msg, ok := <-ws.exchangeChan.Msgs[id]:
if !ok {
time.Sleep(5 * time.Microsecond)
continue
@@ -151,18 +171,18 @@ func (ws *webSocketUtil) closeMsgChannel(id int, timeout time.Duration) bool {
defer ws.chanMutex.Unlock()
ok := true
if _, ok = ws.msgMap[id]; !ok {
if _, ok = ws.exchangeChan.Msgs[id]; !ok {
return false
}
select {
case _, ok = <-ws.msgMap[id]:
case _, ok = <-ws.exchangeChan.Msgs[id]:
if ok {
close(ws.msgMap[id])
delete(ws.msgMap, id)
close(ws.exchangeChan.Msgs[id])
delete(ws.exchangeChan.Msgs, id)
}
default:
close(ws.msgMap[id])
delete(ws.msgMap, id)
close(ws.exchangeChan.Msgs[id])
delete(ws.exchangeChan.Msgs, id)
}
ws.logger.Debug("WS: Channel has been closed\n", "id", id, "timeout", timeout.String())
@@ -196,22 +216,22 @@ func (ws *webSocketUtil) ListenWebSocket() {
for {
_, message, err := ws.wsConn.ReadMessage()
if err != nil {
ws.channels.Err() <- &FoundryError{Type: ReaderCode, Err: err, IsFatal: true}
ws.readChan.Err() <- &FoundryError{Type: ReaderCode, Err: err, IsFatal: true}
return
}
data, err := parseWsRespMessage(string(message))
if err != nil {
ws.channels.Err() <- &FoundryError{Type: ReaderCode, Err: err}
ws.readChan.Err() <- &FoundryError{Type: ReaderCode, Err: err}
continue
}
ws.channels.Msg() <- data
ws.readChan.Msg() <- data
}
}
func (ws *webSocketUtil) ServeWebSocket() {
for {
select {
case message := <-ws.channels.Msg():
case message := <-ws.readChan.Msg():
ws.logger.Debug("WS: Data has been received\n", "msgCode", message.Code)
switch message.Code {
@@ -219,19 +239,25 @@ func (ws *webSocketUtil) ServeWebSocket() {
err := ws.sendOnlyCodeRequest(message.Code)
if err != nil {
ws.isReadReady = false
ws.channels.Err() <- &FoundryError{Type: WriterCode, Err: err}
ws.readChan.Err() <- &FoundryError{Type: WriterCode, Err: err}
continue
}
case RespCreateSessionCode:
case RespServerChangeCode:
ws.isReadReady = true
go ws.GetInitialData()
dataType, data, err := ws.SplitToTypeAndData([]byte(message.MsgJson))
if err != nil {
ws.readChan.Err() <- &FoundryError{Type: WriterCode, Err: err}
continue
}
// ws.logger.Debug("Parsed server change message", "dataType", dataType, "data", data)
ws.ProcessAction(dataType, data)
case RespDataCode:
ws.msgMap[message.Id] = make(chan []byte, 1)
ws.msgMap[message.Id] <- []byte(message.MsgJson)
ws.exchangeChan.Msgs[message.Id] = make(chan []byte, 1)
ws.exchangeChan.Msgs[message.Id] <- []byte(message.MsgJson)
go ws.closeMsgChannel(message.Id, 5*time.Second)
default:
}
case <-ws.channels.Done():
case <-ws.readChan.Done():
return
}
}
@@ -273,26 +299,170 @@ func (ws *webSocketUtil) InsertJsonDataToDB(statePath string) error {
}
func (ws *webSocketUtil) GetInitialData() {
err := ws.InitSetupData()
if err != nil {
ws.readChan.Err() <- &FoundryError{Type: WriterCode, Err: err}
return
}
idState, err := ws.models.FoundryState.GetIdByType(db_model.SetupState)
if err != nil {
ws.readChan.Err() <- &FoundryError{Type: WriterCode, Err: err}
return
}
ws.logger.Debug("Id state", "id", idState)
err = ws.InitWorldsData(idState)
if err != nil {
ws.readChan.Err() <- &FoundryError{Type: WriterCode, Err: err}
return
}
}
func (ws *webSocketUtil) InitSetupData() error {
ws.models.FoundryState.DeleteAll()
ws.models.FoundryState.DeleteAllSeq()
for k := range requests.PathToSetupState {
err := ws.InsertJsonDataToDB(k)
if err != nil {
ws.channels.Err() <- &FoundryError{Type: WriterCode, Err: err}
break
return err
}
}
// for k := range requests.PathToWorldState {
return nil
}
// }
func (ws *webSocketUtil) InitWorldsData(idState int64) error {
worlds, err := ws.models.FoundryState.GetWorlds(idState)
if err != nil {
return err
}
ws.logger.Debug("Worlds", "len", len(worlds))
for i := range worlds {
worldName := worlds[i].TextId
ws.InitWorldData(worldName)
_, err = ws.config.PostReturnToSetup()
if err != nil {
return err
}
}
return nil
}
func (ws *webSocketUtil) InitWorldData(worldName string) error {
ws.logger.Debug("World name", "name", worldName)
err := ws.LaunchWorld(worldName)
if err != nil {
return err
}
for k := range requests.PathToWorldState {
err := ws.InsertJsonDataToDB(k)
if err != nil {
return err
}
}
return nil
}
func (ws *webSocketUtil) LaunchWorld(worldName string) error {
resp, err := ws.config.PostLaunchWorld(worldName)
if err != nil {
return err
}
if resp.StatusCode != 200 {
return errors.New("World is not found")
}
ws.exchangeChan.ProgressMsg[worldName] = make(chan struct{})
ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
defer cancel()
select {
case <-ws.exchangeChan.ProgressMsg[worldName]:
ws.logger.Debug("World has been started(from GetInitialData)", "world", worldName)
case <-ctx.Done():
close(ws.exchangeChan.ProgressMsg[worldName])
err := ctx.Err()
if err != nil {
return err
}
return ErrorTimeout
}
return nil
}
func (ws *webSocketUtil) CreateNewDataModels(db *sql.DB) {
ws.models = db_model.NewModels(db)
}
func (ws *webSocketUtil) SplitToTypeAndData(dataJson []byte) (string, any, error) {
var rawItems []json.RawMessage
err := json.Unmarshal(dataJson, &rawItems)
if err != nil {
return "", nil, err
}
var dataType string
err = json.Unmarshal(rawItems[0], &dataType)
if err != nil {
return "", nil, err
}
var data map[string]any
err = json.Unmarshal(rawItems[1], &data)
if err != nil {
return "", nil, err
}
actionDataPtr := types.GetWsMsgAction(dataType)
if actionDataPtr == nil {
return dataType, nil, nil
}
err = types.FillStruct(data, actionDataPtr)
if err != nil {
return "", nil, err
}
return dataType, actionDataPtr, nil
}
func (ws *webSocketUtil) ProcessAction(dataType string, data any) {
switch tp := data.(type) {
case *types.WsSessionMsg:
ws.ProcessSessionAction(tp)
case *types.WsProgressMsg:
ws.ProcessProgressAction(tp)
case *types.WsShutdownMsg:
ws.ProcessShutdownAction(tp)
default:
ws.logger.Debug("default")
}
}
func (ws *webSocketUtil) ProcessSessionAction(data *types.WsSessionMsg) {
ws.logger.Debug("ProcessSessionAction", "data", data)
go ws.GetInitialData()
}
func (ws *webSocketUtil) ProcessProgressAction(data *types.WsProgressMsg) {
if !data.HasChanged {
ws.logger.Debug("World has been launched", "world", data.Id)
select {
case <-ws.exchangeChan.ProgressMsg[data.Id]:
ws.logger.Warn("Channel for the world is closed", "world", data.Id)
default:
close(ws.exchangeChan.ProgressMsg[data.Id])
}
}
}
func (ws *webSocketUtil) ProcessShutdownAction(data *types.WsShutdownMsg) {
ws.logger.Debug("ProcessShutdownAction", "data", data)
}
func (ws *webSocketUtil) CreateWSMessageByPage(page string) *types.WsMessage {
msgToSend := &types.WsMessage{Code: CodesRespToReq[RespCreateSessionCode], Id: ws.currWsId, MsgJson: fmt.Sprintf("[\"%s\"]", requests.WsTypeData[page])}
msgToSend := &types.WsMessage{Code: CodesRespToReq[RespServerChangeCode], Id: ws.currWsId, MsgJson: fmt.Sprintf("[\"%s\"]", requests.WsTypeData[page])}
ws.currWsId++
ws.logger.Debug("WS: Data to send\n", "msgToSend", msgToSend.ToString())