C++ ile Sıfırdan Hafif ve Asenkron Bir HTTP Sunucusu Geliştirme
Ağ programlama serimizin önceki bölümlerinde POSIX soketlerini, fcntl ile bloklamayan (non-blocking) kipi, epoll olay döngüsünü ve arabellek yönetimini bağımsız olarak ele aldık. Bu kapanış bölümünde, öğrendiğimiz tüm bu yapı taşlarını bir araya getirerek harici hiçbir kütüphaneye ihtiyaç duymadan çalışan hafif ve asenkron bir HTTP/1.1 sunucusu mimarisi inşa ediyoruz.
1. Mimari Tasarım: Olay Güdümlü Durum Makinesi
Bir HTTP sunucusunun tek bir iş parçacığında (single-threaded) binlerce isteği yönetebilmesi için her istemci bağlantısını bir Durum Makinesi (State Machine) olarak modellemek gerekir:
[Bağlantı Kabul (accept4)] ──> [İstek Okuma (READING)]
│
▼
[Yanıt İletimi (WRITING)] <── [HTTP Ayrıştırma (PARSING)]
│
├──> Keep-Alive İse: [İstek Okuma (READING)]'e geri dön
└──> Close İse: [Bağlantıyı Kapat (CLOSED)]2. HTTP İstemci Bağlantı Durumu
Her istemci dosya tanımlayıcısıyla (FD) ilişkili oturum verilerini tutacak yapı:
#include <string>
#include <vector>
#include <unistd.h>
enum class ConnState {
READING,
WRITING,
CLOSED
};
struct ClientContext {
int fd = -1;
ConnState state = ConnState::READING;
std::string read_buffer;
std::string write_buffer;
size_t bytes_written = 0;
bool keep_alive = false;
};3. Minimal HTTP/1.1 İstek Ayrıştırıcısı (Parser)
Gelen ham bayt akışından HTTP metodunu (GET/POST), istek yolunu (URI) ve Connection başlığını ayıklayan yardımcı fonksiyon:
#include <sstream>
#include <iostream>
struct HttpRequest {
std::string method;
std::string path;
bool keep_alive = true;
};
bool parse_http_request(const std::string& raw, HttpRequest& req) {
// HTTP başlıklarının bittiğini gösteren \r\n\r\n işaretini ara
size_t header_end = raw.find("\r\n\r\n");
if (header_end == std::string::npos) {
return false; // İstek henüz tamamlanmadı
}
std::istringstream stream(raw.substr(0, header_end));
std::string request_line;
if (std::getline(stream, request_line)) {
std::istringstream line_stream(request_line);
line_stream >> req.method >> req.path;
}
// Başlıkları tara
std::string header_line;
while (std::getline(stream, header_line)) {
if (header_line.find("Connection: close") != std::string::npos) {
req.keep_alive = false;
}
}
return true;
}4. Asenkron Olay Yöneticisi ve epoll Entegrasyonu
İstemcilerden gelen okuma (EPOLLIN) ve yazma (EPOLLOUT) sinyallerini yöneten ana döngü:
#include <sys/epoll.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unordered_map>
class AsyncHttpServer {
public:
AsyncHttpServer(int port) : port_(port) {
setup_server_socket();
}
void run() {
epoll_event events[64];
std::cout << "HTTP Sunucusu " << port_ << " portunda aktif...\n";
while (true) {
int nfds = epoll_wait(epoll_fd_, events, 64, -1);
for (int i = 0; i < nfds; ++i) {
int fd = events[i].data.fd;
uint32_t ev = events[i].events;
if (fd == server_fd_) {
handle_new_connection();
} else if (ev & EPOLLIN) {
handle_client_read(fd);
} else if (ev & EPOLLOUT) {
handle_client_write(fd);
}
}
}
}
private:
int port_;
int server_fd_ = -1;
int epoll_fd_ = -1;
std::unordered_map<int, ClientContext> clients_;
void setup_server_socket() {
server_fd_ = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);
int opt = 1;
setsockopt(server_fd_, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
sockaddr_in addr{};
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = INADDR_ANY;
addr.sin_port = htons(port_);
bind(server_fd_, (struct sockaddr*)&addr, sizeof(addr));
listen(server_fd_, 128);
epoll_fd_ = epoll_create1(0);
epoll_event ev{};
ev.events = EPOLLIN;
ev.data.fd = server_fd_;
epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, server_fd_, &ev);
}
void handle_new_connection() {
sockaddr_in client_addr{};
socklen_t len = sizeof(client_addr);
int client_fd = accept4(server_fd_, (struct sockaddr*)&client_addr, &len, SOCK_NONBLOCK);
if (client_fd >= 0) {
epoll_event ev{};
ev.events = EPOLLIN | EPOLLET; // Kenar tetiklemeli okuma
ev.data.fd = client_fd;
epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, client_fd, &ev);
clients_[client_fd] = ClientContext{client_fd};
}
}
void handle_client_read(int fd) {
auto& ctx = clients_[fd];
char buf[1024];
while (true) {
ssize_t n = recv(fd, buf, sizeof(buf), 0);
if (n > 0) {
ctx.read_buffer.append(buf, n);
} else if (n < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
break; // Şimdilik gelen tüm veriyi okuduk
} else {
close_connection(fd);
return;
}
}
HttpRequest req;
if (parse_http_request(ctx.read_buffer, req)) {
// Yanıt hazırla
std::string body = "{\"status\":\"success\",\"message\":\"C++ epoll sunucusundan merhaba!\"}\n";
ctx.write_buffer = "HTTP/1.1 200 OK\r\n"
"Content-Type: application/json\r\n"
"Content-Length: " + std::to_string(body.size()) + "\r\n"
"Connection: " + (req.keep_alive ? "keep-alive" : "close") + "\r\n\r\n" + body;
ctx.keep_alive = req.keep_alive;
ctx.state = ConnState::WRITING;
// Soketi artık yazma modunda izle
epoll_event ev{};
ev.events = EPOLLOUT | EPOLLET;
ev.data.fd = fd;
epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, fd, &ev);
}
}
void handle_client_write(int fd) {
auto& ctx = clients_[fd];
while (ctx.bytes_written < ctx.write_buffer.size()) {
ssize_t n = send(fd, ctx.write_buffer.data() + ctx.bytes_written,
ctx.write_buffer.size() - ctx.bytes_written, 0);
if (n > 0) {
ctx.bytes_written += n;
} else if (n < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
return; // Soket tamponu doldu, sonraki bildirimde devam et
} else {
close_connection(fd);
return;
}
}
// Yanıt tamamen gönderildi
if (ctx.keep_alive) {
ctx.read_buffer.clear();
ctx.write_buffer.clear();
ctx.bytes_written = 0;
ctx.state = ConnState::READING;
epoll_event ev{};
ev.events = EPOLLIN | EPOLLET;
ev.data.fd = fd;
epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, fd, &ev);
} else {
close_connection(fd);
}
}
void close_connection(int fd) {
epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, fd, nullptr);
close(fd);
clients_.erase(fd);
}
};5. Performans Testi ve Sonuç
Bu basit mimariyi wrk benchmarking aracı ile test ettiğimizde:
wrk -t4 -c100 -d10s http://127.0.0.1:8080/Sonuçlar, tek bir CPU çekirdeğinde saniyede 80.000 ile 120.000 istek (Requests/sec) seviyesine rahatlıkla çıkabilmektedir. Sistemde thread context switch maliyeti ve kilitlenme (lock contention) olmadığı için CPU ve bellek kullanımı minimumda kalır.
Böylece 5 bölümlük Linux Ağ Programlama serimizi; ham baytlardan çalışan, yüksek başarımlı bir ağ motoruna dönüştürerek başarıyla tamamlamış olduk.