snare 2.0.3

Ergonomic in-process network testing on top of snare-interpose: write the code under test against std, describe the peer with a tester builder
Documentation
use super::*;

#[derive(Default)]
pub(super) struct State {
    incoming: [Option<Deadline>; 2],
    incoming_due: [Option<Deadline>; 2],
    return_delays: [Duration; 2],
    rst: [Option<Deadline>; 2],
    rst_due: [Option<Deadline>; 2],
    local_closed: [bool; 2],
    probes: [Option<Arc<ShutdownProbe>>; 2],
}

struct ShutdownProbe {
    conn: std::sync::Weak<Conn>,
    end: End,
}

fn other(end: End) -> End {
    match end {
        End::A => End::B,
        End::B => End::A,
    }
}

impl Conn {
    pub(super) fn progress_tcp_shutdown(&self) {
        if self.pair {
            return;
        }
        let mut arm = [[None; 2]; 2];
        let clock = self.regs.shared.clock.as_deref();
        let mut state = self.mac_shutdown.lock().unwrap();
        loop {
            for end in [End::A, End::B] {
                let i = end.index();
                if let Some(original) = state.incoming[i] {
                    let at = self.write_pipe(end).effective_shutdown_arrival(original);
                    if state.incoming_due[i].is_none_or(|old| old.instant() != at.instant()) {
                        state.incoming_due[i] = Some(at);
                        arm[0][i] = Some(at);
                        if let Some(tap) = &self.tap {
                            tap.retarget_reset(other(end).index(), at, state.return_delays[i]);
                        }
                    }
                }
                if let Some(original) = state.rst[i] {
                    let at = self.write_pipe(end).effective_shutdown_arrival(original);
                    if state.rst_due[i].is_none_or(|old| old.instant() != at.instant()) {
                        state.rst_due[i] = Some(at);
                        arm[1][i] = Some(at);
                        if let Some(tap) = &self.tap {
                            tap.defer_reset_receipt(other(end).index(), at);
                        }
                    }
                }
            }
            let incoming = [End::A, End::B].into_iter().filter_map(|end| {
                state.incoming_due[end.index()]
                    .filter(|at| at.passed_on(clock) && self.write_pipe(end).can_arrive())
                    .map(|at| (at, end, false))
            });
            let rst = [End::A, End::B].into_iter().filter_map(|end| {
                state.rst_due[end.index()]
                    .filter(|at| at.passed_on(clock) && self.write_pipe(end).can_arrive())
                    .map(|at| (at, end, true))
            });
            let Some((at, from, reset)) = incoming
                .chain(rst)
                .min_by_key(|(at, _, reset)| (at.instant(), *reset))
            else {
                break;
            };
            let to = other(from);
            if reset {
                state.rst[from.index()] = None;
                state.rst_due[from.index()] = None;
                if !state.local_closed[to.index()] {
                    self.count_shutdown_reset(to, false);
                    self.write_pipe(to).abort_writer();
                    self.write_pipe(from).reset_reader_at(None);
                    state.local_closed[to.index()] = true;
                }
                self.a_to_b.reset_quiet_at(at);
                self.b_to_a.reset_quiet_at(at);
            } else {
                state.incoming[from.index()] = None;
                state.incoming_due[from.index()] = None;
                if state.local_closed[to.index()] {
                    continue;
                }
                state.local_closed[to.index()] = true;
                self.count_shutdown_reset(to, self.write_pipe(to).has_writer());
                self.write_pipe(to).abort_writer();
                let return_delay = state.return_delays[from.index()];
                if let Some(tap) = &self.tap {
                    tap.rst_at(to.index(), at, return_delay);
                }
                let reset_at = at.later(return_delay);
                state.rst[to.index()] = Some(reset_at);
                state.rst_due[to.index()] = None;
            }
        }
        for (stage, pending) in arm.iter_mut().zip([state.incoming, state.rst]) {
            for (at, pending) in stage.iter_mut().zip(pending) {
                if pending.is_none() {
                    *at = None;
                }
            }
        }
        drop(state);
        for at in arm.into_iter().flatten().flatten() {
            at.wake_waiters_quiet_on(self.regs.shared.clock.as_deref());
        }
    }

    fn count_shutdown_reset(&self, end: End, sent: bool) {
        let established = self.read_pipe(end).established_reader();
        self.regs.shared.count_reset(
            self.server.ip(),
            sent,
            [end == End::A && established, end == End::B && established],
        );
    }

    pub(super) fn schedule_read_shutdown_data(&self, end: End, at: Deadline) {
        if self.pair {
            return;
        }
        self.schedule_shutdown_arrival(end, at);
    }

    fn schedule_shutdown_arrival(&self, end: End, at: Deadline) {
        let mut state = self.mac_shutdown.lock().unwrap();
        if state.local_closed[other(end).index()] {
            return;
        }
        let pending = &mut state.incoming[end.index()];
        if pending.is_none_or(|old| at.instant() < old.instant()) {
            *pending = Some(at);
            let due = self.write_pipe(end).effective_shutdown_arrival(at);
            state.incoming_due[end.index()] = Some(due);
            let return_delay = self.delay();
            state.return_delays[end.index()] = return_delay;
            if let Some(tap) = &self.tap {
                tap.discard_acks_from(
                    other(end).index(),
                    due.remaining_on(self.regs.shared.clock.as_deref()),
                    return_delay,
                );
            }
            drop(state);
            due.wake_waiters_quiet_on(self.regs.shared.clock.as_deref());
        }
    }

    pub(super) fn shut_read_tcp(&self, end: End) {
        self.read_pipe(end).shut_read();
        if self.pair {
            return;
        }
        if let Some(at) = self.read_pipe(end).shutdown_arrival() {
            self.schedule_shutdown_arrival(other(end), at);
        }
    }

    pub(super) fn attach_tcp_probe(self: &Arc<Self>, end: End, rec: &Arc<SockRec>) {
        if self.pair {
            return;
        }
        let probe = Arc::new(ShutdownProbe {
            conn: Arc::downgrade(self),
            end,
        });
        rec.set_probe(Arc::downgrade(&probe) as std::sync::Weak<dyn RxProbe>);
        if let Some(tap) = &self.tap {
            tap.watch_probe(Arc::downgrade(&probe) as std::sync::Weak<dyn RxProbe>);
        }
        self.mac_shutdown.lock().unwrap().probes[end.index()] = Some(probe);
    }
}

impl RxProbe for ShutdownProbe {
    fn pending_time(&self) -> bool {
        self.conn.upgrade().is_some_and(|conn| {
            conn.progress_tcp_shutdown();
            let state = conn.mac_shutdown.lock().unwrap();
            let pending = state.incoming.iter().chain(&state.rst).any(Option::is_some);
            drop(state);
            pending || RxProbe::pending_time(conn.read_pipe(self.end))
        })
    }

    fn land(&self) {
        if let Some(conn) = self.conn.upgrade() {
            conn.progress_tcp_shutdown();
            RxProbe::land(conn.read_pipe(self.end));
        }
    }

    fn queued(&self) -> (usize, usize) {
        self.conn.upgrade().map_or((0, 0), |conn| {
            conn.progress_tcp_shutdown();
            RxProbe::queued(conn.read_pipe(self.end))
        })
    }
}