Skip to main content

subc_client_rs/
scope_served_by.rs

1pub use subc_control::{ScopeServedByAnswer, ScopeServedByReply};
2use subc_control::{ScopeServedByRequest, SCOPE_SERVED_BY_OP};
3use subc_protocol::{scope::SCOPE_SERVED_BY_CAPABILITY, ErrorBody, Frame, FrameType};
4use tokio::sync::oneshot;
5
6use crate::{ModuleHandle, ScopeCallError, CATALOG_UPDATE_TIMEOUT};
7
8impl ModuleHandle {
9    /// Read acknowledged-bind history for an epoch owned by this module.
10    /// Only `Served` is affirmative. Ended or absent epochs are `Unknown`, as are
11    /// epochs not yet re-registered after a daemon restart.
12    /// Without `scope-served-by/v1` in HELLO_ACK, nothing is sent.
13    pub async fn scope_served_by(
14        &self,
15        scope_ref: String,
16        scope_epoch: u64,
17        module_id: String,
18    ) -> Result<ScopeServedByReply, ScopeCallError> {
19        if !self
20            .shared
21            .daemon_capabilities
22            .iter()
23            .any(|cap| cap == SCOPE_SERVED_BY_CAPABILITY)
24        {
25            return Err(ScopeCallError::NotSupported {
26                op: SCOPE_SERVED_BY_OP,
27            });
28        }
29        let body = serde_json::to_vec(&ScopeServedByRequest::new(
30            scope_ref,
31            scope_epoch,
32            module_id,
33        ))
34        .map_err(|err| ScopeCallError::Protocol(err.to_string()))?;
35        let (corr, writer, rx) = {
36            let mut inner = self.shared.lock_inner();
37            if inner.closed {
38                return Err(ScopeCallError::ConnectionClosed);
39            }
40            let writer = inner
41                .writer
42                .clone()
43                .ok_or(ScopeCallError::ConnectionClosed)?;
44            let corr = crate::next_module_control_corr(&mut inner)
45                .ok_or(ScopeCallError::ConnectionClosed)?;
46            let (tx, rx) = oneshot::channel();
47            inner.pending_scope_served_by.insert(corr, tx);
48            (corr, writer, rx)
49        };
50        let _guard = ServedByWaiter {
51            handle: self.clone(),
52            corr,
53        };
54        let frame = Frame::build_with_version(
55            self.shared.negotiated_ver,
56            FrameType::Request,
57            crate::control_flags(),
58            0,
59            0,
60            corr,
61            body,
62        )
63        .map_err(|err| ScopeCallError::Protocol(err.to_string()))?;
64        let reply = tokio::time::timeout(CATALOG_UPDATE_TIMEOUT, async {
65            writer
66                .send(frame)
67                .await
68                .map_err(|_| ScopeCallError::ConnectionClosed)?;
69            rx.await.map_err(|_| ScopeCallError::ConnectionClosed)
70        })
71        .await
72        .map_err(|_| ScopeCallError::Timeout)??;
73        match reply.header.ty {
74            FrameType::Response => serde_json::from_slice(&reply.body)
75                .map_err(|err| ScopeCallError::Protocol(err.to_string())),
76            FrameType::Error => {
77                let body: ErrorBody = serde_json::from_slice(&reply.body)
78                    .map_err(|err| ScopeCallError::Protocol(err.to_string()))?;
79                Err(ScopeCallError::Refused {
80                    code: body.code,
81                    message: body.message,
82                })
83            }
84            other => Err(ScopeCallError::Protocol(format!(
85                "unexpected {SCOPE_SERVED_BY_OP} terminal frame: {other:?}"
86            ))),
87        }
88    }
89}
90
91struct ServedByWaiter {
92    handle: ModuleHandle,
93    corr: u64,
94}
95impl Drop for ServedByWaiter {
96    fn drop(&mut self) {
97        self.handle
98            .shared
99            .lock_inner()
100            .pending_scope_served_by
101            .remove(&self.corr);
102    }
103}