OdbServerAppBase.cpp

#include "OdbServerAppBase.h"
#include "OdbServerAppBase.h"
#include "Logger.h"
 
using namespace Utils;
using namespace std::filesystem;
 
namespace Odb::Lib::App
{
    OdbServerAppBase::OdbServerAppBase(int argc, char* argv[])
        : OdbAppBase(argc, argv)        
    {
    }
 
    bool OdbServerAppBase::preServerRun()
    {
        // override in extended class to configure server or run custom code
        return true;
    }
 
    bool OdbServerAppBase::postServerRun()
    {
        // override in extended class to cleanup server or run custom code
        return true;
    }
 
    OdbServerAppBase::~OdbServerAppBase()
    {
        m_vecControllers.clear();
    }
 
    ExitCode OdbServerAppBase::Run()
    {
        // print usage and exit w/ success
        if (args().help())
        {
            args().printUsage();
            return ExitCode::Success;
        }
 
        // call base class
        if (ExitCode::Success != OdbAppBase::Run()) return ExitCode::FailedInit;
 
        // set Crow's log level
        m_crowApp.loglevel(crow::LogLevel::Info);
 
        // enable HTTP compression
        m_crowApp.use_compression(crow::compression::algorithm::GZIP);
 
        try
        {
            if (args().useHttps())
            {
                path sslDirPath(args().sslDir());
                if (!exists(sslDirPath) || !is_directory(sslDirPath))
                {
                    logerror("SSL was specified but the directory does not exist, exiting...");
                    return ExitCode::FailedInitSslDirDoesNotExist;
                }               
 
                // enable SSL/HTTPS
                m_crowApp.ssl_file((sslDirPath / SSL_CERT_FILE).string(),
                                   (sslDirPath / SSL_KEY_FILE).string());
            }
        }
        catch (boost::wrapexcept<boost::system::system_error>& e)
        {
            // log the error
            logexception(e);
            logerror("SSL was specified but it failed to initialize, exiting...");          
            return ExitCode::FailedInitSsl;
        }
 
        // let subclasses add controller types
        add_controllers();
 
        // register all added controllers' routes
        register_routes();
 
        // set port to passed-in port or default if none supplied
        m_crowApp.port(static_cast<unsigned short>(args().port()));
 
        // set server to use multiple threads
        m_crowApp.multithreaded();
 
        if (!preServerRun()) return ExitCode::PreServerRunFailed;
 
        // run the Crow server
        m_crowApp.run();
 
        if (!postServerRun()) return ExitCode::PostServerRunFailed;
 
        // success!
        return ExitCode::Success;
    }
 
    CrowApp& OdbServerAppBase::crow_app()
    {
        return m_crowApp;
    }
 
    RequestAuthenticationBase& OdbServerAppBase::request_auth()
    {
        return *m_pRequestAuthentication;
    }
 
    void OdbServerAppBase::request_auth(std::unique_ptr<RequestAuthenticationBase> pRequestAuthentication)
    {
        m_pRequestAuthentication = std::move(pRequestAuthentication);
    }
 
    void OdbServerAppBase::register_routes()
    {
        for (const auto& pController : m_vecControllers)
        {
            pController->register_routes();
        }
    }
}