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

added more stuff including some of docker support

Browse Source
This commit is contained in:
ACoolName
2025-03-15 21:16:17 +02:00
parent 4b9c30be7e
commit 5f99ec77a0
22 changed files with 1009 additions and 261 deletions
Download Patch File Download Diff File Expand all files Collapse all files

156
db_handler/mongo/authorization.go
View File

@@ -1,156 +0,0 @@
package mongo
import (
"context"
"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 ServerPermissions struct {
Username string `json:"username"`
ServerId string `json:"server_id"`
Permissions models.Permission `json:"permissions"`
}
type MongoDbAuthorizationHandler struct {
dbhandler.AuthorizationDbHandler
collection *mongo.Collection
}
func (self *MongoDbAuthorizationHandler) RemoveUser(username string) error {
_, err := self.collection.DeleteMany(
context.Background(),
bson.D{
{Key: "username", Value: username},
},
)
return err
}
func (self *MongoDbAuthorizationHandler) RemoveServer(serverId string) error {
_, err := self.collection.DeleteMany(
context.Background(),
bson.D{
{Key: "server_id", Value: serverId},
},
)
return err
}
func (self *MongoDbAuthorizationHandler) AddPermissions(username string, serverId string, permissions models.Permission) error {
var serverPermissions ServerPermissions
err := self.collection.FindOne(
context.Background(),
bson.D{
{Key: "username", Value: username},
{Key: "server_id", Value: serverId},
},
).Decode(&serverPermissions)
if err != nil {
return err
}
newPermissions := serverPermissions.Permissions | permissions
_, err = self.collection.UpdateOne(
context.Background(),
bson.D{
{Key: "username", Value: username},
{Key: "server_id", Value: serverId},
},
bson.M{"$set": bson.M{
"permissions": newPermissions,
},
},
)
return err
}
func (self *MongoDbAuthorizationHandler) RemovePermissions(username string, serverId string, permissions models.Permission) error {
var serverPermissions ServerPermissions
err := self.collection.FindOne(
context.Background(),
bson.D{
{Key: "username", Value: username},
{Key: "server_id", Value: serverId},
},
).Decode(&serverPermissions)
if err != nil {
return err
}
newPermissions := serverPermissions.Permissions | permissions ^ permissions
_, err = self.collection.UpdateOne(
context.Background(),
bson.D{
{Key: "username", Value: username},
{Key: "server_id", Value: serverId},
},
bson.M{"$set": bson.M{
"permissions": newPermissions,
},
},
)
return err
}
func (self *MongoDbAuthorizationHandler) SetPermissions(username string, serverId string, permissions models.Permission) error {
_, err := self.collection.UpdateOne(
context.Background(),
bson.D{
{Key: "username", Value: username},
{Key: "server_id", Value: serverId},
},
bson.M{"$set": bson.M{
"permissions": permissions,
},
},
)
return err
}
func (self *MongoDbAuthorizationHandler) GetPermissions(username string, serverId string) (models.Permission, error) {
var serverPermissions ServerPermissions
err := self.collection.FindOne(
context.Background(),
bson.D{
{Key: "username", Value: username},
{Key: "server_id", Value: serverId},
},
).Decode(&serverPermissions)
if err != nil {
return 0, err
}
return serverPermissions.Permissions, nil
}
func NewAuthorizationHandler(config models.MongoDBConfig) (*MongoDbAuthorizationHandler, error) {
clientOptions := options.Client().ApplyURI(config.Url).SetAuth(options.Credential{
Username: config.Username,
Password: config.Password,
})
client, err := mongo.Connect(context.TODO(), clientOptions)
if err != nil {
return nil, err
}
return &MongoDbAuthorizationHandler{
collection: client.Database(config.Database).Collection(config.Collection),
}, nil
}

192
db_handler/mongo/servers.go Normal file
View File

@@ -0,0 +1,192 @@
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 Image struct {
Registry string `bson:"registry"`
Tag string `bson:"tag"`
}
type Port struct {
PublicPort uint16 `bson:"public_port"`
ContainerPort uint16 `bson:"container_port"`
Protocol models.PortProtocol `bson:"protocol"`
}
type Server struct {
Id string `bson:"id"`
Owner string `bson:"owner"`
Image Image `bson:"image"`
Nickname string `bson:"nickname"`
Command string `bson:"command"`
Ports []Port `bson:"ports"`
}
func convertToDbServer(server dbhandler.Server) Server {
ports := make([]Port, len(server.Ports))
for i, port := range server.Ports {
ports[i] = Port{
PublicPort: port.PublicPort,
ContainerPort: port.ContainerPort,
Protocol: port.Protocol,
}
}
return Server{
Id: server.Id,
Owner: server.Owner,
Image: Image{
Registry: server.Image.Registry,
Tag: server.Image.Tag,
},
Nickname: server.Nickname,
Command: server.Command,
Ports: ports,
}
}
func convertToResponseServer(server Server) dbhandler.Server {
ports := make([]models.Port, len(server.Ports))
for i, port := range server.Ports {
ports[i] = models.Port{
PublicPort: port.PublicPort,
ContainerPort: port.ContainerPort,
Protocol: port.Protocol,
}
}
return dbhandler.Server{
Id: server.Id,
Owner: server.Owner,
Image: &models.Image{
Registry: server.Image.Registry,
Tag: server.Image.Tag,
},
Nickname: server.Nickname,
Command: server.Command,
Ports: ports,
}
}
type ServersDbHandler struct {
dbhandler.ServersDbHandler
collection *mongo.Collection
}
func (self *ServersDbHandler) ListServers(ctx context.Context) ([]dbhandler.Server, error) {
var servers []Server
cursor, err := self.collection.Find(ctx, bson.M{})
if err != nil {
return nil, err
}
defer cursor.Close(ctx)
err = cursor.All(ctx, &servers)
if err != nil {
return nil, err
}
dbServers := make([]dbhandler.Server, len(servers))
for i, server := range servers {
dbServers[i] = convertToResponseServer(server)
}
return dbServers, nil
}
func (self *ServersDbHandler) GetServer(ctx context.Context, serverId string) (*dbhandler.Server, error) {
var server Server
err := self.collection.FindOne(ctx, bson.M{"server_id": serverId}).Decode(&server)
if err != nil {
return nil, err
}
responseServer := convertToResponseServer(server)
return &responseServer, nil
}
func (self *ServersDbHandler) CreateServer(ctx context.Context, server dbhandler.Server) error {
dbServer := convertToDbServer(server)
_, err := self.collection.InsertOne(ctx, &dbServer)
return err
}
func (self *ServersDbHandler) DeleteServer(ctx context.Context, serverId string) error {
_, err := self.collection.DeleteOne(ctx, bson.M{
"server_id": serverId,
})
return err
}
func (self *ServersDbHandler) UpdateServer(ctx context.Context, serverId string, updateParams dbhandler.ServerUpdateRequest) error {
updateServerRequest := bson.M{}
if updateParams.Owner != "" {
updateServerRequest["owner"] = updateParams.Owner
}
if updateParams.Image != nil {
updateServerRequest["image"] = bson.M{
"registry": updateParams.Image.Registry,
"tag": updateParams.Image.Tag,
}
}
if updateParams.Ports != nil {
ports := make([]bson.M, len(updateParams.Ports))
for i, port := range updateParams.Ports {
ports[i] = bson.M{
"number": port.PublicPort,
"protocol": port.Protocol,
}
}
}
if updateParams.Nickname != "" {
updateServerRequest["nickname"] = updateParams.Nickname
}
if updateParams.Command != "" {
updateServerRequest["command"] = updateParams.Command
}
_, err := self.collection.UpdateOne(ctx, bson.M{"server_id": serverId}, bson.M{"$set": updateServerRequest})
return err
}
func NewServersDbHandler(config models.MongoDBConfig) (*ServersDbHandler, 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 &ServersDbHandler{
collection: client.Database(config.Database).Collection(config.Collection),
}, nil
}

161
db_handler/mongo/servers_authorization.go Normal file
View File

@@ -0,0 +1,161 @@
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 ServerPermissions struct {
Username string `bson:"username"`
ServerId string `bson:"server_id"`
Permissions models.Permission `bson:"permissions"`
}
type AuthorizationDbHandler struct {
dbhandler.ServersAuthorizationDbHandler
collection *mongo.Collection
}
func (self *AuthorizationDbHandler) RemoveUser(ctx context.Context, username string) error {
_, err := self.collection.DeleteMany(
ctx,
bson.M{
"username": username,
},
)
return err
}
func (self *AuthorizationDbHandler) RemoveServer(ctx context.Context, serverId string) error {
_, err := self.collection.DeleteMany(
ctx,
bson.M{
"server_id": serverId,
},
)
return err
}
func (self *AuthorizationDbHandler) AddPermissions(ctx context.Context, username string, serverId string, permissions models.Permission) error {
var serverPermissions ServerPermissions
err := self.collection.FindOne(
ctx,
bson.M{
"username": username,
"server_id": serverId,
},
).Decode(&serverPermissions)
if err != nil {
return err
}
newPermissions := serverPermissions.Permissions | permissions
_, err = self.collection.UpdateOne(
ctx,
bson.M{
"username": username,
"server_id": serverId,
},
bson.M{"$set": bson.M{
"permissions": newPermissions,
},
},
)
return err
}
func (self *AuthorizationDbHandler) RemovePermissions(ctx context.Context, username string, serverId string, permissions models.Permission) error {
var serverPermissions ServerPermissions
err := self.collection.FindOne(
ctx,
bson.M{
"username": username,
"server_id": serverId,
},
).Decode(&serverPermissions)
if err != nil {
return err
}
newPermissions := serverPermissions.Permissions | permissions ^ permissions
_, err = self.collection.UpdateOne(
ctx,
bson.M{
"username": username,
"server_id": serverId,
},
bson.M{"$set": bson.M{
"permissions": newPermissions,
},
},
)
return err
}
func (self *AuthorizationDbHandler) SetPermissions(ctx context.Context, username string, serverId string, permissions models.Permission) error {
_, err := self.collection.UpdateOne(
ctx,
bson.M{
"username": username,
"server_id": serverId,
},
bson.M{"$set": bson.M{
"permissions": permissions,
},
},
)
return err
}
func (self *AuthorizationDbHandler) GetPermissions(ctx context.Context, username string, serverId string) (models.Permission, error) {
var serverPermissions ServerPermissions
err := self.collection.FindOne(
ctx,
bson.M{
"username": username,
"server_id": serverId,
},
).Decode(&serverPermissions)
if err != nil {
return 0, err
}
return serverPermissions.Permissions, nil
}
func NewAuthorizationHandler(config models.MongoDBConfig) (*AuthorizationDbHandler, 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 &AuthorizationDbHandler{
collection: client.Database(config.Database).Collection(config.Collection),
}, nil
}

38
db_handler/mongo/user_pass_authentication.go
View File

@@ -3,6 +3,7 @@ package mongo
import (
"context"
"fmt"
"time"
"git.acooldomain.co/server-manager/backend-kubernetes-go/dbhandler"
"git.acooldomain.co/server-manager/backend-kubernetes-go/models"
@@ -23,14 +24,14 @@ type Invite struct {
Token string `json:"token"`
}
type MongoDbUserPassHandler struct {
type UserPassAuthenticationDbHandler struct {
dbhandler.UserPassAuthanticationDbHandler
collection *mongo.Collection
}
func (self *MongoDbUserPassHandler) AuthenticateUser(username string, password string) (models.Permission, error) {
func (self *UserPassAuthenticationDbHandler) AuthenticateUser(ctx context.Context, username string, password string) (models.Permission, error) {
var user AuthUser
err := self.collection.FindOne(context.Background(), bson.D{bson.E{Key: "username", Value: username}}).Decode(&user)
err := self.collection.FindOne(ctx, bson.M{"username": username}).Decode(&user)
if err != nil {
return 0, err
@@ -49,7 +50,8 @@ func (self *MongoDbUserPassHandler) AuthenticateUser(username string, password s
return user.Permissions, nil
}
func (self *MongoDbUserPassHandler) CreateUser(
func (self *UserPassAuthenticationDbHandler) CreateUser(
ctx context.Context,
username string,
password string,
permissions models.Permission,
@@ -60,7 +62,7 @@ func (self *MongoDbUserPassHandler) CreateUser(
return err
}
_, err = self.collection.InsertOne(context.Background(), &AuthUser{
_, err = self.collection.InsertOne(ctx, &AuthUser{
Username: username,
HashedPassword: hashedPassword,
Permissions: permissions,
@@ -69,25 +71,26 @@ func (self *MongoDbUserPassHandler) CreateUser(
return err
}
func (self *MongoDbUserPassHandler) RemoveUser(username string) error {
func (self *UserPassAuthenticationDbHandler) RemoveUser(ctx context.Context, username string) error {
_, err := self.collection.DeleteOne(
context.Background(),
bson.D{
{Key: "username", Value: username},
ctx,
bson.M{
"username": username,
},
)
return err
}
func (self *MongoDbUserPassHandler) SetPermissions(
func (self *UserPassAuthenticationDbHandler) SetPermissions(
ctx context.Context,
username string,
permissions models.Permission,
) error {
_, err := self.collection.UpdateOne(
context.Background(),
bson.D{
{Key: "username", Value: username},
ctx,
bson.M{
"username": username,
},
bson.M{
"$set": bson.M{
@@ -99,19 +102,22 @@ func (self *MongoDbUserPassHandler) SetPermissions(
return err
}
func NewUserPassAuthHandler(config models.MongoDBConfig) (*MongoDbUserPassHandler, error) {
func NewUserPassAuthHandler(config models.MongoDBConfig) (*UserPassAuthenticationDbHandler, error) {
clientOptions := options.Client().ApplyURI(config.Url).SetAuth(options.Credential{
Username: config.Username,
Password: config.Password,
})
client, err := mongo.Connect(context.TODO(), clientOptions)
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 &MongoDbUserPassHandler{
return &UserPassAuthenticationDbHandler{
collection: client.Database(config.Database).Collection(config.Collection),
}, nil
}

69
db_handler/mongo/users.go
View File

@@ -2,6 +2,8 @@ package mongo
import (
"context"
"fmt"
"time"
"git.acooldomain.co/server-manager/backend-kubernetes-go/dbhandler"
"git.acooldomain.co/server-manager/backend-kubernetes-go/models"
@@ -10,44 +12,60 @@ import (
"go.mongodb.org/mongo-driver/mongo/options"
)
type MongoDbUserHandler struct {
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 *MongoDbUserHandler) GetUser(username string) (*dbhandler.User, error) {
users, err := self.collection.Find(context.TODO(), bson.D{bson.E{Key: "username", Value: username}})
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
}
var user dbhandler.User
err = users.Decode(&user)
if err != nil {
return nil, err
}
return &user, nil
return &dbhandler.User{
Username: user.Username,
Email: user.Email,
Nickname: user.Nickname,
}, nil
}
func (self *MongoDbUserHandler) ListUsers() ([]dbhandler.User, error) {
users, err := self.collection.Find(context.TODO(), bson.D{})
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 response []dbhandler.User
users.All(nil, &response)
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 *MongoDbUserHandler) CreateUser(user dbhandler.User) error {
_, err := self.collection.InsertOne(context.TODO(), &dbhandler.User{
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,
@@ -60,19 +78,28 @@ func (self *MongoDbUserHandler) CreateUser(user dbhandler.User) error {
return nil
}
func NewUsersHandler(config models.MongoDBConfig) (*MongoDbUserHandler, error) {
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,
})
client, err := mongo.Connect(context.TODO(), clientOptions)
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 &MongoDbUserHandler{
return &UsersDbHandler{
collection: client.Database(config.Database).Collection(config.Collection),
}, nil
}