1use super::*;
4use std::sync::atomic::{AtomicU64, Ordering};
5use tokio::sync::oneshot;
6
7pub(super) const ALPN: &[u8] = b"data-fabric/control/1";
8pub(super) const CONTROL_TIMEOUT: Duration = Duration::from_secs(30);
10const MAX_REQUEST: usize = 32 * 1024;
11pub const MAX_CONTROL_REPLY: usize = MAX_FRAME;
13
14pub type InquiryResponder = Arc<dyn Fn(PeerId, &[u8]) -> Option<Vec<u8>> + Send + Sync>;
20
21#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, serde::Serialize)]
23pub struct Timing {
24 pub count: u64,
25 pub total_us: u64,
26 pub max_us: u64,
27}
28
29#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, serde::Serialize)]
33pub struct ControlTiming {
34 pub inquiry: Timing,
35 pub host_wait: Timing,
36 pub host_service: Timing,
37}
38
39#[derive(Default)]
40struct Series {
41 count: AtomicU64,
42 total_us: AtomicU64,
43 max_us: AtomicU64,
44}
45impl Series {
46 fn add(&self, elapsed: Duration) {
47 let us = elapsed.as_micros().min(u64::MAX as u128) as u64;
48 self.count.fetch_add(1, Ordering::Relaxed);
49 self.total_us.fetch_add(us, Ordering::Relaxed);
50 self.max_us.fetch_max(us, Ordering::Relaxed);
51 }
52 fn get(&self) -> Timing {
53 Timing {
54 count: self.count.load(Ordering::Relaxed),
55 total_us: self.total_us.load(Ordering::Relaxed),
56 max_us: self.max_us.load(Ordering::Relaxed),
57 }
58 }
59}
60
61#[derive(Default)]
62pub(super) struct TimingCounters {
63 inquiry: Series,
64 host_wait: Series,
65 host_service: Series,
66}
67impl TimingCounters {
68 fn snapshot(&self) -> ControlTiming {
69 ControlTiming {
70 inquiry: self.inquiry.get(),
71 host_wait: self.host_wait.get(),
72 host_service: self.host_service.get(),
73 }
74 }
75}
76
77pub struct ControlRequest {
78 peer: PeerId,
79 remote_address: Option<SocketAddr>,
80 payload: Vec<u8>,
81 reply: oneshot::Sender<Vec<u8>>,
82 timing: Arc<TimingCounters>,
83 queued: std::time::Instant,
84 taken: Option<std::time::Instant>,
85}
86impl ControlRequest {
87 pub fn remote_address(&self) -> Option<SocketAddr> {
90 self.remote_address
91 }
92 pub fn peer(&self) -> PeerId {
93 self.peer
94 }
95 pub fn payload(&self) -> &[u8] {
96 &self.payload
97 }
98 pub fn waited(&self) -> Duration {
100 self.queued.elapsed()
101 }
102
103 pub fn expired(&self) -> bool {
104 self.reply.is_closed()
105 }
106 pub fn respond(self, bytes: Vec<u8>) -> Result<()> {
108 if bytes.len() > MAX_FRAME {
109 return Err(Error::TooLarge);
110 }
111 if let Some(taken) = self.taken {
112 self.timing.host_service.add(taken.elapsed());
113 }
114 self.reply.send(bytes).map_err(|_| Error::Rejected)
115 }
116 fn take(mut self) -> Self {
118 if self.taken.is_none() {
119 self.timing.host_wait.add(self.queued.elapsed());
120 self.taken = Some(std::time::Instant::now());
121 }
122 self
123 }
124}
125
126#[derive(Clone)]
129pub(super) struct ControlInbox {
130 sender: mpsc::Sender<ControlRequest>,
131 signal: Arc<tokio::sync::Notify>,
132 responder: Arc<std::sync::RwLock<Option<InquiryResponder>>>,
133 timing: Arc<TimingCounters>,
134}
135impl ControlInbox {
136 pub(super) fn new(
137 capacity: usize,
138 ) -> (
139 Self,
140 mpsc::Receiver<ControlRequest>,
141 Arc<tokio::sync::Notify>,
142 ) {
143 let (sender, receiver) = mpsc::channel(capacity);
144 let signal = Arc::new(tokio::sync::Notify::new());
145 (
146 Self {
147 sender,
148 signal: signal.clone(),
149 responder: Arc::default(),
150 timing: Arc::default(),
151 },
152 receiver,
153 signal,
154 )
155 }
156 pub(super) fn set_responder(&self, responder: InquiryResponder) {
157 *self
158 .responder
159 .write()
160 .unwrap_or_else(|error| error.into_inner()) = Some(responder);
161 }
162 pub(super) fn timing(&self) -> ControlTiming {
163 self.timing.snapshot()
164 }
165 async fn inquire(&self, peer: PeerId, payload: Vec<u8>) -> (Vec<u8>, Option<Vec<u8>>) {
168 let responder = self
169 .responder
170 .read()
171 .unwrap_or_else(|error| error.into_inner())
172 .clone();
173 let Some(responder) = responder else {
174 return (payload, None);
175 };
176 let started = std::time::Instant::now();
177 let answered = tokio::task::spawn_blocking(move || {
178 let answer = responder(peer, &payload);
179 (payload, answer)
180 })
181 .await;
182 match answered {
183 Ok((payload, answer)) => {
184 if answer.is_some() {
185 self.timing.inquiry.add(started.elapsed());
186 }
187 (payload, answer)
188 }
189 Err(_) => (Vec::new(), Some(Vec::new())),
191 }
192 }
193 fn offer(&self, request: ControlRequest) -> Result<()> {
196 self.sender
197 .try_send(request)
198 .map_err(|_| Error::Backpressure)?;
199 self.signal.notify_one();
200 Ok(())
201 }
202}
203
204async fn settle_on_direct_path(connection: &iroh::endpoint::Connection) {
217 use futures_util::StreamExt;
218 let direct = |paths: &iroh::endpoint::PathList<'_>| {
219 paths.iter().any(|path| path.is_selected() && path.is_ip())
220 };
221 if direct(&connection.paths()) {
222 return;
223 }
224 let mut stream = connection.paths_stream();
225 let switched = tokio::time::timeout(DIRECT_PATH_SETTLE, async {
226 while let Some(paths) = stream.next().await {
227 if direct(&paths) {
228 return true;
229 }
230 }
231 false
232 })
233 .await
234 .unwrap_or(false);
235 if switched {
236 tokio::time::sleep(PATH_SWITCH_GRACE).await;
237 }
238}
239
240const DIRECT_PATH_SETTLE: Duration = Duration::from_millis(750);
241const PATH_SWITCH_GRACE: Duration = Duration::from_millis(250);
242
243pub(super) async fn receive(
244 connection: &iroh::endpoint::Connection,
245 inbox: &ControlInbox,
246 remote_address: Option<SocketAddr>,
247 (send, recv): (
248 &mut iroh::endpoint::SendStream,
249 &mut iroh::endpoint::RecvStream,
250 ),
251) -> Result<()> {
252 tracing::info!(target: "data_fabric_transport", remote = %connection.remote_id(), "CONTROL_ACCEPT_STREAM");
253 let payload = recv.read_to_end(MAX_REQUEST).await.map_err(transport)?;
254 tracing::info!(target: "data_fabric_transport", bytes = payload.len(), "CONTROL_REQUEST_READ");
255 let (reply, response) = oneshot::channel();
256 let settled = settle_on_direct_path(connection);
259 let peer = *connection.remote_id().as_bytes();
260 let (payload, answer) = inbox.inquire(peer, payload).await;
261 let bytes = if let Some(bytes) = answer {
262 if bytes.len() > MAX_FRAME {
263 return Err(Error::TooLarge);
264 }
265 tracing::info!(target: "data_fabric_transport", "CONTROL_INQUIRY_ANSWERED");
266 bytes
267 } else {
268 inbox.offer(ControlRequest {
269 peer,
270 remote_address,
271 payload,
272 reply,
273 timing: inbox.timing.clone(),
274 queued: std::time::Instant::now(),
275 taken: None,
276 })?;
277 tokio::select! {
278 response = response => response.map_err(|_| Error::Rejected)?,
279 _ = send.stopped() => return Err(Error::Rejected),
280 }
281 };
282 settled.await;
283 tracing::info!(target: "data_fabric_transport", bytes = bytes.len(), paths = ?connection.paths(), "CONTROL_REPLY_WRITE");
284 send.write_all(&bytes).await.map_err(transport)?;
285 send.finish().map_err(transport)?;
286 tracing::info!(target: "data_fabric_transport", "CONTROL_REPLY_FINISHED");
287 Ok(())
288}
289
290#[derive(Clone)]
294pub struct ControlClient {
295 connections: super::connections::Connections,
296 control_cancel: watch::Sender<bool>,
297}
298
299impl ControlClient {
300 pub fn request_control(
301 self,
302 peer: PeerId,
303 payload: &[u8],
304 ) -> impl std::future::Future<Output = Result<Vec<u8>>> + Send + 'static {
305 let payload = (payload.len() <= MAX_REQUEST).then(|| payload.to_vec());
306 let connections = self.connections.clone();
307 let mut cancelled = self.control_cancel.subscribe();
308 async move {
309 if *cancelled.borrow() {
310 return Err(Error::Cancelled);
311 }
312 tokio::select! {
313 _ = cancelled.changed() => Err(Error::Cancelled),
314 outcome = async {
315 let payload = payload.ok_or(Error::TooLarge)?;
316 let mut stage = "connect";
317 let mut observed = None;
318 let outcome = tokio::time::timeout(CONTROL_TIMEOUT, async {
319 let connection = tokio::time::timeout(TIMEOUT, connections.connect(peer, ALPN))
320 .await.map_err(|_| Error::Timeout("control connect"))?
321 ?;
322 observed = Some(connection.clone());
323 settle_on_direct_path(&connection).await;
324 stage = "open stream";
325 tracing::info!(target: "data_fabric_transport", paths = ?connection.paths(), "CONTROL_CLIENT_CONNECTED");
326 let (mut send, mut recv) = connection.open_bi().await.map_err(transport)?;
327 stage = "write request";
328 send.write_all(&payload).await.map_err(transport)?;
329 send.finish().map_err(transport)?;
330 stage = "read response";
331 tracing::info!(target: "data_fabric_transport", bytes = payload.len(), "CONTROL_REQUEST_SENT");
332 let reply = recv.read_to_end(MAX_FRAME).await.map_err(transport)?;
333 tracing::info!(target: "data_fabric_transport", bytes = reply.len(), "CONTROL_REPLY_READ");
334 Ok(reply)
335 })
336 .await
337 .map_err(|_| Error::Timeout("control response")).and_then(|result| result);
338 tracing::info!(target: "data_fabric_transport", stage, success = outcome.is_ok(),
339 error = outcome.as_ref().err().map(ToString::to_string), "CONTROL_CLIENT_END");
340 if outcome.is_err()
341 && let Some(connection) = observed
342 {
343 tracing::info!(target: "data_fabric_transport", paths = ?connection.paths(), stats = ?connection.stats(), "CONTROL_CLIENT_FAILURE");
344 }
345 if outcome.is_err() && matches!(stage, "read response" | "write request") {
347 connections.discard(peer, ALPN).await;
348 }
349 match outcome {
352 Err(_) if matches!(stage, "connect" | "open stream") => {
353 Err(Error::ControlNotSent(stage))
354 }
355 other => other,
356 }
357 } => outcome,
358 }
359 }
360 }
361}
362
363impl Node {
364 pub fn control_signal(&self) -> Arc<tokio::sync::Notify> {
369 self.control_signal.clone()
370 }
371
372 pub fn has_deferred_controls(&self) -> bool {
374 !self.deferred_controls.is_empty()
375 }
376
377 pub fn rearm_control_signal(&self) {
380 self.control_signal.notify_one();
381 }
382
383 pub fn poll_control(&mut self) -> Option<ControlRequest> {
384 for _ in 0..8 {
385 let request = self
386 .deferred_controls
387 .pop_front()
388 .or_else(|| self.controls.try_recv().ok())?;
389 if !request.expired() {
390 return Some(request.take());
391 }
392 }
393 None
394 }
395
396 pub fn set_inquiry_responder(&self, responder: InquiryResponder) {
398 self.control_inbox.set_responder(responder);
399 }
400
401 pub fn connection_capacity(&self) -> super::budget::CapacityCounts {
403 self.connections.capacity_counts()
404 }
405
406 pub fn control_timing(&self) -> ControlTiming {
408 self.control_inbox.timing()
409 }
410
411 pub fn poll_control_matching(
415 &mut self,
416 matches: impl Fn(&[u8]) -> bool,
417 ) -> Option<ControlRequest> {
418 self.poll_control_first(matches, 8)
419 }
420
421 pub fn poll_control_first(
425 &mut self,
426 matches: impl Fn(&[u8]) -> bool,
427 depth: usize,
428 ) -> Option<ControlRequest> {
429 let mut scanned = Vec::with_capacity(16);
430 while let Some(request) = self.deferred_controls.pop_front() {
431 scanned.push(request);
432 }
433 for _ in 0..depth {
434 let Ok(request) = self.controls.try_recv() else {
435 break;
436 };
437 scanned.push(request);
438 }
439 let selected = scanned
440 .iter()
441 .position(|request| !request.expired() && matches(request.payload()))
442 .map(|index| scanned.remove(index).take());
443 self.deferred_controls.extend(scanned);
444 selected
445 }
446
447 pub fn control_client(&self) -> ControlClient {
448 ControlClient {
449 connections: self.connections.clone(),
450 control_cancel: self.control_cancel.clone(),
451 }
452 }
453
454 pub fn request_control(
457 &self,
458 peer: PeerId,
459 payload: &[u8],
460 ) -> impl std::future::Future<Output = Result<Vec<u8>>> + Send + 'static {
461 self.control_client().request_control(peer, payload)
462 }
463}