open_net/api/ws/
request_control.rs1use super::{
2 ConnectionId, OperationId, OperationSnapshot, RequestId, SessionId, TaskEndCause,
3 TerminationOutcome, WriteOutcome,
4};
5use crate::error::ErrorKind;
6use crate::module::ws_client::native_pending::NativePending;
7use crate::module::ws_client::operation_control::OperationControl;
8use crate::{Metadata, NetError, Result};
9use std::fmt;
10use std::sync::{Arc, Mutex, Weak};
11use std::time::Instant;
12
13#[derive(Clone)]
19pub struct RequestRegistration {
20 request_id: RequestId,
22 session_id: SessionId,
24 registered_at: Instant,
26 token: u64,
28 pending: Weak<NativePending>,
31 timing: Arc<RegistrationTiming>,
34}
35
36pub(crate) struct RegistrationTiming {
38 deadline: Mutex<Option<Instant>>,
41}
42
43impl RegistrationTiming {
44 pub(crate) fn new(deadline: Option<Instant>) -> Self {
45 Self {
46 deadline: Mutex::new(deadline),
47 }
48 }
49
50 pub(crate) fn deadline(&self) -> Result<Option<Instant>> {
51 self.deadline
52 .lock()
53 .map(|value| *value)
54 .map_err(NetError::from_poison)
55 }
56
57 pub(crate) fn establish(&self, deadline: Instant) -> Result<()> {
58 let mut current = self.deadline.lock().map_err(NetError::from_poison)?;
59 if current.is_none() {
60 *current = Some(deadline);
61 }
62 Ok(())
63 }
64}
65
66impl RequestRegistration {
67 pub(crate) fn new(
68 request_id: RequestId,
69 session_id: SessionId,
70 registered_at: Instant,
71 token: u64,
72 pending: Weak<NativePending>,
73 timing: Arc<RegistrationTiming>,
74 ) -> Self {
75 Self {
76 request_id,
77 session_id,
78 registered_at,
79 token,
80 pending,
81 timing,
82 }
83 }
84
85 pub fn request_id(&self) -> &RequestId {
87 &self.request_id
88 }
89 pub fn session_id(&self) -> SessionId {
91 self.session_id
92 }
93 pub fn registered_at(&self) -> Instant {
95 self.registered_at
96 }
97
98 pub fn response_deadline(&self) -> Result<Option<Instant>> {
101 self.timing.deadline()
102 }
103
104 pub(crate) fn token(&self) -> u64 {
105 self.token
106 }
107 pub(crate) fn pending(&self) -> Weak<NativePending> {
108 self.pending.clone()
109 }
110 pub(crate) fn belongs_to(&self, pending: &NativePending) -> bool {
111 std::ptr::eq(self.pending.as_ptr(), pending)
112 }
113}
114
115impl fmt::Debug for RequestRegistration {
116 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
117 formatter
118 .debug_struct("RequestRegistration")
119 .field("request_id", &self.request_id)
120 .field("session_id", &self.session_id)
121 .field("registered_at", &self.registered_at)
122 .field("response_deadline", &self.response_deadline())
123 .finish_non_exhaustive()
124 }
125}
126
127#[derive(Clone)]
134pub struct RequestSnapshot {
135 pub operation_id: OperationId,
137 pub request_id: RequestId,
139 pub session_id: SessionId,
141 pub connection_id: Option<ConnectionId>,
144 pub registered_at: Instant,
146 pub response_deadline: Option<Instant>,
149 pub metadata: Metadata,
151 pub operation: OperationSnapshot,
153}
154
155impl fmt::Debug for RequestSnapshot {
156 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
157 formatter
158 .debug_struct("RequestSnapshot")
159 .field("operation_id", &self.operation_id)
160 .field("request_id", &self.request_id)
161 .field("session_id", &self.session_id)
162 .field("connection_id", &self.connection_id)
163 .field("registered_at", &self.registered_at)
164 .field("response_deadline", &self.response_deadline)
165 .field("metadata_entries", &self.metadata.len())
166 .field("operation", &self.operation)
167 .finish()
168 }
169}
170
171#[derive(Clone)]
177pub struct RequestHandle {
178 core: Arc<OperationControl>,
181 registration: RequestRegistration,
184}
185
186impl RequestHandle {
187 #[cfg(feature = "quality-doctor")]
203 pub fn quality_ref(&self) -> Option<crate::api::quality::QualityReportRef> {
204 self.core.quality_ref()
205 }
206 #[cfg(feature = "quality-doctor")]
207 pub(crate) fn quality_parent(&self, parent: crate::api::quality::QualityReportRef) {
208 if let Some(probe) = self.core.quality() {
209 probe.parent(parent);
210 }
211 }
212 pub(crate) fn retry_report(&self) -> crate::api::retry::RetryReport {
213 self.core.retry_report()
214 }
215
216 pub(crate) fn has_selected_result(&self) -> bool {
217 self.core.is_finished()
218 }
219
220 pub(crate) fn expire_operation_attempt(&self) {
223 self.core
224 .prepare_termination(self.core.deadline_error(), TaskEndCause::Expired)
225 .dispatch();
226 }
227
228 pub(crate) fn new(core: Arc<OperationControl>, registration: RequestRegistration) -> Self {
229 Self { core, registration }
230 }
231 pub fn id(&self) -> OperationId {
233 self.core.id()
234 }
235 pub fn request_id(&self) -> &RequestId {
237 self.registration.request_id()
238 }
239 pub fn registration(&self) -> &RequestRegistration {
241 &self.registration
242 }
243 pub fn state(&self) -> Result<OperationSnapshot> {
245 self.core.snapshot()
246 }
247 pub fn cancel(&self) -> Result<TerminationOutcome> {
250 self.terminate(
251 NetError::from(ErrorKind::Cancelled),
252 TaskEndCause::Cancelled,
253 )
254 }
255 pub fn expire(&self) -> Result<TerminationOutcome> {
258 self.terminate(NetError::from(ErrorKind::TimedOut), TaskEndCause::Expired)
259 }
260 pub async fn written(&self) -> Result<WriteOutcome> {
265 self.core.written().await
266 }
267
268 fn terminate(&self, error: NetError, cause: TaskEndCause) -> Result<TerminationOutcome> {
269 if let Some(pending) = self.registration.pending.upgrade() {
270 pending.terminate(self.request_id(), self.registration.token, error, cause)
271 } else if self.core.snapshot()?.result.is_some() {
272 Ok(TerminationOutcome::AlreadyFinished)
273 } else {
274 Err(NetError::from(ErrorKind::EngineDropped))
275 }
276 }
277}
278
279impl fmt::Debug for RequestHandle {
280 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
281 formatter
282 .debug_struct("RequestHandle")
283 .field("id", &self.id())
284 .field("registration", &self.registration)
285 .field("state", &self.state())
286 .finish()
287 }
288}