Struct VeloBuilder 

pub struct VeloBuilder { /* private fields */ }

Builder for configuring and creating a Velo instance.

Implementations

impl VeloBuilder

pub fn new() -> Self

Create a new empty builder.

pub fn add_transport(self, transport: Arc<dyn Transport>) -> Self

Add a transport to the system.

pub fn stream_config(self, config: StreamConfig) -> Result<Self>

Set the streaming transport configuration.

Only one transport server is allowed per Velo instance. Returns Err if called more than once on the same builder.

pub fn stream_bind_addr(self, addr: IpAddr) -> Self

Convenience: pin the TCP streaming listener to a single interface IP (instead of the default 0.0.0.0 + multi-interface advertise).

pub fn messenger_mux(self, config: MuxConfig) -> Result<Self>

Install the batched, multiplexed streaming transport (messenger-mux-v1), described in streaming/BATCHING.md.

Opt-in, and the mux is not the default transport. MuxConfig::enabled defaults to false, and calling this with it left false is exactly the same node as not calling it at all: nothing is registered and nothing is advertised.

The legacy transport stays configured either way — a mux-enabled node registers both, and each attach picks between them from what the peer advertised. So a canary is one node with the flag on, talking the mux to other canaries and the legacy path to everything else, and rollback is the same flag: set it back to false and the node stops advertising messenger-mux-v1, so the next attach negotiates the legacy path. No code change, no wire change, and no coordination with peers, because a key that is never advertised is never selected.

Only one mux may be installed per instance — its _stream_batch handler is registered on the messenger for its lifetime and the messenger refuses a duplicate handler name. Calling this twice fails here rather than at the second attach.

pub fn discovery(self, discovery: Arc<dyn PeerDiscovery>) -> Self

Set the peer discovery backend.

pub fn metrics(self, metrics: Arc<VeloMetrics>) -> Self

Install Prometheus collectors for this Velo instance.

pub async fn build(self) -> Result<Arc<Velo>>

Build the Velo system with the configured transports and discovery.

Construction order:

1. Build Messenger (async)
2. Extract WorkerId
3. Resolve the streaming transport from stream_config (default: TCP on 0.0.0.0:0 with multi-interface advertise via WorkerAddress).
4. Merge the streaming transport’s address() into the local PeerInfo’s WorkerAddress (so peers can discover the streaming listener alongside messenger endpoints).
5. Create AnchorManager via builder, with the streaming transport wired in as both the default and the only registry entry (keyed by its TransportKey).
6. Register streaming control-plane handlers on Messenger.
7. Assemble Velo struct, holding a clone of the streaming transport so register_peer can fan out to it on every newly-known peer.

Trait Implementations

impl Default for VeloBuilder

fn default() -> Self

Returns the “default value” for a type.