Drogon C++ Framework

Drogon is a high-performance C++17/20 HTTP application framework designed for building various types of Web App servers. It is cross-platform, supporting Linux, macOS, FreeBSD/OpenBSD, HaikuOS, and Windows.

Key Features:

• High Performance: Uses a non-blocking IO framework based on epoll (or kqueue on macOS/FreeBSD).
• Asynchronous Programming: Fully asynchronous logic and support for C++ coroutines.
• Protocol Support: HTTP 1.0/1.1, HTTPS (via OpenSSL), and WebSocket (client and server).
• Templating & Views: Supports CSP (C++ Server Pages) templates where C++ code is embedded in HTML, and dynamic loading of view pages via .so files.
• Database Support: Asynchronous access to PostgreSQL, MySQL (MariaDB), Redis, and SQLite3 (via thread pool).
• RESTful API Support: Built-in JSON request/response handling and flexible path-to-handler mapping.
• Tooling: Includes drogon_ctl, a command-line tool to simplify controller and view code generation.
• Advanced Features: Supports cookies, built-in sessions, Gzip/Brotli compression, pipelining, and a lightweight ORM.

For standard web pages or simple logic, inherit from HttpSimpleController<T>. This allows you to define routes using the PATH_LIST macros. This approach is highly recommended for maintaining clean code and is the standard way to implement controllers.

You can generate the boilerplate for these controllers using the command: drogon_ctl create controller <ControllerName>.

/// The TestCtrl.h file
#pragma once
#include <drogon/HttpSimpleController.h>

using namespace drogon;

class TestCtrl : public HttpSimpleController<TestCtrl>
{
public:
    void asyncHandleHttpRequest(const HttpRequestPtr& req, std::function<void (const HttpResponsePtr &)> &&callback) override;
    PATH_LIST_BEGIN
    PATH_ADD("/test", Get);
    PATH_LIST_END
};

/// The TestCtrl.cc file
#include "TestCtrl.h"

void TestCtrl::asyncHandleHttpRequest(const HttpRequestPtr& req,
                                      std::function<void (const HttpResponsePtr &)> &&callback)
{
    HttpResponsePtr resp = HttpResponse::newHttpResponse();
    resp->setBody("<p>Hello, world!</p>");
    resp->setExpiredTime(0);
    callback(resp);
}

To build RESTful APIs, inherit from HttpController<T>. This class provides the METHOD_LIST macros, which allow you to map specific HTTP methods (Get, Post, etc.) and complex path parameters (e.g., /{id}) to specific member functions. This is the preferred way to handle parameterized routes and RESTful resource management.

/// The header file
#pragma once
#include <drogon/HttpController.h>

using namespace drogon;

namespace api::v1
{
class User : public HttpController<User>
{
  public:
    METHOD_LIST_BEGIN
    METHOD_ADD(User::getInfo, "/{id}", Get); 
    METHOD_ADD(User::getDetailInfo, "/{id}/detailinfo", Get); 
    METHOD_ADD(User::newUser, "/{name}", Post); 
    METHOD_LIST_END

    void getInfo(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback, int userId) const;
    void getDetailInfo(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback, int userId) const;
    void newUser(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback, std::string &&userName);
  public:
    User()
    {
        LOG_DEBUG << "User constructor!";
    }
};
}

A Drogon application can be initialized in several ways depending on the complexity of your requirements.

1. Programmatic Configuration

You can configure the application directly in main() using the app() singleton. This is useful for simple setups.

2. Configuration via JSON File

For production applications, it is recommended to use a JSON configuration file to keep the main() function clean.

3. Inline Lambda Handlers

For extremely simple logic, you can register handlers directly in main() using lambdas. However, this is not recommended for complex applications as it leads to unreadable code.

// Programmatic configuration
int main()
{
    app().setLogPath("./")
         .setLogLevel(trantor::Logger::kWarn)
         .addListener("0.0.0.0", 80)
         .setThreadNum(16)
         .enableRunAsDaemon()
         .run();
}

// Configuration via JSON file
int main()
{
    app().loadConfigFile("./config.json").run();
}

// Inline Lambda Handler (not recommended for complex apps)
app().registerHandler("/test?username={name}",
                    [](const HttpRequestPtr& req,
                       std::function<void (const HttpResponsePtr &)> &&callback,
                       const std::string &name) -> void
                    {
                        Json::Value json;
                        json["result"] = "ok";
                        json["message"] = "hello, " + name;
                        HttpResponsePtr resp = HttpResponse::newHttpJsonResponse(json);
                        callback(resp);
                    },
                    {Get, "LoginFilter"});

Drogon provides a variety of examples to demonstrate different capabilities of the framework, ranging from basic 'Hello World' applications to complex implementations involving WebSockets, Redis, and RESTful APIs. Use these examples to understand specific patterns for:

• Basic Web Services: helloworld (multiple ways to implement a basic server).
• Client-side Operations: client_example (HTTP client) and websocket_client (WebSocket client).
• Session & Security: login_session (built-in session management) and cors (Cross-Origin Resource Sharing).
• Data & Storage: redis (Redis integration), redis_cache (using coroutines with Redis), jsonstore (building RESTful APIs with in-memory storage), and redis_chat (combining WebSockets with Redis pub/sub).
• Advanced Networking: file_upload (handling file uploads), simple_reverse_proxy (implementing an HTTP reverse proxy with round-robin), and websocket_server (a chat room server).
• Observability & Performance: prometheus_example (using the Prometheus exporter) and benchmark (basic performance testing).