refactored

factories/dbhandlers.go

@@ -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
+}

factories/go.mod

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

factories/instancemanagers.go

@@ -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
+}