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

added stuff

Browse Source
This commit is contained in:
ACoolName 2024-05-21 21:59:38 +03:00
parent cbe0d7934b
commit a6a63805e4
4 changed files with 236 additions and 236 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
.vscode/launch.json vendored
View File

@ -1,20 +1,20 @@
{ {
// Use IntelliSense to learn about possible attributes. // Use IntelliSense to learn about possible attributes.
// Hover to view descriptions of existing attributes. // Hover to view descriptions of existing attributes.
// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
"version": "0.2.0", "version": "0.2.0",
"configurations": [ "configurations": [
{ {
"name": "Launch Package", "name": "Launch Package",
"type": "go", "type": "go",
"request": "launch", "request": "launch",
"mode": "auto", "mode": "auto",
"program": "${workspaceFolder}", "program": "${workspaceFolder}",
"env": { "env": {
"HOST_IP": "127.0.0.1", "HOST_IP": "127.0.0.1",
"UPNP_PATH": "test.upnp", "UPNP_PATH": "test.upnp",
"CONFIG_PATH": "config.json" "CONFIG_PATH": "config.json"
} }
} }
] ]
} }

174
mail/mail.go
View File

@ -1,87 +1,87 @@
package mail package mail
import ( import (
"crypto/tls" "crypto/tls"
"fmt" "fmt"
"net/mail" "net/mail"
"net/smtp" "net/smtp"
"acooldomain.co/backend/models" "acooldomain.co/backend/models"
) )
const EMAIL_SERVER_ENV_VAR = "EMAIL_SERVER" const EMAIL_SERVER_ENV_VAR = "EMAIL_SERVER"
const FROM_EMAIL_ENV_VAR = "FROM_EMAIL" const FROM_EMAIL_ENV_VAR = "FROM_EMAIL"
var auth *smtp.Auth var auth *smtp.Auth
var mailConfig *models.EmailConfig var mailConfig *models.EmailConfig
func InitializeClient(config models.EmailConfig) error { func InitializeClient(config models.EmailConfig) error {
simpleAuth := smtp.PlainAuth("", config.Username, config.Password, config.Server) simpleAuth := smtp.PlainAuth("", config.Username, config.Password, config.Server)
auth = &simpleAuth auth = &simpleAuth
mailConfig = &config mailConfig = &config
return nil return nil
} }
func SendMail( func SendMail(
recipient string, recipient string,
subject string, subject string,
content string, content string,
) error { ) error {
if auth == nil { if auth == nil {
return fmt.Errorf("mail not initialized") return fmt.Errorf("mail not initialized")
} }
if mailConfig == nil { if mailConfig == nil {
return fmt.Errorf("mail not initialized") return fmt.Errorf("mail not initialized")
} }
from := mail.Address{Name: "", Address: mailConfig.FromEmail} from := mail.Address{Name: "", Address: mailConfig.FromEmail}
to := mail.Address{Name: "", Address: recipient} to := mail.Address{Name: "", Address: recipient}
headers := make(map[string]string) headers := make(map[string]string)
headers["From"] = from.String() headers["From"] = from.String()
headers["To"] = to.String() headers["To"] = to.String()
headers["Subject"] = subject headers["Subject"] = subject
message := "" message := ""
for k, v := range headers { for k, v := range headers {
message += fmt.Sprintf("%s: %s\r\n", k, v) message += fmt.Sprintf("%s: %s\r\n", k, v)
} }
message += "\r\n" + content message += "\r\n" + content
conn, err := tls.Dial("tcp", mailConfig.Server+":465", &tls.Config{ServerName: mailConfig.Server}) conn, err := tls.Dial("tcp", mailConfig.Server+":465", &tls.Config{ServerName: mailConfig.Server})
if err != nil { if err != nil {
return err return err
} }
client, err := smtp.NewClient(conn, mailConfig.Server) client, err := smtp.NewClient(conn, mailConfig.Server)
if err != nil { if err != nil {
return err return err
} }
if err = client.Auth(*auth); err != nil { if err = client.Auth(*auth); err != nil {
return err return err
} }
if err = client.Mail(mailConfig.FromEmail); err != nil { if err = client.Mail(mailConfig.FromEmail); err != nil {
return err return err
} }
if err = client.Rcpt(recipient); err != nil { if err = client.Rcpt(recipient); err != nil {
return err return err
} }
writer, err := client.Data() writer, err := client.Data()
if err != nil { if err != nil {
return err return err
} }
_, err = writer.Write([]byte(message)) _, err = writer.Write([]byte(message))
if err != nil { if err != nil {
return err return err
} }
if err = writer.Close(); err != nil { if err = writer.Close(); err != nil {
return err return err
} }
return client.Quit() return client.Quit()
} }

28
models/config.go
View File

@ -1,14 +1,14 @@
package models package models
type EmailConfig struct { type EmailConfig struct {
FromEmail string FromEmail string
Username string Username string
Password string Password string
Server string Server string
} }
type GlobalConfig struct { type GlobalConfig struct {
Email EmailConfig Email EmailConfig
Key string Key string
Algorithm string Algorithm string
} }

232
servers/browsers.go
View File

@ -1,116 +1,116 @@
package servers package servers
import ( import (
"context" "context"
"encoding/json" "encoding/json"
"fmt" "fmt"
"acooldomain.co/backend/auth" "acooldomain.co/backend/auth"
"acooldomain.co/backend/models" "acooldomain.co/backend/models"
"github.com/docker/docker/api/types/container" "github.com/docker/docker/api/types/container"
"github.com/docker/docker/api/types/filters" "github.com/docker/docker/api/types/filters"
"github.com/docker/docker/api/types/volume" "github.com/docker/docker/api/types/volume"
"github.com/docker/docker/client" "github.com/docker/docker/client"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo"
) )
func (con Connection) getBrowserInfo(volume volume.Volume) (*models.FileBrowserInfo, error) { func (con Connection) getBrowserInfo(volume volume.Volume) (*models.FileBrowserInfo, error) {
serverInfo, err := con.getServerInfo(volume) serverInfo, err := con.getServerInfo(volume)
if err != nil { if err != nil {
return nil, err return nil, err
} }
containers, err := con.dockerClient.ContainerList(context.TODO(), container.ListOptions{ containers, err := con.dockerClient.ContainerList(context.TODO(), container.ListOptions{
All: true, All: true,
Filters: filters.NewArgs(filters.Arg("label", "type=FILE_BROWSER"), filters.Arg("label", fmt.Sprintf("volume_id=%s", volume.Name))), Filters: filters.NewArgs(filters.Arg("label", "type=FILE_BROWSER"), filters.Arg("label", fmt.Sprintf("volume_id=%s", volume.Name))),
}) })
if err != nil || len(containers) == 0 { if err != nil || len(containers) == 0 {
return nil, nil return nil, nil
} }
container := containers[0] container := containers[0]
jsonData, err := json.Marshal(container.Labels) jsonData, err := json.Marshal(container.Labels)
if err != nil { if err != nil {
return nil, err return nil, err
} }
var browserInfo ContainerLabels var browserInfo ContainerLabels
err = json.Unmarshal(jsonData, &browserInfo) err = json.Unmarshal(jsonData, &browserInfo)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return &models.FileBrowserInfo{ return &models.FileBrowserInfo{
Id: container.ID, Id: container.ID,
OwnerId: browserInfo.OwnerId, OwnerId: browserInfo.OwnerId,
ConnectedTo: *serverInfo, ConnectedTo: *serverInfo,
Url: container.ID[:12] + "." + DOMAIN, Url: container.ID[:12] + "." + DOMAIN,
}, nil }, nil
} }
func (con Connection) GetBrowsers(ctx *gin.Context) { func (con Connection) GetBrowsers(ctx *gin.Context) {
volumes, err := con.dockerClient.VolumeList( volumes, err := con.dockerClient.VolumeList(
context.TODO(), context.TODO(),
volume.ListOptions{ volume.ListOptions{
Filters: filters.NewArgs(filters.Arg("label", "type=GAME")), Filters: filters.NewArgs(filters.Arg("label", "type=GAME")),
}, },
) )
if err != nil { if err != nil {
ctx.AbortWithError(500, err) ctx.AbortWithError(500, err)
} }
var servers []models.FileBrowserInfo var servers []models.FileBrowserInfo
for _, volume := range volumes.Volumes { for _, volume := range volumes.Volumes {
browserInfo, err := con.getBrowserInfo(*volume) browserInfo, err := con.getBrowserInfo(*volume)
if err != nil { if err != nil {
ctx.AbortWithError(500, err) ctx.AbortWithError(500, err)
} }
if browserInfo == nil { if browserInfo == nil {
continue continue
} }
servers = append(servers, *browserInfo) servers = append(servers, *browserInfo)
} }
if err != nil { if err != nil {
ctx.AbortWithError(500, err) ctx.AbortWithError(500, err)
} }
ctx.JSON(200, servers) ctx.JSON(200, servers)
} }
func (con Connection) StopBrowser(ctx *gin.Context) { func (con Connection) StopBrowser(ctx *gin.Context) {
serverId := ctx.Param("server_id") serverId := ctx.Param("server_id")
containersList, err := con.dockerClient.ContainerList(context.TODO(), container.ListOptions{ containersList, err := con.dockerClient.ContainerList(context.TODO(), container.ListOptions{
Filters: filters.NewArgs(filters.Arg("label", "volume_id="+serverId), filters.Arg("label", "type=FILE_BROWSER")), Filters: filters.NewArgs(filters.Arg("label", "volume_id="+serverId), filters.Arg("label", "type=FILE_BROWSER")),
}) })
if err != nil { if err != nil {
ctx.AbortWithError(500, err) ctx.AbortWithError(500, err)
return return
} }
if len(containersList) == 0 { if len(containersList) == 0 {
ctx.Status(200) ctx.Status(200)
return return
} }
for _, containerData := range containersList { for _, containerData := range containersList {
con.dockerClient.ContainerStop(context.TODO(), containerData.ID, container.StopOptions{}) con.dockerClient.ContainerStop(context.TODO(), containerData.ID, container.StopOptions{})
} }
ctx.Status(200) ctx.Status(200)
} }
func LoadBrowsersGroup(group *gin.RouterGroup, mongo_client *mongo.Client, config models.GlobalConfig) { func LoadBrowsersGroup(group *gin.RouterGroup, mongo_client *mongo.Client, config models.GlobalConfig) {
apiClient, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation()) apiClient, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
if err != nil { if err != nil {
panic(err) panic(err)
} }
defer apiClient.Close() defer apiClient.Close()
connection := Connection{databaseConnection: mongo_client, dockerClient: apiClient} connection := Connection{databaseConnection: mongo_client, dockerClient: apiClient}
group.GET("/", auth.AuthorizedTo(0), connection.GetBrowsers) group.GET("/", auth.AuthorizedTo(0), connection.GetBrowsers)
group.POST("/:server_id/stop", auth.AuthorizedTo(models.Browse, connection.serverAuthorized(models.Browse)), connection.StopBrowser) group.POST("/:server_id/stop", auth.AuthorizedTo(models.Browse, connection.serverAuthorized(models.Browse)), connection.StopBrowser)
} }