* Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved.
*/
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <unistd.h>
#include <atomic>
#include <chrono>
#include <cstring>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
#include <thread>
class MockHttpServer {
private:
std::atomic<bool> running_{false};
std::thread serverThread_;
int serverSocket_{-1};
int port_;
std::map<std::string, std::string> responses_;
std::string generateResponse(int statusCode, const std::string& body,
const std::map<std::string, std::string>& headers = {})
{
std::ostringstream response;
switch (statusCode) {
case 200:
response << "HTTP/1.1 200 OK\r\n";
break;
case 201:
response << "HTTP/1.1 201 Created\r\n";
break;
case 404:
response << "HTTP/1.1 404 Not Found\r\n";
break;
case 500:
response << "HTTP/1.1 500 Internal Server Error\r\n";
break;
default:
response << "HTTP/1.1 " << statusCode << " Status\r\n";
break;
}
response << "Content-Type: application/json\r\n";
response << "Content-Length: " << body.length() << "\r\n";
response << "Connection: close\r\n";
response << "Server: MockHttpServer/1.0\r\n";
for (const auto& header : headers) {
response << header.first << ": " << header.second << "\r\n";
}
response << "\r\n";
response << body;
return response.str();
}
std::string handleRequest(const std::string& method, const std::string& path, const std::string& body,
const std::string& fullRequest = "")
{
if (path == "/test" && method == "GET") {
bool slowResponse = false;
if (fullRequest.find("X-Slow-Response: true") != std::string::npos ||
fullRequest.find("X-Graceful-Test: true") != std::string::npos) {
slowResponse = true;
}
if (slowResponse) {
std::cout << "MockServer: Slow response requested, waiting 3 seconds..." << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(3));
std::cout << "MockServer: Slow response wait completed, sending response" << std::endl;
}
std::string responseBody = "{\"status\": \"ok\", \"message\": \"GET test successful\", \"timestamp\": " +
std::to_string(time(nullptr)) +
", \"slow\": " + (slowResponse ? "true" : "false") + "}";
return generateResponse(200, responseBody);
}
if (path == "/test" && method == "POST") {
std::string responseBody =
"{\"status\": \"ok\", \"message\": \"POST test successful\", \"received_bytes\": " +
std::to_string(body.length()) + "}";
return generateResponse(201, responseBody);
}
if (path == "/echo" && method == "POST") {
std::string responseBody =
"{\"echo\": \"" + body + "\", \"original_length\": " + std::to_string(body.length()) + "}";
return generateResponse(200, responseBody);
}
if (path == "/slow" && method == "GET") {
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
std::string responseBody = "{\"status\": \"ok\", \"message\": \"Slow response after 1 second\"}";
return generateResponse(200, responseBody);
}
if (path == "/status/404" && method == "GET") {
std::string responseBody = "{\"error\": \"not found\", \"path\": \"" + path + "\"}";
return generateResponse(404, responseBody);
}
if (path == "/status/500" && method == "GET") {
std::string responseBody =
"{\"error\": \"internal server error\", \"timestamp\": " + std::to_string(time(nullptr)) + "}";
return generateResponse(500, responseBody);
}
if (path == "/headers" && method == "GET") {
std::string responseBody = "{\"message\": \"Headers received\", \"server\": \"MockHttpServer\"}";
return generateResponse(200, responseBody);
}
std::string responseBody = "{\"error\": \"not found\", \"path\": \"" + path + "\"}";
return generateResponse(404, responseBody);
}
std::string parseHttpRequest(const std::string& request)
{
std::istringstream iss(request);
std::string line;
std::string method, path, version;
if (std::getline(iss, line)) {
std::istringstream requestLine(line);
requestLine >> method >> path >> version;
}
std::string body;
char ch;
while (iss.get(ch)) {
body += ch;
}
return handleRequest(method, path, body, request);
}
void serverLoop()
{
while (running_) {
struct sockaddr_in clientAddr;
socklen_t clientAddrLen = sizeof(clientAddr);
int clientSocket = accept(serverSocket_, (struct sockaddr*)&clientAddr, &clientAddrLen);
if (clientSocket < 0) {
continue;
}
char buffer[4096];
std::string request;
ssize_t bytesRead;
while ((bytesRead = read(clientSocket, buffer, sizeof(buffer) - 1)) > 0) {
buffer[bytesRead] = '\0';
request += buffer;
if (request.find("\r\n\r\n") != std::string::npos) {
break;
}
}
if (!request.empty()) {
std::string response = parseHttpRequest(request);
write(clientSocket, response.c_str(), response.length());
}
close(clientSocket);
}
}
public:
MockHttpServer(int port = 8080) : port_(port)
{
}
~MockHttpServer()
{
stop();
}
bool start()
{
serverSocket_ = socket(AF_INET, SOCK_STREAM, 0);
if (serverSocket_ < 0) {
std::cerr << "❌ Failed to create socket" << std::endl;
return false;
}
int opt = 1;
if (setsockopt(serverSocket_, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
std::cerr << "❌ Failed to set socket options" << std::endl;
close(serverSocket_);
return false;
}
struct sockaddr_in serverAddr;
std::memset(&serverAddr, 0, sizeof(serverAddr));
serverAddr.sin_family = AF_INET;
serverAddr.sin_addr.s_addr = INADDR_ANY;
serverAddr.sin_port = htons(port_);
if (bind(serverSocket_, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {
std::cerr << "❌ Failed to bind to port " << port_ << std::endl;
close(serverSocket_);
return false;
}
if (listen(serverSocket_, 10) < 0) {
std::cerr << "❌ Failed to start listening" << std::endl;
close(serverSocket_);
return false;
}
running_ = true;
serverThread_ = std::thread(&MockHttpServer::serverLoop, this);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
return true;
}
void stop()
{
if (running_) {
running_ = false;
if (serverSocket_ >= 0) {
close(serverSocket_);
serverSocket_ = -1;
}
int tempSocket = socket(AF_INET, SOCK_STREAM, 0);
if (tempSocket >= 0) {
struct sockaddr_in addr;
std::memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = inet_addr("127.0.0.1");
addr.sin_port = htons(port_);
connect(tempSocket, (struct sockaddr*)&addr, sizeof(addr));
close(tempSocket);
}
if (serverThread_.joinable()) {
std::this_thread::sleep_for(std::chrono::milliseconds(100));
if (serverThread_.joinable()) {
serverThread_.detach();
} else {
serverThread_.join();
}
}
}
}
int getPort() const
{
return port_;
}
bool isRunning() const
{
return running_;
}
};