dn724/dncurrency
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

Remove unnecessary fmt::streamed

Browse source
This commit is contained in:
Piotr Wójcik 2025-01-21 18:25:32 +01:00
commit c0a278b231
8 changed files with 39 additions and 42 deletions
Download patch file Download diff file Expand all files Collapse all files

4
nano/node/network.cpp
View file

@ -357,12 +357,12 @@ bool nano::network::merge_peer (nano::endpoint const & peer)
if (track_reachout (peer)) if (track_reachout (peer))
{ {
node.stats.inc (nano::stat::type::network, nano::stat::detail::merge_peer); node.stats.inc (nano::stat::type::network, nano::stat::detail::merge_peer);
node.logger.debug (nano::log::type::network, "Initiating peer merge: {}", fmt::streamed (peer)); node.logger.debug (nano::log::type::network, "Initiating peer merge: {}", peer);
bool started = tcp_channels.start_tcp (peer); bool started = tcp_channels.start_tcp (peer);
if (!started) if (!started)
{ {
node.stats.inc (nano::stat::type::tcp, nano::stat::detail::merge_peer_failed); node.stats.inc (nano::stat::type::tcp, nano::stat::detail::merge_peer_failed);
node.logger.debug (nano::log::type::network, "Peer merge failed: {}", fmt::streamed (peer)); node.logger.debug (nano::log::type::network, "Peer merge failed: {}", peer);
} }
return started; return started;
} }

4
nano/node/online_reps.cpp
View file

@ -32,7 +32,7 @@ void nano::online_reps::start ()
nano::lock_guard<nano::mutex> lock{ mutex }; nano::lock_guard<nano::mutex> lock{ mutex };
cached_trended = trended_l; cached_trended = trended_l;
logger.info (nano::log::type::online_reps, "Initial trended weight: {}", fmt::streamed (cached_trended)); logger.info (nano::log::type::online_reps, "Initial trended weight: {}", cached_trended);
} }
thread = std::thread ([this] () { thread = std::thread ([this] () {
@ -125,7 +125,7 @@ void nano::online_reps::sample ()
nano::lock_guard<nano::mutex> lock{ mutex }; nano::lock_guard<nano::mutex> lock{ mutex };
cached_trended = trended_l; cached_trended = trended_l;
} }
logger.info (nano::log::type::online_reps, "Updated trended weight: {}", fmt::streamed (trended_l)); logger.info (nano::log::type::online_reps, "Updated trended weight: {}", trended_l);
} }
nano::uint128_t nano::online_reps::calculate_online () const nano::uint128_t nano::online_reps::calculate_online () const

4
nano/node/peer_history.cpp
View file

@ -92,7 +92,7 @@ void nano::peer_history::run_one ()
if (!exists) if (!exists)
{ {
stats.inc (nano::stat::type::peer_history, nano::stat::detail::inserted); stats.inc (nano::stat::type::peer_history, nano::stat::detail::inserted);
logger.debug (nano::log::type::peer_history, "Saved new peer: {}", fmt::streamed (endpoint)); logger.debug (nano::log::type::peer_history, "Saved new peer: {}", endpoint);
} }
else else
{ {
@ -116,7 +116,7 @@ void nano::peer_history::run_one ()
stats.inc (nano::stat::type::peer_history, nano::stat::detail::erased); stats.inc (nano::stat::type::peer_history, nano::stat::detail::erased);
logger.debug (nano::log::type::peer_history, "Erased peer: {} (not seen for {}s)", logger.debug (nano::log::type::peer_history, "Erased peer: {} (not seen for {}s)",
fmt::streamed (endpoint.endpoint ()), endpoint.endpoint (),
nano::log::seconds_delta (timestamp)); nano::log::seconds_delta (timestamp));
} }
} }

8
nano/node/transport/tcp_channels.cpp
View file

@ -56,7 +56,7 @@ bool nano::transport::tcp_channels::check (const nano::tcp_endpoint & endpoint,
if (node.network.not_a_peer (nano::transport::map_tcp_to_endpoint (endpoint), node.config.allow_local_peers)) if (node.network.not_a_peer (nano::transport::map_tcp_to_endpoint (endpoint), node.config.allow_local_peers))
{ {
node.stats.inc (nano::stat::type::tcp_channels_rejected, nano::stat::detail::not_a_peer); node.stats.inc (nano::stat::type::tcp_channels_rejected, nano::stat::detail::not_a_peer);
node.logger.debug (nano::log::type::tcp_channels, "Rejected invalid endpoint channel: {}", fmt::streamed (endpoint)); node.logger.debug (nano::log::type::tcp_channels, "Rejected invalid endpoint channel: {}", endpoint);
return false; // Reject return false; // Reject
} }
@ -76,7 +76,7 @@ bool nano::transport::tcp_channels::check (const nano::tcp_endpoint & endpoint,
if (has_duplicate) if (has_duplicate)
{ {
node.stats.inc (nano::stat::type::tcp_channels_rejected, nano::stat::detail::channel_duplicate); node.stats.inc (nano::stat::type::tcp_channels_rejected, nano::stat::detail::channel_duplicate);
node.logger.debug (nano::log::type::tcp_channels, "Rejected duplicate channel: {} ({})", fmt::streamed (endpoint), node_id.to_node_id ()); node.logger.debug (nano::log::type::tcp_channels, "Rejected duplicate channel: {} ({})", endpoint, node_id.to_node_id ());
return false; // Reject return false; // Reject
} }
@ -100,7 +100,7 @@ std::shared_ptr<nano::transport::tcp_channel> nano::transport::tcp_channels::cre
if (!check (endpoint, node_id)) if (!check (endpoint, node_id))
{ {
node.stats.inc (nano::stat::type::tcp_channels, nano::stat::detail::channel_rejected); node.stats.inc (nano::stat::type::tcp_channels, nano::stat::detail::channel_rejected);
node.logger.debug (nano::log::type::tcp_channels, "Rejected channel: {} ({})", fmt::streamed (endpoint), node_id.to_node_id ()); node.logger.debug (nano::log::type::tcp_channels, "Rejected channel: {} ({})", endpoint, node_id.to_node_id ());
// Rejection reason should be logged earlier // Rejection reason should be logged earlier
return nullptr; return nullptr;
@ -108,7 +108,7 @@ std::shared_ptr<nano::transport::tcp_channel> nano::transport::tcp_channels::cre
node.stats.inc (nano::stat::type::tcp_channels, nano::stat::detail::channel_accepted); node.stats.inc (nano::stat::type::tcp_channels, nano::stat::detail::channel_accepted);
node.logger.debug (nano::log::type::tcp_channels, "Accepted channel: {} ({}) ({})", node.logger.debug (nano::log::type::tcp_channels, "Accepted channel: {} ({}) ({})",
fmt::streamed (socket->remote_endpoint ()), socket->remote_endpoint (),
to_string (socket->endpoint_type ()), to_string (socket->endpoint_type ()),
node_id.to_node_id ()); node_id.to_node_id ());

10
nano/node/transport/tcp_listener.cpp
View file

@ -58,7 +58,7 @@ void nano::transport::tcp_listener::start ()
local = acceptor.local_endpoint (); local = acceptor.local_endpoint ();
} }
logger.debug (nano::log::type::tcp_listener, "Listening for incoming connections on: {}", fmt::streamed (acceptor.local_endpoint ())); logger.debug (nano::log::type::tcp_listener, "Listening for incoming connections on: {}", acceptor.local_endpoint ());
} }
catch (boost::system::system_error const & ex) catch (boost::system::system_error const & ex)
{ {
@ -286,7 +286,7 @@ auto nano::transport::tcp_listener::connect_impl (asio::ip::tcp::endpoint endpoi
if (result.result == accept_result::accepted) if (result.result == accept_result::accepted)
{ {
stats.inc (nano::stat::type::tcp_listener, nano::stat::detail::connect_success, nano::stat::dir::out); stats.inc (nano::stat::type::tcp_listener, nano::stat::detail::connect_success, nano::stat::dir::out);
logger.debug (nano::log::type::tcp_listener, "Successfully connected to: {}", fmt::streamed (endpoint)); logger.debug (nano::log::type::tcp_listener, "Successfully connected to: {}", endpoint);
release_assert (result.server); release_assert (result.server);
result.server->initiate_handshake (); result.server->initiate_handshake ();
@ -300,7 +300,7 @@ auto nano::transport::tcp_listener::connect_impl (asio::ip::tcp::endpoint endpoi
catch (boost::system::system_error const & ex) catch (boost::system::system_error const & ex)
{ {
stats.inc (nano::stat::type::tcp_listener, nano::stat::detail::connect_error, nano::stat::dir::out); stats.inc (nano::stat::type::tcp_listener, nano::stat::detail::connect_error, nano::stat::dir::out);
logger.log (nano::log::level::debug, nano::log::type::tcp_listener, "Error connecting to: {} ({})", fmt::streamed (endpoint), ex.what ()); logger.log (nano::log::level::debug, nano::log::type::tcp_listener, "Error connecting to: {} ({})", endpoint, ex.what ());
} }
} }
@ -387,7 +387,7 @@ auto nano::transport::tcp_listener::accept_one (asio::ip::tcp::socket raw_socket
if (auto result = check_limits (remote_endpoint.address (), type); result != accept_result::accepted) if (auto result = check_limits (remote_endpoint.address (), type); result != accept_result::accepted)
{ {
stats.inc (nano::stat::type::tcp_listener, nano::stat::detail::accept_rejected, to_stat_dir (type)); stats.inc (nano::stat::type::tcp_listener, nano::stat::detail::accept_rejected, to_stat_dir (type));
logger.debug (nano::log::type::tcp_listener, "Rejected connection from: {} ({})", fmt::streamed (remote_endpoint), to_string (type)); logger.debug (nano::log::type::tcp_listener, "Rejected connection from: {} ({})", remote_endpoint, to_string (type));
// Rejection reason should be logged earlier // Rejection reason should be logged earlier
try try
@ -406,7 +406,7 @@ auto nano::transport::tcp_listener::accept_one (asio::ip::tcp::socket raw_socket
} }
stats.inc (nano::stat::type::tcp_listener, nano::stat::detail::accept_success, to_stat_dir (type)); stats.inc (nano::stat::type::tcp_listener, nano::stat::detail::accept_success, to_stat_dir (type));
logger.debug (nano::log::type::tcp_listener, "Accepted connection: {} ({})", fmt::streamed (remote_endpoint), to_string (type)); logger.debug (nano::log::type::tcp_listener, "Accepted connection: {} ({})", remote_endpoint, to_string (type));
auto socket = std::make_shared<nano::transport::tcp_socket> (node, std::move (raw_socket), remote_endpoint, local_endpoint, to_socket_endpoint (type)); auto socket = std::make_shared<nano::transport::tcp_socket> (node, std::move (raw_socket), remote_endpoint, local_endpoint, to_socket_endpoint (type));
auto server = std::make_shared<nano::transport::tcp_server> (socket, node.shared (), true); auto server = std::make_shared<nano::transport::tcp_server> (socket, node.shared (), true);

38
nano/node/transport/tcp_server.cpp
View file

@ -33,7 +33,7 @@ nano::transport::tcp_server::~tcp_server ()
return; return;
} }
node->logger.debug (nano::log::type::tcp_server, "Exiting server: {}", fmt::streamed (remote_endpoint)); node->logger.debug (nano::log::type::tcp_server, "Exiting server: {}", remote_endpoint);
stop (); stop ();
} }
@ -53,7 +53,7 @@ void nano::transport::tcp_server::start ()
return; return;
} }
node->logger.debug (nano::log::type::tcp_server, "Starting server: {}", fmt::streamed (remote_endpoint)); node->logger.debug (nano::log::type::tcp_server, "Starting server: {}", remote_endpoint);
receive_message (); receive_message ();
} }
@ -86,7 +86,7 @@ void nano::transport::tcp_server::receive_message ()
node->logger.debug (nano::log::type::tcp_server, "Error reading message: {}, status: {} ({})", node->logger.debug (nano::log::type::tcp_server, "Error reading message: {}, status: {} ({})",
ec.message (), ec.message (),
to_string (this_l->message_deserializer->status), to_string (this_l->message_deserializer->status),
fmt::streamed (this_l->remote_endpoint)); this_l->remote_endpoint);
this_l->stop (); this_l->stop ();
} }
@ -134,7 +134,7 @@ void nano::transport::tcp_server::received_message (std::unique_ptr<nano::messag
{ {
node->logger.debug (nano::log::type::tcp_server, "Error deserializing message: {} ({})", node->logger.debug (nano::log::type::tcp_server, "Error deserializing message: {} ({})",
to_string (message_deserializer->status), to_string (message_deserializer->status),
fmt::streamed (remote_endpoint)); remote_endpoint);
} }
break; break;
} }
@ -193,7 +193,7 @@ auto nano::transport::tcp_server::process_message (std::unique_ptr<nano::message
case handshake_status::abort: case handshake_status::abort:
{ {
node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_abort); node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_abort);
node->logger.debug (nano::log::type::tcp_server, "Aborting handshake: {} ({})", to_string (message->type ()), fmt::streamed (remote_endpoint)); node->logger.debug (nano::log::type::tcp_server, "Aborting handshake: {} ({})", to_string (message->type ()), remote_endpoint);
return process_result::abort; return process_result::abort;
} }
@ -212,7 +212,7 @@ auto nano::transport::tcp_server::process_message (std::unique_ptr<nano::message
if (!success) if (!success)
{ {
node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_error); node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_error);
node->logger.debug (nano::log::type::tcp_server, "Error switching to bootstrap mode: {} ({})", to_string (message->type ()), fmt::streamed (remote_endpoint)); node->logger.debug (nano::log::type::tcp_server, "Error switching to bootstrap mode: {} ({})", to_string (message->type ()), remote_endpoint);
return process_result::abort; // Switch failed, abort return process_result::abort; // Switch failed, abort
} }
@ -276,21 +276,21 @@ auto nano::transport::tcp_server::process_handshake (nano::node_id_handshake con
if (node->flags.disable_tcp_realtime) if (node->flags.disable_tcp_realtime)
{ {
node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_error); node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_error);
node->logger.debug (nano::log::type::tcp_server, "Handshake attempted with disabled realtime mode ({})", fmt::streamed (remote_endpoint)); node->logger.debug (nano::log::type::tcp_server, "Handshake attempted with disabled realtime mode ({})", remote_endpoint);
return handshake_status::abort; return handshake_status::abort;
} }
if (!message.query && !message.response) if (!message.query && !message.response)
{ {
node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_error); node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_error);
node->logger.debug (nano::log::type::tcp_server, "Invalid handshake message received ({})", fmt::streamed (remote_endpoint)); node->logger.debug (nano::log::type::tcp_server, "Invalid handshake message received ({})", remote_endpoint);
return handshake_status::abort; return handshake_status::abort;
} }
if (message.query && handshake_received) // Second handshake message should be a response only if (message.query && handshake_received) // Second handshake message should be a response only
{ {
node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_error); node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_error);
node->logger.debug (nano::log::type::tcp_server, "Detected multiple handshake queries ({})", fmt::streamed (remote_endpoint)); node->logger.debug (nano::log::type::tcp_server, "Detected multiple handshake queries ({})", remote_endpoint);
return handshake_status::abort; return handshake_status::abort;
} }
@ -300,7 +300,7 @@ auto nano::transport::tcp_server::process_handshake (nano::node_id_handshake con
node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::node_id_handshake, nano::stat::dir::in); node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::node_id_handshake, nano::stat::dir::in);
node->logger.debug (nano::log::type::tcp_server, "Handshake message received: {} ({})", node->logger.debug (nano::log::type::tcp_server, "Handshake message received: {} ({})",
message.query ? (message.response ? "query + response" : "query") : (message.response ? "response" : "none"), message.query ? (message.response ? "query + response" : "query") : (message.response ? "response" : "none"),
fmt::streamed (remote_endpoint)); remote_endpoint);
if (message.query) if (message.query)
{ {
@ -320,7 +320,7 @@ auto nano::transport::tcp_server::process_handshake (nano::node_id_handshake con
else else
{ {
node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_error); node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_error);
node->logger.debug (nano::log::type::tcp_server, "Error switching to realtime mode ({})", fmt::streamed (remote_endpoint)); node->logger.debug (nano::log::type::tcp_server, "Error switching to realtime mode ({})", remote_endpoint);
return handshake_status::abort; return handshake_status::abort;
} }
@ -328,7 +328,7 @@ auto nano::transport::tcp_server::process_handshake (nano::node_id_handshake con
else else
{ {
node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_response_invalid); node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_response_invalid);
node->logger.debug (nano::log::type::tcp_server, "Invalid handshake response received ({})", fmt::streamed (remote_endpoint)); node->logger.debug (nano::log::type::tcp_server, "Invalid handshake response received ({})", remote_endpoint);
return handshake_status::abort; return handshake_status::abort;
} }
@ -348,7 +348,7 @@ void nano::transport::tcp_server::initiate_handshake ()
auto query = node->network.prepare_handshake_query (nano::transport::map_tcp_to_endpoint (remote_endpoint)); auto query = node->network.prepare_handshake_query (nano::transport::map_tcp_to_endpoint (remote_endpoint));
nano::node_id_handshake message{ node->network_params.network, query }; nano::node_id_handshake message{ node->network_params.network, query };
node->logger.debug (nano::log::type::tcp_server, "Initiating handshake query ({})", fmt::streamed (remote_endpoint)); node->logger.debug (nano::log::type::tcp_server, "Initiating handshake query ({})", remote_endpoint);
auto shared_const_buffer = message.to_shared_const_buffer (); auto shared_const_buffer = message.to_shared_const_buffer ();
socket->async_write (shared_const_buffer, [this_l = shared_from_this ()] (boost::system::error_code const & ec, std::size_t size_a) { socket->async_write (shared_const_buffer, [this_l = shared_from_this ()] (boost::system::error_code const & ec, std::size_t size_a) {
@ -360,7 +360,7 @@ void nano::transport::tcp_server::initiate_handshake ()
if (ec) if (ec)
{ {
node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_network_error); node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_network_error);
node->logger.debug (nano::log::type::tcp_server, "Error sending handshake query: {} ({})", ec.message (), fmt::streamed (this_l->remote_endpoint)); node->logger.debug (nano::log::type::tcp_server, "Error sending handshake query: {} ({})", ec.message (), this_l->remote_endpoint);
// Stop invalid handshake // Stop invalid handshake
this_l->stop (); this_l->stop ();
@ -385,7 +385,7 @@ void nano::transport::tcp_server::send_handshake_response (nano::node_id_handsha
auto own_query = node->network.prepare_handshake_query (nano::transport::map_tcp_to_endpoint (remote_endpoint)); auto own_query = node->network.prepare_handshake_query (nano::transport::map_tcp_to_endpoint (remote_endpoint));
nano::node_id_handshake handshake_response{ node->network_params.network, own_query, response }; nano::node_id_handshake handshake_response{ node->network_params.network, own_query, response };
node->logger.debug (nano::log::type::tcp_server, "Responding to handshake ({})", fmt::streamed (remote_endpoint)); node->logger.debug (nano::log::type::tcp_server, "Responding to handshake ({})", remote_endpoint);
auto shared_const_buffer = handshake_response.to_shared_const_buffer (); auto shared_const_buffer = handshake_response.to_shared_const_buffer ();
socket->async_write (shared_const_buffer, [this_l = shared_from_this ()] (boost::system::error_code const & ec, std::size_t size_a) { socket->async_write (shared_const_buffer, [this_l = shared_from_this ()] (boost::system::error_code const & ec, std::size_t size_a) {
@ -397,7 +397,7 @@ void nano::transport::tcp_server::send_handshake_response (nano::node_id_handsha
if (ec) if (ec)
{ {
node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_network_error); node->stats.inc (nano::stat::type::tcp_server, nano::stat::detail::handshake_network_error);
node->logger.debug (nano::log::type::tcp_server, "Error sending handshake response: {} ({})", ec.message (), fmt::streamed (this_l->remote_endpoint)); node->logger.debug (nano::log::type::tcp_server, "Error sending handshake response: {} ({})", ec.message (), this_l->remote_endpoint);
// Stop invalid handshake // Stop invalid handshake
this_l->stop (); this_l->stop ();
@ -551,7 +551,7 @@ void nano::transport::tcp_server::timeout ()
} }
if (socket->has_timed_out ()) if (socket->has_timed_out ())
{ {
node->logger.debug (nano::log::type::tcp_server, "Closing TCP server due to timeout ({})", fmt::streamed (remote_endpoint)); node->logger.debug (nano::log::type::tcp_server, "Closing TCP server due to timeout ({})", remote_endpoint);
socket->close (); socket->close ();
} }
@ -600,7 +600,7 @@ bool nano::transport::tcp_server::to_bootstrap_connection ()
socket->type_set (nano::transport::socket_type::bootstrap); socket->type_set (nano::transport::socket_type::bootstrap);
node->logger.debug (nano::log::type::tcp_server, "Switched to bootstrap mode ({})", fmt::streamed (remote_endpoint)); node->logger.debug (nano::log::type::tcp_server, "Switched to bootstrap mode ({})", remote_endpoint);
return true; return true;
} }
@ -630,7 +630,7 @@ bool nano::transport::tcp_server::to_realtime_connection (nano::account const &
socket->type_set (nano::transport::socket_type::realtime); socket->type_set (nano::transport::socket_type::realtime);
node->logger.debug (nano::log::type::tcp_server, "Switched to realtime mode ({})", fmt::streamed (remote_endpoint)); node->logger.debug (nano::log::type::tcp_server, "Switched to realtime mode ({})", remote_endpoint);
return true; return true;
} }

11
nano/node/transport/tcp_socket.cpp
View file

@ -83,10 +83,7 @@ void nano::transport::tcp_socket::async_connect (nano::tcp_endpoint const & endp
boost::system::error_code ec; boost::system::error_code ec;
this_l->local = this_l->raw_socket.local_endpoint (ec); this_l->local = this_l->raw_socket.local_endpoint (ec);
} }
node_l->logger.debug (nano::log::type::tcp_socket, "Successfully connected to: {}, local: {}", this_l->remote, this_l->local);
node_l->logger.debug (nano::log::type::tcp_socket, "Successfully connected to: {}, local: {}",
fmt::streamed (this_l->remote),
fmt::streamed (this_l->local));
} }
callback (ec); callback (ec);
})); }));
@ -318,7 +315,7 @@ void nano::transport::tcp_socket::ongoing_checkup ()
if (condition_to_disconnect) if (condition_to_disconnect)
{ {
// TODO: Stats // TODO: Stats
node_l->logger.debug (nano::log::type::tcp_socket, "Socket timeout, closing: {}", fmt::streamed (this_l->remote)); node_l->logger.debug (nano::log::type::tcp_socket, "Socket timeout, closing: {}", this_l->remote);
this_l->timed_out = true; this_l->timed_out = true;
this_l->close (); this_l->close ();
} }
@ -395,13 +392,13 @@ void nano::transport::tcp_socket::close_internal ()
{ {
node_l->stats.inc (nano::stat::type::socket, nano::stat::detail::error_socket_close); node_l->stats.inc (nano::stat::type::socket, nano::stat::detail::error_socket_close);
node_l->logger.error (nano::log::type::tcp_socket, "Failed to close socket gracefully: {} ({})", node_l->logger.error (nano::log::type::tcp_socket, "Failed to close socket gracefully: {} ({})",
fmt::streamed (remote), remote,
ec.message ()); ec.message ());
} }
else else
{ {
// TODO: Stats // TODO: Stats
node_l->logger.debug (nano::log::type::tcp_socket, "Closed socket: {}", fmt::streamed (remote)); node_l->logger.debug (nano::log::type::tcp_socket, "Closed socket: {}", remote);
} }
} }

2
nano/rpc/rpc.cpp
View file

@ -45,7 +45,7 @@ void nano::rpc::start ()
logger.critical (nano::log::type::rpc, "Error while binding for RPC on port: {} ({})", endpoint.port (), ec.message ()); logger.critical (nano::log::type::rpc, "Error while binding for RPC on port: {} ({})", endpoint.port (), ec.message ());
throw std::runtime_error (ec.message ()); throw std::runtime_error (ec.message ());
} }
logger.info (nano::log::type::rpc, "RPC listening address: {}", fmt::streamed (acceptor.local_endpoint ())); logger.info (nano::log::type::rpc, "RPC listening address: {}", acceptor.local_endpoint ());
acceptor.listen (); acceptor.listen ();
accept (); accept ();
} }