open_net/api/ws/
request_client.rs1use super::{
2 dispatch, Request, RequestHandle, RequestOptions, RequestSnapshot, Response, SessionId,
3};
4use crate::error::ErrorKind;
5use crate::module::ws_client::session_runtime::SessionRuntime;
6use crate::{EnqueueError, NetError, Result};
7use std::fmt;
8use std::sync::Arc;
9use std::time::Instant;
10use tokio::sync::oneshot;
11
12#[derive(Clone)]
15pub struct RequestClient {
16 pub(crate) runtime: Arc<SessionRuntime>,
18}
19impl RequestClient {
20 pub fn session_id(&self) -> SessionId {
22 self.runtime.id
23 }
24 pub fn request(&self, request: Request) -> RequestBuilder {
26 RequestBuilder {
27 client: self.clone(),
28 request,
29 options: RequestOptions::default(),
30 admission_started: None,
31 }
32 }
33 pub async fn execute(&self, request: Request) -> Result<Response> {
39 self.request(request).send().await
40 }
41 pub fn pending_snapshot(&self) -> Result<Vec<RequestSnapshot>> {
43 self.runtime.pending.snapshot()
44 }
45}
46impl fmt::Debug for RequestClient {
47 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
48 f.debug_struct("RequestClient")
49 .field("session_id", &self.session_id())
50 .finish()
51 }
52}
53#[must_use]
56#[derive(Debug)]
57pub struct RequestBuilder {
58 client: RequestClient,
60 request: Request,
62 options: RequestOptions,
64 admission_started: Option<Instant>,
67}
68impl RequestBuilder {
69 pub fn options(mut self, options: RequestOptions) -> Self {
71 self.options = options;
72 self.admission_started = None;
73 self
74 }
75 pub async fn send(self) -> Result<Response> {
77 self.enqueue()
78 .await
79 .map_err(EnqueueError::into_error)?
80 .response()
81 .await
82 }
83 pub async fn enqueue(mut self) -> std::result::Result<RequestReceipt, EnqueueError<Self>> {
88 match self.admit().await.and_then(PreparedRequest::commit) {
89 Ok(receipt) => Ok(receipt),
90 Err(error) => Err(EnqueueError::new(self, error)),
91 }
92 }
93 pub fn try_enqueue(mut self) -> std::result::Result<RequestReceipt, EnqueueError<Self>> {
95 match self.try_admit().and_then(PreparedRequest::commit) {
96 Ok(receipt) => Ok(receipt),
97 Err(error) => Err(EnqueueError::new(self, error)),
98 }
99 }
100 pub async fn prepare(mut self) -> std::result::Result<PreparedRequest, EnqueueError<Self>> {
105 match self.admit().await {
106 Ok(prepared) => Ok(prepared),
107 Err(error) => Err(EnqueueError::new(self, error)),
108 }
109 }
110 pub fn try_prepare(mut self) -> std::result::Result<PreparedRequest, EnqueueError<Self>> {
112 match self.try_admit() {
113 Ok(prepared) => Ok(prepared),
114 Err(error) => Err(EnqueueError::new(self, error)),
115 }
116 }
117 async fn admit(&mut self) -> Result<PreparedRequest> {
118 let started = *self.admission_started.get_or_insert_with(Instant::now);
119 let admission = dispatch::prepare(
120 &self.client.runtime,
121 self.request.message(),
122 &self.options.send,
123 started,
124 Some((&self.request, &self.options)),
125 true,
126 )
127 .await?;
128 PreparedRequest::new(admission)
129 }
130 fn try_admit(&mut self) -> Result<PreparedRequest> {
131 let started = *self.admission_started.get_or_insert_with(Instant::now);
132 let admission = dispatch::try_prepare(
133 &self.client.runtime,
134 self.request.message(),
135 &self.options.send,
136 started,
137 Some((&self.request, &self.options)),
138 )?;
139 PreparedRequest::new(admission)
140 }
141}
142#[must_use]
144#[derive(Debug)]
145pub struct RequestReceipt {
146 handle: RequestHandle,
148 response: oneshot::Receiver<Result<Response>>,
150}
151impl RequestReceipt {
152 pub fn handle(&self) -> &RequestHandle {
154 &self.handle
155 }
156 pub async fn response(self) -> Result<Response> {
160 self.response
161 .await
162 .map_err(|_| {
163 crate::log_e!(crate::LogType::WSC; "ws.request.response",
164 "session_id|operation_id", self.handle.registration().session_id().as_u64(), self.handle.id().as_u64());
165 NetError::from(ErrorKind::EngineDropped)
166 })?
167 }
168}
169#[must_use]
172pub struct PreparedRequest {
173 admission: dispatch::Admission,
175 handle: RequestHandle,
177 response: Option<oneshot::Receiver<Result<Response>>>,
180}
181impl PreparedRequest {
182 fn new(mut admission: dispatch::Admission) -> Result<Self> {
183 let (handle, response) = admission.request.take().ok_or_else(|| {
184 dispatch::log_invariant(&admission.control, "request_registration_missing");
185 NetError::from(ErrorKind::Internal)
186 })?;
187 Ok(Self {
188 admission,
189 handle,
190 response: Some(response),
191 })
192 }
193 pub fn handle(&self) -> &RequestHandle {
195 &self.handle
196 }
197 pub fn commit(mut self) -> Result<RequestReceipt> {
203 let response = self.response.take().ok_or_else(|| {
204 dispatch::log_invariant(&self.admission.control, "prepared_response_missing");
205 NetError::from(ErrorKind::Internal)
206 })?;
207 self.admission.commit()?;
208 Ok(RequestReceipt {
209 handle: self.handle.clone(),
210 response,
211 })
212 }
213}
214impl fmt::Debug for PreparedRequest {
215 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
216 f.debug_struct("PreparedRequest")
217 .field("handle", &self.handle)
218 .finish()
219 }
220}