http_server.h

Go to the documentation of this file.

 
#pragma once
 
#include <atomic>
#include <cstdint>
#include <functional>
#include <string>
#include <thread>
#include <unordered_map>
#include <vector>
 
#include "json.h"
 
namespace ascii_query {
 
struct HttpRequest {
  std::string method;                                   
  std::string path;                                     
  std::string query_string;                             
  std::unordered_map<std::string, std::string> headers; 
  std::unordered_map<std::string, std::string> params;  
  std::string body;                                     
 
  [[nodiscard]] std::string param(const std::string &name, const std::string &default_value = "") const {
    auto it = params.find(name);
    return (it != params.end()) ? it->second : default_value;
  }
 
  [[nodiscard]] bool hasParam(const std::string &name) const {
    return params.find(name) != params.end();
  }
 
  [[nodiscard]] int paramInt(const std::string &name, int default_value = 0) const {
    auto it = params.find(name);
    if (it == params.end())
      return default_value;
    try {
      return std::stoi(it->second);
    } catch (...) {
      return default_value;
    }
  }
 
  [[nodiscard]] std::string header(const std::string &name, const std::string &default_value = "") const;
};
 
struct HttpResponse {
  int status_code = 200;
  std::string status_text = "OK";
  std::unordered_map<std::string, std::string> headers;
  std::string body;
 
  HttpResponse() = default;
  HttpResponse(int code, std::string text, std::string content_type, std::string response_body)
      : status_code(code), status_text(std::move(text)), body(std::move(response_body)) {
    headers["Content-Type"] = std::move(content_type);
  }
 
  // Convenience constructors
  static HttpResponse ok(const std::string &content_type, const std::string &body) {
    return HttpResponse(200, "OK", content_type, body);
  }
 
  static HttpResponse json(const std::string &body) {
    return ok("application/json", body);
  }
 
  static HttpResponse html(const std::string &body) {
    return ok("text/html; charset=utf-8", body);
  }
 
  static HttpResponse text(const std::string &body) {
    return ok("text/plain", body);
  }
 
  static HttpResponse notFound(const std::string &message = "Not Found") {
    return HttpResponse(404, "Not Found", "application/json", R"({"error":")" + json::escape(message) + R"("})");
  }
 
  static HttpResponse badRequest(const std::string &message = "Bad Request") {
    return HttpResponse(400, "Bad Request", "application/json", R"({"error":")" + json::escape(message) + R"("})");
  }
 
  static HttpResponse serverError(const std::string &message = "Internal Server Error") {
    return HttpResponse(500, "Internal Server Error", "application/json",
                        R"({"error":")" + json::escape(message) + R"("})");
  }
 
  static HttpResponse noContent() {
    return HttpResponse(204, "No Content", "text/plain", "");
  }
 
  HttpResponse &setHeader(const std::string &name, const std::string &value) {
    headers[name] = value;
    return *this;
  }
 
  [[nodiscard]] std::string serialize() const;
};
 
using RouteHandler = std::function<HttpResponse(const HttpRequest &)>;
 
class HttpServer {
public:
  HttpServer();
  ~HttpServer();
 
  // Non-copyable
  HttpServer(const HttpServer &) = delete;
  HttpServer &operator=(const HttpServer &) = delete;
 
  void addRoute(const std::string &method, const std::string &path, RouteHandler handler);
 
  void setDefaultHandler(RouteHandler handler);
 
  bool start(uint16_t port);
 
  void stop();
 
  [[nodiscard]] bool isRunning() const {
    return running_;
  }
 
  [[nodiscard]] uint16_t port() const {
    return port_;
  }
 
  [[nodiscard]] const std::string &lastError() const {
    return last_error_;
  }
 
  bool processOneRequest();
 
private:
  struct Route {
    std::string method;
    std::string path;
    RouteHandler handler;
  };
 
  std::vector<Route> routes_;
  RouteHandler default_handler_;
 
  std::atomic<bool> running_{false};
  std::thread server_thread_;
  uint16_t port_ = 0;
  int server_socket_ = -1;
  std::string last_error_;
 
  void serverLoop();
  void handleClient(int client_socket);
  bool parseRequest(const std::string &raw, HttpRequest &request);
  void parseQueryString(const std::string &query, std::unordered_map<std::string, std::string> &params);
  std::string urlDecode(const std::string &str);
  RouteHandler findHandler(const std::string &method, const std::string &path);
};
 
} // namespace ascii_query