ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2026-04-29 15:37:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

stress_test now supports message sending & stats

Browse Source
This commit is contained in:
Peter Thorson
2012-06-07 13:44:06 -05:00
parent a3b7546d65
commit 61be3c182c
6 changed files with 203 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files

183
examples/wsperf/stress_handler.cpp
View File

@@ -64,6 +64,7 @@ stress_handler::stress_handler(wscmd::cmd& cmd)
, m_failed_connections(0)
, m_next_con_id(0)
, m_init(boost::chrono::steady_clock::now())
, m_next_msg_id(0)
, m_con_sync(false)
{
if (!wscmd::extract_number<size_t>(cmd,"msg_count",m_msg_count)) {
@@ -112,14 +113,6 @@ stress_handler::stress_handler(wscmd::cmd& cmd)
// TODO: choose random number between 0 and max_dur
m_con_duration = max_dur;
}
std::cout << "con_duration: " << m_con_duration
<< "msg_count: " << m_msg_count
<< "msg_size: " << m_msg_size
<< "m_con_sync: " << m_con_sync
<< "m_con_lifetime: " << m_con_lifetime
<< "m_msg_mode: " << m_msg_mode
<< std::endl;
}
void stress_handler::on_connect(connection_ptr con) {
@@ -127,18 +120,76 @@ void stress_handler::on_connect(connection_ptr con) {
m_con_data[con] = con_data(m_next_con_id++, m_init);
m_con_data[con].start = boost::chrono::steady_clock::now();
m_dirty.push_back(con);
}
void stress_handler::on_handshake_init(connection_ptr con) {
boost::lock_guard<boost::mutex> lock(m_lock);
m_con_data[con].tcp_established = boost::chrono::steady_clock::now();
m_dirty.push_back(con);
// TODO: log close reason?
}
void stress_handler::start_message_test() {
m_msg.reset(new std::string());
m_msg->assign(m_msg_size,'*');
// for each connection send the first message
std::map<connection_ptr,con_data>::iterator it;
for (it = m_con_data.begin(); it != m_con_data.end(); it++) {
connection_ptr con = (*it).first;
con_data& data = (*it).second;
/*data.msg = con->get_data_message();
std::string msg;
msg.assign(m_msg_size,'*');
data.msg->set_payload(msg);
data.msg->reset(websocketpp::frame::opcode::BINARY);*/
boost::lock_guard<boost::mutex> lock(m_lock);
msg_data foo;
foo.msg_id = m_next_msg_id++;
foo.send_time = boost::chrono::steady_clock::now();
data.messages.push_back(foo);
con->send(*m_msg);
}
}
void stress_handler::on_message(connection_ptr con,websocketpp::message::data_ptr msg) {
time_point mark = boost::chrono::steady_clock::now();
boost::lock_guard<boost::mutex> lock(m_lock);
std::map<connection_ptr,con_data>::iterator element = m_con_data.find(con);
if (element == m_con_data.end()) {
std::cout << "Bad Bad Bad" << std::endl;
return;
}
con_data& data = (*element).second;
data.messages.back().recv_time = mark;
if (data.messages.size() < m_msg_count) {
msg_data foo;
foo.msg_id = m_next_msg_id++;
foo.send_time = boost::chrono::steady_clock::now();
data.messages.push_back(foo);
con->send(*m_msg);
} else {
close(con);
}
}
void stress_handler::on_open(connection_ptr con) {
{
boost::lock_guard<boost::mutex> lock(m_lock);
@@ -152,7 +203,6 @@ void stress_handler::on_open(connection_ptr con) {
m_con_data[con].on_open = boost::chrono::steady_clock::now();
m_con_data[con].status = "Open";
m_dirty.push_back(con);
}
start(con);
@@ -165,7 +215,6 @@ void stress_handler::on_close(connection_ptr con) {
m_con_data[con].on_close = boost::chrono::steady_clock::now();
m_con_data[con].status = "Closed";
m_dirty.push_back(con);
// TODO: log close reason?
}
@@ -177,19 +226,19 @@ void stress_handler::on_fail(connection_ptr con) {
m_con_data[con].on_fail = boost::chrono::steady_clock::now();
m_con_data[con].status = "Failed";
m_dirty.push_back(con);
// TODO: log failure reason
}
void stress_handler::start(connection_ptr con) {}
void stress_handler::start(connection_ptr con) {
//close(con);
}
void stress_handler::close(connection_ptr con) {
//boost::lock_guard<boost::mutex> lock(m_lock);
m_con_data[con].close_sent = boost::chrono::steady_clock::now();
m_con_data[con].status = "Closing";
m_dirty.push_back(con);
con->close(websocketpp::close::status::NORMAL);
// TODO: log close reason?
@@ -198,10 +247,12 @@ void stress_handler::close(connection_ptr con) {
std::string stress_handler::get_data() const {
std::stringstream data;
data << "{";
{
boost::lock_guard<boost::mutex> lock(m_lock);
data << "\"current_connections\":" << m_current_connections;
data << ",\"max_connections\":" << m_max_connections;
data << ",\"total_connections\":" << m_total_connections;
@@ -211,20 +262,11 @@ std::string stress_handler::get_data() const {
// for each item in m_dirty
std::string sep = "";
std::list<connection_ptr>::const_iterator it;
for (it = m_dirty.begin(); it != m_dirty.end(); it++) {
std::map<connection_ptr,con_data>::const_iterator element;
element = m_con_data.find(*it);
if (element == m_con_data.end()) {
continue;
}
data << sep << element->second.print();
std::map<connection_ptr,con_data>::const_iterator it;
for (it = m_con_data.begin(); it != m_con_data.end(); it++) {
data << sep << (*it).second.print();
sep = ",";
}
m_dirty.clear();
data << "]";
}
@@ -235,45 +277,29 @@ std::string stress_handler::get_data() const {
}
bool stress_handler::maintenance() {
std::list<connection_ptr> to_process;
std::cout << "locking..." << std::endl;
boost::lock_guard<boost::mutex> lock(m_lock);
{
boost::lock_guard<boost::mutex> lock(m_lock);
bool quit = true;
std::map<connection_ptr,con_data>::iterator it;
for (it = m_con_data.begin(); it != m_con_data.end(); it++) {
to_process.push_back((*it).first);
if ((*it).first->get_state() != websocketpp::session::state::CLOSED) {
quit = false;
}
}
if (quit) {
return true;
}
}
bool quit = true;
time_point now = boost::chrono::steady_clock::now();
std::list<connection_ptr>::iterator it;
for (it = to_process.begin(); it != to_process.end(); it++) {
connection_ptr con = (*it);
std::map<connection_ptr,con_data>::iterator element;
boost::lock_guard<boost::mutex> lock(m_lock);
element = m_con_data.find(con);
if (element == m_con_data.end()) {
continue;
std::cout << "found " << m_con_data.size() << " connections" << std::endl;
std::map<connection_ptr,con_data>::iterator it;
for (it = m_con_data.begin(); it != m_con_data.end(); it++) {
if ((*it).first->get_state() != websocketpp::session::state::CLOSED) {
quit = false;
}
con_data& data = element->second;
connection_ptr con = (*it).first;
con_data& data = (*it).second;
std::cout << "processing " << data.id << "...";
// check the connection state
if (con->get_state() != websocketpp::session::state::OPEN) {
std::cout << "ignored" << std::endl;
continue;
}
@@ -283,7 +309,50 @@ bool stress_handler::maintenance() {
if (milliseconds > m_con_duration) {
close(con);
}
std::cout << "closed" << std::endl;
}
if (quit) {
return true;
}
/*std::cout << "found " << to_process.size() << " connections" << std::endl;
std::list<connection_ptr>::iterator it2;
for (it2 = to_process.begin(); it2 != to_process.end(); it++) {
connection_ptr con = (*it2);
std::map<connection_ptr,con_data>::iterator element;
element = m_con_data.find(con);
if (element == m_con_data.end()) {
continue;
}
con_data& data = element->second;
// check the connection state
if (con->get_state() != websocketpp::session::state::OPEN) {
std::cout << "ignored" << std::endl;
continue;
}
boost::chrono::nanoseconds dur = now - data.on_open;
size_t milliseconds = static_cast<size_t>(dur.count()) / 1000000;
if (milliseconds > m_con_duration) {
close(con);
}
std::cout << "closed" << std::endl;
}*/
return false;
}