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

refactored

Browse Source
This commit is contained in:
ACoolName 2025-03-18 23:27:27 +02:00
parent 64f59ea232
commit 6c1f34c682
45 changed files with 398 additions and 413 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
auth/auth.go
View File

@ -8,14 +8,14 @@ import (
"strings"
"time"
"git.acooldomain.co/server-manager/backend-kubernetes-go/db_handler/mongo"
"git.acooldomain.co/server-manager/backend-kubernetes-go/dbhandler"
"git.acooldomain.co/server-manager/backend-kubernetes-go/models"
"git.acooldomain.co/server-manager/backend/dbhandler"
"git.acooldomain.co/server-manager/backend/factories"
"git.acooldomain.co/server-manager/backend/models"
"github.com/gin-gonic/gin"
"github.com/golang-jwt/jwt"
)
type Connection struct {
type AuthApi struct {
config models.GlobalConfig
tokenHandler dbhandler.InviteTokenDbHandler
@ -35,7 +35,7 @@ type AuthClaims struct {
Claims
}
func (con *Connection) signToken(token Claims) (string, error) {
func (con *AuthApi) signToken(token Claims) (string, error) {
t := jwt.New(jwt.GetSigningMethod(con.config.Signing.Algorithm))
t.Claims = &AuthClaims{
@ -70,7 +70,7 @@ func AuthorizedTo(requiredPermissions models.Permission) gin.HandlerFunc {
}
}
func (con *Connection) LoggedIn(ctx *gin.Context) {
func (con *AuthApi) LoggedIn(ctx *gin.Context) {
authCookie, err := ctx.Request.Cookie("auth")
if err != nil {
ctx.AbortWithError(403, err)
@ -110,7 +110,7 @@ type SignUpRequest struct {
Password string
}
func (con Connection) signUp(ctx *gin.Context) {
func (con AuthApi) signUp(ctx *gin.Context) {
var request SignUpRequest
err := json.NewDecoder(ctx.Request.Body).Decode(&request)
@ -145,7 +145,7 @@ type SignInRequest struct {
Password string
}
func (con Connection) signIn(ctx *gin.Context) {
func (con AuthApi) signIn(ctx *gin.Context) {
var request SignInRequest
err := json.NewDecoder(ctx.Request.Body).Decode(&request)
@ -175,7 +175,7 @@ func (con Connection) signIn(ctx *gin.Context) {
ctx.IndentedJSON(http.StatusOK, signedToken)
}
func (con Connection) Verify(ctx *gin.Context) {
func (con AuthApi) Verify(ctx *gin.Context) {
claimsPointer, exists := ctx.Get("claims")
if !exists {
ctx.Status(403)
@ -215,39 +215,26 @@ func (con Connection) Verify(ctx *gin.Context) {
ctx.Redirect(303, fmt.Sprintf("http://%s/login", con.config.Domain))
}
func LoadGroup(group *gin.RouterGroup, client *mongo.Client, config models.GlobalConfig) {
var userAuthHandler dbhandler.UserPassAuthanticationDbHandler
var inviteHandler dbhandler.InviteTokenDbHandler
var serverAuthHandler dbhandler.ServersAuthorizationDbHandler
var err error
if config.Authentication.UserPass.Type == models.MONGO {
userAuthHandler, err = mongo.NewUserPassAuthHandler(*config.Authentication.UserPass.Mongo)
if err != nil {
panic(err)
}
func LoadGroup(group *gin.RouterGroup, config models.GlobalConfig) gin.HandlerFunc {
userAuthHandler, err := factories.GetUserPassAuthDbHandler(config.Authentication.UserPass)
if err != nil {
panic(err)
}
if config.Authentication.UserPass.InviteTokenDatabase.Type == models.MONGO {
inviteHandler, err = mongo.NewInviteTokenDbHandler(*config.Authentication.UserPass.Mongo)
if err != nil {
panic(err)
}
inviteHandler, err := factories.GetInviteTokenDbHandler(config.Authentication.UserPass.InviteTokenDatabase)
if err != nil {
panic(err)
}
mailClient = *mail.NewMailClient(config.Email)
connection := Connection{
userPassAuthHandler: userAuthHandler,
tokenHandler: inviteHandler,
mailClient: mailClient,
config: &config,
connection := AuthApi{
userAuthDbHandler: userAuthHandler,
tokenHandler: inviteHandler,
config: config,
}
connection := Connection{DatabaseConnection: client}
group.POST("/signin", connection.signIn)
group.POST("/signup", AuthorizedTo(models.Admin), connection.signUp)
group.POST("/signup", connection.LoggedIn, AuthorizedTo(models.Admin), connection.signUp)
group.Any("/verify", connection.Verify)
return connection.LoggedIn
}

2
auth/go.mod
View File

@ -1,4 +1,4 @@
module git.acooldomain.co/server-manager/backend-kubernetes-go/auth
module git.acooldomain.co/server-manager/backend/auth
go 1.22.0

3
db_handler/go.mod
View File

@ -1,3 +0,0 @@
module git.acooldomain.co/server-manager/backend-kubernetes-go/dbhandler
go 1.22.0

105
db_handler/mongo/users.go
View File

@ -1,105 +0,0 @@
package mongo
import (
"context"
"fmt"
"time"
"git.acooldomain.co/server-manager/backend-kubernetes-go/dbhandler"
"git.acooldomain.co/server-manager/backend-kubernetes-go/models"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
type User struct {
Username string `bson:"username"`
Email string `bson:"email"`
Nickname string `bson:"nickname"`
}
type UsersDbHandler struct {
dbhandler.UsersDBHandler
collection *mongo.Collection
}
func (self *UsersDbHandler) GetUser(ctx context.Context, username string) (*dbhandler.User, error) {
var user User
err := self.collection.FindOne(ctx, bson.M{"username": username}).Decode(&user)
if err != nil {
return nil, err
}
return &dbhandler.User{
Username: user.Username,
Email: user.Email,
Nickname: user.Nickname,
}, nil
}
func (self *UsersDbHandler) ListUsers(ctx context.Context) ([]dbhandler.User, error) {
cursor, err := self.collection.Find(ctx, bson.M{})
if err != nil {
return nil, err
}
defer cursor.Close(ctx)
var users []User
cursor.All(nil, &users)
response := make([]dbhandler.User, len(users))
for i, user := range users {
response[i] = dbhandler.User{
Username: user.Username,
Nickname: user.Nickname,
Email: user.Email,
}
}
return response, nil
}
func (self *UsersDbHandler) CreateUser(ctx context.Context, user dbhandler.User) error {
_, err := self.collection.InsertOne(ctx, &User{
Username: user.Username,
Email: user.Email,
Nickname: user.Nickname,
}, &options.InsertOneOptions{})
if err != nil {
return err
}
return nil
}
func (self *UsersDbHandler) DeleteUser(ctx context.Context, username string) error {
_, err := self.collection.DeleteOne(ctx, bson.M{"username": username})
return err
}
func NewUsersHandler(config models.MongoDBConfig) (*UsersDbHandler, error) {
clientOptions := options.Client().ApplyURI(config.Url).SetAuth(options.Credential{
Username: config.Username,
Password: config.Password,
})
ctx, cancel := context.WithTimeoutCause(context.Background(), 30*time.Second, fmt.Errorf("Timeout"))
defer cancel()
client, err := mongo.Connect(ctx, clientOptions)
if err != nil {
return nil, err
}
return &UsersDbHandler{
collection: client.Database(config.Database).Collection(config.Collection),
}, nil
}

14
db_handler/users.go
View File

@ -1,14 +0,0 @@
package dbhandler
type User struct {
Username string
Nickname string
Email string
}
type UsersDBHandler interface {
GetUser(username string) (User, error)
ListUsers() ([]User, error)
CreateUser(user User) error
DeleteUser(username string) error
}

0
db_handler/db_handler.go → dbhandler/db_handler.go
View File

3
dbhandler/go.mod Normal file
View File

@ -0,0 +1,3 @@
module git.acooldomain.co/server-manager/backend/dbhandler
go 1.22.0

2
db_handler/mongo/go.mod → dbhandler/mongo/go.mod
View File

@ -1,4 +1,4 @@
module git.acooldomain.co/server-manager/backend-kubernetes-go/db_handler/mongo
module git.acooldomain.co/server-manager/backend/dbhandler/mongo
go 1.24.1

0
db_handler/mongo/go.sum → dbhandler/mongo/go.sum
View File

4
db_handler/mongo/servers.go → dbhandler/mongo/servers.go
View File

@ -5,8 +5,8 @@ import (
"fmt"
"time"
"git.acooldomain.co/server-manager/backend-kubernetes-go/dbhandler"
"git.acooldomain.co/server-manager/backend-kubernetes-go/models"
"git.acooldomain.co/server-manager/backend/dbhandler"
"git.acooldomain.co/server-manager/backend/models"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"

4
db_handler/mongo/servers_authorization.go → dbhandler/mongo/servers_authorization.go
View File

@ -5,8 +5,8 @@ import (
"fmt"
"time"
"git.acooldomain.co/server-manager/backend-kubernetes-go/dbhandler"
"git.acooldomain.co/server-manager/backend-kubernetes-go/models"
"git.acooldomain.co/server-manager/backend/dbhandler"
"git.acooldomain.co/server-manager/backend/models"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"

4
db_handler/mongo/user_pass_authentication.go → dbhandler/mongo/user_pass_authentication.go
View File

@ -5,8 +5,8 @@ import (
"fmt"
"time"
"git.acooldomain.co/server-manager/backend-kubernetes-go/dbhandler"
"git.acooldomain.co/server-manager/backend-kubernetes-go/models"
"git.acooldomain.co/server-manager/backend/dbhandler"
"git.acooldomain.co/server-manager/backend/models"
"github.com/google/uuid"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo"

2
db_handler/oidc_auth.go → dbhandler/oidc_auth.go
View File

@ -7,7 +7,7 @@ import (
"fmt"
"log"
"git.acooldomain.co/server-manager/backend-kubernetes-go/models"
"git.acooldomain.co/server-manager/backend/models"
"github.com/coreos/go-oidc"
"golang.org/x/oauth2"
)

2
db_handler/servers.go → dbhandler/servers.go
View File

@ -3,7 +3,7 @@ package dbhandler
import (
"context"
"git.acooldomain.co/server-manager/backend-kubernetes-go/models"
"git.acooldomain.co/server-manager/backend/models"
)
type Server struct {

2
db_handler/servers_authorization.go → dbhandler/servers_authorization.go
View File

@ -3,7 +3,7 @@ package dbhandler
import (
"context"
"git.acooldomain.co/server-manager/backend-kubernetes-go/models"
"git.acooldomain.co/server-manager/backend/models"
)
type ServersAuthorizationDbHandler interface {

2
db_handler/user_pass_auth.go → dbhandler/user_pass_auth.go
View File

@ -3,7 +3,7 @@ package dbhandler
import (
"context"
"git.acooldomain.co/server-manager/backend-kubernetes-go/models"
"git.acooldomain.co/server-manager/backend/models"
"golang.org/x/crypto/bcrypt"
)

174
factories/dbhandlers.go Normal file
View File

@ -0,0 +1,174 @@
package factories
import (
"errors"
"sync"
"git.acooldomain.co/server-manager/backend/dbhandler/mongo"
"git.acooldomain.co/server-manager/backend/dbhandler"
"git.acooldomain.co/server-manager/backend/models"
)
var (
serversDbHandlers = make(map[string]dbhandler.ServersDbHandler)
serversAuthDbHandlers = make(map[string]dbhandler.ServersAuthorizationDbHandler)
userPassAuthDbHandlers = make(map[string]dbhandler.UserPassAuthanticationDbHandler)
inviteTokenDbHandlers = make(map[string]dbhandler.InviteTokenDbHandler)
serversDbMutex sync.Mutex
serversAuthDbMutex sync.Mutex
userPassAuthDbMutex sync.Mutex
inviteTokenDbMutex sync.Mutex
)
func getMongoCacheKey(config *models.MongoDBConfig) string {
return "Mongo/" + config.Username + "/" + config.Password + "/" + config.Url + "/" + config.Database + "/" + config.Collection
}
func GetServersDbHandler(config models.ServersDatabaseConfig) (dbhandler.ServersDbHandler, error) {
var key string
var handler dbhandler.ServersDbHandler
var err error
var exists bool
switch config.Type {
case models.MONGO:
if config.Mongo == nil {
return nil, errors.New("missing MongoDB configuration")
}
key = getMongoCacheKey(config.Mongo)
default:
return nil, errors.New("unsupported database type")
}
serversDbMutex.Lock()
defer serversDbMutex.Unlock()
if handler, exists = serversDbHandlers[key]; exists {
return handler, nil
}
switch config.Type {
case models.MONGO:
handler, err = mongo.NewServersDbHandler(*config.Mongo)
if err != nil {
return nil, err
}
default:
return nil, errors.New("unsupported database type")
}
serversDbHandlers[key] = handler
return handler, nil
}
func GetServersAuthorizationDbHandler(config models.ServersAuthorizationDatabaseConfig) (dbhandler.ServersAuthorizationDbHandler, error) {
var key string
var handler dbhandler.ServersAuthorizationDbHandler
var err error
var exists bool
switch config.Type {
case models.MONGO:
if config.Mongo == nil {
return nil, errors.New("missing MongoDB configuration")
}
key = getMongoCacheKey(config.Mongo)
default:
return nil, errors.New("unsupported database type")
}
serversAuthDbMutex.Lock()
defer serversAuthDbMutex.Unlock()
if handler, exists = serversAuthDbHandlers[key]; exists {
return handler, nil
}
switch config.Type {
case models.MONGO:
handler, err = mongo.NewServersAuthorizationHandler(*config.Mongo)
if err != nil {
return nil, err
}
default:
return nil, errors.New("unsupported database type")
}
serversAuthDbHandlers[key] = handler
return handler, nil
}
func GetUserPassAuthDbHandler(config models.UserPassAuthConfig) (dbhandler.UserPassAuthanticationDbHandler, error) {
var key string
var handler dbhandler.UserPassAuthanticationDbHandler
var err error
var exists bool
switch config.Type {
case models.MONGO:
if config.Mongo == nil {
return nil, errors.New("missing MongoDB configuration")
}
key = getMongoCacheKey(config.Mongo)
default:
return nil, errors.New("unsupported database type")
}
userPassAuthDbMutex.Lock()
defer userPassAuthDbMutex.Unlock()
if handler, exists = userPassAuthDbHandlers[key]; exists {
return handler, nil
}
switch config.Type {
case models.MONGO:
handler, err = mongo.NewUserPassAuthHandler(*config.Mongo)
if err != nil {
return nil, err
}
default:
return nil, errors.New("unsupported database type")
}
userPassAuthDbHandlers[key] = handler
return handler, nil
}
func GetInviteTokenDbHandler(config models.InviteTokenDatabaseConfig) (dbhandler.InviteTokenDbHandler, error) {
var key string
var handler dbhandler.InviteTokenDbHandler
var err error
var exists bool
switch config.Type {
case models.MONGO:
if config.Mongo == nil {
return nil, errors.New("missing MongoDB configuration")
}
key = getMongoCacheKey(config.Mongo)
default:
return nil, errors.New("unsupported database type")
}
inviteTokenDbMutex.Lock()
defer inviteTokenDbMutex.Unlock()
if handler, exists = inviteTokenDbHandlers[key]; exists {
return handler, nil
}
switch config.Type {
case models.MONGO:
handler, err = mongo.NewInviteTokenDbHandler(*config.Mongo)
if err != nil {
return nil, err
}
default:
return nil, errors.New("unsupported database type")
}
inviteTokenDbHandlers[key] = handler
return handler, nil
}

3
factories/go.mod Normal file
View File

@ -0,0 +1,3 @@
module git.acooldomain.co/server-manager/backend/factories
go 1.22.0

56
factories/instancemanagers.go Normal file
View File

@ -0,0 +1,56 @@
package factories
import (
"errors"
"sync"
instancemanager "git.acooldomain.co/server-manager/backend/instancemanager"
"git.acooldomain.co/server-manager/backend/instancemanager/docker"
"git.acooldomain.co/server-manager/backend/models"
)
var (
instanceManagerHandlers = make(map[string]instancemanager.InstanceManager)
instanceManagerMutex sync.Mutex
)
func getDockerCacheKey(config *models.DockerInstanceManagerConfig) string {
return "Docker"
}
func GetInstanceManager(config models.InstanceManagerConfig) (instancemanager.InstanceManager, error) {
var key string
var handler instancemanager.InstanceManager
var err error
var exists bool
switch config.Type {
case models.DOCKER:
if config.Docker == nil {
return nil, errors.New("missing Docker configuration")
}
key = getDockerCacheKey(config.Docker)
default:
return nil, errors.New("unsupported database type")
}
instanceManagerMutex.Lock()
defer instanceManagerMutex.Unlock()
if handler, exists = instanceManagerHandlers[key]; exists {
return handler, nil
}
switch config.Type {
case models.DOCKER:
handler, err = docker.NewInstanceManager(*config.Docker)
if err != nil {
return nil, err
}
default:
return nil, errors.New("unsupported database type")
}
instanceManagerHandlers[key] = handler
return handler, nil
}

2
go.mod
View File

@ -1,4 +1,4 @@
module git.acooldomain.co/server-manager/backend-kubernetes-go
module git.acooldomain.co/server-manager/backend
go 1.23.0

12
go.work
View File

@ -3,14 +3,14 @@ go 1.24.1
use (
.
./auth
./db_handler
./db_handler/mongo
./dbhandler
./dbhandler/mongo
./mail
./models
./instance_manager
./instance_manager/docker
./instance_manager/kubernetes
./instancemanager
./instancemanager/docker
./instancemanager/kubernetes
./servers
./users
./utils
./factories
)

3
instance_manager/docker/go.mod
View File

@ -1,3 +0,0 @@
module git.acooldomain.co/server-manager/backend-kubernetes-go/instance_manager/docker
go 1.22.0

3
instance_manager/go.mod
View File

@ -1,3 +0,0 @@
module git.acooldomain.co/server-manager/backend-kubernetes-go/instance_manager
go 1.22.0

3
instance_manager/kubernetes/go.mod
View File

@ -1,3 +0,0 @@
module git.acooldomain.co/server-manager/backend-kubernetes-go/instance_manager/kubernetes
go 1.22.0

3
instancemanager/docker/go.mod Normal file
View File

@ -0,0 +1,3 @@
module git.acooldomain.co/server-manager/backend/instancemanager/docker
go 1.22.0

4
instance_manager/docker/instance_manager.go → instancemanager/docker/instance_manager.go
View File

@ -6,8 +6,8 @@ import (
"fmt"
"net"
instancemanager "git.acooldomain.co/server-manager/backend-kubernetes-go/instance_manager"
"git.acooldomain.co/server-manager/backend-kubernetes-go/models"
instancemanager "git.acooldomain.co/server-manager/backend/instancemanager"
"git.acooldomain.co/server-manager/backend/models"
"github.com/buildkite/shellwords"
"github.com/docker/docker/api/types"
"github.com/docker/docker/api/types/container"

0
instance_manager/docker/labels.go → instancemanager/docker/labels.go
View File

4
instance_manager/docker/utils.go → instancemanager/docker/utils.go
View File

@ -6,8 +6,8 @@ import (
"log"
"strings"
instancemanager "git.acooldomain.co/server-manager/backend-kubernetes-go/instance_manager"
"git.acooldomain.co/server-manager/backend-kubernetes-go/models"
instancemanager "git.acooldomain.co/server-manager/backend/instancemanager"
"git.acooldomain.co/server-manager/backend/models"
"github.com/docker/docker/api/types"
"github.com/docker/docker/api/types/filters"
"github.com/docker/go-connections/nat"

3
instancemanager/go.mod Normal file
View File

@ -0,0 +1,3 @@
module git.acooldomain.co/server-manager/backend/instancemanager
go 1.22.0

2
instance_manager/instance_manager.go → instancemanager/instance_manager.go
View File

@ -4,7 +4,7 @@ import (
"context"
"net"
"git.acooldomain.co/server-manager/backend-kubernetes-go/models"
"git.acooldomain.co/server-manager/backend/models"
)
type Server struct {

3
instancemanager/kubernetes/go.mod Normal file
View File

@ -0,0 +1,3 @@
module git.acooldomain.co/server-manager/backend/instancemanager/kubernetes
go 1.22.0

4
instance_manager/kubernetes/instance_manager.go → instancemanager/kubernetes/instance_manager.go
View File

@ -4,8 +4,8 @@ import (
"context"
"net"
"git.acooldomain.co/server-manager/backend-kubernetes-go/instance_manager"
"git.acooldomain.co/server-manager/backend-kubernetes-go/models"
"git.acooldomain.co/server-manager/backend/instancemanager"
"git.acooldomain.co/server-manager/backend/models"
)
type InstanceManager struct {

2
mail/go.mod
View File

@ -1,3 +1,3 @@
module git.acooldomain.co/server-manager/backend-kubernetes-go/mail
module git.acooldomain.co/server-manager/backend/mail
go 1.22.0

2
mail/mail.go
View File

@ -6,7 +6,7 @@ import (
"net/mail"
"net/smtp"
"git.acooldomain.co/server-manager/backend-kubernetes-go/models"
"git.acooldomain.co/server-manager/backend/models"
)
type MailClient struct {

44
main.go
View File

@ -1,22 +1,19 @@
package main
import (
"context"
"encoding/json"
"fmt"
"os"
"git.acooldomain.co/server-manager/backend-kubernetes-go/auth"
"git.acooldomain.co/server-manager/backend-kubernetes-go/dbhandler"
"git.acooldomain.co/server-manager/backend-kubernetes-go/mail"
"git.acooldomain.co/server-manager/backend-kubernetes-go/models"
"git.acooldomain.co/server-manager/backend-kubernetes-go/servers"
"git.acooldomain.co/server-manager/backend-kubernetes-go/users"
"git.acooldomain.co/server-manager/backend/auth"
"git.acooldomain.co/server-manager/backend/models"
"git.acooldomain.co/server-manager/backend/servers"
"git.acooldomain.co/server-manager/backend/users"
"github.com/gin-contrib/cors"
"github.com/gin-gonic/gin"
)
const CONFIG_SECRET_NAME = "CONFIG_PATH"
const CONFIG_PATH = "CONFIG_PATH"
func main() {
router := gin.Default()
@ -24,7 +21,7 @@ func main() {
cors_config := cors.DefaultConfig()
cors_config.AllowCredentials = true
cors_config.ExposeHeaders = []string{"set-cookie"}
file, err := os.Open(fmt.Sprintf("/run/secrets/%s", os.Getenv(CONFIG_SECRET_NAME)))
file, err := os.Open(fmt.Sprintf("%s", os.Getenv(CONFIG_PATH)))
if err != nil {
panic(err)
}
@ -40,24 +37,23 @@ func main() {
if err != nil {
panic(err)
}
loggedIn := auth.LoadGroup(router.Group("/auth"), config)
client, err := dbhandler.Connect(config.UsersDatabase.Mongo)
defer func() {
if err = client.Disconnect(context.TODO()); err != nil {
panic(err)
}
}()
usersGroup := router.Group("/users")
usersGroup.Use(loggedIn)
users.LoadGroup(usersGroup, config)
if err != nil {
panic(err)
}
mail.InitializeClient(config.Email)
serversGroup := router.Group("/servers")
serversGroup.Use(loggedIn)
servers.LoadGroup(serversGroup, config)
users.LoadGroup(router.Group("/users"), client, config)
auth.LoadGroup(router.Group("/auth"), client, config)
servers.LoadGroup(router.Group("/servers"), client, config)
servers.LoadBrowsersGroup(router.Group("/browsers"), client, config)
servers.LoadeImagesGroup(router.Group("/images"), client, config)
browsersGroup := router.Group("/browsers")
browsersGroup.Use(loggedIn)
servers.LoadBrowsersGroup(browsersGroup, config)
imagesGroup := router.Group("/images")
imagesGroup.Use(loggedIn)
servers.LoadeImagesGroup(imagesGroup, config)
router.Run("0.0.0.0:8080")
}

12
models/config.go
View File

@ -43,11 +43,6 @@ type AuthenticationConfig struct {
UserPass UserPassAuthConfig `yaml:"user_pass"`
}
type UsersDatabaseConfig struct {
Type DatabaseType `yaml:"type"`
Mongo *MongoDBConfig `yaml:"mongo"`
}
type FileBrowserConfig struct {
Image Image `yaml:"image"`
Command string `yaml:"command"`
@ -62,8 +57,8 @@ type DockerInstanceManagerConfig struct {
}
type InstanceManagerConfig struct {
Type InstanceManagerType `yaml:"type"`
Docker DockerInstanceManagerConfig `yaml:"docker"`
Type InstanceManagerType `yaml:"type"`
Docker *DockerInstanceManagerConfig `yaml:"docker"`
}
type ServersDatabaseConfig struct {
@ -86,11 +81,10 @@ type GlobalConfig struct {
Domain string `yaml:"domain"`
Signing SigningConfig `yaml:"signing"`
Authentication AuthenticationConfig `yaml:"authentication"`
InstanceManager InstanceManagerConfig `yaml:"instance_manager"`
InstanceManager InstanceManagerConfig `yaml:"instancemanager"`
Users UsersConfig `yaml:"users"`
// Database Configs
ServersDatabase ServersDatabaseConfig `yaml:"servers_database"`
UsersDatabase UsersDatabaseConfig `yaml:"users_database"`
ServersAuthorizationDatabase ServersAuthorizationDatabaseConfig `yaml:"servers_authorization_database"`
}

2
models/go.mod
View File

@ -1,3 +1,3 @@
module git.acooldomain.co/server-manager/backend-kubernetes-go/models
module git.acooldomain.co/server-manager/backend/models
go 1.22.0

46
servers/browsers.go
View File

@ -1,16 +1,13 @@
package servers
import (
"git.acooldomain.co/server-manager/backend-kubernetes-go/auth"
"git.acooldomain.co/server-manager/backend-kubernetes-go/db_handler/mongo"
"git.acooldomain.co/server-manager/backend-kubernetes-go/dbhandler"
instancemanager "git.acooldomain.co/server-manager/backend-kubernetes-go/instance_manager"
"git.acooldomain.co/server-manager/backend-kubernetes-go/instance_manager/docker"
"git.acooldomain.co/server-manager/backend-kubernetes-go/models"
"git.acooldomain.co/server-manager/backend/auth"
"git.acooldomain.co/server-manager/backend/factories"
"git.acooldomain.co/server-manager/backend/models"
"github.com/gin-gonic/gin"
)
func (con Connection) GetBrowsers(ctx *gin.Context) {
func (con ServersApi) GetBrowsers(ctx *gin.Context) {
fileBrowsers, err := con.InstanceManager.ListFileBrowsers(ctx)
if err != nil {
@ -20,7 +17,7 @@ func (con Connection) GetBrowsers(ctx *gin.Context) {
ctx.JSON(200, fileBrowsers)
}
func (con Connection) StopBrowser(ctx *gin.Context) {
func (con ServersApi) StopBrowser(ctx *gin.Context) {
serverId := ctx.Param("server_id")
err := con.InstanceManager.StopFileBrowser(ctx, serverId)
if err != nil {
@ -32,35 +29,22 @@ func (con Connection) StopBrowser(ctx *gin.Context) {
}
func LoadBrowsersGroup(group *gin.RouterGroup, config models.GlobalConfig) {
var instanceManager instancemanager.InstanceManager
var serversDbHandler dbhandler.ServersDbHandler
var serversAuthorizationHandler dbhandler.ServersAuthorizationDbHandler
var err error
if config.InstanceManager.Type == models.DOCKER {
instanceManager, err = docker.NewInstanceManager(config.InstanceManager.Docker)
if err != nil {
panic(err)
}
serversDbHandler, err := factories.GetServersDbHandler(config.ServersDatabase)
if err != nil {
panic(err)
}
if config.ServersDatabase.Type == models.MONGO {
serversDbHandler, err = mongo.NewServersDbHandler(*config.ServersDatabase.Mongo)
if err != nil {
panic(err)
}
serversAuthorizationHandler, err := factories.GetServersAuthorizationDbHandler(config.ServersAuthorizationDatabase)
if err != nil {
panic(err)
}
if config.ServersAuthorizationDatabase.Type == models.MONGO {
serversAuthorizationHandler, err = mongo.NewAuthorizationHandler(*config.ServersAuthorizationDatabase.Mongo)
if err != nil {
panic(err)
}
instanceManager, err := factories.GetInstanceManager(config.InstanceManager)
if err != nil {
panic(err)
}
connection := Connection{
connection := ServersApi{
ServersDbHandler: serversDbHandler,
ServerAuthorization: serversAuthorizationHandler,
InstanceManager: instanceManager,

2
servers/go.mod
View File

@ -1,4 +1,4 @@
module git.acooldomain.co/server-manager/backend-kubernetes-go/servers
module git.acooldomain.co/server-manager/backend/servers
go 1.22.0

45
servers/images.go
View File

@ -3,12 +3,10 @@ package servers
import (
"fmt"
"git.acooldomain.co/server-manager/backend-kubernetes-go/auth"
"git.acooldomain.co/server-manager/backend-kubernetes-go/db_handler/mongo"
"git.acooldomain.co/server-manager/backend-kubernetes-go/dbhandler"
instancemanager "git.acooldomain.co/server-manager/backend-kubernetes-go/instance_manager"
"git.acooldomain.co/server-manager/backend-kubernetes-go/instance_manager/docker"
"git.acooldomain.co/server-manager/backend-kubernetes-go/models"
"git.acooldomain.co/server-manager/backend/auth"
"git.acooldomain.co/server-manager/backend/factories"
instancemanager "git.acooldomain.co/server-manager/backend/instancemanager"
"git.acooldomain.co/server-manager/backend/models"
"github.com/gin-gonic/gin"
)
@ -29,7 +27,7 @@ func convertImageToImageData(instanceImage instancemanager.Image) *ImageData {
DisplayName: fmt.Sprintf("%s %s", instanceImage.Registry, instanceImage.Tag),
}
}
func (con Connection) GetImages(ctx *gin.Context) {
func (con ServersApi) GetImages(ctx *gin.Context) {
images, err := con.InstanceManager.ListImages(ctx)
if err != nil {
ctx.AbortWithError(500, err)
@ -51,35 +49,22 @@ func (con Connection) GetImages(ctx *gin.Context) {
}
func LoadeImagesGroup(group *gin.RouterGroup, config models.GlobalConfig) {
var instanceManager instancemanager.InstanceManager
var serversDbHandler dbhandler.ServersDbHandler
var serversAuthorizationHandler dbhandler.ServersAuthorizationDbHandler
var err error
if config.InstanceManager.Type == models.DOCKER {
instanceManager, err = docker.NewInstanceManager(config.InstanceManager.Docker)
if err != nil {
panic(err)
}
instanceManager, err := factories.GetInstanceManager(config.InstanceManager)
if err != nil {
panic(err)
}
if config.ServersDatabase.Type == models.MONGO {
serversDbHandler, err = mongo.NewServersDbHandler(*config.ServersDatabase.Mongo)
if err != nil {
panic(err)
}
serversDbHandler, err := factories.GetServersDbHandler(config.ServersDatabase)
if err != nil {
panic(err)
}
if config.ServersAuthorizationDatabase.Type == models.MONGO {
serversAuthorizationHandler, err = mongo.NewAuthorizationHandler(*config.ServersAuthorizationDatabase.Mongo)
if err != nil {
panic(err)
}
serversAuthorizationHandler, err := factories.GetServersAuthorizationDbHandler(config.ServersAuthorizationDatabase)
if err != nil {
panic(err)
}
connection := Connection{
connection := ServersApi{
ServersDbHandler: serversDbHandler,
ServerAuthorization: serversAuthorizationHandler,
InstanceManager: instanceManager,

76
servers/servers.go
View File

@ -10,12 +10,11 @@ import (
"strings"
"time"
"git.acooldomain.co/server-manager/backend-kubernetes-go/auth"
"git.acooldomain.co/server-manager/backend-kubernetes-go/db_handler/mongo"
"git.acooldomain.co/server-manager/backend-kubernetes-go/dbhandler"
instancemanager "git.acooldomain.co/server-manager/backend-kubernetes-go/instance_manager"
"git.acooldomain.co/server-manager/backend-kubernetes-go/instance_manager/docker"
"git.acooldomain.co/server-manager/backend-kubernetes-go/models"
"git.acooldomain.co/server-manager/backend/auth"
"git.acooldomain.co/server-manager/backend/dbhandler"
"git.acooldomain.co/server-manager/backend/factories"
instancemanager "git.acooldomain.co/server-manager/backend/instancemanager"
"git.acooldomain.co/server-manager/backend/models"
"github.com/gin-gonic/gin"
"github.com/gorilla/websocket"
)
@ -28,7 +27,7 @@ var upgrader = websocket.Upgrader{
},
}
type Connection struct {
type ServersApi struct {
ServersDbHandler dbhandler.ServersDbHandler
InstanceManager instancemanager.InstanceManager
ServerAuthorization dbhandler.ServersAuthorizationDbHandler
@ -65,7 +64,7 @@ type CreateServerRequest struct {
Nickname string `json:"Nickname"`
}
func (con Connection) ServerAuthorized(permissions models.Permission) func(*gin.Context) {
func (con ServersApi) ServerAuthorized(permissions models.Permission) func(*gin.Context) {
return func(ctx *gin.Context) {
claimsPointer, exists := ctx.Get("claims")
if !exists {
@ -96,7 +95,7 @@ func (con Connection) ServerAuthorized(permissions models.Permission) func(*gin.
}
}
func (con Connection) CreateServer(ctx *gin.Context) {
func (con ServersApi) CreateServer(ctx *gin.Context) {
claims, exists := ctx.Get("claims")
if !exists {
ctx.AbortWithStatus(500)
@ -157,7 +156,7 @@ type StartServerRequest struct {
Ports []PortMappingRequest `json:"Ports"`
}
func (con Connection) StartServer(ctx *gin.Context) {
func (con ServersApi) StartServer(ctx *gin.Context) {
serverId := ctx.Param("server_id")
var request StartServerRequest
@ -194,7 +193,7 @@ func (con Connection) StartServer(ctx *gin.Context) {
ctx.JSON(200, instanceServer.Id)
}
func (con Connection) GetServers(ctx *gin.Context) {
func (con ServersApi) GetServers(ctx *gin.Context) {
instanceServers, err := con.InstanceManager.ListServers(ctx)
if err != nil {
ctx.AbortWithError(500, err)
@ -246,7 +245,7 @@ func (con Connection) GetServers(ctx *gin.Context) {
ctx.JSON(200, servers)
}
func (con Connection) StopServer(ctx *gin.Context) {
func (con ServersApi) StopServer(ctx *gin.Context) {
serverId := ctx.Param("server_id")
err := con.InstanceManager.StopServer(ctx, serverId)
if err != nil {
@ -257,7 +256,7 @@ func (con Connection) StopServer(ctx *gin.Context) {
ctx.Status(200)
}
func (con Connection) DeleteServer(ctx *gin.Context) {
func (con ServersApi) DeleteServer(ctx *gin.Context) {
serverId := ctx.Param("server_id")
err := con.InstanceManager.DeleteServer(ctx, serverId)
@ -279,7 +278,7 @@ type RunCommandRequest struct {
Command string `json:"Command"`
}
func (con Connection) RunCommand(ctx *gin.Context) {
func (con ServersApi) RunCommand(ctx *gin.Context) {
var request RunCommandRequest
err := json.NewDecoder(ctx.Request.Body).Decode(&request)
if err != nil {
@ -312,7 +311,7 @@ type Commands struct {
Arguments string `json:"Arguments"`
}
func (con Connection) AttachServer(ctx *gin.Context) {
func (con ServersApi) AttachServer(ctx *gin.Context) {
serverId := ctx.Param("server_id")
stop := false
var err error
@ -355,13 +354,10 @@ func (con Connection) AttachServer(ctx *gin.Context) {
hijackedPointer, err := con.InstanceManager.InteractiveTerminal(ctx, serverId)
if err != nil {
ctx.AbortWithError(500, err)
stop = true
return
}
hijacked = *hijackedPointer
if err != nil {
stop = true
break
}
}
if count > 0 {
containerRead <- string(data[:count])
@ -444,7 +440,7 @@ type UpdateServerRequest struct {
UserPermissions map[string]models.Permission `json:"UserPermissions"`
}
func (con Connection) UpdateServer(ctx *gin.Context) {
func (con ServersApi) UpdateServer(ctx *gin.Context) {
serverId := ctx.Param("server_id")
var request UpdateServerRequest
err := json.NewDecoder(ctx.Request.Body).Decode(&request)
@ -478,7 +474,7 @@ func (con Connection) UpdateServer(ctx *gin.Context) {
}
func (con Connection) BrowseServer(ctx *gin.Context) {
func (con ServersApi) BrowseServer(ctx *gin.Context) {
serverId := ctx.Param("server_id")
browserInfo, err := con.InstanceManager.StartFileBrowser(ctx, serverId)
@ -489,7 +485,7 @@ func (con Connection) BrowseServer(ctx *gin.Context) {
ctx.JSON(200, browserInfo.Url)
}
func (con Connection) GetServerUserPermissions(ctx *gin.Context) {
func (con ServersApi) GetServerUserPermissions(ctx *gin.Context) {
claims, exists := ctx.Get("claims")
if !exists {
ctx.AbortWithStatus(500)
@ -516,7 +512,7 @@ type SetServerUserPermissionsRequest struct {
Permissions models.Permission
}
func (con Connection) SetServerUserPermissions(ctx *gin.Context) {
func (con ServersApi) SetServerUserPermissions(ctx *gin.Context) {
serverId := ctx.Param("server_id")
if serverId == "" {
ctx.AbortWithStatus(500)
@ -541,36 +537,22 @@ func (con Connection) SetServerUserPermissions(ctx *gin.Context) {
}
func LoadGroup(group *gin.RouterGroup, config models.GlobalConfig) {
var instanceManager instancemanager.InstanceManager
var serversDbHandler dbhandler.ServersDbHandler
var serversAuthorizationHandler dbhandler.ServersAuthorizationDbHandler
var err error
if config.InstanceManager.Type == models.DOCKER {
instanceManager, err = docker.NewInstanceManager(config.InstanceManager.Docker)
if err != nil {
panic(err)
}
instanceManager, err := factories.GetInstanceManager(config.InstanceManager)
if err != nil {
panic(err)
}
if config.ServersDatabase.Type == models.MONGO {
serversDbHandler, err = mongo.NewServersDbHandler(*config.ServersDatabase.Mongo)
if err != nil {
panic(err)
}
serversDbHandler, err := factories.GetServersDbHandler(config.ServersDatabase)
if err != nil {
panic(err)
}
if config.ServersAuthorizationDatabase.Type == models.MONGO {
serversAuthorizationHandler, err = mongo.NewAuthorizationHandler(*config.ServersAuthorizationDatabase.Mongo)
if err != nil {
panic(err)
}
serversAuthorizationHandler, err := factories.GetServersAuthorizationDbHandler(config.ServersAuthorizationDatabase)
if err != nil {
panic(err)
}
connection := Connection{
connection := ServersApi{
ServersDbHandler: serversDbHandler,
ServerAuthorization: serversAuthorizationHandler,
InstanceManager: instanceManager,

2
users/go.mod
View File

@ -1,4 +1,4 @@
module git.acooldomain.co/server-manager/backend-kubernetes-go/users
module git.acooldomain.co/server-manager/backend/users
go 1.22.0

47
users/users.go
View File

@ -4,15 +4,15 @@ import (
"encoding/json"
"net/http"
"git.acooldomain.co/server-manager/backend-kubernetes-go/auth"
"git.acooldomain.co/server-manager/backend-kubernetes-go/db_handler/mongo"
"git.acooldomain.co/server-manager/backend-kubernetes-go/dbhandler"
"git.acooldomain.co/server-manager/backend-kubernetes-go/mail"
"git.acooldomain.co/server-manager/backend-kubernetes-go/models"
"git.acooldomain.co/server-manager/backend/auth"
"git.acooldomain.co/server-manager/backend/dbhandler"
"git.acooldomain.co/server-manager/backend/factories"
"git.acooldomain.co/server-manager/backend/mail"
"git.acooldomain.co/server-manager/backend/models"
"github.com/gin-gonic/gin"
)
type Connection struct {
type UsersApi struct {
userPassAuthHandler dbhandler.UserPassAuthanticationDbHandler
tokenHandler dbhandler.InviteTokenDbHandler
mailClient mail.MailClient
@ -25,7 +25,7 @@ type UserResponse struct {
Permissions models.Permission `json:"Permissions"`
}
func (con Connection) GetUsers(ctx *gin.Context) {
func (con UsersApi) GetUsers(ctx *gin.Context) {
users, err := con.userPassAuthHandler.ListUsers(ctx)
if err != nil {
@ -36,7 +36,7 @@ func (con Connection) GetUsers(ctx *gin.Context) {
ctx.JSON(http.StatusOK, users)
}
func (con Connection) GetUser(ctx *gin.Context) {
func (con UsersApi) GetUser(ctx *gin.Context) {
claims, exists := ctx.Get("claims")
if !exists {
ctx.AbortWithStatus(403)
@ -54,7 +54,7 @@ type InviteUser struct {
Permissions models.Permission `json:"Permissions"`
}
func (con Connection) InviteUser(ctx *gin.Context) {
func (con UsersApi) InviteUser(ctx *gin.Context) {
var request InviteUser
json.NewDecoder(ctx.Request.Body).Decode(&request)
@ -78,7 +78,7 @@ type SetUserPermissionsRequest struct {
Permissions models.Permission `json:"Permissions"`
}
func (con Connection) SetUserPermissions(ctx *gin.Context) {
func (con UsersApi) SetUserPermissions(ctx *gin.Context) {
var request SetUserPermissionsRequest
json.NewDecoder(ctx.Request.Body).Decode(&request)
username := ctx.Param("user_id")
@ -92,7 +92,7 @@ func (con Connection) SetUserPermissions(ctx *gin.Context) {
ctx.JSON(200, "OK")
}
func (con Connection) DeleteUser(ctx *gin.Context) {
func (con UsersApi) DeleteUser(ctx *gin.Context) {
username := ctx.Param("user_id")
err := con.userPassAuthHandler.RemoveUser(ctx, username)
@ -106,29 +106,16 @@ func (con Connection) DeleteUser(ctx *gin.Context) {
}
func LoadGroup(group *gin.RouterGroup, config models.GlobalConfig) {
var userAuthHandler dbhandler.UserPassAuthanticationDbHandler
var inviteHandler dbhandler.InviteTokenDbHandler
var mailClient mail.MailClient
var err error
if config.Authentication.UserPass.Type == models.MONGO {
userAuthHandler, err = mongo.NewUserPassAuthHandler(*config.Authentication.UserPass.Mongo)
if err != nil {
panic(err)
}
userAuthHandler, err := factories.GetUserPassAuthDbHandler(config.Authentication.UserPass)
if err != nil {
panic(err)
}
if config.Authentication.UserPass.InviteTokenDatabase.Type == models.MONGO {
inviteHandler, err = mongo.NewInviteTokenDbHandler(*config.Authentication.UserPass.Mongo)
if err != nil {
panic(err)
}
}
inviteHandler, err := factories.GetInviteTokenDbHandler(config.Authentication.UserPass.InviteTokenDatabase)
mailClient = *mail.NewMailClient(config.Email)
mailClient := *mail.NewMailClient(config.Email)
connection := Connection{
connection := UsersApi{
userPassAuthHandler: userAuthHandler,
tokenHandler: inviteHandler,
mailClient: mailClient,

41
utils/constructors.go
View File

@ -1,41 +0,0 @@
package dbhandler
import (
"fmt"
"sync"
"git.acooldomain.co/server-manager/backend-kubernetes-go/db_handler/mongo"
"git.acooldomain.co/server-manager/backend-kubernetes-go/dbhandler"
"git.acooldomain.co/server-manager/backend-kubernetes-go/models"
)
var (
mu sync.Mutex
existingServerAuthHandlers = make(map[string]dbhandler.ServersAuthorizationDbHandler)
)
func configToKey(config any) (string, error) {
switch c := config.(type) {
case models.MongoDBConfig:
return fmt.Sprintf("mongo:%s:%s:%s:%s:%s", c.Url, c.Database, c.Collection, c.Username, c.Password), nil
default:
return "", fmt.Errorf("unknown config format")
}
}
func GetServersAuthDbHandler(config any) (dbhandler.ServersAuthorizationDbHandler, error) {
mu.Lock()
defer mu.Unlock()
key, err := configToKey(config)
if handler, exists := existingServerAuthHandlers[key]; err != nil && exists {
return handler, nil
}
switch c := config.(type) {
case models.MongoDBConfig:
handler, err := mongo.NewServersAuthorizationHandler(c)
return handler, err
}
return nil, fmt.Errorf("Unknown config format")
}

3
utils/go.mod
View File

@ -1,3 +0,0 @@
module git.acooldomain.co/server-manager/backend-kubernetes-go/utils
go 1.22.0