How do I get a static list of all supported protocols?

[nathanielc]

With the changes in 0.52 its now possible to dynamically get a list of supported protocols. However I am interested (for diagnostic reasons) in getting the union of supported protocols of the local node regardless of if there is an active connection using that protocol.

As far as I can tell the only way to get a list of protocols now is to listen for ConnectionEvent::LocalProtocolsChange events. However this implies that whatever protocol is listening for those events is shared between all connected peers. Otherwise the handler does not get the ConnectionEvent::LocalProtocolsChange events themselves. Do I miss understand?

Is there a way to directly ask a behavior for its static set of protocols? Or maybe a way for the identify behavior to expose the union of all locally supported protocols across all connections?

Preferably I can get this set before even a single connection is made. Thoughts?

[mxinden]

As far as I can tell the only way to get a list of protocols now is to listen for ConnectionEvent::LocalProtocolsChange events. However this implies that whatever protocol is listening for those events is shared between all connected peers. Otherwise the handler does not get the ConnectionEvent::LocalProtocolsChange events themselves. Do I miss understand?

I am not sure this is correct. LocalProtocolsChange is scoped to a connection, i.e. it implies that the local node supports a protocol on the specific connection.

Is there a way to directly ask a behavior for its static set of protocols? Or maybe a way for the identify behavior to expose the union of all locally supported protocols across all connections?

Note that it is not the NetworkBehaviour, but the ConnectionHandler. In other words, it is not the main state machine, but the connection state machine.

Preferably I can get this set before even a single connection is made. Thoughts?

Today, I don't see a way other than implementing your own ConnectionHandler that listens for the local protocol change events only.

[nathanielc]

Note that it is not the NetworkBehaviour, but the ConnectionHandler. In other words, it is not the main state machine, but the connection state machine.

Yeah that makes sense. The reason I asked about it from the Behaviour context is that the Behaviour knows the static set of possible protocols because the behaviour handles calling listen_protocol on each of the connection handlers. I guess the challenge here is the behaviours can dynamically create connection handlers and so its not well defined statically.

Today, I don't see a way other than implementing your own ConnectionHandler that listens for the local protocol change events only.

I tried this, but my testing showed that I didn't get the ConnectionHandler::LocalProtocolsChange event. My assumption is that because my new connection handler was for a protocol that the remote node did not support.

FWIW for now i have hard coded my list of local protocols for diagnostic reasons. I may not even need this in the future. Thanks for confirming that I didn't miss something obvious.

[thomaseizinger]

Note that it is not the NetworkBehaviour, but the ConnectionHandler. In other words, it is not the main state machine, but the connection state machine.

Yeah that makes sense. The reason I asked about it from the Behaviour context is that the Behaviour knows the static set of possible protocols because the behaviour handles calling listen_protocol on each of the connection handlers.

It seems there is a misunderstanding here. NetworkBehaviours and ConnectionHandlers run in separate tasks and they communicate via message-passing. Thus the NetworkBehaviour does not call listen_protocol.

• NetworkBehaviours are composed into a tree (same as deriving serde::Serialize just applies recursively)
• ConnectionHandlers are also composed into a tree
• 1 ConnectionHandler is instantiated per physical connection (i.e. TCP, QUIC, etc). The NetworkBehaviour is tasked with this via handle_{in,out}bound_....
• Once constructed, a new task is spawned into your configured runtime that bridges between the established connection (i.e. StreamMuxer and the ConnectionHandler state machine).

Because a NetworkBehaviour gets to chose on a per connection basis, which ConnectionHandler it returns, there is no such thing as a "static list of supported protocols". At least not generally. It may be that the set of NetworkBehaviours that you use always supports all protocols on all connections but this is not universally true. For example, libp2p::relay will refuse to establish further relayed connections over an existing relayed connection. This is a decision we make on a per-connection basis.

Today, I don't see a way other than implementing your own ConnectionHandler that listens for the local protocol change events only.

I tried this, but my testing showed that I didn't get the ConnectionHandler::LocalProtocolsChange event.

You will receive this event as the very first thing once the connection is established.

My assumption is that because my new connection handler was for a protocol that the remote node did not support.

This assumption is not correct. Unless you have a protocol such as "identify" in place, we have no idea about learning which protocols the remote supports. Certainly, we cannot know this prior to such a protocol executing.

FWIW for now i have hard coded my list of local protocols for diagnostic reasons. I may not even need this in the future. Thanks for confirming that I didn't miss something obvious.

In general, it is best if you don't program against the assumption of a statically supported list of protocols. Each protocol should fail gracefully if the remote doesn't support it. In other words, handle StreamUpgradeError::NegotiationFailed properly. For inbound streams, there is (somewhat obviously) nothing you need to do.

[nathanielc]

Thanks for the detailed explanations.

Yeah I understand the separate tasks and that the Behaviour itself is not calling listen_protocol, I should have been more specific, apologies for the confusion.

And generally we are not programing against a static set of protocols, rather just wanted to expose the set for diagnostics. However its clear that's not a good approach and will likely change the upstream logic accordingly.

I am however still confused about this bit:

Today, I don't see a way other than implementing your own ConnectionHandler that listens for the local protocol change events only.

I tried this, but my testing showed that I didn't get the ConnectionHandler::LocalProtocolsChange event.

You will receive this event as the very first thing once the connection is established.

My assumption is that because my new connection handler was for a protocol that the remote node did not support.

This assumption is not correct. Unless you have a protocol such as "identify" in place, we have no idea about learning which protocols the remote supports. Certainly, we cannot know this prior to such a protocol executing.

I had assumed that my connection handler would not receive ConnectionHandler events if it didn't upgrade the connection for the specific protocol of the handler. Do all connection handlers for a connection receive all events even if the connection is not fully negotiated ?

For example if I have two Behaviours identify and a custom one foo. Assuming all nodes I connect to support identify and only some support foo. Will the local foo connection handlers to remote nodes that do not support foo continue to receive ConnectionHandler::LocalProtocolsChange events?

[thomaseizinger]

For example if I have two Behaviours identify and a custom one foo. Assuming all nodes I connect to support identify and only some support foo. Will the local foo connection handlers to remote nodes that do not support foo continue to receive ConnectionHandler::LocalProtocolsChange events?

All ConnectionHandlers are composed into a tree using ConnectionHandlerSelect:

• ConnectionHandlerSelect
  • identify::Handler
  • foo::Handler

Inbound & outbound streams and events from the behaviour are only delivered to one of the subhandlers. All other events are delivered to all sub handlers, see here:

rust-libp2p/swarm/src/handler/select.rs

Lines 274 to 349 in 577e387

	fn on_connection_event(
	&mut self,
	event: ConnectionEvent<
	Self::InboundProtocol,
	Self::OutboundProtocol,
	Self::InboundOpenInfo,
	Self::OutboundOpenInfo,
	>,
	) {
	match event {
	ConnectionEvent::FullyNegotiatedOutbound(fully_negotiated_outbound) => {
	match fully_negotiated_outbound.transpose() {
	Either::Left(f) => self
	.proto1
	.on_connection_event(ConnectionEvent::FullyNegotiatedOutbound(f)),
	Either::Right(f) => self
	.proto2
	.on_connection_event(ConnectionEvent::FullyNegotiatedOutbound(f)),
	}
	}
	ConnectionEvent::FullyNegotiatedInbound(fully_negotiated_inbound) => {
	match fully_negotiated_inbound.transpose() {
	Either::Left(f) => self
	.proto1
	.on_connection_event(ConnectionEvent::FullyNegotiatedInbound(f)),
	Either::Right(f) => self
	.proto2
	.on_connection_event(ConnectionEvent::FullyNegotiatedInbound(f)),
	}
	}
	ConnectionEvent::AddressChange(address) => {
	self.proto1
	.on_connection_event(ConnectionEvent::AddressChange(AddressChange {
	new_address: address.new_address,
	}));
	self.proto2
	.on_connection_event(ConnectionEvent::AddressChange(AddressChange {
	new_address: address.new_address,
	}));
	}
	ConnectionEvent::DialUpgradeError(dial_upgrade_error) => {
	match dial_upgrade_error.transpose() {
	Either::Left(err) => self
	.proto1
	.on_connection_event(ConnectionEvent::DialUpgradeError(err)),
	Either::Right(err) => self
	.proto2
	.on_connection_event(ConnectionEvent::DialUpgradeError(err)),
	}
	}
	ConnectionEvent::ListenUpgradeError(listen_upgrade_error) => {
	self.on_listen_upgrade_error(listen_upgrade_error)
	}
	ConnectionEvent::LocalProtocolsChange(supported_protocols) => {
	self.proto1
	.on_connection_event(ConnectionEvent::LocalProtocolsChange(
	supported_protocols.clone(),
	));
	self.proto2
	.on_connection_event(ConnectionEvent::LocalProtocolsChange(
	supported_protocols,
	));
	}
	ConnectionEvent::RemoteProtocolsChange(supported_protocols) => {
	self.proto1
	.on_connection_event(ConnectionEvent::RemoteProtocolsChange(
	supported_protocols.clone(),
	));
	self.proto2
	.on_connection_event(ConnectionEvent::RemoteProtocolsChange(
	supported_protocols,
	));
	}
	}
	}

[nathanielc]

Thanks!