refactor foundry lib structure; add transport classes for db,http,websocket; add action interface instead of multiple function that accepts action classes; add changing foundry status on websocket responses

internal/foundry/transport/db.go

@@ -0,0 +1,98 @@
+package transport
+
+import (
+	"gitea.local.lab/Lbenedar/foundry_helper_service/internal/foundry/models/db"
+	"gitea.local.lab/Lbenedar/foundry_helper_service/internal/foundry/models/json"
+	"gitea.local.lab/Lbenedar/foundry_helper_service/internal/foundry/requests"
+	"gitea.local.lab/Lbenedar/foundry_helper_service/internal/foundry/types"
+)
+
+func (tr *FoundryTransport) FillDBWithFoundryData() {
+	err := tr.InitSetupData()
+	if err != nil {
+		tr.ReadChan.Err() <- &types.FoundryError{Direction: types.WriterCode, Err: err, Type: types.DbCode}
+		return
+	}
+
+	idState, err := tr.Models.FoundryState.GetIdByType(db.SetupState)
+	if err != nil {
+		tr.ReadChan.Err() <- &types.FoundryError{Direction: types.WriterCode, Err: err, Type: types.DbCode}
+		return
+	}
+
+	err = tr.InitWorldsData(idState)
+	if err != nil {
+		tr.ReadChan.Err() <- &types.FoundryError{Direction: types.WriterCode, Err: err, Type: types.DbCode}
+		return
+	}
+}
+
+func (tr *FoundryTransport) InitSetupData() error {
+	tr.Models.FoundryState.DeleteAll()
+	tr.Models.FoundryState.DeleteAllSeq()
+	for k := range requests.PathToSetupState {
+		err := tr.InsertJsonDataToDB(k)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (tr *FoundryTransport) InsertJsonDataToDB(statePath string) error {
+	_, ok1 := requests.PathToSetupState[statePath]
+	_, ok2 := requests.PathToWorldState[statePath]
+	if !ok1 && !ok2 {
+		return ErrorStateTypeNotExist
+	}
+
+	msgJson, err := tr.GetJsonData(statePath)
+	if err != nil {
+		return err
+	}
+
+	foundryStateJson, err := json.ParseSetupModel(msgJson)
+	if err != nil {
+		return err
+	}
+
+	foundryStateDb := foundryStateJson.GetFoundryStateDB(requests.PathToSetupState[statePath])
+	err = tr.Models.FoundryState.Insert(foundryStateDb)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (tr *FoundryTransport) InitWorldsData(idState int64) error {
+	worlds, err := tr.Models.FoundryState.GetWorlds(idState)
+	if err != nil {
+		return err
+	}
+	tr.Logger.Debug("Worlds", "len", len(worlds))
+
+	for i := range worlds {
+		worldName := worlds[i].TextId
+		tr.InitWorldData(worldName)
+		_, err = tr.Http.PostReturnToSetup()
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (tr *FoundryTransport) InitWorldData(worldName string) error {
+	tr.Logger.Debug("World name", "name", worldName)
+	err := tr.LaunchWorld(worldName)
+	if err != nil {
+		return err
+	}
+	for k := range requests.PathToWorldState {
+		err := tr.InsertJsonDataToDB(k)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

internal/foundry/transport/errors.go

@@ -0,0 +1,11 @@
+package transport
+
+import "errors"
+
+var (
+	ErrorNotAuth           = errors.New("Admin is not authenticated")
+	ErrorIsNotReady        = errors.New("Connection is not ready for communication")
+	ErrorTimeout           = errors.New("Answer has not been received after timeout")
+	ErrorStateTypeNotExist = errors.New("State type does not exists")
+	ErrorAuthPassWrong     = errors.New("Authentication password is wrong")
+)

internal/foundry/transport/http.go

@@ -0,0 +1,101 @@
+package transport
+
+import (
+	"context"
+	"errors"
+	"io"
+	"strconv"
+	"strings"
+	"time"
+)
+
+func (tr *FoundryTransport) LaunchWorld(worldName string) error {
+	resp, err := tr.Http.PostLaunchWorld(worldName)
+	if err != nil {
+		return err
+	}
+	if resp.StatusCode != 200 {
+		return errors.New("World is not found")
+	}
+
+	tr.ExchangeChan.ProgressMsg[worldName] = make(chan struct{})
+	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
+	defer cancel()
+
+	select {
+	case <-tr.ExchangeChan.ProgressMsg[worldName]:
+		tr.Logger.Debug("World has been started(from GetInitialData)", "world", worldName)
+	case <-ctx.Done():
+		close(tr.ExchangeChan.ProgressMsg[worldName])
+		err := ctx.Err()
+		if err != nil {
+			return err
+		}
+		return ErrorTimeout
+	}
+	return nil
+}
+
+func (tr *FoundryTransport) ConnectToFoundry() error {
+	var err error
+
+	ok, err := tr.Http.GetSessionToken()
+	if err != nil {
+		return err
+	}
+
+	if tr.Http.Password != "" && !ok {
+		err := tr.Authenticate()
+		if err != nil {
+			return err
+		}
+	}
+
+	tr.Logger.Info("Successefully connected to Foundry", "host", tr.Http.Host)
+	return nil
+}
+
+func (tr *FoundryTransport) Authenticate() error {
+	if tr.Http.SessionID == "" {
+		err := tr.Http.GetSessionId()
+		if err != nil {
+			return err
+		}
+	}
+
+	resp, err := tr.Http.PostAuthenticationData()
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	contentLen, err := strconv.Atoi(resp.Header.Get("Content-Length"))
+	if err != nil {
+		return err
+	}
+
+	return tr.CheckAuthRespAnswer(resp.Body, contentLen)
+}
+
+func (tr *FoundryTransport) CheckAuthRespAnswer(r io.Reader, respLength int) error {
+	authBody := make([]byte, respLength)
+
+	_, err := r.Read(authBody)
+	if err != nil && err != io.EOF {
+		return err
+	}
+
+	if !strings.Contains(string(authBody), "Admin authentication successful") {
+		return ErrorAuthPassWrong
+	}
+	tr.IsAuth = true
+	return nil
+}
+
+func (tr *FoundryTransport) HasSessionId() bool {
+	return tr.Http.SessionID != ""
+}
+
+func (tr *FoundryTransport) InitSessionId() error {
+	return tr.Http.GetSessionId()
+}

internal/foundry/transport/transport.go

@@ -0,0 +1,71 @@
+package transport
+
+import (
+	"database/sql"
+	"log/slog"
+	"sync"
+	"time"
+
+	"gitea.local.lab/Lbenedar/foundry_helper_service/internal/foundry/models/db"
+	"gitea.local.lab/Lbenedar/foundry_helper_service/internal/foundry/requests"
+	"gitea.local.lab/Lbenedar/foundry_helper_service/internal/foundry/types"
+	"github.com/gorilla/websocket"
+)
+
+type FoundryTransport struct {
+	WsConn       *websocket.Conn
+	CurrWsId     int
+	ChanMutex    sync.Mutex
+	ReadChan     types.ReadChannels
+	ExchangeChan types.ExchangeChannels
+
+	Http   requests.FoundryHttpRequest
+	IsAuth bool
+
+	Models   *db.Models
+	IsDbInit bool
+
+	Logger *slog.Logger
+}
+
+func NewFoundryTransport(dbConn *sql.DB, logger *slog.Logger, httpConfig *requests.FoundryHttpRequest) *FoundryTransport {
+	return &FoundryTransport{
+		CurrWsId: 0,
+		ExchangeChan: types.ExchangeChannels{
+			Msgs:        make(map[int]chan []byte),
+			ProgressMsg: map[string]chan struct{}{},
+		},
+
+		Http:   *httpConfig,
+		IsAuth: false,
+
+		Models:   db.NewModels(dbConn),
+		IsDbInit: false,
+
+		Logger: logger,
+	}
+}
+
+func (t *FoundryTransport) CloseMsgChannel(id int, timeout time.Duration) bool {
+	time.Sleep(timeout)
+
+	t.ChanMutex.Lock()
+	defer t.ChanMutex.Unlock()
+
+	ok := true
+	if _, ok = t.ExchangeChan.Msgs[id]; !ok {
+		return false
+	}
+	select {
+	case _, ok = <-t.ExchangeChan.Msgs[id]:
+		if ok {
+			close(t.ExchangeChan.Msgs[id])
+			delete(t.ExchangeChan.Msgs, id)
+		}
+	default:
+		close(t.ExchangeChan.Msgs[id])
+		delete(t.ExchangeChan.Msgs, id)
+	}
+
+	return ok
+}

internal/foundry/transport/websocket.go

@@ -0,0 +1,111 @@
+package transport
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+	"time"
+
+	"gitea.local.lab/Lbenedar/foundry_helper_service/internal/foundry/requests"
+	"gitea.local.lab/Lbenedar/foundry_helper_service/internal/foundry/types"
+	"github.com/gorilla/websocket"
+)
+
+func (tr *FoundryTransport) InitWebSocketConnection() error {
+	if !tr.IsAuth {
+		return ErrorNotAuth
+	}
+
+	query := url.Values{}
+	query.Add("session", tr.Http.SessionID)
+	query.Add("EIO", "4")
+	query.Add("transport", "websocket")
+
+	u := url.URL{Scheme: "ws", Host: tr.Http.Host, Path: fmt.Sprintf("%s/", requests.SocketPath), RawQuery: query.Encode()}
+
+	wsHeader := http.Header{}
+	wsHeader.Set("Cookie", fmt.Sprintf("session=%s", tr.Http.SessionID))
+
+	wsConn, _, err := websocket.DefaultDialer.Dial(u.String(), wsHeader)
+	if err != nil {
+		return err
+	}
+
+	tr.WsConn = wsConn
+	tr.CurrWsId = 0
+	tr.Logger.Info("Successefully connected to Foundry Websocket")
+	return nil
+}
+
+func (tr *FoundryTransport) HandleWebsocketRequest(msg *types.WsMessage) ([]byte, error) {
+	err := tr.WsConn.WriteMessage(websocket.TextMessage, msg.ToByteSlice())
+	if err != nil {
+		return nil, err
+	}
+
+	data, err := tr.ReceiveMessage(msg.Id)
+	if err != nil {
+		return nil, err
+	}
+	return data, nil
+}
+
+func (tr *FoundryTransport) ReceiveMessage(id int) ([]byte, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	for {
+		select {
+		case msg, ok := <-tr.ExchangeChan.Msgs[id]:
+			if !ok {
+				time.Sleep(5 * time.Microsecond)
+				continue
+			}
+			tr.CloseMsgChannel(id, 0)
+			return msg, nil
+		case <-ctx.Done():
+			err := ctx.Err()
+			if err != nil {
+				return nil, err
+			}
+			return nil, ErrorTimeout
+		default:
+			time.Sleep(5 * time.Microsecond)
+		}
+	}
+}
+
+func (tr *FoundryTransport) ListenWebSocket() {
+	for {
+		_, message, err := tr.WsConn.ReadMessage()
+		if err != nil {
+			tr.ReadChan.Err() <- &types.FoundryError{Direction: types.ReaderCode, Err: err, Type: types.WebSocketCode}
+			return
+		}
+		data, err := types.ParseWsRespMessage(string(message), types.RequestCodes)
+		if err != nil {
+			tr.ReadChan.Err() <- &types.FoundryError{Direction: types.ReaderCode, Err: err, Type: types.WebSocketCode}
+			continue
+		}
+		tr.ReadChan.Msg() <- data
+	}
+}
+
+func (tr *FoundryTransport) SendOnlyCodeRequest(code string) error {
+	tr.Logger.Debug("WS: Data has been send\n", "msg", types.CodesRespToReq[code])
+
+	return tr.WsConn.WriteMessage(websocket.TextMessage, []byte(types.CodesRespToReq[code]))
+}
+
+func (tr *FoundryTransport) GetJsonData(stateType string) ([]byte, error) {
+	msg := types.NewWsMessageByPage(stateType, tr.CurrWsId)
+	tr.CurrWsId++
+
+	return tr.HandleWebsocketRequest(msg)
+}
+
+func (tr *FoundryTransport) CloseWebSocketConn() {
+	tr.Logger.Debug("Websocket has been closed")
+	tr.WsConn.Close()
+}