1use std::{
19 collections::VecDeque,
20 sync::{
21 Arc,
22 atomic::{AtomicBool, Ordering},
23 },
24 time::Duration,
25};
26
27use ahash::AHashMap;
28use dashmap::DashMap;
29use nautilus_core::UUID4;
30use nautilus_model::identifiers::{ClientOrderId, VenueOrderId};
31use nautilus_network::websocket::{AuthTracker, WebSocketClient};
32use tokio_tungstenite::tungstenite::Message;
33use ustr::Ustr;
34
35use crate::{
36 common::enums::AxOrderRequestType,
37 websocket::{
38 messages::{
39 AxOrdersWsFrame, AxOrdersWsMessage, AxWsCancelOrder, AxWsError, AxWsGetOpenOrders,
40 AxWsListResponse, AxWsOrderEvent, AxWsOrderResponse, AxWsPlaceOrder, OrderMetadata,
41 },
42 parse::parse_order_message,
43 },
44};
45
46const LOGIN_TIMEOUT: Duration = Duration::from_secs(5);
47
48#[derive(Clone, Debug)]
50pub struct WsOrderInfo {
51 pub client_order_id: ClientOrderId,
53 pub symbol: Ustr,
55 pub cid: u64,
57}
58
59#[derive(Debug)]
60enum OrderSendError {
61 NotSent(String),
62 Ambiguous(String),
63}
64
65impl core::fmt::Display for OrderSendError {
66 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
67 match self {
68 Self::NotSent(message) | Self::Ambiguous(message) => f.write_str(message),
69 }
70 }
71}
72
73#[derive(Debug)]
75pub enum HandlerCommand {
76 SetClient(WebSocketClient),
78 Disconnect,
80 SessionAuthenticated,
82 PlaceOrder {
84 request_id: i64,
85 order: AxWsPlaceOrder,
86 order_info: WsOrderInfo,
87 },
88 CancelOrder {
90 request_id: i64,
91 order_id: String,
92 client_order_id: ClientOrderId,
93 command_id: Option<UUID4>,
94 },
95 GetOpenOrders { request_id: i64 },
97}
98
99pub(crate) struct AxOrdersWsFeedHandler {
104 signal: Arc<AtomicBool>,
105 inner: Option<WebSocketClient>,
106 cmd_rx: tokio::sync::mpsc::UnboundedReceiver<HandlerCommand>,
107 raw_rx: tokio::sync::mpsc::UnboundedReceiver<(u64, Message)>,
108 auth_tracker: AuthTracker,
109 cancel_on_disconnect: Option<bool>,
110 awaiting_login: bool,
111 authenticated_epoch: Option<u64>,
112 login_deadline: Option<tokio::time::Instant>,
113 session_failed: bool,
114 pending_orders: AHashMap<i64, WsOrderInfo>,
115 message_queue: VecDeque<AxOrdersWsMessage>,
116 orders_metadata: Arc<DashMap<ClientOrderId, OrderMetadata>>,
117 venue_to_client_order_id: Arc<DashMap<VenueOrderId, ClientOrderId>>,
118 has_authenticated_session: bool,
119 needs_session_restore: bool,
120}
121
122impl AxOrdersWsFeedHandler {
123 #[must_use]
125 pub(crate) fn new(
126 signal: Arc<AtomicBool>,
127 cmd_rx: tokio::sync::mpsc::UnboundedReceiver<HandlerCommand>,
128 raw_rx: tokio::sync::mpsc::UnboundedReceiver<(u64, Message)>,
129 auth_tracker: AuthTracker,
130 cancel_on_disconnect: Option<bool>,
131 orders_metadata: Arc<DashMap<ClientOrderId, OrderMetadata>>,
132 venue_to_client_order_id: Arc<DashMap<VenueOrderId, ClientOrderId>>,
133 ) -> Self {
134 Self {
135 signal,
136 inner: None,
137 cmd_rx,
138 raw_rx,
139 auth_tracker,
140 cancel_on_disconnect,
141 awaiting_login: cancel_on_disconnect.is_some(),
142 authenticated_epoch: None,
143 login_deadline: cancel_on_disconnect
144 .is_some()
145 .then(|| tokio::time::Instant::now() + LOGIN_TIMEOUT),
146 session_failed: false,
147 pending_orders: AHashMap::new(),
148 message_queue: VecDeque::new(),
149 orders_metadata,
150 venue_to_client_order_id,
151 has_authenticated_session: false,
152 needs_session_restore: false,
153 }
154 }
155
156 fn restore_authenticated_session(&mut self) {
157 if self.has_authenticated_session {
158 log::debug!("Restoring authenticated session after reconnection");
159
160 self.auth_tracker.succeed();
162 self.message_queue
163 .push_back(AxOrdersWsMessage::Authenticated);
164 log::debug!("Authenticated session restored");
165 } else {
166 log::warn!("Cannot restore authentication before the initial session succeeds");
167 }
168 }
169
170 pub(crate) async fn next(&mut self) -> Option<AxOrdersWsMessage> {
174 loop {
175 if self.needs_session_restore && self.message_queue.is_empty() {
176 self.needs_session_restore = false;
177 self.restore_authenticated_session();
178 }
179
180 if let Some(msg) = self.message_queue.pop_front() {
181 return Some(msg);
182 }
183
184 if self.awaiting_login
185 && self
186 .login_deadline
187 .is_some_and(|deadline| deadline <= tokio::time::Instant::now())
188 {
189 let messages = self.fail_login("Orders WebSocket login timed out".to_string());
190 self.message_queue.extend(messages);
191 }
192
193 if self.session_failed && self.message_queue.is_empty() {
194 self.cmd_rx.close();
195
196 while let Some(cmd) = self.cmd_rx.recv().await {
197 self.handle_command(cmd).await;
198 }
199
200 if let Some(msg) = self.message_queue.pop_front() {
201 return Some(msg);
202 }
203
204 if let Some(inner) = self.inner.take() {
205 inner.disconnect().await;
206 }
207
208 return None;
209 }
210
211 tokio::select! {
212 biased;
213 Some(cmd) = self.cmd_rx.recv() => {
214 self.handle_command(cmd).await;
215 }
216
217 () = tokio::time::sleep(std::time::Duration::from_millis(100)) => {
218 if self.signal.load(Ordering::Acquire) {
219 log::debug!("Stop signal received during idle period");
220 return None;
221 }
222 }
223
224 msg = self.raw_rx.recv() => {
225 let (epoch, msg) = match msg {
226 Some(msg) => msg,
227 None => {
228 log::debug!("WebSocket stream closed");
229 if self.awaiting_login {
230 self.auth_tracker.fail("Orders WebSocket closed before session login");
231 }
232 return None;
233 }
234 };
235
236 if let Message::Ping(data) = &msg {
237 log::trace!("Received ping frame with {} bytes", data.len());
238
239 if let Some(client) = &self.inner
240 && let Err(e) = client.send_pong(data.to_vec()).await
241 {
242 log::warn!("Failed to send pong frame: {e}");
243 }
244 continue;
245 }
246
247 if let Some(messages) = self.parse_raw_message(epoch, msg) {
248 self.message_queue.extend(messages);
249 }
250
251 if self.signal.load(Ordering::Acquire) {
252 log::debug!("Stop signal received");
253 return None;
254 }
255 }
256 }
257 }
258 }
259
260 async fn handle_command(&mut self, cmd: HandlerCommand) {
261 match cmd {
262 HandlerCommand::SetClient(client) => {
263 log::debug!("WebSocketClient received by handler");
264 self.inner = Some(client);
265 }
266 HandlerCommand::Disconnect => {
267 log::debug!("Disconnect command received");
268 self.auth_tracker.fail("Disconnected");
269
270 if let Some(inner) = self.inner.take() {
271 inner.disconnect().await;
272 }
273 }
274 HandlerCommand::SessionAuthenticated => {
275 log::debug!("Session authenticated command received");
276 self.has_authenticated_session = true;
277 self.awaiting_login = false;
278 self.auth_tracker.succeed();
279 self.message_queue
280 .push_back(AxOrdersWsMessage::Authenticated);
281 }
282 HandlerCommand::PlaceOrder {
283 request_id,
284 order,
285 order_info,
286 } => {
287 log::debug!(
288 "PlaceOrder command received: request_id={request_id}, symbol={}",
289 order.s
290 );
291 self.pending_orders.insert(request_id, order_info.clone());
292
293 if let Err(e) = self.send_json(&order).await {
294 log::error!("Failed to send place order message: {e}");
295
296 match e {
297 OrderSendError::NotSent(reason) => {
298 self.pending_orders.remove(&request_id);
299 self.message_queue
300 .push_back(AxOrdersWsMessage::PlaceOrderError {
301 client_order_id: order_info.client_order_id,
302 reason,
303 });
304 }
305 OrderSendError::Ambiguous(reason) => {
306 self.message_queue
307 .push_back(AxOrdersWsMessage::Error(AxWsError::new(format!(
308 "Failed to send place order for {}: {reason}",
309 order_info.client_order_id
310 ))));
311 }
312 }
313 }
314 }
315 HandlerCommand::CancelOrder {
316 request_id,
317 order_id,
318 client_order_id,
319 command_id,
320 } => {
321 log::debug!(
322 "CancelOrder command received: request_id={request_id}, order_id={order_id}"
323 );
324 self.send_cancel_order(request_id, &order_id, client_order_id, command_id)
325 .await;
326 }
327 HandlerCommand::GetOpenOrders { request_id } => {
328 log::debug!("GetOpenOrders command received: request_id={request_id}");
329 self.send_get_open_orders(request_id).await;
330 }
331 }
332 }
333
334 async fn send_cancel_order(
335 &mut self,
336 request_id: i64,
337 order_id: &str,
338 client_order_id: ClientOrderId,
339 command_id: Option<UUID4>,
340 ) {
341 let msg = AxWsCancelOrder {
342 rid: request_id,
343 t: AxOrderRequestType::CancelOrder,
344 oid: order_id.to_string(),
345 };
346
347 if let Err(e) = self.send_json(&msg).await {
348 log::error!("Failed to send cancel order message: {e}");
349
350 match e {
351 OrderSendError::NotSent(reason) => {
352 self.message_queue
353 .push_back(AxOrdersWsMessage::CancelOrderError {
354 client_order_id,
355 reason,
356 command_id,
357 });
358 }
359 OrderSendError::Ambiguous(reason) => {
360 self.message_queue
361 .push_back(AxOrdersWsMessage::Error(AxWsError::new(format!(
362 "Failed to send cancel for order {order_id}: {reason}"
363 ))));
364 }
365 }
366 }
367 }
368
369 async fn send_get_open_orders(&mut self, request_id: i64) {
370 let msg = AxWsGetOpenOrders {
371 rid: request_id,
372 t: AxOrderRequestType::GetOpenOrders,
373 };
374
375 if let Err(e) = self.send_json(&msg).await {
376 let reason = match e {
377 OrderSendError::NotSent(reason) | OrderSendError::Ambiguous(reason) => reason,
378 };
379
380 log::error!("Failed to send get open orders message: {reason}");
381 self.message_queue
382 .push_back(AxOrdersWsMessage::Error(AxWsError::new(format!(
383 "Failed to send get open orders request: {reason}"
384 ))));
385 }
386 }
387
388 async fn send_json<T: serde::Serialize>(&self, msg: &T) -> Result<(), OrderSendError> {
389 if self.awaiting_login {
390 return Err(OrderSendError::NotSent(
391 "Orders WebSocket session login pending".to_string(),
392 ));
393 }
394
395 if self.session_failed {
396 return Err(OrderSendError::NotSent(
397 "Orders WebSocket session authentication failed".to_string(),
398 ));
399 }
400
401 let Some(inner) = &self.inner else {
402 return Err(OrderSendError::NotSent(
403 "No WebSocket client available".to_string(),
404 ));
405 };
406
407 let payload =
408 serde_json::to_string(msg).map_err(|e| OrderSendError::NotSent(e.to_string()))?;
409 log::trace!("Sending WebSocket payload ({} bytes)", payload.len());
410
411 if self.cancel_on_disconnect.is_some() {
412 let expected_epoch = self.authenticated_epoch.ok_or_else(|| {
413 OrderSendError::NotSent(
414 "No authenticated orders WebSocket session available".to_string(),
415 )
416 })?;
417
418 if inner.connection_epoch() != expected_epoch {
419 return Err(OrderSendError::Ambiguous(
420 "Orders WebSocket session changed before login".to_string(),
421 ));
422 }
423
424 return inner
425 .send_text_on_connection(payload, None, expected_epoch)
426 .await
427 .map_err(|e| OrderSendError::Ambiguous(e.to_string()));
428 }
429
430 inner
431 .send_text(payload, None)
432 .await
433 .map_err(|e| OrderSendError::Ambiguous(e.to_string()))
434 }
435
436 fn parse_raw_message(&mut self, epoch: u64, msg: Message) -> Option<Vec<AxOrdersWsMessage>> {
437 match msg {
438 Message::Text(text) => {
439 if text == nautilus_network::RECONNECTED {
440 log::info!("Received WebSocket reconnected signal");
441
442 if self.cancel_on_disconnect.is_some() {
443 let has_current_login = self.authenticated_epoch.is_some()
444 && !self.awaiting_login
445 && self.authenticated_epoch == Some(epoch);
446
447 if !has_current_login {
448 self.awaiting_login = true;
449 self.authenticated_epoch = None;
450 self.login_deadline = Some(tokio::time::Instant::now() + LOGIN_TIMEOUT);
451 self.auth_tracker.invalidate();
452 }
453 } else {
454 self.auth_tracker.fail("Reconnecting");
455 self.needs_session_restore = true;
456 }
457
458 return Some(vec![AxOrdersWsMessage::Reconnected]);
459 }
460
461 log::trace!("Raw websocket message: {text}");
462
463 let raw_msg: AxOrdersWsFrame = match parse_order_message(&text) {
464 Ok(v) => v,
465 Err(e) => {
466 log::error!("Failed to parse WebSocket message: {e}: {text}");
467 return None;
468 }
469 };
470
471 self.handle_raw_message(epoch, raw_msg)
472 }
473 Message::Binary(data) => {
474 log::debug!("Received binary message with {} bytes", data.len());
475 None
476 }
477 Message::Close(_) => {
478 log::debug!("Received close message, waiting for reconnection");
479 None
480 }
481 _ => None,
482 }
483 }
484
485 fn handle_raw_message(
486 &mut self,
487 epoch: u64,
488 raw_msg: AxOrdersWsFrame,
489 ) -> Option<Vec<AxOrdersWsMessage>> {
490 match raw_msg {
491 AxOrdersWsFrame::Error(err) => {
492 log::warn!(
493 "Order error response: rid={} code={:?} msg={:?}",
494 err.rid,
495 err.err.code,
496 err.err.msg
497 );
498
499 Some(vec![AxOrdersWsMessage::Error(err.into())])
500 }
501 AxOrdersWsFrame::Response(resp) => self.handle_response(epoch, resp),
502 AxOrdersWsFrame::Event(event) => self.handle_event(*event),
503 }
504 }
505
506 fn handle_response(
507 &mut self,
508 epoch: u64,
509 resp: AxWsOrderResponse,
510 ) -> Option<Vec<AxOrdersWsMessage>> {
511 match resp {
512 AxWsOrderResponse::PlaceOrder(msg) => {
513 log::debug!("Place order response: rid={} oid={}", msg.rid, msg.res.oid);
514 let Some(order_info) = self.pending_orders.remove(&msg.rid) else {
515 log::warn!("Ignoring unsolicited place order response: rid={}", msg.rid);
516 return Some(vec![AxOrdersWsMessage::PlaceOrderResponse(msg)]);
517 };
518
519 let venue_order_id = match VenueOrderId::new_checked(&msg.res.oid) {
520 Ok(venue_order_id) => venue_order_id,
521 Err(e) => {
522 log::warn!(
523 "Invalid venue order ID in place response for {}: {e}",
524 order_info.client_order_id,
525 );
526 return Some(vec![AxOrdersWsMessage::PlaceOrderResponse(msg)]);
527 }
528 };
529
530 if let Some(mut metadata) =
531 self.orders_metadata.get_mut(&order_info.client_order_id)
532 {
533 if metadata
534 .venue_order_id
535 .is_none_or(|current| current == venue_order_id)
536 {
537 metadata.venue_order_id = Some(venue_order_id);
538 self.venue_to_client_order_id
539 .insert(venue_order_id, order_info.client_order_id);
540 }
541 } else {
542 log::debug!(
543 "Order tracking already cleared before place response: {}",
544 order_info.client_order_id,
545 );
546 }
547
548 Some(vec![AxOrdersWsMessage::PlaceOrderResponse(msg)])
549 }
550 AxWsOrderResponse::CancelOrder(msg) => {
551 log::debug!(
552 "Cancel order response: rid={} accepted={}",
553 msg.rid,
554 msg.res.cxl_rx
555 );
556 Some(vec![AxOrdersWsMessage::CancelOrderResponse(msg)])
557 }
558 AxWsOrderResponse::OpenOrders(msg) => {
559 log::debug!("Open orders response: {} orders", msg.res.orders.len());
560 Some(vec![AxOrdersWsMessage::OpenOrdersResponse(msg)])
561 }
562 AxWsOrderResponse::List(msg) => self.handle_login(epoch, &msg),
563 }
564 }
565
566 fn fail_login(&mut self, error: String) -> Vec<AxOrdersWsMessage> {
567 log::error!("{error}");
568 self.awaiting_login = false;
569 self.authenticated_epoch = None;
570 self.login_deadline = None;
571 self.session_failed = true;
572 self.auth_tracker.fail(error.clone());
573 vec![AxOrdersWsMessage::Error(AxWsError::new(error))]
574 }
575
576 fn handle_login(
577 &mut self,
578 epoch: u64,
579 msg: &AxWsListResponse,
580 ) -> Option<Vec<AxOrdersWsMessage>> {
581 if self.session_failed {
582 log::warn!("Ignoring orders WebSocket login after session failure");
583 return None;
584 }
585
586 if self.cancel_on_disconnect.is_some()
587 && self
588 .inner
589 .as_ref()
590 .is_some_and(|inner| inner.connection_epoch() != epoch)
591 {
592 log::warn!("Ignoring stale orders WebSocket login: epoch={epoch}");
593 return None;
594 }
595
596 let order_count = msg.res.o.as_ref().map_or(0, |o| o.len());
597 log::debug!(
598 "List subscription response: rid={} li={} orders={}",
599 msg.rid,
600 msg.res.li,
601 order_count
602 );
603
604 let expected = self.cancel_on_disconnect?;
605 let acknowledged = msg.res.cod;
606 let accepted = if expected {
607 acknowledged == Some(true)
608 } else {
609 acknowledged != Some(true)
610 };
611
612 if !accepted {
613 let error = format!(
614 "AX cancel-on-disconnect acknowledgment mismatch: expected {expected}, was {acknowledged:?}"
615 );
616 log::error!("{error}");
617 return Some(self.fail_login(error));
618 }
619
620 self.awaiting_login = false;
621 self.authenticated_epoch = Some(epoch);
622 self.login_deadline = None;
623 self.has_authenticated_session = true;
624 self.auth_tracker.succeed();
625 Some(vec![AxOrdersWsMessage::Authenticated])
626 }
627
628 fn handle_event(&self, event: AxWsOrderEvent) -> Option<Vec<AxOrdersWsMessage>> {
629 if matches!(event, AxWsOrderEvent::Heartbeat) {
630 log::trace!("Received heartbeat");
631 return None;
632 }
633 Some(vec![AxOrdersWsMessage::Event(Box::new(event))])
634 }
635}
636
637#[cfg(test)]
638mod tests {
639 use std::sync::{Arc, atomic::AtomicBool};
640
641 use dashmap::DashMap;
642 use futures_util::StreamExt;
643 use nautilus_core::time::get_atomic_clock_realtime;
644 use nautilus_model::{
645 identifiers::{AccountId, InstrumentId, StrategyId, TraderId},
646 types::{Currency, Money},
647 };
648 use nautilus_network::websocket::{AuthTracker, WebSocketConfig, auth::AuthState};
649 use rstest::rstest;
650 use rust_decimal::Decimal;
651 use ustr::Ustr;
652
653 use super::*;
654 use crate::{
655 common::enums::{AxOrderSide, AxTimeInForce},
656 execution::create_order_filled,
657 websocket::{
658 messages::{
659 AxWsListResponse, AxWsListResult, AxWsOrderError, AxWsOrderErrorResponse,
660 AxWsOrderFilled, AxWsPlaceOrderResponse, AxWsPlaceOrderResult,
661 },
662 orders::OrdersCaches,
663 },
664 };
665
666 fn test_handler(cancel_on_disconnect: Option<bool>) -> AxOrdersWsFeedHandler {
667 let (_cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
668 let (_raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
669 AxOrdersWsFeedHandler::new(
670 Arc::new(AtomicBool::new(false)),
671 cmd_rx,
672 raw_rx,
673 AuthTracker::default(),
674 cancel_on_disconnect,
675 Arc::new(DashMap::new()),
676 Arc::new(DashMap::new()),
677 )
678 }
679
680 fn login(cod: Option<bool>) -> AxWsListResponse {
681 AxWsListResponse {
682 rid: 0,
683 res: AxWsListResult {
684 li: "test-user".to_string(),
685 o: Some(vec![]),
686 cod,
687 chb: None,
688 },
689 }
690 }
691
692 async fn connected_client() -> (WebSocketClient, tokio::task::JoinHandle<()>) {
693 let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
694 let addr = listener.local_addr().unwrap();
695 let server = tokio::spawn(async move {
696 let (socket, _) = listener.accept().await.unwrap();
697 let mut socket = tokio_tungstenite::accept_async(socket).await.unwrap();
698 while socket.next().await.is_some() {}
699 });
700
701 let config = WebSocketConfig::builder()
702 .url(format!("ws://{addr}"))
703 .build()
704 .unwrap();
705 let (_, client) = WebSocketClient::stream_builder()
706 .config(config)
707 .connect()
708 .await
709 .unwrap();
710 (client, server)
711 }
712
713 #[tokio::test]
714 async fn test_order_writes_wait_for_login_after_reconnect() {
715 let mut handler = test_handler(Some(true));
716
717 let request = AxWsGetOpenOrders {
718 rid: 72,
719 t: AxOrderRequestType::GetOpenOrders,
720 };
721
722 let error = handler.send_json(&request).await.unwrap_err();
723 assert!(matches!(
724 error,
725 OrderSendError::NotSent(reason) if reason == "Orders WebSocket session login pending"
726 ));
727
728 let messages = handler
729 .handle_response(0, AxWsOrderResponse::List(login(Some(true))))
730 .unwrap();
731 assert!(matches!(
732 messages.as_slice(),
733 [AxOrdersWsMessage::Authenticated]
734 ));
735 assert!(handler.auth_tracker.is_authenticated());
736
737 handler.authenticated_epoch = Some(1);
738 let messages = handler
739 .parse_raw_message(0, Message::Text(nautilus_network::RECONNECTED.into()))
740 .unwrap();
741 assert!(matches!(
742 messages.as_slice(),
743 [AxOrdersWsMessage::Reconnected]
744 ));
745 assert_eq!(
746 handler.auth_tracker.auth_state(),
747 AuthState::Unauthenticated
748 );
749
750 let error = handler.send_json(&request).await.unwrap_err();
751 assert!(matches!(
752 error,
753 OrderSendError::NotSent(reason) if reason == "Orders WebSocket session login pending"
754 ));
755
756 let messages = handler
757 .handle_response(0, AxWsOrderResponse::List(login(Some(true))))
758 .unwrap();
759 assert!(matches!(
760 messages.as_slice(),
761 [AxOrdersWsMessage::Authenticated]
762 ));
763 let error = handler.send_json(&request).await.unwrap_err();
764 assert!(matches!(
765 error,
766 OrderSendError::NotSent(reason) if reason == "No WebSocket client available"
767 ));
768 }
769
770 #[tokio::test]
771 async fn test_early_login_is_preserved_and_stale_epoch_is_rejected() {
772 let (inner, server) = connected_client().await;
773 let mut handler = test_handler(Some(true));
774 handler.inner = Some(inner);
775
776 let request = AxWsGetOpenOrders {
777 rid: 72,
778 t: AxOrderRequestType::GetOpenOrders,
779 };
780
781 handler.handle_response(0, AxWsOrderResponse::List(login(Some(true))));
782 tokio::time::timeout(Duration::from_secs(1), handler.send_json(&request))
783 .await
784 .unwrap()
785 .unwrap();
786 handler.parse_raw_message(0, Message::Text(nautilus_network::RECONNECTED.into()));
787
788 assert!(!handler.awaiting_login);
789 assert_eq!(handler.authenticated_epoch, Some(0));
790 assert_eq!(handler.login_deadline, None);
791 assert!(handler.auth_tracker.is_authenticated());
792
793 handler.authenticated_epoch = Some(1);
794 let error = handler.send_json(&request).await.unwrap_err();
795 assert!(matches!(
796 error,
797 OrderSendError::Ambiguous(reason) if reason == "Orders WebSocket session changed before login"
798 ));
799
800 handler.inner.take().unwrap().disconnect().await;
801 server.abort();
802 }
803
804 #[tokio::test]
805 async fn test_stale_login_does_not_authenticate_current_connection() {
806 let (inner, server) = connected_client().await;
807 let mut handler = test_handler(Some(true));
808 handler.inner = Some(inner);
809
810 let messages = handler.handle_response(1, AxWsOrderResponse::List(login(Some(true))));
811
812 assert!(messages.is_none());
813 assert_eq!(handler.authenticated_epoch, None);
814 assert!(handler.awaiting_login);
815 assert!(!handler.auth_tracker.is_authenticated());
816 assert!(handler.login_deadline.is_some());
817
818 handler.handle_response(0, AxWsOrderResponse::List(login(Some(true))));
819 assert_eq!(handler.authenticated_epoch, Some(0));
820 assert!(handler.auth_tracker.is_authenticated());
821 handler.inner.take().unwrap().disconnect().await;
822 server.abort();
823 }
824
825 #[tokio::test]
826 async fn test_set_client_is_processed_before_initial_login() {
827 let (inner, server) = connected_client().await;
828 let (cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
829 let (raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
830
831 let mut handler = AxOrdersWsFeedHandler::new(
832 Arc::new(AtomicBool::new(false)),
833 cmd_rx,
834 raw_rx,
835 AuthTracker::default(),
836 Some(true),
837 Arc::new(DashMap::new()),
838 Arc::new(DashMap::new()),
839 );
840 cmd_tx.send(HandlerCommand::SetClient(inner)).unwrap();
841 raw_tx
842 .send((
843 0,
844 Message::Text(r#"{"rid":0,"res":{"li":"test-user","o":[],"cod":true}}"#.into()),
845 ))
846 .unwrap();
847
848 let message = handler.next().await.unwrap();
849
850 assert!(matches!(message, AxOrdersWsMessage::Authenticated));
851 assert_eq!(handler.authenticated_epoch, Some(0));
852 assert!(handler.auth_tracker.is_authenticated());
853 handler.inner.take().unwrap().disconnect().await;
854 server.abort();
855 }
856
857 #[tokio::test]
858 async fn test_order_writes_stop_after_cancel_on_disconnect_mismatch() {
859 let mut handler = test_handler(Some(true));
860
861 let request = AxWsGetOpenOrders {
862 rid: 72,
863 t: AxOrderRequestType::GetOpenOrders,
864 };
865
866 let messages = handler
867 .handle_response(0, AxWsOrderResponse::List(login(Some(false))))
868 .unwrap();
869
870 assert!(matches!(messages.as_slice(), [AxOrdersWsMessage::Error(_)]));
871 assert!(handler.session_failed);
872 assert!(!handler.auth_tracker.is_authenticated());
873 let error = handler.send_json(&request).await.unwrap_err();
874 assert!(matches!(
875 error,
876 OrderSendError::NotSent(reason) if reason == "Orders WebSocket session authentication failed"
877 ));
878 }
879
880 #[tokio::test]
881 async fn test_failed_session_drains_buffered_commands_before_close() {
882 let (cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
883 let (_raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
884
885 let mut handler = AxOrdersWsFeedHandler::new(
886 Arc::new(AtomicBool::new(false)),
887 cmd_rx,
888 raw_rx,
889 AuthTracker::default(),
890 Some(true),
891 Arc::new(DashMap::new()),
892 Arc::new(DashMap::new()),
893 );
894 handler.session_failed = true;
895 handler.awaiting_login = false;
896 let client_order_id = ClientOrderId::from("CID-SHUTDOWN");
897 let command_id = UUID4::new();
898
899 let order_info = WsOrderInfo {
900 client_order_id,
901 symbol: Ustr::from("EURUSD-PERP"),
902 cid: 42,
903 };
904
905 cmd_tx
906 .send(HandlerCommand::PlaceOrder {
907 request_id: 1,
908 order: AxWsPlaceOrder {
909 rid: 1,
910 t: AxOrderRequestType::PlaceOrder,
911 s: order_info.symbol,
912 d: AxOrderSide::Buy,
913 q: 1,
914 p: Decimal::from(100),
915 tif: AxTimeInForce::Gtc,
916 po: true,
917 st: None,
918 tag: None,
919 cid: Some(order_info.cid),
920 },
921 order_info,
922 })
923 .unwrap();
924
925 cmd_tx
926 .send(HandlerCommand::CancelOrder {
927 request_id: 2,
928 order_id: "OID-SHUTDOWN".to_string(),
929 client_order_id,
930 command_id: Some(command_id),
931 })
932 .unwrap();
933
934 let place = handler.next().await.unwrap();
935 assert!(matches!(
936 place,
937 AxOrdersWsMessage::PlaceOrderError {
938 client_order_id: id,
939 reason,
940 } if id == client_order_id && reason == "Orders WebSocket session authentication failed"
941 ));
942 let cancel = handler.next().await.unwrap();
943 assert!(matches!(
944 cancel,
945 AxOrdersWsMessage::CancelOrderError {
946 client_order_id: id,
947 reason,
948 command_id: actual_command_id,
949 } if id == client_order_id
950 && reason == "Orders WebSocket session authentication failed"
951 && actual_command_id == Some(command_id)
952 ));
953 assert!(
954 cmd_tx
955 .send(HandlerCommand::GetOpenOrders { request_id: 3 })
956 .is_err()
957 );
958 assert!(handler.next().await.is_none());
959 assert!(handler.pending_orders.is_empty());
960 }
961
962 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
963 async fn test_failed_session_drains_concurrent_commands() {
964 let (cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
965 let (_raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
966
967 let mut handler = AxOrdersWsFeedHandler::new(
968 Arc::new(AtomicBool::new(false)),
969 cmd_rx,
970 raw_rx,
971 AuthTracker::default(),
972 Some(true),
973 Arc::new(DashMap::new()),
974 Arc::new(DashMap::new()),
975 );
976 handler.session_failed = true;
977 handler.awaiting_login = false;
978 let client_order_id = ClientOrderId::from("CID-CONCURRENT-SHUTDOWN");
979
980 let order_info = WsOrderInfo {
981 client_order_id,
982 symbol: Ustr::from("EURUSD-PERP"),
983 cid: 42,
984 };
985
986 let command_count = 32;
987 let barrier = Arc::new(tokio::sync::Barrier::new(command_count + 1));
988 let mut senders = Vec::with_capacity(command_count);
989
990 for index in 0..command_count {
991 let cmd_tx = cmd_tx.clone();
992 let barrier = barrier.clone();
993 let order_info = order_info.clone();
994
995 senders.push(tokio::spawn(async move {
996 barrier.wait().await;
997 cmd_tx
998 .send(HandlerCommand::PlaceOrder {
999 request_id: index as i64,
1000 order: AxWsPlaceOrder {
1001 rid: index as i64,
1002 t: AxOrderRequestType::PlaceOrder,
1003 s: order_info.symbol,
1004 d: AxOrderSide::Buy,
1005 q: 1,
1006 p: Decimal::from(100),
1007 tif: AxTimeInForce::Gtc,
1008 po: true,
1009 st: None,
1010 tag: None,
1011 cid: Some(order_info.cid),
1012 },
1013 order_info,
1014 })
1015 .is_ok()
1016 }));
1017 }
1018
1019 barrier.wait().await;
1020 let mut rejected = 0;
1021
1022 while let Some(message) = handler.next().await {
1023 assert!(matches!(
1024 message,
1025 AxOrdersWsMessage::PlaceOrderError {
1026 client_order_id: id,
1027 ..
1028 } if id == client_order_id
1029 ));
1030 rejected += 1;
1031 }
1032
1033 let accepted = futures_util::future::join_all(senders)
1034 .await
1035 .into_iter()
1036 .filter(|result| matches!(result, Ok(true)))
1037 .count();
1038
1039 assert_eq!(rejected, accepted);
1040 assert!(handler.pending_orders.is_empty());
1041 }
1042
1043 #[tokio::test]
1044 async fn test_late_login_does_not_authenticate_failed_session() {
1045 let mut handler = test_handler(Some(true));
1046 handler.session_failed = true;
1047 handler.auth_tracker.fail("login failed");
1048
1049 let messages = handler.handle_response(0, AxWsOrderResponse::List(login(Some(true))));
1050
1051 assert!(messages.is_none());
1052 assert!(handler.session_failed);
1053 assert!(!handler.auth_tracker.is_authenticated());
1054 }
1055
1056 #[tokio::test]
1057 async fn test_gate_rejections_carry_client_order_id() {
1058 let mut handler = test_handler(Some(true));
1059 let client_order_id = ClientOrderId::from("CID-GATE");
1060 let command_id = UUID4::new();
1061
1062 let order_info = WsOrderInfo {
1063 client_order_id,
1064 symbol: Ustr::from("EURUSD-PERP"),
1065 cid: 42,
1066 };
1067
1068 handler
1069 .handle_command(HandlerCommand::PlaceOrder {
1070 request_id: 1,
1071 order: AxWsPlaceOrder {
1072 rid: 1,
1073 t: AxOrderRequestType::PlaceOrder,
1074 s: order_info.symbol,
1075 d: AxOrderSide::Buy,
1076 q: 1,
1077 p: Decimal::from(100),
1078 tif: AxTimeInForce::Gtc,
1079 po: true,
1080 st: None,
1081 tag: None,
1082 cid: Some(order_info.cid),
1083 },
1084 order_info,
1085 })
1086 .await;
1087
1088 handler
1089 .handle_command(HandlerCommand::CancelOrder {
1090 request_id: 2,
1091 order_id: "OID-GATE".to_string(),
1092 client_order_id,
1093 command_id: Some(command_id),
1094 })
1095 .await;
1096
1097 let place = handler.message_queue.pop_front().unwrap();
1098 assert!(matches!(
1099 place,
1100 AxOrdersWsMessage::PlaceOrderError {
1101 client_order_id: id,
1102 reason,
1103 } if id == client_order_id && reason == "Orders WebSocket session login pending"
1104 ));
1105 let cancel = handler.message_queue.pop_front().unwrap();
1106 assert!(matches!(
1107 cancel,
1108 AxOrdersWsMessage::CancelOrderError {
1109 client_order_id: id,
1110 reason,
1111 command_id: actual_command_id,
1112 } if id == client_order_id
1113 && reason == "Orders WebSocket session login pending"
1114 && actual_command_id == Some(command_id)
1115 ));
1116 }
1117
1118 #[tokio::test]
1119 async fn test_login_timeout_emits_error_before_close() {
1120 let (_cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
1121 let (_raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
1122
1123 let mut handler = AxOrdersWsFeedHandler::new(
1124 Arc::new(AtomicBool::new(false)),
1125 cmd_rx,
1126 raw_rx,
1127 AuthTracker::default(),
1128 Some(true),
1129 Arc::new(DashMap::new()),
1130 Arc::new(DashMap::new()),
1131 );
1132 handler.login_deadline = Some(tokio::time::Instant::now());
1133
1134 let message = handler.next().await.unwrap();
1135 assert!(matches!(
1136 message,
1137 AxOrdersWsMessage::Error(AxWsError { message, .. }) if message == "Orders WebSocket login timed out"
1138 ));
1139 assert!(handler.next().await.is_none());
1140 }
1141
1142 #[rstest]
1143 fn test_late_place_order_response_does_not_restore_cleared_tracking() {
1144 let mut handler = test_handler(None);
1145 let request_id = 12;
1146 let client_order_id = ClientOrderId::from("CID-12");
1147 handler.pending_orders.insert(
1148 request_id,
1149 WsOrderInfo {
1150 client_order_id,
1151 symbol: Ustr::from("EURUSD-PERP"),
1152 cid: 1012,
1153 },
1154 );
1155
1156 let response = AxWsOrderResponse::PlaceOrder(AxWsPlaceOrderResponse {
1157 rid: request_id,
1158 res: AxWsPlaceOrderResult {
1159 oid: "OID-12".to_string(),
1160 },
1161 });
1162
1163 let messages = handler.handle_response(0, response).unwrap();
1164
1165 assert_eq!(messages.len(), 1);
1166 assert!(handler.pending_orders.get(&request_id).is_none());
1167 assert!(!handler.orders_metadata.contains_key(&client_order_id));
1168 assert!(handler.venue_to_client_order_id.is_empty());
1169 }
1170
1171 #[rstest]
1172 fn test_place_order_error_preserves_cid_for_reconciliation() {
1173 let mut handler = test_handler(None);
1174 let request_id = 13;
1175 let cid = 1013;
1176 let client_order_id = ClientOrderId::from("CID-13");
1177 handler
1178 .orders_metadata
1179 .insert(client_order_id, test_order_metadata(client_order_id));
1180 handler.pending_orders.insert(
1181 request_id,
1182 WsOrderInfo {
1183 client_order_id,
1184 symbol: Ustr::from("EURUSD-PERP"),
1185 cid,
1186 },
1187 );
1188
1189 let messages = handler
1190 .handle_raw_message(
1191 0,
1192 AxOrdersWsFrame::Error(AxWsOrderErrorResponse {
1193 rid: request_id,
1194 err: AxWsOrderError {
1195 code: Some(400),
1196 msg: Some("invalid order".to_string()),
1197 },
1198 }),
1199 )
1200 .unwrap();
1201
1202 assert_eq!(messages.len(), 1);
1203 assert_eq!(
1204 handler
1205 .pending_orders
1206 .get(&request_id)
1207 .unwrap()
1208 .client_order_id,
1209 client_order_id,
1210 );
1211 assert!(handler.orders_metadata.contains_key(&client_order_id));
1212 handler.handle_response(
1213 0,
1214 AxWsOrderResponse::PlaceOrder(AxWsPlaceOrderResponse {
1215 rid: request_id,
1216 res: AxWsPlaceOrderResult {
1217 oid: "OID-13".to_string(),
1218 },
1219 }),
1220 );
1221
1222 assert_eq!(
1223 handler
1224 .orders_metadata
1225 .get(&client_order_id)
1226 .unwrap()
1227 .venue_order_id,
1228 Some(VenueOrderId::from("OID-13"))
1229 );
1230 assert_eq!(
1231 *handler
1232 .venue_to_client_order_id
1233 .get(&VenueOrderId::from("OID-13"))
1234 .unwrap(),
1235 client_order_id
1236 );
1237 }
1238
1239 #[rstest]
1240 #[case::known_unsent(true, false)]
1241 #[case::ambiguous_request_error(false, true)]
1242 #[tokio::test]
1243 async fn test_place_error_tracking_depends_on_send_certainty(
1244 #[case] send_failure: bool,
1245 #[case] expect_pending: bool,
1246 ) {
1247 let mut handler = test_handler(None);
1248 let client_order_id = ClientOrderId::from("CID-UNCERTAIN");
1249 let request_id = 17;
1250 let cid = 1017;
1251 handler
1252 .orders_metadata
1253 .insert(client_order_id, test_order_metadata(client_order_id));
1254
1255 let order_info = WsOrderInfo {
1256 client_order_id,
1257 symbol: Ustr::from("EURUSD-PERP"),
1258 cid,
1259 };
1260
1261 if send_failure {
1262 handler
1263 .handle_command(HandlerCommand::PlaceOrder {
1264 request_id,
1265 order: AxWsPlaceOrder {
1266 rid: request_id,
1267 t: AxOrderRequestType::PlaceOrder,
1268 s: order_info.symbol,
1269 d: AxOrderSide::Buy,
1270 q: 100,
1271 p: Decimal::from(50000),
1272 tif: AxTimeInForce::Gtc,
1273 po: false,
1274 st: None,
1275 tag: None,
1276 cid: Some(cid),
1277 },
1278 order_info,
1279 })
1280 .await;
1281
1282 assert!(matches!(
1283 handler.message_queue.pop_front(),
1284 Some(AxOrdersWsMessage::PlaceOrderError { .. })
1285 ));
1286 } else {
1287 handler.pending_orders.insert(request_id, order_info);
1288 handler.handle_raw_message(
1289 0,
1290 AxOrdersWsFrame::Error(AxWsOrderErrorResponse {
1291 rid: request_id,
1292 err: AxWsOrderError {
1293 code: Some(500),
1294 msg: Some("unresolved request".to_string()),
1295 },
1296 }),
1297 );
1298 }
1299
1300 if !expect_pending {
1301 assert!(handler.pending_orders.get(&request_id).is_none());
1302 return;
1303 }
1304
1305 let caches = OrdersCaches {
1306 orders_metadata: handler.orders_metadata.clone(),
1307 venue_to_client_id: handler.venue_to_client_order_id.clone(),
1308 cid_to_client_order_id: Arc::new(DashMap::new()),
1309 ..OrdersCaches::default()
1310 };
1311
1312 caches.cid_to_client_order_id.insert(cid, client_order_id);
1313 let mut fill: AxWsOrderFilled =
1314 serde_json::from_str(include_str!("../../../test_data/ws_order_filled.json")).unwrap();
1315 fill.o.cid = Some(cid);
1316 let event = create_order_filled(
1317 &fill.o,
1318 &fill.xs,
1319 fill.ts,
1320 fill.tn,
1321 &caches,
1322 AccountId::from("AX-001"),
1323 Money::from("1.23 USD"),
1324 get_atomic_clock_realtime(),
1325 )
1326 .expect("fill after uncertain error must remain tracked");
1327
1328 assert_eq!(event.client_order_id, client_order_id);
1329 assert_eq!(event.trader_id, TraderId::from("TRADER-001"));
1330 assert_eq!(event.strategy_id, StrategyId::from("S-001"));
1331 assert_eq!(event.instrument_id, InstrumentId::from("EURUSD-PERP.AX"));
1332 assert_eq!(event.last_qty.as_decimal(), Decimal::from(100));
1333 assert_eq!(event.last_px.as_decimal(), Decimal::from(50000));
1334 assert_eq!(event.commission, Some(Money::from("1.23 USD")));
1335 assert_eq!(
1336 handler
1337 .pending_orders
1338 .get(&request_id)
1339 .unwrap()
1340 .client_order_id,
1341 client_order_id
1342 );
1343 assert_eq!(
1344 *caches.cid_to_client_order_id.get(&cid).unwrap(),
1345 client_order_id
1346 );
1347 }
1348
1349 #[rstest]
1350 fn test_late_place_response_preserves_replacement_binding() {
1351 let mut handler = test_handler(None);
1352 let client_order_id = ClientOrderId::from("CID-REPLACED");
1353 let replacement_id = VenueOrderId::from("OID-CHILD");
1354 let mut metadata = test_order_metadata(client_order_id);
1355 metadata.venue_order_id = Some(replacement_id);
1356 handler.orders_metadata.insert(client_order_id, metadata);
1357 handler
1358 .venue_to_client_order_id
1359 .insert(replacement_id, client_order_id);
1360 handler.pending_orders.insert(
1361 18,
1362 WsOrderInfo {
1363 client_order_id,
1364 symbol: Ustr::from("EURUSD-PERP"),
1365 cid: 1018,
1366 },
1367 );
1368
1369 handler.handle_response(
1370 0,
1371 AxWsOrderResponse::PlaceOrder(AxWsPlaceOrderResponse {
1372 rid: 18,
1373 res: AxWsPlaceOrderResult {
1374 oid: "OID-PARENT".to_string(),
1375 },
1376 }),
1377 );
1378
1379 assert_eq!(
1380 handler
1381 .orders_metadata
1382 .get(&client_order_id)
1383 .unwrap()
1384 .venue_order_id,
1385 Some(replacement_id)
1386 );
1387 assert_eq!(
1388 *handler
1389 .venue_to_client_order_id
1390 .get(&replacement_id)
1391 .unwrap(),
1392 client_order_id
1393 );
1394 assert_eq!(handler.venue_to_client_order_id.len(), 1);
1395 }
1396
1397 #[rstest]
1398 fn test_handle_event_suppresses_heartbeat() {
1399 let handler = test_handler(None);
1400
1401 let event = AxWsOrderEvent::Heartbeat;
1402 let result = handler.handle_event(event);
1403 assert!(result.is_none());
1404 }
1405
1406 fn test_order_metadata(client_order_id: ClientOrderId) -> OrderMetadata {
1407 OrderMetadata {
1408 trader_id: TraderId::from("TRADER-001"),
1409 strategy_id: StrategyId::from("S-001"),
1410 instrument_id: InstrumentId::from("EURUSD-PERP.AX"),
1411 client_order_id,
1412 order_init: None,
1413 is_accepted: false,
1414 venue_order_id: None,
1415 ts_init: 0.into(),
1416 size_precision: 0,
1417 price_precision: 2,
1418 quote_currency: Currency::USD(),
1419 }
1420 }
1421}