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(|_| NetError::from(ErrorKind::EngineDropped))?
163 }
164}
165#[must_use]
168pub struct PreparedRequest {
169 admission: dispatch::Admission,
171 handle: RequestHandle,
173 response: Option<oneshot::Receiver<Result<Response>>>,
176}
177impl PreparedRequest {
178 fn new(mut admission: dispatch::Admission) -> Result<Self> {
179 let (handle, response) = admission
180 .request
181 .take()
182 .ok_or_else(|| NetError::from(ErrorKind::Internal))?;
183 Ok(Self {
184 admission,
185 handle,
186 response: Some(response),
187 })
188 }
189 pub fn handle(&self) -> &RequestHandle {
191 &self.handle
192 }
193 pub fn commit(mut self) -> Result<RequestReceipt> {
199 let response = self
200 .response
201 .take()
202 .ok_or_else(|| NetError::from(ErrorKind::Internal))?;
203 self.admission.commit()?;
204 Ok(RequestReceipt {
205 handle: self.handle.clone(),
206 response,
207 })
208 }
209}
210impl fmt::Debug for PreparedRequest {
211 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
212 f.debug_struct("PreparedRequest")
213 .field("handle", &self.handle)
214 .finish()
215 }
216}