uvco::examples Namespace Reference

Namespaces
namespace	anonymous_namespace{http_server.cc}

Classes
struct	HttpRequest
struct	HttpResponse
class	Router

Typedefs
using	HttpHandler = std::function<Promise<HttpResponse>(const HttpRequest &)>

Functions
Promise< HttpResponse >	notFoundHandler (const HttpRequest &request)
	A handler returning a 404 error.
Promise< void >	connectionHandler (TcpStream stream, const Router &router)
Promise< void >	httpServer (TcpServer &server, Router router)

Function Documentation

connectionHandler()

Promise< void > uvco::examples::connectionHandler	(	TcpStream	stream,
		const Router &	router )

                                                                        {
  while (true) {
    const std::optional<std::string> headersStrOpt =
        co_await readHeaders(stream);
    if (!headersStrOpt) {
      co_await handleBadRequest(stream);
      co_return;
    }
 
    const std::optional<HttpRequest> requestOpt = parseRequest(*headersStrOpt);
    if (!requestOpt) {
      co_await handleBadRequest(stream);
      co_return;
    }
 
    const HttpRequest &request = *requestOpt;
 
    bool closeConnection = true;
    for (const auto &header : request.headers) {
      if (boost::iequals(header.first, "connection") &&
          boost::iequals(header.second, "keep-alive")) {
        closeConnection = false;
        break;
      }
    }
 
    HttpResponse response;
    const HttpHandler handler = router.getHandler(std::string(request.path));
    if (handler) {
      response = co_await handler(request);
    } else {
      response = co_await notFoundHandler(request);
    }
 
    if (closeConnection) {
      response.headers.emplace_back("Connection", "close");
    } else {
      response.headers.emplace_back("Connection", "keep-alive");
    }
 
    co_await stream.write(response.toString());
 
    if (closeConnection) {
      stream.close();
      co_return;
    }
  }
}