nickorlow/anthracite
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Release v0.3.0
Some checks failed
Docker Build & Publish / build (push) Has been cancelled
Details

Browse source
This commit is contained in:
Nicholas Orlowsky 2025-02-24 19:29:43 -05:00
parent c07f3ebf81
commit 9b5719f9be
17 changed files with 612 additions and 308 deletions
Download patch file Download diff file Expand all files Collapse all files

59
lib/config/config.hpp
View file

@ -1,59 +0,0 @@
#pragma once
#include <optional>
#include <inttypes.h>
#include <string>
namespace anthracite::config {
class http_config {
uint16_t _port;
public:
http_config(uint16_t port) : _port(port) {};
virtual ~http_config() {};
uint16_t port() { return _port; }
};
class https_config : public http_config {
std::string _cert_path;
std::string _key_path;
public:
https_config(uint16_t port, std::string cert_path, std::string key_path) :
http_config(port), _cert_path(cert_path), _key_path(key_path) {};
};
class config {
int _worker_threads;
int _max_clients;
std::optional<http_config> _http_config;
std::optional<https_config> _https_config;
public:
config(int worker_threads, int max_clients) : _worker_threads(worker_threads), _max_clients(max_clients) {
}
void add_http_config(http_config config) {
_http_config = config;
}
void add_https_config(https_config config) {
_https_config = config;
}
int worker_threads() {
return _worker_threads;
}
int max_clients() {
return _max_clients;
}
std::optional<http_config>& http_cfg() {
return _http_config;
}
std::optional<https_config>& https_cfg() {
return _https_config;
}
};
};

5
lib/log/log.cpp
View file

@ -1,5 +1,4 @@
#include "./log.hpp"
#include <syncstream>
namespace anthracite::log {
enum LOG_LEVEL Logger::_level = LOG_LEVEL_NONE;
@ -28,8 +27,8 @@ int LogBuf::sync()
if (this->_level <= logger._level) {
char thread_name[100];
pthread_getname_np(pthread_self(), thread_name, 100);
std::osyncstream(std::cout) << "[" << this->_tag << "] [" << syscall(SYS_gettid) << ":" << thread_name << "] "<< this->str();
std::cout.flush();
_output_stream << "[" << this->_tag << "] [" << syscall(SYS_gettid) << ":" << thread_name << "] " << this->str();
_output_stream.flush();
}
this->str("");
return 0;

1
lib/log/log.hpp
View file

@ -5,6 +5,7 @@
#include <sstream>
#include <inttypes.h>
#include <memory>
#include <string>
#include "../http/request.hpp"
#include "../http/response.hpp"

103
lib/socket/openssl_socket.cpp
View file

@ -6,6 +6,7 @@
#include <iostream>
#include <malloc.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <openssl/err.h>
#include <openssl/ssl.h>
#include <string>
@ -16,85 +17,101 @@
namespace anthracite::socket {
SSL_CTX* openssl_socket::_context = nullptr;
openssl_socket::openssl_socket(int port, int max_queue)
: anthracite_socket(port, max_queue)
openssl_listener::openssl_listener(std::string& key_path, std::string& cert_path, int port, int max_queue, bool nonblocking)
: listener(port, max_queue, nonblocking)
{
const SSL_METHOD* method = TLS_server_method();
if (_context == nullptr) {
_context = SSL_CTX_new(method);
}
_context = SSL_CTX_new(method);
if (!_context) {
log::err << "Unable to initialize SSL" << std::endl;
throw std::exception();
}
if (SSL_CTX_use_certificate_file(_context, "cert.pem", SSL_FILETYPE_PEM) <= 0) {
log::err << "Unable to open cert.pem" << std::endl;
if (SSL_CTX_use_certificate_file(_context, cert_path.c_str(), SSL_FILETYPE_PEM) <= 0) {
log::err << "Unable to open Cert file at: " << cert_path << std::endl;
throw std::exception();
}
if (SSL_CTX_use_PrivateKey_file(_context, "key.pem", SSL_FILETYPE_PEM) <= 0) {
log::err << "Unable to open key.pem" << std::endl;
if (SSL_CTX_use_PrivateKey_file(_context, key_path.c_str(), SSL_FILETYPE_PEM) <= 0) {
log::err << "Unable to open Key file at: " << key_path << std::endl;
throw std::exception();
}
}
openssl_socket::~openssl_socket() = default;
bool openssl_socket::wait_for_conn()
bool openssl_listener::wait_for_conn(server** client_sock_p)
{
client_ip = "";
struct timeval tv = { .tv_sec = 1, .tv_usec = 0 };
fd_set read_fd;
FD_ZERO(&read_fd);
FD_SET(server_socket, &read_fd);
if (select(server_socket + 1, &read_fd, NULL, NULL, &wait_timeout)) {
client_socket = accept(server_socket, reinterpret_cast<struct sockaddr*>(&client_addr), &client_addr_len);
std::array<char, INET_ADDRSTRLEN> ip_str { 0 };
inet_ntop(AF_INET, &client_addr.sin_addr, ip_str.data(), INET_ADDRSTRLEN);
client_ip = std::string(ip_str.data());
_ssl = SSL_new(_context);
SSL_set_fd(_ssl, client_socket);
if (SSL_accept(_ssl) <= 0) {
log::warn << "Unable to open SSL connection with client" << std::endl;
client_ip = "";
close(client_socket);
client_socket = -1;
struct sockaddr_in client_addr {};
socklen_t client_addr_len;
int csock = accept(_sock_fd, reinterpret_cast<struct sockaddr*>(&client_addr), &client_addr_len);
if (csock > 0) {
std::array<char, INET6_ADDRSTRLEN> ip_str { 0 };
if (inet_ntop(AF_INET, &client_addr.sin_addr, ip_str.data(), INET_ADDRSTRLEN) == NULL) {
if (inet_ntop(AF_INET6, &client_addr.sin_addr, ip_str.data(), INET6_ADDRSTRLEN) == NULL) {
log::warn << "Unable to decode client's IP address" << std::endl;
}
}
SSL* ssl = SSL_new(_context);
if (ssl == NULL) {
for (int i = 0; i < 5 && close(csock) != 0; ++i)
;
return false;
}
if (SSL_set_fd(ssl, csock) == 0) {
SSL_free(ssl);
for (int i = 0; i < 5 && close(csock) != 0; ++i)
;
return false;
}
if (SSL_accept(ssl) <= 0) {
log::warn << "Unable to open SSL connection with client" << std::endl;
SSL_free(ssl);
for (int i = 0; i < 5 && close(csock) != 0; ++i)
;
return false;
}
std::string client_ip = std::string(ip_str.data());
*client_sock_p = new openssl_server(csock, client_ip, _nonblocking, ssl);
return true;
} else {
return false;
}
}
void openssl_socket::close_conn()
openssl_listener::~openssl_listener() {}
openssl_server::openssl_server(int sock_fd, std::string client_ip, bool nonblocking, SSL* ssl)
: server(sock_fd, client_ip, nonblocking)
, _ssl(ssl)
{
}
openssl_server::~openssl_server()
{
SSL_shutdown(_ssl);
SSL_free(_ssl);
close(client_socket);
client_socket = -1;
}
void openssl_socket::send_message(std::string& msg)
void openssl_server::send_message(const std::string& msg)
{
if (client_socket == -1) {
return;
}
SSL_write(_ssl, &msg[0], msg.length());
}
std::string openssl_socket::recv_message(int buffer_size)
std::string openssl_server::recv_message(int buffer_size)
{
if (client_socket == -1) {
return "";
}
// Ignored because it's nonfatal, just slower
int nodelay_opt = 1;
(void)setsockopt(_sock_fd, SOL_TCP, TCP_NODELAY, &nodelay_opt, sizeof(nodelay_opt));
setsockopt(client_socket, SOL_SOCKET, SO_RCVTIMEO, &timeout_tv, sizeof timeout_tv);
std::vector<char> response(buffer_size + 1);
ssize_t result = SSL_read(_ssl, response.data(), buffer_size + 1);

23
lib/socket/openssl_socket.hpp
View file

@ -5,18 +5,25 @@
#include <openssl/err.h>
namespace anthracite::socket {
class openssl_socket : public anthracite_socket {
class openssl_server : public server{
private:
static SSL_CTX* _context;
SSL* _ssl;
public:
openssl_socket(int port, int max_queue = MAX_QUEUE_LENGTH);
~openssl_socket();
openssl_server(int sock_fd, std::string client_ip, bool nonblocking, SSL* ssl);
~openssl_server();
bool wait_for_conn() override;
void close_conn() override;
void send_message(std::string& msg) override;
void send_message(const std::string& msg) override;
std::string recv_message(int buffer_size) override;
};
class openssl_listener : public listener {
private:
SSL_CTX* _context;
public:
openssl_listener(std::string& key_path, std::string& cert_path, int port, int max_queue_length, bool nonblocking);
~openssl_listener();
bool wait_for_conn(server** client_sock_) override;
};
};

147
lib/socket/socket.cpp
View file

@ -1,98 +1,120 @@
#include "./socket.hpp"
#include "../log/log.hpp"
#include "assert.h"
#include <arpa/inet.h>
#include <array>
#include <exception>
#include <fcntl.h>
#include <iostream>
#include <malloc.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <string>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <unistd.h>
#include <vector>
#include <unistd.h>
#include <fcntl.h>
#include "assert.h"
#include <netinet/in.h>
#include <netinet/tcp.h>
namespace anthracite::socket {
const struct timeval anthracite_socket::timeout_tv = { .tv_sec = 5, .tv_usec = 0 };
anthracite_socket::anthracite_socket(int port, int max_queue, bool nonblocking)
: server_socket(::socket(AF_INET, SOCK_STREAM, 0))
, client_ip("")
, _nonblocking(nonblocking)
socket::socket(bool nonblocking)
: _nonblocking(nonblocking)
{
}
listener::listener(int port, int max_queue, bool nonblocking)
: socket(nonblocking)
, _port(port)
{
_sock_fd = ::socket(AF_INET, SOCK_STREAM, 0);
if (_sock_fd == -1) {
log::err << "Listener was unable to open a socket" << std::endl;
throw std::exception();
}
struct sockaddr_in address {};
address.sin_family = AF_INET;
address.sin_port = htons(port);
address.sin_port = htons(_port);
address.sin_addr.s_addr = INADDR_ANY;
int reuse_opt = 1;
setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR, &reuse_opt, sizeof(reuse_opt));
bind(server_socket, reinterpret_cast<struct sockaddr*>(&address), sizeof(address));
if (_nonblocking) {
fcntl(server_socket, F_SETFL, O_NONBLOCK);
if (setsockopt(_sock_fd, SOL_SOCKET, SO_REUSEADDR, &reuse_opt, sizeof(reuse_opt)) < 0) {
log::err << "Listener was unable to set SO_REUSEADDR" << std::endl;
throw std::exception();
}
listen(server_socket, max_queue);
if (bind(_sock_fd, reinterpret_cast<struct sockaddr*>(&address), sizeof(address)) != 0) {
log::err << "Listener was unable to bind to address" << std::endl;
throw std::exception();
}
if (fcntl(_sock_fd, F_SETFL, O_NONBLOCK) == -1) {
log::err << "Listener was unable to fcntl(O_NONBLOCK)" << std::endl;
throw std::exception();
}
if (listen(_sock_fd, max_queue) == -1) {
log::err << "Listener was unable to begin listening" << std::endl;
throw std::exception();
}
}
bool anthracite_socket::wait_for_conn()
bool listener::wait_for_conn(server** client_sock_p)
{
client_ip = "";
client_socket = accept(server_socket, reinterpret_cast<struct sockaddr*>(&client_addr), &client_addr_len);
if (client_socket > 0) {
if (_nonblocking) {
fcntl(client_socket, F_SETFL, O_NONBLOCK);
struct sockaddr_in client_addr {};
socklen_t client_addr_len;
int csock = accept(_sock_fd, reinterpret_cast<struct sockaddr*>(&client_addr), &client_addr_len);
if (csock > 0) {
std::array<char, INET6_ADDRSTRLEN> ip_str { 0 };
if (inet_ntop(AF_INET, &client_addr.sin_addr, ip_str.data(), INET_ADDRSTRLEN) == NULL) {
if (inet_ntop(AF_INET6, &client_addr.sin_addr, ip_str.data(), INET6_ADDRSTRLEN) == NULL) {
log::warn << "Unable to decode client's IP address" << std::endl;
}
}
std::array<char, INET_ADDRSTRLEN> ip_str { 0 };
inet_ntop(AF_INET, &client_addr.sin_addr, ip_str.data(), INET_ADDRSTRLEN);
client_ip = std::string(ip_str.data());
std::string client_ip = std::string(ip_str.data());
*client_sock_p = new server(csock, client_ip, _nonblocking);
return true;
} else {
return false;
}
}
const std::string& anthracite_socket::get_client_ip()
server::server(int sock_fd, std::string client_ip, bool nonblocking)
: _sock_fd(sock_fd)
, _client_ip(std::move(client_ip))
, socket(nonblocking)
{
return client_ip;
}
void anthracite_socket::close_conn() {
close(client_socket);
client_socket = -1;
}
void anthracite_socket::send_message(std::string& msg)
{
if (client_socket == -1) {
return;
if (_nonblocking) {
if (fcntl(_sock_fd, F_SETFL, O_NONBLOCK) == -1) {
log::err << "Server was unable to fcntl(O_NONBLOCK)" << std::endl;
throw std::exception();
}
}
send(client_socket, &msg[0], msg.length(), 0);
}
bool anthracite_socket::has_client() {
return client_socket > 0;
}
std::string anthracite_socket::recv_message(int buffer_size)
void server::send_message(const std::string& msg)
{
if (client_socket == -1) {
return "";
}
//setsockopt(client_socket, SOL_SOCKET, SO_RCVTIMEO, &timeout_tv, sizeof timeout_tv);
// Ignored because if we fail to send, it probably means
// a HUP will occur and it'll be closed. TODO: Just close
// it here and add a return value
(void)send(_sock_fd, &msg[0], msg.length(), 0);
}
std::string server::recv_message(int buffer_size)
{
// Ignored because it's nonfatal, just slower
int nodelay_opt = 1;
assert(setsockopt(client_socket, SOL_TCP, TCP_NODELAY, &nodelay_opt, sizeof(nodelay_opt)) == 0);
(void)setsockopt(_sock_fd, SOL_TCP, TCP_NODELAY, &nodelay_opt, sizeof(nodelay_opt));
std::vector<char> response(buffer_size + 1);
ssize_t result = recv(client_socket, response.data(), buffer_size + 1, 0);
ssize_t result = recv(_sock_fd, response.data(), buffer_size + 1, 0);
if (result < 1) {
return "";
@ -102,4 +124,21 @@ std::string anthracite_socket::recv_message(int buffer_size)
return { response.data() };
}
server::~server()
{
for (int i = 0; i < 5 && close(_sock_fd) != 0; ++i)
;
}
listener::~listener()
{
for (int i = 0; i < 5 && close(_sock_fd) != 0; ++i)
;
}
const std::string& server::client_ip()
{
return _client_ip;
}
};

50
lib/socket/socket.hpp
View file

@ -10,32 +10,42 @@
namespace anthracite::socket {
class socket {
protected:
bool _nonblocking;
socket(bool nonblocking);
public:
socket(){}
virtual ~socket(){}
};
class anthracite_socket {
class server : public socket {
protected:
int _sock_fd;
std::string _client_ip;
public:
server(int sock_fd, std::string client_ip, bool nonblocking);
~server();
protected:
bool _nonblocking;
struct timeval wait_timeout = { .tv_sec = 1, .tv_usec = 0};
int server_socket;
int client_socket {};
std::string client_ip;
struct sockaddr_in client_addr {};
socklen_t client_addr_len {};
static const struct timeval timeout_tv;
static const int MAX_QUEUE_LENGTH = 100;
virtual void send_message(const std::string& msg);
virtual std::string recv_message(int buffer_size);
const std::string& client_ip();
public:
anthracite_socket(int port, int max_queue = MAX_QUEUE_LENGTH, bool nonblocking = false);
int fd() { return _sock_fd; }
};
virtual const std::string& get_client_ip() final;
class listener : public socket {
protected:
uint16_t _port;
int _sock_fd;
public:
listener(int port, int max_queue_length, bool nonblocking);
~listener();
virtual bool has_client();
virtual bool wait_for_conn();
virtual void close_conn();
virtual void send_message(std::string& msg);
virtual std::string recv_message(int buffer_size);
virtual bool wait_for_conn(server** client_sock_p);
int csock() { return client_socket; }
int fd() { return _sock_fd; }
int port() { return _port; }
};
};

135
lib/thread_mgr/event_loop.cpp
View file

@ -1,14 +1,14 @@
#include "./event_loop.hpp"
#include "../log/log.hpp"
#include "../socket/openssl_socket.hpp"
#include "assert.h"
#include "signal.h"
#include "sys/epoll.h"
#include <chrono>
#include <mutex>
#include <pthread.h>
#include <sstream>
#include <syncstream>
#include "signal.h"
#include <thread>
using std::chrono::duration;
using std::chrono::duration_cast;
@ -16,29 +16,18 @@ using std::chrono::high_resolution_clock;
using std::chrono::milliseconds;
namespace anthracite::thread_mgr {
event_loop::event::event(socket::anthracite_socket* socket, std::chrono::time_point<std::chrono::high_resolution_clock> timestamp)
: _socket(socket)
, _ts(timestamp)
{
}
socket::anthracite_socket* event_loop::event::socket()
{
return _socket;
}
std::chrono::time_point<std::chrono::high_resolution_clock>& event_loop::event::timestamp()
{
return _ts;
}
event_loop::event_loop(backends::backend& backend, config::config& config)
: thread_mgr(backend, config)
event_loop::event_loop(std::vector<socket::listener*>& listen_sockets, backends::backend& backend, int max_threads, int max_clients)
: thread_mgr(backend)
, _error_backend("./www")
, _max_threads(max_threads)
, _listen_sockets(listen_sockets)
, _max_clients(max_clients)
, _nonblocking(false)
{
}
bool event_loop::event_handler(socket::anthracite_socket* sock)
bool event_loop::event_handler(socket::server* sock)
{
std::string raw_request = sock->recv_message(http::HEADER_BYTES);
@ -46,7 +35,7 @@ bool event_loop::event_handler(socket::anthracite_socket* sock)
return false;
}
http::request req(raw_request, sock->get_client_ip());
http::request req(raw_request, sock->client_ip());
std::unique_ptr<http::response> resp = req.is_supported_version() ? _backend.handle_request(req) : _error_backend.handle_error(http::status_codes::HTTP_VERSION_NOT_SUPPORTED);
std::string header = resp->header_to_string();
sock->send_message(header);
@ -65,107 +54,81 @@ void event_loop::worker_thread_loop(int threadno)
ss << "worker " << threadno;
pthread_setname_np(pthread_self(), ss.str().c_str());
struct epoll_event* events = new struct epoll_event[_config.max_clients()];
struct epoll_event* events = new struct epoll_event[_max_clients];
int timeout_ms = 1000;
if (_nonblocking) {
timeout_ms = 0;
}
log::info << "Starting worker thread " << threadno << std::endl;
std::osyncstream(log::info) << "Starting worker thread " << threadno << std::endl;
int epoll_fd = epoll_create(1);
for (socket::listener* sl : _listen_sockets) {
struct epoll_event event;
event.events = EPOLLIN | EPOLLEXCLUSIVE;
event.data.ptr = sl;
epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sl->fd(), &event);
if (threadno == 0) {
std::osyncstream(log::info) << "Listening started on port " << sl->port() << std::endl;
}
}
while (_run) {
int ready_fds = epoll_wait(_epoll_fd, events, _config.max_clients(), timeout_ms);
int ready_fds = epoll_wait(epoll_fd, events, _max_clients, timeout_ms);
if (ready_fds > 0) {
for (int i = 0; i < ready_fds; i++) {
socket::anthracite_socket* sockptr = reinterpret_cast<socket::anthracite_socket*>(events[i].data.ptr);
socket::socket* sockptr = reinterpret_cast<socket::socket*>(events[i].data.ptr);
socket::server* server_ptr = dynamic_cast<socket::server*>(sockptr);
if (!event_handler(sockptr)) {
epoll_ctl(_epoll_fd, EPOLL_CTL_DEL, sockptr->csock(), &events[i]);
sockptr->close_conn();
delete sockptr;
if (server_ptr != nullptr) {
if (!event_handler(server_ptr)) {
delete server_ptr;
}
} else {
socket::listener* listen_ptr = dynamic_cast<socket::listener*>(sockptr);
if (listen_ptr != nullptr) {
socket::server* server_sock;
while (listen_ptr->wait_for_conn(&server_sock)) {
struct epoll_event event;
event.events = EPOLLIN | EPOLLEXCLUSIVE;
event.data.ptr = server_sock;
epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_sock->fd(), &event);
}
} else {
std::osyncstream(log::err) << "Had socket type that wasn't listener or server" << std::endl;
}
}
}
}
}
log::info << "Stopping worker thread " << threadno << std::endl;
}
delete[] events;
void event_loop::listener_thread_loop(config::http_config& http_config)
{
socket::anthracite_socket* socket;
config::http_config* http_ptr = &http_config;
config::https_config* https_ptr = dynamic_cast<config::https_config*>(http_ptr);
bool is_tls = https_ptr != nullptr;
if (is_tls) {
socket = new socket::openssl_socket(https_ptr->port());
} else {
socket = new socket::anthracite_socket(http_ptr->port());
}
std::osyncstream(log::info) << "Listening for " << (is_tls ? "HTTPS" : "HTTP") << " connections on port " << http_ptr->port() << std::endl;
while (_run) {
if (socket->wait_for_conn()) {
socket::anthracite_socket* client_sock;
if (is_tls) {
socket::openssl_socket* ssl_sock = dynamic_cast<socket::openssl_socket*>(socket);
client_sock = new socket::openssl_socket(*ssl_sock);
} else {
client_sock = new socket::anthracite_socket(*socket);
}
struct epoll_event event;
event.events = EPOLLIN | EPOLLEXCLUSIVE;// | EPOLLET;
event.data.ptr = client_sock;
epoll_ctl(_epoll_fd, EPOLL_CTL_ADD, client_sock->csock(), &event);
}
}
std::osyncstream(log::info) << "Stopping listening for " << (is_tls ? "HTTPS" : "HTTP") << " connections on port " << http_ptr->port() << std::endl;
delete socket;
std::osyncstream(log::info) << "Stopping worker thread " << threadno << std::endl;
}
void event_loop::start()
{
std::lock_guard<std::mutex> lg(_run_lock);
signal(SIGPIPE, SIG_IGN);
log::info << "Starting event_loop Thread Manager" << std::endl;
_run = true;
_epoll_fd = epoll_create(1);
std::vector<std::thread> listener_threads;
std::vector<std::thread> worker_threads;
for (int i = 0; i < _config.worker_threads(); i++) {
for (int i = 0; i < _max_threads; i++) {
auto thread = std::thread(&event_loop::worker_thread_loop, this, i);
worker_threads.push_back(std::move(thread));
}
if (_config.http_cfg().has_value()) {
auto thread = std::thread(&event_loop::listener_thread_loop, this, std::ref(_config.http_cfg().value()));
listener_threads.push_back(std::move(thread));
}
if (_config.https_cfg().has_value()) {
auto thread = std::thread(&event_loop::listener_thread_loop, this, std::ref(_config.https_cfg().value()));
listener_threads.push_back(std::move(thread));
}
for (std::thread& t : worker_threads) {
t.join();
}
for (std::thread& t : listener_threads) {
t.join();
}
}
void event_loop::stop()

25
lib/thread_mgr/event_loop.hpp
View file

@ -1,34 +1,25 @@
#include "./thread_mgr.hpp"
#include "../socket/socket.hpp"
#include "../backends/file_backend.hpp"
#include <chrono>
#include <condition_variable>
#include <mutex>
#include <queue>
#include <vector>
#include "../socket/socket.hpp"
namespace anthracite::thread_mgr {
class event_loop : public virtual thread_mgr {
class event {
socket::anthracite_socket* _socket;
std::chrono::time_point<std::chrono::high_resolution_clock> _ts;
public:
event(socket::anthracite_socket* socket, std::chrono::time_point<std::chrono::high_resolution_clock> timestamp);
socket::anthracite_socket* socket();
std::chrono::time_point<std::chrono::high_resolution_clock>& timestamp();
};
int _epoll_fd;
std::mutex _event_mtx;
backends::file_backend _error_backend;
std::vector<socket::listener*>& _listen_sockets;
bool _nonblocking;
std::mutex _run_lock;
int _max_threads;
int _max_clients;
void worker_thread_loop(int threadno);
void listener_thread_loop(config::http_config& http_config);
void eventer_thread_loop();
bool event_handler(socket::anthracite_socket*);
bool event_handler(socket::server*);
public:
event_loop(backends::backend& backend, config::config& config);
event_loop(std::vector<socket::listener*>&, backends::backend& backend, int max_workers, int max_clients);
void start() override;
void stop() override;
};

4
lib/thread_mgr/thread_mgr.hpp
View file

@ -1,16 +1,14 @@
#pragma once
#include "../backends/backend.hpp"
#include "../config/config.hpp"
namespace anthracite::thread_mgr {
class thread_mgr {
protected:
bool _run;
backends::backend& _backend;
config::config& _config;
public:
thread_mgr(backends::backend& backend, config::config& config): _backend(backend), _config(config) {}
thread_mgr(backends::backend& backend): _backend(backend) {}
virtual ~thread_mgr() = default;
virtual void start() = 0;
virtual void stop() = 0;