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() FL_NOEXCEPT = default;

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

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

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

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

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

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

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

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

    bool has_body() const { 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_NOEXCEPT;

    Response& status(int code);

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

    Response& body(const string& content);

    Response& json(const class json& data);

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

    static Response not_found();

    static Response bad_request(const string& message);

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

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

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

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

    bool start(int port = 8080);

    void stop();

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

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

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

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

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

    size_t update();

    bool is_running() const { return mRunning; }

    int port() const { return mPort; }

    string last_error() const { return mLastError; }
 
private:
    // EngineEvents::Listener implementation
    void onExit() 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);
    void accept_connections();
    size_t process_requests();
    optional<Request> read_request(ClientConnection& client);
    bool send_response(int client_fd, const Response& response);
    optional<RouteHandler> find_handler(const string& method, const string& path) const;
    void close_client(size_t index);
    void cleanup_stale_connections();
 
#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);
#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