httpserver.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_HTTP
#include <functional>
#include <promeki/function.h>
#include <promeki/namespace.h>
#include <promeki/objectbase.h>
#include <promeki/error.h>
#include <promeki/socketaddress.h>
#include <promeki/list.h>
#include <promeki/uniqueptr.h>
#include <promeki/httprouter.h>
#include <promeki/httprequest.h>
#include <promeki/httpresponse.h>
#include <promeki/httpconnection.h>
#include <promeki/variant.h>
#include <promeki/variantdatabase.h>
#include <promeki/variantlookup.h>
#include <promeki/variantspec.h>
#include <promeki/json.h>
#include <promeki/stringlist.h>
#include <promeki/sslcontext.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class TcpServer;
class EventLoop;
class WebSocket;
 
class HttpServer : public ObjectBase {
                PROMEKI_OBJECT(HttpServer, ObjectBase)
        public:
                explicit HttpServer(ObjectBase *parent = nullptr);
 
                ~HttpServer() override;
 
                // ----------------------------------------------------
                // Listening
                // ----------------------------------------------------
 
                Error listen(const SocketAddress &address, int backlog = 50);
 
                Error listen(uint16_t port, int backlog = 50);
 
                void close();
 
                bool isListening() const;
 
                SocketAddress serverAddress() const;
 
                // ----------------------------------------------------
                // Routing
                // ----------------------------------------------------
 
                HttpRouter &router() { return _router; }
 
                const HttpRouter &router() const { return _router; }
 
                void route(const String &pattern, const HttpMethod &method, HttpHandlerFunc handler);
 
                void route(const String &pattern, const HttpMethod &method, HttpHandler::Ptr handler);
 
                void any(const String &pattern, HttpHandlerFunc handler);
 
                void use(HttpMiddleware middleware);
 
                using WebSocketHandler = Function<void(WebSocket *socket, const HttpRequest &request)>;
 
                void routeWebSocket(const String &pattern, WebSocketHandler handler);
 
                // ----------------------------------------------------
                // Reflection adapters
                // ----------------------------------------------------
 
                template <CompiledString N>
                void exposeDatabase(const String &mountPath, VariantDatabase<N> &db, bool readOnly = false);
 
                template <typename T> void exposeLookup(const String &mountPath, T &target);
 
                // ----------------------------------------------------
                // Per-connection tuning (applied to every new connection)
                // ----------------------------------------------------
 
                void setIdleTimeoutMs(unsigned int ms) { _idleTimeoutMs = ms; }
 
                void setMaxBodyBytes(int64_t bytes) { _maxBodyBytes = bytes; }
 
                int connectionCount() const;
 
                void setSslContext(SslContext ctx) { _sslContext = std::move(ctx); }
 
                SslContext sslContext() const { return _sslContext; }
 
                static bool hasTlsSupport() { return SslContext::hasTlsSupport(); }
 
                PROMEKI_SIGNAL(requestReceived, HttpRequest);
 
                PROMEKI_SIGNAL(responseSent, HttpRequest, HttpResponse);
 
                PROMEKI_SIGNAL(errorOccurred, Error);
 
        private:
                void onNewConnection();
                void dispatchRequest(HttpRequest &request, HttpResponse &response);
                void reapClosedConnection(HttpConnection *conn);
 
                EventLoop           *_loop = nullptr;
                UniquePtr<TcpServer> _tcpServer;
                int                  _acceptHandle = -1;
                HttpRouter           _router;
                HttpConnection::List _connections;
 
                unsigned int    _idleTimeoutMs = HttpConnection::DefaultIdleTimeoutMs;
                int64_t         _maxBodyBytes = HttpConnection::DefaultMaxBodyBytes;
                SslContext _sslContext;
 
                // Helpers for the reflection adapters; non-template
                // because the per-key plumbing doesn't depend on the
                // database's compile-time Name tag.
                static JsonObject specToJson(const VariantSpec &spec);
                static String     lookupPathToKey(const String &slashPath);
};
 
// ============================================================
// Reflection adapter template definitions
// ============================================================
 
template <CompiledString N>
void HttpServer::exposeDatabase(const String &mountPath, VariantDatabase<N> &db, bool readOnly) {
        using DB = VariantDatabase<N>;
        using ID = typename DB::ID;
 
        // Full snapshot.
        route(mountPath, HttpMethod::Get, [&db](const HttpRequest &, HttpResponse &res) { res.setJson(db.toJson()); });
 
        // Schema introspection.  Keys not yet present in the
        // database still appear here when a spec was declared at
        // static-init time.
        const String schemaPath = mountPath + "/_schema";
        route(schemaPath, HttpMethod::Get, [](const HttpRequest &, HttpResponse &res) {
                JsonObject out;
                const auto specs = DB::registeredSpecs();
                for (auto it = specs.cbegin(); it != specs.cend(); ++it) {
                        const String name = ID::fromId(it->first).name();
                        out.set(name, HttpServer::specToJson(it->second));
                }
                res.setJson(out);
        });
 
        // Per-key get.
        const String keyPath = mountPath + "/{key}";
        route(keyPath, HttpMethod::Get, [&db](const HttpRequest &req, HttpResponse &res) {
                const String name = req.pathParam("key");
                ID           id = ID::find(name);
                if (!id.isValid() || !db.contains(id)) {
                        res = HttpResponse::notFound(String("Unknown key: ") + name);
                        return;
                }
                JsonObject out;
                out.setFromVariant(name, db.get(id));
                const VariantSpec *sp = DB::spec(id);
                if (sp != nullptr) {
                        out.set("_spec", HttpServer::specToJson(*sp));
                }
                res.setJson(out);
        });
 
        if (readOnly) return;
 
        // Per-key set.
        route(keyPath, HttpMethod::Put, [&db](const HttpRequest &req, HttpResponse &res) {
                const String name = req.pathParam("key");
                Error        perr;
                JsonObject   body = req.bodyAsJson(&perr);
                if (perr.isError() || !body.contains("value")) {
                        res = HttpResponse::badRequest("Body must be JSON object with a \"value\" field");
                        return;
                }
                // Snapshot the value via JsonObject::forEach,
                // which converts the underlying nlohmann json
                // into a typed @ref Variant — that's the path
                // that setFromJson knows how to coerce
                // against the registered spec.
                ID      id(name);
                Variant captured;
                body.forEach([&](const String &k, const Variant &val) {
                        if (k == "value") captured = val;
                });
                Error serr = db.setFromJson(id, captured);
                if (serr.isError()) {
                        res = HttpResponse::badRequest(String("Validation failed for key '") + name +
                                                       "': " + serr.desc());
                        return;
                }
                JsonObject out;
                out.setFromVariant(name, db.get(id));
                res.setJson(out);
        });
 
        // Per-key delete.
        route(keyPath, HttpMethod::Delete, [&db](const HttpRequest &req, HttpResponse &res) {
                const String name = req.pathParam("key");
                ID           id = ID::find(name);
                if (!id.isValid() || !db.contains(id)) {
                        res = HttpResponse::notFound(String("Unknown key: ") + name);
                        return;
                }
                db.remove(id);
                res = HttpResponse::noContent();
        });
}
 
template <typename T> void HttpServer::exposeLookup(const String &mountPath, T &target) {
        const String greedy = mountPath + "/{path:*}";
        route(greedy, HttpMethod::Get, [&target](const HttpRequest &req, HttpResponse &res) {
                const String key = HttpServer::lookupPathToKey(req.pathParam("path"));
                if (key.isEmpty()) {
                        res = HttpResponse::badRequest("Empty lookup key");
                        return;
                }
                Error err;
                auto  v = VariantLookup<T>::resolve(target, key, &err);
                if (!v.hasValue() || err.isError()) {
                        res = HttpResponse::notFound(String("Unknown lookup: ") + key);
                        return;
                }
                JsonObject out;
                out.setFromVariant("value", *v);
                res.setJson(out);
        });
}
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_HTTP