server.cpp File Reference

Implements an HTTP server using Boost.Beast and Boost.Asio to serve GitHub user data. More...

#include "server.hpp"
#include "user.hpp"
#include <boost/asio.hpp>
#include <boost/asio/signal_set.hpp>
#include <boost/beast/core.hpp>
#include <boost/beast/http.hpp>
#include <boost/beast/version.hpp>
#include <nlohmann/json.hpp>
#include <iostream>
#include <memory>
#include <string>
#include <thread>
#include <vector>

Go to the source code of this file.

Data Structures
class	HttpSession
	Manages a single HTTP session with a client. More...

Typedefs
using	tcp = net::ip::tcp

Functions
void	start_http_server (int port)
	Starts the HTTP server on the specified port.

Detailed Description

Implements an HTTP server using Boost.Beast and Boost.Asio to serve GitHub user data.

Definition in file server.cpp.

Typedef Documentation

tcp

using tcp = net::ip::tcp

Definition at line 26 of file server.cpp.

Function Documentation

start_http_server()

void start_http_server

(

int

port

)

Starts the HTTP server on the specified port.

Starts the HTTP server.

Sets up an io_context, signal handlers for graceful shutdown, and an asynchronous TCP acceptor to listen for and handle incoming HTTP connections using HttpSession.

The server runs in a multi-threaded fashion, utilizing all available hardware threads.

Parameters

port	The port number on which the HTTP server should listen.

Lambda for accepting incoming connections recursively.

This lambda captures itself and re-issues accept calls until the server is stopped.

Definition at line 130 of file server.cpp.

                                 {
  try {
    net::io_context ioc{};
 
    // Set up signal handling for clean shutdown
    net::signal_set signals(ioc, SIGINT, SIGTERM);
    signals.async_wait([&](auto, auto) {
      std::cout << "\nShutting down server...\n";
      ioc.stop();
    });
 
    tcp::acceptor acceptor{ioc, {tcp::v4(), static_cast<unsigned short>(port)}};
 
    /**
     * @brief Lambda for accepting incoming connections recursively.
     *
     * This lambda captures itself and re-issues accept calls until the server
     * is stopped.
     */
    auto do_accept = [&](auto &&self) -> void {
      acceptor.async_accept(
          [&](beast::error_code error_code, tcp::socket socket) {
            if (!error_code) {
              std::make_shared<HttpSession>(std::move(socket))->start();
            }
            if (!ioc.stopped()) {
              self(self); // Accept next connection
            }
          });
    };
 
    do_accept(do_accept);
 
    std::cout << "Server started on port " << port
              << ". Visit http://localhost:" << port << "/USERNAME\n";
    std::cout << "Press Ctrl+C to quit.\n";
 
    // Run io_context on multiple threads
    const auto num_threads = std::max(1U, std::thread::hardware_concurrency());
    std::vector<std::thread> threads;
    threads.reserve(num_threads - 1);
 
    for (unsigned i = 0; i < num_threads - 1; ++i) {
      threads.emplace_back([&ioc]() { ioc.run(); });
    }
 
    ioc.run();
 
    for (auto &thread : threads) {
      thread.join();
    }
  } catch (const std::exception &e) {
    std::cerr << "Server error: " << e.what() << "\n";
  }
}