feat: Integrate new webserver (#1722)

For #919.
The new web server is not using dosguard yet. It will be fixed by a
separate PR.

src/app/ClioApplication.cpp

@@ -26,25 +26,39 @@
 #include "etl/NetworkValidatedLedgers.hpp"
 #include "feed/SubscriptionManager.hpp"
 #include "rpc/Counters.hpp"
+#include "rpc/Errors.hpp"
 #include "rpc/RPCEngine.hpp"
 #include "rpc/WorkQueue.hpp"
 #include "rpc/common/impl/HandlerProvider.hpp"
+#include "util/Assert.hpp"
 #include "util/build/Build.hpp"
 #include "util/config/Config.hpp"
 #include "util/log/Logger.hpp"
+#include "util/prometheus/Http.hpp"
 #include "util/prometheus/Prometheus.hpp"
+#include "web/AdminVerificationStrategy.hpp"
 #include "web/RPCServerHandler.hpp"
 #include "web/Server.hpp"
+#include "web/SubscriptionContextInterface.hpp"
 #include "web/dosguard/DOSGuard.hpp"
 #include "web/dosguard/IntervalSweepHandler.hpp"
 #include "web/dosguard/WhitelistHandler.hpp"
+#include "web/ng/Connection.hpp"
+#include "web/ng/RPCServerHandler.hpp"
+#include "web/ng/Request.hpp"
+#include "web/ng/Response.hpp"
+#include "web/ng/Server.hpp"
 
 #include <boost/asio/io_context.hpp>
+#include <boost/asio/spawn.hpp>
+#include <boost/beast/http/status.hpp>
 
 #include <cstdint>
 #include <cstdlib>
+#include <exception>
 #include <memory>
 #include <thread>
+#include <utility>
 #include <vector>
 
 namespace app {
@@ -79,7 +93,7 @@ ClioApplication::ClioApplication(util::Config const& config) : config_(config),
 }
 
 int
-ClioApplication::run()
+ClioApplication::run(bool const useNgWebServer)
 {
     auto const threads = config_.valueOr("io_threads", 2);
     if (threads <= 0) {
@@ -126,9 +140,91 @@ ClioApplication::run()
     auto const rpcEngine =
         RPCEngineType::make_RPCEngine(config_, backend, balancer, dosGuard, workQueue, counters, handlerProvider);
 
+    if (useNgWebServer or config_.valueOr("server.__ng_web_server", false)) {
+        web::ng::RPCServerHandler<RPCEngineType, etl::ETLService> handler{config_, backend, rpcEngine, etl};
+
+        auto expectedAdminVerifier = web::make_AdminVerificationStrategy(config_);
+        if (not expectedAdminVerifier.has_value()) {
+            LOG(util::LogService::error()) << "Error creating admin verifier: " << expectedAdminVerifier.error();
+            return EXIT_FAILURE;
+        }
+        auto const adminVerifier = std::move(expectedAdminVerifier).value();
+
+        auto httpServer = web::ng::make_Server(config_, ioc);
+
+        if (not httpServer.has_value()) {
+            LOG(util::LogService::error()) << "Error creating web server: " << httpServer.error();
+            return EXIT_FAILURE;
+        }
+
+        httpServer->onGet(
+            "/metrics",
+            [adminVerifier](
+                web::ng::Request const& request,
+                web::ng::ConnectionMetadata& connectionMetadata,
+                web::SubscriptionContextPtr,
+                boost::asio::yield_context
+            ) -> web::ng::Response {
+                auto const maybeHttpRequest = request.asHttpRequest();
+                ASSERT(maybeHttpRequest.has_value(), "Got not a http request in Get");
+                auto const& httpRequest = maybeHttpRequest->get();
+
+                // FIXME(#1702): Using veb server thread to handle prometheus request. Better to post on work queue.
+                auto maybeResponse = util::prometheus::handlePrometheusRequest(
+                    httpRequest, adminVerifier->isAdmin(httpRequest, connectionMetadata.ip())
+                );
+                ASSERT(maybeResponse.has_value(), "Got unexpected request for Prometheus");
+                return web::ng::Response{std::move(maybeResponse).value(), request};
+            }
+        );
+
+        util::Logger webServerLog{"WebServer"};
+        auto onRequest = [adminVerifier, &webServerLog, &handler](
+                             web::ng::Request const& request,
+                             web::ng::ConnectionMetadata& connectionMetadata,
+                             web::SubscriptionContextPtr subscriptionContext,
+                             boost::asio::yield_context yield
+                         ) -> web::ng::Response {
+            LOG(webServerLog.info()) << connectionMetadata.tag()
+                                     << "Received request from ip = " << connectionMetadata.ip()
+                                     << " - posting to WorkQueue";
+
+            connectionMetadata.setIsAdmin([&adminVerifier, &request, &connectionMetadata]() {
+                return adminVerifier->isAdmin(request.httpHeaders(), connectionMetadata.ip());
+            });
+
+            try {
+                return handler(request, connectionMetadata, std::move(subscriptionContext), yield);
+            } catch (std::exception const&) {
+                return web::ng::Response{
+                    boost::beast::http::status::internal_server_error,
+                    rpc::makeError(rpc::RippledError::rpcINTERNAL),
+                    request
+                };
+            }
+        };
+
+        httpServer->onPost("/", onRequest);
+        httpServer->onWs(onRequest);
+
+        auto const maybeError = httpServer->run();
+        if (maybeError.has_value()) {
+            LOG(util::LogService::error()) << "Error starting web server: " << *maybeError;
+            return EXIT_FAILURE;
+        }
+
+        // Blocks until stopped.
+        // When stopped, shared_ptrs fall out of scope
+        // Calls destructors on all resources, and destructs in order
+        start(ioc, threads);
+
+        return EXIT_SUCCESS;
+    }
+
     // Init the web server
     auto handler =
         std::make_shared<web::RPCServerHandler<RPCEngineType, etl::ETLService>>(config_, backend, rpcEngine, etl);
+
     auto const httpServer = web::make_HttpServer(config_, ioc, dosGuard, handler);
 
     // Blocks until stopped.