| title | name | category | tags | editor | contributors | |||||
|---|---|---|---|---|---|---|---|---|---|---|
REQ-RES-RELIABILITY |
Reliability for request-response protocols |
Standards Track |
|
Oleksandr Kozlov <[email protected]> |
|
This RFC describes a set of instructions used across different WAKU2 implementations for improved reliability during usage of request-response protocols by a light node:
- WAKU2-LIGHTPUSH - is used for sending messages;
- WAKU2-FILTER - is used for receiving messages;
The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in this document are to be interpreted as described in RFC2119.
- Service node - provides services to other nodes such as relaying messages sent by LightPush to the network or service messages from the network through Filter, usually serves responses;
- Light node - connects to and uses one or more service nodes via LightPush and/or Filter protocols, usually sends requests;
- Service node failure - can mean various things depending on the protocol in use:
- generic protocol failure - request is timed out or failed without error codes;
- LightPush specific failure - refer to error codes and consider request a failure when it is clear that service node cannot serve any future request, for example when service node does not have any peers to relay and returns
NO_PEERS_TO_RELAY; - Filter specific failure - we consider service node failing when it cannot serve subscribe or ping request with OK status;
Specifications of the mentioned protocols do not define some of the real world use cases that are often observed in unreliable network environment from the perspective of light nodes that are consumers of LightPush and/or Filter protocols. Such use cases can be: recovery from offline state, decreasing the number of missed messages, increasing the probability of messages being broadcasted within the network, mitigating unreliability of the service node in use.
Node health is a metric meant to determine the connectivity state of a light node and its present ability to reliably send and receive messages from the network. We consider this reliability to be dependent on amount of simultaneous connections to responsive service nodes. Unfortunately the more connections light node establishes - the more bandwidth is consumed. To address this we RECOMMEND following states:
- unhealthy:
- no connections to service nodes are available regardless of protocol;
- minimally healthy:
- Filter has one service node connection AND LightPush protocol has one service node connection;
- sufficiently healthy:
- Filter has at least 2 connections available to service nodes AND LightPush has at least 2 connections available to service nodes;
Overall node health SHOULD be considered as unhealthy or minimally healthy respectively if one of the protocols is unhealthy or minimally healthy, while the other is sufficiently healthy.
Light nodes SHOULD maintain a pool of reliable service nodes for each protocol and have a connection to them. In case service node fails to serve protocol request - light node MAY drop connection to it and replace with a new service node in the pool.
We RECOMMEND to replace service node for LightPush right after first failure in case:
- connection to it is lost or request timed out;
- its response contains error codes:
UNSUPPORTED_PUBSUB_TOPIC,INTERNAL_SERVER_ERRORorNO_PEERS_TO_RELAY; - request failed but without error message returned;
For Filter we'd RECOMMEND replacing service node:
- request for subscription fails;
- ping failed 2 times in a row;
During discovery light node SHOULD filter out service nodes based on preferences before establishing connection. These preferences MAY include:
- Libp2p multiadresses of a service node;
- Waku or libp2p protocols that a service node implements;
- Wakus shards that a service node is part of;
More details about discovery can be found at WAKU2 Discovery domain or RELAY-SHARDING Discovery.
Examples of filtering:
- When light node discovers service nodes that implement needed Waku protocols - it SHOULD prioritize those that implement most recent version of protocol;
- Light node MUST connect only to those service nodes that participate in needed shard and cluster;
- Light node MUST use only those service nodes that implement needed transport protocols;
- When Circuit V2 multi-addresses discovered by a light node - it SHOULD prefer other service nodes that can be connected directly if possible;
Light nodes MUST keep information about service nodes up to date. For example when a service node is discovered second time, we need to be sure to keep connection information up to date in Peer Store.
The following information MUST be up to date:
- ENR information;
- Libp2p multiaddresses;
To improve chances of delivery of messages light node can attempt sending same message via LightPush to 2 or more service nodes at the same time. While doing so it is important to note that bandwidth consumption increases proportionally to amount of additional service nodes used. We RECOMMEND to use 2 service nodes at a time.
When light node sends a message it MUST await for LightPush response from service node and check it for possible error codes.
In case request failed without error code, timed out or response contains errors that can be temporary for service node (e.g TOO_MANY_REQUESTS) -
light node SHOULD try to re-send message after some interval and continue doing so until OK response is received or canceled.
Interval time can be arbitrary but we RECOMMEND starting with 1 second and increasing it on each failure during LightPush send.
Important to note that per another recommendation - light node SHOULD replace failing service node with another within the pool of service nodes used by LightPush.
Light node can verify that network that is used at the moment has seen messages that were sent via LightPush earlier. In order to do that light node SHOULD use Store protocol or Filter protocol to a different service node than the one used for LightPush service node.
By using Store protocol light node can query any service node that implements Store protocol and see if the messages that were sent in the past period were seen. Due to Store message eligibility only some of the messages will be stored so there is a limit as to which messages can be verified by Store queries. We RECOMMEND to do periodic Store queries once per 30 seconds.
By using Filter protocol's active subscription light node can verify that message that was sent through LightPush was seen by another service node in the network. Filter protocol does not have such limitation as to type of messages received with subscription but active subscription does not allow to see messages exchanged in the network while light node was offline.
In case some of the messages were not verified by any of the previous methods - they SHOULD be re-sent by LightPush using different service node.
To ensure that subscription is maintained by a service node and not closed - light node SHOULD do recurring pings. We RECOMMEND for light node to send ping requests once per minute. In case light node does not receive OK response or it times out 2 times - such service node SHOULD be replaced as part of maintenance of pool of reliable service nodes. Right after such replace light node MUST create new subscription to newly connected service node as described in Filter specification.
To mitigate possibility of messages not being delivered by a service node - we RECOMMEND to consider using multiple Filter subscriptions. Light node can initiate two subscriptions to the same content topic but to different service nodes. While receiving messages through two subscriptions - duplicates MUST be dropped by using deterministic message hashing. Note that such approach increases bandwidth consumption proportionally to amount of extra subscriptions established and SHOULD be used with caution.
Network state SHOULD be monitored by light node and in case it goes offline - regular pings MUST be stopped. When network connection returns light node SHOULD initiate Filter ping to service nodes in use. In case those pings fail light node MUST replace service nodes following advice of pool of reliable service nodes without waiting for multiple failures. Note that HistoryQuery can be used if a light node wants to retrieve messages circulated in the network while it was offline.
Copyright and related rights waived via CC0.