Server/SourceFiles/Core/AppInitializer.cpp - master - Shymer123/LumenServer

Server/SourceFiles/Core/AppInitializer.cpp
278 строк14 KB
Shymer123
corrected build.sh in terms of checking the env file, the generation of the default config has been fixed (server -> Server).
08 авг 2026, 17:36
08 авг 2026, 17:368664d5b
#include "AppInitializer.h"
#include "System/ConfigPaths.h"
#ifdef LUMEN_HAS_MYSQL
#include "Storage/Db/Implementations/MySQLDatabase.h"
#endif
#ifdef LUMEN_HAS_POSTGRESQL
#include "Storage/Db/Implementations/PostgreSQLDatabase.h"
#endif
#include "Network/ResponseContext.h"
#include "RuntimeContext.h"
#include "Runtime.h"
#include <iostream>

namespace Core {
    AppInitializer::AppInitializer(int& argc, char** argv)
    {
        (void)argc;
        (void)argv;
    }

    AppInitializer::~AppInitializer() {}

    bool AppInitializer::initialize()
    {
        if(m_initialized)
        {
            return true;
        }

        try {
            loadSettings();
            setupDatabase();
            setupRepositories();
            setupServices();
            setupMiddleware();
            setupControllers();
            setupHandlers();
            setupThreadPool();
            setupRouter();

            std::cout << "[AppInit] Successful initialized" << std::endl;
            m_initialized = true;
            return true;
        } catch (const std::exception& e) {
            std::cerr << "[AppInit] Initialization failed: " << e.what() << std::endl;
            return false;
        }
    }

    void AppInitializer::run()
    {
        if(!m_initialized)
        {
            throw std::runtime_error("[AppInit] AppInitializer not initialized");
        }

        RuntimeContext ctx(m_dependencies.settings, m_dependencies.router.get(),
                           m_dependencies.threadPoolManager.get());
        m_runtime = std::make_unique<Runtime>(ctx);

        m_runtime->setExitSignal(&m_exitCv, &m_exitMutex);
        m_runtime->start();

        {
            std::unique_lock<std::mutex> lock(m_exitMutex);
            m_exitCv.wait(lock);
        }

        m_runtime->stop();

        std::cout << "[AppInit] Server shutdown complete" << std::endl;
    }

    void AppInitializer::loadSettings()
    {
        m_dependencies.settings.loadConfig(System::ConfigPaths::configFile());
    }

    void AppInitializer::setupDatabase()
    {
        size_t connectionsCount = m_dependencies.settings.databaseSettings().poolSize();

        auto factory = [this]() -> std::unique_ptr<Storage::Db::IDatabase> {
            switch (m_dependencies.settings.databaseSettings().type())
            {
#ifdef LUMEN_HAS_MYSQL
                case Core::Types::DbType::MySQL:
                    return std::make_unique<Storage::Db::Implementations::MySQLDatabase>();
#endif // ifdef LUMEN_HAS_MYSQL
#ifdef LUMEN_HAS_POSTGRESQL
                case Core::Types::DbType::PostgreSQL:
                    return std::make_unique<Storage::Db::Implementations::PostgreSQLDatabase>();
#endif // ifdef LUMEN_HAS_POSTGRESQL
                default:
                    throw std::runtime_error("Unsupported database type");
            }
        };

        m_dependencies.database.dbManager = std::make_unique<Storage::Db::DatabaseManager>(connectionsCount, factory);
        if (!m_dependencies.database.dbManager->connect(m_dependencies.settings.databaseSettings()))
        {
            throw std::runtime_error("Database connection failed");
        }
    }

    void AppInitializer::setupRepositories()
    {
        auto& db = *m_dependencies.database.dbManager;

        m_dependencies.database.authRepo = std::make_unique<Storage::Db::Repositories::AuthRepository>(db);
        m_dependencies.database.chatRepo = std::make_unique<Storage::Db::Repositories::ChatRepository>(db);
        m_dependencies.database.contactRepo = std::make_unique<Storage::Db::Repositories::ContactRepository>(db);
        m_dependencies.database.messageRepo = std::make_unique<Storage::Db::Repositories::MessageRepository>(db);
        m_dependencies.database.sessionRepo = std::make_unique<Storage::Db::Repositories::SessionRepository>(db);
        m_dependencies.database.fileRepo = std::make_unique<Storage::Db::Repositories::FileRepository>(db);
    }

    void AppInitializer::setupServices()
    {
        auto& dbDeps = m_dependencies.database;

        m_dependencies.services.tokenService = std::make_unique<Services::TokenService>(*dbDeps.sessionRepo,
                                                                                        m_dependencies.settings.securitySettings());
        m_dependencies.services.authService = std::make_unique<Services::AuthService>(*dbDeps.authRepo,
                                                                                      *m_dependencies.services.tokenService);
        m_dependencies.services.fileService = std::make_unique<Services::FileService>(*dbDeps.fileRepo);
        m_dependencies.services.messageService = std::make_unique<Services::MessageService>(*dbDeps.messageRepo,
                                                                                            *m_dependencies.services.fileService);
        m_dependencies.services.chatService = std::make_unique<Services::ChatService>(*dbDeps.chatRepo,
                                                                                      *m_dependencies.services.messageService);
        m_dependencies.services.contactService = std::make_unique<Services::ContactService>(*dbDeps.contactRepo,
                                                                                             *m_dependencies.services.authService);
    }

    void AppInitializer::setupMiddleware()
    {
        m_dependencies.authMiddleware = std::make_unique<Middleware::AuthMiddleware>(*m_dependencies.services.tokenService);
    }

    void AppInitializer::setupControllers()
    {
        auto& services = m_dependencies.services;

        m_dependencies.controllers.authController = std::make_unique<Controllers::AuthController>(*services.authService);
        m_dependencies.controllers.chatController = std::make_unique<Controllers::ChatController>(*services.chatService);
        m_dependencies.controllers.contactController = std::make_unique<Controllers::ContactController>(*services.contactService);
        m_dependencies.controllers.messageController = std::make_unique<Controllers::MessageController>(*services.messageService);
        m_dependencies.controllers.fileController = std::make_unique<Controllers::FileController>(*services.fileService);
    }

    void AppInitializer::setupHandlers()
    {
        auto& controllers = m_dependencies.controllers;
        auto& authMiddleware = m_dependencies.authMiddleware;

        m_dependencies.handlers.authHandler = std::make_unique<Network::Handlers::AuthHandler>(*controllers.authController,
                                                                                               *authMiddleware);
        m_dependencies.handlers.chatHandler = std::make_unique<Network::Handlers::ChatHandler>(*controllers.chatController,
                                                                                               *authMiddleware);
        m_dependencies.handlers.contactHandler = std::make_unique<Network::Handlers::ContactHandler>(*controllers.contactController,
                                                                                                     *authMiddleware);
        m_dependencies.handlers.messageHandler = std::make_unique<Network::Handlers::MessageHandler>(*controllers.messageController,
                                                                                                     *authMiddleware);
        m_dependencies.handlers.fileHandler = std::make_unique<Network::Handlers::FileHandler>(*controllers.fileController,
                                                                                               *authMiddleware);
    }

    void AppInitializer::setupThreadPool()
    {
        size_t netThreadsCount = m_dependencies.settings.threadSettings().networkThreadsCount();
        size_t workerThreadsCount = m_dependencies.settings.threadSettings().workerThreadsCount();
        m_dependencies.threadPoolManager = std::make_unique<Infrastructure::ThreadPoolManager>(netThreadsCount, workerThreadsCount);
    }

    void AppInitializer::setupRouter()
    {
        m_dependencies.router = std::make_unique<Network::Router>(m_dependencies.threadPoolManager->workers());
        auto& handlers = m_dependencies.handlers;

        m_dependencies.router->registerJsonHandler("get_auth_data", [&handlers](const nlohmann::json& req, Network::ResponseContext& responseCtx) {
            auto result = handlers.authHandler->handleGetAuthData(req);
            responseCtx.sendJson(result);
        });
        m_dependencies.router->registerJsonHandler("login", [&handlers](const nlohmann::json& req, Network::ResponseContext& responseCtx) {
            auto result = handlers.authHandler->handleLogin(req);
            responseCtx.sendJson(result);
        });
        m_dependencies.router->registerJsonHandler("register", [&handlers](const nlohmann::json& req, Network::ResponseContext& responseCtx) {
            auto result = handlers.authHandler->handleRegister(req);
            responseCtx.sendJson(result);
        });
        m_dependencies.router->registerJsonHandler("auto_login", [&handlers](const nlohmann::json& req, Network::ResponseContext& responseCtx) {
            auto result = handlers.authHandler->handleAutoLogin(req);
            responseCtx.sendJson(result);
        });
        m_dependencies.router->registerJsonHandler("logout", [&handlers](const nlohmann::json& req, Network::ResponseContext& responseCtx) {
            Network::RequestContext ctx;
            auto result = handlers.authHandler->handleLogout(req, ctx);
            responseCtx.sendJson(result);
        });

        m_dependencies.router->registerJsonHandler("get_chats", [&handlers](const nlohmann::json& req, Network::ResponseContext& responseCtx) {
            Network::RequestContext ctx;
            auto result = handlers.chatHandler->handleGetChats(req, ctx);
            responseCtx.sendJson(result);
        });
        m_dependencies.router->registerJsonHandler("create_dialog", [&handlers](const nlohmann::json& req, Network::ResponseContext& responseCtx) {
            Network::RequestContext ctx;
            auto result = handlers.chatHandler->handleCreateDialog(req, ctx);
            responseCtx.sendJson(result);
        });
        m_dependencies.router->registerJsonHandler("create_group", [&handlers](const nlohmann::json& req, Network::ResponseContext& responseCtx) {
            Network::RequestContext ctx;
            auto result = handlers.chatHandler->handleCreateGroup(req, ctx);
            responseCtx.sendJson(result);
        });
        m_dependencies.router->registerJsonHandler("add_members", [&handlers](const nlohmann::json& req, Network::ResponseContext& responseCtx) {
            Network::RequestContext ctx;
            auto result = handlers.chatHandler->handleAddMembers(req, ctx);
            responseCtx.sendJson(result);
        });

        m_dependencies.router->registerJsonHandler("send_message", [&handlers](const nlohmann::json& req, Network::ResponseContext& responseCtx) {
            Network::RequestContext ctx;
            auto result = handlers.messageHandler->handleSendMessage(req, ctx);
            responseCtx.sendJson(result);
        });
        m_dependencies.router->registerJsonHandler("get_messages", [&handlers](const nlohmann::json& req, Network::ResponseContext& responseCtx) {
            Network::RequestContext ctx;
            auto result = handlers.messageHandler->handleGetMessages(req, ctx);
            responseCtx.sendJson(result);
        });

        m_dependencies.router->registerJsonHandler("get_contacts", [&handlers](const nlohmann::json& req, Network::ResponseContext& responseCtx) {
            Network::RequestContext ctx;
            auto result = handlers.contactHandler->handleGetContacts(req, ctx);
            responseCtx.sendJson(result);
        });
        m_dependencies.router->registerJsonHandler("add_contact", [&handlers](const nlohmann::json& req, Network::ResponseContext& responseCtx) {
            Network::RequestContext ctx;
            auto result = handlers.contactHandler->handleAddContact(req, ctx);
            responseCtx.sendJson(result);
        });
        m_dependencies.router->registerJsonHandler("remove_contact", [&handlers](const nlohmann::json& req, Network::ResponseContext& responseCtx) {
            Network::RequestContext ctx;
            auto result = handlers.contactHandler->handleRemoveContact(req, ctx);
            responseCtx.sendJson(result);
        });

        m_dependencies.router->registerJsonHandler("start_upload_file", [&handlers](const nlohmann::json& req, Network::ResponseContext& responseCtx) {
            Network::RequestContext ctx;
            auto result = handlers.fileHandler->handleStartUpload(req, ctx);
            responseCtx.sendJson(result);
        });
        m_dependencies.router->registerFileHandler("upload_chunk_file", [&handlers](const nlohmann::json& req, const std::vector<std::byte>& rawData,
                                                                 Network::ResponseContext& responseCtx) {
            Network::RequestContext ctx;
            auto result = handlers.fileHandler->handleUploadChunk(req, rawData, ctx);
            responseCtx.sendJson(result);
        });
        m_dependencies.router->registerJsonHandler("complete_upload_file", [&handlers](const nlohmann::json& req, Network::ResponseContext& responseCtx) {
            Network::RequestContext ctx;
            auto result = handlers.fileHandler->handleCompleteUpload(req, ctx);
            responseCtx.sendJson(result);
        });
        m_dependencies.router->registerJsonHandler("download_chunk_file", [&handlers](const nlohmann::json& req, Network::ResponseContext& responseCtx) {
            Network::RequestContext ctx;
            auto result = handlers.fileHandler->handleDownloadChunk(req, ctx);
            responseCtx.sendFile(result.first, result.second);
        });
        m_dependencies.router->registerJsonHandler("cancel_upload_file", [&handlers](const nlohmann::json& req, Network::ResponseContext& responseCtx) {
            Network::RequestContext ctx;
            auto result = handlers.fileHandler->handleCancelUpload(req, ctx);
            responseCtx.sendJson(result);
        });
    }

} // namespace Core