second-brain-sync 0.13.4

Bidirectional sync for second-brain: SSH transport, JSONL change log, conflict resolution
Documentation
use std::net::IpAddr;

use anyhow::Result;

use super::{Advert, Found, on_local_network, read_strings, txt_map};

/// Registers adverts with the system's DNS-SD service; dropping a handle
/// withdraws its advert.
pub(super) trait Registry {
    type Handle;
    fn register(&mut self, advert: &Advert) -> Result<Self::Handle>;
}

/// The adverts registered through a `Registry`, brought in line with what
/// should be advertised on each `update`.
pub(super) struct Registrations<R: Registry> {
    registry: R,
    held: Vec<(Advert, R::Handle)>,
    failing: Vec<Advert>,
}

impl<R: Registry> Registrations<R> {
    pub(super) fn new(registry: R) -> Self {
        Self {
            registry,
            held: Vec::new(),
            failing: Vec::new(),
        }
    }

    /// Withdraws what is no longer wanted before registering anything, so a
    /// changed advert never holds its name twice. An advert that fails to
    /// register is tried again on each update, with one warning until it
    /// succeeds.
    pub(super) fn update(&mut self, wanted: &[Advert]) {
        self.held.retain(|(advert, _)| wanted.contains(advert));
        self.failing.retain(|advert| wanted.contains(advert));
        for advert in wanted {
            if self.held.iter().any(|(held, _)| held == advert) {
                continue;
            }
            match self.registry.register(advert) {
                Ok(handle) => {
                    self.failing.retain(|failed| failed != advert);
                    self.held.push((advert.clone(), handle));
                }
                Err(e) if !self.failing.contains(advert) => {
                    tracing::warn!(
                        "cannot advertise {} {:?} through the system's DNS-SD service: {e:#}",
                        advert.service,
                        advert.instance
                    );
                    self.failing.push(advert.clone());
                }
                Err(_) => {}
            }
        }
    }

    pub(super) fn handles(&self) -> impl Iterator<Item = &R::Handle> {
        self.held.iter().map(|(_, handle)| handle)
    }

    /// Drops, in `handles` order, each handle `keep` refuses; the next
    /// `update` registers its advert again.
    pub(super) fn retain(&mut self, mut keep: impl FnMut(&mut R::Handle) -> bool) {
        self.held.retain_mut(|(_, handle)| keep(handle));
    }
}

/// What one resolved instance counts as: an instance per IPv4 address on
/// the local network, the same rule the codec applies to an answer's source.
pub(super) fn resolved(instance: &str, port: u16, txt: &[u8], addresses: &[IpAddr]) -> Vec<Found> {
    let Some(strings) = read_strings(txt) else {
        return Vec::new();
    };
    if instance.is_empty() {
        return Vec::new();
    }
    let txt = txt_map(&strings);
    let mut out = Vec::new();
    for &address in addresses {
        let found = Found {
            instance: instance.to_string(),
            address,
            port,
            txt: txt.clone(),
        };
        if on_local_network(address) && !out.contains(&found) {
            out.push(found);
        }
    }
    out
}

#[cfg(test)]
mod tests {
    use std::cell::RefCell;
    use std::net::{Ipv4Addr, Ipv6Addr};
    use std::rc::Rc;

    use anyhow::bail;

    use super::*;
    use crate::mdns::{TXT_ID, TXT_LOGIN, device_advert, pairing_advert, txt_record};

    type Log = Rc<RefCell<Vec<String>>>;

    struct Fake {
        log: Log,
        refused: Rc<RefCell<Vec<u16>>>,
    }

    struct Handle {
        port: u16,
        log: Log,
    }

    impl Drop for Handle {
        fn drop(&mut self) {
            self.log
                .borrow_mut()
                .push(format!("withdraw {}", self.port));
        }
    }

    impl Registry for Fake {
        type Handle = Handle;
        fn register(&mut self, advert: &Advert) -> Result<Handle> {
            if self.refused.borrow().contains(&advert.port) {
                bail!("refused");
            }
            self.log
                .borrow_mut()
                .push(format!("register {}", advert.port));
            Ok(Handle {
                port: advert.port,
                log: self.log.clone(),
            })
        }
    }

    fn registrations() -> (Registrations<Fake>, Log, Rc<RefCell<Vec<u16>>>) {
        let log = Log::default();
        let refused = Rc::new(RefCell::new(Vec::new()));
        let fake = Fake {
            log: log.clone(),
            refused: refused.clone(),
        };
        (Registrations::new(fake), log, refused)
    }

    fn taken(log: &Log) -> Vec<String> {
        std::mem::take(&mut *log.borrow_mut())
    }

    #[test]
    fn an_update_registers_each_new_advert_once_and_withdraws_dropped_ones() {
        let (mut registrations, log, _) = registrations();
        let device = device_advert("peer-1", "me", 22);
        let pairing = pairing_advert("desk", "peer-1", 7201);
        registrations.update(&[device.clone(), pairing.clone(), device.clone()]);
        assert_eq!(taken(&log), ["register 22", "register 7201"]);
        registrations.update(&[device.clone(), pairing.clone()]);
        assert_eq!(taken(&log), Vec::<String>::new());
        registrations.update(std::slice::from_ref(&device));
        assert_eq!(taken(&log), ["withdraw 7201"]);
        registrations.update(&[]);
        assert_eq!(taken(&log), ["withdraw 22"]);
        assert_eq!(registrations.handles().count(), 0);
    }

    #[test]
    fn a_changed_advert_is_withdrawn_before_it_is_registered_again() {
        let (mut registrations, log, _) = registrations();
        registrations.update(&[device_advert("peer-1", "me", 22)]);
        taken(&log);
        registrations.update(&[device_advert("peer-1", "me", 2222)]);
        assert_eq!(taken(&log), ["withdraw 22", "register 2222"]);
    }

    #[test]
    fn a_refused_or_ended_registration_is_registered_on_a_later_update() {
        let (mut registrations, log, refused) = registrations();
        let device = device_advert("peer-1", "me", 22);
        refused.borrow_mut().push(22);
        registrations.update(std::slice::from_ref(&device));
        registrations.update(std::slice::from_ref(&device));
        assert_eq!(registrations.handles().count(), 0);
        refused.borrow_mut().clear();
        registrations.update(std::slice::from_ref(&device));
        assert_eq!(taken(&log), ["register 22"]);

        registrations.retain(|_| false);
        assert_eq!(taken(&log), ["withdraw 22"]);
        registrations.update(std::slice::from_ref(&device));
        assert_eq!(taken(&log), ["register 22"]);
    }

    #[test]
    fn a_resolved_instance_counts_once_per_local_ipv4_address() {
        let advert = device_advert("peer-1", "me", 2222);
        let lan = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 5));
        let link = IpAddr::V4(Ipv4Addr::new(169, 254, 3, 4));
        let found = resolved(
            "peer-1",
            2222,
            &txt_record(&advert),
            &[
                lan,
                IpAddr::V4(Ipv4Addr::new(8, 8, 8, 8)),
                IpAddr::V4(Ipv4Addr::new(100, 64, 0, 1)),
                IpAddr::V6(Ipv6Addr::LOCALHOST),
                link,
                lan,
            ],
        );
        let addresses: Vec<IpAddr> = found.iter().map(|f| f.address).collect();
        assert_eq!(addresses, [lan, link]);
        for found in &found {
            assert_eq!(found.instance, "peer-1");
            assert_eq!(found.port, 2222);
            assert_eq!(found.get(TXT_ID), Some("peer-1"));
            assert_eq!(found.get(TXT_LOGIN), Some("me"));
        }
    }

    #[test]
    fn a_resolved_instance_with_a_cut_txt_record_or_no_name_is_not_found() {
        let txt = txt_record(&device_advert("peer-1", "me", 22));
        let lan = [IpAddr::V4(Ipv4Addr::new(10, 0, 0, 2))];
        assert!(resolved("peer-1", 22, &txt[..txt.len() - 1], &lan).is_empty());
        assert!(resolved("", 22, &txt, &lan).is_empty());
        let shadowed = [
            5, b'I', b'D', b'=', b'a', b'b', 5, b'i', b'd', b'=', b'c', b'd',
        ];
        let found = resolved("peer", 22, &shadowed, &lan);
        assert_eq!(found[0].get(TXT_ID), Some("ab"));
    }
}