Websocket 1.2.1 vs 1.3.0

[unitech2617-alt]

i'am concurrent send test. (I'm not very good at English)
using websocket++/0.8.2 test client about 20 clients connect to websocket server and than send 100 messages of simple string on time(per 10min, 20min, 30min, 40min, 50min, 00min)
crow 1.2.1 websocket is keep connection very well, but 1.3.0 version is disconnected in processing.(error code 1006)
what difference? can you help me?

[gittiver]

Can you send me the test case as code somehow?
This would make it easier for me to look what is going on.

[unitech2617-alt]

<ws_client.hpp>

#include <websocketpp/config/asio_no_tls_client.hpp>
#include <websocketpp/client.hpp>

#include <websocketpp/common/thread.hpp>
#include <websocketpp/common/memory.hpp>

#include
#include
#include
#include
#include

typedef websocketpp::clientwebsocketpp::config::asio_client client;

using websocketpp::lib::placeholders::_1;
using websocketpp::lib::placeholders::_2;
using websocketpp::lib::bind;

// pull out the type of messages sent by our config
typedef websocketpp::config::asio_client::message_type::ptr message_ptr;

class WSClient {
private:
std::thread thMain;
client c;
client::connection_ptr ws_con;

public:
WSClient(std::string url) {
try {
// Start the ASIO io_service run loop
this->thMain = std::thread([this, url] { runThread(url); });
}
catch (const std::exception& e) {
std::cout << e.what() << std::endl;
}
catch (websocketpp::lib::error_code e) {
std::cout << e.message() << std::endl;
}
catch (...) {
std::cout << "other exception" << std::endl;
}
}

void send(std::string msg)
{
	websocketpp::lib::error_code ec;
	if(ws_con)
		c.send(ws_con->get_handle(), msg.c_str(), msg.size() + 1, websocketpp::frame::opcode::TEXT, ec);
}

void on_open(client* c, websocketpp::connection_hdl hdl) {
	//m_status = "Open";

	ws_con = c->get_con_from_hdl(hdl);
	//m_server = con->get_response_header("Server");
}

void on_fail(client* c, websocketpp::connection_hdl hdl) {
	//m_status = "Failed";

	ws_con = c->get_con_from_hdl(hdl);
	//m_server = con->get_response_header("Server");
	//m_error_reason = con->get_ec().message();
}

void on_close(client* c, websocketpp::connection_hdl hdl) {
	//m_status = "Closed";
	ws_con = c->get_con_from_hdl(hdl);
	std::stringstream s;
	s << "close code: " << ws_con->get_remote_close_code() << " ("
		<< websocketpp::close::status::get_string(ws_con->get_remote_close_code())
		<< "), close reason: " << ws_con->get_remote_close_reason();
	//m_error_reason = s.str();
}
// This message handler will be invoked once for each incoming message. It

// prints the message and then sends a copy of the message back to the server.
void on_message(client* c, websocketpp::connection_hdl hdl, message_ptr msg) {
printf("%s \n", msg->get_payload().c_str());

	//websocketpp::lib::error_code ec;

	//c->send(hdl, msg->get_payload(), msg->get_opcode(), ec);
	//if (ec) {
	//	std::cout << "Echo failed because: " << ec.message() << std::endl;
	//}
}

void runThread(std::string url) {
	//std::string uri = "wss://localhost:9001";

	// Set logging to be pretty verbose (everything except message payloads)
	c.set_access_channels(websocketpp::log::alevel::all);
	c.clear_access_channels(websocketpp::log::alevel::frame_payload);

	websocketpp::lib::error_code ec2;
	// Initialize ASIO
	c.init_asio(ec2);
	if (ec2) {
		printf("Failed to init asio, %i : %s", ec2.value(), ec2.message().c_str());
	}

	// Register our message handler
	c.set_message_handler(bind(&WSClient::on_message, this, &c, ::_1, ::_2));

	c.set_open_handler(bind(&WSClient::on_open, this, &c, ::_1));

	c.set_fail_handler(bind(&WSClient::on_fail, this, &c, ::_1));

	c.set_close_handler(bind(&WSClient::on_close, this, &c, ::_1));

	while (true) {
		websocketpp::lib::error_code ec;
		ws_con = c.get_connection(url, ec);
		if (ec) {
			std::cout << "could not create connection because: " << ec.message() << std::endl;
			std::cin.get();
			return;
		}

		// Note that connect here only requests a connection. No network messages are
		// exchanged until the event loop starts running in the next line.
		c.connect(ws_con);

		// Start the ASIO io_service run loop
		// this will cause a single connection to be made to the server. c.run()
		// will exit when this connection is closed.
		c.run();
		c.reset();
		printf("Connection closed, retry!");
		//std::cin.get();

	}
}

};

<main.cpp>

void schedule_next_hour_timer(WSClient& ws_sock , asio::system_timer& timer, asio::io_context& io_context);

void handle_timer_expiry(const asio::error_code& error, asio::system_timer& timer, asio::io_context& io_context, WSClient& ws_sock ) {
if (error == asio::error::operation_aborted) {
// Timer was cancelled, possibly during shutdown
return;
}
if (error) {
std::cerr << "Timer error: " << error.message() << std::endl;
return;
}

// Action to perform on the hour
auto now = std::chrono::system_clock::now();
std::time_t now_c = std::chrono::system_clock::to_time_t(now);
struct tm time_info = {};
localtime_s(&time_info, &now_c);
std::cout << "On the hour! Current time: " << std::put_time(&time_info, "%H:%M:%S") << std::endl;


CString msg;
for (int i = 0; i < 100; ++i)
{
    msg.Format("ID : %d , DATE : %04d-%02d-%02d %02d:%02d:%02d , MSG NO : %d",i, time_info.tm_year+1900, time_info.tm_mon+1, time_info.tm_mday, time_info.tm_hour, time_info.tm_min, time_info.tm_sec, i);

    if(time_info.tm_min == 0)
        ws_sock .send_ws(msg.GetBuffer());
    if (time_info.tm_min == 10)
        ws_sock .send_ws(msg.GetBuffer());
    if (time_info.tm_min == 20)
        ws_sock .send_ws(msg.GetBuffer());
    if (time_info.tm_min == 30)
        ws_sock .send_ws(msg.GetBuffer());
    if (time_info.tm_min == 40)
        ws_sock .send_ws(msg.GetBuffer());
    if (time_info.tm_min == 50)
        ws_sock .send_ws(msg.GetBuffer());
}

// Schedule the next timer for the next hour
// (Implementation details for scheduling the next timer are below)
schedule_next_hour_timer(ws_sock , timer, io_context);

}

void schedule_next_hour_timer(WSClient& ws_sock , asio::system_timer& timer, asio::io_context& io_context) {
auto now = std::chrono::system_clock::now();
// 00,10,20,30,40,50
now = now + std::chrono::minutes(10);
auto now_time_t = std::chrono::system_clock::to_time_t(now);
std::tm current_tm;
localtime_s(&current_tm, &now_time_t);

// Calculate time to the next hour
current_tm.tm_min = (current_tm.tm_min / 10) * 10;
current_tm.tm_sec = 0;

auto next_hour = std::chrono::system_clock::from_time_t(std::mktime(&current_tm));

timer.expires_at(next_hour); // Use relative time from last expiry
timer.async_wait(std::bind(&handle_timer_expiry, std::placeholders::_1, std::ref(timer), std::ref(io_context), std::ref(ws_sock )));

}

int main(int argc, char* argv[]) {
int id = 0;

if (argc == 2)
{
    id = std::stoi(argv[1]);
}

SetConsoleOutputCP(CP_UTF8);

asio::io_context io_context;
asio::executor_work_guard<asio::io_context::executor_type> work_guard(io_context.get_executor());

std::unique_ptr<WSClient> ws_sock = std::make_unique<WSClient>("ws://127.0.0.1:40080/ws");)

asio::system_timer timer(io_context);
// Initial scheduling for the first "on the hour" event
schedule_next_hour_timer(ws_sock , timer, io_context);


std::thread t([&] { io_context.run(); });
io_context.run();

t.join();

std::cout << "exit" << std::endl;
return 0;

}

this is WSClient class base client test code. i am using asio 1.30.2 library, timer is to work on 00,10,20,30,40,50 min and send 100 packets to websocket, excute 20 clients and Simultaneous connection.
it is not full source, some modifications may be required.
thank you your reply.

[gittiver]

We have fixed a web socket related issue after 1.3.0 https://github.com/CrowCpp/Crow/issues/, can you check if using the current master branch fixes your issue?