feature: Adds backend system and basic API.

This adds the backend API, as well as backend infrastructure, including
autostarting and basic communication between the Goroutine + Application.

backend/api/controllers/v1/backends/create.go

@@ -0,0 +1,271 @@
+package backends
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"git.terah.dev/imterah/hermes/api/backendruntime"
+	"git.terah.dev/imterah/hermes/api/dbcore"
+	"git.terah.dev/imterah/hermes/api/jwtcore"
+	"git.terah.dev/imterah/hermes/api/permissions"
+	"git.terah.dev/imterah/hermes/commonbackend"
+	"github.com/charmbracelet/log"
+	"github.com/gin-gonic/gin"
+	"github.com/go-playground/validator/v10"
+)
+
+type BackendCreationRequest struct {
+	Token             string `validate:"required"`
+	Name              string `validate:"required"`
+	Description       *string
+	Backend           string      `validate:"required"`
+	BackendParameters interface{} `json:"connectionDetails" validate:"required"`
+}
+
+func CreateBackend(c *gin.Context) {
+	var req BackendCreationRequest
+
+	if err := c.BindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{
+			"error": fmt.Sprintf("Failed to parse body: %s", err.Error()),
+		})
+
+		return
+	}
+
+	if err := validator.New().Struct(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{
+			"error": fmt.Sprintf("Failed to validate body: %s", err.Error()),
+		})
+
+		return
+	}
+
+	user, err := jwtcore.GetUserFromJWT(req.Token)
+
+	if err != nil {
+		if err.Error() == "token is expired" || err.Error() == "user does not exist" {
+			c.JSON(http.StatusForbidden, gin.H{
+				"error": err.Error(),
+			})
+
+			return
+		} else {
+			log.Warnf("Failed to get user from the provided JWT token: %s", err.Error())
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Failed to parse token",
+			})
+
+			return
+		}
+	}
+
+	if !permissions.UserHasPermission(user, "backends.add") {
+		c.JSON(http.StatusForbidden, gin.H{
+			"error": "Missing permissions",
+		})
+
+		return
+	}
+
+	var backendParameters []byte
+
+	switch parameters := req.BackendParameters.(type) {
+	case string:
+		backendParameters = []byte(parameters)
+	case map[string]interface{}:
+		backendParameters, err = json.Marshal(parameters)
+
+		if err != nil {
+			log.Warnf("Failed to marshal JSON recieved as BackendParameters: %s", err.Error())
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Failed to prepare parameters",
+			})
+
+			return
+		}
+	default:
+		c.JSON(http.StatusBadRequest, gin.H{
+			"error": fmt.Sprintf("Invalid type for connectionDetails (recieved %T)", parameters),
+		})
+
+		return
+	}
+
+	var backendRuntimeFilePath string
+
+	for _, runtime := range backendruntime.AvailableBackends {
+		if runtime.Name == req.Backend {
+			backendRuntimeFilePath = runtime.Path
+		}
+	}
+
+	if backendRuntimeFilePath == "" {
+		c.JSON(http.StatusBadRequest, gin.H{
+			"error": "Unsupported backend recieved",
+		})
+
+		return
+	}
+
+	backend := backendruntime.NewBackend(backendRuntimeFilePath)
+	err = backend.Start()
+
+	if err != nil {
+		log.Warnf("Failed to start backend: %s", err.Error())
+
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"error": "Failed to start backend",
+		})
+
+		return
+	}
+
+	backend.RuntimeCommands <- &commonbackend.CheckServerParameters{
+		Type:      "checkServerParameters",
+		Arguments: backendParameters,
+	}
+
+	backendParamCheckResponse := <-backend.RuntimeCommands
+
+	switch responseMessage := backendParamCheckResponse.(type) {
+	case error:
+		log.Warnf("Failed to get response for backend: %s", responseMessage.Error())
+
+		err = backend.Stop()
+
+		if err != nil {
+			log.Warnf("Failed to stop backend: %s", err.Error())
+		}
+
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"error": "Failed to get status response from backend",
+		})
+
+		return
+	case *commonbackend.CheckParametersResponse:
+		if responseMessage.InResponseTo != "checkServerParameters" {
+			log.Errorf("Got illegal response to CheckServerParameters: %s", responseMessage.InResponseTo)
+
+			err = backend.Stop()
+
+			if err != nil {
+				log.Warnf("Failed to stop backend: %s", err.Error())
+			}
+
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"error": "Failed to get status response from backend",
+			})
+
+			return
+		}
+
+		if !responseMessage.IsValid {
+			err = backend.Stop()
+
+			if err != nil {
+				log.Warnf("Failed to stop backend: %s", err.Error())
+			}
+
+			var errorMessage string
+
+			if responseMessage.Message == "" {
+				errorMessage = "Unkown error while trying to parse connectionDetails"
+			} else {
+				errorMessage = fmt.Sprintf("Invalid backend parameters: %s", responseMessage.Message)
+			}
+
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": errorMessage,
+			})
+
+			return
+		}
+	default:
+		log.Warnf("Got illegal response type for backend: %T", responseMessage)
+	}
+
+	log.Info("Passed backend checks successfully")
+
+	backendInDatabase := &dbcore.Backend{
+		UserID:            user.ID,
+		Name:              req.Name,
+		Description:       req.Description,
+		Backend:           req.Backend,
+		BackendParameters: base64.StdEncoding.EncodeToString(backendParameters),
+	}
+
+	if result := dbcore.DB.Create(&backendInDatabase); result.Error != nil {
+		log.Warnf("Failed to create backend: %s", result.Error.Error())
+
+		err = backend.Stop()
+
+		if err != nil {
+			log.Warnf("Failed to stop backend: %s", err.Error())
+		}
+
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"error": "Failed to add backend into database",
+		})
+
+		return
+	}
+
+	backend.RuntimeCommands <- &commonbackend.Start{
+		Type:      "start",
+		Arguments: backendParameters,
+	}
+
+	backendStartResponse := <-backend.RuntimeCommands
+
+	switch responseMessage := backendStartResponse.(type) {
+	case error:
+		log.Warnf("Failed to get response for backend: %s", responseMessage.Error())
+
+		err = backend.Stop()
+
+		if err != nil {
+			log.Warnf("Failed to stop backend: %s", err.Error())
+		}
+
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"error": "Failed to get status response from backend",
+		})
+
+		return
+	case *commonbackend.BackendStatusResponse:
+		if !responseMessage.IsRunning {
+			err = backend.Stop()
+
+			if err != nil {
+				log.Warnf("Failed to start backend: %s", err.Error())
+			}
+
+			var errorMessage string
+
+			if responseMessage.Message == "" {
+				errorMessage = "Unkown error while trying to start the backend"
+			} else {
+				errorMessage = fmt.Sprintf("Failed to start backend: %s", responseMessage.Message)
+			}
+
+			c.JSON(http.StatusBadRequest, gin.H{
+				"error": errorMessage,
+			})
+
+			return
+		}
+	default:
+		log.Warnf("Got illegal response type for backend: %T", responseMessage)
+	}
+
+	backendruntime.RunningBackends[backendInDatabase.ID] = backend
+
+	c.JSON(http.StatusOK, gin.H{
+		"success": true,
+	})
+}