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

This renames bootstrap_server_type to socket::type and moves the type declaration on to the socket class since this is a socket-related property, not necessarily related to bootstrapping. (#3350)

Browse source
This commit is contained in:
clemahieu 2021-06-22 14:43:11 +02:00 • committed by GitHub
commit b6dcf1de54
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
6 changed files with 26 additions and 27 deletions
Download patch file Download diff file Expand all files Collapse all files

20
nano/node/bootstrap/bootstrap_server.cpp
View file

@ -111,11 +111,11 @@ nano::bootstrap_server::~bootstrap_server ()
{
node->logger.try_log ("Exiting incoming TCP/bootstrap server");
}
if (type == nano::bootstrap_server_type::bootstrap)
if (type == nano::socket::type_t::bootstrap)
{
--node->bootstrap.bootstrap_count;
}
else if (type == nano::bootstrap_server_type::realtime)
else if (type == nano::socket::type_t::realtime)
{
--node->bootstrap.realtime_count;
// Clear temporary channel
@ -524,7 +524,7 @@ void nano::bootstrap_server::receive_node_id_handshake_action (boost::system::er
auto request (std::make_unique<nano::node_id_handshake> (error, stream, header_a));
if (!error)
{
if (type == nano::bootstrap_server_type::undefined && !node->flags.disable_tcp_realtime)
if (type == nano::socket::type_t::undefined && !node->flags.disable_tcp_realtime)
{
add_request (std::unique_ptr<nano::message> (request.release ()));
}
@ -696,7 +696,7 @@ public:
if (!connection->node->network.syn_cookies.validate (nano::transport::map_tcp_to_endpoint (connection->remote_endpoint), node_id, message_a.response->second) && node_id != connection->node->node_id.pub)
{
connection->remote_node_id = node_id;
connection->type = nano::bootstrap_server_type::realtime;
connection->type = nano::socket::type_t::realtime;
++connection->node->bootstrap.realtime_count;
connection->finish_request_async ();
}
@ -711,8 +711,8 @@ public:
connection->finish_request_async ();
}
nano::account node_id (connection->remote_node_id);
nano::bootstrap_server_type type (connection->type);
debug_assert (node_id.is_zero () || type == nano::bootstrap_server_type::realtime);
nano::socket::type_t type (connection->type);
debug_assert (node_id.is_zero () || type == nano::socket::type_t::realtime);
connection->node->network.tcp_message_manager.put_message (nano::tcp_message_item{ std::make_shared<nano::node_id_handshake> (message_a), connection->remote_endpoint, connection->remote_node_id, connection->socket, connection->type });
}
std::shared_ptr<nano::bootstrap_server> connection;
@ -753,15 +753,15 @@ void nano::bootstrap_server::run_next (nano::unique_lock<nano::mutex> & lock_a)
bool nano::bootstrap_server::is_bootstrap_connection ()
{
if (type == nano::bootstrap_server_type::undefined && !node->flags.disable_bootstrap_listener && node->bootstrap.bootstrap_count < node->config.bootstrap_connections_max)
if (type == nano::socket::type_t::undefined && !node->flags.disable_bootstrap_listener && node->bootstrap.bootstrap_count < node->config.bootstrap_connections_max)
{
++node->bootstrap.bootstrap_count;
type = nano::bootstrap_server_type::bootstrap;
type = nano::socket::type_t::bootstrap;
}
return type == nano::bootstrap_server_type::bootstrap;
return type == nano::socket::type_t::bootstrap;
}
bool nano::bootstrap_server::is_realtime_connection ()
{
return type == nano::bootstrap_server_type::realtime || type == nano::bootstrap_server_type::realtime_response_server;
return type == nano::socket::type_t::realtime || type == nano::socket::type_t::realtime_response_server;
}

9
nano/node/bootstrap/bootstrap_server.hpp
View file

@ -34,13 +34,6 @@ private:
std::unique_ptr<container_info_component> collect_container_info (bootstrap_listener & bootstrap_listener, std::string const & name);
class message;
enum class bootstrap_server_type
{
undefined,
bootstrap,
realtime,
realtime_response_server // special type for tcp channel response server
};
class bootstrap_server final : public std::enable_shared_from_this<nano::bootstrap_server>
{
public:
@ -71,7 +64,7 @@ public:
nano::mutex mutex;
std::queue<std::unique_ptr<nano::message>> requests;
std::atomic<bool> stopped{ false };
std::atomic<nano::bootstrap_server_type> type{ nano::bootstrap_server_type::undefined };
std::atomic<nano::socket::type_t> type{ nano::socket::type_t::undefined };
// Remote enpoint used to remove response channel even after socket closing
nano::tcp_endpoint remote_endpoint{ boost::asio::ip::address_v6::any (), 0 };
nano::account remote_node_id{ 0 };

2
nano/node/network.cpp
View file

@ -925,7 +925,7 @@ nano::tcp_message_item nano::tcp_message_manager::get_message ()
}
else
{
result = nano::tcp_message_item{ std::make_shared<nano::keepalive> (), nano::tcp_endpoint (boost::asio::ip::address_v6::any (), 0), 0, nullptr, nano::bootstrap_server_type::undefined };
result = nano::tcp_message_item{ std::make_shared<nano::keepalive> (), nano::tcp_endpoint (boost::asio::ip::address_v6::any (), 0), 0, nullptr, nano::socket::type_t::undefined };
}
lock.unlock ();
producer_condition.notify_one ();

7
nano/node/socket.hpp
View file

@ -33,6 +33,13 @@ class socket : public std::enable_shared_from_this<nano::socket>
friend class server_socket;
public:
enum class type_t
{
undefined,
bootstrap,
realtime,
realtime_response_server // special type for tcp channel response server
};
/**
* Constructor
* @param node Owning node

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

@ -288,7 +288,7 @@ void nano::transport::tcp_channels::process_messages ()
}
}
void nano::transport::tcp_channels::process_message (nano::message const & message_a, nano::tcp_endpoint const & endpoint_a, nano::account const & node_id_a, std::shared_ptr<nano::socket> const & socket_a, nano::bootstrap_server_type type_a)
void nano::transport::tcp_channels::process_message (nano::message const & message_a, nano::tcp_endpoint const & endpoint_a, nano::account const & node_id_a, std::shared_ptr<nano::socket> const & socket_a, nano::socket::type_t type_a)
{
if (!stopped && message_a.header.version_using >= protocol_constants ().protocol_version_min ())
{
@ -315,9 +315,9 @@ void nano::transport::tcp_channels::process_message (nano::message const & messa
temporary_channel->set_node_id (node_id_a);
temporary_channel->set_network_version (message_a.header.version_using);
temporary_channel->temporary = true;
debug_assert (type_a == nano::bootstrap_server_type::realtime || type_a == nano::bootstrap_server_type::realtime_response_server);
debug_assert (type_a == nano::socket::type_t::realtime || type_a == nano::socket::type_t::realtime_response_server);
// Don't insert temporary channels for response_server
if (type_a == nano::bootstrap_server_type::realtime)
if (type_a == nano::socket::type_t::realtime)
{
insert (temporary_channel, socket_a, nullptr);
}
@ -327,7 +327,7 @@ void nano::transport::tcp_channels::process_message (nano::message const & messa
{
// Initial node_id_handshake request without node ID
debug_assert (message_a.header.type == nano::message_type::node_id_handshake);
debug_assert (type_a == nano::bootstrap_server_type::undefined);
debug_assert (type_a == nano::socket::type_t::undefined);
node.stats.inc (nano::stat::type::message, nano::stat::detail::node_id_handshake, nano::stat::dir::in);
}
}
@ -691,7 +691,7 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptr<n
callback_a (channel_a);
}
// Listen for possible responses
response_server->type = nano::bootstrap_server_type::realtime_response_server;
response_server->type = nano::socket::type_t::realtime_response_server;
response_server->remote_node_id = channel_a->get_node_id ();
response_server->receive ();
node_l->network.tcp_channels.remove_node_id_handshake_socket (socket_l);

5
nano/node/transport/tcp.hpp
View file

@ -17,7 +17,6 @@ namespace mi = boost::multi_index;
namespace nano
{
class bootstrap_server;
enum class bootstrap_server_type;
class tcp_message_item final
{
public:
@ -25,7 +24,7 @@ public:
nano::tcp_endpoint endpoint;
nano::account node_id;
std::shared_ptr<nano::socket> socket;
nano::bootstrap_server_type type;
nano::socket::type_t type;
};
namespace transport
{
@ -93,7 +92,7 @@ namespace transport
void start ();
void stop ();
void process_messages ();
void process_message (nano::message const &, nano::tcp_endpoint const &, nano::account const &, std::shared_ptr<nano::socket> const &, nano::bootstrap_server_type);
void process_message (nano::message const &, nano::tcp_endpoint const &, nano::account const &, std::shared_ptr<nano::socket> const &, nano::socket::type_t);
bool max_ip_connections (nano::tcp_endpoint const &);
// Should we reach out to this endpoint with a keepalive message
bool reachout (nano::endpoint const &);