subc_client_rs/
scope_served_by.rs1pub 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 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}