Simple Http Server Planned maintenance scheduled April 23, 2019 at 23:30 UTC (7:30pm US/Eastern) Announcing the arrival of Valued Associate #679: Cesar Manara Unicorn Meta Zoo #1: Why another podcast?Node.JS HTTP server displaying GooglePortable periodic/one-shot timer implementationConcise HTTP serverCalling other machines from the LinkedList if one is blocked or downReceiving a JSON string response from a URLSimple Router classPython HTTP ServerSimple Multi-Threaded Web ServerNodeJS static file HTTP serverBasic Python HTTP Server
Is openssl rand command cryptographically secure?
Simple Http Server
How much damage would a cupful of neutron star matter do to the Earth?
Special flights
Is CEO the "profession" with the most psychopaths?
What is the difference between a "ranged attack" and a "ranged weapon attack"?
RSA find public exponent
Where is the Next Backup Size entry on iOS 12?
Nose gear failure in single prop aircraft: belly landing or nose-gear up landing?
Can an iPhone 7 be made to function as a NFC Tag?
Resize vertical bars (absolute-value symbols)
Would color changing eyes affect vision?
How to force a browser when connecting to a specific domain to be https only using only the client machine?
Asymptotics question
Getting out of while loop on console
Positioning dot before text in math mode
How many time has Arya actually used Needle?
Why is it faster to reheat something than it is to cook it?
Random body shuffle every night—can we still function?
The test team as an enemy of development? And how can this be avoided?
Found this skink in my tomato plant bucket. Is he trapped? Or could he leave if he wanted?
How to write capital alpha?
Tannaka duality for semisimple groups
If Windows 7 doesn't support WSL, then what is "Subsystem for UNIX-based Applications"?
Simple Http Server
Planned maintenance scheduled April 23, 2019 at 23:30 UTC (7:30pm US/Eastern)
Announcing the arrival of Valued Associate #679: Cesar Manara
Unicorn Meta Zoo #1: Why another podcast?Node.JS HTTP server displaying GooglePortable periodic/one-shot timer implementationConcise HTTP serverCalling other machines from the LinkedList if one is blocked or downReceiving a JSON string response from a URLSimple Router classPython HTTP ServerSimple Multi-Threaded Web ServerNodeJS static file HTTP serverBasic Python HTTP Server
.everyoneloves__top-leaderboard:empty,.everyoneloves__mid-leaderboard:empty,.everyoneloves__bot-mid-leaderboard:empty margin-bottom:0;
$begingroup$
I'm working on a project (studying) and I have a lot of time for proof of concepts and write something from scratch.
Basically I'm creating a Http Server (simple, but not too simple) in C++ using sockets and multi-threading.
There are two topics that I'm concerned about: the design pattern of my code structure and the efficiency of my thread implementation. Obs: a little worried about C++ best practices, since I'm diving too fast into C++ (Am I abusing of std items?, since this require a low-level implementation).
Server is the main file, that calls Routes, Request and Response. Request and Response contains Struct (that contains Status Code). And Routes contains Request and Response.
IMPORTANT: I'm using nlohmann/json (https://github.com/nlohmann/json) and j-ulrich status-codes (https://github.com/j-ulrich/http-status-codes-cpp).
Server (Accepting Sockets and Multi-threading):
#pragma once
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <iostream>
#include <unordered_map>
#include <thread>
#include <mutex>
#include <condition_variable>
#include "Server/Request.h"
#include "Server/Response.h"
#include "Server/Struct.h"
#include "Server/Routes.h"
#include "Tools/Logger.h"
class Server
public:
Server(unsigned int port, unsigned int max_connections = 64, unsigned int thread_count = 5);
~Server();
bool setRoute(std::string path, Struct::Methods method, void (*callback)(Request*, Response*));
bool doListen();
bool doStop();
private:
unsigned int _port;
unsigned int _max_connections;
unsigned int _thread_count;
std::mutex _mutex;
std::condition_variable _condition;
bool _signal;
std::vector<unsigned int> _queue;
std::thread* _thread_consume;
std::thread* _thread_process;
Routes* _routes;
int _socket;
struct sockaddr_in _address;
bool _listen;
bool _doStop();
bool _doCreateSocket(int& socket_in);
bool _doBindSocket(int file_descriptor);
void _doConsumeSocket();
void _doProcessSocket(int id);
bool _doProcessRequest(Request* request, Response* response);
;
#include "Server/Server.h"
Server::Server(unsigned int port, unsigned int max_connections, unsigned int thread_count)
if (port > 65535)
Logger::doSendMessage(Logger::TYPES::ERROR, "[Port must be something between 0 and 65535 on Server::Constructor.");
if (max_connections < 1)
Logger::doSendMessage(Logger::TYPES::ERROR, "Max connections can't be lower than 1 on Server::Constructor.");
_port = port;
_max_connections = max_connections;
_thread_count = thread_count;
_routes = new Routes();
int status = _doCreateSocket(_socket);
if (!status)
Logger::doSendMessage(Logger::TYPES::ERROR, "Failed to create socket on Server::Constructor.");
if (!_doBindSocket(_socket))
Logger::doSendMessage(Logger::TYPES::ERROR, "Failed to bind socket on Server::Constructor.");
;
_signal = false;
_listen = false;
Server::~Server()
_doStop();
shutdown(_socket, SHUT_RD);
close(_socket);
try
_thread_consume->join();
for (size_t i = 0; i < _thread_count; i++)
_thread_process[i].join();
catch (...)
delete _thread_consume;
delete[] _thread_process;
delete _routes;
bool Server::setRoute(std::string path, Struct::Methods method, void (*callback)(Request*, Response*))
return _routes->setRoute(path, method, callback);
bool Server::doListen()
if (_listen) return false;
int status;
status = listen(_socket, _max_connections);
if (status < 0) return false;
Logger::doSendMessage(Logger::TYPES::INFO, "Server running with success at port " + std::to_string(_port) + ".");
_listen = true;
_thread_consume = new std::thread(&Server::_doConsumeSocket, this);
_thread_process = new std::thread[_thread_count];
for (size_t i = 0; i < _thread_count; i++)
_thread_process[i] = std::thread(&Server::_doProcessSocket, this, i);
return true;
bool Server::doStop()
return _doStop();
bool Server::_doStop()
if (!_listen) return false;
std::lock_guard<std::mutex> lock(_mutex);
_listen = false;
_condition.notify_one();
return true;
bool Server::_doCreateSocket(int& socket_in) SO_REUSEPORT, &opt, sizeof(opt));
if (error) return false;
socket_in = file_descriptor;
return true;
bool Server::_doBindSocket(int file_descriptor)
if (!file_descriptor) return false;
_address.sin_family = AF_INET;
_address.sin_addr.s_addr = INADDR_ANY;
_address.sin_port = htons(_port);
int status;
status = bind(file_descriptor, (struct sockaddr*) &_address, sizeof(_address));
if (status < 0) return false;
return true;
void Server::_doConsumeSocket()
int socket_in;
int address_size = sizeof(_address);
while (_listen)
socket_in = accept(_socket, (struct sockaddr*) &_address, (socklen_t*) &address_size);
if (socket_in < 0) continue;
std::lock_guard<std::mutex> lock(_mutex);
_queue.push_back(socket_in);
_signal = true;
_condition.notify_one();
void Server::_doProcessSocket(int id)
while (_listen)
int queue_size = 0;
std::unique_lock<std::mutex> lock(_mutex);
_condition.wait(lock,
[this]
if (this->_signal) return true;
if (!this->_listen && !this->_queue.size()) return true;
return false;
);
queue_size = _queue.size();
if (!queue_size)
std::lock_guard<std::mutex> lock(_mutex);
_signal = false;
_condition.notify_one();
continue;
int socket_in = 0;
std::lock_guard<std::mutex> lock(_mutex);
socket_in = _queue[0];
_queue.erase(_queue.begin());
Request* request = new Request(socket_in);
Response* response = new Response(socket_in);
int status = _doProcessRequest(request, response);
delete request;
delete response;
close(socket_in);
bool Server::_doProcessRequest(Request* request, Response* response)
if (!request->isValid())
response->doSendError(HttpStatus::Code::BadRequest, "Invalid request.");
return false;
std::string path = request->getPath();
Struct::Methods method = request->getMethod();
Routes::Route route;
if (!(_routes->getRoute(path, method, route) && route.isValid()))
response->doSendError(HttpStatus::Code::Forbidden, "Path invalid/not found.");
return false;
if (route.method != method)
response->doSendError(HttpStatus::Code::MethodNotAllowed, "Method invalid/not found.");
return false;
void (*callback)(Request*, Response*) = route.callback;
callback(request, response);
if (!response->isSent())
response->doSendError(HttpStatus::Code::ServiceUnavailable, "Resource was not found or can't respond now.");
return true;
Request (parsing) and Response (sending)
Request
#pragma once
#include <unistd.h>
#include <string.h>
#include <iostream>
#include <string>
#include <vector>
#include <unordered_map>
#include <regex>
#include <json.hpp>
#include "Server/Struct.h"
using json = nlohmann::json;
class Request
public:
Request(int socket, unsigned int buffer_size = 1024);
~Request();
bool isValid();
std::string getPath() return _attributes.path;
Struct::Methods getMethod() return _attributes.method;
std::unordered_map<std::string, std::string> getHeaders() return _attributes.headers;
std::string getHeader(std::string header) return _attributes.headers[header];
json getBody() return _attributes.body;
private:
int _socket;
unsigned int _buffer_size;
std::string _data;
Struct::Attributes _attributes;
bool _status;
std::string _doReceiveData(int sock_in);
bool _doParseData(std::string data, Struct::Attributes& attributes);
std::vector<std::string> _doSplitText(std::string text, std::string delimiter);
std::vector<std::string> _doSplitText(std::string text, std::string delimiter, int lock);
;
Request::Request(int socket, unsigned int buffer_size)
_socket = socket;
_buffer_size = buffer_size;
_status = false;
_data = _doReceiveData(_socket);
if (!_data.length()) return;
bool result;
result = _doParseData(_data, _attributes);
if (!result) return;
if (!_attributes.isValidRequest()) return;
_status = true;
Request::~Request()
bool Request::isValid()
return _status;
std::string Request::_doReceiveData(int sock_in)
char* buffer = new char[_buffer_size];
memset(buffer, '', _buffer_size);
read(sock_in, buffer, _buffer_size);
std::string data;
data.assign(buffer);
delete[] buffer;
return data;
bool Request::_doParseData(std::string data, Struct::Attributes& attributes)
std::string delimiter = "rn";
std::vector<std::string> rows = _doSplitText(data, delimiter);
if (!rows.size()) return false;
std::string header = rows[0];
rows.erase(rows.begin());
if (!header.length()) return false;
std::vector<std::string> parsed_header = _doSplitText(header, std::string(" "));
if (parsed_header.size() < 2) return false;
Struct::Methods method = Struct::doParseHttpMethod(parsed_header[0]);
if (method == Struct::Methods::NONE) return false;
std::string path = parsed_header[1];
std::unordered_map<std::string, std::string> headers;
for (size_t i = 0; i < rows.size(); i++)
std::string row = rows[i];
delimiter = ":";
std::vector<std::string> splited = _doSplitText(row, delimiter, true);
if (splited.size() != 2) continue;
headers[splited[0]] = splited[1];
_attributes.method = method;
_attributes.path = path;
_attributes.headers = headers;
std::string content_length = headers["Content-Length"];
int content_size = 0;
if (content_size = atoi(content_length.c_str()))
std::string body = data.substr(data.length() - content_size, data.length());
json parsed_body = json::parse(body, nullptr, false);
if (parsed_body != NULL && !parsed_body.is_discarded()) _attributes.body = parsed_body;
return true;
std::vector<std::string> Request::_doSplitText(std::string text, std::string delimiter)
std::vector<std::string> result;
int delimiter_length = delimiter.length();
std::string block;
std::string region;
int index = 0;
for (size_t i = 0; i < text.length(); i++)
block = text.substr(i, delimiter_length);
if (block.length() != delimiter_length) continue;
if (block == delimiter)
region = text.substr(index, i - index);
result.push_back(region);
index = i + delimiter_length;
return result;
std::vector<std::string> Request::_doSplitText(std::string text, std::string delimiter, int lock)
...
Response
#pragma once
#include <unistd.h>
#include <iostream>
#include <string>
#include <unordered_map>
#include "Server/Struct.h"
class Response
public:
Response(int socket_in);
~Response();
bool isSent() return _sent;
void setCode(HttpStatus::Code code) _attributes.code = code;
void setHeader(std::string key, std::string value) _attributes.headers[key] = value;
void setBody(json body) _attributes.body = body;
void doClearHeaders() _attributes.headers.clear();
void doClearBody() _attributes.body = json::value_t::object;
bool doSendSuccess();
bool doSendError(HttpStatus::Code code, const std::string& message);
private:
int _socket;
bool _sent;
Struct::Attributes _attributes;
bool _doSendPayload();
bool _doCreatePayload(std::string& payload);
;
#include "Response.h"
Response::Response(int socket_in)
_socket = socket_in;
_sent = false;
Response::~Response()
bool Response::doSendSuccess()
setCode(HttpStatus::Code::OK);
setHeader("Connection", "Closed");
return _doSendPayload();
bool Response::doSendError(HttpStatus::Code code, const std::string& message)
setCode(code);
doClearHeaders();
doClearBody();
setHeader("Connection", "Closed");
json body;
body["error"] = ;
body["error"]["code"] = code;
body["error"]["message"] = message;
setBody(body);
return _doSendPayload();
bool Response::_doSendPayload()
if (_sent) return false;
int status;
setHeader("Server", "Dark");
setHeader("Content-Type", "application/json");
std::string payload;
status = _doCreatePayload(payload);
if (!status) return false;
status = write(_socket, payload.c_str(), payload.size());
if (status < 1) return false;
_sent = true;
return true;
bool Response::_doCreatePayload(std::string& payload)
std::string current_payload;
std::string data = _attributes.body.dump(4);
int data_length = data.size();
if (data_length)
_attributes.headers["Content-Length"] = std::to_string(data_length);
current_payload += _attributes.version + " " + std::to_string((int) _attributes.code) + " " + HttpStatus::getReasonPhrase(_attributes.code) + "rn";
std::unordered_map<std::string, std::string>::iterator iterator;
for (iterator = _attributes.headers.begin(); iterator != _attributes.headers.end(); iterator++)
std::string key = iterator->first;
std::string value = iterator->second;
current_payload += key + ": " + value + "rn";
if (data_length) current_payload += "rn" + data + "rnrn";
payload = current_payload;
return true;
Routes
#pragma once
#include <iostream>
#include <string>
#include <vector>
#include "Server/Request.h"
#include "Server/Response.h"
class Routes
public:
Routes();
~Routes();
struct Route
std::string path;
Struct::Methods method;
void (*callback)(Request*, Response*);
bool isValid() method > Struct::Methods::LAST) return false;
if (callback == nullptr) return false;
return true;
;
bool setRoute(std::string path, Struct::Methods method, void (*callback)(Request*, Response*));
bool getRoute(std::string path, Struct::Methods method, Route& route);
private:
std::vector<Route> _routes;
int _getRouteIndex(std::string path, Struct::Methods method);
;
#include "Routes.h"
Routes::Routes()
Routes::~Routes()
bool Routes::setRoute(std::string path, Struct::Methods method, void (*callback)(Request*, Response*))
bool Routes::getRoute(std::string path, Struct::Methods method, Routes::Route& route)
int index = _getRouteIndex(path, method);
if (index < 0) return false;
route = _routes[index];
return true;
int Routes::_getRouteIndex(std::string path, Struct::Methods method)
for (size_t i = 0; i < _routes.size(); i++)
Route* route = &_routes[i];
if (route->path == path && route->method == method)
return i;
return -1;
Struct and StatusCode
StatusCode
https://github.com/j-ulrich/http-status-codes-cpp
Struct
#pragma once
#include <json.hpp>
#include "Server/StatusCode.h"
using json = nlohmann::json;
class Struct
public:
enum class Methods
NONE = 0, GET = 1, POST = 2, FIRST = GET, LAST = POST
;
struct Attributes
const std::string version = "HTTP/1.1";
std::string path;
Methods method;
HttpStatus::Code code;
std::unordered_map<std::string, std::string> headers;
json body;
Attributes()
code = HttpStatus::Code::InternalServerError;
body = json::value_t::object;
bool isValidRequest()
if (!path.length()) return false;
if (method < Methods::FIRST
bool isValidResponse()
if (!headers.size()) return false;
return true;
;
static Methods doParseHttpMethod(std::string value)
Methods target = Methods::NONE;
if (value == "GET") target = Methods::GET;
if (value == "POST") target = Methods::POST;
return target;
private:
;
Main (usage):
#include "Server/Server.h"
void exec(Request* request, Response* response)
json body;
body["foo"] = 123;
body["bar"] = true;
response->setBody(body);
response->doSendSuccess();
int main(int argc, char* argv[])
Server* server = new Server(5000);
server->setRoute("/getStatus", Struct::Methods::GET, exec);
server->setRoute("/postStatus", Struct::Methods::POST, exec);
server->doListen();
// let threads live for some time before they eternaly be gone
/*
actually I'm stuck with this sleep, I don't know how to hold
this until caller call doStop() without using while and
consuming process power
*/
sleep(30);
delete server;
return 1;
Basically I'm mirroring NodeJS express API Usage:
server.setRoute(path, route, callback);
So, what can be done to improve my code in terms of optimization and efficiency?
Thanks in advance.
c++ multithreading http socket server
New contributor
$endgroup$
add a comment |
$begingroup$
I'm working on a project (studying) and I have a lot of time for proof of concepts and write something from scratch.
Basically I'm creating a Http Server (simple, but not too simple) in C++ using sockets and multi-threading.
There are two topics that I'm concerned about: the design pattern of my code structure and the efficiency of my thread implementation. Obs: a little worried about C++ best practices, since I'm diving too fast into C++ (Am I abusing of std items?, since this require a low-level implementation).
Server is the main file, that calls Routes, Request and Response. Request and Response contains Struct (that contains Status Code). And Routes contains Request and Response.
IMPORTANT: I'm using nlohmann/json (https://github.com/nlohmann/json) and j-ulrich status-codes (https://github.com/j-ulrich/http-status-codes-cpp).
Server (Accepting Sockets and Multi-threading):
#pragma once
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <iostream>
#include <unordered_map>
#include <thread>
#include <mutex>
#include <condition_variable>
#include "Server/Request.h"
#include "Server/Response.h"
#include "Server/Struct.h"
#include "Server/Routes.h"
#include "Tools/Logger.h"
class Server
public:
Server(unsigned int port, unsigned int max_connections = 64, unsigned int thread_count = 5);
~Server();
bool setRoute(std::string path, Struct::Methods method, void (*callback)(Request*, Response*));
bool doListen();
bool doStop();
private:
unsigned int _port;
unsigned int _max_connections;
unsigned int _thread_count;
std::mutex _mutex;
std::condition_variable _condition;
bool _signal;
std::vector<unsigned int> _queue;
std::thread* _thread_consume;
std::thread* _thread_process;
Routes* _routes;
int _socket;
struct sockaddr_in _address;
bool _listen;
bool _doStop();
bool _doCreateSocket(int& socket_in);
bool _doBindSocket(int file_descriptor);
void _doConsumeSocket();
void _doProcessSocket(int id);
bool _doProcessRequest(Request* request, Response* response);
;
#include "Server/Server.h"
Server::Server(unsigned int port, unsigned int max_connections, unsigned int thread_count)
if (port > 65535)
Logger::doSendMessage(Logger::TYPES::ERROR, "[Port must be something between 0 and 65535 on Server::Constructor.");
if (max_connections < 1)
Logger::doSendMessage(Logger::TYPES::ERROR, "Max connections can't be lower than 1 on Server::Constructor.");
_port = port;
_max_connections = max_connections;
_thread_count = thread_count;
_routes = new Routes();
int status = _doCreateSocket(_socket);
if (!status)
Logger::doSendMessage(Logger::TYPES::ERROR, "Failed to create socket on Server::Constructor.");
if (!_doBindSocket(_socket))
Logger::doSendMessage(Logger::TYPES::ERROR, "Failed to bind socket on Server::Constructor.");
;
_signal = false;
_listen = false;
Server::~Server()
_doStop();
shutdown(_socket, SHUT_RD);
close(_socket);
try
_thread_consume->join();
for (size_t i = 0; i < _thread_count; i++)
_thread_process[i].join();
catch (...)
delete _thread_consume;
delete[] _thread_process;
delete _routes;
bool Server::setRoute(std::string path, Struct::Methods method, void (*callback)(Request*, Response*))
return _routes->setRoute(path, method, callback);
bool Server::doListen()
if (_listen) return false;
int status;
status = listen(_socket, _max_connections);
if (status < 0) return false;
Logger::doSendMessage(Logger::TYPES::INFO, "Server running with success at port " + std::to_string(_port) + ".");
_listen = true;
_thread_consume = new std::thread(&Server::_doConsumeSocket, this);
_thread_process = new std::thread[_thread_count];
for (size_t i = 0; i < _thread_count; i++)
_thread_process[i] = std::thread(&Server::_doProcessSocket, this, i);
return true;
bool Server::doStop()
return _doStop();
bool Server::_doStop()
if (!_listen) return false;
std::lock_guard<std::mutex> lock(_mutex);
_listen = false;
_condition.notify_one();
return true;
bool Server::_doCreateSocket(int& socket_in) SO_REUSEPORT, &opt, sizeof(opt));
if (error) return false;
socket_in = file_descriptor;
return true;
bool Server::_doBindSocket(int file_descriptor)
if (!file_descriptor) return false;
_address.sin_family = AF_INET;
_address.sin_addr.s_addr = INADDR_ANY;
_address.sin_port = htons(_port);
int status;
status = bind(file_descriptor, (struct sockaddr*) &_address, sizeof(_address));
if (status < 0) return false;
return true;
void Server::_doConsumeSocket()
int socket_in;
int address_size = sizeof(_address);
while (_listen)
socket_in = accept(_socket, (struct sockaddr*) &_address, (socklen_t*) &address_size);
if (socket_in < 0) continue;
std::lock_guard<std::mutex> lock(_mutex);
_queue.push_back(socket_in);
_signal = true;
_condition.notify_one();
void Server::_doProcessSocket(int id)
while (_listen)
int queue_size = 0;
std::unique_lock<std::mutex> lock(_mutex);
_condition.wait(lock,
[this]
if (this->_signal) return true;
if (!this->_listen && !this->_queue.size()) return true;
return false;
);
queue_size = _queue.size();
if (!queue_size)
std::lock_guard<std::mutex> lock(_mutex);
_signal = false;
_condition.notify_one();
continue;
int socket_in = 0;
std::lock_guard<std::mutex> lock(_mutex);
socket_in = _queue[0];
_queue.erase(_queue.begin());
Request* request = new Request(socket_in);
Response* response = new Response(socket_in);
int status = _doProcessRequest(request, response);
delete request;
delete response;
close(socket_in);
bool Server::_doProcessRequest(Request* request, Response* response)
if (!request->isValid())
response->doSendError(HttpStatus::Code::BadRequest, "Invalid request.");
return false;
std::string path = request->getPath();
Struct::Methods method = request->getMethod();
Routes::Route route;
if (!(_routes->getRoute(path, method, route) && route.isValid()))
response->doSendError(HttpStatus::Code::Forbidden, "Path invalid/not found.");
return false;
if (route.method != method)
response->doSendError(HttpStatus::Code::MethodNotAllowed, "Method invalid/not found.");
return false;
void (*callback)(Request*, Response*) = route.callback;
callback(request, response);
if (!response->isSent())
response->doSendError(HttpStatus::Code::ServiceUnavailable, "Resource was not found or can't respond now.");
return true;
Request (parsing) and Response (sending)
Request
#pragma once
#include <unistd.h>
#include <string.h>
#include <iostream>
#include <string>
#include <vector>
#include <unordered_map>
#include <regex>
#include <json.hpp>
#include "Server/Struct.h"
using json = nlohmann::json;
class Request
public:
Request(int socket, unsigned int buffer_size = 1024);
~Request();
bool isValid();
std::string getPath() return _attributes.path;
Struct::Methods getMethod() return _attributes.method;
std::unordered_map<std::string, std::string> getHeaders() return _attributes.headers;
std::string getHeader(std::string header) return _attributes.headers[header];
json getBody() return _attributes.body;
private:
int _socket;
unsigned int _buffer_size;
std::string _data;
Struct::Attributes _attributes;
bool _status;
std::string _doReceiveData(int sock_in);
bool _doParseData(std::string data, Struct::Attributes& attributes);
std::vector<std::string> _doSplitText(std::string text, std::string delimiter);
std::vector<std::string> _doSplitText(std::string text, std::string delimiter, int lock);
;
Request::Request(int socket, unsigned int buffer_size)
_socket = socket;
_buffer_size = buffer_size;
_status = false;
_data = _doReceiveData(_socket);
if (!_data.length()) return;
bool result;
result = _doParseData(_data, _attributes);
if (!result) return;
if (!_attributes.isValidRequest()) return;
_status = true;
Request::~Request()
bool Request::isValid()
return _status;
std::string Request::_doReceiveData(int sock_in)
char* buffer = new char[_buffer_size];
memset(buffer, '', _buffer_size);
read(sock_in, buffer, _buffer_size);
std::string data;
data.assign(buffer);
delete[] buffer;
return data;
bool Request::_doParseData(std::string data, Struct::Attributes& attributes)
std::string delimiter = "rn";
std::vector<std::string> rows = _doSplitText(data, delimiter);
if (!rows.size()) return false;
std::string header = rows[0];
rows.erase(rows.begin());
if (!header.length()) return false;
std::vector<std::string> parsed_header = _doSplitText(header, std::string(" "));
if (parsed_header.size() < 2) return false;
Struct::Methods method = Struct::doParseHttpMethod(parsed_header[0]);
if (method == Struct::Methods::NONE) return false;
std::string path = parsed_header[1];
std::unordered_map<std::string, std::string> headers;
for (size_t i = 0; i < rows.size(); i++)
std::string row = rows[i];
delimiter = ":";
std::vector<std::string> splited = _doSplitText(row, delimiter, true);
if (splited.size() != 2) continue;
headers[splited[0]] = splited[1];
_attributes.method = method;
_attributes.path = path;
_attributes.headers = headers;
std::string content_length = headers["Content-Length"];
int content_size = 0;
if (content_size = atoi(content_length.c_str()))
std::string body = data.substr(data.length() - content_size, data.length());
json parsed_body = json::parse(body, nullptr, false);
if (parsed_body != NULL && !parsed_body.is_discarded()) _attributes.body = parsed_body;
return true;
std::vector<std::string> Request::_doSplitText(std::string text, std::string delimiter)
std::vector<std::string> result;
int delimiter_length = delimiter.length();
std::string block;
std::string region;
int index = 0;
for (size_t i = 0; i < text.length(); i++)
block = text.substr(i, delimiter_length);
if (block.length() != delimiter_length) continue;
if (block == delimiter)
region = text.substr(index, i - index);
result.push_back(region);
index = i + delimiter_length;
return result;
std::vector<std::string> Request::_doSplitText(std::string text, std::string delimiter, int lock)
...
Response
#pragma once
#include <unistd.h>
#include <iostream>
#include <string>
#include <unordered_map>
#include "Server/Struct.h"
class Response
public:
Response(int socket_in);
~Response();
bool isSent() return _sent;
void setCode(HttpStatus::Code code) _attributes.code = code;
void setHeader(std::string key, std::string value) _attributes.headers[key] = value;
void setBody(json body) _attributes.body = body;
void doClearHeaders() _attributes.headers.clear();
void doClearBody() _attributes.body = json::value_t::object;
bool doSendSuccess();
bool doSendError(HttpStatus::Code code, const std::string& message);
private:
int _socket;
bool _sent;
Struct::Attributes _attributes;
bool _doSendPayload();
bool _doCreatePayload(std::string& payload);
;
#include "Response.h"
Response::Response(int socket_in)
_socket = socket_in;
_sent = false;
Response::~Response()
bool Response::doSendSuccess()
setCode(HttpStatus::Code::OK);
setHeader("Connection", "Closed");
return _doSendPayload();
bool Response::doSendError(HttpStatus::Code code, const std::string& message)
setCode(code);
doClearHeaders();
doClearBody();
setHeader("Connection", "Closed");
json body;
body["error"] = ;
body["error"]["code"] = code;
body["error"]["message"] = message;
setBody(body);
return _doSendPayload();
bool Response::_doSendPayload()
if (_sent) return false;
int status;
setHeader("Server", "Dark");
setHeader("Content-Type", "application/json");
std::string payload;
status = _doCreatePayload(payload);
if (!status) return false;
status = write(_socket, payload.c_str(), payload.size());
if (status < 1) return false;
_sent = true;
return true;
bool Response::_doCreatePayload(std::string& payload)
std::string current_payload;
std::string data = _attributes.body.dump(4);
int data_length = data.size();
if (data_length)
_attributes.headers["Content-Length"] = std::to_string(data_length);
current_payload += _attributes.version + " " + std::to_string((int) _attributes.code) + " " + HttpStatus::getReasonPhrase(_attributes.code) + "rn";
std::unordered_map<std::string, std::string>::iterator iterator;
for (iterator = _attributes.headers.begin(); iterator != _attributes.headers.end(); iterator++)
std::string key = iterator->first;
std::string value = iterator->second;
current_payload += key + ": " + value + "rn";
if (data_length) current_payload += "rn" + data + "rnrn";
payload = current_payload;
return true;
Routes
#pragma once
#include <iostream>
#include <string>
#include <vector>
#include "Server/Request.h"
#include "Server/Response.h"
class Routes
public:
Routes();
~Routes();
struct Route
std::string path;
Struct::Methods method;
void (*callback)(Request*, Response*);
bool isValid() method > Struct::Methods::LAST) return false;
if (callback == nullptr) return false;
return true;
;
bool setRoute(std::string path, Struct::Methods method, void (*callback)(Request*, Response*));
bool getRoute(std::string path, Struct::Methods method, Route& route);
private:
std::vector<Route> _routes;
int _getRouteIndex(std::string path, Struct::Methods method);
;
#include "Routes.h"
Routes::Routes()
Routes::~Routes()
bool Routes::setRoute(std::string path, Struct::Methods method, void (*callback)(Request*, Response*))
bool Routes::getRoute(std::string path, Struct::Methods method, Routes::Route& route)
int index = _getRouteIndex(path, method);
if (index < 0) return false;
route = _routes[index];
return true;
int Routes::_getRouteIndex(std::string path, Struct::Methods method)
for (size_t i = 0; i < _routes.size(); i++)
Route* route = &_routes[i];
if (route->path == path && route->method == method)
return i;
return -1;
Struct and StatusCode
StatusCode
https://github.com/j-ulrich/http-status-codes-cpp
Struct
#pragma once
#include <json.hpp>
#include "Server/StatusCode.h"
using json = nlohmann::json;
class Struct
public:
enum class Methods
NONE = 0, GET = 1, POST = 2, FIRST = GET, LAST = POST
;
struct Attributes
const std::string version = "HTTP/1.1";
std::string path;
Methods method;
HttpStatus::Code code;
std::unordered_map<std::string, std::string> headers;
json body;
Attributes()
code = HttpStatus::Code::InternalServerError;
body = json::value_t::object;
bool isValidRequest()
if (!path.length()) return false;
if (method < Methods::FIRST
bool isValidResponse()
if (!headers.size()) return false;
return true;
;
static Methods doParseHttpMethod(std::string value)
Methods target = Methods::NONE;
if (value == "GET") target = Methods::GET;
if (value == "POST") target = Methods::POST;
return target;
private:
;
Main (usage):
#include "Server/Server.h"
void exec(Request* request, Response* response)
json body;
body["foo"] = 123;
body["bar"] = true;
response->setBody(body);
response->doSendSuccess();
int main(int argc, char* argv[])
Server* server = new Server(5000);
server->setRoute("/getStatus", Struct::Methods::GET, exec);
server->setRoute("/postStatus", Struct::Methods::POST, exec);
server->doListen();
// let threads live for some time before they eternaly be gone
/*
actually I'm stuck with this sleep, I don't know how to hold
this until caller call doStop() without using while and
consuming process power
*/
sleep(30);
delete server;
return 1;
Basically I'm mirroring NodeJS express API Usage:
server.setRoute(path, route, callback);
So, what can be done to improve my code in terms of optimization and efficiency?
Thanks in advance.
c++ multithreading http socket server
New contributor
$endgroup$
add a comment |
$begingroup$
I'm working on a project (studying) and I have a lot of time for proof of concepts and write something from scratch.
Basically I'm creating a Http Server (simple, but not too simple) in C++ using sockets and multi-threading.
There are two topics that I'm concerned about: the design pattern of my code structure and the efficiency of my thread implementation. Obs: a little worried about C++ best practices, since I'm diving too fast into C++ (Am I abusing of std items?, since this require a low-level implementation).
Server is the main file, that calls Routes, Request and Response. Request and Response contains Struct (that contains Status Code). And Routes contains Request and Response.
IMPORTANT: I'm using nlohmann/json (https://github.com/nlohmann/json) and j-ulrich status-codes (https://github.com/j-ulrich/http-status-codes-cpp).
Server (Accepting Sockets and Multi-threading):
#pragma once
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <iostream>
#include <unordered_map>
#include <thread>
#include <mutex>
#include <condition_variable>
#include "Server/Request.h"
#include "Server/Response.h"
#include "Server/Struct.h"
#include "Server/Routes.h"
#include "Tools/Logger.h"
class Server
public:
Server(unsigned int port, unsigned int max_connections = 64, unsigned int thread_count = 5);
~Server();
bool setRoute(std::string path, Struct::Methods method, void (*callback)(Request*, Response*));
bool doListen();
bool doStop();
private:
unsigned int _port;
unsigned int _max_connections;
unsigned int _thread_count;
std::mutex _mutex;
std::condition_variable _condition;
bool _signal;
std::vector<unsigned int> _queue;
std::thread* _thread_consume;
std::thread* _thread_process;
Routes* _routes;
int _socket;
struct sockaddr_in _address;
bool _listen;
bool _doStop();
bool _doCreateSocket(int& socket_in);
bool _doBindSocket(int file_descriptor);
void _doConsumeSocket();
void _doProcessSocket(int id);
bool _doProcessRequest(Request* request, Response* response);
;
#include "Server/Server.h"
Server::Server(unsigned int port, unsigned int max_connections, unsigned int thread_count)
if (port > 65535)
Logger::doSendMessage(Logger::TYPES::ERROR, "[Port must be something between 0 and 65535 on Server::Constructor.");
if (max_connections < 1)
Logger::doSendMessage(Logger::TYPES::ERROR, "Max connections can't be lower than 1 on Server::Constructor.");
_port = port;
_max_connections = max_connections;
_thread_count = thread_count;
_routes = new Routes();
int status = _doCreateSocket(_socket);
if (!status)
Logger::doSendMessage(Logger::TYPES::ERROR, "Failed to create socket on Server::Constructor.");
if (!_doBindSocket(_socket))
Logger::doSendMessage(Logger::TYPES::ERROR, "Failed to bind socket on Server::Constructor.");
;
_signal = false;
_listen = false;
Server::~Server()
_doStop();
shutdown(_socket, SHUT_RD);
close(_socket);
try
_thread_consume->join();
for (size_t i = 0; i < _thread_count; i++)
_thread_process[i].join();
catch (...)
delete _thread_consume;
delete[] _thread_process;
delete _routes;
bool Server::setRoute(std::string path, Struct::Methods method, void (*callback)(Request*, Response*))
return _routes->setRoute(path, method, callback);
bool Server::doListen()
if (_listen) return false;
int status;
status = listen(_socket, _max_connections);
if (status < 0) return false;
Logger::doSendMessage(Logger::TYPES::INFO, "Server running with success at port " + std::to_string(_port) + ".");
_listen = true;
_thread_consume = new std::thread(&Server::_doConsumeSocket, this);
_thread_process = new std::thread[_thread_count];
for (size_t i = 0; i < _thread_count; i++)
_thread_process[i] = std::thread(&Server::_doProcessSocket, this, i);
return true;
bool Server::doStop()
return _doStop();
bool Server::_doStop()
if (!_listen) return false;
std::lock_guard<std::mutex> lock(_mutex);
_listen = false;
_condition.notify_one();
return true;
bool Server::_doCreateSocket(int& socket_in) SO_REUSEPORT, &opt, sizeof(opt));
if (error) return false;
socket_in = file_descriptor;
return true;
bool Server::_doBindSocket(int file_descriptor)
if (!file_descriptor) return false;
_address.sin_family = AF_INET;
_address.sin_addr.s_addr = INADDR_ANY;
_address.sin_port = htons(_port);
int status;
status = bind(file_descriptor, (struct sockaddr*) &_address, sizeof(_address));
if (status < 0) return false;
return true;
void Server::_doConsumeSocket()
int socket_in;
int address_size = sizeof(_address);
while (_listen)
socket_in = accept(_socket, (struct sockaddr*) &_address, (socklen_t*) &address_size);
if (socket_in < 0) continue;
std::lock_guard<std::mutex> lock(_mutex);
_queue.push_back(socket_in);
_signal = true;
_condition.notify_one();
void Server::_doProcessSocket(int id)
while (_listen)
int queue_size = 0;
std::unique_lock<std::mutex> lock(_mutex);
_condition.wait(lock,
[this]
if (this->_signal) return true;
if (!this->_listen && !this->_queue.size()) return true;
return false;
);
queue_size = _queue.size();
if (!queue_size)
std::lock_guard<std::mutex> lock(_mutex);
_signal = false;
_condition.notify_one();
continue;
int socket_in = 0;
std::lock_guard<std::mutex> lock(_mutex);
socket_in = _queue[0];
_queue.erase(_queue.begin());
Request* request = new Request(socket_in);
Response* response = new Response(socket_in);
int status = _doProcessRequest(request, response);
delete request;
delete response;
close(socket_in);
bool Server::_doProcessRequest(Request* request, Response* response)
if (!request->isValid())
response->doSendError(HttpStatus::Code::BadRequest, "Invalid request.");
return false;
std::string path = request->getPath();
Struct::Methods method = request->getMethod();
Routes::Route route;
if (!(_routes->getRoute(path, method, route) && route.isValid()))
response->doSendError(HttpStatus::Code::Forbidden, "Path invalid/not found.");
return false;
if (route.method != method)
response->doSendError(HttpStatus::Code::MethodNotAllowed, "Method invalid/not found.");
return false;
void (*callback)(Request*, Response*) = route.callback;
callback(request, response);
if (!response->isSent())
response->doSendError(HttpStatus::Code::ServiceUnavailable, "Resource was not found or can't respond now.");
return true;
Request (parsing) and Response (sending)
Request
#pragma once
#include <unistd.h>
#include <string.h>
#include <iostream>
#include <string>
#include <vector>
#include <unordered_map>
#include <regex>
#include <json.hpp>
#include "Server/Struct.h"
using json = nlohmann::json;
class Request
public:
Request(int socket, unsigned int buffer_size = 1024);
~Request();
bool isValid();
std::string getPath() return _attributes.path;
Struct::Methods getMethod() return _attributes.method;
std::unordered_map<std::string, std::string> getHeaders() return _attributes.headers;
std::string getHeader(std::string header) return _attributes.headers[header];
json getBody() return _attributes.body;
private:
int _socket;
unsigned int _buffer_size;
std::string _data;
Struct::Attributes _attributes;
bool _status;
std::string _doReceiveData(int sock_in);
bool _doParseData(std::string data, Struct::Attributes& attributes);
std::vector<std::string> _doSplitText(std::string text, std::string delimiter);
std::vector<std::string> _doSplitText(std::string text, std::string delimiter, int lock);
;
Request::Request(int socket, unsigned int buffer_size)
_socket = socket;
_buffer_size = buffer_size;
_status = false;
_data = _doReceiveData(_socket);
if (!_data.length()) return;
bool result;
result = _doParseData(_data, _attributes);
if (!result) return;
if (!_attributes.isValidRequest()) return;
_status = true;
Request::~Request()
bool Request::isValid()
return _status;
std::string Request::_doReceiveData(int sock_in)
char* buffer = new char[_buffer_size];
memset(buffer, '', _buffer_size);
read(sock_in, buffer, _buffer_size);
std::string data;
data.assign(buffer);
delete[] buffer;
return data;
bool Request::_doParseData(std::string data, Struct::Attributes& attributes)
std::string delimiter = "rn";
std::vector<std::string> rows = _doSplitText(data, delimiter);
if (!rows.size()) return false;
std::string header = rows[0];
rows.erase(rows.begin());
if (!header.length()) return false;
std::vector<std::string> parsed_header = _doSplitText(header, std::string(" "));
if (parsed_header.size() < 2) return false;
Struct::Methods method = Struct::doParseHttpMethod(parsed_header[0]);
if (method == Struct::Methods::NONE) return false;
std::string path = parsed_header[1];
std::unordered_map<std::string, std::string> headers;
for (size_t i = 0; i < rows.size(); i++)
std::string row = rows[i];
delimiter = ":";
std::vector<std::string> splited = _doSplitText(row, delimiter, true);
if (splited.size() != 2) continue;
headers[splited[0]] = splited[1];
_attributes.method = method;
_attributes.path = path;
_attributes.headers = headers;
std::string content_length = headers["Content-Length"];
int content_size = 0;
if (content_size = atoi(content_length.c_str()))
std::string body = data.substr(data.length() - content_size, data.length());
json parsed_body = json::parse(body, nullptr, false);
if (parsed_body != NULL && !parsed_body.is_discarded()) _attributes.body = parsed_body;
return true;
std::vector<std::string> Request::_doSplitText(std::string text, std::string delimiter)
std::vector<std::string> result;
int delimiter_length = delimiter.length();
std::string block;
std::string region;
int index = 0;
for (size_t i = 0; i < text.length(); i++)
block = text.substr(i, delimiter_length);
if (block.length() != delimiter_length) continue;
if (block == delimiter)
region = text.substr(index, i - index);
result.push_back(region);
index = i + delimiter_length;
return result;
std::vector<std::string> Request::_doSplitText(std::string text, std::string delimiter, int lock)
...
Response
#pragma once
#include <unistd.h>
#include <iostream>
#include <string>
#include <unordered_map>
#include "Server/Struct.h"
class Response
public:
Response(int socket_in);
~Response();
bool isSent() return _sent;
void setCode(HttpStatus::Code code) _attributes.code = code;
void setHeader(std::string key, std::string value) _attributes.headers[key] = value;
void setBody(json body) _attributes.body = body;
void doClearHeaders() _attributes.headers.clear();
void doClearBody() _attributes.body = json::value_t::object;
bool doSendSuccess();
bool doSendError(HttpStatus::Code code, const std::string& message);
private:
int _socket;
bool _sent;
Struct::Attributes _attributes;
bool _doSendPayload();
bool _doCreatePayload(std::string& payload);
;
#include "Response.h"
Response::Response(int socket_in)
_socket = socket_in;
_sent = false;
Response::~Response()
bool Response::doSendSuccess()
setCode(HttpStatus::Code::OK);
setHeader("Connection", "Closed");
return _doSendPayload();
bool Response::doSendError(HttpStatus::Code code, const std::string& message)
setCode(code);
doClearHeaders();
doClearBody();
setHeader("Connection", "Closed");
json body;
body["error"] = ;
body["error"]["code"] = code;
body["error"]["message"] = message;
setBody(body);
return _doSendPayload();
bool Response::_doSendPayload()
if (_sent) return false;
int status;
setHeader("Server", "Dark");
setHeader("Content-Type", "application/json");
std::string payload;
status = _doCreatePayload(payload);
if (!status) return false;
status = write(_socket, payload.c_str(), payload.size());
if (status < 1) return false;
_sent = true;
return true;
bool Response::_doCreatePayload(std::string& payload)
std::string current_payload;
std::string data = _attributes.body.dump(4);
int data_length = data.size();
if (data_length)
_attributes.headers["Content-Length"] = std::to_string(data_length);
current_payload += _attributes.version + " " + std::to_string((int) _attributes.code) + " " + HttpStatus::getReasonPhrase(_attributes.code) + "rn";
std::unordered_map<std::string, std::string>::iterator iterator;
for (iterator = _attributes.headers.begin(); iterator != _attributes.headers.end(); iterator++)
std::string key = iterator->first;
std::string value = iterator->second;
current_payload += key + ": " + value + "rn";
if (data_length) current_payload += "rn" + data + "rnrn";
payload = current_payload;
return true;
Routes
#pragma once
#include <iostream>
#include <string>
#include <vector>
#include "Server/Request.h"
#include "Server/Response.h"
class Routes
public:
Routes();
~Routes();
struct Route
std::string path;
Struct::Methods method;
void (*callback)(Request*, Response*);
bool isValid() method > Struct::Methods::LAST) return false;
if (callback == nullptr) return false;
return true;
;
bool setRoute(std::string path, Struct::Methods method, void (*callback)(Request*, Response*));
bool getRoute(std::string path, Struct::Methods method, Route& route);
private:
std::vector<Route> _routes;
int _getRouteIndex(std::string path, Struct::Methods method);
;
#include "Routes.h"
Routes::Routes()
Routes::~Routes()
bool Routes::setRoute(std::string path, Struct::Methods method, void (*callback)(Request*, Response*))
bool Routes::getRoute(std::string path, Struct::Methods method, Routes::Route& route)
int index = _getRouteIndex(path, method);
if (index < 0) return false;
route = _routes[index];
return true;
int Routes::_getRouteIndex(std::string path, Struct::Methods method)
for (size_t i = 0; i < _routes.size(); i++)
Route* route = &_routes[i];
if (route->path == path && route->method == method)
return i;
return -1;
Struct and StatusCode
StatusCode
https://github.com/j-ulrich/http-status-codes-cpp
Struct
#pragma once
#include <json.hpp>
#include "Server/StatusCode.h"
using json = nlohmann::json;
class Struct
public:
enum class Methods
NONE = 0, GET = 1, POST = 2, FIRST = GET, LAST = POST
;
struct Attributes
const std::string version = "HTTP/1.1";
std::string path;
Methods method;
HttpStatus::Code code;
std::unordered_map<std::string, std::string> headers;
json body;
Attributes()
code = HttpStatus::Code::InternalServerError;
body = json::value_t::object;
bool isValidRequest()
if (!path.length()) return false;
if (method < Methods::FIRST
bool isValidResponse()
if (!headers.size()) return false;
return true;
;
static Methods doParseHttpMethod(std::string value)
Methods target = Methods::NONE;
if (value == "GET") target = Methods::GET;
if (value == "POST") target = Methods::POST;
return target;
private:
;
Main (usage):
#include "Server/Server.h"
void exec(Request* request, Response* response)
json body;
body["foo"] = 123;
body["bar"] = true;
response->setBody(body);
response->doSendSuccess();
int main(int argc, char* argv[])
Server* server = new Server(5000);
server->setRoute("/getStatus", Struct::Methods::GET, exec);
server->setRoute("/postStatus", Struct::Methods::POST, exec);
server->doListen();
// let threads live for some time before they eternaly be gone
/*
actually I'm stuck with this sleep, I don't know how to hold
this until caller call doStop() without using while and
consuming process power
*/
sleep(30);
delete server;
return 1;
Basically I'm mirroring NodeJS express API Usage:
server.setRoute(path, route, callback);
So, what can be done to improve my code in terms of optimization and efficiency?
Thanks in advance.
c++ multithreading http socket server
New contributor
$endgroup$
I'm working on a project (studying) and I have a lot of time for proof of concepts and write something from scratch.
Basically I'm creating a Http Server (simple, but not too simple) in C++ using sockets and multi-threading.
There are two topics that I'm concerned about: the design pattern of my code structure and the efficiency of my thread implementation. Obs: a little worried about C++ best practices, since I'm diving too fast into C++ (Am I abusing of std items?, since this require a low-level implementation).
Server is the main file, that calls Routes, Request and Response. Request and Response contains Struct (that contains Status Code). And Routes contains Request and Response.
IMPORTANT: I'm using nlohmann/json (https://github.com/nlohmann/json) and j-ulrich status-codes (https://github.com/j-ulrich/http-status-codes-cpp).
Server (Accepting Sockets and Multi-threading):
#pragma once
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <iostream>
#include <unordered_map>
#include <thread>
#include <mutex>
#include <condition_variable>
#include "Server/Request.h"
#include "Server/Response.h"
#include "Server/Struct.h"
#include "Server/Routes.h"
#include "Tools/Logger.h"
class Server
public:
Server(unsigned int port, unsigned int max_connections = 64, unsigned int thread_count = 5);
~Server();
bool setRoute(std::string path, Struct::Methods method, void (*callback)(Request*, Response*));
bool doListen();
bool doStop();
private:
unsigned int _port;
unsigned int _max_connections;
unsigned int _thread_count;
std::mutex _mutex;
std::condition_variable _condition;
bool _signal;
std::vector<unsigned int> _queue;
std::thread* _thread_consume;
std::thread* _thread_process;
Routes* _routes;
int _socket;
struct sockaddr_in _address;
bool _listen;
bool _doStop();
bool _doCreateSocket(int& socket_in);
bool _doBindSocket(int file_descriptor);
void _doConsumeSocket();
void _doProcessSocket(int id);
bool _doProcessRequest(Request* request, Response* response);
;
#include "Server/Server.h"
Server::Server(unsigned int port, unsigned int max_connections, unsigned int thread_count)
if (port > 65535)
Logger::doSendMessage(Logger::TYPES::ERROR, "[Port must be something between 0 and 65535 on Server::Constructor.");
if (max_connections < 1)
Logger::doSendMessage(Logger::TYPES::ERROR, "Max connections can't be lower than 1 on Server::Constructor.");
_port = port;
_max_connections = max_connections;
_thread_count = thread_count;
_routes = new Routes();
int status = _doCreateSocket(_socket);
if (!status)
Logger::doSendMessage(Logger::TYPES::ERROR, "Failed to create socket on Server::Constructor.");
if (!_doBindSocket(_socket))
Logger::doSendMessage(Logger::TYPES::ERROR, "Failed to bind socket on Server::Constructor.");
;
_signal = false;
_listen = false;
Server::~Server()
_doStop();
shutdown(_socket, SHUT_RD);
close(_socket);
try
_thread_consume->join();
for (size_t i = 0; i < _thread_count; i++)
_thread_process[i].join();
catch (...)
delete _thread_consume;
delete[] _thread_process;
delete _routes;
bool Server::setRoute(std::string path, Struct::Methods method, void (*callback)(Request*, Response*))
return _routes->setRoute(path, method, callback);
bool Server::doListen()
if (_listen) return false;
int status;
status = listen(_socket, _max_connections);
if (status < 0) return false;
Logger::doSendMessage(Logger::TYPES::INFO, "Server running with success at port " + std::to_string(_port) + ".");
_listen = true;
_thread_consume = new std::thread(&Server::_doConsumeSocket, this);
_thread_process = new std::thread[_thread_count];
for (size_t i = 0; i < _thread_count; i++)
_thread_process[i] = std::thread(&Server::_doProcessSocket, this, i);
return true;
bool Server::doStop()
return _doStop();
bool Server::_doStop()
if (!_listen) return false;
std::lock_guard<std::mutex> lock(_mutex);
_listen = false;
_condition.notify_one();
return true;
bool Server::_doCreateSocket(int& socket_in) SO_REUSEPORT, &opt, sizeof(opt));
if (error) return false;
socket_in = file_descriptor;
return true;
bool Server::_doBindSocket(int file_descriptor)
if (!file_descriptor) return false;
_address.sin_family = AF_INET;
_address.sin_addr.s_addr = INADDR_ANY;
_address.sin_port = htons(_port);
int status;
status = bind(file_descriptor, (struct sockaddr*) &_address, sizeof(_address));
if (status < 0) return false;
return true;
void Server::_doConsumeSocket()
int socket_in;
int address_size = sizeof(_address);
while (_listen)
socket_in = accept(_socket, (struct sockaddr*) &_address, (socklen_t*) &address_size);
if (socket_in < 0) continue;
std::lock_guard<std::mutex> lock(_mutex);
_queue.push_back(socket_in);
_signal = true;
_condition.notify_one();
void Server::_doProcessSocket(int id)
while (_listen)
int queue_size = 0;
std::unique_lock<std::mutex> lock(_mutex);
_condition.wait(lock,
[this]
if (this->_signal) return true;
if (!this->_listen && !this->_queue.size()) return true;
return false;
);
queue_size = _queue.size();
if (!queue_size)
std::lock_guard<std::mutex> lock(_mutex);
_signal = false;
_condition.notify_one();
continue;
int socket_in = 0;
std::lock_guard<std::mutex> lock(_mutex);
socket_in = _queue[0];
_queue.erase(_queue.begin());
Request* request = new Request(socket_in);
Response* response = new Response(socket_in);
int status = _doProcessRequest(request, response);
delete request;
delete response;
close(socket_in);
bool Server::_doProcessRequest(Request* request, Response* response)
if (!request->isValid())
response->doSendError(HttpStatus::Code::BadRequest, "Invalid request.");
return false;
std::string path = request->getPath();
Struct::Methods method = request->getMethod();
Routes::Route route;
if (!(_routes->getRoute(path, method, route) && route.isValid()))
response->doSendError(HttpStatus::Code::Forbidden, "Path invalid/not found.");
return false;
if (route.method != method)
response->doSendError(HttpStatus::Code::MethodNotAllowed, "Method invalid/not found.");
return false;
void (*callback)(Request*, Response*) = route.callback;
callback(request, response);
if (!response->isSent())
response->doSendError(HttpStatus::Code::ServiceUnavailable, "Resource was not found or can't respond now.");
return true;
Request (parsing) and Response (sending)
Request
#pragma once
#include <unistd.h>
#include <string.h>
#include <iostream>
#include <string>
#include <vector>
#include <unordered_map>
#include <regex>
#include <json.hpp>
#include "Server/Struct.h"
using json = nlohmann::json;
class Request
public:
Request(int socket, unsigned int buffer_size = 1024);
~Request();
bool isValid();
std::string getPath() return _attributes.path;
Struct::Methods getMethod() return _attributes.method;
std::unordered_map<std::string, std::string> getHeaders() return _attributes.headers;
std::string getHeader(std::string header) return _attributes.headers[header];
json getBody() return _attributes.body;
private:
int _socket;
unsigned int _buffer_size;
std::string _data;
Struct::Attributes _attributes;
bool _status;
std::string _doReceiveData(int sock_in);
bool _doParseData(std::string data, Struct::Attributes& attributes);
std::vector<std::string> _doSplitText(std::string text, std::string delimiter);
std::vector<std::string> _doSplitText(std::string text, std::string delimiter, int lock);
;
Request::Request(int socket, unsigned int buffer_size)
_socket = socket;
_buffer_size = buffer_size;
_status = false;
_data = _doReceiveData(_socket);
if (!_data.length()) return;
bool result;
result = _doParseData(_data, _attributes);
if (!result) return;
if (!_attributes.isValidRequest()) return;
_status = true;
Request::~Request()
bool Request::isValid()
return _status;
std::string Request::_doReceiveData(int sock_in)
char* buffer = new char[_buffer_size];
memset(buffer, '', _buffer_size);
read(sock_in, buffer, _buffer_size);
std::string data;
data.assign(buffer);
delete[] buffer;
return data;
bool Request::_doParseData(std::string data, Struct::Attributes& attributes)
std::string delimiter = "rn";
std::vector<std::string> rows = _doSplitText(data, delimiter);
if (!rows.size()) return false;
std::string header = rows[0];
rows.erase(rows.begin());
if (!header.length()) return false;
std::vector<std::string> parsed_header = _doSplitText(header, std::string(" "));
if (parsed_header.size() < 2) return false;
Struct::Methods method = Struct::doParseHttpMethod(parsed_header[0]);
if (method == Struct::Methods::NONE) return false;
std::string path = parsed_header[1];
std::unordered_map<std::string, std::string> headers;
for (size_t i = 0; i < rows.size(); i++)
std::string row = rows[i];
delimiter = ":";
std::vector<std::string> splited = _doSplitText(row, delimiter, true);
if (splited.size() != 2) continue;
headers[splited[0]] = splited[1];
_attributes.method = method;
_attributes.path = path;
_attributes.headers = headers;
std::string content_length = headers["Content-Length"];
int content_size = 0;
if (content_size = atoi(content_length.c_str()))
std::string body = data.substr(data.length() - content_size, data.length());
json parsed_body = json::parse(body, nullptr, false);
if (parsed_body != NULL && !parsed_body.is_discarded()) _attributes.body = parsed_body;
return true;
std::vector<std::string> Request::_doSplitText(std::string text, std::string delimiter)
std::vector<std::string> result;
int delimiter_length = delimiter.length();
std::string block;
std::string region;
int index = 0;
for (size_t i = 0; i < text.length(); i++)
block = text.substr(i, delimiter_length);
if (block.length() != delimiter_length) continue;
if (block == delimiter)
region = text.substr(index, i - index);
result.push_back(region);
index = i + delimiter_length;
return result;
std::vector<std::string> Request::_doSplitText(std::string text, std::string delimiter, int lock)
...
Response
#pragma once
#include <unistd.h>
#include <iostream>
#include <string>
#include <unordered_map>
#include "Server/Struct.h"
class Response
public:
Response(int socket_in);
~Response();
bool isSent() return _sent;
void setCode(HttpStatus::Code code) _attributes.code = code;
void setHeader(std::string key, std::string value) _attributes.headers[key] = value;
void setBody(json body) _attributes.body = body;
void doClearHeaders() _attributes.headers.clear();
void doClearBody() _attributes.body = json::value_t::object;
bool doSendSuccess();
bool doSendError(HttpStatus::Code code, const std::string& message);
private:
int _socket;
bool _sent;
Struct::Attributes _attributes;
bool _doSendPayload();
bool _doCreatePayload(std::string& payload);
;
#include "Response.h"
Response::Response(int socket_in)
_socket = socket_in;
_sent = false;
Response::~Response()
bool Response::doSendSuccess()
setCode(HttpStatus::Code::OK);
setHeader("Connection", "Closed");
return _doSendPayload();
bool Response::doSendError(HttpStatus::Code code, const std::string& message)
setCode(code);
doClearHeaders();
doClearBody();
setHeader("Connection", "Closed");
json body;
body["error"] = ;
body["error"]["code"] = code;
body["error"]["message"] = message;
setBody(body);
return _doSendPayload();
bool Response::_doSendPayload()
if (_sent) return false;
int status;
setHeader("Server", "Dark");
setHeader("Content-Type", "application/json");
std::string payload;
status = _doCreatePayload(payload);
if (!status) return false;
status = write(_socket, payload.c_str(), payload.size());
if (status < 1) return false;
_sent = true;
return true;
bool Response::_doCreatePayload(std::string& payload)
std::string current_payload;
std::string data = _attributes.body.dump(4);
int data_length = data.size();
if (data_length)
_attributes.headers["Content-Length"] = std::to_string(data_length);
current_payload += _attributes.version + " " + std::to_string((int) _attributes.code) + " " + HttpStatus::getReasonPhrase(_attributes.code) + "rn";
std::unordered_map<std::string, std::string>::iterator iterator;
for (iterator = _attributes.headers.begin(); iterator != _attributes.headers.end(); iterator++)
std::string key = iterator->first;
std::string value = iterator->second;
current_payload += key + ": " + value + "rn";
if (data_length) current_payload += "rn" + data + "rnrn";
payload = current_payload;
return true;
Routes
#pragma once
#include <iostream>
#include <string>
#include <vector>
#include "Server/Request.h"
#include "Server/Response.h"
class Routes
public:
Routes();
~Routes();
struct Route
std::string path;
Struct::Methods method;
void (*callback)(Request*, Response*);
bool isValid() method > Struct::Methods::LAST) return false;
if (callback == nullptr) return false;
return true;
;
bool setRoute(std::string path, Struct::Methods method, void (*callback)(Request*, Response*));
bool getRoute(std::string path, Struct::Methods method, Route& route);
private:
std::vector<Route> _routes;
int _getRouteIndex(std::string path, Struct::Methods method);
;
#include "Routes.h"
Routes::Routes()
Routes::~Routes()
bool Routes::setRoute(std::string path, Struct::Methods method, void (*callback)(Request*, Response*))
bool Routes::getRoute(std::string path, Struct::Methods method, Routes::Route& route)
int index = _getRouteIndex(path, method);
if (index < 0) return false;
route = _routes[index];
return true;
int Routes::_getRouteIndex(std::string path, Struct::Methods method)
for (size_t i = 0; i < _routes.size(); i++)
Route* route = &_routes[i];
if (route->path == path && route->method == method)
return i;
return -1;
Struct and StatusCode
StatusCode
https://github.com/j-ulrich/http-status-codes-cpp
Struct
#pragma once
#include <json.hpp>
#include "Server/StatusCode.h"
using json = nlohmann::json;
class Struct
public:
enum class Methods
NONE = 0, GET = 1, POST = 2, FIRST = GET, LAST = POST
;
struct Attributes
const std::string version = "HTTP/1.1";
std::string path;
Methods method;
HttpStatus::Code code;
std::unordered_map<std::string, std::string> headers;
json body;
Attributes()
code = HttpStatus::Code::InternalServerError;
body = json::value_t::object;
bool isValidRequest()
if (!path.length()) return false;
if (method < Methods::FIRST
bool isValidResponse()
if (!headers.size()) return false;
return true;
;
static Methods doParseHttpMethod(std::string value)
Methods target = Methods::NONE;
if (value == "GET") target = Methods::GET;
if (value == "POST") target = Methods::POST;
return target;
private:
;
Main (usage):
#include "Server/Server.h"
void exec(Request* request, Response* response)
json body;
body["foo"] = 123;
body["bar"] = true;
response->setBody(body);
response->doSendSuccess();
int main(int argc, char* argv[])
Server* server = new Server(5000);
server->setRoute("/getStatus", Struct::Methods::GET, exec);
server->setRoute("/postStatus", Struct::Methods::POST, exec);
server->doListen();
// let threads live for some time before they eternaly be gone
/*
actually I'm stuck with this sleep, I don't know how to hold
this until caller call doStop() without using while and
consuming process power
*/
sleep(30);
delete server;
return 1;
Basically I'm mirroring NodeJS express API Usage:
server.setRoute(path, route, callback);
So, what can be done to improve my code in terms of optimization and efficiency?
Thanks in advance.
c++ multithreading http socket server
c++ multithreading http socket server
New contributor
New contributor
edited 5 hours ago
Radagast
New contributor
asked 6 hours ago
RadagastRadagast
1263
1263
New contributor
New contributor
add a comment |
add a comment |
2 Answers
2
active
oldest
votes
$begingroup$
Note: This review focuses on the use of C++, rather than the functionality.
Naming:
- IMHO, the use of "do" at the start of function names is unnecessary and makes the code harder to read. The names would be fine without it (e.g.
sendSuccess
,sendError
,createSocket
all make perfect sense).
Server:
If the port must always fit in a 16 bit unsigned int, we can use
std::uint16_t
(from the<cstdint>
header) instead of anunsigned int
.The
new
keyword should almost never be used in modern C++. If we need to create it on the heap,_routes
should be astd::unique_ptr
(from<memory>
), which will be cleaned up automatically for us. In this case it looks like the variable could just be created on the stack (i.e. declared asRoutes _routes;
)._doCreateSocket()
returns a bool, but theServer
constructor uses anint
to hold the return type.It's better to use the constructor's member initializer list to initialize variables where possible (it's neater, and we don't have to worry about initializing objects twice), e.g.:
Server::Server(std::uint16_t port, unsigned int max_connections, unsigned int thread_count):
_port(port),
_max_connections(max_connections),
_thread_count(thread_count),
_signal(false),
_thread_consume(nullptr),
_thread_process(nullptr),
_routes(nullptr),
_socket(-1), // or something
_listen(false)
if (max_connections < 1)
Logger::doSendMessage(Logger::TYPES::ERROR, "Max connections can't be lower than 1 on Server::Constructor.");
if (!_doCreateSocket(_socket))
Logger::doSendMessage(Logger::TYPES::ERROR, "Failed to create socket on Server::Constructor.");
if (!_doBindSocket(_socket))
Logger::doSendMessage(Logger::TYPES::ERROR, "Failed to bind socket on Server::Constructor.");
Note that plain data variables (e.g. pointers, ints) are left uninitialized (and may contain any random value) unless we explicitly initialize them. It's safest to always set them to a known value in the constructor.
_thread_consume
can also be created on the stack (thestd::thread
default constructor doesn't launch a new thread), and_thread_process
can be astd::vector<std::thread>
. This saves us from having to do any manual memory management.Prefer to use
std::function
from the<functional>
header, instead of raw function pointers. (e.g.std::function<void(Request*, Response*)>
).The
request
andresponse
variables inServer::_doProcessSocket
should be created on the stack. We can still pass them by pointers if necessary by taking their addresses (_doProcessRequest(&request, &response)
), or (better) we could pass them by reference.The status code returned by
Server::_doProcessRequest()
isn't used.In
Server::_doProcessRequest()
, theif (route.method != method)
check is unnecessary, since we used themethod
while finding the route.The forwarding from
doStop
to_doStop
is unnecessary.This class is doing several things. It manages a thread pool, as well as doing raw socket stuff. We could definitely split the socket functionality into a separate class.
Request:
Member functions that don't alter the member variables of a class should be declared
const
, e.g.:bool isValid() const;
. This means we can make proper use ofconst
andconst&
variables, allowing the compiler to perform better optimisations, and preventing programmer error.The getter functions in this class all return by value. This probably results in some unnecessary copies being made, which may be expensive where the objects require allocation of memory (e.g. copying the
unordered_map
/string
s). It might be better to return byconst&
instead, e.g.:std::unordered_map<std::string, std::string> const& getHeaders();
. This still prevents the caller from altering referenced variable, but allows them to decide whether to copy it, copy part of it, or not copy it at all.In
Request::_doReceiveData
, we can use astd::vector<char>
for the buffer rather than doing manual memory management. (It's guaranteed to provide contiguous memory, which we can access using the.data()
member function).
Routes:
Routes::setRoute
should probably use theRoute::isValid
method, rather than duplicating the checks.There's some unnecessary
string
copies ingetRoute
. We should pass the variable as a reference:const std::string& path
instead.Using iterators and the standard library search algorithms is more idiomatic C++ than indices. e.g.:
auto route = std::find_if(_routes.begin(), routes.end(),
[] (Route const& route) return (route.path == path) && (route->method == method); );
if (route == routes.end()) // route not found!(Unless it's reused elsewhere, I'd be inclined to remove the
Routes
class in favor of astd::vector<Route> _routes;
in theServer
class.)
Main:
(Use
std::this_thread::sleep_for
for a portable sleep function.)I think
std::condition_variable::wait()
may be what you're looking for.
$endgroup$
add a comment |
$begingroup$
It's not bad code for someone new to C++. Here are some observations and suggestions that may help you improve your code.
Avoid relative paths in #include
s
Generally it's better to omit relative path names from #include
files and instead point the compiler to the appropriate location. So instead of this:
#include "Server/Routes.h"
#include "Tools/Logger.h"
write this:
#include "Routes.h"
#include "Logger.h"
For gcc
, you'd use -I
to tell the compiler where to find these files. This makes the code less dependent on the actual file structure, and leaving such details in a single location: a Makefile
or compiler configuration file. With cmake
, we can use include_directories
.
Prefer to avoid using new
and delete
directly
The server
variable within the main()
function doesn't really need to be allocated via new
. The same is true of the _routes
member of Server
and probably some other places as well. That way, it is automatically created with the correct length and then discarded when the function is complete or the owning object is deleted.
Avoid leading underscores in names
Anything with a leading underscore is a reserved name in C++ (and in C). See this question for details.
Prefer modern initializers for constructors
The constructor use the more modern initializer style rather than the old style you're currently using. Instead of this:
Response::Response(int socket_in)
_socket = socket_in;
_sent = false;
one could write this:
Response::Response(int socket_in) :
_socketsocket_in,
_sentfalse
Let the compiler create default destructor
The compiler will create a destructor by default which is essentially identical to what you've got in several places, so you can simply omit both the declaraton and implementation from your code.
Fix the bug
This is a very subtle bug, but a bug nonetheless. Within Server::setRoute()
three threads are created, two of which take this
as a parameter. The problem is that there's no guarantee that the object still exists for the duration of the launched threads. What you need is to use enable_shared_from_this
with the class and then use a shared_ptr
. This question explains a bit more. Generally speaking, it is somewhat difficult to write robust multithreaded code in C++ because there are many ways to create subtle bugs like this.
Avoid needless casts and variables
The current code contains these two lines:
void (*callback)(Request*, Response*) = route.callback;
callback(request, response);
But this could be much more simply written like this:
route.callback(request, response);
Use const
where practical
The Request::isValid()
and Routes::_getRouteIndex
member functions do not alter the underlying objects and therefore should be declared const
. That is, the declaration should be:
int _getRouteIndex(std::string path, Struct::Methods method) const;
Use "range for
" and simplify your code
The current Routes::_getRouteIndex
looks like this:
int Routes::_getRouteIndex(std::string path, Struct::Methods method)
for (size_t i = 0; i < _routes.size(); i++)
Route* route = &_routes[i];
if (route->path == path && route->method == method)
return i;
return -1;
Using a range for
it could be written like this:
int Routes::_getRouteIndex(std::string path, Struct::Methods method) const
int i0;
for (const auto &r : _routes)
if (r.path == path && r.method == method)
return i;
++i;
return -1;
However, even better in this instance, use the next suggestion.
Use library functions where appropriate
The code for Routes
currently stores each Route
in a std::vector
and then goes through some machinations to recover the index. This could be done more simply by using a std::unordered_map
. Also, it may be sufficient just to use the path
as an index because the calling code checks that the method matches. Right now, it's not possible to trigger the "Method invalid/not found" error because getRoute
only returns true if both the path
and the method
match.
Omit unused variables
Because argc
and argv
are unused, you could use the alternative form of main
:
int main ()
There are also a number of other places in which passed variables are unused.
$endgroup$
add a comment |
Your Answer
StackExchange.ifUsing("editor", function ()
StackExchange.using("externalEditor", function ()
StackExchange.using("snippets", function ()
StackExchange.snippets.init();
);
);
, "code-snippets");
StackExchange.ready(function()
var channelOptions =
tags: "".split(" "),
id: "196"
;
initTagRenderer("".split(" "), "".split(" "), channelOptions);
StackExchange.using("externalEditor", function()
// Have to fire editor after snippets, if snippets enabled
if (StackExchange.settings.snippets.snippetsEnabled)
StackExchange.using("snippets", function()
createEditor();
);
else
createEditor();
);
function createEditor()
StackExchange.prepareEditor(
heartbeatType: 'answer',
autoActivateHeartbeat: false,
convertImagesToLinks: false,
noModals: true,
showLowRepImageUploadWarning: true,
reputationToPostImages: null,
bindNavPrevention: true,
postfix: "",
imageUploader:
brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
allowUrls: true
,
onDemand: true,
discardSelector: ".discard-answer"
,immediatelyShowMarkdownHelp:true
);
);
Radagast is a new contributor. Be nice, and check out our Code of Conduct.
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function ()
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodereview.stackexchange.com%2fquestions%2f217783%2fsimple-http-server%23new-answer', 'question_page');
);
Post as a guest
Required, but never shown
2 Answers
2
active
oldest
votes
2 Answers
2
active
oldest
votes
active
oldest
votes
active
oldest
votes
$begingroup$
Note: This review focuses on the use of C++, rather than the functionality.
Naming:
- IMHO, the use of "do" at the start of function names is unnecessary and makes the code harder to read. The names would be fine without it (e.g.
sendSuccess
,sendError
,createSocket
all make perfect sense).
Server:
If the port must always fit in a 16 bit unsigned int, we can use
std::uint16_t
(from the<cstdint>
header) instead of anunsigned int
.The
new
keyword should almost never be used in modern C++. If we need to create it on the heap,_routes
should be astd::unique_ptr
(from<memory>
), which will be cleaned up automatically for us. In this case it looks like the variable could just be created on the stack (i.e. declared asRoutes _routes;
)._doCreateSocket()
returns a bool, but theServer
constructor uses anint
to hold the return type.It's better to use the constructor's member initializer list to initialize variables where possible (it's neater, and we don't have to worry about initializing objects twice), e.g.:
Server::Server(std::uint16_t port, unsigned int max_connections, unsigned int thread_count):
_port(port),
_max_connections(max_connections),
_thread_count(thread_count),
_signal(false),
_thread_consume(nullptr),
_thread_process(nullptr),
_routes(nullptr),
_socket(-1), // or something
_listen(false)
if (max_connections < 1)
Logger::doSendMessage(Logger::TYPES::ERROR, "Max connections can't be lower than 1 on Server::Constructor.");
if (!_doCreateSocket(_socket))
Logger::doSendMessage(Logger::TYPES::ERROR, "Failed to create socket on Server::Constructor.");
if (!_doBindSocket(_socket))
Logger::doSendMessage(Logger::TYPES::ERROR, "Failed to bind socket on Server::Constructor.");
Note that plain data variables (e.g. pointers, ints) are left uninitialized (and may contain any random value) unless we explicitly initialize them. It's safest to always set them to a known value in the constructor.
_thread_consume
can also be created on the stack (thestd::thread
default constructor doesn't launch a new thread), and_thread_process
can be astd::vector<std::thread>
. This saves us from having to do any manual memory management.Prefer to use
std::function
from the<functional>
header, instead of raw function pointers. (e.g.std::function<void(Request*, Response*)>
).The
request
andresponse
variables inServer::_doProcessSocket
should be created on the stack. We can still pass them by pointers if necessary by taking their addresses (_doProcessRequest(&request, &response)
), or (better) we could pass them by reference.The status code returned by
Server::_doProcessRequest()
isn't used.In
Server::_doProcessRequest()
, theif (route.method != method)
check is unnecessary, since we used themethod
while finding the route.The forwarding from
doStop
to_doStop
is unnecessary.This class is doing several things. It manages a thread pool, as well as doing raw socket stuff. We could definitely split the socket functionality into a separate class.
Request:
Member functions that don't alter the member variables of a class should be declared
const
, e.g.:bool isValid() const;
. This means we can make proper use ofconst
andconst&
variables, allowing the compiler to perform better optimisations, and preventing programmer error.The getter functions in this class all return by value. This probably results in some unnecessary copies being made, which may be expensive where the objects require allocation of memory (e.g. copying the
unordered_map
/string
s). It might be better to return byconst&
instead, e.g.:std::unordered_map<std::string, std::string> const& getHeaders();
. This still prevents the caller from altering referenced variable, but allows them to decide whether to copy it, copy part of it, or not copy it at all.In
Request::_doReceiveData
, we can use astd::vector<char>
for the buffer rather than doing manual memory management. (It's guaranteed to provide contiguous memory, which we can access using the.data()
member function).
Routes:
Routes::setRoute
should probably use theRoute::isValid
method, rather than duplicating the checks.There's some unnecessary
string
copies ingetRoute
. We should pass the variable as a reference:const std::string& path
instead.Using iterators and the standard library search algorithms is more idiomatic C++ than indices. e.g.:
auto route = std::find_if(_routes.begin(), routes.end(),
[] (Route const& route) return (route.path == path) && (route->method == method); );
if (route == routes.end()) // route not found!(Unless it's reused elsewhere, I'd be inclined to remove the
Routes
class in favor of astd::vector<Route> _routes;
in theServer
class.)
Main:
(Use
std::this_thread::sleep_for
for a portable sleep function.)I think
std::condition_variable::wait()
may be what you're looking for.
$endgroup$
add a comment |
$begingroup$
Note: This review focuses on the use of C++, rather than the functionality.
Naming:
- IMHO, the use of "do" at the start of function names is unnecessary and makes the code harder to read. The names would be fine without it (e.g.
sendSuccess
,sendError
,createSocket
all make perfect sense).
Server:
If the port must always fit in a 16 bit unsigned int, we can use
std::uint16_t
(from the<cstdint>
header) instead of anunsigned int
.The
new
keyword should almost never be used in modern C++. If we need to create it on the heap,_routes
should be astd::unique_ptr
(from<memory>
), which will be cleaned up automatically for us. In this case it looks like the variable could just be created on the stack (i.e. declared asRoutes _routes;
)._doCreateSocket()
returns a bool, but theServer
constructor uses anint
to hold the return type.It's better to use the constructor's member initializer list to initialize variables where possible (it's neater, and we don't have to worry about initializing objects twice), e.g.:
Server::Server(std::uint16_t port, unsigned int max_connections, unsigned int thread_count):
_port(port),
_max_connections(max_connections),
_thread_count(thread_count),
_signal(false),
_thread_consume(nullptr),
_thread_process(nullptr),
_routes(nullptr),
_socket(-1), // or something
_listen(false)
if (max_connections < 1)
Logger::doSendMessage(Logger::TYPES::ERROR, "Max connections can't be lower than 1 on Server::Constructor.");
if (!_doCreateSocket(_socket))
Logger::doSendMessage(Logger::TYPES::ERROR, "Failed to create socket on Server::Constructor.");
if (!_doBindSocket(_socket))
Logger::doSendMessage(Logger::TYPES::ERROR, "Failed to bind socket on Server::Constructor.");
Note that plain data variables (e.g. pointers, ints) are left uninitialized (and may contain any random value) unless we explicitly initialize them. It's safest to always set them to a known value in the constructor.
_thread_consume
can also be created on the stack (thestd::thread
default constructor doesn't launch a new thread), and_thread_process
can be astd::vector<std::thread>
. This saves us from having to do any manual memory management.Prefer to use
std::function
from the<functional>
header, instead of raw function pointers. (e.g.std::function<void(Request*, Response*)>
).The
request
andresponse
variables inServer::_doProcessSocket
should be created on the stack. We can still pass them by pointers if necessary by taking their addresses (_doProcessRequest(&request, &response)
), or (better) we could pass them by reference.The status code returned by
Server::_doProcessRequest()
isn't used.In
Server::_doProcessRequest()
, theif (route.method != method)
check is unnecessary, since we used themethod
while finding the route.The forwarding from
doStop
to_doStop
is unnecessary.This class is doing several things. It manages a thread pool, as well as doing raw socket stuff. We could definitely split the socket functionality into a separate class.
Request:
Member functions that don't alter the member variables of a class should be declared
const
, e.g.:bool isValid() const;
. This means we can make proper use ofconst
andconst&
variables, allowing the compiler to perform better optimisations, and preventing programmer error.The getter functions in this class all return by value. This probably results in some unnecessary copies being made, which may be expensive where the objects require allocation of memory (e.g. copying the
unordered_map
/string
s). It might be better to return byconst&
instead, e.g.:std::unordered_map<std::string, std::string> const& getHeaders();
. This still prevents the caller from altering referenced variable, but allows them to decide whether to copy it, copy part of it, or not copy it at all.In
Request::_doReceiveData
, we can use astd::vector<char>
for the buffer rather than doing manual memory management. (It's guaranteed to provide contiguous memory, which we can access using the.data()
member function).
Routes:
Routes::setRoute
should probably use theRoute::isValid
method, rather than duplicating the checks.There's some unnecessary
string
copies ingetRoute
. We should pass the variable as a reference:const std::string& path
instead.Using iterators and the standard library search algorithms is more idiomatic C++ than indices. e.g.:
auto route = std::find_if(_routes.begin(), routes.end(),
[] (Route const& route) return (route.path == path) && (route->method == method); );
if (route == routes.end()) // route not found!(Unless it's reused elsewhere, I'd be inclined to remove the
Routes
class in favor of astd::vector<Route> _routes;
in theServer
class.)
Main:
(Use
std::this_thread::sleep_for
for a portable sleep function.)I think
std::condition_variable::wait()
may be what you're looking for.
$endgroup$
add a comment |
$begingroup$
Note: This review focuses on the use of C++, rather than the functionality.
Naming:
- IMHO, the use of "do" at the start of function names is unnecessary and makes the code harder to read. The names would be fine without it (e.g.
sendSuccess
,sendError
,createSocket
all make perfect sense).
Server:
If the port must always fit in a 16 bit unsigned int, we can use
std::uint16_t
(from the<cstdint>
header) instead of anunsigned int
.The
new
keyword should almost never be used in modern C++. If we need to create it on the heap,_routes
should be astd::unique_ptr
(from<memory>
), which will be cleaned up automatically for us. In this case it looks like the variable could just be created on the stack (i.e. declared asRoutes _routes;
)._doCreateSocket()
returns a bool, but theServer
constructor uses anint
to hold the return type.It's better to use the constructor's member initializer list to initialize variables where possible (it's neater, and we don't have to worry about initializing objects twice), e.g.:
Server::Server(std::uint16_t port, unsigned int max_connections, unsigned int thread_count):
_port(port),
_max_connections(max_connections),
_thread_count(thread_count),
_signal(false),
_thread_consume(nullptr),
_thread_process(nullptr),
_routes(nullptr),
_socket(-1), // or something
_listen(false)
if (max_connections < 1)
Logger::doSendMessage(Logger::TYPES::ERROR, "Max connections can't be lower than 1 on Server::Constructor.");
if (!_doCreateSocket(_socket))
Logger::doSendMessage(Logger::TYPES::ERROR, "Failed to create socket on Server::Constructor.");
if (!_doBindSocket(_socket))
Logger::doSendMessage(Logger::TYPES::ERROR, "Failed to bind socket on Server::Constructor.");
Note that plain data variables (e.g. pointers, ints) are left uninitialized (and may contain any random value) unless we explicitly initialize them. It's safest to always set them to a known value in the constructor.
_thread_consume
can also be created on the stack (thestd::thread
default constructor doesn't launch a new thread), and_thread_process
can be astd::vector<std::thread>
. This saves us from having to do any manual memory management.Prefer to use
std::function
from the<functional>
header, instead of raw function pointers. (e.g.std::function<void(Request*, Response*)>
).The
request
andresponse
variables inServer::_doProcessSocket
should be created on the stack. We can still pass them by pointers if necessary by taking their addresses (_doProcessRequest(&request, &response)
), or (better) we could pass them by reference.The status code returned by
Server::_doProcessRequest()
isn't used.In
Server::_doProcessRequest()
, theif (route.method != method)
check is unnecessary, since we used themethod
while finding the route.The forwarding from
doStop
to_doStop
is unnecessary.This class is doing several things. It manages a thread pool, as well as doing raw socket stuff. We could definitely split the socket functionality into a separate class.
Request:
Member functions that don't alter the member variables of a class should be declared
const
, e.g.:bool isValid() const;
. This means we can make proper use ofconst
andconst&
variables, allowing the compiler to perform better optimisations, and preventing programmer error.The getter functions in this class all return by value. This probably results in some unnecessary copies being made, which may be expensive where the objects require allocation of memory (e.g. copying the
unordered_map
/string
s). It might be better to return byconst&
instead, e.g.:std::unordered_map<std::string, std::string> const& getHeaders();
. This still prevents the caller from altering referenced variable, but allows them to decide whether to copy it, copy part of it, or not copy it at all.In
Request::_doReceiveData
, we can use astd::vector<char>
for the buffer rather than doing manual memory management. (It's guaranteed to provide contiguous memory, which we can access using the.data()
member function).
Routes:
Routes::setRoute
should probably use theRoute::isValid
method, rather than duplicating the checks.There's some unnecessary
string
copies ingetRoute
. We should pass the variable as a reference:const std::string& path
instead.Using iterators and the standard library search algorithms is more idiomatic C++ than indices. e.g.:
auto route = std::find_if(_routes.begin(), routes.end(),
[] (Route const& route) return (route.path == path) && (route->method == method); );
if (route == routes.end()) // route not found!(Unless it's reused elsewhere, I'd be inclined to remove the
Routes
class in favor of astd::vector<Route> _routes;
in theServer
class.)
Main:
(Use
std::this_thread::sleep_for
for a portable sleep function.)I think
std::condition_variable::wait()
may be what you're looking for.
$endgroup$
Note: This review focuses on the use of C++, rather than the functionality.
Naming:
- IMHO, the use of "do" at the start of function names is unnecessary and makes the code harder to read. The names would be fine without it (e.g.
sendSuccess
,sendError
,createSocket
all make perfect sense).
Server:
If the port must always fit in a 16 bit unsigned int, we can use
std::uint16_t
(from the<cstdint>
header) instead of anunsigned int
.The
new
keyword should almost never be used in modern C++. If we need to create it on the heap,_routes
should be astd::unique_ptr
(from<memory>
), which will be cleaned up automatically for us. In this case it looks like the variable could just be created on the stack (i.e. declared asRoutes _routes;
)._doCreateSocket()
returns a bool, but theServer
constructor uses anint
to hold the return type.It's better to use the constructor's member initializer list to initialize variables where possible (it's neater, and we don't have to worry about initializing objects twice), e.g.:
Server::Server(std::uint16_t port, unsigned int max_connections, unsigned int thread_count):
_port(port),
_max_connections(max_connections),
_thread_count(thread_count),
_signal(false),
_thread_consume(nullptr),
_thread_process(nullptr),
_routes(nullptr),
_socket(-1), // or something
_listen(false)
if (max_connections < 1)
Logger::doSendMessage(Logger::TYPES::ERROR, "Max connections can't be lower than 1 on Server::Constructor.");
if (!_doCreateSocket(_socket))
Logger::doSendMessage(Logger::TYPES::ERROR, "Failed to create socket on Server::Constructor.");
if (!_doBindSocket(_socket))
Logger::doSendMessage(Logger::TYPES::ERROR, "Failed to bind socket on Server::Constructor.");
Note that plain data variables (e.g. pointers, ints) are left uninitialized (and may contain any random value) unless we explicitly initialize them. It's safest to always set them to a known value in the constructor.
_thread_consume
can also be created on the stack (thestd::thread
default constructor doesn't launch a new thread), and_thread_process
can be astd::vector<std::thread>
. This saves us from having to do any manual memory management.Prefer to use
std::function
from the<functional>
header, instead of raw function pointers. (e.g.std::function<void(Request*, Response*)>
).The
request
andresponse
variables inServer::_doProcessSocket
should be created on the stack. We can still pass them by pointers if necessary by taking their addresses (_doProcessRequest(&request, &response)
), or (better) we could pass them by reference.The status code returned by
Server::_doProcessRequest()
isn't used.In
Server::_doProcessRequest()
, theif (route.method != method)
check is unnecessary, since we used themethod
while finding the route.The forwarding from
doStop
to_doStop
is unnecessary.This class is doing several things. It manages a thread pool, as well as doing raw socket stuff. We could definitely split the socket functionality into a separate class.
Request:
Member functions that don't alter the member variables of a class should be declared
const
, e.g.:bool isValid() const;
. This means we can make proper use ofconst
andconst&
variables, allowing the compiler to perform better optimisations, and preventing programmer error.The getter functions in this class all return by value. This probably results in some unnecessary copies being made, which may be expensive where the objects require allocation of memory (e.g. copying the
unordered_map
/string
s). It might be better to return byconst&
instead, e.g.:std::unordered_map<std::string, std::string> const& getHeaders();
. This still prevents the caller from altering referenced variable, but allows them to decide whether to copy it, copy part of it, or not copy it at all.In
Request::_doReceiveData
, we can use astd::vector<char>
for the buffer rather than doing manual memory management. (It's guaranteed to provide contiguous memory, which we can access using the.data()
member function).
Routes:
Routes::setRoute
should probably use theRoute::isValid
method, rather than duplicating the checks.There's some unnecessary
string
copies ingetRoute
. We should pass the variable as a reference:const std::string& path
instead.Using iterators and the standard library search algorithms is more idiomatic C++ than indices. e.g.:
auto route = std::find_if(_routes.begin(), routes.end(),
[] (Route const& route) return (route.path == path) && (route->method == method); );
if (route == routes.end()) // route not found!(Unless it's reused elsewhere, I'd be inclined to remove the
Routes
class in favor of astd::vector<Route> _routes;
in theServer
class.)
Main:
(Use
std::this_thread::sleep_for
for a portable sleep function.)I think
std::condition_variable::wait()
may be what you're looking for.
answered 2 hours ago
user673679user673679
3,75311231
3,75311231
add a comment |
add a comment |
$begingroup$
It's not bad code for someone new to C++. Here are some observations and suggestions that may help you improve your code.
Avoid relative paths in #include
s
Generally it's better to omit relative path names from #include
files and instead point the compiler to the appropriate location. So instead of this:
#include "Server/Routes.h"
#include "Tools/Logger.h"
write this:
#include "Routes.h"
#include "Logger.h"
For gcc
, you'd use -I
to tell the compiler where to find these files. This makes the code less dependent on the actual file structure, and leaving such details in a single location: a Makefile
or compiler configuration file. With cmake
, we can use include_directories
.
Prefer to avoid using new
and delete
directly
The server
variable within the main()
function doesn't really need to be allocated via new
. The same is true of the _routes
member of Server
and probably some other places as well. That way, it is automatically created with the correct length and then discarded when the function is complete or the owning object is deleted.
Avoid leading underscores in names
Anything with a leading underscore is a reserved name in C++ (and in C). See this question for details.
Prefer modern initializers for constructors
The constructor use the more modern initializer style rather than the old style you're currently using. Instead of this:
Response::Response(int socket_in)
_socket = socket_in;
_sent = false;
one could write this:
Response::Response(int socket_in) :
_socketsocket_in,
_sentfalse
Let the compiler create default destructor
The compiler will create a destructor by default which is essentially identical to what you've got in several places, so you can simply omit both the declaraton and implementation from your code.
Fix the bug
This is a very subtle bug, but a bug nonetheless. Within Server::setRoute()
three threads are created, two of which take this
as a parameter. The problem is that there's no guarantee that the object still exists for the duration of the launched threads. What you need is to use enable_shared_from_this
with the class and then use a shared_ptr
. This question explains a bit more. Generally speaking, it is somewhat difficult to write robust multithreaded code in C++ because there are many ways to create subtle bugs like this.
Avoid needless casts and variables
The current code contains these two lines:
void (*callback)(Request*, Response*) = route.callback;
callback(request, response);
But this could be much more simply written like this:
route.callback(request, response);
Use const
where practical
The Request::isValid()
and Routes::_getRouteIndex
member functions do not alter the underlying objects and therefore should be declared const
. That is, the declaration should be:
int _getRouteIndex(std::string path, Struct::Methods method) const;
Use "range for
" and simplify your code
The current Routes::_getRouteIndex
looks like this:
int Routes::_getRouteIndex(std::string path, Struct::Methods method)
for (size_t i = 0; i < _routes.size(); i++)
Route* route = &_routes[i];
if (route->path == path && route->method == method)
return i;
return -1;
Using a range for
it could be written like this:
int Routes::_getRouteIndex(std::string path, Struct::Methods method) const
int i0;
for (const auto &r : _routes)
if (r.path == path && r.method == method)
return i;
++i;
return -1;
However, even better in this instance, use the next suggestion.
Use library functions where appropriate
The code for Routes
currently stores each Route
in a std::vector
and then goes through some machinations to recover the index. This could be done more simply by using a std::unordered_map
. Also, it may be sufficient just to use the path
as an index because the calling code checks that the method matches. Right now, it's not possible to trigger the "Method invalid/not found" error because getRoute
only returns true if both the path
and the method
match.
Omit unused variables
Because argc
and argv
are unused, you could use the alternative form of main
:
int main ()
There are also a number of other places in which passed variables are unused.
$endgroup$
add a comment |
$begingroup$
It's not bad code for someone new to C++. Here are some observations and suggestions that may help you improve your code.
Avoid relative paths in #include
s
Generally it's better to omit relative path names from #include
files and instead point the compiler to the appropriate location. So instead of this:
#include "Server/Routes.h"
#include "Tools/Logger.h"
write this:
#include "Routes.h"
#include "Logger.h"
For gcc
, you'd use -I
to tell the compiler where to find these files. This makes the code less dependent on the actual file structure, and leaving such details in a single location: a Makefile
or compiler configuration file. With cmake
, we can use include_directories
.
Prefer to avoid using new
and delete
directly
The server
variable within the main()
function doesn't really need to be allocated via new
. The same is true of the _routes
member of Server
and probably some other places as well. That way, it is automatically created with the correct length and then discarded when the function is complete or the owning object is deleted.
Avoid leading underscores in names
Anything with a leading underscore is a reserved name in C++ (and in C). See this question for details.
Prefer modern initializers for constructors
The constructor use the more modern initializer style rather than the old style you're currently using. Instead of this:
Response::Response(int socket_in)
_socket = socket_in;
_sent = false;
one could write this:
Response::Response(int socket_in) :
_socketsocket_in,
_sentfalse
Let the compiler create default destructor
The compiler will create a destructor by default which is essentially identical to what you've got in several places, so you can simply omit both the declaraton and implementation from your code.
Fix the bug
This is a very subtle bug, but a bug nonetheless. Within Server::setRoute()
three threads are created, two of which take this
as a parameter. The problem is that there's no guarantee that the object still exists for the duration of the launched threads. What you need is to use enable_shared_from_this
with the class and then use a shared_ptr
. This question explains a bit more. Generally speaking, it is somewhat difficult to write robust multithreaded code in C++ because there are many ways to create subtle bugs like this.
Avoid needless casts and variables
The current code contains these two lines:
void (*callback)(Request*, Response*) = route.callback;
callback(request, response);
But this could be much more simply written like this:
route.callback(request, response);
Use const
where practical
The Request::isValid()
and Routes::_getRouteIndex
member functions do not alter the underlying objects and therefore should be declared const
. That is, the declaration should be:
int _getRouteIndex(std::string path, Struct::Methods method) const;
Use "range for
" and simplify your code
The current Routes::_getRouteIndex
looks like this:
int Routes::_getRouteIndex(std::string path, Struct::Methods method)
for (size_t i = 0; i < _routes.size(); i++)
Route* route = &_routes[i];
if (route->path == path && route->method == method)
return i;
return -1;
Using a range for
it could be written like this:
int Routes::_getRouteIndex(std::string path, Struct::Methods method) const
int i0;
for (const auto &r : _routes)
if (r.path == path && r.method == method)
return i;
++i;
return -1;
However, even better in this instance, use the next suggestion.
Use library functions where appropriate
The code for Routes
currently stores each Route
in a std::vector
and then goes through some machinations to recover the index. This could be done more simply by using a std::unordered_map
. Also, it may be sufficient just to use the path
as an index because the calling code checks that the method matches. Right now, it's not possible to trigger the "Method invalid/not found" error because getRoute
only returns true if both the path
and the method
match.
Omit unused variables
Because argc
and argv
are unused, you could use the alternative form of main
:
int main ()
There are also a number of other places in which passed variables are unused.
$endgroup$
add a comment |
$begingroup$
It's not bad code for someone new to C++. Here are some observations and suggestions that may help you improve your code.
Avoid relative paths in #include
s
Generally it's better to omit relative path names from #include
files and instead point the compiler to the appropriate location. So instead of this:
#include "Server/Routes.h"
#include "Tools/Logger.h"
write this:
#include "Routes.h"
#include "Logger.h"
For gcc
, you'd use -I
to tell the compiler where to find these files. This makes the code less dependent on the actual file structure, and leaving such details in a single location: a Makefile
or compiler configuration file. With cmake
, we can use include_directories
.
Prefer to avoid using new
and delete
directly
The server
variable within the main()
function doesn't really need to be allocated via new
. The same is true of the _routes
member of Server
and probably some other places as well. That way, it is automatically created with the correct length and then discarded when the function is complete or the owning object is deleted.
Avoid leading underscores in names
Anything with a leading underscore is a reserved name in C++ (and in C). See this question for details.
Prefer modern initializers for constructors
The constructor use the more modern initializer style rather than the old style you're currently using. Instead of this:
Response::Response(int socket_in)
_socket = socket_in;
_sent = false;
one could write this:
Response::Response(int socket_in) :
_socketsocket_in,
_sentfalse
Let the compiler create default destructor
The compiler will create a destructor by default which is essentially identical to what you've got in several places, so you can simply omit both the declaraton and implementation from your code.
Fix the bug
This is a very subtle bug, but a bug nonetheless. Within Server::setRoute()
three threads are created, two of which take this
as a parameter. The problem is that there's no guarantee that the object still exists for the duration of the launched threads. What you need is to use enable_shared_from_this
with the class and then use a shared_ptr
. This question explains a bit more. Generally speaking, it is somewhat difficult to write robust multithreaded code in C++ because there are many ways to create subtle bugs like this.
Avoid needless casts and variables
The current code contains these two lines:
void (*callback)(Request*, Response*) = route.callback;
callback(request, response);
But this could be much more simply written like this:
route.callback(request, response);
Use const
where practical
The Request::isValid()
and Routes::_getRouteIndex
member functions do not alter the underlying objects and therefore should be declared const
. That is, the declaration should be:
int _getRouteIndex(std::string path, Struct::Methods method) const;
Use "range for
" and simplify your code
The current Routes::_getRouteIndex
looks like this:
int Routes::_getRouteIndex(std::string path, Struct::Methods method)
for (size_t i = 0; i < _routes.size(); i++)
Route* route = &_routes[i];
if (route->path == path && route->method == method)
return i;
return -1;
Using a range for
it could be written like this:
int Routes::_getRouteIndex(std::string path, Struct::Methods method) const
int i0;
for (const auto &r : _routes)
if (r.path == path && r.method == method)
return i;
++i;
return -1;
However, even better in this instance, use the next suggestion.
Use library functions where appropriate
The code for Routes
currently stores each Route
in a std::vector
and then goes through some machinations to recover the index. This could be done more simply by using a std::unordered_map
. Also, it may be sufficient just to use the path
as an index because the calling code checks that the method matches. Right now, it's not possible to trigger the "Method invalid/not found" error because getRoute
only returns true if both the path
and the method
match.
Omit unused variables
Because argc
and argv
are unused, you could use the alternative form of main
:
int main ()
There are also a number of other places in which passed variables are unused.
$endgroup$
It's not bad code for someone new to C++. Here are some observations and suggestions that may help you improve your code.
Avoid relative paths in #include
s
Generally it's better to omit relative path names from #include
files and instead point the compiler to the appropriate location. So instead of this:
#include "Server/Routes.h"
#include "Tools/Logger.h"
write this:
#include "Routes.h"
#include "Logger.h"
For gcc
, you'd use -I
to tell the compiler where to find these files. This makes the code less dependent on the actual file structure, and leaving such details in a single location: a Makefile
or compiler configuration file. With cmake
, we can use include_directories
.
Prefer to avoid using new
and delete
directly
The server
variable within the main()
function doesn't really need to be allocated via new
. The same is true of the _routes
member of Server
and probably some other places as well. That way, it is automatically created with the correct length and then discarded when the function is complete or the owning object is deleted.
Avoid leading underscores in names
Anything with a leading underscore is a reserved name in C++ (and in C). See this question for details.
Prefer modern initializers for constructors
The constructor use the more modern initializer style rather than the old style you're currently using. Instead of this:
Response::Response(int socket_in)
_socket = socket_in;
_sent = false;
one could write this:
Response::Response(int socket_in) :
_socketsocket_in,
_sentfalse
Let the compiler create default destructor
The compiler will create a destructor by default which is essentially identical to what you've got in several places, so you can simply omit both the declaraton and implementation from your code.
Fix the bug
This is a very subtle bug, but a bug nonetheless. Within Server::setRoute()
three threads are created, two of which take this
as a parameter. The problem is that there's no guarantee that the object still exists for the duration of the launched threads. What you need is to use enable_shared_from_this
with the class and then use a shared_ptr
. This question explains a bit more. Generally speaking, it is somewhat difficult to write robust multithreaded code in C++ because there are many ways to create subtle bugs like this.
Avoid needless casts and variables
The current code contains these two lines:
void (*callback)(Request*, Response*) = route.callback;
callback(request, response);
But this could be much more simply written like this:
route.callback(request, response);
Use const
where practical
The Request::isValid()
and Routes::_getRouteIndex
member functions do not alter the underlying objects and therefore should be declared const
. That is, the declaration should be:
int _getRouteIndex(std::string path, Struct::Methods method) const;
Use "range for
" and simplify your code
The current Routes::_getRouteIndex
looks like this:
int Routes::_getRouteIndex(std::string path, Struct::Methods method)
for (size_t i = 0; i < _routes.size(); i++)
Route* route = &_routes[i];
if (route->path == path && route->method == method)
return i;
return -1;
Using a range for
it could be written like this:
int Routes::_getRouteIndex(std::string path, Struct::Methods method) const
int i0;
for (const auto &r : _routes)
if (r.path == path && r.method == method)
return i;
++i;
return -1;
However, even better in this instance, use the next suggestion.
Use library functions where appropriate
The code for Routes
currently stores each Route
in a std::vector
and then goes through some machinations to recover the index. This could be done more simply by using a std::unordered_map
. Also, it may be sufficient just to use the path
as an index because the calling code checks that the method matches. Right now, it's not possible to trigger the "Method invalid/not found" error because getRoute
only returns true if both the path
and the method
match.
Omit unused variables
Because argc
and argv
are unused, you could use the alternative form of main
:
int main ()
There are also a number of other places in which passed variables are unused.
answered 16 mins ago
EdwardEdward
48k380213
48k380213
add a comment |
add a comment |
Radagast is a new contributor. Be nice, and check out our Code of Conduct.
Radagast is a new contributor. Be nice, and check out our Code of Conduct.
Radagast is a new contributor. Be nice, and check out our Code of Conduct.
Radagast is a new contributor. Be nice, and check out our Code of Conduct.
Thanks for contributing an answer to Code Review Stack Exchange!
- Please be sure to answer the question. Provide details and share your research!
But avoid …
- Asking for help, clarification, or responding to other answers.
- Making statements based on opinion; back them up with references or personal experience.
Use MathJax to format equations. MathJax reference.
To learn more, see our tips on writing great answers.
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function ()
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodereview.stackexchange.com%2fquestions%2f217783%2fsimple-http-server%23new-answer', 'question_page');
);
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown