server-manager/backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added more logic

Browse Source
This commit is contained in:
ACoolName
2024-05-14 15:12:18 +03:00
parent c68de6705a
commit 16b6850635
4 changed files with 152 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files

135
servers/servers.go
View File

@@ -4,7 +4,9 @@ import (
"context"
"encoding/json"
"fmt"
"os"
"strings"
"time"
"acooldomain.co/backend/auth"
"acooldomain.co/backend/models"
@@ -16,6 +18,7 @@ import (
"github.com/docker/docker/api/types/network"
"github.com/docker/docker/api/types/volume"
"github.com/docker/docker/client"
"github.com/docker/go-connections/nat"
"github.com/gin-gonic/gin"
v1 "github.com/opencontainers/image-spec/specs-go/v1"
"go.mongodb.org/mongo-driver/bson"
@@ -51,6 +54,22 @@ func (con Connection) getServerInfo(volume volume.Volume) (*models.ServerInfo, e
return nil, err
}
json.Unmarshal(jsonData, &volumeLabels)
imageList, err := con.apiClient.ImageList(context.Background(), image.ListOptions{Filters: filters.NewArgs(filters.Arg("reference", volumeLabels.ImageId))})
if len(imageList) == 0 {
return nil, fmt.Errorf("ImageId %s does not exist", volumeLabels.ImageId)
}
imageSummery := imageList[0]
imageInspect, _, err := con.apiClient.ImageInspectWithRaw(context.Background(), imageSummery.ID)
if err != nil {
return nil, err
}
var imagePorts []models.Port = make([]models.Port, len(imageInspect.Config.ExposedPorts))
i := 0
for imagePort := range imageInspect.Config.ExposedPorts {
imagePorts[i] = models.Port{Protocol: imagePort.Proto(), Number: imagePort.Int()}
i += 1
}
imageNameAndVersion := strings.Split(volumeLabels.ImageId, ":")
@@ -78,6 +97,7 @@ func (con Connection) getServerInfo(volume volume.Volume) (*models.ServerInfo, e
Image: models.ImageInfo{
Name: imageName,
Version: imageVersion,
Ports: imagePorts,
},
OwnerId: volumeLabels.OwnerId,
On: state,
@@ -126,16 +146,19 @@ func (con Connection) CreateServer(ctx *gin.Context) {
claims, exists := ctx.Get("claims")
if !exists {
ctx.AbortWithStatus(500)
return
}
var request CreateServerRequest
err := json.NewDecoder(ctx.Request.Body).Decode(&request)
if err != nil {
ctx.AbortWithError(400, err)
return
}
imageList, err := con.apiClient.ImageList(context.Background(), image.ListOptions{All: true, Filters: filters.NewArgs(filters.Arg("reference", request.ImageId))})
if err != nil {
ctx.AbortWithError(400, err)
return
}
if len(imageList) == 0 {
ctx.AbortWithStatusJSON(404, "imageNotFound")
@@ -145,16 +168,17 @@ func (con Connection) CreateServer(ctx *gin.Context) {
labels, err := convertLabelsToMap(VolumeLabels{OwnerId: claims.(*auth.AuthClaims).Username, ImageId: imageSummary.RepoTags[0], Type: "GAME"})
if err != nil {
ctx.AbortWithError(400, err)
return
}
volumeResponse, err := con.apiClient.VolumeCreate(context.Background(), volume.CreateOptions{
Labels: labels,
})
if err != nil {
ctx.AbortWithError(500, err)
return
}
ctx.JSON(200, volumeResponse.Name)
}
func (con Connection) StartServer(ctx *gin.Context) {
@@ -162,6 +186,7 @@ func (con Connection) StartServer(ctx *gin.Context) {
claims, exists := ctx.Get("claims")
if !exists {
ctx.AbortWithStatus(403)
return
}
// command := ctx.Param("command")
@@ -170,6 +195,7 @@ func (con Connection) StartServer(ctx *gin.Context) {
if err != nil {
ctx.AbortWithError(500, err)
return
}
if serverInfo.On {
@@ -187,6 +213,7 @@ func (con Connection) StartServer(ctx *gin.Context) {
jsonString, err := json.Marshal(labels)
if err != nil {
ctx.AbortWithError(500, err)
return
}
jsonLabels := make(map[string]string)
json.Unmarshal(jsonString, &jsonLabels)
@@ -196,6 +223,18 @@ func (con Connection) StartServer(ctx *gin.Context) {
image, _, err := con.apiClient.ImageInspectWithRaw(context.Background(), imageId)
if err != nil {
ctx.AbortWithError(500, err)
return
}
var portMapping nat.PortMap = make(nat.PortMap)
for _, port := range serverInfo.Image.Ports {
dockerPort, err := nat.NewPort(port.Protocol, fmt.Sprint(port.Number))
if err != nil {
ctx.AbortWithError(500, err)
return
}
portMapping[dockerPort] = []nat.PortBinding{{HostIP: "0.0.0.0"}}
}
response, err := con.apiClient.ContainerCreate(
@@ -212,8 +251,9 @@ func (con Connection) StartServer(ctx *gin.Context) {
Labels: jsonLabels,
},
&container.HostConfig{
AutoRemove: true,
Mounts: []mount.Mount{{Source: serverInfo.Id, Target: image.Config.WorkingDir, Type: "volume"}},
AutoRemove: true,
Mounts: []mount.Mount{{Source: serverInfo.Id, Target: image.Config.WorkingDir, Type: "volume"}},
PortBindings: portMapping,
},
&network.NetworkingConfig{},
&v1.Platform{},
@@ -221,9 +261,41 @@ func (con Connection) StartServer(ctx *gin.Context) {
)
if err != nil {
ctx.AbortWithError(500, err)
return
}
if err := con.apiClient.ContainerStart(ctx, response.ID, container.StartOptions{}); err != nil {
ctx.AbortWithError(500, err)
return
}
UPNPPath, exists := os.LookupEnv("UPNP_PATH")
HostIP, hostIPexists := os.LookupEnv("HOST_IP")
if exists && hostIPexists {
time.Sleep(time.Millisecond * 100)
containerData, err := con.apiClient.ContainerInspect(context.Background(), response.ID)
if err != nil {
ctx.AbortWithError(500, err)
return
}
fo, err := os.OpenFile(UPNPPath, os.O_APPEND, os.ModeAppend)
if err != nil {
panic(err)
}
defer func() {
if err := fo.Close(); err != nil {
panic(err)
}
}()
for containerPort, portBindings := range containerData.NetworkSettings.Ports {
for _, hostPort := range portBindings {
number, proto := hostPort.HostPort, containerPort.Proto()
_, err := fo.Write([]byte(fmt.Sprintf("%s|%s|%s|%s|%s\n", HostIP, number, "0.0.0.0", number, strings.ToUpper(proto))))
if err != nil {
ctx.AbortWithError(500, err)
return
}
}
}
}
ctx.JSON(200, response.ID)
}
@@ -239,7 +311,6 @@ func (con Connection) GetServers(ctx *gin.Context) {
ctx.AbortWithError(500, err)
}
var servers []models.ServerInfo
println("Found %d Containers", len(volumes.Volumes))
for _, volume := range volumes.Volumes {
serverInfo, err := con.getServerInfo(*volume)
if err != nil {
@@ -252,7 +323,56 @@ func (con Connection) GetServers(ctx *gin.Context) {
ctx.AbortWithError(500, err)
}
ctx.JSON(200, servers)
}
func (con Connection) StopServer(ctx *gin.Context) {
serverId := ctx.Param("server_id")
containersList, err := con.apiClient.ContainerList(context.Background(), container.ListOptions{
Filters: filters.NewArgs(filters.Arg("label", "volume_id="+serverId), filters.Arg("label", "type=GAME")),
})
if err != nil {
ctx.AbortWithError(500, err)
return
}
if len(containersList) == 0 {
ctx.Status(200)
return
}
for _, containerData := range containersList {
con.apiClient.ContainerStop(context.Background(), containerData.ID, container.StopOptions{})
}
ctx.Status(200)
}
func (con Connection) serverAuthorized(permissions models.Permission) func(*gin.Context) bool {
return func(ctx *gin.Context) bool {
claims, exists := ctx.Get("claims")
if !exists {
return false
}
server_id := ctx.Param("server_id")
if server_id == "" {
return false
}
var serverData models.ServerData
con.connection.Database("Backend").Collection("Servers").FindOne(context.Background(), bson.D{{Key: "ServerId", Value: server_id}}).Decode(&serverData)
if serverData.OwnerId == claims.(*auth.AuthClaims).Username {
return true
}
userPermissions := serverData.UserPermissions[claims.(*auth.AuthClaims).Username]
if userPermissions&permissions == permissions || userPermissions&models.Admin == models.Admin {
return true
}
return false
}
}
func LoadGroup(group *gin.RouterGroup, mongo_client *mongo.Client) {
@@ -263,7 +383,8 @@ func LoadGroup(group *gin.RouterGroup, mongo_client *mongo.Client) {
defer apiClient.Close()
connection := Connection{connection: mongo_client, apiClient: apiClient}
group.Use(auth.AuthorizedTo(models.Start)).POST("/:server_id/start", connection.StartServer)
group.Use(auth.AuthorizedTo(models.Create)).POST("/", connection.CreateServer)
group.GET("/", connection.GetServers)
group.POST("/:server_id/start", auth.AuthorizedTo(models.Start, connection.serverAuthorized(models.Start)), connection.StartServer)
group.POST("/", auth.AuthorizedTo(models.Create), connection.CreateServer)
group.GET("/", auth.AuthorizedTo(0), connection.GetServers)
group.POST("/:server_id/stop", auth.AuthorizedTo(models.Stop, connection.serverAuthorized(models.Stop)), connection.StopServer)
}