kapitan/IXWebSocket
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

clang-format

Browse Source
This commit is contained in:
Benjamin Sergeant
2019-12-30 08:46:18 -08:00
parent 8b5e42fe84
commit d60777b9cc
13 changed files with 239 additions and 238 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
ixwebsocket/IXSocketAppleSSL.cpp
View File

@@ -105,7 +105,9 @@ namespace ix
} }
} }
OSStatus SocketAppleSSL::writeToSocket(SSLConnectionRef connection, const void* data, size_t* len) OSStatus SocketAppleSSL::writeToSocket(SSLConnectionRef connection,
const void* data,
size_t* len)
{ {
int fd = (int) (long) connection; int fd = (int) (long) connection;
if (fd < 0) return errSSLInternal; if (fd < 0) return errSSLInternal;
@@ -165,7 +167,8 @@ namespace ix
_sslContext = SSLCreateContext(kCFAllocatorDefault, kSSLClientSide, kSSLStreamType); _sslContext = SSLCreateContext(kCFAllocatorDefault, kSSLClientSide, kSSLStreamType);
SSLSetIOFuncs(_sslContext, SocketAppleSSL::readFromSocket, SocketAppleSSL::writeToSocket); SSLSetIOFuncs(
_sslContext, SocketAppleSSL::readFromSocket, SocketAppleSSL::writeToSocket);
SSLSetConnection(_sslContext, (SSLConnectionRef)(long) _sockfd); SSLSetConnection(_sslContext, (SSLConnectionRef)(long) _sockfd);
SSLSetProtocolVersionMin(_sslContext, kTLSProtocol12); SSLSetProtocolVersionMin(_sslContext, kTLSProtocol12);
SSLSetPeerDomainName(_sslContext, host.c_str(), host.size()); SSLSetPeerDomainName(_sslContext, host.c_str(), host.size());

2
ixwebsocket/IXSocketServer.cpp
View File

@@ -11,8 +11,8 @@
#include "IXSocketConnect.h" #include "IXSocketConnect.h"
#include "IXSocketFactory.h" #include "IXSocketFactory.h"
#include <assert.h> #include <assert.h>
#include <stdio.h>
#include <sstream> #include <sstream>
#include <stdio.h>
#include <string.h> #include <string.h>
namespace ix namespace ix

4
test/IXCobraChatTest.cpp
View File

@@ -37,9 +37,7 @@ namespace
class CobraChat class CobraChat
{ {
public: public:
CobraChat(const std::string& user, CobraChat(const std::string& user, const std::string& session, const std::string& endpoint);
const std::string& session,
const std::string& endpoint);
void subscribe(const std::string& channel); void subscribe(const std::string& channel);
void start(); void start();

14
ws/ws.cpp
View File

@@ -269,7 +269,9 @@ int main(int argc, char** argv)
cobra2sentry->add_option("--rolesecret", rolesecret, "Role secret")->required(); cobra2sentry->add_option("--rolesecret", rolesecret, "Role secret")->required();
cobra2sentry->add_option("--dsn", dsn, "Sentry DSN"); cobra2sentry->add_option("--dsn", dsn, "Sentry DSN");
cobra2sentry->add_option("--jobs", jobs, "Number of thread sending events to Sentry"); cobra2sentry->add_option("--jobs", jobs, "Number of thread sending events to Sentry");
cobra2sentry->add_option("--queue_size", maxQueueSize, "Size of the queue to hold messages before they are sent to Sentry"); cobra2sentry->add_option("--queue_size",
maxQueueSize,
"Size of the queue to hold messages before they are sent to Sentry");
cobra2sentry->add_option("channel", channel, "Channel")->required(); cobra2sentry->add_option("channel", channel, "Channel")->required();
cobra2sentry->add_flag("-v", verbose, "Verbose"); cobra2sentry->add_flag("-v", verbose, "Verbose");
cobra2sentry->add_flag("-s", strict, "Strict mode. Error out when sending to sentry fails"); cobra2sentry->add_flag("-s", strict, "Strict mode. Error out when sending to sentry fails");
@@ -474,8 +476,14 @@ int main(int argc, char** argv)
} }
else if (app.got_subcommand("snake")) else if (app.got_subcommand("snake"))
{ {
ret = ix::ws_snake_main( ret = ix::ws_snake_main(port,
port, hostname, redisHosts, redisPort, redisPassword, verbose, appsConfigPath, tlsOptions); hostname,
redisHosts,
redisPort,
redisPassword,
verbose,
appsConfigPath,
tlsOptions);
} }
else if (app.got_subcommand("httpd")) else if (app.got_subcommand("httpd"))
{ {

5
ws/ws_broadcast_server.cpp
View File

@@ -5,8 +5,8 @@
*/ */
#include <ixwebsocket/IXWebSocketServer.h> #include <ixwebsocket/IXWebSocketServer.h>
#include <sstream>
#include <spdlog/spdlog.h> #include <spdlog/spdlog.h>
#include <sstream>
namespace ix namespace ix
@@ -38,7 +38,8 @@ namespace ix
else if (msg->type == ix::WebSocketMessageType::Close) else if (msg->type == ix::WebSocketMessageType::Close)
{ {
spdlog::info("Closed connection: code {} reason {}", spdlog::info("Closed connection: code {} reason {}",
msg->closeInfo.code, msg->closeInfo.reason); msg->closeInfo.code,
msg->closeInfo.reason);
} }
else if (msg->type == ix::WebSocketMessageType::Error) else if (msg->type == ix::WebSocketMessageType::Error)
{ {

2
ws/ws_chat.cpp
View File

@@ -14,8 +14,8 @@
#include <ixwebsocket/IXSocket.h> #include <ixwebsocket/IXSocket.h>
#include <ixwebsocket/IXWebSocket.h> #include <ixwebsocket/IXWebSocket.h>
#include <queue> #include <queue>
#include <sstream>
#include <spdlog/spdlog.h> #include <spdlog/spdlog.h>
#include <sstream>
// for convenience // for convenience
using json = nlohmann::json; using json = nlohmann::json;

176
ws/ws_cobra_to_sentry.cpp
View File

@@ -9,23 +9,24 @@
#include <condition_variable> #include <condition_variable>
#include <ixcobra/IXCobraConnection.h> #include <ixcobra/IXCobraConnection.h>
#include <ixsentry/IXSentryClient.h> #include <ixsentry/IXSentryClient.h>
#include <map>
#include <mutex> #include <mutex>
#include <queue> #include <queue>
#include <spdlog/spdlog.h> #include <spdlog/spdlog.h>
#include <sstream> #include <sstream>
#include <thread> #include <thread>
#include <vector> #include <vector>
#include <map>
namespace ix namespace ix
{ {
class QueueManager class QueueManager
{ {
public: public:
QueueManager(size_t maxQueueSize, QueueManager(size_t maxQueueSize, std::atomic<bool>& stop)
std::atomic<bool> &stop) : : _maxQueueSize(maxQueueSize)
_maxQueueSize(maxQueueSize), , _stop(stop)
_stop(stop) {} {
}
Json::Value pop(); Json::Value pop();
void add(Json::Value msg); void add(Json::Value msg);
@@ -136,95 +137,90 @@ namespace ix
std::thread t1(timer); std::thread t1(timer);
auto sentrySender = [&queueManager, auto sentrySender =
verbose, [&queueManager, verbose, &errorSending, &sentCount, &stop, &throttled, &dsn] {
&errorSending, SentryClient sentryClient(dsn);
&sentCount,
&stop,
&throttled,
&dsn] {
SentryClient sentryClient(dsn);
while (true) while (true)
{
Json::Value msg = queueManager.pop();
if (msg.isNull()) continue;
if (stop) return;
auto ret = sentryClient.send(msg, verbose);
HttpResponsePtr response = ret.first;
if (!response)
{ {
spdlog::warn("Null HTTP Response"); Json::Value msg = queueManager.pop();
continue;
}
if (verbose) if (msg.isNull()) continue;
{ if (stop) return;
for (auto it : response->headers)
auto ret = sentryClient.send(msg, verbose);
HttpResponsePtr response = ret.first;
if (!response)
{ {
spdlog::info("{}: {}", it.first, it.second); spdlog::warn("Null HTTP Response");
continue;
} }
spdlog::info("Upload size: {}", response->uploadSize); if (verbose)
spdlog::info("Download size: {}", response->downloadSize);
spdlog::info("Status: {}", response->statusCode);
if (response->errorCode != HttpErrorCode::Ok)
{ {
spdlog::info("error message: {}", response->errorMsg); for (auto it : response->headers)
}
if (response->headers["Content-Type"] != "application/octet-stream")
{
spdlog::info("payload: {}", response->payload);
}
}
if (response->statusCode != 200)
{
spdlog::error("Error sending data to sentry: {}", response->statusCode);
spdlog::error("Body: {}", ret.second);
spdlog::error("Response: {}", response->payload);
errorSending = true;
// Error 429 Too Many Requests
if (response->statusCode == 429)
{
auto retryAfter = response->headers["Retry-After"];
std::stringstream ss;
ss << retryAfter;
int seconds;
ss >> seconds;
if (!ss.eof() || ss.fail())
{ {
seconds = 30; spdlog::info("{}: {}", it.first, it.second);
spdlog::warn("Error parsing Retry-After header. "
"Using {} for the sleep duration",
seconds);
} }
spdlog::warn("Error 429 - Too Many Requests. ws will sleep " spdlog::info("Upload size: {}", response->uploadSize);
"and retry after {} seconds", spdlog::info("Download size: {}", response->downloadSize);
retryAfter);
throttled = true; spdlog::info("Status: {}", response->statusCode);
auto duration = std::chrono::seconds(seconds); if (response->errorCode != HttpErrorCode::Ok)
std::this_thread::sleep_for(duration); {
throttled = false; spdlog::info("error message: {}", response->errorMsg);
}
if (response->headers["Content-Type"] != "application/octet-stream")
{
spdlog::info("payload: {}", response->payload);
}
} }
}
else
{
++sentCount;
}
if (stop) return; if (response->statusCode != 200)
} {
}; spdlog::error("Error sending data to sentry: {}", response->statusCode);
spdlog::error("Body: {}", ret.second);
spdlog::error("Response: {}", response->payload);
errorSending = true;
// Error 429 Too Many Requests
if (response->statusCode == 429)
{
auto retryAfter = response->headers["Retry-After"];
std::stringstream ss;
ss << retryAfter;
int seconds;
ss >> seconds;
if (!ss.eof() || ss.fail())
{
seconds = 30;
spdlog::warn("Error parsing Retry-After header. "
"Using {} for the sleep duration",
seconds);
}
spdlog::warn("Error 429 - Too Many Requests. ws will sleep "
"and retry after {} seconds",
retryAfter);
throttled = true;
auto duration = std::chrono::seconds(seconds);
std::this_thread::sleep_for(duration);
throttled = false;
}
}
else
{
++sentCount;
}
if (stop) return;
}
};
// Create a thread pool // Create a thread pool
spdlog::info("Starting {} sentry sender jobs", jobs); spdlog::info("Starting {} sentry sender jobs", jobs);
@@ -241,12 +237,11 @@ namespace ix
verbose, verbose,
&throttled, &throttled,
&receivedCount, &receivedCount,
&queueManager]( &queueManager](ix::CobraConnectionEventType eventType,
ix::CobraConnectionEventType eventType, const std::string& errMsg,
const std::string& errMsg, const ix::WebSocketHttpHeaders& headers,
const ix::WebSocketHttpHeaders& headers, const std::string& subscriptionId,
const std::string& subscriptionId, CobraConnection::MsgId msgId) {
CobraConnection::MsgId msgId) {
if (eventType == ix::CobraConnection_EventType_Open) if (eventType == ix::CobraConnection_EventType_Open)
{ {
spdlog::info("Subscriber connected"); spdlog::info("Subscriber connected");
@@ -265,11 +260,8 @@ namespace ix
spdlog::info("Subscriber authenticated"); spdlog::info("Subscriber authenticated");
conn.subscribe(channel, conn.subscribe(channel,
filter, filter,
[&jsonWriter, [&jsonWriter, verbose, &throttled, &receivedCount, &queueManager](
verbose, const Json::Value& msg) {
&throttled,
&receivedCount,
&queueManager](const Json::Value& msg) {
if (verbose) if (verbose)
{ {
spdlog::info(jsonWriter.write(msg)); spdlog::info(jsonWriter.write(msg));

135
ws/ws_cobra_to_statsd.cpp
View File

@@ -22,10 +22,11 @@ namespace
class QueueManager class QueueManager
{ {
public: public:
QueueManager(size_t maxQueueSize, QueueManager(size_t maxQueueSize, std::atomic<bool>& stop)
std::atomic<bool> &stop) : : _maxQueueSize(maxQueueSize)
_maxQueueSize(maxQueueSize), , _stop(stop)
_stop(stop) {} {
}
Json::Value pop(); Json::Value pop();
void add(Json::Value msg); void add(Json::Value msg);
@@ -67,7 +68,7 @@ namespace
_condition.notify_one(); _condition.notify_one();
} }
} }
} } // namespace
namespace ix namespace ix
{ {
@@ -152,17 +153,11 @@ namespace ix
std::thread t1(timer); std::thread t1(timer);
auto statsdSender = [&queueManager, auto statsdSender = [&queueManager, &host, &port, &sentCount, &tokens, &prefix, &stop] {
&host,
&port,
&sentCount,
&tokens,
&prefix,
&stop] {
// statsd client // statsd client
// test with netcat as a server: `nc -ul 8125` // test with netcat as a server: `nc -ul 8125`
bool statsdBatch = true; bool statsdBatch = true;
#ifndef _WIN32 #ifndef _WIN32
statsd::StatsdClient statsdClient(host, port, prefix, statsdBatch); statsd::StatsdClient statsdClient(host, port, prefix, statsdBatch);
#else #else
int statsdClient; int statsdClient;
@@ -191,69 +186,65 @@ namespace ix
std::thread t2(statsdSender); std::thread t2(statsdSender);
conn.setEventCallback([&conn, conn.setEventCallback(
&channel, [&conn, &channel, &filter, &jsonWriter, verbose, &queueManager, &receivedCount](
&filter, ix::CobraConnectionEventType eventType,
&jsonWriter, const std::string& errMsg,
verbose, const ix::WebSocketHttpHeaders& headers,
&queueManager, const std::string& subscriptionId,
&receivedCount](ix::CobraConnectionEventType eventType, CobraConnection::MsgId msgId) {
const std::string& errMsg, if (eventType == ix::CobraConnection_EventType_Open)
const ix::WebSocketHttpHeaders& headers,
const std::string& subscriptionId,
CobraConnection::MsgId msgId) {
if (eventType == ix::CobraConnection_EventType_Open)
{
spdlog::info("Subscriber connected");
for (auto it : headers)
{ {
spdlog::info("{}: {}", it.first, it.second); spdlog::info("Subscriber connected");
for (auto it : headers)
{
spdlog::info("{}: {}", it.first, it.second);
}
} }
} if (eventType == ix::CobraConnection_EventType_Closed)
if (eventType == ix::CobraConnection_EventType_Closed) {
{ spdlog::info("Subscriber closed");
spdlog::info("Subscriber closed"); }
} else if (eventType == ix::CobraConnection_EventType_Authenticated)
else if (eventType == ix::CobraConnection_EventType_Authenticated) {
{ spdlog::info("Subscriber authenticated");
spdlog::info("Subscriber authenticated"); conn.subscribe(channel,
conn.subscribe(channel, filter,
filter, [&jsonWriter, &queueManager, verbose, &receivedCount](
[&jsonWriter, &queueManager, verbose, &receivedCount]( const Json::Value& msg) {
const Json::Value& msg) { if (verbose)
if (verbose) {
{ spdlog::info(jsonWriter.write(msg));
spdlog::info(jsonWriter.write(msg)); }
}
receivedCount++; receivedCount++;
++receivedCount; ++receivedCount;
queueManager.add(msg); queueManager.add(msg);
}); });
} }
else if (eventType == ix::CobraConnection_EventType_Subscribed) else if (eventType == ix::CobraConnection_EventType_Subscribed)
{ {
spdlog::info("Subscriber: subscribed to channel {}", subscriptionId); spdlog::info("Subscriber: subscribed to channel {}", subscriptionId);
} }
else if (eventType == ix::CobraConnection_EventType_UnSubscribed) else if (eventType == ix::CobraConnection_EventType_UnSubscribed)
{ {
spdlog::info("Subscriber: unsubscribed from channel {}", subscriptionId); spdlog::info("Subscriber: unsubscribed from channel {}", subscriptionId);
} }
else if (eventType == ix::CobraConnection_EventType_Error) else if (eventType == ix::CobraConnection_EventType_Error)
{ {
spdlog::error("Subscriber: error {}", errMsg); spdlog::error("Subscriber: error {}", errMsg);
} }
else if (eventType == ix::CobraConnection_EventType_Published) else if (eventType == ix::CobraConnection_EventType_Published)
{ {
spdlog::error("Published message hacked: {}", msgId); spdlog::error("Published message hacked: {}", msgId);
} }
else if (eventType == ix::CobraConnection_EventType_Pong) else if (eventType == ix::CobraConnection_EventType_Pong)
{ {
spdlog::info("Received websocket pong"); spdlog::info("Received websocket pong");
} }
}); });
while (true) while (true)
{ {

2
ws/ws_ping_pong.cpp
View File

@@ -4,12 +4,12 @@
* Copyright (c) 2018-2019 Machine Zone, Inc. All rights reserved. * Copyright (c) 2018-2019 Machine Zone, Inc. All rights reserved.
*/ */
#include <iostream>
#include <ixwebsocket/IXSocket.h> #include <ixwebsocket/IXSocket.h>
#include <ixwebsocket/IXSocketTLSOptions.h> #include <ixwebsocket/IXSocketTLSOptions.h>
#include <ixwebsocket/IXWebSocket.h> #include <ixwebsocket/IXWebSocket.h>
#include <spdlog/spdlog.h> #include <spdlog/spdlog.h>
#include <sstream> #include <sstream>
#include <iostream>
namespace ix namespace ix
{ {

98
ws/ws_proxy_server.cpp
View File

@@ -61,7 +61,7 @@ namespace ix
// Server connection // Server connection
state->webSocket().setOnMessageCallback([webSocket, state, verbose]( state->webSocket().setOnMessageCallback([webSocket, state, verbose](
const WebSocketMessagePtr& msg) { const WebSocketMessagePtr& msg) {
if (msg->type == ix::WebSocketMessageType::Open) if (msg->type == ix::WebSocketMessageType::Open)
{ {
spdlog::info("New connection to remote server"); spdlog::info("New connection to remote server");
@@ -101,61 +101,61 @@ namespace ix
}); });
// Client connection // Client connection
webSocket->setOnMessageCallback([state, remoteUrl, verbose]( webSocket->setOnMessageCallback(
const WebSocketMessagePtr& msg) { [state, remoteUrl, verbose](const WebSocketMessagePtr& msg) {
if (msg->type == ix::WebSocketMessageType::Open) if (msg->type == ix::WebSocketMessageType::Open)
{
spdlog::info("New connection from client");
spdlog::info("id: {}", state->getId());
spdlog::info("Uri: {}", msg->openInfo.uri);
spdlog::info("Headers:");
for (auto it : msg->openInfo.headers)
{ {
spdlog::info("{}: {}", it.first, it.second); spdlog::info("New connection from client");
spdlog::info("id: {}", state->getId());
spdlog::info("Uri: {}", msg->openInfo.uri);
spdlog::info("Headers:");
for (auto it : msg->openInfo.headers)
{
spdlog::info("{}: {}", it.first, it.second);
}
// Connect to the 'real' server
std::string url(remoteUrl);
url += msg->openInfo.uri;
state->webSocket().setUrl(url);
state->webSocket().disableAutomaticReconnection();
state->webSocket().start();
// we should sleep here for a bit until we've established the
// connection with the remote server
while (state->webSocket().getReadyState() != ReadyState::Open)
{
spdlog::info("waiting for server connection establishment");
std::this_thread::sleep_for(std::chrono::milliseconds(10));
}
spdlog::info("server connection established");
} }
else if (msg->type == ix::WebSocketMessageType::Close)
// Connect to the 'real' server
std::string url(remoteUrl);
url += msg->openInfo.uri;
state->webSocket().setUrl(url);
state->webSocket().disableAutomaticReconnection();
state->webSocket().start();
// we should sleep here for a bit until we've established the
// connection with the remote server
while (state->webSocket().getReadyState() != ReadyState::Open)
{ {
spdlog::info("waiting for server connection establishment"); spdlog::info("Closed client connection: client id {} code {} reason {}",
std::this_thread::sleep_for(std::chrono::milliseconds(10)); state->getId(),
msg->closeInfo.code,
msg->closeInfo.reason);
state->webSocket().close(msg->closeInfo.code, msg->closeInfo.reason);
} }
spdlog::info("server connection established"); else if (msg->type == ix::WebSocketMessageType::Error)
}
else if (msg->type == ix::WebSocketMessageType::Close)
{
spdlog::info("Closed client connection: client id {} code {} reason {}",
state->getId(),
msg->closeInfo.code,
msg->closeInfo.reason);
state->webSocket().close(msg->closeInfo.code, msg->closeInfo.reason);
}
else if (msg->type == ix::WebSocketMessageType::Error)
{
spdlog::error("Connection error: {}", msg->errorInfo.reason);
spdlog::error("#retries: {}", msg->errorInfo.retries);
spdlog::error("Wait time(ms): {}", msg->errorInfo.wait_time);
spdlog::error("HTTP Status: {}", msg->errorInfo.http_status);
}
else if (msg->type == ix::WebSocketMessageType::Message)
{
spdlog::info("Received {} bytes from client", msg->wireSize);
if (verbose)
{ {
spdlog::info("payload {}", msg->str); spdlog::error("Connection error: {}", msg->errorInfo.reason);
spdlog::error("#retries: {}", msg->errorInfo.retries);
spdlog::error("Wait time(ms): {}", msg->errorInfo.wait_time);
spdlog::error("HTTP Status: {}", msg->errorInfo.http_status);
} }
else if (msg->type == ix::WebSocketMessageType::Message)
{
spdlog::info("Received {} bytes from client", msg->wireSize);
if (verbose)
{
spdlog::info("payload {}", msg->str);
}
state->webSocket().send(msg->str, msg->binary); state->webSocket().send(msg->str, msg->binary);
} }
}); });
}); });
auto res = server.listen(); auto res = server.listen();

2
ws/ws_receive.cpp
View File

@@ -14,8 +14,8 @@
#include <ixwebsocket/IXSocketTLSOptions.h> #include <ixwebsocket/IXSocketTLSOptions.h>
#include <ixwebsocket/IXWebSocket.h> #include <ixwebsocket/IXWebSocket.h>
#include <msgpack11/msgpack11.hpp> #include <msgpack11/msgpack11.hpp>
#include <spdlog/spdlog.h>
#include <mutex> #include <mutex>
#include <spdlog/spdlog.h>
#include <sstream> #include <sstream>
#include <vector> #include <vector>

2
ws/ws_send.cpp
View File

@@ -14,8 +14,8 @@
#include <ixwebsocket/IXSocketTLSOptions.h> #include <ixwebsocket/IXSocketTLSOptions.h>
#include <ixwebsocket/IXWebSocket.h> #include <ixwebsocket/IXWebSocket.h>
#include <msgpack11/msgpack11.hpp> #include <msgpack11/msgpack11.hpp>
#include <spdlog/spdlog.h>
#include <mutex> #include <mutex>
#include <spdlog/spdlog.h>
#include <sstream> #include <sstream>
#include <vector> #include <vector>

28
ws/ws_transfer.cpp
View File

@@ -70,19 +70,23 @@ namespace ix
if (readyState == ReadyState::Open) if (readyState == ReadyState::Open)
{ {
++receivers; ++receivers;
client->send(msg->str, client->send(
msg->binary, msg->str, msg->binary, [&id](int current, int total) -> bool {
[&id](int current, int total) -> bool { spdlog::info("{}: [client {}]: Step {} out of {}",
spdlog::info("{}: [client {}]: Step {} out of {}", "ws_transfer",
"ws_transfer", id, current, total); id,
return true; current,
}); total);
return true;
});
do do
{ {
size_t bufferedAmount = client->bufferedAmount(); size_t bufferedAmount = client->bufferedAmount();
spdlog::info("{}: [client {}]: {} bytes left to send", spdlog::info("{}: [client {}]: {} bytes left to send",
"ws_transfer", id, bufferedAmount); "ws_transfer",
id,
bufferedAmount);
std::this_thread::sleep_for(std::chrono::milliseconds(500)); std::this_thread::sleep_for(std::chrono::milliseconds(500));
@@ -97,8 +101,12 @@ namespace ix
: readyState == ReadyState::Closing ? "Closing" : "Closed"; : readyState == ReadyState::Closing ? "Closing" : "Closed";
size_t bufferedAmount = client->bufferedAmount(); size_t bufferedAmount = client->bufferedAmount();
spdlog::info("{}: [client {}]: has readystate {} bytes left to be sent", spdlog::info(
"ws_transfer", id, readyStateString, bufferedAmount); "{}: [client {}]: has readystate {} bytes left to be sent",
"ws_transfer",
id,
readyStateString,
bufferedAmount);
} }
} }
} }