backend/factories/dbhandlers.go

package factories

import (
	"context"
	"errors"
	"log"
	"sync"
	"time"

	"git.acooldomain.co/server-manager/backend/dbhandler"
	"git.acooldomain.co/server-manager/backend/dbhandler/mongo"
	"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

	ctx, cancel := context.WithTimeoutCause(context.Background(), 5*time.Second, errors.New("Timeout"))
	defer cancel()
	if config.InitialUser == nil {
		return handler, nil
	}

	count, _ := handler.CountUsers(ctx)
	if count == 0 {
		log.Printf("Trying to create user %#v\n", config.InitialUser)
		err := handler.CreateUser(ctx, config.InitialUser.Username, config.InitialUser.Password, models.Admin, config.InitialUser.Email, 10)
		if err != nil {
			log.Printf("Failed to create initial user %e\n", err)
		}
	}
	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
}