aboutsummaryrefslogtreecommitdiffstats
path: root/src/transport/mod.rs
diff options
context:
space:
mode:
authortv <tv@krebsco.de>2026-11-19 17:44:03 +0000
committertv <tv@krebsco.de>2026-11-19 19:26:01 +0100
commit59e889254b1fda2dcc8e3e6d596635d1b77f589f (patch)
tree2412dd262e7ae729498eb3300912395b601cd0b6 /src/transport/mod.rs
parent180aba9ff89a4a294e284aa281d96adbcfe1b85b (diff)
transport: wire versions spoken side by side
A build speaks wire versions OLDEST to VERSION and writes each node the newest both speak (wire::choose), as the node's SPEAKS says; the oldest until it says. The identity layer keeps that per address (Book::speaks): a SPEAKS from an address sets it for the address, and for every address of the node proven there, and a new address of a node takes it over. Paths encodes each message for an address in its version (Transport::encode_in; Transport::encode is the newest). So that two nodes know what the other speaks once they have proven themselves to each other, before any other message goes between them, a SPEAKS goes ahead of every WHO and ME, and WHO and ME are read in every version from 52 on (wire::PROOFS): their tags and layout never change. Without that, a node whose oldest version is past the other's couldn't read its proofs, and the two would never get to the handshake that says what each speaks. A SPEAKS naming no version this build speaks is logged as a message of another version is, naming the node to upgrade, the versions as ranges. A 0.0.1 node takes a SPEAKS from an address not yet proven for any other message from there: it drops it, and asks WHO. This build speaks 52 alone, so nothing it sends changes but the SPEAKS ahead of the proofs. A release adding a version encodes and decodes the older ones from their own, frozen, types.
Diffstat (limited to 'src/transport/mod.rs')
-rw-r--r--src/transport/mod.rs18
1 files changed, 15 insertions, 3 deletions
diff --git a/src/transport/mod.rs b/src/transport/mod.rs
index 7bc6ae0..ee63988 100644
--- a/src/transport/mod.rs
+++ b/src/transport/mod.rs
@@ -261,8 +261,9 @@ pub(crate) enum ParsedMessage {
/// SPEAKS: the wire versions the sender speaks, the oldest and the newest, and the
/// newest revision of the federation it knows, by ID, where it is built with the
-/// federation. Sent with every handshake, in a layout no build changes (`wire::SPEAKS`):
-/// a build that doesn't know it ignores it, as a message of another wire version.
+/// federation. Sent with every handshake, and ahead of every WHO and ME
+/// (`transport::identity`), in a layout no build changes (`wire::SPEAKS`): a build that
+/// doesn't know it ignores it, as a message of another wire version.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct Speaks {
pub(crate) oldest: u8,
@@ -1198,7 +1199,18 @@ pub(crate) trait Transport: Send + Sync {
/// identity, as `local_id` gives it on that node.
async fn resolve_seed(&self, seed: &str) -> Result<String>;
- fn encode(&self, peer: &str, message: &ParsedMessage) -> Result<EncodedMessage>;
+ /// `message` to `peer` in wire `version`, one this build speaks (`wire::OLDEST..=
+ /// wire::VERSION`). The identity layer writes to each node in the newest version both
+ /// speak, whatever is asked (`Paths::version_at`).
+ fn encode_in(&self, peer: &str, message: &ParsedMessage, version: u8)
+ -> Result<EncodedMessage>;
+
+ /// `message` to `peer` in the newest wire version; under the identity layer, in the one
+ /// `peer` speaks.
+ fn encode(&self, peer: &str, message: &ParsedMessage) -> Result<EncodedMessage> {
+ self.encode_in(peer, message, wire::VERSION)
+ }
+
async fn send_encoded(&self, message: &EncodedMessage) -> Result<()>;
/// Sends an outbound message payload to a targeted peer on a specific topic.