From a569eeb4a286584b7ce9039cdeb4d298f6fc1b11 Mon Sep 17 00:00:00 2001 From: Janitha Karunaratne Date: Wed, 5 Mar 2014 22:42:55 -0800 Subject: [PATCH] Added stats based classes and intergrated them with the factory and workers --- Makefile | 4 +- common.h | 2 +- events.cc | 12 ---- events.h | 26 -------- stats.cc | 90 +++++++++++++++++++++++++++ stats.h | 120 ++++++++++++++++++++++++++++++++++++ tcp_factory.cc | 50 ++++++++------- tcp_factory.h | 23 ++++--- tcp_worker.cc | 164 +++++++++++++++++++++++++++++++------------------ tcp_worker.h | 74 +++++++++++++++------- 10 files changed, 413 insertions(+), 152 deletions(-) delete mode 100644 events.cc delete mode 100644 events.h create mode 100644 stats.cc create mode 100644 stats.h diff --git a/Makefile b/Makefile index 4ef9384..70cd8eb 100644 --- a/Makefile +++ b/Makefile @@ -1,8 +1,8 @@ CC=g++ CFLAGS=-Wall -Wunused -Wextra -g3 -std=c++0x -pedantic LDFLAGS= -LIBS=-lev -lrt -SOURCES=main.cc common.cc flamethrower.cc params.cc events.cc tcp_factory.cc tcp_worker.cc payload.cc http_worker.cc +LIBS=-lev -lrt -lmsgpack +SOURCES=main.cc common.cc flamethrower.cc params.cc stats.cc tcp_factory.cc tcp_worker.cc payload.cc http_worker.cc OBJECTS=$(SOURCES:.cc=.o) EXECUTABLE=flamethrower diff --git a/common.h b/common.h index 8dd6b0a..36b374d 100644 --- a/common.h +++ b/common.h @@ -23,7 +23,7 @@ #include #include "params.h" -#include "events.h" +#include "stats.h" #define DEBUG 1 diff --git a/events.cc b/events.cc deleted file mode 100644 index 28a231b..0000000 --- a/events.cc +++ /dev/null @@ -1,12 +0,0 @@ -#include "events.h" - -#define NS_PER_S 1000000000 - -uint64_t timestamp_ns_now() { - uint64_t nsec; - timespec tspec; - clock_gettime(CLOCK_REALTIME, &tspec); - nsec = tspec.tv_sec * NS_PER_S + tspec.tv_nsec; - return nsec; -} - diff --git a/events.h b/events.h deleted file mode 100644 index ae896e0..0000000 --- a/events.h +++ /dev/null @@ -1,26 +0,0 @@ -#ifndef EVENTS_H -#define EVENTS_H - -#include -#include - -uint64_t timestamp_ns_now(); - -class Event { -public: - Event() {} - virtual ~Event() {} -}; - -class TcpClientEvent : public Event { -public: - uint64_t established_time; - - TcpClientEvent() : Event() {} - virtual ~TcpClientEvent() {} -}; - - - - -#endif diff --git a/stats.cc b/stats.cc new file mode 100644 index 0000000..7edb29e --- /dev/null +++ b/stats.cc @@ -0,0 +1,90 @@ +#include "stats.h" + +//////////////////////////////////////////////////////////////////////////////// +#define NS_PER_S 1000000000 + +uint64_t timestamp_ns_now() { + uint64_t nsec; + timespec tspec; + clock_gettime(CLOCK_REALTIME, &tspec); + nsec = tspec.tv_sec * NS_PER_S + tspec.tv_nsec; + return nsec; +} + +//////////////////////////////////////////////////////////////////////////////// +StatsList::StatsList() { +} + +StatsList::~StatsList() { +} + +void StatsList::push(Stats *stats) { + +} + +//////////////////////////////////////////////////////////////////////////////// +Stats::Stats() { + +} + +Stats::~Stats() { + +} + +void Stats::print() { + +} + +//////////////////////////////////////////////////////////////////////////////// +TcpFactoryStats::TcpFactoryStats() + : Stats() { +} + +TcpFactoryStats::~TcpFactoryStats() { +} + +void TcpFactoryStats::print() { + +} + +//////////////////////////////////////////////////////////////////////////////// +TcpWorkerStats::TcpWorkerStats() + : Stats() { + +} + +TcpWorkerStats::~TcpWorkerStats() { + +} + +void TcpWorkerStats::print() { + +} + +//////////////////////////////////////////////////////////////////////////////// +TcpServerWorkerStats::TcpServerWorkerStats() + : TcpWorkerStats() { + +} + +TcpServerWorkerStats::~TcpServerWorkerStats() { + +} + +void TcpServerWorkerStats::print() { + +} + +//////////////////////////////////////////////////////////////////////////////// +TcpClientWorkerStats::TcpClientWorkerStats() + : TcpWorkerStats() { + +} + +TcpClientWorkerStats::~TcpClientWorkerStats() { + +} + +void TcpClientWorkerStats::print() { + +} diff --git a/stats.h b/stats.h new file mode 100644 index 0000000..2f57055 --- /dev/null +++ b/stats.h @@ -0,0 +1,120 @@ +#ifndef STATS_H +#define STATS_H + +#include +#include +#include + +#include + +uint64_t timestamp_ns_now(); + +class Stats; + +//////////////////////////////////////////////////////////////////////////////// +class StatsList { +private: + std::list stats; +public: + StatsList(); + virtual ~StatsList(); + + void push(Stats *stats); +}; + +//////////////////////////////////////////////////////////////////////////////// +class Stats { +public: + Stats(); + virtual ~Stats(); + + virtual void print(); +}; + + +//////////////////////////////////////////////////////////////////////////////// +class FactoryStats : public Stats { +}; + +class TcpFactoryStats : public FactoryStats { +public: + uint64_t bytes_in; + uint64_t bytes_out; + uint64_t cumulative_count; + + TcpFactoryStats(); + virtual ~TcpFactoryStats(); + + virtual void print(); +}; + +class TcpServerFactoryStats : public TcpFactoryStats { +}; + +class TcpClientFactoryStats : public TcpFactoryStats { +}; + + +//////////////////////////////////////////////////////////////////////////////// +class TcpWorkerStats : public Stats { +public: + + uint64_t readable_time; + uint64_t writable_time; + uint64_t close_time; + + uint64_t bytes_in; + uint64_t bytes_out; + + TcpWorkerStats(); + virtual ~TcpWorkerStats(); + + virtual void print(); +}; + +//////////////////////////////////////////////////////////////////////////////// +class TcpServerWorkerStats : public TcpWorkerStats { +public: + + uint64_t established_time; + + TcpServerWorkerStats(); + virtual ~TcpServerWorkerStats(); + + virtual void print(); +}; + +//////////////////////////////////////////////////////////////////////////////// +class TcpClientWorkerStats : public TcpWorkerStats { +public: + + uint64_t connect_time; + uint64_t established_time; + + TcpClientWorkerStats(); + virtual ~TcpClientWorkerStats(); + + virtual void print(); +}; + +//////////////////////////////////////////////////////////////////////////////// +class TcpServerEchoStats : public TcpServerWorkerStats { +}; + +class TcpClientEchoStats : public TcpClientWorkerStats { +}; + +class TcpServerRawStats : public TcpServerWorkerStats { +}; + +class TcpClientRawStats : public TcpClientWorkerStats { +}; + +class TcpServerHttpStats : public TcpServerWorkerStats { +}; + +class TcpClientHttpStats : public TcpClientWorkerStats { +}; + + +#endif diff --git a/tcp_factory.cc b/tcp_factory.cc index 4d60b5d..0fce997 100644 --- a/tcp_factory.cc +++ b/tcp_factory.cc @@ -5,8 +5,8 @@ Factory::Factory(struct ev_loop *loop, FactoryParams ¶ms) : loop(loop), - params(params) { - + params(params), + statslist() { } Factory::~Factory() { @@ -16,10 +16,14 @@ Factory* Factory::maker(struct ev_loop *loop, FactoryParams ¶ms) { switch(params.type) { case FactoryParams::FactoryType::TCP_SERVER: - return new TcpServerFactory(loop, (TcpServerFactoryParams&)params); + return new TcpServerFactory(loop, + (TcpServerFactoryParams&)params, + *new TcpServerFactoryStats()); break; case FactoryParams::FactoryType::TCP_CLIENT: - return new TcpClientFactory(loop, (TcpClientFactoryParams&)params); + return new TcpClientFactory(loop, + (TcpClientFactoryParams&)params, + *new TcpClientFactoryStats()); break; default: perror("error: invalid factory type\n"); @@ -30,13 +34,11 @@ Factory* Factory::maker(struct ev_loop *loop, FactoryParams ¶ms) { //////////////////////////////////////////////////////////////////////////////// TcpFactory::TcpFactory(struct ev_loop *loop, - TcpFactoryParams ¶ms) + TcpFactoryParams ¶ms, + TcpFactoryStats &stats) : Factory(loop, params), params(params), - bytes_in(0), - bytes_out(0), - cumulative_count(0) -{ + stats(stats) { debug_print("ctor\n"); @@ -64,6 +66,7 @@ TcpFactory::~TcpFactory() { workers.pop_front(); } + delete &stats; } void TcpFactory::factory_cb(struct ev_loop *loop, @@ -97,28 +100,31 @@ void TcpFactory::stats_cb() { "bytes_out=%lu " "count=%lu " "workers=%lu\n", - bytes_in, - bytes_out, - cumulative_count, + stats.bytes_in, + stats.bytes_out, + stats.cumulative_count, workers.size()); } void TcpFactory::worker_new_cb(TcpWorker &worker) { workers.push_back(&worker); worker.workers_list_pos = --workers.end(); - cumulative_count++; + stats.cumulative_count++; } void TcpFactory::worker_delete_cb(TcpWorker &worker) { workers.erase(worker.workers_list_pos); + statslist.push(&worker.stats); ev_async_send(loop, &factory_async); } //////////////////////////////////////////////////////////////////////////////// TcpServerFactory::TcpServerFactory(struct ev_loop *loop, - TcpServerFactoryParams ¶ms) - : TcpFactory(loop, params), - params(params) { + TcpServerFactoryParams ¶ms, + TcpServerFactoryStats &stats) + : TcpFactory(loop, params, stats), + params(params), + stats(stats) { debug_print("ctor\n"); @@ -187,7 +193,7 @@ void TcpServerFactory::accept_cb(struct ev_loop *loop, void TcpServerFactory::accept_cb() { // TODO(Janitha): Maybe this is better done in the worker_new_cb? - if(cumulative_count >= params.count) { + if(stats.cumulative_count >= params.count) { debug_print("cumulative count reached\n"); ev_io_stop(loop, &accept_watcher); ev_async_stop(loop, &factory_async); @@ -228,9 +234,11 @@ void TcpServerFactory::factory_cb() { //////////////////////////////////////////////////////////////////////////////// TcpClientFactory::TcpClientFactory(struct ev_loop *loop, - TcpClientFactoryParams ¶ms) - : TcpFactory(loop, params), - params(params) { + TcpClientFactoryParams ¶ms, + TcpClientFactoryStats &stats) + : TcpFactory(loop, params, stats), + params(params), + stats(stats) { debug_print("ctor\n"); @@ -245,7 +253,7 @@ void TcpClientFactory::factory_cb() { debug_print("called\n"); // TODO(Janitha): Maybe this is better done in the worker_new_cb? - if(cumulative_count >= params.count) { + if(stats.cumulative_count >= params.count) { debug_print("cumulative count reached\n"); ev_async_stop(loop, &factory_async); return; diff --git a/tcp_factory.h b/tcp_factory.h index 3d81633..dfb5927 100644 --- a/tcp_factory.h +++ b/tcp_factory.h @@ -18,6 +18,8 @@ class Factory { struct ev_loop *loop; FactoryParams ¶ms; + StatsList statslist; + Factory(struct ev_loop *loop, FactoryParams ¶ms); virtual ~Factory(); @@ -32,15 +34,14 @@ class TcpFactory : public Factory { struct ev_timer stats_timer; public: TcpFactoryParams ¶ms; + TcpFactoryStats &stats; + struct ev_async factory_async; std::list workers; - // Stats - uint64_t bytes_in; - uint64_t bytes_out; - uint64_t cumulative_count; - - TcpFactory(struct ev_loop *loop, TcpFactoryParams ¶ms); + TcpFactory(struct ev_loop *loop, + TcpFactoryParams ¶ms, + TcpFactoryStats &stats); virtual ~TcpFactory(); virtual void worker_new_cb(TcpWorker &worker); @@ -62,8 +63,11 @@ class TcpServerFactory : public TcpFactory { struct ev_io accept_watcher; public: TcpServerFactoryParams ¶ms; + TcpServerFactoryStats &stats; - TcpServerFactory(struct ev_loop *loop, TcpServerFactoryParams ¶ms); + TcpServerFactory(struct ev_loop *loop, + TcpServerFactoryParams ¶ms, + TcpServerFactoryStats &stats); virtual ~TcpServerFactory(); virtual void start_listening(); @@ -80,8 +84,11 @@ class TcpClientFactory : public TcpFactory { private: public: TcpClientFactoryParams ¶ms; + TcpClientFactoryStats &stats; - TcpClientFactory(struct ev_loop *loop, TcpClientFactoryParams ¶ms); + TcpClientFactory(struct ev_loop *loop, + TcpClientFactoryParams ¶ms, + TcpClientFactoryStats &stats); virtual ~TcpClientFactory(); virtual void create_connection(); diff --git a/tcp_worker.cc b/tcp_worker.cc index 86f726b..c7fe6e6 100644 --- a/tcp_worker.cc +++ b/tcp_worker.cc @@ -1,13 +1,14 @@ #include "tcp_worker.h" //////////////////////////////////////////////////////////////////////////////// -TcpWorker::TcpWorker(TcpFactory &factory, TcpWorkerParams ¶ms, int sock) +TcpWorker::TcpWorker(TcpFactory &factory, + TcpWorkerParams ¶ms, + TcpWorkerStats &stats, + int sock) : factory(factory), params(params), - sock(sock), - readable_time(0), - writable_time(0), - close_time(0) { + stats(stats), + sock(sock) { debug_socket_print(sock, "ctor\n"); @@ -30,8 +31,8 @@ TcpWorker::~TcpWorker() { perror("socket close error"); } - if(!close_time) { - close_time = timestamp_ns_now(); + if(!stats.close_time) { + stats.close_time = timestamp_ns_now(); } factory.worker_delete_cb(*this); @@ -132,8 +133,9 @@ TcpWorker::SockAct TcpWorker::recv_buf(char *buf, size_t buflen, size_t &recvlen recvlen = ret; - // Update factory stats - factory.bytes_in += ret; + // Update stats + stats.bytes_in += ret; + factory.stats.bytes_in += ret; return SockAct::CONTINUE; } @@ -163,8 +165,9 @@ TcpWorker::SockAct TcpWorker::send_buf(char *buf, size_t buflen, size_t &sentlen sentlen = ret; - // Update factory stats - factory.bytes_out += ret; + // Update stats + stats.bytes_out += ret; + factory.stats.bytes_out += ret; return SockAct::CONTINUE; } @@ -186,8 +189,8 @@ void TcpWorker::read_cb(struct ev_loop *loop, struct ev_io *watcher, int revents TcpWorker *worker = (TcpWorker*)watcher->data; // Timestamp - if(!worker->readable_time) { - worker->readable_time = timestamp_ns_now(); + if(!worker->stats.readable_time) { + worker->stats.readable_time = timestamp_ns_now(); } worker->read_cb(); @@ -228,8 +231,8 @@ void TcpWorker::write_cb(struct ev_loop *loop, struct ev_io *watcher, int revent TcpWorker *worker = (TcpWorker*)watcher->data; // Timestamp - if(!worker->writable_time) { - worker->writable_time = timestamp_ns_now(); + if(!worker->stats.writable_time) { + worker->stats.writable_time = timestamp_ns_now(); } worker->write_cb(); @@ -322,10 +325,13 @@ TcpWorker::SockAct TcpWorker::write_payloads(PayloadList &payloads, size_t sendl } //////////////////////////////////////////////////////////////////////////////// -TcpServerWorker::TcpServerWorker(TcpServerFactory &factory, TcpServerWorkerParams ¶ms, int sock) - : TcpWorker(factory, params, sock), +TcpServerWorker::TcpServerWorker(TcpServerFactory &factory, + TcpServerWorkerParams ¶ms, + TcpServerWorkerStats &stats, + int sock) + : TcpWorker(factory, params, stats, sock), params(params), - established_time(0) { + stats(stats) { debug_socket_print(sock, "ctor\n"); @@ -352,14 +358,14 @@ TcpServerWorker::TcpServerWorker(TcpServerFactory &factory, TcpServerWorkerParam ev_io_start(factory.loop, &sock_w_ev); // Accept timestamp - established_time = timestamp_ns_now(); + stats.established_time = timestamp_ns_now(); } TcpServerWorker::~TcpServerWorker() { debug_socket_print(sock, "dtor\n"); - if(!close_time) { - close_time = timestamp_ns_now(); + if(!stats.close_time) { + stats.close_time = timestamp_ns_now(); } debug_print("latency: " @@ -367,9 +373,9 @@ TcpServerWorker::~TcpServerWorker() { "writable=%luns " "close=%luns " "\n", - readable_time - established_time, - writable_time - established_time, - close_time - established_time); + stats.readable_time - stats.established_time, + stats.writable_time - stats.established_time, + stats.close_time - stats.established_time); } @@ -377,17 +383,28 @@ void TcpServerWorker::finish() { return TcpWorker::finish(); } -TcpServerWorker* TcpServerWorker::maker(TcpServerFactory &factory, TcpServerWorkerParams ¶ms, int sock) { +TcpServerWorker* TcpServerWorker::maker(TcpServerFactory &factory, + TcpServerWorkerParams ¶ms, + int sock) { switch(params.type) { case TcpServerWorkerParams::WorkerType::ECHO: - return new TcpServerEcho(factory, (TcpServerEchoParams&)params, sock); + return new TcpServerEcho(factory, + (TcpServerEchoParams&)params, + *new TcpServerEchoStats(), + sock); break; case TcpServerWorkerParams::WorkerType::RAW: - return new TcpServerRaw(factory, (TcpServerRawParams&)params, sock); + return new TcpServerRaw(factory, + (TcpServerRawParams&)params, + *new TcpServerRawStats(), + sock); break; case TcpServerWorkerParams::WorkerType::HTTP: - return new TcpServerHttp(factory, (TcpServerHttpParams&)params, sock); + return new TcpServerHttp(factory, + (TcpServerHttpParams&)params, + *new TcpServerHttpStats(), + sock); break; default: perror("error: invalid worker type\n"); @@ -398,11 +415,12 @@ TcpServerWorker* TcpServerWorker::maker(TcpServerFactory &factory, TcpServerWork } //////////////////////////////////////////////////////////////////////////////// -TcpClientWorker::TcpClientWorker(TcpClientFactory &factory, TcpClientWorkerParams ¶ms) - : TcpWorker(factory, params), +TcpClientWorker::TcpClientWorker(TcpClientFactory &factory, + TcpClientWorkerParams ¶ms, + TcpClientWorkerStats &stats) + : TcpWorker(factory, params, stats), params(params), - connect_time(0), - established_time(0) { + stats(stats) { debug_print("ctor\n"); @@ -473,7 +491,7 @@ TcpClientWorker::TcpClientWorker(TcpClientFactory &factory, TcpClientWorkerParam ev_timer_start(factory.loop, &sock_timeout); // Connect timestamp - connect_time = timestamp_ns_now(); + stats.connect_time = timestamp_ns_now(); } @@ -481,8 +499,8 @@ TcpClientWorker::~TcpClientWorker() { debug_socket_print(sock, "dtor\n"); ev_timer_stop(factory.loop, &sock_timeout); - if(!close_time) { - close_time = timestamp_ns_now(); + if(!stats.close_time) { + stats.close_time = timestamp_ns_now(); } debug_print("latency: " @@ -491,10 +509,10 @@ TcpClientWorker::~TcpClientWorker() { "writable=%luns " "close=%luns " "\n", - established_time - connect_time, - readable_time - established_time, - writable_time - established_time, - close_time - established_time); + stats.established_time - stats.connect_time, + stats.readable_time - stats.established_time, + stats.writable_time - stats.established_time, + stats.close_time - stats.established_time); } @@ -503,17 +521,24 @@ void TcpClientWorker::finish() { return TcpWorker::finish(); } -TcpClientWorker* TcpClientWorker::maker(TcpClientFactory &factory, TcpClientWorkerParams ¶ms) { +TcpClientWorker* TcpClientWorker::maker(TcpClientFactory &factory, + TcpClientWorkerParams ¶ms) { switch(params.type) { case TcpClientWorkerParams::WorkerType::ECHO: - return new TcpClientEcho(factory, (TcpClientEchoParams&)params); + return new TcpClientEcho(factory, + (TcpClientEchoParams&)params, + *new TcpClientEchoStats()); break; case TcpClientWorkerParams::WorkerType::RAW: - return new TcpClientRaw(factory, (TcpClientRawParams&)params); + return new TcpClientRaw(factory, + (TcpClientRawParams&)params, + *new TcpClientRawStats()); break; case TcpClientWorkerParams::WorkerType::HTTP: - return new TcpClientHttp(factory, (TcpClientHttpParams&)params); + return new TcpClientHttp(factory, + (TcpClientHttpParams&)params, + *new TcpClientHttpStats()); break; default: perror("error: invalid worker type\n"); @@ -531,8 +556,8 @@ void TcpClientWorker::connected_cb(struct ev_loop *loop, struct ev_io *watcher, TcpClientWorker *worker = (TcpClientWorker*)watcher->data; - if(!worker->established_time) { - worker->established_time = timestamp_ns_now(); + if(!worker->stats.established_time) { + worker->stats.established_time = timestamp_ns_now(); } worker->connected_cb(); @@ -590,9 +615,13 @@ void TcpClientWorker::timeout_cb() { //////////////////////////////////////////////////////////////////////////////// -TcpServerEcho::TcpServerEcho(TcpServerFactory &factory, TcpServerEchoParams ¶ms, int sock) - : TcpServerWorker(factory, params, sock), - params(params) { +TcpServerEcho::TcpServerEcho(TcpServerFactory &factory, + TcpServerEchoParams ¶ms, + TcpServerEchoStats &stats, + int sock) + : TcpServerWorker(factory, params, stats, sock), + params(params), + stats(stats) { debug_socket_print(sock, "ctor\n"); } @@ -622,9 +651,12 @@ void TcpServerEcho::read_cb() { } //////////////////////////////////////////////////////////////////////////////// -TcpClientEcho::TcpClientEcho(TcpClientFactory &factory, TcpClientEchoParams ¶ms) - : TcpClientWorker(factory, params), - params(params) { +TcpClientEcho::TcpClientEcho(TcpClientFactory &factory, + TcpClientEchoParams ¶ms, + TcpClientEchoStats &stats) + : TcpClientWorker(factory, params, stats), + params(params), + stats(stats) { debug_print("ctor\n"); } @@ -654,9 +686,13 @@ void TcpClientEcho::read_cb() { } //////////////////////////////////////////////////////////////////////////////// -TcpServerRaw::TcpServerRaw(TcpServerFactory &factory, TcpServerRawParams ¶ms, int sock) - : TcpServerWorker(factory, params, sock), +TcpServerRaw::TcpServerRaw(TcpServerFactory &factory, + TcpServerRawParams ¶ms, + TcpServerRawStats &stats, + int sock) + : TcpServerWorker(factory, params, stats, sock), params(params), + stats(stats), payloads(*this, params.payloads) { debug_socket_print(sock, "ctor\n"); } @@ -688,9 +724,12 @@ void TcpServerRaw::write_cb() { } //////////////////////////////////////////////////////////////////////////////// -TcpClientRaw::TcpClientRaw(TcpClientFactory &factory, TcpClientRawParams ¶ms) - : TcpClientWorker(factory, params), +TcpClientRaw::TcpClientRaw(TcpClientFactory &factory, + TcpClientRawParams ¶ms, + TcpClientRawStats &stats) + : TcpClientWorker(factory, params, stats), params(params), + stats(stats), payloads(*this, params.payloads) { debug_print("ctor\n"); @@ -722,9 +761,13 @@ void TcpClientRaw::write_cb() { } //////////////////////////////////////////////////////////////////////////////// -TcpServerHttp::TcpServerHttp(TcpServerFactory &factory, TcpServerHttpParams ¶ms, int sock) - : TcpServerWorker(factory, params, sock), +TcpServerHttp::TcpServerHttp(TcpServerFactory &factory, + TcpServerHttpParams ¶ms, + TcpServerHttpStats &stats, + int sock) + : TcpServerWorker(factory, params, stats, sock), params(params), + stats(stats), state(ServerState::START), firstline_payloads(*this, params.firstline_payloads), header_payloads(*this, params.header_payloads), @@ -989,9 +1032,12 @@ void TcpServerHttp::write_cb() { } //////////////////////////////////////////////////////////////////////////////// -TcpClientHttp::TcpClientHttp(TcpClientFactory &factory, TcpClientHttpParams ¶ms) - : TcpClientWorker(factory, params), +TcpClientHttp::TcpClientHttp(TcpClientFactory &factory, + TcpClientHttpParams ¶ms, + TcpClientHttpStats &stats) + : TcpClientWorker(factory, params, stats), params(params), + stats(stats), state(ClientState::REQUEST_FIRSTLINE), firstline_payloads(*this, params.firstline_payloads), header_payloads(*this, params.header_payloads), diff --git a/tcp_worker.h b/tcp_worker.h index bfe5eb9..5d90bf1 100644 --- a/tcp_worker.h +++ b/tcp_worker.h @@ -24,6 +24,7 @@ class TcpWorker { TcpFactory &factory; TcpWorkerParams ¶ms; + TcpWorkerStats &stats; int sock; @@ -40,13 +41,15 @@ class TcpWorker { ERROR }; - uint64_t readable_time; - uint64_t writable_time; - uint64_t close_time; - - TcpWorker(TcpFactory &factory, TcpWorkerParams ¶ms, int sock=-1); + TcpWorker(TcpFactory &factory, + TcpWorkerParams ¶ms, + TcpWorkerStats &stats, + int sock=-1); virtual ~TcpWorker(); + // Worker actions + virtual void finish(); + // Socket abstractions SockAct recv_buf(char *buf, size_t buflen, size_t &recvlen); SockAct send_buf(char *buf, size_t buflen, size_t &sentlen); @@ -63,9 +66,6 @@ class TcpWorker { static void close_wait_cb(struct ev_loop *loop, struct ev_io *watcher, int revents); virtual void close_wait_cb(); - // Worker actions - virtual void finish(); - // Misc abstractions SockAct read_echo(); SockAct write_payloads(PayloadList &payloads, size_t sendlen, size_t &sentlen); @@ -78,14 +78,18 @@ class TcpWorker { class TcpServerWorker : public TcpWorker { private: TcpServerWorkerParams ¶ms; + TcpServerWorkerStats &stats; public: - uint64_t established_time; - - TcpServerWorker(TcpServerFactory &factory, TcpServerWorkerParams ¶ms, int sock); + TcpServerWorker(TcpServerFactory &factory, + TcpServerWorkerParams ¶ms, + TcpServerWorkerStats &stats, + int sock); virtual ~TcpServerWorker(); - static TcpServerWorker* maker(TcpServerFactory &factory, TcpServerWorkerParams ¶ms, int sock); + static TcpServerWorker* maker(TcpServerFactory &factory, + TcpServerWorkerParams ¶ms, + int sock); virtual void finish(); }; @@ -97,16 +101,19 @@ class TcpServerWorker : public TcpWorker { class TcpClientWorker : public TcpWorker { private: TcpClientWorkerParams ¶ms; + TcpClientWorkerStats &stats; + struct ev_timer sock_timeout; -public: - uint64_t connect_time; - uint64_t established_time; +public: - TcpClientWorker(TcpClientFactory &factory, TcpClientWorkerParams ¶ms); + TcpClientWorker(TcpClientFactory &factory, + TcpClientWorkerParams ¶ms, + TcpClientWorkerStats &stats); virtual ~TcpClientWorker(); - static TcpClientWorker* maker(TcpClientFactory &factory, TcpClientWorkerParams ¶ms); + static TcpClientWorker* maker(TcpClientFactory &factory, + TcpClientWorkerParams ¶ms); static void connected_cb(struct ev_loop *loop, struct ev_io *watcher,int revents); virtual void connected_cb(); @@ -124,8 +131,12 @@ class TcpClientWorker : public TcpWorker { class TcpServerEcho : public TcpServerWorker { private: TcpServerEchoParams ¶ms; + TcpServerEchoStats &stats; public: - TcpServerEcho(TcpServerFactory &factory, TcpServerEchoParams ¶ms, int sock); + TcpServerEcho(TcpServerFactory &factory, + TcpServerEchoParams ¶ms, + TcpServerEchoStats &stats, + int sock); virtual ~TcpServerEcho(); virtual void read_cb(); @@ -140,8 +151,11 @@ class TcpServerEcho : public TcpServerWorker { class TcpClientEcho : public TcpClientWorker { private: TcpClientEchoParams ¶ms; + TcpClientEchoStats &stats; public: - TcpClientEcho(TcpClientFactory &factory, TcpClientEchoParams ¶ms); + TcpClientEcho(TcpClientFactory &factory, + TcpClientEchoParams ¶ms, + TcpClientEchoStats &stats); virtual ~TcpClientEcho(); virtual void read_cb(); @@ -156,10 +170,14 @@ class TcpClientEcho : public TcpClientWorker { class TcpServerRaw : public TcpServerWorker { private: TcpServerRawParams ¶ms; + TcpServerRawStats &stats; PayloadList payloads; public: - TcpServerRaw(TcpServerFactory &factory, TcpServerRawParams ¶ms, int sock); + TcpServerRaw(TcpServerFactory &factory, + TcpServerRawParams ¶ms, + TcpServerRawStats &stats, + int sock); virtual ~TcpServerRaw(); virtual void write_cb(); @@ -174,10 +192,13 @@ class TcpServerRaw : public TcpServerWorker { class TcpClientRaw : public TcpClientWorker { private: TcpClientRawParams ¶ms; + TcpClientRawStats &stats; PayloadList payloads; public: - TcpClientRaw(TcpClientFactory &factory, TcpClientRawParams ¶ms); + TcpClientRaw(TcpClientFactory &factory, + TcpClientRawParams ¶ms, + TcpClientRawStats &stats); virtual ~TcpClientRaw(); virtual void write_cb(); @@ -192,6 +213,7 @@ class TcpClientRaw : public TcpClientWorker { class TcpServerHttp : public TcpServerWorker { private: TcpServerHttpParams ¶ms; + TcpServerHttpStats &stats; enum class ServerState { START, @@ -213,7 +235,10 @@ class TcpServerHttp : public TcpServerWorker { MemHunter request_crlfcrlf_mh; public: - TcpServerHttp(TcpServerFactory &factory, TcpServerHttpParams ¶ms, int sock); + TcpServerHttp(TcpServerFactory &factory, + TcpServerHttpParams ¶ms, + TcpServerHttpStats &stats, + int sock); virtual ~TcpServerHttp(); virtual void read_cb(); @@ -229,6 +254,7 @@ class TcpServerHttp : public TcpServerWorker { class TcpClientHttp : public TcpClientWorker { private: TcpClientHttpParams ¶ms; + TcpClientHttpStats &stats; public: enum class ClientState { @@ -246,7 +272,9 @@ class TcpClientHttp : public TcpClientWorker { PayloadList header_payloads; PayloadList body_payloads; - TcpClientHttp(TcpClientFactory &factory, TcpClientHttpParams ¶ms); + TcpClientHttp(TcpClientFactory &factory, + TcpClientHttpParams ¶ms, + TcpClientHttpStats &stats); virtual ~TcpClientHttp(); virtual void read_cb();