server.h

Go to the documentation of this file.

 
#pragma once
 
#include "fl/stl/int.h"
#include "fl/stl/unique_ptr.h"
#include "fl/stl/function.h"
#include "fl/stl/string.h"
#include "fl/stl/vector.h"
#include "fl/stl/optional.h"
#include "fl/stl/map.h"
#include "fl/system/engine_events.h"
#include "platforms/esp/is_esp.h"  // ok platform headers - for FL_IS_ESP32  // IWYU pragma: keep
#include "fl/stl/noexcept.h"
 
namespace fl {
namespace asio {
namespace http {

class Request {
public:
    Request() = default; // ok no noexcept: infer member exception contracts (#4773)

    const string& method() const FL_NO_EXCEPT { return mMethod; }

    const string& path() const FL_NO_EXCEPT { return mPath; }

    const string& body() const FL_NO_EXCEPT { return mBody; }

    const string& http_version() const FL_NO_EXCEPT { return mHttpVersion; }

    optional<string> header(const string& name) const FL_NO_EXCEPT;

    optional<string> query(const string& param) const FL_NO_EXCEPT;

    bool is_get() const FL_NO_EXCEPT { return mMethod == "GET"; }

    bool is_post() const FL_NO_EXCEPT { return mMethod == "POST"; }

    bool has_body() const FL_NO_EXCEPT { return !mBody.empty(); }
 
private:
    friend class Server;
 
    string mMethod;
    string mPath;
    string mHttpVersion;
    string mBody;
    map<string, string> mHeaders;
    map<string, string> mQuery;
};

class Response {
public:
    Response() FL_NO_EXCEPT;

    Response& status(int code) FL_NO_EXCEPT;

    Response& header(const string& name, const string& value) FL_NO_EXCEPT;

    Response& body(const string& content) FL_NO_EXCEPT;

    Response& json(const class json& data) FL_NO_EXCEPT;

    static Response ok(const string& body = "") FL_NO_EXCEPT;

    static Response not_found() FL_NO_EXCEPT;

    static Response bad_request(const string& message) FL_NO_EXCEPT;

    static Response internal_error(const string& message) FL_NO_EXCEPT;
 
private:
    friend class Server;
 
    int mStatusCode = 200;
    string mBody;
    map<string, string> mHeaders;
 
    string to_string() const FL_NO_EXCEPT;
};

using RouteHandler = function<Response(const Request&)>;

class Server : public EngineEvents::Listener {
public:
    Server() FL_NO_EXCEPT;

    ~Server() FL_NO_EXCEPT;
 
    // Non-copyable
    Server(const Server&) FL_NO_EXCEPT = delete;
    Server& operator=(const Server&) FL_NO_EXCEPT = delete;

    bool start(int port = 8080) FL_NO_EXCEPT;

    void stop() FL_NO_EXCEPT;

    void route(const string& method, const string& path, RouteHandler handler) FL_NO_EXCEPT;

    void get(const string& path, RouteHandler handler) FL_NO_EXCEPT;

    void post(const string& path, RouteHandler handler) FL_NO_EXCEPT;

    void put(const string& path, RouteHandler handler) FL_NO_EXCEPT;

    void del(const string& path, RouteHandler handler) FL_NO_EXCEPT;

    size_t update() FL_NO_EXCEPT;

    bool is_running() const FL_NO_EXCEPT { return mRunning; }

    int port() const FL_NO_EXCEPT { return mPort; }

    string last_error() const FL_NO_EXCEPT { return mLastError; }
 
private:
    // EngineEvents::Listener implementation
    void onExit() FL_NO_EXCEPT override;
 
    // Forward declaration for async integration helper
    class ServerAsyncRunner;
    struct RouteEntry {
        string method;
        string path;
        RouteHandler handler;
    };
 
    struct ClientConnection {
        int fd = -1;
        u32 connect_time = 0;
        string buffer;
    };
 
    int mPort = 0;
    int mListenSocket = -1;
    bool mRunning = false;
    string mLastError;
 
    vector<RouteEntry> mRoutes;
    vector<ClientConnection> mClientSockets;
 
    // Async system integration
    fl::unique_ptr<ServerAsyncRunner> mAsyncRunner;
 
    bool setup_listen_socket(int port) FL_NO_EXCEPT;
    void accept_connections() FL_NO_EXCEPT;
    size_t process_requests() FL_NO_EXCEPT;
    optional<Request> read_request(ClientConnection& client) FL_NO_EXCEPT;
    bool send_response(int client_fd, const Response& response) FL_NO_EXCEPT;
    optional<RouteHandler> find_handler(const string& method, const string& path) const FL_NO_EXCEPT;
    void close_client(size_t index) FL_NO_EXCEPT;
    void cleanup_stale_connections() FL_NO_EXCEPT;
 
#ifdef FL_IS_ESP32
public:
    // ESP32: Static handler bridging esp_http_server callbacks to RouteHandlers.
    // Declared public so the C callback wrapper can call it.
    // Parameter is httpd_req_t* cast to void* to avoid ESP-IDF header dependency.
    static int handle_esp_request(void* req) FL_NO_EXCEPT;
#endif
};
 
} // namespace http
} // namespace asio
 
// Convenience type aliases for common use
using HttpServer = asio::http::Server;
using http_request = asio::http::Request;
using http_response = asio::http::Response;
 
} // namespace fl