feat(environment): #36: configure environment variable settings globally

.devcontainer/devcontainer.json

@@ -13,6 +13,12 @@
 	// "customizations": {},
 	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
 	"remoteUser": "root",
+	"runArgs": [
+		// This is necessary to avoid having to manually export environment variables from 
+		// the .env file in every terminal session.
+		"--env-file",
+		"${localWorkspaceFolder}/.env"
+	],
 	"customizations": {
 		"vscode": {
 			"extensions": [

.env.example

@@ -1,3 +1,8 @@
+API_HOST=tobemodified
+API_PORT=tobemodified
+API_LOG_LEVEL=tobemodified # Possible values: TRACE (0), DEBUG (1), INFO (2), WARN (3) or ERROR (4)
+API_NUMBER_OF_THREADS=tobemodified # Cannot be less than 1
+
 POSTGRES_HOST=tobemodified
 POSTGRES_PORT=tobemodified
 POSTGRES_DB=tobemodified

CMakeLists.txt

@@ -5,6 +5,7 @@ project(${PROJECT_NAME} CXX)
 file(GLOB_RECURSE sources CONFIGURE_DEPENDS 
   ${CMAKE_SOURCE_DIR}/src/*/*.cpp
   ${CMAKE_SOURCE_DIR}/src/data/models/odb-gen/*.cxx
+  ${CMAKE_SOURCE_DIR}/src/utils/**/*.cpp
 )
 
 set(PROJECT_OBJECTS ${PROJECT_NAME}_lib)

README.md

@@ -16,6 +16,7 @@ For development purposes use a devcontainer named `developing`.
 - Microsoft VS Code
   - VS Code should also have the "Dev Containers" extension installed. To check it, open "View: Extensions" with `Ctrl + Shift + X` or as shown in the screenshot below:
   <p style="text-align: center;"><img src="docs/images/vscodeExtensions.png" alt="vscodeExtensions" width="400"/></p>
+- Before running the container, create a .env file in the project root and specify the environment variables in it, just as you did in .env.example. Otherwise, running the devcontainer will result in an error.
 - Make sure Docker daemon is running before opening the dev container (`Ctrl + Shift + P` -> "Reopen in container" or click here + "Reopen in container")
  <p style="text-align: center;"><img src="docs/images/vscodeContainer.png" alt="vscodeContainer" width="400"/></p>
 
@@ -39,7 +40,7 @@ When dependencies are built, use the command `conan build . -pr:h profiles/to-do
 
 #### Before launching web server:
 - Run the database container via docker compose command `docker compose up -d` from workspace.
-- Import environment variables declared in the `.env` file while in the dev container and using the command `export $(grep -v '^#' .env | xargs)`. If the file containing the environment variables is named something other than `.env`, you should modify the command to specify the correct name.
+- Import the environment variables defined in the .env file in the project root. The environment variables were automatically exported from .env when the container was built. If the contents of the .env file have been modified after the container was built, run the command `export $(grep -v '^#' .env | xargs)`, but keep in mind that the environment variables will only be visible in the terminal session where the command was executed.
 
 To launch the executable, click Launch in the CMake extension.
 <p style="text-align: center;"><img src="docs/images/cmakeLaunch.png" alt="cmakeLaunch" width="400"/></p>
@@ -103,4 +104,4 @@ The alembic tool is used to work with migrations. To work with it, you need to m
 
 Alternatively, you can use make targets.
 - To create a migration, run the command `make create-migration name=<name-of-migration>`, where `name` is the name of the migration. You can also use `make create-migration`, in which case the migration will be named after the current date and time.
-- To apply the migrations, run the `make apply-migrations` command.
+- To apply the migrations, run the `make apply-migrations` command.

src/data/db_connection.cpp

@@ -1,4 +1,5 @@
 #include "db_connection.h"
+#include "../utils/app-config/app-config.h"
 
 #include <cstdlib>
 #include <stdexcept>
@@ -14,15 +15,17 @@ std::shared_ptr<odb::database> DbConnection::get()
         flag,
         []()
         {
-            const std::string user = std::getenv("POSTGRES_USER");
-            const std::string password = std::getenv("POSTGRES_PASSWORD");
-            const std::string db_name = std::getenv("POSTGRES_DB");
-            const std::string host = std::getenv("POSTGRES_HOST");
-            const std::string port = std::getenv("POSTGRES_PORT");
+            auto& config = AppConfig::GetInstance();
 
-            std::string conninfo = "host=" + host + " port=" + port + " dbname=" + db_name + " user=" + user + " password=" + password;
+            const std::string host = config.getDatabaseHost();
+            const std::string port = config.getDatabasePort();
+            const std::string user = config.getDatabaseUser();
+            const std::string password = config.getDatabasePassword();
+            const std::string dbname = config.getDatabaseName();
 
-            instance_ = std::shared_ptr<odb::database>(new odb::pgsql::database(conninfo));
+            std::string conn = "host=" + host + " port=" + port + " dbname=" + dbname + " user=" + user + " password=" + password;
+
+            instance_ = std::shared_ptr<odb::database>(new odb::pgsql::database(conn));
         }
     );
 

src/main.cpp

@@ -1,9 +1,15 @@
+#include "utils/app-config/app-config.h"
 #include <drogon/HttpAppFramework.h>
 
 int main()
 {
-    drogon::app().addListener("127.0.0.1", 8080).setLogLevel(trantor::Logger::kInfo).setThreadNum(1);
+    // We need to set the logging level right away; otherwise, the default level
+    // will be used until .setLogLevel is called
+    drogon::app().setLogLevel(AppConfig::getApiLogLevel());
 
+    auto& config = AppConfig::GetInstance();
+
+    drogon::app().addListener(config.getApiHost(), config.getApiPort()).setThreadNum(config.getApiNumThreads());
     drogon::app().run();
 
     return 0;

src/utils/app-config/app-config.cpp

@@ -0,0 +1,161 @@
+#include "app-config.h"
+
+AppConfig::AppConfig()
+{
+    setApiHost(getEnv("API_HOST", "0.0.0.0"));
+    setApiPort(getEnvInt("API_PORT", 80));
+    setApiNumThreads(getEnvInt("API_NUMBER_OF_THREADS", 1));
+    setDatabaseHost(getEnv("POSTGRES_HOST", "0.0.0.0"));
+    setDatabasePort(getEnv("POSTGRES_PORT", "5432"));
+    setDatabaseName(getEnv("POSTGRES_DB", "to-dos-api-cpp-db"));
+    setDatabaseUser(getEnv("POSTGRES_USER", "postgres"));
+    setDatabasePassword(getEnv("POSTGRES_PASSWORD", "password"));
+}
+
+AppConfig& AppConfig::GetInstance()
+{
+    static AppConfig instance;
+    return instance;
+}
+
+std::string AppConfig::getEnv(std::string name, std::string defaultValue)
+{
+    char* value = std::getenv(name.c_str());
+
+    if (value)
+    {
+        return std::string(value);
+    }
+    else
+    {
+        LOG_WARN << "Failed to get the value of the " << name << " environment variable; the default value will be used: " << defaultValue;
+        return defaultValue;
+    }
+}
+
+uint32_t AppConfig::getEnvInt(std::string name, uint32_t defaultValue)
+{
+    char* value = std::getenv(name.c_str());
+
+    if (!value)
+        return defaultValue;
+
+    try
+    {
+        auto result = std::stoi(value);
+        auto limit = std::numeric_limits<uint32_t>::max();
+
+        if (result < 0 || result > limit)
+            throw std::overflow_error(
+                "error: an attempt to write a " + name + " value which is larger than what can be stored in a " + std::to_string(limit)
+            );
+
+        return static_cast<uint32_t>(result);
+    }
+    catch (const std::exception& e)
+    {
+        LOG_ERROR << e.what();
+        return defaultValue;
+    }
+}
+
+trantor::Logger::LogLevel AppConfig::parseLogLevel(const std::string& level)
+{
+    // kTrace < kDebug < kInfo < kWarn < kError
+    if (level == "TRACE")
+        return trantor::Logger::kTrace;
+    else if (level == "DEBUG")
+        return trantor::Logger::kDebug;
+    else if (level == "INFO")
+        return trantor::Logger::kInfo;
+    else if (level == "WARN")
+        return trantor::Logger::kWarn;
+    else
+        return trantor::Logger::kError;
+}
+
+void AppConfig::setApiHost(std::string apiHost)
+{
+    apiHost_ = apiHost;
+    LOG_DEBUG << "Update value: apiHost_=" << apiHost_;
+};
+
+void AppConfig::setApiPort(uint32_t apiPort)
+{
+    apiPort_ = apiPort;
+    LOG_DEBUG << "Update value: apiPort_=" << apiPort_;
+};
+
+void AppConfig::setApiNumThreads(uint32_t apiNumThreads)
+{
+    uint32_t numberOfThreads = apiNumThreads;
+
+    if (numberOfThreads > 0)
+    {
+        apiNumThreads_ = numberOfThreads;
+    }
+    else
+    {
+        apiNumThreads_ = 1;
+        LOG_ERROR << "The number of allocated threads cannot be less than 1";
+    }
+
+    LOG_DEBUG << "Update value: apiNumThreads_=" << apiNumThreads_;
+};
+
+void AppConfig::setDatabaseHost(std::string databaseHost)
+{
+    databaseHost_ = databaseHost;
+    LOG_DEBUG << "Update value: databaseHost_=" << databaseHost_;
+};
+
+void AppConfig::setDatabasePort(std::string databasePort)
+{
+    databasePort_ = databasePort;
+    LOG_DEBUG << "Update value: databasePort_=" << databasePort_;
+};
+
+void AppConfig::setDatabaseName(std::string databaseName)
+{
+    databaseName_ = databaseName;
+    LOG_DEBUG << "Update value: databaseName_=" << databaseName_;
+};
+
+void AppConfig::setDatabaseUser(std::string databaseUser)
+{
+    databaseUser_ = databaseUser;
+    LOG_DEBUG << "Update value: databaseUser_=" << databaseUser_;
+};
+
+void AppConfig::setDatabasePassword(std::string databasePassword)
+{
+    databasePassword_ = databasePassword;
+    LOG_DEBUG << "Update value: databasePassword_=" << databasePassword_;
+};
+
+const std::string& AppConfig::getApiHost() const
+{ return apiHost_; }
+
+const uint32_t& AppConfig::getApiPort() const
+{ return apiPort_; }
+
+const uint32_t& AppConfig::getApiNumThreads() const
+{ return apiNumThreads_; }
+
+const trantor::Logger::LogLevel AppConfig::getApiLogLevel()
+{ return parseLogLevel(getEnv("API_LOG_LEVEL", "INFO")); }
+
+const std::string& AppConfig::getDatabaseHost() const
+{ return databaseHost_; }
+
+const std::string& AppConfig::getDatabasePort() const
+{ return databasePort_; }
+
+const std::string& AppConfig::getDatabaseName() const
+{ return databaseName_; }
+
+const std::string& AppConfig::getDatabaseUser() const
+{ return databaseUser_; }
+
+const std::string& AppConfig::getDatabasePassword() const
+{ return databasePassword_; }