yog 0.0.52

yog: the standalone server for litany loops — the world, the balls and the conversations, behind one wire
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

//! The wire's half of the **one** intake (REMOTE §3, §9.5; bl-b6fa).
//!
//! There is one thing in yog that turns a gesture envelope into a reply
//! envelope, and it is
//! [`ConsumerCtx::answer`](crate::boundary::consumer::ConsumerCtx::answer) —
//! build a fresh [`Deps`](crate::boundary::dispatch::Deps) over the latest
//! published snapshot, open the §4.1 `ui.json`, decode with the codec, run
//! `dispatch`/`answer`, encode the reply. The gestures inbox drives it on a
//! poll; a connection drives it on a request. **Two doors, one room** — which
//! is why the wire adds no verb and cannot: it never sees an `Action` or a
//! `Query`, only bytes on their way to the same chokepoint.

use crate::boundary::consumer::ConsumerCtx;
use serde_json::Value;
use std::sync::Arc;

/// The engine's [`Answerer`](super::server::Answerer): the deposit consumer's
/// context, shared rather than copied.
pub struct Intake {
    ctx: Arc<ConsumerCtx>,
}

impl Intake {
    /// Wrap the context the gestures-inbox consumer is already driving.
    pub fn new(ctx: Arc<ConsumerCtx>) -> Self {
        Self { ctx }
    }
}

impl super::server::Answerer for Intake {
    /// One request, one reply frame — **unless the read is follow-class**
    /// (bl-73e7), in which case it is the frames that read produces, written as
    /// they are produced. Two arms and no third: [`follow`](ConsumerCtx::follow)
    /// answers `None` for every request that is not one, and for a follow whose
    /// address does not resolve — which then earns the ordinary refusal, in one
    /// frame, from the one function that words it.
    ///
    /// **The certificate's grade is spent one level down** (REMOTE §4.2,
    /// bl-7ff3), where the identity already is: a foot's follow-class read is
    /// not one of the three gestures it may send, so `follow` answers `None`
    /// for it and the refusal arrives through the same one function that words
    /// every other one. No second refusal path here, and nothing to forget.
    ///
    /// **This is where the wire's trust grade is spent** (REMOTE §4, bl-8bbc):
    /// [`answer_as`](ConsumerCtx::answer_as) is
    /// [`answer`](ConsumerCtx::answer) with a client identity, and the identity
    /// is the whole difference between the two intakes. The inbox's callers are
    /// the world's own residents and are unscoped (§3); a connection is a
    /// caller from another trust domain and sees its registrations. A held read
    /// spends it at the same moment and on the same terms — a connection that
    /// stays open is still one request.
    fn answer(
        &self,
        peer: &crate::registry::Peer,
        request: Value,
    ) -> Box<dyn Iterator<Item = Value>> {
        // **This client is speaking, so it was seen** (REMOTE §5 as amended,
        // bl-d542): one stamp per request, at the one door every connection's
        // bytes pass through, ahead of both arms so a follow-class read that
        // parks for thirty seconds is stamped when it arrives rather than when
        // it ends.
        self.ctx.seen(peer);
        match self.ctx.follow(peer, &request) {
            Some(frames) => frames,
            None => Box::new(std::iter::once(self.ctx.answer_as(peer, &request))),
        }
    }
}

#[cfg(test)]
mod tests;