liminal-cli 0.3.1

The liminal command: serve the network, maintain its stores, or serve its discovery MCP over stdio
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

use super::super::RailError;
use super::{Live, Source};

/// Only a Connect refusal can renew: no admitted application act is repeated.
fn expired_admission(error: &RailError) -> bool {
    let RailError::Refused(message) = error else {
        return false;
    };
    message.starts_with("connection error: server rejected")
        && message.ends_with(": lys pass admission refused: pass_expired")
}

impl Live {
    pub(super) fn admit<T>(
        &self,
        connect: impl FnMut(&[u8]) -> Result<T, RailError>,
    ) -> Result<T, RailError> {
        Self::admit_with(
            connect,
            || {
                let Source::Lys(agent) = &self.source else {
                    return Ok(false);
                };
                agent
                    .forget_expired_pass()
                    .map_err(|error| RailError::Refused(error.0))
            },
            || self.credential(),
        )
    }

    fn admit_with<T>(
        mut connect: impl FnMut(&[u8]) -> Result<T, RailError>,
        renew: impl FnOnce() -> Result<bool, RailError>,
        credential: impl Fn() -> Result<Vec<u8>, RailError>,
    ) -> Result<T, RailError> {
        let answer = connect(&credential()?);
        if let Err(error) = &answer
            && expired_admission(error)
            && renew()?
        {
            return connect(&credential()?);
        }
        answer
    }
}

#[cfg(test)]
mod tests {
    use super::{Live, RailError};
    use std::cell::Cell;

    #[test]
    fn an_expired_admission_asks_once_more_and_keeps_a_second_refusal() {
        let calls = Cell::new(0);
        let renewals = Cell::new(0);
        let error = RailError::Refused("connection error: server rejected connection (reason 6): lys pass admission refused: pass_expired".to_owned());
        let result: Result<(), _> = Live::admit_with(
            |_| {
                calls.set(calls.get() + 1);
                Err(error.clone())
            },
            || {
                renewals.set(renewals.get() + 1);
                Ok(true)
            },
            || Ok(Vec::new()),
        );
        assert_eq!(result, Err(error));
        assert_eq!(calls.get(), 2);
        assert_eq!(renewals.get(), 1);
    }

    #[test]
    fn an_application_refusal_and_an_unproven_pass_are_never_repeated() {
        for text in [
            "conversation 1: pass_expired",
            "connection error: server rejected connection (reason 6): lys pass admission refused: signature_refused",
        ] {
            let calls = Cell::new(0);
            let renewals = Cell::new(0);
            let result: Result<(), _> = Live::admit_with(
                |_| {
                    calls.set(calls.get() + 1);
                    Err(RailError::Refused(text.to_owned()))
                },
                || {
                    renewals.set(renewals.get() + 1);
                    Err(RailError::Refused("this refusal cannot renew".to_owned()))
                },
                || Ok(Vec::new()),
            );
            assert_eq!(result, Err(RailError::Refused(text.to_owned())));
            assert_eq!(calls.get(), 1);
            assert_eq!(renewals.get(), 0);
        }
    }
}