1use std::{
23 cell::{OnceCell, RefCell},
24 fmt::Debug,
25 rc::Rc,
26};
27
28use ahash::AHashMap;
29use indexmap::IndexMap;
30#[cfg(feature = "python")]
31use nautilus_common::python::wrappers::release_python_wrapper;
32use nautilus_common::{
33 actor::{
34 DataActor, DataActorNative,
35 registry::{deregister_actor, try_get_actor_unchecked},
36 },
37 cache::Cache,
38 clock::Clock,
39 component::{
40 Component, component_state, deregister_component, dispose_component,
41 register_component_actor, release_component_subscriptions, reset_component,
42 start_component, stop_component,
43 },
44 enums::{ComponentState, ComponentTrigger, Environment},
45 logging::RECV,
46 messages::execution::TradingCommand,
47 msgbus,
48 msgbus::{
49 ShareableMessageHandler, TypedHandler, get_message_bus,
50 switchboard::{get_event_order_topic, get_event_position_topic},
51 },
52 timer::{TimeEvent, TimeEventCallback},
53};
54use nautilus_core::{UUID4, UnixNanos};
55use nautilus_model::{
56 events::{OrderEventAny, PositionEvent},
57 identifiers::{
58 ActorId, ComponentId, ExecAlgorithmId, StrategyId, TraderId, check_order_id_tag,
59 normalize_order_id_tag,
60 },
61 orders::Order,
62};
63use nautilus_portfolio::portfolio::Portfolio;
64use nautilus_trading::{
65 ExecutionAlgorithm, ExecutionAlgorithmNative,
66 strategy::{Strategy, StrategyNative, route_time_event},
67};
68use ustr::Ustr;
69
70use crate::{
71 clock_factory::ClockFactory,
72 registration::{
73 base_strategy_id, ensure_unique_order_id_tag, next_order_id_tag, strategy_control_endpoint,
74 strategy_registration_id,
75 },
76};
77
78#[derive(Debug, Clone, Copy, PartialEq, Eq)]
79pub(crate) enum StrategyCommand {
80 ExitMarket,
81}
82
83type ExecutionAlgorithmSubscriptionFn = Box<dyn FnMut() -> anyhow::Result<()>>;
84type PersistedComponentState = IndexMap<String, Vec<u8>>;
85type ComponentStateLoadFn = fn(Ustr, PersistedComponentState) -> anyhow::Result<()>;
86type ComponentStateSaveFn = fn(Ustr) -> anyhow::Result<PersistedComponentState>;
87
88#[derive(Clone, Copy)]
89struct ComponentStateCallbacks {
90 load: ComponentStateLoadFn,
91 save: ComponentStateSaveFn,
92}
93
94pub struct Trader {
110 pub trader_id: TraderId,
112 pub instance_id: UUID4,
114 pub environment: Environment,
116 state: ComponentState,
118 clock_factory: ClockFactory,
120 pub(crate) cache: Rc<RefCell<Cache>>,
122 pub(crate) portfolio: Rc<RefCell<Portfolio>>,
124 pub(crate) actor_ids: Vec<ActorId>,
126 actor_state_callbacks: AHashMap<ActorId, ComponentStateCallbacks>,
128 pub(crate) strategy_ids: Vec<StrategyId>,
130 strategy_state_callbacks: AHashMap<StrategyId, ComponentStateCallbacks>,
132 strategy_stop_fns: AHashMap<StrategyId, Box<dyn FnMut() -> bool>>,
134 strategy_handler_ids: AHashMap<StrategyId, (Ustr, Ustr)>,
136 pub(crate) exec_algorithm_ids: Vec<ExecAlgorithmId>,
138 exec_algorithm_restore_fns: AHashMap<ExecAlgorithmId, ExecutionAlgorithmSubscriptionFn>,
140 exec_algorithm_cleanup_fns: AHashMap<ExecAlgorithmId, ExecutionAlgorithmSubscriptionFn>,
142 pub(crate) clocks: IndexMap<ComponentId, Rc<RefCell<dyn Clock>>>,
144 clocks_snapshot: OnceCell<ComponentClockSnapshot>,
145 ts_created: UnixNanos,
147 ts_started: Option<UnixNanos>,
149 ts_stopped: Option<UnixNanos>,
151}
152
153impl Debug for Trader {
154 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
155 write!(f, "{:?}", stringify!(TraderId)) }
157}
158
159impl Trader {
160 #[must_use]
162 pub fn new(
163 trader_id: TraderId,
164 instance_id: UUID4,
165 environment: Environment,
166 clock_factory: ClockFactory,
167 cache: Rc<RefCell<Cache>>,
168 portfolio: Rc<RefCell<Portfolio>>,
169 ) -> Self {
170 let clock = clock_factory.clock();
171 let ts_created = clock.borrow().timestamp_ns();
172
173 Self {
174 trader_id,
175 instance_id,
176 environment,
177 state: ComponentState::PreInitialized,
178 clock_factory,
179 cache,
180 portfolio,
181 actor_ids: Vec::new(),
182 actor_state_callbacks: AHashMap::new(),
183 strategy_ids: Vec::new(),
184 strategy_state_callbacks: AHashMap::new(),
185 strategy_stop_fns: AHashMap::new(),
186 strategy_handler_ids: AHashMap::new(),
187 exec_algorithm_ids: Vec::new(),
188 exec_algorithm_restore_fns: AHashMap::new(),
189 exec_algorithm_cleanup_fns: AHashMap::new(),
190 clocks: IndexMap::new(),
191 clocks_snapshot: OnceCell::new(),
192 ts_created,
193 ts_started: None,
194 ts_stopped: None,
195 }
196 }
197
198 #[must_use]
200 pub const fn trader_id(&self) -> TraderId {
201 self.trader_id
202 }
203
204 #[must_use]
206 pub const fn instance_id(&self) -> UUID4 {
207 self.instance_id
208 }
209
210 #[must_use]
212 pub const fn environment(&self) -> Environment {
213 self.environment
214 }
215
216 #[must_use]
218 pub const fn state(&self) -> ComponentState {
219 self.state
220 }
221
222 #[must_use]
224 pub const fn ts_created(&self) -> UnixNanos {
225 self.ts_created
226 }
227
228 #[must_use]
230 pub const fn ts_started(&self) -> Option<UnixNanos> {
231 self.ts_started
232 }
233
234 #[must_use]
236 pub const fn ts_stopped(&self) -> Option<UnixNanos> {
237 self.ts_stopped
238 }
239
240 #[must_use]
242 pub const fn actor_count(&self) -> usize {
243 self.actor_ids.len()
244 }
245
246 #[must_use]
248 pub const fn strategy_count(&self) -> usize {
249 self.strategy_ids.len()
250 }
251
252 #[must_use]
254 pub const fn exec_algorithm_count(&self) -> usize {
255 self.exec_algorithm_ids.len()
256 }
257
258 #[must_use]
260 pub fn get_component_clocks(&self) -> Vec<Rc<RefCell<dyn Clock>>> {
261 self.get_component_clocks_snapshot().to_vec()
262 }
263
264 #[must_use]
269 pub fn get_component_clocks_snapshot(&self) -> Rc<[Rc<RefCell<dyn Clock>>]> {
270 self.clocks_snapshot
271 .get_or_init(|| self.clocks.values().cloned().collect())
272 .clone()
273 }
274
275 #[must_use]
277 pub const fn component_count(&self) -> usize {
278 self.actor_ids.len() + self.strategy_ids.len() + self.exec_algorithm_ids.len()
279 }
280
281 #[must_use]
283 pub fn actor_ids(&self) -> Vec<ActorId> {
284 self.actor_ids.clone()
285 }
286
287 #[must_use]
289 pub fn strategy_ids(&self) -> Vec<StrategyId> {
290 self.strategy_ids.clone()
291 }
292
293 #[must_use]
295 pub fn exec_algorithm_ids(&self) -> Vec<ExecAlgorithmId> {
296 self.exec_algorithm_ids.clone()
297 }
298
299 pub fn create_component_clock(&mut self, component_id: ComponentId) -> Rc<RefCell<dyn Clock>> {
305 let clock = self.clock_factory.create_component_clock();
306 self.clocks_snapshot.take();
307 self.clocks.insert(component_id, clock.clone());
308 clock
309 }
310
311 pub fn add_actor<T>(&mut self, actor: T) -> anyhow::Result<()>
319 where
320 T: DataActor + DataActorNative + Component + Debug + 'static,
321 {
322 self.validate_actor_or_strategy_registration()?;
323
324 let actor_id = actor.actor_id();
325
326 if self.actor_ids.contains(&actor_id) {
328 anyhow::bail!("Actor {actor_id} is already registered");
329 }
330
331 let component_id = ComponentId::from(actor_id);
332 self.ensure_component_id_available(component_id)?;
333 let clock = self.create_component_clock(component_id);
334
335 let mut actor_mut = actor;
336 if let Err(e) = actor_mut.register(self.trader_id, clock, self.cache.clone()) {
337 self.release_component_clock(component_id);
338 return Err(e);
339 }
340
341 self.add_registered_actor(actor_mut)
342 }
343
344 pub fn add_actor_from_factory<F, T>(&mut self, factory: F) -> anyhow::Result<()>
356 where
357 F: FnOnce() -> anyhow::Result<T>,
358 T: DataActor + DataActorNative + Component + Debug + 'static,
359 {
360 let actor = factory()?;
361
362 self.add_actor(actor)
363 }
364
365 pub fn add_registered_actor<T>(&mut self, actor: T) -> anyhow::Result<()>
371 where
372 T: DataActor + DataActorNative + Component + Debug + 'static,
373 {
374 let actor_id = actor.actor_id();
375
376 register_component_actor(actor);
378
379 self.actor_ids.push(actor_id);
381 self.actor_state_callbacks.insert(
382 actor_id,
383 ComponentStateCallbacks {
384 load: Self::load_component_state::<T>,
385 save: Self::save_component_state::<T>,
386 },
387 );
388
389 log::info!("Registered actor {actor_id} with trader {}", self.trader_id);
390
391 Ok(())
392 }
393
394 pub fn add_actor_id_for_lifecycle<T>(&mut self, actor_id: ActorId) -> anyhow::Result<()>
404 where
405 T: DataActor + DataActorNative + Debug + 'static,
406 {
407 if self.actor_ids.contains(&actor_id) {
409 anyhow::bail!("Actor '{actor_id}' is already tracked by trader");
410 }
411
412 self.actor_ids.push(actor_id);
414 self.actor_state_callbacks.insert(
415 actor_id,
416 ComponentStateCallbacks {
417 load: Self::load_component_state::<T>,
418 save: Self::save_component_state::<T>,
419 },
420 );
421
422 log::debug!(
423 "Added actor ID '{actor_id}' to trader {} for lifecycle management",
424 self.trader_id
425 );
426
427 Ok(())
428 }
429
430 pub fn add_exec_algorithm_id_for_lifecycle(
440 &mut self,
441 exec_algorithm_id: ExecAlgorithmId,
442 ) -> anyhow::Result<()> {
443 if self.exec_algorithm_ids.contains(&exec_algorithm_id) {
444 anyhow::bail!("Execution algorithm '{exec_algorithm_id}' is already tracked by trader");
445 }
446
447 self.exec_algorithm_ids.push(exec_algorithm_id);
448
449 log::debug!(
450 "Added exec algorithm ID '{exec_algorithm_id}' to trader {} for lifecycle management",
451 self.trader_id
452 );
453
454 Ok(())
455 }
456
457 pub fn add_strategy_id_with_subscriptions<T>(
468 &mut self,
469 strategy_id: StrategyId,
470 ) -> anyhow::Result<()>
471 where
472 T: Strategy + StrategyNative + DataActorNative + Component + Debug + 'static,
473 {
474 if self.strategy_ids.contains(&strategy_id) {
475 anyhow::bail!("Strategy '{strategy_id}' is already tracked by trader");
476 }
477
478 let existing_order_id_tags: Vec<&str> =
479 self.strategy_ids.iter().map(StrategyId::get_tag).collect();
480 ensure_unique_order_id_tag(&existing_order_id_tags, strategy_id.get_tag())?;
481
482 let actor_id = strategy_id.inner();
483
484 let order_topic = get_event_order_topic(strategy_id);
486 let order_actor_id = actor_id;
487 let order_handler = TypedHandler::from(move |event: &OrderEventAny| {
488 if let Some(mut strategy) = try_get_actor_unchecked::<T>(&order_actor_id) {
489 strategy.handle_order_event(event.clone());
490 } else {
491 log::error!("Strategy {order_actor_id} not found for order event handling");
492 }
493 });
494 let order_handler_id = order_handler.id();
495 msgbus::subscribe_order_events(order_topic.into(), order_handler, None);
496
497 let position_topic = get_event_position_topic(strategy_id);
499 let position_handler = TypedHandler::from(move |event: &PositionEvent| {
500 if let Some(mut strategy) = try_get_actor_unchecked::<T>(&actor_id) {
501 strategy.handle_position_event(event.clone());
502 } else {
503 log::error!("Strategy {actor_id} not found for position event handling");
504 }
505 });
506 let position_handler_id = position_handler.id();
507 msgbus::subscribe_position_events(position_topic.into(), position_handler, None);
508
509 let control_actor_id = actor_id;
510 let control_handler = TypedHandler::from(move |command: &StrategyCommand| {
511 if let Some(mut strategy) = try_get_actor_unchecked::<T>(&control_actor_id) {
512 match command {
513 StrategyCommand::ExitMarket => {
514 if let Err(e) = strategy.market_exit() {
515 log::error!(
516 "Error handling strategy command for {control_actor_id}: {e}"
517 );
518 }
519 }
520 }
521 } else {
522 log::error!("Strategy {control_actor_id} not found for control handling");
523 }
524 });
525 get_message_bus()
526 .borrow_mut()
527 .endpoint_map::<StrategyCommand>()
528 .register(strategy_control_endpoint(strategy_id), control_handler);
529
530 self.strategy_ids.push(strategy_id);
531 self.strategy_state_callbacks.insert(
532 strategy_id,
533 ComponentStateCallbacks {
534 load: Self::load_component_state::<T>,
535 save: Self::save_component_state::<T>,
536 },
537 );
538 self.strategy_handler_ids
539 .insert(strategy_id, (order_handler_id, position_handler_id));
540
541 let stop_actor_id = actor_id;
543 let stop_fn = Box::new(move || -> bool {
544 if let Some(mut strategy) = try_get_actor_unchecked::<T>(&stop_actor_id) {
545 Strategy::stop(&mut *strategy)
546 } else {
547 log::error!("Strategy {stop_actor_id} not found for stop");
548 true
549 }
550 });
551 self.strategy_stop_fns.insert(strategy_id, stop_fn);
552
553 log::debug!(
554 "Added strategy '{strategy_id}' to trader {} with event subscriptions",
555 self.trader_id
556 );
557
558 Ok(())
559 }
560
561 pub fn prepare_strategy_for_registration<T>(
569 &self,
570 strategy: &mut T,
571 ) -> anyhow::Result<StrategyId>
572 where
573 T: Strategy + StrategyNative + DataActorNative + Component + Debug + 'static,
574 {
575 if let Some(order_id_tag) = StrategyNative::strategy_core(strategy)
577 .config
578 .order_id_tag
579 .as_deref()
580 {
581 check_order_id_tag(order_id_tag)?;
582 }
583
584 let existing_order_id_tags: Vec<&str> =
585 self.strategy_ids.iter().map(StrategyId::get_tag).collect();
586
587 let configured_strategy_id = StrategyNative::strategy_core(strategy).strategy_id();
588 let runtime_order_id_tag =
589 normalize_order_id_tag(StrategyNative::strategy_core(strategy).order_id_tag());
590
591 let strategy_id = if let Some(strategy_id) = configured_strategy_id {
592 ensure_unique_order_id_tag(&existing_order_id_tags, strategy_id.get_tag())?;
593 StrategyNative::strategy_core_mut(strategy).change_id(strategy_id)?;
594 strategy_id
595 } else {
596 let order_id_tag = runtime_order_id_tag.map_or_else(
597 || next_order_id_tag(&existing_order_id_tags),
598 str::to_string,
599 );
600 ensure_unique_order_id_tag(&existing_order_id_tags, &order_id_tag)?;
601
602 let base_id = strategy_registration_id::<T>(strategy);
603 let strategy_id =
604 StrategyId::new_checked(format!("{}-{order_id_tag}", base_strategy_id(&base_id)))?;
605 StrategyNative::strategy_core_mut(strategy).change_id(strategy_id)?;
606 strategy_id
607 };
608
609 if self.strategy_ids.contains(&strategy_id) {
610 anyhow::bail!("Strategy {strategy_id} is already registered");
611 }
612
613 Ok(strategy_id)
614 }
615
616 pub fn add_strategy<T>(&mut self, mut strategy: T) -> anyhow::Result<()>
628 where
629 T: Strategy + StrategyNative + DataActorNative + Component + Debug + 'static,
630 {
631 self.validate_actor_or_strategy_registration()?;
632
633 let strategy_id = self.prepare_strategy_for_registration(&mut strategy)?;
634
635 let component_id = strategy.component_id();
636 self.ensure_component_id_available(component_id)?;
637 let clock = self.create_component_clock(component_id);
638
639 if let Err(e) = StrategyNative::strategy_core_mut(&mut strategy).register(
641 self.trader_id,
642 clock.clone(),
643 self.cache.clone(),
644 self.portfolio.clone(),
645 ) {
646 self.release_component_clock(component_id);
647 return Err(e);
648 }
649
650 let actor_id = strategy.actor_id().inner();
652 let callback = TimeEventCallback::from(move |event: TimeEvent| {
653 if let Some(mut strategy) = try_get_actor_unchecked::<T>(&actor_id) {
654 log::debug!("{RECV} {event}");
655
656 if strategy.not_running() {
657 log::trace!("Received message when not running - skipping {event}");
658 return;
659 }
660
661 route_time_event(&mut *strategy, &event);
662 if let Err(e) = DataActor::on_time_event(&mut *strategy, &event) {
663 log::error!("{e}");
664 }
665 } else {
666 log::error!("Strategy {actor_id} not found for time event handling");
667 }
668 });
669 clock.borrow_mut().register_default_handler(callback);
670
671 if let Err(e) = strategy.initialize() {
673 self.release_component_clock(component_id);
674 return Err(e);
675 }
676
677 register_component_actor(strategy);
679
680 self.add_strategy_id_with_subscriptions::<T>(strategy_id)?;
681
682 log::info!(
683 "Registered strategy {strategy_id} with trader {}",
684 self.trader_id
685 );
686
687 Ok(())
688 }
689
690 pub fn add_exec_algorithm<T>(&mut self, mut exec_algorithm: T) -> anyhow::Result<()>
701 where
702 T: ExecutionAlgorithm + ExecutionAlgorithmNative + Component + Debug + 'static,
703 {
704 self.validate_exec_algorithm_registration()?;
705
706 let exec_algorithm_id = ExecAlgorithmId::new(exec_algorithm.component_id().inner());
707
708 if self.exec_algorithm_ids.contains(&exec_algorithm_id) {
709 anyhow::bail!("Execution algorithm '{exec_algorithm_id}' is already registered");
710 }
711
712 let component_id = exec_algorithm.component_id();
713 self.ensure_component_id_available(component_id)?;
714 let clock = self.create_component_clock(component_id);
715 if let Err(e) = exec_algorithm.register(self.trader_id, clock, self.cache.clone()) {
716 self.release_component_clock(component_id);
717 return Err(e);
718 }
719
720 exec_algorithm
721 .exec_algorithm_core_mut()
722 .set_portfolio(self.portfolio.clone());
723
724 register_component_actor(exec_algorithm);
725
726 let actor_id = exec_algorithm_id.inner();
729 let restore_actor_id = actor_id;
730 let restore_fn: ExecutionAlgorithmSubscriptionFn = Box::new(move || {
731 let Some(mut algo) = try_get_actor_unchecked::<T>(&restore_actor_id) else {
732 anyhow::bail!(
733 "Execution algorithm {restore_actor_id} not found while restoring subscriptions"
734 );
735 };
736
737 let mut strategy_ids = {
738 let cache = algo.exec_algorithm_core_mut().cache_ref();
739 cache
740 .orders_for_exec_algorithm(&exec_algorithm_id, None, None, None, None, None)
741 .into_iter()
742 .filter(|order| {
743 !order.is_closed() && order.exec_algorithm_id() == Some(exec_algorithm_id)
744 })
745 .map(|order| order.strategy_id())
746 .collect::<Vec<_>>()
747 };
748 strategy_ids.sort_unstable();
749 strategy_ids.dedup();
750
751 for strategy_id in strategy_ids {
752 algo.subscribe_to_strategy_events(strategy_id);
753 }
754
755 Ok(())
756 });
757 let cleanup_actor_id = actor_id;
758 let cleanup_fn: ExecutionAlgorithmSubscriptionFn = Box::new(move || {
759 let Some(mut algo) = try_get_actor_unchecked::<T>(&cleanup_actor_id) else {
760 anyhow::bail!(
761 "Execution algorithm {cleanup_actor_id} not found while cleaning subscriptions"
762 );
763 };
764 algo.unsubscribe_all_strategy_events();
765 Ok(())
766 });
767 let endpoint: Ustr = format!("{exec_algorithm_id}.execute").into();
768 let handler = ShareableMessageHandler::from_typed(move |command: &TradingCommand| {
769 if let Some(mut algo) = try_get_actor_unchecked::<T>(&actor_id) {
770 if let Err(e) = algo.execute(command.clone()) {
771 log::error!("Error executing command on algorithm {actor_id}: {e}");
772 }
773 } else {
774 log::error!("Execution algorithm {actor_id} not found in registry");
775 }
776 });
777 msgbus::register_any(endpoint.into(), handler);
778
779 self.exec_algorithm_ids.push(exec_algorithm_id);
780 self.exec_algorithm_restore_fns
781 .insert(exec_algorithm_id, restore_fn);
782 self.exec_algorithm_cleanup_fns
783 .insert(exec_algorithm_id, cleanup_fn);
784
785 log::info!(
786 "Registered execution algorithm {exec_algorithm_id} with trader {}",
787 self.trader_id
788 );
789
790 Ok(())
791 }
792
793 pub(crate) fn ensure_component_id_available(
798 &self,
799 component_id: ComponentId,
800 ) -> anyhow::Result<()> {
801 let id = component_id.inner();
802 let tracked = self.clocks.contains_key(&component_id)
803 || self.actor_ids.iter().any(|actor_id| actor_id.inner() == id)
804 || self
805 .strategy_ids
806 .iter()
807 .any(|strategy_id| strategy_id.inner() == id)
808 || self
809 .exec_algorithm_ids
810 .iter()
811 .any(|exec_algorithm_id| exec_algorithm_id.inner() == id);
812
813 if tracked {
814 anyhow::bail!(
815 "Component {component_id} is already registered with trader {}",
816 self.trader_id
817 );
818 }
819
820 Ok(())
821 }
822
823 pub(crate) fn validate_actor_or_strategy_registration(&self) -> anyhow::Result<()> {
829 match self.state {
830 ComponentState::PreInitialized
831 | ComponentState::Ready
832 | ComponentState::Starting
833 | ComponentState::Stopped
834 | ComponentState::Running => Ok(()),
835 ComponentState::Disposed => {
836 anyhow::bail!("Cannot add components to disposed trader")
837 }
838 _ => anyhow::bail!("Cannot add components in current state: {}", self.state),
839 }
840 }
841
842 pub(crate) fn validate_exec_algorithm_registration(&self) -> anyhow::Result<()> {
844 match self.state {
845 ComponentState::PreInitialized | ComponentState::Ready | ComponentState::Stopped => {
846 Ok(())
847 }
848 ComponentState::Running => {
849 anyhow::bail!("Cannot add execution algorithms to running trader")
850 }
851 ComponentState::Disposed => {
852 anyhow::bail!("Cannot add components to disposed trader")
853 }
854 _ => anyhow::bail!(
855 "Cannot add execution algorithms in current state: {}",
856 self.state
857 ),
858 }
859 }
860
861 pub fn start_components(&mut self) -> anyhow::Result<()> {
867 let actor_ids = self.actor_ids.clone();
868 let strategy_ids = self.strategy_ids.clone();
869 let exec_algorithm_ids = self.exec_algorithm_ids.clone();
870
871 for actor_id in actor_ids {
872 log::debug!("Starting actor {actor_id}");
873 Self::start_component_if_not_running(actor_id.inner())?;
874 }
875
876 for strategy_id in strategy_ids {
877 log::debug!("Starting strategy {strategy_id}");
878 Self::start_component_if_not_running(strategy_id.inner())?;
879 }
880
881 let mut restored_exec_algorithm_ids = Vec::new();
882
883 for exec_algorithm_id in exec_algorithm_ids {
884 log::debug!("Starting execution algorithm {exec_algorithm_id}");
885 match self.start_exec_algorithm_if_not_running(exec_algorithm_id) {
886 Ok(true) => restored_exec_algorithm_ids.push(exec_algorithm_id),
887 Ok(false) => {}
888 Err(start_err) => {
889 return Err(self.exec_algorithm_start_error_with_rollback(
890 exec_algorithm_id,
891 &restored_exec_algorithm_ids,
892 start_err,
893 ));
894 }
895 }
896 }
897
898 Ok(())
899 }
900
901 pub fn start_with_component_callbacks(trader: &Rc<RefCell<Self>>) -> anyhow::Result<()> {
907 trader
908 .borrow_mut()
909 .transition_state(ComponentTrigger::Start)?;
910
911 let (actor_ids, strategy_ids, exec_algorithm_ids) = {
912 let trader_ref = trader.borrow();
913 (
914 trader_ref.actor_ids.clone(),
915 trader_ref.strategy_ids.clone(),
916 trader_ref.exec_algorithm_ids.clone(),
917 )
918 };
919
920 for actor_id in actor_ids {
921 log::debug!("Starting actor {actor_id}");
922 Self::start_component_if_not_running(actor_id.inner())?;
923 }
924
925 for strategy_id in strategy_ids {
926 log::debug!("Starting strategy {strategy_id}");
927 Self::start_component_if_not_running(strategy_id.inner())?;
928 }
929
930 let mut restored_exec_algorithm_ids = Vec::new();
931
932 for exec_algorithm_id in exec_algorithm_ids {
933 log::debug!("Starting execution algorithm {exec_algorithm_id}");
934 let component_state = match component_state(&exec_algorithm_id.inner()) {
935 Ok(state) => state,
936 Err(start_err) => {
937 let e = trader
938 .borrow_mut()
939 .exec_algorithm_start_error_with_rollback(
940 exec_algorithm_id,
941 &restored_exec_algorithm_ids,
942 start_err,
943 );
944 return Err(e);
945 }
946 };
947
948 if component_state == ComponentState::Running {
949 continue;
950 }
951
952 if let Err(start_err) = trader
953 .borrow_mut()
954 .restore_exec_algorithm_subscriptions(exec_algorithm_id)
955 {
956 let e = trader
957 .borrow_mut()
958 .exec_algorithm_start_error_with_rollback(
959 exec_algorithm_id,
960 &restored_exec_algorithm_ids,
961 start_err,
962 );
963 return Err(e);
964 }
965 restored_exec_algorithm_ids.push(exec_algorithm_id);
966
967 if let Err(start_err) = start_component(&exec_algorithm_id.inner()) {
968 let e = trader
969 .borrow_mut()
970 .exec_algorithm_start_error_with_rollback(
971 exec_algorithm_id,
972 &restored_exec_algorithm_ids,
973 start_err,
974 );
975 return Err(e);
976 }
977 }
978
979 let mut trader_ref = trader.borrow_mut();
980 let clock = trader_ref.clock_factory.clock();
981 trader_ref.ts_started = Some(clock.borrow().timestamp_ns());
982 trader_ref.transition_state(ComponentTrigger::StartCompleted)?;
983
984 Ok(())
985 }
986
987 fn start_component_if_not_running(component_id: Ustr) -> anyhow::Result<()> {
988 if component_state(&component_id)? == ComponentState::Running {
989 return Ok(());
990 }
991
992 start_component(&component_id)
993 }
994
995 fn start_exec_algorithm_if_not_running(
996 &mut self,
997 exec_algorithm_id: ExecAlgorithmId,
998 ) -> anyhow::Result<bool> {
999 if component_state(&exec_algorithm_id.inner())? == ComponentState::Running {
1000 return Ok(false);
1001 }
1002
1003 self.restore_exec_algorithm_subscriptions(exec_algorithm_id)?;
1004 if let Err(start_err) = start_component(&exec_algorithm_id.inner()) {
1005 return match self.cleanup_exec_algorithm_subscriptions(exec_algorithm_id) {
1006 Ok(()) => Err(start_err),
1007 Err(cleanup_err) => anyhow::bail!(
1008 "Failed to start execution algorithm {exec_algorithm_id}: {start_err:#}; \
1009 failed to roll back subscriptions: {cleanup_err:#}"
1010 ),
1011 };
1012 }
1013
1014 Ok(true)
1015 }
1016
1017 fn restore_exec_algorithm_subscriptions(
1018 &mut self,
1019 exec_algorithm_id: ExecAlgorithmId,
1020 ) -> anyhow::Result<()> {
1021 if let Some(restore_fn) = self.exec_algorithm_restore_fns.get_mut(&exec_algorithm_id) {
1022 restore_fn()?;
1023 }
1024 Ok(())
1025 }
1026
1027 fn cleanup_exec_algorithm_subscriptions(
1028 &mut self,
1029 exec_algorithm_id: ExecAlgorithmId,
1030 ) -> anyhow::Result<()> {
1031 if let Some(cleanup_fn) = self.exec_algorithm_cleanup_fns.get_mut(&exec_algorithm_id) {
1032 cleanup_fn()?;
1033 }
1034 Ok(())
1035 }
1036
1037 fn cleanup_exec_algorithm_subscriptions_for(
1038 &mut self,
1039 exec_algorithm_ids: &[ExecAlgorithmId],
1040 ) -> anyhow::Result<()> {
1041 let mut errors = Vec::new();
1042
1043 for exec_algorithm_id in exec_algorithm_ids {
1044 if let Err(e) = self.cleanup_exec_algorithm_subscriptions(*exec_algorithm_id) {
1045 errors.push(format!("{exec_algorithm_id}: {e:#}"));
1046 }
1047 }
1048
1049 if errors.is_empty() {
1050 Ok(())
1051 } else {
1052 anyhow::bail!("{}", errors.join("; "))
1053 }
1054 }
1055
1056 fn exec_algorithm_start_error_with_rollback(
1057 &mut self,
1058 exec_algorithm_id: ExecAlgorithmId,
1059 restored_exec_algorithm_ids: &[ExecAlgorithmId],
1060 start_err: anyhow::Error,
1061 ) -> anyhow::Error {
1062 match self.cleanup_exec_algorithm_subscriptions_for(restored_exec_algorithm_ids) {
1063 Ok(()) => start_err,
1064 Err(cleanup_err) => anyhow::anyhow!(
1065 "Failed while starting execution algorithm {exec_algorithm_id}: {start_err:#}; \
1066 failed to roll back restored subscriptions: {cleanup_err:#}"
1067 ),
1068 }
1069 }
1070
1071 pub fn stop_components(&mut self) -> anyhow::Result<()> {
1080 let mut errors = Vec::new();
1081
1082 for actor_id in &self.actor_ids {
1083 log::debug!("Stopping actor {actor_id}");
1084
1085 if let Err(e) = Self::stop_component_if_active(actor_id.inner()) {
1086 errors.push(format!("actor {actor_id}: {e:#}"));
1087 }
1088 }
1089
1090 for exec_algorithm_id in &self.exec_algorithm_ids {
1091 log::debug!("Stopping execution algorithm {exec_algorithm_id}");
1092
1093 if let Err(e) = Self::stop_component_if_active(exec_algorithm_id.inner()) {
1094 errors.push(format!("execution algorithm {exec_algorithm_id}: {e:#}"));
1095 }
1096 }
1097
1098 for strategy_id in self.strategy_ids.clone() {
1099 log::debug!("Stopping strategy {strategy_id}");
1100 let should_proceed = self
1101 .strategy_stop_fns
1102 .get_mut(&strategy_id)
1103 .is_none_or(|stop_fn| stop_fn());
1104
1105 if should_proceed && let Err(e) = Self::stop_component_if_active(strategy_id.inner()) {
1106 errors.push(format!("strategy {strategy_id}: {e:#}"));
1107 }
1108 }
1109
1110 if errors.is_empty() {
1111 Ok(())
1112 } else {
1113 anyhow::bail!("Failed to stop trader components: {}", errors.join("; "))
1114 }
1115 }
1116
1117 pub fn stop_after_start_failure(&mut self) -> anyhow::Result<()> {
1124 self.transition_state(ComponentTrigger::Stop)?;
1125
1126 let stop_result = self.stop_components_after_start_failure();
1127 self.complete_stop(stop_result)
1128 }
1129
1130 fn complete_stop(&mut self, stop_result: anyhow::Result<()>) -> anyhow::Result<()> {
1131 let clock = self.clock_factory.clock();
1132 self.ts_stopped = Some(clock.borrow().timestamp_ns());
1133 let transition_result = self.transition_state(ComponentTrigger::StopCompleted);
1134
1135 match (stop_result, transition_result) {
1136 (Ok(()), Ok(())) => Ok(()),
1137 (Err(stop_err), Ok(())) => Err(stop_err),
1138 (Ok(()), Err(transition_err)) => Err(transition_err),
1139 (Err(stop_err), Err(transition_err)) => anyhow::bail!(
1140 "Failed to stop trader components: {stop_err}; failed to complete trader stop: \
1141 {transition_err}"
1142 ),
1143 }
1144 }
1145
1146 fn stop_components_after_start_failure(&mut self) -> anyhow::Result<()> {
1147 let mut errors = Vec::new();
1148
1149 for actor_id in &self.actor_ids {
1150 log::debug!("Stopping actor {actor_id} after startup failure");
1151 if let Err(e) = Self::stop_component_if_active(actor_id.inner()) {
1152 errors.push(format!("actor {actor_id}: {e:#}"));
1153 }
1154 }
1155
1156 for exec_algorithm_id in self.exec_algorithm_ids.clone() {
1157 log::debug!("Stopping execution algorithm {exec_algorithm_id} after startup failure");
1158 if let Err(e) = Self::stop_component_if_active(exec_algorithm_id.inner()) {
1159 errors.push(format!("execution algorithm {exec_algorithm_id}: {e:#}"));
1160 }
1161
1162 if let Err(e) = self.cleanup_exec_algorithm_subscriptions(exec_algorithm_id) {
1163 errors.push(format!(
1164 "execution algorithm {exec_algorithm_id} subscription cleanup: {e:#}"
1165 ));
1166 }
1167 }
1168
1169 for strategy_id in &self.strategy_ids {
1170 log::debug!("Stopping strategy {strategy_id} after startup failure");
1171 if let Err(e) = Self::stop_component_if_active(strategy_id.inner()) {
1172 errors.push(format!("strategy {strategy_id}: {e:#}"));
1173 }
1174 }
1175
1176 if errors.is_empty() {
1177 Ok(())
1178 } else {
1179 anyhow::bail!(
1180 "Failed to stop one or more trader components after startup failure: {}",
1181 errors.join("; ")
1182 )
1183 }
1184 }
1185
1186 fn stop_component_if_active(component_id: Ustr) -> anyhow::Result<()> {
1187 if !matches!(
1188 component_state(&component_id)?,
1189 ComponentState::Starting | ComponentState::Running | ComponentState::Degraded
1190 ) {
1191 return Ok(());
1192 }
1193
1194 stop_component(&component_id)
1195 }
1196
1197 pub fn reset_components(&mut self) -> anyhow::Result<()> {
1203 for actor_id in &self.actor_ids {
1204 log::debug!("Resetting actor {actor_id}");
1205 reset_component(&actor_id.inner())?;
1206 }
1207
1208 for strategy_id in &self.strategy_ids {
1209 log::debug!("Resetting strategy {strategy_id}");
1210 reset_component(&strategy_id.inner())?;
1211 }
1212
1213 for exec_algorithm_id in self.exec_algorithm_ids.clone() {
1214 log::debug!("Resetting execution algorithm {exec_algorithm_id}");
1215 self.cleanup_exec_algorithm_subscriptions(exec_algorithm_id)?;
1216 reset_component(&exec_algorithm_id.inner())?;
1217 }
1218
1219 Ok(())
1220 }
1221
1222 pub fn dispose_components(&mut self) -> anyhow::Result<()> {
1229 for actor_id in self.actor_ids.clone() {
1230 log::debug!("Disposing actor {actor_id}");
1231 self.retire_actor(actor_id)?;
1232 }
1233
1234 for strategy_id in self.strategy_ids.clone() {
1235 log::debug!("Disposing strategy {strategy_id}");
1236 self.retire_strategy(strategy_id)?;
1237 }
1238
1239 for exec_algorithm_id in self.exec_algorithm_ids.clone() {
1240 log::debug!("Disposing execution algorithm {exec_algorithm_id}");
1241 self.retire_exec_algorithm(exec_algorithm_id)?;
1242 }
1243
1244 for clock in self.clocks.values() {
1246 clock.borrow_mut().cancel_timers();
1247 }
1248
1249 if !self.clocks.is_empty() {
1250 self.clocks.clear();
1251 self.clocks_snapshot.take();
1252 }
1253
1254 Ok(())
1255 }
1256
1257 pub fn clear_strategies(&mut self) -> anyhow::Result<()> {
1263 for strategy_id in self.strategy_ids.clone() {
1264 log::debug!("Disposing strategy {strategy_id}");
1265 self.retire_strategy(strategy_id)?;
1266 }
1267
1268 Ok(())
1269 }
1270
1271 pub fn clear_actors(&mut self) -> anyhow::Result<()> {
1277 for actor_id in self.actor_ids.clone() {
1278 log::debug!("Disposing actor {actor_id}");
1279 Self::stop_before_disposal(actor_id.inner())?;
1280 self.retire_actor(actor_id)?;
1281 }
1282
1283 Ok(())
1284 }
1285
1286 pub fn clear_exec_algorithms(&mut self) -> anyhow::Result<()> {
1292 for exec_algorithm_id in self.exec_algorithm_ids.clone() {
1293 log::debug!("Disposing execution algorithm {exec_algorithm_id}");
1294 self.retire_exec_algorithm(exec_algorithm_id)?;
1295 }
1296
1297 Ok(())
1298 }
1299
1300 pub fn start_actor(&self, actor_id: &ActorId) -> anyhow::Result<()> {
1308 if !self.actor_ids.contains(actor_id) {
1309 anyhow::bail!("Cannot start actor, {actor_id} not found");
1310 }
1311 start_component(&actor_id.inner())
1312 }
1313
1314 pub fn stop_actor(&self, actor_id: &ActorId) -> anyhow::Result<()> {
1320 if !self.actor_ids.contains(actor_id) {
1321 anyhow::bail!("Cannot stop actor, {actor_id} not found");
1322 }
1323 stop_component(&actor_id.inner())
1324 }
1325
1326 pub fn remove_actor(&mut self, actor_id: &ActorId) -> anyhow::Result<()> {
1337 if !self.actor_ids.contains(actor_id) {
1338 anyhow::bail!("Cannot remove actor, {actor_id} not found");
1339 }
1340
1341 Self::stop_before_disposal(actor_id.inner())?;
1342 self.retire_actor(*actor_id)?;
1343
1344 log::info!("Removed actor {actor_id} from trader {}", self.trader_id);
1345 Ok(())
1346 }
1347
1348 pub fn start_strategy(&self, strategy_id: &StrategyId) -> anyhow::Result<()> {
1354 if !self.strategy_ids.contains(strategy_id) {
1355 anyhow::bail!("Cannot start strategy, {strategy_id} not found");
1356 }
1357 start_component(&strategy_id.inner())
1358 }
1359
1360 pub fn stop_strategy(&mut self, strategy_id: &StrategyId) -> anyhow::Result<()> {
1369 if !self.strategy_ids.contains(strategy_id) {
1370 anyhow::bail!("Cannot stop strategy, {strategy_id} not found");
1371 }
1372
1373 let should_proceed = self
1374 .strategy_stop_fns
1375 .get_mut(strategy_id)
1376 .is_none_or(|stop_fn| stop_fn());
1377
1378 if should_proceed {
1379 stop_component(&strategy_id.inner())?;
1380 }
1381
1382 Ok(())
1383 }
1384
1385 pub fn market_exit_strategy(
1394 trader: &Rc<RefCell<Self>>,
1395 strategy_id: &StrategyId,
1396 ) -> anyhow::Result<()> {
1397 let handler = trader.borrow().strategy_command_handler(*strategy_id)?;
1398 handler.handle(&StrategyCommand::ExitMarket);
1399 Ok(())
1400 }
1401
1402 fn strategy_command_handler(
1403 &self,
1404 strategy_id: StrategyId,
1405 ) -> anyhow::Result<TypedHandler<StrategyCommand>> {
1406 if !self.strategy_ids.contains(&strategy_id) {
1407 anyhow::bail!("Cannot market exit strategy, {strategy_id} not found");
1408 }
1409
1410 let endpoint = strategy_control_endpoint(strategy_id);
1411 let handler = {
1412 let msgbus = get_message_bus();
1413 msgbus
1414 .borrow_mut()
1415 .endpoint_map::<StrategyCommand>()
1416 .get(endpoint)
1417 .cloned()
1418 };
1419
1420 let Some(handler) = handler else {
1421 anyhow::bail!(
1422 "Cannot exit market for strategy {strategy_id}: control endpoint '{}' not registered",
1423 endpoint.as_str()
1424 );
1425 };
1426
1427 Ok(handler)
1428 }
1429
1430 pub fn remove_strategy(&mut self, strategy_id: &StrategyId) -> anyhow::Result<()> {
1442 if !self.strategy_ids.contains(strategy_id) {
1443 anyhow::bail!("Cannot remove strategy, {strategy_id} not found");
1444 }
1445
1446 Self::stop_before_disposal(strategy_id.inner())?;
1447 self.retire_strategy(*strategy_id)?;
1448
1449 log::info!(
1450 "Removed strategy {strategy_id} from trader {}",
1451 self.trader_id
1452 );
1453 Ok(())
1454 }
1455
1456 fn stop_before_disposal(id: Ustr) -> anyhow::Result<()> {
1457 let mut state = component_state(&id)?;
1458 if state.transition(&ComponentTrigger::Stop).is_err() {
1459 return Ok(());
1460 }
1461
1462 if let Err(e) = stop_component(&id) {
1464 log::error!(component = id.as_str(); "{e}");
1465 }
1466
1467 Ok(())
1468 }
1469
1470 fn retire_actor(&mut self, actor_id: ActorId) -> anyhow::Result<()> {
1475 Self::dispose_registered_component(actor_id.inner())?;
1476
1477 self.release_component(ComponentId::from(actor_id));
1478 self.actor_ids.retain(|id| id != &actor_id);
1479 self.actor_state_callbacks.remove(&actor_id);
1480
1481 Ok(())
1482 }
1483
1484 fn retire_strategy(&mut self, strategy_id: StrategyId) -> anyhow::Result<()> {
1486 {
1488 let _cache = self
1489 .cache
1490 .try_borrow_mut()
1491 .map_err(|e| anyhow::anyhow!("Cannot clear external order claims: {e}"))?;
1492 }
1493
1494 Self::dispose_registered_component(strategy_id.inner())?;
1495
1496 self.cache
1497 .try_borrow_mut()
1498 .map_err(|e| anyhow::anyhow!("Cannot clear external order claims: {e}"))?
1499 .set_external_order_claims(strategy_id, &[])?;
1500
1501 self.remove_strategy_subscriptions(strategy_id);
1502 self.release_component(ComponentId::from(strategy_id));
1503 self.strategy_ids.retain(|id| id != &strategy_id);
1504 self.strategy_state_callbacks.remove(&strategy_id);
1505 self.strategy_stop_fns.remove(&strategy_id);
1506
1507 Ok(())
1508 }
1509
1510 fn retire_exec_algorithm(&mut self, exec_algorithm_id: ExecAlgorithmId) -> anyhow::Result<()> {
1512 Self::dispose_registered_component(exec_algorithm_id.inner())?;
1513 self.cleanup_exec_algorithm_subscriptions(exec_algorithm_id)?;
1514
1515 let endpoint: Ustr = format!("{exec_algorithm_id}.execute").into();
1516 msgbus::deregister_any(endpoint.into());
1517 self.release_component(ComponentId::from(exec_algorithm_id));
1518 self.exec_algorithm_ids
1519 .retain(|id| id != &exec_algorithm_id);
1520 self.exec_algorithm_restore_fns.remove(&exec_algorithm_id);
1521 self.exec_algorithm_cleanup_fns.remove(&exec_algorithm_id);
1522
1523 Ok(())
1524 }
1525
1526 fn dispose_registered_component(id: Ustr) -> anyhow::Result<()> {
1533 let state = component_state(&id)?;
1534
1535 if state == ComponentState::Disposed {
1536 log::debug!("Component {id} already {state}, skipping disposal transition");
1537 return Ok(());
1538 }
1539
1540 if state == ComponentState::Faulted {
1541 return release_component_subscriptions(&id);
1542 }
1543
1544 dispose_component(&id)
1545 }
1546
1547 fn remove_strategy_subscriptions(&mut self, strategy_id: StrategyId) {
1549 if let Some((order_handler_id, position_handler_id)) =
1550 self.strategy_handler_ids.remove(&strategy_id)
1551 {
1552 let order_topic = get_event_order_topic(strategy_id);
1553 let position_topic = get_event_position_topic(strategy_id);
1554 msgbus::remove_order_event_handler(order_topic.into(), order_handler_id);
1555 msgbus::remove_position_event_handler(position_topic.into(), position_handler_id);
1556 }
1557
1558 get_message_bus()
1559 .borrow_mut()
1560 .endpoint_map::<StrategyCommand>()
1561 .deregister(strategy_control_endpoint(strategy_id));
1562 }
1563
1564 pub(crate) fn release_component(&mut self, component_id: ComponentId) {
1574 self.release_component_clock(component_id);
1575
1576 let id = component_id.inner();
1577 deregister_component(&id);
1578 deregister_actor(&id);
1579
1580 #[cfg(feature = "python")]
1583 release_python_wrapper(component_id);
1584 }
1585
1586 fn release_component_clock(&mut self, component_id: ComponentId) {
1587 if let Some(clock) = self.clocks.shift_remove(&component_id) {
1588 self.clocks_snapshot.take();
1589 let mut clock = clock.borrow_mut();
1590 clock.cancel_timers();
1591 clock.cancel_default_handler();
1592 clock.cancel_callbacks();
1593 }
1594 }
1595
1596 pub(crate) fn load_state(trader: &Rc<RefCell<Self>>) -> anyhow::Result<()> {
1606 let (cache, actor_callbacks, strategy_callbacks) = {
1607 let trader = trader.borrow();
1608 let actor_callbacks = trader.actor_state_callbacks()?;
1609 let strategy_callbacks = trader.strategy_state_callbacks()?;
1610
1611 (trader.cache.clone(), actor_callbacks, strategy_callbacks)
1612 };
1613
1614 if !cache.borrow().has_backing() {
1615 return Ok(());
1616 }
1617
1618 for (actor_id, callbacks) in actor_callbacks {
1619 let state = cache
1620 .borrow()
1621 .load_actor_state(&actor_id)
1622 .map_err(|e| anyhow::anyhow!("Failed to load actor {actor_id} state: {e:#}"))?;
1623 let Some(state) = state.filter(|state| !state.is_empty()) else {
1624 continue;
1625 };
1626
1627 (callbacks.load)(actor_id.inner(), state)
1628 .map_err(|e| anyhow::anyhow!("Failed to restore actor {actor_id} state: {e:#}"))?;
1629 }
1630
1631 for (strategy_id, callbacks) in strategy_callbacks {
1632 let state = cache
1633 .borrow()
1634 .load_strategy_state(&strategy_id)
1635 .map_err(|e| {
1636 anyhow::anyhow!("Failed to load strategy {strategy_id} state: {e:#}")
1637 })?;
1638 let Some(state) = state.filter(|state| !state.is_empty()) else {
1639 continue;
1640 };
1641
1642 (callbacks.load)(strategy_id.inner(), state).map_err(|e| {
1643 anyhow::anyhow!("Failed to restore strategy {strategy_id} state: {e:#}")
1644 })?;
1645 }
1646
1647 Ok(())
1648 }
1649
1650 pub(crate) fn save_state(trader: &Rc<RefCell<Self>>) -> anyhow::Result<()> {
1662 let (cache, actor_callbacks, strategy_callbacks) = {
1663 let trader = trader.borrow();
1664 let actor_callbacks = trader.actor_state_callbacks()?;
1665 let strategy_callbacks = trader.strategy_state_callbacks()?;
1666
1667 (trader.cache.clone(), actor_callbacks, strategy_callbacks)
1668 };
1669
1670 if !cache.borrow().has_backing() {
1671 return Ok(());
1672 }
1673
1674 let mut errors = Vec::new();
1675
1676 for (actor_id, callbacks) in actor_callbacks {
1677 match (callbacks.save)(actor_id.inner()) {
1678 Ok(state) => {
1679 if let Err(e) = cache.borrow().update_actor_state(&actor_id, &state) {
1680 errors.push(format!("actor {actor_id} persistence: {e:#}"));
1681 }
1682 }
1683 Err(e) => errors.push(format!("actor {actor_id} callback: {e:#}")),
1684 }
1685 }
1686
1687 for (strategy_id, callbacks) in strategy_callbacks {
1688 match (callbacks.save)(strategy_id.inner()) {
1689 Ok(state) => {
1690 if let Err(e) = cache.borrow().update_strategy_state(&strategy_id, &state) {
1691 errors.push(format!("strategy {strategy_id} persistence: {e:#}"));
1692 }
1693 }
1694 Err(e) => errors.push(format!("strategy {strategy_id} callback: {e:#}")),
1695 }
1696 }
1697
1698 if errors.is_empty() {
1699 Ok(())
1700 } else {
1701 anyhow::bail!("Failed to save component state: {}", errors.join("; "))
1702 }
1703 }
1704
1705 fn actor_state_callbacks(&self) -> anyhow::Result<Vec<(ActorId, ComponentStateCallbacks)>> {
1706 self.actor_ids
1707 .iter()
1708 .map(|actor_id| {
1709 self.actor_state_callbacks
1710 .get(actor_id)
1711 .copied()
1712 .map(|callbacks| (*actor_id, callbacks))
1713 .ok_or_else(|| anyhow::anyhow!("Actor {actor_id} state callback not found"))
1714 })
1715 .collect()
1716 }
1717
1718 fn strategy_state_callbacks(
1719 &self,
1720 ) -> anyhow::Result<Vec<(StrategyId, ComponentStateCallbacks)>> {
1721 self.strategy_ids
1722 .iter()
1723 .map(|strategy_id| {
1724 self.strategy_state_callbacks
1725 .get(strategy_id)
1726 .copied()
1727 .map(|callbacks| (*strategy_id, callbacks))
1728 .ok_or_else(|| {
1729 anyhow::anyhow!("Strategy {strategy_id} state callback not found")
1730 })
1731 })
1732 .collect()
1733 }
1734
1735 fn load_component_state<T>(
1736 component_id: Ustr,
1737 state: PersistedComponentState,
1738 ) -> anyhow::Result<()>
1739 where
1740 T: DataActor + DataActorNative + Debug + 'static,
1741 {
1742 let mut component = try_get_actor_unchecked::<T>(&component_id).ok_or_else(|| {
1743 anyhow::anyhow!("Component {component_id} not found in actor registry")
1744 })?;
1745 component.on_load(state)
1746 }
1747
1748 fn save_component_state<T>(component_id: Ustr) -> anyhow::Result<PersistedComponentState>
1749 where
1750 T: DataActor + DataActorNative + Debug + 'static,
1751 {
1752 let component = try_get_actor_unchecked::<T>(&component_id).ok_or_else(|| {
1753 anyhow::anyhow!("Component {component_id} not found in actor registry")
1754 })?;
1755 component.on_save()
1756 }
1757
1758 pub fn initialize(&mut self) -> anyhow::Result<()> {
1766 let new_state = self.state.transition(&ComponentTrigger::Initialize)?;
1767 self.state = new_state;
1768
1769 Ok(())
1770 }
1771
1772 fn on_start(&mut self) -> anyhow::Result<()> {
1773 self.start_components()?;
1774
1775 let clock = self.clock_factory.clock();
1777 self.ts_started = Some(clock.borrow().timestamp_ns());
1778
1779 Ok(())
1780 }
1781
1782 fn on_reset(&mut self) -> anyhow::Result<()> {
1783 self.reset_components()?;
1784
1785 self.ts_started = None;
1786 self.ts_stopped = None;
1787
1788 Ok(())
1789 }
1790
1791 fn on_dispose(&mut self) -> anyhow::Result<()> {
1792 if self.is_running() {
1793 self.stop()?;
1794 }
1795
1796 self.dispose_components()?;
1797
1798 Ok(())
1799 }
1800}
1801
1802impl Component for Trader {
1803 fn component_id(&self) -> ComponentId {
1804 ComponentId::new(format!("Trader-{}", self.trader_id))
1805 }
1806
1807 fn state(&self) -> ComponentState {
1808 self.state
1809 }
1810
1811 fn transition_state(&mut self, trigger: ComponentTrigger) -> anyhow::Result<()> {
1812 self.state = self.state.transition(&trigger)?;
1813 log::info!("{}", self.state.variant_name());
1814 Ok(())
1815 }
1816
1817 fn register(
1818 &mut self,
1819 _trader_id: TraderId,
1820 _clock: Rc<RefCell<dyn Clock>>,
1821 _cache: Rc<RefCell<Cache>>,
1822 ) -> anyhow::Result<()> {
1823 anyhow::bail!("Trader cannot register with itself")
1824 }
1825
1826 fn on_start(&mut self) -> anyhow::Result<()> {
1827 Self::on_start(self)
1828 }
1829
1830 fn stop(&mut self) -> anyhow::Result<()> {
1831 self.transition_state(ComponentTrigger::Stop)?;
1832
1833 let stop_result = self.on_stop();
1834 self.complete_stop(stop_result)
1835 }
1836
1837 fn on_stop(&mut self) -> anyhow::Result<()> {
1838 self.stop_components()
1839 }
1840
1841 fn on_reset(&mut self) -> anyhow::Result<()> {
1842 Self::on_reset(self)
1843 }
1844
1845 fn on_dispose(&mut self) -> anyhow::Result<()> {
1846 Self::on_dispose(self)
1847 }
1848}
1849
1850type ComponentClockSnapshot = Rc<[Rc<RefCell<dyn Clock>>]>;
1851
1852#[cfg(test)]
1853mod tests {
1854 use std::{
1855 cell::{Cell, RefCell},
1856 rc::Rc,
1857 sync::{
1858 Arc,
1859 atomic::{AtomicUsize, Ordering},
1860 },
1861 };
1862
1863 #[cfg(feature = "python")]
1864 use nautilus_common::{
1865 actor::data_actor::ImportableActorConfig,
1866 python::{
1867 actor::{PyDataActor, PyDataActorInner},
1868 wrappers::get_python_wrapper,
1869 },
1870 };
1871 use nautilus_common::{
1872 actor::{
1873 DataActorCore,
1874 data_actor::DataActorConfig,
1875 registry::{actor_exists, get_actor_unchecked, try_get_actor_unchecked},
1876 },
1877 cache::Cache,
1878 clock::VirtualClock,
1879 component::get_component,
1880 enums::{ComponentState, Environment},
1881 logging::{
1882 arm_shutdown_on_error, disarm_shutdown_on_error, init_logging, logger::LoggerConfig,
1883 take_shutdown_on_error_trigger, writer::FileWriterConfig,
1884 },
1885 messages::execution::SubmitOrder,
1886 msgbus,
1887 msgbus::{
1888 MessageBus, MessagingSwitchboard, TypedHandler, set_message_bus,
1889 switchboard::{
1890 get_bars_topic, get_book_deltas_topic, get_book_depth_topic, get_custom_topic,
1891 get_event_order_topic,
1892 },
1893 },
1894 nautilus_actor,
1895 runner::{
1896 SyncDataCommandSender, SyncTradingCommandSender, drain_data_cmd_queue,
1897 drain_trading_cmd_queue, replace_data_cmd_sender, replace_exec_cmd_sender,
1898 trading_cmd_queue_is_empty,
1899 },
1900 timer::TimeEventHandler,
1901 };
1902 use nautilus_core::{DurationNanos, UUID4};
1903 use nautilus_data::engine::{DataEngine, config::DataEngineConfig};
1904 use nautilus_execution::engine::{ExecutionEngine, config::ExecutionEngineConfig};
1905 use nautilus_model::{
1906 data::{Bar, BarType, DataType, stubs::stub_bar},
1907 enums::{BookType, OrderSide, OrderStatus, OrderType, PositionAdjustmentType, TimeInForce},
1908 events::{
1909 OrderAccepted, OrderDenied, OrderFilled, OrderRejected, OrderUpdated, PositionAdjusted,
1910 order::spec::{
1911 OrderAcceptedSpec, OrderFilledSpec, OrderRejectedSpec, OrderSubmittedSpec,
1912 OrderUpdatedSpec,
1913 },
1914 },
1915 identifiers::{
1916 AccountId, ActorId, ClientOrderId, ComponentId, InstrumentId, PositionId, TraderId,
1917 VenueOrderId,
1918 },
1919 instruments::{Instrument, InstrumentAny, stubs::audusd_sim},
1920 orders::{OrderAny, OrderTestBuilder},
1921 stubs::TestDefault,
1922 types::{Price, Quantity},
1923 };
1924 use nautilus_portfolio::portfolio::Portfolio;
1925 use nautilus_risk::engine::{RiskEngine, config::RiskEngineConfig};
1926 #[cfg(feature = "python")]
1927 use nautilus_testkit::cache::TestCacheDatabaseControl;
1928 #[cfg(feature = "python")]
1929 use nautilus_trading::python::strategy::{PyStrategy, PyStrategyInner};
1930 use nautilus_trading::{
1931 ExecutionAlgorithmConfig, ExecutionAlgorithmCore, StrategyNative,
1932 nautilus_execution_algorithm, nautilus_strategy,
1933 strategy::{config::StrategyConfig, core::StrategyCore},
1934 };
1935 #[cfg(feature = "python")]
1936 use pyo3::{
1937 ffi::c_str,
1938 prelude::*,
1939 types::{PyDict, PyModule},
1940 };
1941 use rstest::rstest;
1942
1943 use super::*;
1944 use crate::clock_factory::ClockFactory;
1945
1946 #[derive(Debug)]
1948 struct TestDataActor {
1949 core: DataActorCore,
1950 fail_stop: bool,
1951 fail_fault: bool,
1952 fail_dispose: bool,
1953 bars_received: usize,
1954 time_events: usize,
1955 }
1956
1957 impl TestDataActor {
1958 fn new(config: DataActorConfig) -> Self {
1959 Self {
1960 core: DataActorCore::new(config),
1961 fail_stop: false,
1962 fail_fault: false,
1963 fail_dispose: false,
1964 bars_received: 0,
1965 time_events: 0,
1966 }
1967 }
1968 }
1969
1970 impl DataActor for TestDataActor {
1971 fn on_time_event(&mut self, _event: &TimeEvent) -> anyhow::Result<()> {
1972 self.time_events += 1;
1973 Ok(())
1974 }
1975
1976 fn on_stop(&mut self) -> anyhow::Result<()> {
1977 if self.fail_stop {
1978 anyhow::bail!("test actor stop failure");
1979 }
1980 Ok(())
1981 }
1982
1983 fn on_dispose(&mut self) -> anyhow::Result<()> {
1984 if self.fail_dispose {
1985 anyhow::bail!("test actor dispose failure");
1986 }
1987 Ok(())
1988 }
1989
1990 fn on_fault(&mut self) -> anyhow::Result<()> {
1991 if self.fail_fault {
1992 anyhow::bail!("test actor fault failure");
1993 }
1994 Ok(())
1995 }
1996
1997 fn on_bar(&mut self, _bar: &Bar) -> anyhow::Result<()> {
1998 self.bars_received += 1;
1999 Ok(())
2000 }
2001 }
2002
2003 nautilus_actor!(TestDataActor);
2004
2005 #[derive(Debug)]
2007 struct TestExecutionAlgorithm {
2008 core: ExecutionAlgorithmCore,
2009 fail_start: bool,
2010 fail_stop: bool,
2011 submit_on_accept: Option<OrderAny>,
2012 accepted_events: usize,
2013 denied_events: usize,
2014 rejected_events: usize,
2015 updated_events: usize,
2016 filled_events: usize,
2017 position_events: usize,
2018 }
2019
2020 impl TestExecutionAlgorithm {
2021 fn new(config: ExecutionAlgorithmConfig) -> Self {
2022 Self {
2023 core: ExecutionAlgorithmCore::new(config),
2024 fail_start: false,
2025 fail_stop: false,
2026 submit_on_accept: None,
2027 accepted_events: 0,
2028 denied_events: 0,
2029 rejected_events: 0,
2030 updated_events: 0,
2031 filled_events: 0,
2032 position_events: 0,
2033 }
2034 }
2035 }
2036
2037 impl DataActor for TestExecutionAlgorithm {
2038 fn on_start(&mut self) -> anyhow::Result<()> {
2039 if self.fail_start {
2040 anyhow::bail!("test execution algorithm start failure");
2041 }
2042 Ok(())
2043 }
2044
2045 fn on_stop(&mut self) -> anyhow::Result<()> {
2046 if self.fail_stop {
2047 anyhow::bail!("test execution algorithm stop failure");
2048 }
2049
2050 Ok(())
2051 }
2052 }
2053
2054 nautilus_execution_algorithm!(TestExecutionAlgorithm, {
2055 fn on_order(&mut self, _order: OrderAny) -> anyhow::Result<()> {
2056 Ok(())
2057 }
2058
2059 fn on_order_rejected(&mut self, _event: OrderRejected) {
2060 self.rejected_events += 1;
2061 }
2062
2063 fn on_order_accepted(&mut self, _event: OrderAccepted) {
2064 self.accepted_events += 1;
2065
2066 if let Some(order) = self.submit_on_accept.take() {
2067 self.submit_order(order, None, None).unwrap();
2068 }
2069 }
2070
2071 fn on_order_denied(&mut self, _event: OrderDenied) {
2072 self.denied_events += 1;
2073 }
2074
2075 fn on_order_updated(&mut self, _event: OrderUpdated) {
2076 self.updated_events += 1;
2077 }
2078
2079 fn on_algo_order_filled(&mut self, _event: OrderFilled) {
2080 self.filled_events += 1;
2081 }
2082
2083 fn on_position_event(&mut self, _event: PositionEvent) {
2084 self.position_events += 1;
2085 }
2086 });
2087
2088 fn add_cached_exec_order(
2089 cache: &Rc<RefCell<Cache>>,
2090 client_order_id: ClientOrderId,
2091 strategy_id: StrategyId,
2092 exec_algorithm_id: Option<ExecAlgorithmId>,
2093 is_terminal: bool,
2094 ) -> OrderAny {
2095 let mut builder = OrderTestBuilder::new(OrderType::Market);
2096 builder
2097 .client_order_id(client_order_id)
2098 .strategy_id(strategy_id)
2099 .instrument_id(InstrumentId::test_default())
2100 .quantity(Quantity::from(1));
2101
2102 if let Some(exec_algorithm_id) = exec_algorithm_id {
2103 builder
2104 .exec_algorithm_id(exec_algorithm_id)
2105 .exec_spawn_id(client_order_id);
2106 }
2107
2108 let order = builder.build();
2109 cache
2110 .borrow_mut()
2111 .add_order(order.clone(), None, None, false)
2112 .unwrap();
2113
2114 if is_terminal {
2115 let event = OrderEventAny::Rejected(
2116 OrderRejectedSpec::builder()
2117 .trader_id(order.trader_id())
2118 .strategy_id(order.strategy_id())
2119 .instrument_id(order.instrument_id())
2120 .client_order_id(order.client_order_id())
2121 .account_id(AccountId::test_default())
2122 .reason("TEST_TERMINAL".into())
2123 .build(),
2124 );
2125 cache.borrow_mut().update_order(&event).unwrap();
2126 }
2127
2128 order
2129 }
2130
2131 #[derive(Debug)]
2133 struct TestStrategy {
2134 core: StrategyCore,
2135 fail_stop: bool,
2136 }
2137
2138 impl TestStrategy {
2139 fn new(config: StrategyConfig) -> Self {
2140 Self {
2141 core: StrategyCore::new(config),
2142 fail_stop: false,
2143 }
2144 }
2145 }
2146
2147 impl DataActor for TestStrategy {
2148 fn on_stop(&mut self) -> anyhow::Result<()> {
2149 if self.fail_stop {
2150 anyhow::bail!("test strategy stop failure");
2151 }
2152 Ok(())
2153 }
2154 }
2155
2156 nautilus_strategy!(TestStrategy);
2157
2158 #[derive(Debug)]
2159 struct TimerRoutingStrategy {
2160 core: StrategyCore,
2161 time_events: usize,
2162 strategy_time_events: usize,
2163 post_market_exits: usize,
2164 post_market_exits_on_callback: Option<usize>,
2165 gtd_timer_active_on_callback: Option<bool>,
2166 }
2167
2168 impl TimerRoutingStrategy {
2169 fn new(config: StrategyConfig) -> Self {
2170 Self {
2171 core: StrategyCore::new(config),
2172 time_events: 0,
2173 strategy_time_events: 0,
2174 post_market_exits: 0,
2175 post_market_exits_on_callback: None,
2176 gtd_timer_active_on_callback: None,
2177 }
2178 }
2179 }
2180
2181 impl DataActor for TimerRoutingStrategy {
2182 fn on_time_event(&mut self, event: &TimeEvent) -> anyhow::Result<()> {
2183 self.time_events += 1;
2184
2185 if event.name.starts_with("MARKET_EXIT_CHECK:") {
2186 self.post_market_exits_on_callback = Some(self.post_market_exits);
2187 }
2188
2189 if let Some(client_order_id) = event.name.strip_prefix("GTD-EXPIRY:") {
2190 self.gtd_timer_active_on_callback =
2191 Some(self.has_gtd_expiry_timer(&ClientOrderId::from(client_order_id)));
2192 }
2193
2194 Ok(())
2195 }
2196 }
2197
2198 nautilus_strategy!(TimerRoutingStrategy, {
2199 fn on_time_event(&mut self, _event: &TimeEvent) -> anyhow::Result<()> {
2200 self.strategy_time_events += 1;
2201 Ok(())
2202 }
2203
2204 fn post_market_exit(&mut self) {
2205 self.post_market_exits += 1;
2206 }
2207 });
2208
2209 #[expect(clippy::type_complexity)]
2210 fn create_trader_components() -> (
2211 Rc<RefCell<MessageBus>>,
2212 Rc<RefCell<Cache>>,
2213 Rc<RefCell<Portfolio>>,
2214 Rc<RefCell<DataEngine>>,
2215 Rc<RefCell<RiskEngine>>,
2216 Rc<RefCell<ExecutionEngine>>,
2217 ClockFactory,
2218 ) {
2219 let trader_id = TraderId::test_default();
2220 let instance_id = UUID4::new();
2221 let clock_factory = ClockFactory::test_default();
2222 let clock = clock_factory.clock();
2223 let mut clock_ref = clock.borrow_mut();
2224 let test_clock = clock_ref
2225 .as_any_mut()
2226 .downcast_mut::<VirtualClock>()
2227 .expect("test default clock must be VirtualClock");
2228 test_clock.set_time(1_000_000_000u64.into());
2229 drop(clock_ref);
2230 let msgbus = Rc::new(RefCell::new(MessageBus::new(
2231 trader_id,
2232 instance_id,
2233 Some("test".to_string()),
2234 None,
2235 )));
2236 let cache = Rc::new(RefCell::new(Cache::new(None, None)));
2237 let portfolio = Rc::new(RefCell::new(Portfolio::new(
2238 clock.clone(),
2239 cache.clone(),
2240 None,
2241 )));
2242 let data_engine = Rc::new(RefCell::new(DataEngine::new(
2243 clock.clone(),
2244 cache.clone(),
2245 Some(DataEngineConfig::default()),
2246 )));
2247
2248 let risk_cache = Rc::new(RefCell::new(Cache::new(None, None)));
2250 let risk_clock = Rc::new(RefCell::new(VirtualClock::new()));
2251 let risk_portfolio = Portfolio::new(
2252 risk_clock.clone() as Rc<RefCell<dyn Clock>>,
2253 risk_cache.clone(),
2254 None,
2255 );
2256 let risk_engine = Rc::new(RefCell::new(RiskEngine::new(
2257 RiskEngineConfig::default(),
2258 risk_portfolio,
2259 risk_clock as Rc<RefCell<dyn Clock>>,
2260 risk_cache,
2261 )));
2262 let exec_engine = Rc::new(RefCell::new(ExecutionEngine::new(
2263 clock.clone(),
2264 cache.clone(),
2265 Some(ExecutionEngineConfig::default()),
2266 )));
2267
2268 (
2269 msgbus,
2270 cache,
2271 portfolio,
2272 data_engine,
2273 risk_engine,
2274 exec_engine,
2275 clock_factory,
2276 )
2277 }
2278
2279 #[rstest]
2280 fn test_trader_creation() {
2281 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2282 create_trader_components();
2283 let trader_id = TraderId::test_default();
2284 let instance_id = UUID4::new();
2285
2286 let trader = Trader::new(
2287 trader_id,
2288 instance_id,
2289 Environment::Backtest,
2290 clock_factory,
2291 cache,
2292 portfolio,
2293 );
2294
2295 assert_eq!(trader.trader_id(), trader_id);
2296 assert_eq!(trader.instance_id(), instance_id);
2297 assert_eq!(trader.environment(), Environment::Backtest);
2298 assert_eq!(trader.state(), ComponentState::PreInitialized);
2299 assert_eq!(trader.actor_count(), 0);
2300 assert_eq!(trader.strategy_count(), 0);
2301 assert_eq!(trader.exec_algorithm_count(), 0);
2302 assert_eq!(trader.component_count(), 0);
2303 assert!(!trader.is_running());
2304 assert!(!trader.is_stopped());
2305 assert!(!trader.is_disposed());
2306 assert!(trader.ts_created() > 0);
2307 assert!(trader.ts_started().is_none());
2308 assert!(trader.ts_stopped().is_none());
2309 }
2310
2311 #[rstest]
2312 fn test_trader_component_id() {
2313 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2314 create_trader_components();
2315 let trader_id = TraderId::from("TRADER-001");
2316 let instance_id = UUID4::new();
2317
2318 let trader = Trader::new(
2319 trader_id,
2320 instance_id,
2321 Environment::Backtest,
2322 clock_factory,
2323 cache,
2324 portfolio,
2325 );
2326
2327 assert_eq!(
2328 trader.component_id(),
2329 ComponentId::from("Trader-TRADER-001")
2330 );
2331 }
2332
2333 #[rstest]
2334 fn test_add_actor_success() {
2335 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2336 create_trader_components();
2337 let trader_id = TraderId::test_default();
2338 let instance_id = UUID4::new();
2339
2340 let mut trader = Trader::new(
2341 trader_id,
2342 instance_id,
2343 Environment::Backtest,
2344 clock_factory,
2345 cache,
2346 portfolio,
2347 );
2348
2349 let actor = TestDataActor::new(DataActorConfig::default());
2350 let actor_id = actor.actor_id();
2351
2352 let result = trader.add_actor(actor);
2353 assert!(result.is_ok());
2354 assert_eq!(trader.actor_count(), 1);
2355 assert_eq!(trader.component_count(), 1);
2356 assert!(trader.actor_ids().contains(&actor_id));
2357 }
2358
2359 #[rstest]
2360 fn test_add_duplicate_actor_fails() {
2361 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2362 create_trader_components();
2363 let trader_id = TraderId::test_default();
2364 let instance_id = UUID4::new();
2365
2366 let mut trader = Trader::new(
2367 trader_id,
2368 instance_id,
2369 Environment::Backtest,
2370 clock_factory,
2371 cache,
2372 portfolio,
2373 );
2374
2375 let config = DataActorConfig {
2376 actor_id: Some(ActorId::from("TestActor")),
2377 ..Default::default()
2378 };
2379 let actor1 = TestDataActor::new(config.clone());
2380 let actor2 = TestDataActor::new(config);
2381
2382 assert!(trader.add_actor(actor1).is_ok());
2384 assert_eq!(trader.actor_count(), 1);
2385
2386 let result = trader.add_actor(actor2);
2388 assert!(result.is_err());
2389 assert!(
2390 result
2391 .unwrap_err()
2392 .to_string()
2393 .contains("already registered")
2394 );
2395 assert_eq!(trader.actor_count(), 1);
2396 }
2397
2398 #[rstest]
2399 fn test_add_strategy_success() {
2400 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2401 create_trader_components();
2402 let trader_id = TraderId::test_default();
2403 let instance_id = UUID4::new();
2404
2405 let mut trader = Trader::new(
2406 trader_id,
2407 instance_id,
2408 Environment::Backtest,
2409 clock_factory,
2410 cache,
2411 portfolio,
2412 );
2413
2414 let config = StrategyConfig {
2415 strategy_id: Some(StrategyId::from("Test-Strategy")),
2416 ..Default::default()
2417 };
2418 let strategy = TestStrategy::new(config);
2419
2420 let result = trader.add_strategy(strategy);
2421 assert!(result.is_ok());
2422 assert_eq!(trader.strategy_count(), 1);
2423 assert_eq!(trader.component_count(), 1);
2424 assert!(
2425 trader
2426 .strategy_ids()
2427 .contains(&StrategyId::from("Test-Strategy"))
2428 );
2429 }
2430
2431 #[rstest]
2432 fn test_add_strategy_rejects_order_id_tag_with_separator() {
2433 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2434 create_trader_components();
2435 let trader_id = TraderId::test_default();
2436 let instance_id = UUID4::new();
2437
2438 let mut trader = Trader::new(
2439 trader_id,
2440 instance_id,
2441 Environment::Backtest,
2442 clock_factory,
2443 cache,
2444 portfolio,
2445 );
2446
2447 let config = StrategyConfig {
2448 strategy_id: Some(StrategyId::from("HyphenTagStrategy-001")),
2449 order_id_tag: Some("001".to_string()),
2450 ..Default::default()
2451 };
2452 let mut strategy = TestStrategy::new(config);
2453 StrategyNative::strategy_core_mut(&mut strategy)
2454 .config
2455 .order_id_tag = Some("A-B".to_string());
2456
2457 let error = trader.add_strategy(strategy).unwrap_err();
2458
2459 assert_eq!(
2460 error.to_string(),
2461 "`order_id_tag` cannot contain the '-' strategy ID separator, was 'A-B'"
2462 );
2463 assert_eq!(trader.strategy_count(), 0);
2464 assert_eq!(trader.component_count(), 0);
2465 }
2466
2467 #[rstest]
2468 fn test_add_strategy_rejects_non_ascii_order_id_tag() {
2469 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2470 create_trader_components();
2471 let trader_id = TraderId::test_default();
2472 let instance_id = UUID4::new();
2473
2474 let mut trader = Trader::new(
2475 trader_id,
2476 instance_id,
2477 Environment::Backtest,
2478 clock_factory,
2479 cache,
2480 portfolio,
2481 );
2482
2483 let config = StrategyConfig {
2484 order_id_tag: Some("T01€".to_string()),
2485 ..Default::default()
2486 };
2487 let strategy = TestStrategy::new(config);
2488
2489 let error = trader.add_strategy(strategy).unwrap_err();
2490
2491 assert_eq!(
2492 error.to_string(),
2493 "invalid string for 'value' contained a non-ASCII char, was 'TestStrategy-T01€'"
2494 );
2495 assert_eq!(trader.strategy_count(), 0);
2496 assert_eq!(trader.component_count(), 0);
2497 }
2498
2499 #[rstest]
2500 fn test_add_strategy_preserves_explicit_instrument_strategy_id() {
2501 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2502 create_trader_components();
2503 let trader_id = TraderId::test_default();
2504 let instance_id = UUID4::new();
2505
2506 let mut trader = Trader::new(
2507 trader_id,
2508 instance_id,
2509 Environment::Backtest,
2510 clock_factory,
2511 cache,
2512 portfolio,
2513 );
2514
2515 let strategy_id = StrategyId::from("ExampleStrategy-XNAS");
2516 let config = StrategyConfig {
2517 strategy_id: Some(strategy_id),
2518 ..Default::default()
2519 };
2520 let strategy = TestStrategy::new(config);
2521
2522 trader.add_strategy(strategy).unwrap();
2523
2524 let mut registered = get_actor_unchecked::<TestStrategy>(&strategy_id.inner());
2525 let (client_order_id, order_list_id) = {
2526 let mut order_factory = registered.order_factory();
2527 (
2528 order_factory.generate_client_order_id(),
2529 order_factory.generate_order_list_id(),
2530 )
2531 };
2532
2533 assert_eq!(trader.strategy_ids(), vec![strategy_id]);
2534 assert_eq!(registered.strategy_id(), Some(strategy_id));
2535 assert!(client_order_id.as_str().ends_with("-001-XNAS-1"));
2536 assert!(order_list_id.as_str().ends_with("-001-XNAS-1"));
2537 }
2538
2539 #[rstest]
2540 fn test_add_strategy_appends_configured_order_id_tag_to_explicit_strategy_id() {
2541 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2542 create_trader_components();
2543 let trader_id = TraderId::test_default();
2544 let instance_id = UUID4::new();
2545
2546 let mut trader = Trader::new(
2547 trader_id,
2548 instance_id,
2549 Environment::Backtest,
2550 clock_factory,
2551 cache,
2552 portfolio,
2553 );
2554
2555 let strategy_id = StrategyId::from("ExampleStrategy-XNAS");
2556 let runtime_strategy_id = StrategyId::from("ExampleStrategy-XNAS-T01");
2557 let config = StrategyConfig {
2558 strategy_id: Some(strategy_id),
2559 order_id_tag: Some("T01".to_string()),
2560 ..Default::default()
2561 };
2562 let strategy = TestStrategy::new(config);
2563
2564 trader.add_strategy(strategy).unwrap();
2565
2566 assert!(try_get_actor_unchecked::<TestStrategy>(&strategy_id.inner()).is_none());
2567
2568 let mut registered = get_actor_unchecked::<TestStrategy>(&runtime_strategy_id.inner());
2569 let (client_order_id, order_list_id) = {
2570 let mut order_factory = registered.order_factory();
2571 (
2572 order_factory.generate_client_order_id(),
2573 order_factory.generate_order_list_id(),
2574 )
2575 };
2576
2577 assert_eq!(trader.strategy_ids(), vec![runtime_strategy_id]);
2578 assert_eq!(registered.strategy_id(), Some(runtime_strategy_id));
2579 assert!(client_order_id.as_str().ends_with("-001-T01-1"));
2580 assert!(order_list_id.as_str().ends_with("-001-T01-1"));
2581 }
2582
2583 #[rstest]
2584 fn test_add_strategies_with_no_order_id_tags_assigns_unique_tags() {
2585 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2586 create_trader_components();
2587 let trader_id = TraderId::test_default();
2588 let instance_id = UUID4::new();
2589
2590 let mut trader = Trader::new(
2591 trader_id,
2592 instance_id,
2593 Environment::Backtest,
2594 clock_factory,
2595 cache,
2596 portfolio,
2597 );
2598
2599 let strategy1 = TestStrategy::new(StrategyConfig::default());
2600 let strategy2 = TestStrategy::new(StrategyConfig::default());
2601
2602 assert!(trader.add_strategy(strategy1).is_ok());
2603 assert!(trader.add_strategy(strategy2).is_ok());
2604 assert_eq!(
2605 trader.strategy_ids(),
2606 vec![
2607 StrategyId::from("TestStrategy-000"),
2608 StrategyId::from("TestStrategy-001")
2609 ]
2610 );
2611 }
2612
2613 #[rstest]
2614 fn test_automatic_strategy_tag_skips_existing_tags(#[values(false, true)] remove_first: bool) {
2615 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2616 create_trader_components();
2617
2618 let mut trader = Trader::new(
2619 TraderId::test_default(),
2620 UUID4::new(),
2621 Environment::Backtest,
2622 clock_factory,
2623 cache,
2624 portfolio,
2625 );
2626
2627 if remove_first {
2628 trader
2629 .add_strategy(TestStrategy::new(StrategyConfig::default()))
2630 .unwrap();
2631 }
2632
2633 trader
2634 .add_strategy(TestStrategy::new(StrategyConfig {
2635 strategy_id: Some(StrategyId::from("TestStrategy-001")),
2636 ..Default::default()
2637 }))
2638 .unwrap();
2639
2640 if remove_first {
2641 trader
2642 .remove_strategy(&StrategyId::from("TestStrategy-000"))
2643 .unwrap();
2644 }
2645
2646 trader
2647 .add_strategy(TestStrategy::new(StrategyConfig::default()))
2648 .unwrap();
2649
2650 assert_eq!(
2651 trader.strategy_ids(),
2652 vec![
2653 StrategyId::from("TestStrategy-001"),
2654 StrategyId::from("TestStrategy-002"),
2655 ]
2656 );
2657 }
2658
2659 #[rstest]
2660 #[case("actor", "strategy")]
2661 #[case("actor", "algorithm")]
2662 #[case("strategy", "actor")]
2663 #[case("strategy", "algorithm")]
2664 #[case("algorithm", "actor")]
2665 #[case("algorithm", "strategy")]
2666 fn test_native_registration_preserves_colliding_component(
2667 #[case] first_kind: &str,
2668 #[case] second_kind: &str,
2669 ) {
2670 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2671 create_trader_components();
2672
2673 let mut trader = Trader::new(
2674 TraderId::test_default(),
2675 UUID4::new(),
2676 Environment::Backtest,
2677 clock_factory,
2678 cache,
2679 portfolio,
2680 );
2681
2682 let id = Ustr::from("Collision-001");
2683
2684 let mut add = |kind| match kind {
2685 "actor" => trader.add_actor(TestDataActor::new(DataActorConfig {
2686 actor_id: Some(ActorId::new(id)),
2687 ..Default::default()
2688 })),
2689 "strategy" => trader.add_strategy(TestStrategy::new(StrategyConfig {
2690 strategy_id: Some(StrategyId::new(id)),
2691 ..Default::default()
2692 })),
2693 "algorithm" => {
2694 trader.add_exec_algorithm(TestExecutionAlgorithm::new(ExecutionAlgorithmConfig {
2695 exec_algorithm_id: Some(ExecAlgorithmId::new(id)),
2696 ..Default::default()
2697 }))
2698 }
2699 _ => unreachable!(),
2700 };
2701
2702 add(first_kind).unwrap();
2703 let component = get_component(&id).unwrap();
2704 let clock = match first_kind {
2705 "actor" => get_actor_unchecked::<TestDataActor>(&id).clock_rc(),
2706 "strategy" => get_actor_unchecked::<TestStrategy>(&id).clock_rc(),
2707 "algorithm" => get_actor_unchecked::<TestExecutionAlgorithm>(&id).clock_rc(),
2708 _ => unreachable!(),
2709 };
2710
2711 let error = add(second_kind).unwrap_err();
2712
2713 assert_eq!(
2714 error.to_string(),
2715 format!(
2716 "Component {id} is already registered with trader {}",
2717 trader.trader_id()
2718 )
2719 );
2720 assert!(Rc::ptr_eq(&component, &get_component(&id).unwrap()));
2721 let clocks = trader.get_component_clocks();
2722 assert_eq!(clocks.len(), 1);
2723 assert!(Rc::ptr_eq(&clock, &clocks[0]));
2724 assert_eq!(trader.actor_count(), usize::from(first_kind == "actor"));
2725 assert_eq!(
2726 trader.strategy_count(),
2727 usize::from(first_kind == "strategy")
2728 );
2729 assert_eq!(
2730 trader.exec_algorithm_count(),
2731 usize::from(first_kind == "algorithm")
2732 );
2733 }
2734
2735 #[rstest]
2736 #[case::actor("actor", false)]
2737 #[case::strategy_initialized("strategy", false)]
2738 #[case::strategy_registered("strategy", true)]
2739 #[case::algorithm("algorithm", false)]
2740 fn test_failed_native_registration_keeps_id_reusable(
2741 #[case] kind: &str,
2742 #[case] registered: bool,
2743 ) {
2744 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2745 create_trader_components();
2746
2747 let mut trader = Trader::new(
2748 TraderId::test_default(),
2749 UUID4::new(),
2750 Environment::Backtest,
2751 clock_factory,
2752 cache,
2753 portfolio,
2754 );
2755
2756 let id = Ustr::from("Retry-001");
2757
2758 let add = |trader: &mut Trader, initialize: bool| match kind {
2759 "actor" => {
2760 let mut actor = TestDataActor::new(DataActorConfig {
2761 actor_id: Some(ActorId::new(id)),
2762 ..Default::default()
2763 });
2764
2765 if initialize {
2766 actor.initialize().unwrap();
2767 }
2768
2769 trader.add_actor(actor)
2770 }
2771 "strategy" => {
2772 let mut strategy = TestStrategy::new(StrategyConfig {
2773 strategy_id: Some(StrategyId::new(id)),
2774 ..Default::default()
2775 });
2776
2777 if initialize && registered {
2778 let clock = trader.clock_factory.create_component_clock();
2779 StrategyNative::strategy_core_mut(&mut strategy)
2780 .register(
2781 trader.trader_id(),
2782 clock,
2783 trader.cache.clone(),
2784 trader.portfolio.clone(),
2785 )
2786 .unwrap();
2787 } else if initialize {
2788 strategy.initialize().unwrap();
2789 }
2790
2791 trader.add_strategy(strategy)
2792 }
2793 "algorithm" => {
2794 let mut algorithm = TestExecutionAlgorithm::new(ExecutionAlgorithmConfig {
2795 exec_algorithm_id: Some(ExecAlgorithmId::new(id)),
2796 ..Default::default()
2797 });
2798
2799 if initialize {
2800 algorithm.initialize().unwrap();
2801 }
2802
2803 trader.add_exec_algorithm(algorithm)
2804 }
2805 _ => unreachable!(),
2806 };
2807
2808 let error = add(&mut trader, true).unwrap_err();
2809
2810 let expected_error = if registered {
2811 format!(
2812 "DataActor {id} already registered with trader {}",
2813 trader.trader_id()
2814 )
2815 } else {
2816 format!(
2817 "Invalid state trigger {} -> {}",
2818 ComponentState::Ready,
2819 ComponentTrigger::Initialize,
2820 )
2821 };
2822
2823 assert_eq!(error.to_string(), expected_error);
2824 assert!(trader.get_component_clocks().is_empty());
2825
2826 add(&mut trader, false).unwrap();
2827
2828 assert_eq!(trader.get_component_clocks().len(), 1);
2829 assert_eq!(component_state(&id).unwrap(), ComponentState::Ready);
2830 assert_eq!(trader.actor_count(), usize::from(kind == "actor"));
2831 assert_eq!(trader.strategy_count(), usize::from(kind == "strategy"));
2832 assert_eq!(
2833 trader.exec_algorithm_count(),
2834 usize::from(kind == "algorithm")
2835 );
2836 }
2837
2838 #[rstest]
2839 fn test_native_collision_preserves_externally_registered_actor() {
2840 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2841 create_trader_components();
2842 let trader_id = TraderId::test_default();
2843 let clock = clock_factory.create_component_clock();
2844
2845 let mut actor = TestDataActor::new(DataActorConfig {
2846 actor_id: Some(ActorId::from("External-001")),
2847 ..Default::default()
2848 });
2849
2850 actor
2851 .register(trader_id, clock.clone(), cache.clone())
2852 .unwrap();
2853 register_component_actor(actor);
2854
2855 let mut trader = Trader::new(
2856 trader_id,
2857 UUID4::new(),
2858 Environment::Backtest,
2859 clock_factory,
2860 cache,
2861 portfolio,
2862 );
2863
2864 let actor_id = ActorId::from("External-001");
2865 trader
2866 .add_actor_id_for_lifecycle::<TestDataActor>(actor_id)
2867 .unwrap();
2868 let component = get_component(&actor_id.inner()).unwrap();
2869
2870 let error = trader
2871 .add_strategy(TestStrategy::new(StrategyConfig {
2872 strategy_id: Some(StrategyId::from("External-001")),
2873 ..Default::default()
2874 }))
2875 .unwrap_err();
2876
2877 assert_eq!(
2878 error.to_string(),
2879 format!("Component {actor_id} is already registered with trader {trader_id}")
2880 );
2881 assert!(Rc::ptr_eq(
2882 &component,
2883 &get_component(&actor_id.inner()).unwrap()
2884 ));
2885 assert!(Rc::ptr_eq(
2886 &clock,
2887 &get_actor_unchecked::<TestDataActor>(&actor_id.inner()).clock_rc(),
2888 ));
2889 assert_eq!(trader.actor_ids(), vec![actor_id]);
2890 assert!(trader.strategy_ids().is_empty());
2891 assert!(trader.get_component_clocks().is_empty());
2892 }
2893
2894 #[rstest]
2895 fn test_prepare_strategy_for_registration_is_idempotent() {
2896 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2897 create_trader_components();
2898 let trader_id = TraderId::test_default();
2899 let instance_id = UUID4::new();
2900
2901 let mut trader = Trader::new(
2902 trader_id,
2903 instance_id,
2904 Environment::Backtest,
2905 clock_factory,
2906 cache,
2907 portfolio,
2908 );
2909
2910 let mut strategy = TestStrategy::new(StrategyConfig::default());
2911
2912 let prepared_id = trader
2913 .prepare_strategy_for_registration(&mut strategy)
2914 .unwrap();
2915 assert_eq!(prepared_id, StrategyId::from("TestStrategy-000"));
2916 let core = StrategyNative::strategy_core(&strategy);
2917 assert_eq!(core.config.strategy_id, None);
2918 assert_eq!(core.config.order_id_tag, None);
2919 assert_eq!(core.strategy_id(), Some(prepared_id));
2920 assert_eq!(core.order_id_tag(), Some("000"));
2921
2922 assert!(trader.add_strategy(strategy).is_ok());
2923 assert_eq!(trader.strategy_ids(), vec![prepared_id]);
2924 }
2925
2926 #[rstest]
2927 fn test_add_strategy_with_duplicate_order_id_tag_fails() {
2928 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2929 create_trader_components();
2930 let trader_id = TraderId::test_default();
2931 let instance_id = UUID4::new();
2932
2933 let mut trader = Trader::new(
2934 trader_id,
2935 instance_id,
2936 Environment::Backtest,
2937 clock_factory,
2938 cache,
2939 portfolio,
2940 );
2941
2942 let config = StrategyConfig {
2943 order_id_tag: Some("001".to_string()),
2944 ..Default::default()
2945 };
2946
2947 let strategy1 = TestStrategy::new(config.clone());
2948 let strategy2 = TestStrategy::new(config);
2949
2950 assert!(trader.add_strategy(strategy1).is_ok());
2951 assert_eq!(
2952 trader.strategy_ids(),
2953 vec![StrategyId::from("TestStrategy-001")]
2954 );
2955
2956 let result = trader.add_strategy(strategy2);
2957
2958 assert!(result.is_err());
2959 assert!(
2960 result
2961 .unwrap_err()
2962 .to_string()
2963 .contains("order_id_tag conflict")
2964 );
2965 }
2966
2967 #[rstest]
2968 fn test_add_strategy_id_with_subscriptions_duplicate_order_id_tag_fails() {
2969 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
2970 create_trader_components();
2971 let trader_id = TraderId::test_default();
2972 let instance_id = UUID4::new();
2973
2974 let mut trader = Trader::new(
2975 trader_id,
2976 instance_id,
2977 Environment::Backtest,
2978 clock_factory,
2979 cache,
2980 portfolio,
2981 );
2982
2983 assert!(
2984 trader
2985 .add_strategy_id_with_subscriptions::<TestStrategy>(StrategyId::from("Foo-001"))
2986 .is_ok()
2987 );
2988
2989 let result =
2990 trader.add_strategy_id_with_subscriptions::<TestStrategy>(StrategyId::from("Bar-001"));
2991
2992 assert!(result.is_err());
2993 assert!(
2994 result
2995 .unwrap_err()
2996 .to_string()
2997 .contains("order_id_tag conflict")
2998 );
2999 assert_eq!(trader.strategy_ids(), vec![StrategyId::from("Foo-001")]);
3000 }
3001
3002 #[rstest]
3003 fn test_add_strategy_with_mismatched_strategy_id_and_order_id_tag_appends_tag() {
3004 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
3005 create_trader_components();
3006 let trader_id = TraderId::test_default();
3007 let instance_id = UUID4::new();
3008
3009 let mut trader = Trader::new(
3010 trader_id,
3011 instance_id,
3012 Environment::Backtest,
3013 clock_factory,
3014 cache,
3015 portfolio,
3016 );
3017
3018 let config = StrategyConfig {
3019 strategy_id: Some(StrategyId::from("TestStrategy-001")),
3020 order_id_tag: Some("002".to_string()),
3021 ..Default::default()
3022 };
3023 let strategy = TestStrategy::new(config);
3024
3025 assert!(trader.add_strategy(strategy).is_ok());
3026 assert_eq!(
3027 trader.strategy_ids(),
3028 vec![StrategyId::from("TestStrategy-001-002")]
3029 );
3030 }
3031
3032 #[rstest]
3033 fn test_add_exec_algorithm_success() {
3034 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
3035 create_trader_components();
3036 let trader_id = TraderId::test_default();
3037 let instance_id = UUID4::new();
3038
3039 let mut trader = Trader::new(
3040 trader_id,
3041 instance_id,
3042 Environment::Backtest,
3043 clock_factory,
3044 cache,
3045 portfolio,
3046 );
3047
3048 let config = ExecutionAlgorithmConfig {
3049 exec_algorithm_id: Some(ExecAlgorithmId::from("TestExecutionAlgorithm")),
3050 ..Default::default()
3051 };
3052 let exec_algorithm = TestExecutionAlgorithm::new(config);
3053 let exec_algorithm_id = exec_algorithm.id();
3054
3055 let result = trader.add_exec_algorithm(exec_algorithm);
3056 assert!(result.is_ok());
3057 assert_eq!(trader.exec_algorithm_count(), 1);
3058 assert_eq!(trader.component_count(), 1);
3059 assert!(trader.exec_algorithm_ids().contains(&exec_algorithm_id));
3060 }
3061
3062 #[rstest]
3063 fn test_exec_algorithm_submit_from_order_event_defers_risk_denial() {
3064 std::thread::spawn(|| {
3065 msgbus::get_message_bus().borrow_mut().dispose();
3066 replace_exec_cmd_sender(Arc::new(SyncTradingCommandSender));
3067
3068 let trader_id = TraderId::test_default();
3069 let instance_id = UUID4::new();
3070 let strategy_id = StrategyId::from("Callback-001");
3071 let exec_algorithm_id = ExecAlgorithmId::from("CALLBACK");
3072 let account_id = AccountId::from("SIM-001");
3073 let venue_order_id = VenueOrderId::from("V-PRIMARY-001");
3074 let parent_order_id = ClientOrderId::from("O-PRIMARY-001");
3075 let child_order_id = ClientOrderId::from("O-CHILD-001");
3076 let clock_factory = ClockFactory::test_default();
3077 let clock = clock_factory.clock();
3078 let msgbus = Rc::new(RefCell::new(MessageBus::new(
3079 trader_id,
3080 instance_id,
3081 Some("test".to_string()),
3082 None,
3083 )));
3084 set_message_bus(msgbus);
3085
3086 let cache = Rc::new(RefCell::new(Cache::default()));
3087 let instrument = InstrumentAny::CurrencyPair(audusd_sim());
3088 let instrument_id = instrument.id();
3089 cache.borrow_mut().add_instrument(instrument).unwrap();
3090 let portfolio = Rc::new(RefCell::new(Portfolio::new(
3091 clock.clone(),
3092 cache.clone(),
3093 None,
3094 )));
3095 let risk_engine = Rc::new(RefCell::new(RiskEngine::new(
3096 RiskEngineConfig::default(),
3097 portfolio.borrow().clone_shallow(),
3098 clock.clone(),
3099 cache.clone(),
3100 )));
3101 let exec_engine = Rc::new(RefCell::new(ExecutionEngine::new(
3102 clock.clone(),
3103 cache.clone(),
3104 Some(ExecutionEngineConfig::default()),
3105 )));
3106 RiskEngine::register_msgbus_handlers(&risk_engine);
3107 ExecutionEngine::register_msgbus_handlers(&exec_engine);
3108
3109 let parent = OrderTestBuilder::new(OrderType::Market)
3110 .trader_id(trader_id)
3111 .strategy_id(strategy_id)
3112 .instrument_id(instrument_id)
3113 .client_order_id(parent_order_id)
3114 .side(OrderSide::Buy)
3115 .quantity(Quantity::from("1000"))
3116 .exec_algorithm_id(exec_algorithm_id)
3117 .exec_spawn_id(parent_order_id)
3118 .build();
3119 let child = OrderTestBuilder::new(OrderType::Market)
3120 .trader_id(trader_id)
3121 .strategy_id(strategy_id)
3122 .instrument_id(instrument_id)
3123 .client_order_id(child_order_id)
3124 .side(OrderSide::Buy)
3125 .quantity(Quantity::from("100000000"))
3126 .exec_algorithm_id(exec_algorithm_id)
3127 .exec_spawn_id(child_order_id)
3128 .build();
3129
3130 let config = ExecutionAlgorithmConfig {
3131 exec_algorithm_id: Some(exec_algorithm_id),
3132 ..Default::default()
3133 };
3134 let mut exec_algorithm = TestExecutionAlgorithm::new(config);
3135 exec_algorithm.submit_on_accept = Some(child);
3136 let mut trader = Trader::new(
3137 trader_id,
3138 instance_id,
3139 Environment::Backtest,
3140 clock_factory,
3141 cache.clone(),
3142 portfolio,
3143 );
3144 trader.add_exec_algorithm(exec_algorithm).unwrap();
3145 trader.start_components().unwrap();
3146
3147 cache
3148 .borrow_mut()
3149 .add_order(parent.clone(), None, None, false)
3150 .unwrap();
3151 let submit = SubmitOrder::new(
3152 trader_id,
3153 None,
3154 strategy_id,
3155 instrument_id,
3156 parent.client_order_id(),
3157 parent.init_event().clone(),
3158 Some(exec_algorithm_id),
3159 None,
3160 None,
3161 UUID4::new(),
3162 clock.borrow().timestamp_ns(),
3163 None,
3164 );
3165 get_actor_unchecked::<TestExecutionAlgorithm>(&exec_algorithm_id.inner())
3166 .execute(TradingCommand::SubmitOrder(submit))
3167 .unwrap();
3168
3169 let submitted = OrderEventAny::Submitted(
3170 OrderSubmittedSpec::builder()
3171 .trader_id(trader_id)
3172 .strategy_id(strategy_id)
3173 .instrument_id(instrument_id)
3174 .client_order_id(parent.client_order_id())
3175 .account_id(account_id)
3176 .build(),
3177 );
3178 let accepted = OrderEventAny::Accepted(
3179 OrderAcceptedSpec::builder()
3180 .trader_id(trader_id)
3181 .strategy_id(strategy_id)
3182 .instrument_id(instrument_id)
3183 .client_order_id(parent.client_order_id())
3184 .venue_order_id(venue_order_id)
3185 .account_id(account_id)
3186 .build(),
3187 );
3188 msgbus::send_order_event(MessagingSwitchboard::exec_engine_process(), submitted);
3189 msgbus::send_order_event(MessagingSwitchboard::exec_engine_process(), accepted);
3190
3191 {
3192 let cache = cache.borrow();
3193 let parent = cache.order(&parent.client_order_id()).unwrap();
3194 let child = cache.order(&child_order_id).unwrap();
3195 let exec_algorithm =
3196 get_actor_unchecked::<TestExecutionAlgorithm>(&exec_algorithm_id.inner());
3197
3198 assert!(!trading_cmd_queue_is_empty());
3199 assert_eq!(risk_engine.borrow().command_count(), 0);
3200 assert_eq!(exec_engine.borrow().event_count(), 2);
3201 assert_eq!(parent.status(), OrderStatus::Accepted);
3202 assert_eq!(parent.event_count(), 3);
3203 assert_eq!(child.status(), OrderStatus::Initialized);
3204 assert_eq!(child.event_count(), 1);
3205 assert_eq!(exec_algorithm.accepted_events, 1);
3206 assert_eq!(exec_algorithm.denied_events, 0);
3207 assert!(exec_algorithm.submit_on_accept.is_none());
3208 }
3209
3210 drain_trading_cmd_queue();
3211
3212 {
3213 let cache = cache.borrow();
3214 let parent = cache.order(&parent.client_order_id()).unwrap();
3215 let child = cache.order(&child_order_id).unwrap();
3216 let exec_algorithm =
3217 get_actor_unchecked::<TestExecutionAlgorithm>(&exec_algorithm_id.inner());
3218
3219 assert!(trading_cmd_queue_is_empty());
3220 assert_eq!(risk_engine.borrow().command_count(), 1);
3221 assert_eq!(exec_engine.borrow().event_count(), 3);
3222 assert_eq!(parent.status(), OrderStatus::Accepted);
3223 assert_eq!(parent.event_count(), 3);
3224 assert_eq!(child.status(), OrderStatus::Denied);
3225 assert_eq!(child.event_count(), 2);
3226 assert_eq!(
3227 child.last_event().message(),
3228 Some("QUANTITY_EXCEEDS_MAXIMUM: effective=100000000, max=1000000".into())
3229 );
3230 assert_eq!(exec_algorithm.accepted_events, 1);
3231 assert_eq!(exec_algorithm.denied_events, 1);
3232 assert!(exec_algorithm.submit_on_accept.is_none());
3233 }
3234 })
3235 .join()
3236 .unwrap();
3237 }
3238
3239 #[rstest]
3240 fn test_exec_algorithm_restores_cached_strategy_subscriptions_on_start_and_restart() {
3241 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
3242 create_trader_components();
3243 let trader_id = TraderId::test_default();
3244 let instance_id = UUID4::new();
3245 let unique = UUID4::new();
3246 let exec_algorithm_id = ExecAlgorithmId::from(format!("RECOVERY-{unique}"));
3247 let other_algorithm_id = ExecAlgorithmId::from(format!("OTHER-{unique}"));
3248 let strategy_a = StrategyId::from(format!("RecoveryA-{unique}"));
3249 let strategy_b = StrategyId::from(format!("RecoveryB-{unique}"));
3250 let terminal_strategy = StrategyId::from(format!("Terminal-{unique}"));
3251 let external_strategy = StrategyId::external();
3252
3253 let order_a = add_cached_exec_order(
3254 &cache,
3255 ClientOrderId::from(format!("O-A1-{unique}")),
3256 strategy_a,
3257 Some(exec_algorithm_id),
3258 false,
3259 );
3260 add_cached_exec_order(
3261 &cache,
3262 ClientOrderId::from(format!("O-A2-{unique}")),
3263 strategy_a,
3264 Some(exec_algorithm_id),
3265 false,
3266 );
3267 add_cached_exec_order(
3268 &cache,
3269 ClientOrderId::from(format!("O-B-{unique}")),
3270 strategy_b,
3271 Some(exec_algorithm_id),
3272 false,
3273 );
3274 add_cached_exec_order(
3275 &cache,
3276 ClientOrderId::from(format!("O-TERMINAL-{unique}")),
3277 terminal_strategy,
3278 Some(exec_algorithm_id),
3279 true,
3280 );
3281 add_cached_exec_order(
3282 &cache,
3283 ClientOrderId::from(format!("O-OTHER-{unique}")),
3284 StrategyId::from(format!("Other-{unique}")),
3285 Some(other_algorithm_id),
3286 false,
3287 );
3288 add_cached_exec_order(
3289 &cache,
3290 ClientOrderId::from(format!("O-EXTERNAL-{unique}")),
3291 external_strategy,
3292 None,
3293 false,
3294 );
3295
3296 let mut trader = Trader::new(
3297 trader_id,
3298 instance_id,
3299 Environment::Backtest,
3300 clock_factory,
3301 cache,
3302 portfolio,
3303 );
3304 let config = ExecutionAlgorithmConfig {
3305 exec_algorithm_id: Some(exec_algorithm_id),
3306 ..Default::default()
3307 };
3308 trader
3309 .add_exec_algorithm(TestExecutionAlgorithm::new(config))
3310 .unwrap();
3311
3312 trader.start_components().unwrap();
3313
3314 assert_eq!(order_a.exec_spawn_id(), Some(order_a.client_order_id()));
3315 {
3316 let registered =
3317 get_actor_unchecked::<TestExecutionAlgorithm>(&exec_algorithm_id.inner());
3318 assert!(registered.core.is_strategy_subscribed(&strategy_a));
3319 assert!(registered.core.is_strategy_subscribed(&strategy_b));
3320 assert!(!registered.core.is_strategy_subscribed(&terminal_strategy));
3321 assert!(!registered.core.is_strategy_subscribed(&external_strategy));
3322 }
3323
3324 let rejected = OrderEventAny::Rejected(
3325 OrderRejectedSpec::builder()
3326 .trader_id(order_a.trader_id())
3327 .strategy_id(strategy_a)
3328 .instrument_id(order_a.instrument_id())
3329 .client_order_id(order_a.client_order_id())
3330 .account_id(AccountId::test_default())
3331 .reason("TEST_REJECTED".into())
3332 .build(),
3333 );
3334 let updated = OrderEventAny::Updated(
3335 OrderUpdatedSpec::builder()
3336 .trader_id(order_a.trader_id())
3337 .strategy_id(strategy_a)
3338 .instrument_id(order_a.instrument_id())
3339 .client_order_id(order_a.client_order_id())
3340 .build(),
3341 );
3342 let filled = OrderEventAny::Filled(
3343 OrderFilledSpec::builder()
3344 .trader_id(order_a.trader_id())
3345 .strategy_id(strategy_a)
3346 .instrument_id(order_a.instrument_id())
3347 .client_order_id(order_a.client_order_id())
3348 .build(),
3349 );
3350 let position = PositionEvent::PositionAdjusted(PositionAdjusted::new(
3351 trader_id,
3352 strategy_a,
3353 InstrumentId::test_default(),
3354 PositionId::from(format!("P-{unique}")),
3355 AccountId::test_default(),
3356 PositionAdjustmentType::Funding,
3357 None,
3358 None,
3359 None,
3360 UUID4::new(),
3361 0.into(),
3362 0.into(),
3363 ));
3364
3365 let order_topic = format!("events.order.{strategy_a}");
3366 msgbus::publish_order_event(order_topic.clone().into(), &rejected);
3367 msgbus::publish_order_event(order_topic.clone().into(), &updated);
3368 msgbus::publish_order_event(order_topic.into(), &filled);
3369 msgbus::publish_position_event(format!("events.position.{strategy_a}").into(), &position);
3370
3371 {
3372 let registered =
3373 get_actor_unchecked::<TestExecutionAlgorithm>(&exec_algorithm_id.inner());
3374 assert_eq!(registered.rejected_events, 1);
3375 assert_eq!(registered.updated_events, 1);
3376 assert_eq!(registered.filled_events, 1);
3377 assert_eq!(registered.position_events, 1);
3378 }
3379
3380 trader.stop_components().unwrap();
3381 trader.reset_components().unwrap();
3382 {
3383 let registered =
3384 get_actor_unchecked::<TestExecutionAlgorithm>(&exec_algorithm_id.inner());
3385 assert!(!registered.core.is_strategy_subscribed(&strategy_a));
3386 assert!(!registered.core.is_strategy_subscribed(&strategy_b));
3387 }
3388
3389 trader.start_components().unwrap();
3390 {
3391 let registered =
3392 get_actor_unchecked::<TestExecutionAlgorithm>(&exec_algorithm_id.inner());
3393 assert!(registered.core.is_strategy_subscribed(&strategy_a));
3394 assert!(registered.core.is_strategy_subscribed(&strategy_b));
3395 }
3396
3397 trader.stop_components().unwrap();
3398 trader.clear_exec_algorithms().unwrap();
3399 assert!(trader.exec_algorithm_restore_fns.is_empty());
3400 assert!(trader.exec_algorithm_cleanup_fns.is_empty());
3401 }
3402
3403 #[rstest]
3404 fn test_exec_algorithm_start_failure_cleans_all_restored_subscriptions() {
3405 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
3406 create_trader_components();
3407 let trader_id = TraderId::test_default();
3408 let instance_id = UUID4::new();
3409 let unique = UUID4::new();
3410 let running_algorithm_id = ExecAlgorithmId::from(format!("RUNNING-{unique}"));
3411 let failing_algorithm_id = ExecAlgorithmId::from(format!("FAIL-{unique}"));
3412 let running_strategy_id = StrategyId::from(format!("Running-{unique}"));
3413 let failing_strategy_id = StrategyId::from(format!("Failing-{unique}"));
3414 add_cached_exec_order(
3415 &cache,
3416 ClientOrderId::from(format!("O-RUNNING-{unique}")),
3417 running_strategy_id,
3418 Some(running_algorithm_id),
3419 false,
3420 );
3421 add_cached_exec_order(
3422 &cache,
3423 ClientOrderId::from(format!("O-FAILING-{unique}")),
3424 failing_strategy_id,
3425 Some(failing_algorithm_id),
3426 false,
3427 );
3428
3429 let mut trader = Trader::new(
3430 trader_id,
3431 instance_id,
3432 Environment::Backtest,
3433 clock_factory,
3434 cache,
3435 portfolio,
3436 );
3437 let running_config = ExecutionAlgorithmConfig {
3438 exec_algorithm_id: Some(running_algorithm_id),
3439 ..Default::default()
3440 };
3441 trader
3442 .add_exec_algorithm(TestExecutionAlgorithm::new(running_config))
3443 .unwrap();
3444 let failing_config = ExecutionAlgorithmConfig {
3445 exec_algorithm_id: Some(failing_algorithm_id),
3446 ..Default::default()
3447 };
3448 let mut failing_algorithm = TestExecutionAlgorithm::new(failing_config);
3449 failing_algorithm.fail_start = true;
3450 trader.add_exec_algorithm(failing_algorithm).unwrap();
3451 trader.initialize().unwrap();
3452 let trader = Rc::new(RefCell::new(trader));
3453
3454 let error = Trader::start_with_component_callbacks(&trader).unwrap_err();
3455
3456 assert!(
3457 error
3458 .to_string()
3459 .contains("test execution algorithm start failure")
3460 );
3461 {
3462 let running =
3463 get_actor_unchecked::<TestExecutionAlgorithm>(&running_algorithm_id.inner());
3464 let failing =
3465 get_actor_unchecked::<TestExecutionAlgorithm>(&failing_algorithm_id.inner());
3466 assert!(!running.core.is_strategy_subscribed(&running_strategy_id));
3467 assert!(!failing.core.is_strategy_subscribed(&failing_strategy_id));
3468 }
3469
3470 trader.borrow_mut().stop_after_start_failure().unwrap();
3471
3472 let running = get_actor_unchecked::<TestExecutionAlgorithm>(&running_algorithm_id.inner());
3473 assert!(!running.core.is_strategy_subscribed(&running_strategy_id));
3474 }
3475
3476 #[rstest]
3477 fn test_start_components_failure_cleans_previously_restored_subscriptions() {
3478 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
3479 create_trader_components();
3480 let trader_id = TraderId::test_default();
3481 let instance_id = UUID4::new();
3482 let unique = UUID4::new();
3483 let running_algorithm_id = ExecAlgorithmId::from(format!("DIRECT-RUNNING-{unique}"));
3484 let failing_algorithm_id = ExecAlgorithmId::from(format!("DIRECT-FAIL-{unique}"));
3485 let running_strategy_id = StrategyId::from(format!("DirectRunning-{unique}"));
3486 let failing_strategy_id = StrategyId::from(format!("DirectFailing-{unique}"));
3487 add_cached_exec_order(
3488 &cache,
3489 ClientOrderId::from(format!("O-DIRECT-RUNNING-{unique}")),
3490 running_strategy_id,
3491 Some(running_algorithm_id),
3492 false,
3493 );
3494 add_cached_exec_order(
3495 &cache,
3496 ClientOrderId::from(format!("O-DIRECT-FAILING-{unique}")),
3497 failing_strategy_id,
3498 Some(failing_algorithm_id),
3499 false,
3500 );
3501
3502 let mut trader = Trader::new(
3503 trader_id,
3504 instance_id,
3505 Environment::Backtest,
3506 clock_factory,
3507 cache,
3508 portfolio,
3509 );
3510 trader
3511 .add_exec_algorithm(TestExecutionAlgorithm::new(ExecutionAlgorithmConfig {
3512 exec_algorithm_id: Some(running_algorithm_id),
3513 ..Default::default()
3514 }))
3515 .unwrap();
3516 let mut failing_algorithm = TestExecutionAlgorithm::new(ExecutionAlgorithmConfig {
3517 exec_algorithm_id: Some(failing_algorithm_id),
3518 ..Default::default()
3519 });
3520 failing_algorithm.fail_start = true;
3521 trader.add_exec_algorithm(failing_algorithm).unwrap();
3522
3523 let error = trader.start_components().unwrap_err();
3524
3525 assert!(
3526 error
3527 .to_string()
3528 .contains("test execution algorithm start failure")
3529 );
3530 let running = get_actor_unchecked::<TestExecutionAlgorithm>(&running_algorithm_id.inner());
3531 let failing = get_actor_unchecked::<TestExecutionAlgorithm>(&failing_algorithm_id.inner());
3532 assert!(!running.core.is_strategy_subscribed(&running_strategy_id));
3533 assert!(!failing.core.is_strategy_subscribed(&failing_strategy_id));
3534 }
3535
3536 #[rstest]
3537 fn test_cannot_add_exec_algorithm_while_running() {
3538 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
3539 create_trader_components();
3540 let trader_id = TraderId::test_default();
3541 let instance_id = UUID4::new();
3542
3543 let mut trader = Trader::new(
3544 trader_id,
3545 instance_id,
3546 Environment::Backtest,
3547 clock_factory,
3548 cache,
3549 portfolio,
3550 );
3551 trader.state = ComponentState::Running;
3552
3553 let config = ExecutionAlgorithmConfig {
3554 exec_algorithm_id: Some(ExecAlgorithmId::from("TestExecutionAlgorithm")),
3555 ..Default::default()
3556 };
3557 let exec_algorithm = TestExecutionAlgorithm::new(config);
3558
3559 let result = trader.add_exec_algorithm(exec_algorithm);
3560 assert!(result.is_err());
3561 assert_eq!(
3562 result.unwrap_err().to_string(),
3563 "Cannot add execution algorithms to running trader"
3564 );
3565 assert_eq!(trader.exec_algorithm_count(), 0);
3566 }
3567
3568 #[rstest]
3569 fn test_component_lifecycle() {
3570 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
3571 create_trader_components();
3572 let trader_id = TraderId::test_default();
3573 let instance_id = UUID4::new();
3574
3575 let mut trader = Trader::new(
3576 trader_id,
3577 instance_id,
3578 Environment::Backtest,
3579 clock_factory,
3580 cache,
3581 portfolio,
3582 );
3583
3584 let actor = TestDataActor::new(DataActorConfig::default());
3586
3587 let strategy_config = StrategyConfig {
3588 strategy_id: Some(StrategyId::from("Test-Strategy")),
3589 ..Default::default()
3590 };
3591 let strategy = TestStrategy::new(strategy_config);
3592
3593 let exec_algorithm_config = ExecutionAlgorithmConfig {
3594 exec_algorithm_id: Some(ExecAlgorithmId::from("TestExecutionAlgorithm")),
3595 ..Default::default()
3596 };
3597 let exec_algorithm = TestExecutionAlgorithm::new(exec_algorithm_config);
3598
3599 assert!(trader.add_actor(actor).is_ok());
3600 assert!(trader.add_strategy(strategy).is_ok());
3601 assert!(trader.add_exec_algorithm(exec_algorithm).is_ok());
3602 assert_eq!(trader.component_count(), 3);
3603
3604 let start_result = trader.start_components();
3606 assert!(start_result.is_ok(), "{:?}", start_result.unwrap_err());
3607
3608 assert!(trader.stop_components().is_ok());
3610
3611 assert!(trader.reset_components().is_ok());
3613
3614 assert!(trader.dispose_components().is_ok());
3616 assert_eq!(trader.component_count(), 0);
3617 }
3618
3619 #[rstest]
3620 fn test_native_strategy_timer_routes_market_exit_before_user_callback() {
3621 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
3622 create_trader_components();
3623 let mut trader = Trader::new(
3624 TraderId::test_default(),
3625 UUID4::new(),
3626 Environment::Backtest,
3627 clock_factory,
3628 cache,
3629 portfolio,
3630 );
3631 let strategy_id = StrategyId::from("TimerRouting-001");
3632 let strategy = TimerRoutingStrategy::new(StrategyConfig {
3633 strategy_id: Some(strategy_id),
3634 manage_stop: true,
3635 market_exit_interval_ms: 1,
3636 ..Default::default()
3637 });
3638
3639 trader.add_strategy(strategy).unwrap();
3640 trader.start_components().unwrap();
3641 trader.stop_components().unwrap();
3642
3643 let clock = trader.get_component_clocks().into_iter().next().unwrap();
3644 let deadline = clock.borrow().timestamp_ns() + DurationNanos::new(1_000_000);
3645 let dispatched = dispatch_component_time_events(&clock, deadline);
3646 let strategy = get_actor_unchecked::<TimerRoutingStrategy>(&strategy_id.inner());
3647
3648 assert_eq!(dispatched, 1);
3649 assert_eq!(strategy.time_events, 1);
3650 assert_eq!(strategy.strategy_time_events, 0);
3651 assert_eq!(strategy.post_market_exits, 1);
3652 assert_eq!(strategy.post_market_exits_on_callback, Some(1));
3653 assert!(!strategy.is_exiting());
3654 assert_eq!(strategy.state(), ComponentState::Stopped);
3655 }
3656
3657 #[rstest]
3658 fn test_native_strategy_timer_routes_gtd_expiry_before_user_callback() {
3659 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
3660 create_trader_components();
3661 let trader_id = TraderId::test_default();
3662 let mut trader = Trader::new(
3663 trader_id,
3664 UUID4::new(),
3665 Environment::Backtest,
3666 clock_factory,
3667 cache.clone(),
3668 portfolio,
3669 );
3670
3671 let (strategy_id, client_order_id, deadline) =
3672 register_gtd_timer(&mut trader, &cache, trader_id);
3673
3674 let clock = trader.get_component_clocks().into_iter().next().unwrap();
3675 let dispatched = dispatch_component_time_events(&clock, deadline);
3676 let mut strategy = get_actor_unchecked::<TimerRoutingStrategy>(&strategy_id.inner());
3677 let strategy_state = (
3678 strategy.time_events,
3679 strategy.strategy_time_events,
3680 strategy.gtd_timer_active_on_callback,
3681 strategy.has_gtd_expiry_timer(&client_order_id),
3682 );
3683 drop(strategy);
3684 let cache_ref = cache.borrow();
3685 let cached_order = cache_ref.order(&client_order_id).unwrap();
3686
3687 assert_eq!(dispatched, 1);
3688 assert_eq!(strategy_state, (1, 0, Some(false), false));
3689 assert_eq!(cached_order.status(), OrderStatus::PendingCancel);
3690 assert_eq!(cached_order.event_count(), 4);
3691 }
3692
3693 #[rstest]
3694 fn test_native_strategy_timer_skips_gtd_expiry_when_stopped() {
3695 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
3696 create_trader_components();
3697 let trader_id = TraderId::test_default();
3698 let mut trader = Trader::new(
3699 trader_id,
3700 UUID4::new(),
3701 Environment::Backtest,
3702 clock_factory,
3703 cache.clone(),
3704 portfolio,
3705 );
3706
3707 let (strategy_id, client_order_id, deadline) =
3708 register_gtd_timer(&mut trader, &cache, trader_id);
3709 trader.stop_components().unwrap();
3710
3711 let clock = trader.get_component_clocks().into_iter().next().unwrap();
3712 let dispatched = dispatch_component_time_events(&clock, deadline);
3713 let mut strategy = get_actor_unchecked::<TimerRoutingStrategy>(&strategy_id.inner());
3714 let strategy_state = (
3715 strategy.time_events,
3716 strategy.strategy_time_events,
3717 strategy.has_gtd_expiry_timer(&client_order_id),
3718 strategy.state(),
3719 );
3720 drop(strategy);
3721 let cache_ref = cache.borrow();
3722 let cached_order = cache_ref.order(&client_order_id).unwrap();
3723
3724 assert_eq!(dispatched, 1);
3725 assert_eq!(strategy_state, (0, 0, true, ComponentState::Stopped));
3726 assert_eq!(cached_order.status(), OrderStatus::Accepted);
3727 assert_eq!(cached_order.event_count(), 3);
3728 }
3729
3730 fn dispatch_component_time_events(
3731 clock: &Rc<RefCell<dyn Clock>>,
3732 to_time_ns: UnixNanos,
3733 ) -> usize {
3734 let handlers = queue_component_time_events(clock, to_time_ns);
3735 let dispatched = handlers.len();
3736 for handler in handlers {
3737 handler.run();
3738 }
3739
3740 dispatched
3741 }
3742
3743 fn queue_component_time_events(
3744 clock: &Rc<RefCell<dyn Clock>>,
3745 to_time_ns: UnixNanos,
3746 ) -> Vec<TimeEventHandler> {
3747 let mut clock_ref = clock.borrow_mut();
3748 let test_clock = clock_ref
3749 .as_any_mut()
3750 .downcast_mut::<VirtualClock>()
3751 .expect("component clock must be VirtualClock");
3752 let events = test_clock.advance_time(to_time_ns, true);
3753 test_clock.match_handlers(events)
3754 }
3755
3756 fn register_gtd_timer(
3757 trader: &mut Trader,
3758 cache: &Rc<RefCell<Cache>>,
3759 trader_id: TraderId,
3760 ) -> (StrategyId, ClientOrderId, UnixNanos) {
3761 let deadline =
3762 trader.clock_factory.clock().borrow().timestamp_ns() + DurationNanos::new(1_000_000);
3763 let strategy_id = StrategyId::from("TimerRouting-001");
3764 let strategy = TimerRoutingStrategy::new(StrategyConfig {
3765 strategy_id: Some(strategy_id),
3766 manage_gtd_expiry: true,
3767 ..Default::default()
3768 });
3769 let client_order_id = ClientOrderId::from("O-GTD-001");
3770 let order = OrderTestBuilder::new(OrderType::Limit)
3771 .trader_id(trader_id)
3772 .strategy_id(strategy_id)
3773 .instrument_id(InstrumentId::test_default())
3774 .client_order_id(client_order_id)
3775 .quantity(Quantity::from(1))
3776 .price(Price::from("1.00"))
3777 .time_in_force(TimeInForce::Gtd)
3778 .expire_time(deadline)
3779 .build();
3780
3781 trader.add_strategy(strategy).unwrap();
3782 trader.start_components().unwrap();
3783 cache_accepted_order(cache, &order);
3784 get_actor_unchecked::<TimerRoutingStrategy>(&strategy_id.inner())
3785 .set_gtd_expiry(&order)
3786 .unwrap();
3787
3788 (strategy_id, client_order_id, deadline)
3789 }
3790
3791 fn cache_accepted_order(cache: &Rc<RefCell<Cache>>, order: &OrderAny) {
3792 let account_id = AccountId::test_default();
3793 let submitted = OrderEventAny::Submitted(
3794 OrderSubmittedSpec::builder()
3795 .trader_id(order.trader_id())
3796 .strategy_id(order.strategy_id())
3797 .instrument_id(order.instrument_id())
3798 .client_order_id(order.client_order_id())
3799 .account_id(account_id)
3800 .build(),
3801 );
3802 let accepted = OrderEventAny::Accepted(
3803 OrderAcceptedSpec::builder()
3804 .trader_id(order.trader_id())
3805 .strategy_id(order.strategy_id())
3806 .instrument_id(order.instrument_id())
3807 .client_order_id(order.client_order_id())
3808 .venue_order_id(VenueOrderId::from("V-GTD-001"))
3809 .account_id(account_id)
3810 .build(),
3811 );
3812 let mut cache = cache.borrow_mut();
3813 cache.add_order(order.clone(), None, None, false).unwrap();
3814 cache.update_order(&submitted).unwrap();
3815 cache.update_order(&accepted).unwrap();
3816 }
3817
3818 #[rstest]
3819 fn test_trader_component_lifecycle() {
3820 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
3821 create_trader_components();
3822 let trader_id = TraderId::test_default();
3823 let instance_id = UUID4::new();
3824
3825 let mut trader = Trader::new(
3826 trader_id,
3827 instance_id,
3828 Environment::Backtest,
3829 clock_factory,
3830 cache,
3831 portfolio,
3832 );
3833
3834 assert_eq!(trader.state(), ComponentState::PreInitialized);
3836 assert!(!trader.is_running());
3837 assert!(!trader.is_stopped());
3838 assert!(!trader.is_disposed());
3839
3840 assert!(trader.start().is_err());
3842
3843 trader.initialize().unwrap();
3845
3846 assert!(trader.start().is_ok());
3848 assert_eq!(trader.state(), ComponentState::Running);
3849 assert!(trader.is_running());
3850 assert!(trader.ts_started().is_some());
3851
3852 assert!(trader.stop().is_ok());
3854 assert_eq!(trader.state(), ComponentState::Stopped);
3855 assert!(trader.is_stopped());
3856 assert!(trader.ts_stopped().is_some());
3857
3858 assert!(trader.reset().is_ok());
3860 assert_eq!(trader.state(), ComponentState::Ready);
3861 assert!(trader.ts_started().is_none());
3862 assert!(trader.ts_stopped().is_none());
3863
3864 assert!(trader.dispose().is_ok());
3866 assert_eq!(trader.state(), ComponentState::Disposed);
3867 assert!(trader.is_disposed());
3868 }
3869
3870 #[rstest]
3871 #[case("actor", "actor StopActor-0: test actor stop failure")]
3872 #[case(
3873 "algorithm",
3874 "execution algorithm StopAlgorithm-0: test execution algorithm stop failure"
3875 )]
3876 #[case("strategy", "strategy StopStrategy-000: test strategy stop failure")]
3877 fn test_stop_failure_stops_remaining_components(
3878 #[case] failing_kind: &str,
3879 #[case] expected_error: &str,
3880 #[values(false, true)] after_start_failure: bool,
3881 ) {
3882 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
3883 create_trader_components();
3884 let clock = clock_factory.clock();
3885
3886 let mut trader = Trader::new(
3887 TraderId::test_default(),
3888 UUID4::new(),
3889 Environment::Backtest,
3890 clock_factory,
3891 cache,
3892 portfolio,
3893 );
3894
3895 let mut components = Vec::new();
3896
3897 for index in 0..2 {
3898 let actor_id = ActorId::from(format!("StopActor-{index}"));
3899
3900 let mut actor = TestDataActor::new(DataActorConfig {
3901 actor_id: Some(actor_id),
3902 ..Default::default()
3903 });
3904
3905 actor.fail_stop = failing_kind == "actor" && index == 0;
3906 components.push((actor_id.inner(), actor.fail_stop));
3907 trader.add_actor(actor).unwrap();
3908
3909 let algorithm_id = ExecAlgorithmId::from(format!("StopAlgorithm-{index}"));
3910
3911 let mut algorithm = TestExecutionAlgorithm::new(ExecutionAlgorithmConfig {
3912 exec_algorithm_id: Some(algorithm_id),
3913 ..Default::default()
3914 });
3915
3916 algorithm.fail_stop = failing_kind == "algorithm" && index == 0;
3917 components.push((algorithm_id.inner(), algorithm.fail_stop));
3918 trader.add_exec_algorithm(algorithm).unwrap();
3919
3920 let strategy_id = StrategyId::from(format!("StopStrategy-{index:03}"));
3921
3922 let mut strategy = TestStrategy::new(StrategyConfig {
3923 strategy_id: Some(strategy_id),
3924 ..Default::default()
3925 });
3926
3927 strategy.fail_stop = failing_kind == "strategy" && index == 0;
3928 components.push((strategy_id.inner(), strategy.fail_stop));
3929 trader.add_strategy(strategy).unwrap();
3930 }
3931
3932 trader.initialize().unwrap();
3933 trader.start().unwrap();
3934 clock
3935 .borrow_mut()
3936 .as_any_mut()
3937 .downcast_mut::<VirtualClock>()
3938 .unwrap()
3939 .set_time(3_000_000_000u64.into());
3940
3941 let result = if after_start_failure {
3942 trader.stop_after_start_failure()
3943 } else {
3944 trader.stop()
3945 };
3946
3947 let error = result.unwrap_err();
3948
3949 let prefix = if after_start_failure {
3950 "Failed to stop one or more trader components after startup failure"
3951 } else {
3952 "Failed to stop trader components"
3953 };
3954
3955 assert_eq!(error.to_string(), format!("{prefix}: {expected_error}"));
3956 assert_eq!(trader.state(), ComponentState::Stopped);
3957 assert_eq!(trader.ts_stopped(), Some(3_000_000_000u64.into()));
3958
3959 for (component_id, fail_stop) in components {
3960 let expected = if fail_stop {
3961 ComponentState::Stopping
3962 } else {
3963 ComponentState::Stopped
3964 };
3965
3966 assert_eq!(component_state(&component_id).unwrap(), expected);
3967 }
3968 }
3969
3970 #[rstest]
3971 fn test_stop_collects_all_callback_errors(#[values(false, true)] after_start_failure: bool) {
3972 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
3973 create_trader_components();
3974
3975 let mut trader = Trader::new(
3976 TraderId::test_default(),
3977 UUID4::new(),
3978 Environment::Backtest,
3979 clock_factory,
3980 cache,
3981 portfolio,
3982 );
3983
3984 let actor_ids = [ActorId::from("Stop-A"), ActorId::from("Stop-B")];
3985 for actor_id in actor_ids {
3986 let mut actor = TestDataActor::new(DataActorConfig {
3987 actor_id: Some(actor_id),
3988 ..Default::default()
3989 });
3990
3991 actor.fail_stop = true;
3992 trader.add_actor(actor).unwrap();
3993 }
3994
3995 trader.initialize().unwrap();
3996 trader.start().unwrap();
3997 let result = if after_start_failure {
3998 trader.stop_after_start_failure()
3999 } else {
4000 trader.stop()
4001 };
4002
4003 let prefix = if after_start_failure {
4004 "Failed to stop one or more trader components after startup failure"
4005 } else {
4006 "Failed to stop trader components"
4007 };
4008
4009 assert_eq!(
4010 result.unwrap_err().to_string(),
4011 format!(
4012 "{prefix}: actor Stop-A: test actor stop failure; actor Stop-B: test actor stop failure"
4013 )
4014 );
4015 assert_eq!(trader.state(), ComponentState::Stopped);
4016
4017 for actor_id in actor_ids {
4018 assert_eq!(
4019 component_state(&actor_id.inner()).unwrap(),
4020 ComponentState::Stopping
4021 );
4022 }
4023 }
4024
4025 #[rstest]
4026 fn test_stop_error_preserves_managed_strategy_deferral() {
4027 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4028 create_trader_components();
4029
4030 let mut trader = Trader::new(
4031 TraderId::test_default(),
4032 UUID4::new(),
4033 Environment::Backtest,
4034 clock_factory,
4035 cache,
4036 portfolio,
4037 );
4038
4039 let mut actor = TestDataActor::new(DataActorConfig::default());
4040 actor.fail_stop = true;
4041 trader.add_actor(actor).unwrap();
4042 let strategy_id = StrategyId::from("ManagedStop-001");
4043 trader
4044 .add_strategy(TimerRoutingStrategy::new(StrategyConfig {
4045 strategy_id: Some(strategy_id),
4046 manage_stop: true,
4047 market_exit_interval_ms: 1,
4048 ..Default::default()
4049 }))
4050 .unwrap();
4051
4052 trader.initialize().unwrap();
4053 trader.start().unwrap();
4054
4055 let error = trader.stop().unwrap_err();
4056
4057 assert_eq!(
4058 error.to_string(),
4059 "Failed to stop trader components: actor DataActor: test actor stop failure"
4060 );
4061 assert_eq!(trader.state(), ComponentState::Stopped);
4062 {
4063 let strategy = get_actor_unchecked::<TimerRoutingStrategy>(&strategy_id.inner());
4064 assert_eq!(strategy.state(), ComponentState::Running);
4065 assert!(strategy.is_exiting());
4066 }
4067
4068 let clock = trader.clocks[&ComponentId::from(strategy_id)].clone();
4069 let deadline = clock.borrow().timestamp_ns() + DurationNanos::new(1_000_000);
4070 let dispatched = dispatch_component_time_events(&clock, deadline);
4071
4072 let strategy = get_actor_unchecked::<TimerRoutingStrategy>(&strategy_id.inner());
4073 assert_eq!(dispatched, 1);
4074 assert_eq!(strategy.state(), ComponentState::Stopped);
4075 assert!(!strategy.is_exiting());
4076 assert_eq!(strategy.post_market_exits, 1);
4077 }
4078
4079 #[rstest]
4080 fn test_stop_includes_degraded_components(#[values(false, true)] after_start_failure: bool) {
4081 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4082 create_trader_components();
4083
4084 let mut trader = Trader::new(
4085 TraderId::test_default(),
4086 UUID4::new(),
4087 Environment::Backtest,
4088 clock_factory,
4089 cache,
4090 portfolio,
4091 );
4092
4093 let actor_id = ActorId::from("DegradedActor");
4094 trader
4095 .add_actor(TestDataActor::new(DataActorConfig {
4096 actor_id: Some(actor_id),
4097 ..Default::default()
4098 }))
4099 .unwrap();
4100
4101 let algorithm_id = ExecAlgorithmId::from("DegradedAlgorithm");
4102 trader
4103 .add_exec_algorithm(TestExecutionAlgorithm::new(ExecutionAlgorithmConfig {
4104 exec_algorithm_id: Some(algorithm_id),
4105 ..Default::default()
4106 }))
4107 .unwrap();
4108
4109 let strategy_id = StrategyId::from("DegradedStrategy-001");
4110 trader
4111 .add_strategy(TestStrategy::new(StrategyConfig {
4112 strategy_id: Some(strategy_id),
4113 ..Default::default()
4114 }))
4115 .unwrap();
4116
4117 trader.initialize().unwrap();
4118 trader.start().unwrap();
4119 get_actor_unchecked::<TestDataActor>(&actor_id.inner())
4120 .degrade()
4121 .unwrap();
4122 get_actor_unchecked::<TestExecutionAlgorithm>(&algorithm_id.inner())
4123 .degrade()
4124 .unwrap();
4125 get_actor_unchecked::<TestStrategy>(&strategy_id.inner())
4126 .degrade()
4127 .unwrap();
4128
4129 if after_start_failure {
4130 trader.stop_after_start_failure().unwrap();
4131 } else {
4132 trader.stop().unwrap();
4133 }
4134
4135 assert_eq!(trader.state(), ComponentState::Stopped);
4136
4137 for component_id in [actor_id.inner(), algorithm_id.inner(), strategy_id.inner()] {
4138 assert_eq!(
4139 component_state(&component_id).unwrap(),
4140 ComponentState::Stopped
4141 );
4142 }
4143 }
4144
4145 #[rstest]
4146 fn test_market_exit_strategy_fails_when_control_endpoint_missing() {
4147 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4148 create_trader_components();
4149 let trader_id = TraderId::test_default();
4150 let instance_id = UUID4::new();
4151
4152 let mut trader = Trader::new(
4153 trader_id,
4154 instance_id,
4155 Environment::Backtest,
4156 clock_factory,
4157 cache,
4158 portfolio,
4159 );
4160
4161 let config = StrategyConfig {
4162 strategy_id: Some(StrategyId::from("Test-Strategy")),
4163 ..Default::default()
4164 };
4165 let strategy = TestStrategy::new(config);
4166 trader.add_strategy(strategy).unwrap();
4167
4168 let strategy_id = StrategyId::from("Test-Strategy");
4169 let endpoint = strategy_control_endpoint(strategy_id);
4170 assert!(
4171 get_message_bus()
4172 .borrow_mut()
4173 .endpoint_map::<StrategyCommand>()
4174 .is_registered(endpoint)
4175 );
4176 get_message_bus()
4177 .borrow_mut()
4178 .endpoint_map::<StrategyCommand>()
4179 .deregister(endpoint);
4180
4181 let trader = Rc::new(RefCell::new(trader));
4182 let result = Trader::market_exit_strategy(&trader, &strategy_id);
4183 assert!(result.is_err());
4184 assert_eq!(
4185 result.unwrap_err().to_string(),
4186 format!(
4187 "Cannot exit market for strategy {strategy_id}: control endpoint '{}' not registered",
4188 endpoint.as_str()
4189 )
4190 );
4191 }
4192
4193 #[rstest]
4194 fn test_remove_strategy_deregisters_strategy_endpoint() {
4195 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4196 create_trader_components();
4197 let trader_id = TraderId::test_default();
4198 let instance_id = UUID4::new();
4199
4200 let mut trader = Trader::new(
4201 trader_id,
4202 instance_id,
4203 Environment::Backtest,
4204 clock_factory,
4205 cache,
4206 portfolio,
4207 );
4208
4209 let config = StrategyConfig {
4210 strategy_id: Some(StrategyId::from("Test-Strategy")),
4211 ..Default::default()
4212 };
4213 let strategy = TestStrategy::new(config);
4214 trader.add_strategy(strategy).unwrap();
4215
4216 let strategy_id = StrategyId::from("Test-Strategy");
4217 let endpoint = strategy_control_endpoint(strategy_id);
4218 assert!(
4219 get_message_bus()
4220 .borrow_mut()
4221 .endpoint_map::<StrategyCommand>()
4222 .is_registered(endpoint)
4223 );
4224
4225 trader.remove_strategy(&strategy_id).unwrap();
4226
4227 assert!(
4228 !get_message_bus()
4229 .borrow_mut()
4230 .endpoint_map::<StrategyCommand>()
4231 .is_registered(endpoint)
4232 );
4233 }
4234
4235 #[rstest]
4236 fn test_remove_strategy_clears_external_order_claims() {
4237 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4238 create_trader_components();
4239 let trader_id = TraderId::test_default();
4240 let instance_id = UUID4::new();
4241 let strategy_id = StrategyId::from("Test-Strategy");
4242 let instrument_id = InstrumentId::from("AUDUSD.SIM");
4243
4244 let mut trader = Trader::new(
4245 trader_id,
4246 instance_id,
4247 Environment::Backtest,
4248 clock_factory,
4249 cache.clone(),
4250 portfolio,
4251 );
4252 trader
4253 .add_strategy(TestStrategy::new(StrategyConfig {
4254 strategy_id: Some(strategy_id),
4255 ..Default::default()
4256 }))
4257 .unwrap();
4258 cache
4259 .borrow_mut()
4260 .set_external_order_claims(strategy_id, &[instrument_id])
4261 .unwrap();
4262
4263 trader.remove_strategy(&strategy_id).unwrap();
4264
4265 assert_eq!(cache.borrow().external_order_claim(&instrument_id), None);
4266 }
4267
4268 #[rstest]
4269 fn test_remove_strategy_cache_borrow_failure_preserves_strategy_and_claims() {
4270 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4271 create_trader_components();
4272 let strategy_id = StrategyId::from("Test-Strategy");
4273 let instrument_id = InstrumentId::from("AUDUSD.SIM");
4274 let mut trader = Trader::new(
4275 TraderId::test_default(),
4276 UUID4::new(),
4277 Environment::Backtest,
4278 clock_factory,
4279 cache.clone(),
4280 portfolio,
4281 );
4282 trader
4283 .add_strategy(TestStrategy::new(StrategyConfig {
4284 strategy_id: Some(strategy_id),
4285 ..Default::default()
4286 }))
4287 .unwrap();
4288 cache
4289 .borrow_mut()
4290 .set_external_order_claims(strategy_id, &[instrument_id])
4291 .unwrap();
4292
4293 let cache_borrow = cache.borrow();
4294 let error = trader.remove_strategy(&strategy_id).unwrap_err();
4295
4296 assert_eq!(
4297 error.to_string(),
4298 "Cannot clear external order claims: RefCell already borrowed"
4299 );
4300 assert_eq!(
4301 cache_borrow.external_order_claim(&instrument_id),
4302 Some(strategy_id)
4303 );
4304 assert_eq!(trader.strategy_ids(), vec![strategy_id]);
4305 assert_eq!(
4306 component_state(&strategy_id.inner()).unwrap(),
4307 ComponentState::Ready
4308 );
4309
4310 drop(cache_borrow);
4311 trader.remove_strategy(&strategy_id).unwrap();
4312
4313 assert!(trader.strategy_ids().is_empty());
4314 assert_eq!(cache.borrow().external_order_claim(&instrument_id), None);
4315 }
4316
4317 #[rstest]
4318 fn test_can_add_components_while_running() {
4319 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4320 create_trader_components();
4321 let trader_id = TraderId::test_default();
4322 let instance_id = UUID4::new();
4323
4324 let mut trader = Trader::new(
4325 trader_id,
4326 instance_id,
4327 Environment::Backtest,
4328 clock_factory,
4329 cache,
4330 portfolio,
4331 );
4332
4333 trader.state = ComponentState::Running;
4335
4336 let actor = TestDataActor::new(DataActorConfig::default());
4337 let result = trader.add_actor(actor);
4338 assert!(result.is_ok());
4339 assert_eq!(trader.actor_count(), 1);
4340 }
4341
4342 #[rstest]
4343 fn test_cannot_add_components_while_disposed() {
4344 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4345 create_trader_components();
4346 let trader_id = TraderId::test_default();
4347 let instance_id = UUID4::new();
4348
4349 let mut trader = Trader::new(
4350 trader_id,
4351 instance_id,
4352 Environment::Backtest,
4353 clock_factory,
4354 cache,
4355 portfolio,
4356 );
4357
4358 trader.state = ComponentState::Disposed;
4360
4361 let actor = TestDataActor::new(DataActorConfig::default());
4362 let result = trader.add_actor(actor);
4363 assert!(result.is_err());
4364 assert!(result.unwrap_err().to_string().contains("disposed trader"));
4365 }
4366
4367 #[rstest]
4368 fn test_create_component_clock_backtest_creates_individual_clocks() {
4369 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4370 create_trader_components();
4371 let trader_id = TraderId::test_default();
4372 let instance_id = UUID4::new();
4373
4374 let mut trader = Trader::new(
4375 trader_id,
4376 instance_id,
4377 Environment::Backtest,
4378 clock_factory.clone(),
4379 cache,
4380 portfolio,
4381 );
4382
4383 let component_a = ComponentId::new("ACTOR-A");
4384 let component_b = ComponentId::new("ACTOR-B");
4385 let clock_a = trader.create_component_clock(component_a);
4386 let clock_b = trader.create_component_clock(component_b);
4387 let primary_clock = clock_factory.clock();
4388
4389 assert_ne!(
4391 clock_a.as_ptr() as *const _,
4392 primary_clock.as_ptr() as *const _
4393 );
4394 assert_ne!(clock_a.as_ptr() as *const _, clock_b.as_ptr() as *const _);
4395 }
4396
4397 #[rstest]
4398 fn test_get_component_clocks_returns_registration_order() {
4399 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4400 create_trader_components();
4401 let mut trader = Trader::new(
4402 TraderId::test_default(),
4403 UUID4::new(),
4404 Environment::Backtest,
4405 clock_factory,
4406 cache,
4407 portfolio,
4408 );
4409 let mut registered = Vec::new();
4410
4411 for index in 0..32 {
4412 let component_id = ComponentId::new(format!("ACTOR-{index:02}").as_str());
4413 registered.push(trader.create_component_clock(component_id));
4414 }
4415
4416 let returned = trader.get_component_clocks();
4417 assert_eq!(returned.len(), registered.len());
4418 for (actual, expected) in returned.iter().zip(®istered) {
4419 assert!(Rc::ptr_eq(actual, expected));
4420 }
4421 }
4422
4423 #[rstest]
4424 fn test_component_clock_snapshot_tracks_membership() {
4425 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4426 create_trader_components();
4427
4428 let mut trader = Trader::new(
4429 TraderId::test_default(),
4430 UUID4::new(),
4431 Environment::Backtest,
4432 clock_factory,
4433 cache,
4434 portfolio,
4435 );
4436
4437 let component_a = ComponentId::new("ACTOR-A");
4438 let component_b = ComponentId::new("ACTOR-B");
4439 let empty = trader.get_component_clocks_snapshot();
4440
4441 assert!(empty.is_empty());
4442 assert!(Rc::ptr_eq(&empty, &trader.get_component_clocks_snapshot()));
4443
4444 let clock_a = trader.create_component_clock(component_a);
4445 let first = trader.get_component_clocks_snapshot();
4446
4447 assert!(empty.is_empty());
4448 assert_eq!(first.len(), 1);
4449 assert!(Rc::ptr_eq(&first[0], &clock_a));
4450 assert!(Rc::ptr_eq(&first, &trader.get_component_clocks_snapshot()));
4451
4452 let clock_b = trader.create_component_clock(component_b);
4453 let both = trader.get_component_clocks_snapshot();
4454
4455 assert_eq!(first.len(), 1);
4456 assert_eq!(both.len(), 2);
4457 assert!(Rc::ptr_eq(&both[0], &clock_a));
4458 assert!(Rc::ptr_eq(&both[1], &clock_b));
4459
4460 let replacement = trader.create_component_clock(component_a);
4461 let replaced = trader.get_component_clocks_snapshot();
4462
4463 assert_eq!(replaced.len(), 2);
4464 assert!(!Rc::ptr_eq(&both, &replaced));
4465 assert!(Rc::ptr_eq(&both[0], &clock_a));
4466 assert!(Rc::ptr_eq(&replaced[0], &replacement));
4467 assert!(Rc::ptr_eq(&replaced[1], &clock_b));
4468
4469 trader.release_component_clock(component_a);
4470 let remaining = trader.get_component_clocks_snapshot();
4471
4472 assert_eq!(replaced.len(), 2);
4473 assert_eq!(remaining.len(), 1);
4474 assert!(Rc::ptr_eq(&remaining[0], &clock_b));
4475
4476 trader.release_component_clock(component_a);
4477
4478 assert!(Rc::ptr_eq(
4479 &remaining,
4480 &trader.get_component_clocks_snapshot()
4481 ));
4482
4483 trader.dispose_components().unwrap();
4484 let disposed = trader.get_component_clocks_snapshot();
4485
4486 assert_eq!(remaining.len(), 1);
4487 assert!(disposed.is_empty());
4488 assert!(Rc::ptr_eq(
4489 &disposed,
4490 &trader.get_component_clocks_snapshot()
4491 ));
4492 }
4493
4494 #[rstest]
4495 fn test_create_component_clock_live_uses_factory_with_distinct_instances() {
4496 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, _clock_factory) =
4497 create_trader_components();
4498 let calls = Rc::new(Cell::new(0usize));
4499 let calls_in_closure = calls.clone();
4500 let clock_factory = ClockFactory::new(move || {
4501 calls_in_closure.set(calls_in_closure.get() + 1);
4502 Rc::new(RefCell::new(VirtualClock::new())) as Rc<RefCell<dyn Clock>>
4503 });
4504
4505 let mut trader = Trader::new(
4506 TraderId::test_default(),
4507 UUID4::new(),
4508 Environment::Sandbox,
4509 clock_factory,
4510 cache,
4511 portfolio,
4512 );
4513
4514 let a = trader.create_component_clock(ComponentId::new("ACTOR-A"));
4515 let b = trader.create_component_clock(ComponentId::new("ACTOR-B"));
4516
4517 assert_eq!(
4518 calls.get(),
4519 3,
4520 "factory invoked for primary clock and each component",
4521 );
4522 assert!(
4523 !Rc::ptr_eq(&a, &b),
4524 "each component must get its own clock instance"
4525 );
4526 }
4527
4528 #[rstest]
4529 fn test_clear_strategies_preserves_other_handlers() {
4530 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4531 create_trader_components();
4532 let trader_id = TraderId::test_default();
4533 let instance_id = UUID4::new();
4534
4535 let mut trader = Trader::new(
4536 trader_id,
4537 instance_id,
4538 Environment::Backtest,
4539 clock_factory,
4540 cache,
4541 portfolio,
4542 );
4543
4544 let config = StrategyConfig {
4545 strategy_id: Some(StrategyId::from("Test-Strategy")),
4546 ..Default::default()
4547 };
4548 let strategy = TestStrategy::new(config);
4549 trader.add_strategy(strategy).unwrap();
4550
4551 let strategy_id = StrategyId::from("Test-Strategy");
4552 let endpoint = strategy_control_endpoint(strategy_id);
4553 assert!(
4554 get_message_bus()
4555 .borrow_mut()
4556 .endpoint_map::<StrategyCommand>()
4557 .is_registered(endpoint)
4558 );
4559
4560 let ext_received = Rc::new(RefCell::new(0));
4562 let ext_clone = ext_received.clone();
4563 let ext_handler =
4564 TypedHandler::from_with_id("exec-algo-handler", move |_: &OrderEventAny| {
4565 *ext_clone.borrow_mut() += 1;
4566 });
4567 let order_topic = get_event_order_topic(strategy_id);
4568 msgbus::subscribe_order_events(order_topic.into(), ext_handler, None);
4569
4570 trader.clear_strategies().unwrap();
4571 assert_eq!(trader.strategy_count(), 0);
4572 assert!(
4573 !get_message_bus()
4574 .borrow_mut()
4575 .endpoint_map::<StrategyCommand>()
4576 .is_registered(endpoint)
4577 );
4578
4579 let event = OrderEventAny::Accepted(OrderAccepted::test_default());
4580 msgbus::publish_order_event(order_topic, &event);
4581 assert_eq!(*ext_received.borrow(), 1);
4582 }
4583
4584 #[cfg(feature = "python")]
4585 #[rstest]
4586 fn test_component_message_bus_across_registered_python_components() {
4587 use nautilus_trading::python::algorithm::PyExecutionAlgorithm;
4588
4589 Python::initialize();
4590 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4591 create_trader_components();
4592 let bus = msgbus::get_message_bus();
4593 let mut trader = Trader::new(
4594 TraderId::test_default(),
4595 UUID4::new(),
4596 Environment::Backtest,
4597 clock_factory,
4598 cache,
4599 portfolio,
4600 );
4601 Python::attach(|py| {
4602 let locals = PyDict::new(py);
4603 locals
4604 .set_item("DataActor", py.get_type::<PyDataActor>())
4605 .unwrap();
4606 locals
4607 .set_item("Strategy", py.get_type::<PyStrategy>())
4608 .unwrap();
4609 locals
4610 .set_item("ExecutionAlgorithm", py.get_type::<PyExecutionAlgorithm>())
4611 .unwrap();
4612 py.run(
4613 c_str!(
4614 r#"
4615import weakref
4616import threading
4617class Hooks:
4618 def on_start(self): self.subscribe_topic("app.shared", self.receive)
4619 def on_stop(self): pass
4620 def on_resume(self): pass
4621 def on_dispose(self): pass
4622 def receive(self, value): self.received.append(value)
4623class Actor(Hooks, DataActor): pass
4624class TradingStrategy(Hooks, Strategy): pass
4625class Algorithm(Hooks, ExecutionAlgorithm): pass
4626actor = Actor()
4627strategy = TradingStrategy()
4628algorithm = Algorithm()
4629components = [actor, strategy, algorithm]
4630for component in components: component.received = []
4631references = [weakref.ref(component) for component in components]
4632"#
4633 ),
4634 Some(&locals),
4635 None,
4636 )
4637 .unwrap();
4638 let actor = locals.get_item("actor").unwrap().unwrap().unbind();
4639 let strategy = locals.get_item("strategy").unwrap().unwrap().unbind();
4640 let algorithm = locals.get_item("algorithm").unwrap().unwrap().unbind();
4641 let actor_id = ActorId::from("Actor");
4642 trader.add_python_actor_instance(&actor, actor_id).unwrap();
4643 trader.add_python_strategy_instance(&strategy).unwrap();
4644 let native_algorithm = algorithm
4645 .bind(py)
4646 .extract::<PyRef<PyExecutionAlgorithm>>()
4647 .unwrap()
4648 .clone();
4649 trader
4650 .add_py_execution_algorithm_instance(native_algorithm, &algorithm)
4651 .unwrap();
4652 drop((actor, strategy, algorithm));
4653 py.run(
4654 c_str!(
4655 r#"
4656
4657for component in components: component.start()
4658message = {"symbol": "example", "weights": [13, 29]}
4659for component in components: component.publish_message("app.shared", message)
4660for component in components:
4661 assert len(component.received) == 3
4662 assert all(value is message for value in component.received)
4663errors = []
4664def foreign():
4665
4666 for component in components:
4667 for name, args in [("publish_message", ("app.shared", message)),
4668 ("subscribe_topic", ("app.shared", component.receive)),
4669 ("unsubscribe_topic", ("app.shared", component.receive))]:
4670 try: getattr(component, name)(*args)
4671 except RuntimeError: pass
4672 except BaseException as error: errors.append(type(error).__name__)
4673 else: errors.append(name)
4674thread = threading.Thread(target=foreign)
4675thread.start()
4676thread.join()
4677assert errors == []
4678
4679for component in components:
4680 component.unsubscribe_topic("app.shared", component.receive)
4681 component.subscribe_topic("app.shared", component.receive)
4682 component.stop()
4683"#
4684 ),
4685 Some(&locals),
4686 None,
4687 )
4688 .unwrap();
4689 assert!(Rc::ptr_eq(&bus, &msgbus::get_message_bus()));
4690 trader.dispose_components().unwrap();
4691 py.run(
4692 c_str!(
4693 r#"
4694
4695for component in components:
4696 try: component.subscribe_topic("app.shared", component.receive)
4697 except RuntimeError: pass
4698 else: raise AssertionError("disposed component accepted a subscription")
4699del component, components, actor, strategy, algorithm
4700assert [reference() for reference in references] == [None, None, None]
4701"#
4702 ),
4703 Some(&locals),
4704 None,
4705 )
4706 .unwrap();
4707 locals.clear();
4708 });
4709 }
4710
4711 #[cfg(feature = "python")]
4712 #[rstest]
4713 fn test_python_actor_and_strategy_state_callbacks_use_registered_types() {
4714 pyo3::Python::initialize();
4715
4716 Python::attach(|py| {
4717 py.run(
4718 c_str!(
4719 r#"
4720class StateComponent:
4721 def __init__(self, state):
4722 self.state = state
4723 self.loaded = None
4724 self.calls = []
4725
4726 def on_load(self, state):
4727 self.calls.append("on_load")
4728 self.loaded = dict(state)
4729
4730 def on_save(self):
4731 self.calls.append("on_save")
4732 return self.state
4733"#
4734 ),
4735 None,
4736 None,
4737 )
4738 .unwrap();
4739
4740 let component_class = py.eval(c_str!("StateComponent"), None, None).unwrap();
4741 let actor_save =
4742 IndexMap::from([("actor-save".to_string(), b"python-actor-saved".to_vec())]);
4743 let strategy_save = IndexMap::from([(
4744 "strategy-save".to_string(),
4745 b"python-strategy-saved".to_vec(),
4746 )]);
4747 let py_actor_state = PyDict::new(py);
4748 py_actor_state
4749 .set_item("actor-save", b"python-actor-saved")
4750 .unwrap();
4751 let py_strategy_state = PyDict::new(py);
4752 py_strategy_state
4753 .set_item("strategy-save", b"python-strategy-saved")
4754 .unwrap();
4755 let py_actor = component_class.call1((py_actor_state,)).unwrap().unbind();
4756 let py_strategy = component_class
4757 .call1((py_strategy_state,))
4758 .unwrap()
4759 .unbind();
4760
4761 let actor_id = ActorId::from("PYTHON-STATE-ACTOR");
4762 let strategy_id = StrategyId::from("PYTHON-STATE-STRATEGY-001");
4763 let actor_load =
4764 IndexMap::from([("actor-load".to_string(), b"python-actor-loaded".to_vec())]);
4765 let strategy_load = IndexMap::from([(
4766 "strategy-load".to_string(),
4767 b"python-strategy-loaded".to_vec(),
4768 )]);
4769 let (database, control) = TestCacheDatabaseControl::create();
4770 control.set_actor_state(actor_id, &actor_load);
4771 control.set_strategy_state(strategy_id, &strategy_load);
4772
4773 let (
4774 _msgbus,
4775 cache,
4776 portfolio,
4777 _data_engine,
4778 _risk_engine,
4779 _exec_engine,
4780 clock_factory,
4781 ) = create_trader_components();
4782 cache.borrow_mut().set_database(Box::new(database));
4783 let trader_id = TraderId::test_default();
4784 let mut trader = Trader::new(
4785 trader_id,
4786 UUID4::new(),
4787 Environment::Backtest,
4788 clock_factory,
4789 cache.clone(),
4790 portfolio.clone(),
4791 );
4792
4793 let mut actor = PyDataActor::new(Some(DataActorConfig {
4794 actor_id: Some(actor_id),
4795 ..Default::default()
4796 }));
4797 actor.set_python_instance(py_actor.bind(py)).unwrap();
4798 let actor_clock = trader.create_component_clock(ComponentId::from(actor_id));
4799 actor
4800 .register(trader_id, actor_clock, cache.clone())
4801 .unwrap();
4802 actor.register_in_global_registries().unwrap();
4803 trader
4804 .add_actor_id_for_lifecycle::<PyDataActorInner>(actor_id)
4805 .unwrap();
4806
4807 let mut strategy = PyStrategy::new(Some(StrategyConfig {
4808 strategy_id: Some(strategy_id),
4809 ..Default::default()
4810 }));
4811 strategy.set_python_instance(py_strategy.bind(py)).unwrap();
4812 let strategy_clock = trader.create_component_clock(ComponentId::from(strategy_id));
4813 strategy
4814 .register(trader_id, strategy_clock, cache, portfolio)
4815 .unwrap();
4816 strategy.register_in_global_registries().unwrap();
4817 trader
4818 .add_strategy_id_with_subscriptions::<PyStrategyInner>(strategy_id)
4819 .unwrap();
4820
4821 let trader = Rc::new(RefCell::new(trader));
4822 Trader::load_state(&trader).unwrap();
4823 Trader::save_state(&trader).unwrap();
4824
4825 let actor_loaded = py_actor
4826 .getattr(py, "loaded")
4827 .unwrap()
4828 .extract::<std::collections::HashMap<String, Vec<u8>>>(py)
4829 .unwrap();
4830 let strategy_loaded = py_strategy
4831 .getattr(py, "loaded")
4832 .unwrap()
4833 .extract::<std::collections::HashMap<String, Vec<u8>>>(py)
4834 .unwrap();
4835 let actor_calls = py_actor
4836 .getattr(py, "calls")
4837 .unwrap()
4838 .extract::<Vec<String>>(py)
4839 .unwrap();
4840 let strategy_calls = py_strategy
4841 .getattr(py, "calls")
4842 .unwrap()
4843 .extract::<Vec<String>>(py)
4844 .unwrap();
4845
4846 assert_eq!(
4847 actor_loaded,
4848 std::collections::HashMap::from([(
4849 "actor-load".to_string(),
4850 b"python-actor-loaded".to_vec(),
4851 )])
4852 );
4853 assert_eq!(
4854 strategy_loaded,
4855 std::collections::HashMap::from([(
4856 "strategy-load".to_string(),
4857 b"python-strategy-loaded".to_vec(),
4858 )])
4859 );
4860 assert_eq!(actor_calls, vec!["on_load", "on_save"]);
4861 assert_eq!(strategy_calls, vec!["on_load", "on_save"]);
4862 assert_eq!(control.actor_state(&actor_id), Some(actor_save));
4863 assert_eq!(control.strategy_state(&strategy_id), Some(strategy_save));
4864 });
4865 }
4866
4867 #[rstest]
4868 fn test_clear_actors_disposes_and_clears_state() {
4869 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4870 create_trader_components();
4871 let trader_id = TraderId::test_default();
4872 let instance_id = UUID4::new();
4873
4874 let mut trader = Trader::new(
4875 trader_id,
4876 instance_id,
4877 Environment::Backtest,
4878 clock_factory,
4879 cache,
4880 portfolio,
4881 );
4882
4883 let actor_a = TestDataActor::new(DataActorConfig {
4884 actor_id: Some(ActorId::from("Actor-A")),
4885 ..Default::default()
4886 });
4887 let actor_b = TestDataActor::new(DataActorConfig {
4888 actor_id: Some(ActorId::from("Actor-B")),
4889 ..Default::default()
4890 });
4891 trader.add_actor(actor_a).unwrap();
4892 trader.add_actor(actor_b).unwrap();
4893 assert_eq!(trader.actor_count(), 2);
4894 assert_eq!(
4895 trader.get_component_clocks().len(),
4896 2,
4897 "each registered actor must have a component clock",
4898 );
4899
4900 trader.clear_actors().unwrap();
4901
4902 assert_eq!(trader.actor_count(), 0);
4903 assert!(trader.actor_ids().is_empty());
4904 assert_eq!(
4905 trader.get_component_clocks().len(),
4906 0,
4907 "actor clocks must be dropped after clear_actors",
4908 );
4909 }
4910
4911 #[rstest]
4912 #[case::removed(false, true)]
4913 #[case::reused(true, true)]
4914 #[case::invalid_registration(false, false)]
4915 fn test_queued_actor_time_event_is_revoked_on_retirement(
4916 #[case] reuse_id: bool,
4917 #[case] retire: bool,
4918 ) {
4919 let _guard = init_logging(
4920 TraderId::test_default(),
4921 UUID4::new(),
4922 LoggerConfig::default(),
4923 FileWriterConfig::default(),
4924 )
4925 .unwrap();
4926 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
4927 create_trader_components();
4928
4929 let mut trader = Trader::new(
4930 TraderId::test_default(),
4931 UUID4::new(),
4932 Environment::Backtest,
4933 clock_factory,
4934 cache,
4935 portfolio,
4936 );
4937 let retired_id = ActorId::from("Queued-Retirement");
4938 let active_id = ActorId::from("Queued-Active");
4939 for actor_id in [retired_id, active_id] {
4940 trader
4941 .add_actor(TestDataActor::new(DataActorConfig {
4942 actor_id: Some(actor_id),
4943 ..Default::default()
4944 }))
4945 .unwrap();
4946
4947 trader.start_actor(&actor_id).unwrap();
4948 }
4949
4950 let mut handlers = Vec::new();
4951 let interval = DurationNanos::new(1_000_000_000);
4952
4953 for clock in trader.get_component_clocks() {
4954 clock
4955 .borrow_mut()
4956 .set_timer_ns("stats", interval, None, None, None, None, None)
4957 .unwrap();
4958 let deadline = clock.borrow().timestamp_ns() + interval;
4959 handlers.extend(queue_component_time_events(&clock, deadline));
4960 }
4961
4962 assert_eq!(handlers.len(), 2);
4963
4964 if retire {
4965 trader.remove_actor(&retired_id).unwrap();
4966 } else {
4967 deregister_actor(&retired_id.inner());
4968 }
4969
4970 if reuse_id {
4971 trader
4972 .add_actor(TestDataActor::new(DataActorConfig {
4973 actor_id: Some(retired_id),
4974 ..Default::default()
4975 }))
4976 .unwrap();
4977
4978 trader.start_actor(&retired_id).unwrap();
4979 }
4980
4981 arm_shutdown_on_error(true);
4982
4983 for handler in handlers {
4984 handler.run();
4985 }
4986
4987 let trigger = take_shutdown_on_error_trigger();
4988 disarm_shutdown_on_error();
4989
4990 if retire {
4991 assert!(
4992 trigger.is_none(),
4993 "retired callback logged an error: {trigger:?}"
4994 );
4995 } else {
4996 assert_eq!(
4997 trigger.unwrap().message,
4998 format!("Actor {retired_id} not found for time event handling")
4999 );
5000 }
5001
5002 assert_eq!(
5003 get_actor_unchecked::<TestDataActor>(&active_id.inner()).time_events,
5004 1
5005 );
5006
5007 if reuse_id {
5008 assert_eq!(
5009 get_actor_unchecked::<TestDataActor>(&retired_id.inner()).time_events,
5010 0
5011 );
5012 } else {
5013 assert!(!actor_exists(&retired_id.inner()));
5014 }
5015 }
5016
5017 #[rstest]
5018 fn test_failed_dispose_preserves_queued_callbacks_until_retry(
5019 #[values(false, true)] named: bool,
5020 ) {
5021 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5022 create_trader_components();
5023
5024 let mut trader = Trader::new(
5025 TraderId::test_default(),
5026 UUID4::new(),
5027 Environment::Backtest,
5028 clock_factory,
5029 cache,
5030 portfolio,
5031 );
5032 let actor_id = ActorId::from("Queued-Failed-Dispose");
5033
5034 let mut actor = TestDataActor::new(DataActorConfig {
5035 actor_id: Some(actor_id),
5036 ..Default::default()
5037 });
5038
5039 actor.fail_dispose = true;
5040 trader.add_actor(actor).unwrap();
5041 let clock = trader.get_component_clocks().pop().unwrap();
5042 let calls = Arc::new(AtomicUsize::new(0));
5043 let callback_calls = calls.clone();
5044 let callback = TimeEventCallback::from(move |_| {
5045 callback_calls.fetch_add(1, Ordering::Relaxed);
5046 });
5047
5048 if !named {
5049 clock
5050 .borrow_mut()
5051 .register_default_handler(callback.clone());
5052 }
5053
5054 let interval = DurationNanos::new(1_000_000_000);
5055 clock
5056 .borrow_mut()
5057 .set_timer_ns(
5058 "queued",
5059 interval,
5060 None,
5061 None,
5062 named.then_some(callback),
5063 None,
5064 None,
5065 )
5066 .unwrap();
5067
5068 let first_tick = clock.borrow().timestamp_ns() + interval;
5069 let handlers = queue_component_time_events(&clock, first_tick);
5070 assert_eq!(handlers.len(), 1);
5071
5072 let error = trader.remove_actor(&actor_id).unwrap_err();
5073 assert_eq!(error.to_string(), "test actor dispose failure");
5074
5075 for handler in handlers {
5076 handler.run();
5077 }
5078
5079 assert_eq!(calls.load(Ordering::Relaxed), 1);
5080 assert!(actor_exists(&actor_id.inner()));
5081 assert!(get_component(&actor_id.inner()).is_some());
5082 assert_eq!(trader.actor_ids(), vec![actor_id]);
5083 assert_eq!(clock.borrow().timer_count(), 1);
5084
5085 let handlers = queue_component_time_events(&clock, first_tick + interval);
5086 assert_eq!(handlers.len(), 1);
5087 trader.remove_actor(&actor_id).unwrap();
5088
5089 for handler in handlers {
5090 handler.run();
5091 }
5092
5093 assert_eq!(calls.load(Ordering::Relaxed), 1);
5094 assert!(!actor_exists(&actor_id.inner()));
5095 assert!(get_component(&actor_id.inner()).is_none());
5096 assert!(trader.get_component_clocks().is_empty());
5097 assert!(trader.actor_ids().is_empty());
5098 assert_eq!(clock.borrow().timer_count(), 0);
5099 }
5100
5101 #[rstest]
5102 fn test_remove_actor_deregisters_component() {
5103 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5104 create_trader_components();
5105 let mut trader = Trader::new(
5106 TraderId::test_default(),
5107 UUID4::new(),
5108 Environment::Backtest,
5109 clock_factory,
5110 cache,
5111 portfolio,
5112 );
5113
5114 let retired_id = ActorId::from("Retired-Actor");
5115 let retained_id = ActorId::from("Retained-Actor");
5116 trader
5117 .add_actor(TestDataActor::new(DataActorConfig {
5118 actor_id: Some(retired_id),
5119 ..Default::default()
5120 }))
5121 .unwrap();
5122 trader
5123 .add_actor(TestDataActor::new(DataActorConfig {
5124 actor_id: Some(retained_id),
5125 ..Default::default()
5126 }))
5127 .unwrap();
5128
5129 trader.remove_actor(&retired_id).unwrap();
5130
5131 assert!(get_component(&retired_id.inner()).is_none());
5132 assert!(!actor_exists(&retired_id.inner()));
5133 assert_eq!(trader.actor_ids(), vec![retained_id]);
5134 assert_eq!(trader.get_component_clocks().len(), 1);
5135
5136 assert!(get_component(&retained_id.inner()).is_some());
5138 assert!(actor_exists(&retained_id.inner()));
5139 }
5140
5141 #[rstest]
5142 fn test_remove_strategy_deregisters_component() {
5143 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5144 create_trader_components();
5145 let mut trader = Trader::new(
5146 TraderId::test_default(),
5147 UUID4::new(),
5148 Environment::Backtest,
5149 clock_factory,
5150 cache,
5151 portfolio,
5152 );
5153
5154 trader
5155 .add_strategy(TestStrategy::new(StrategyConfig {
5156 strategy_id: Some(StrategyId::from("Retired-001")),
5157 ..Default::default()
5158 }))
5159 .unwrap();
5160 trader
5161 .add_strategy(TestStrategy::new(StrategyConfig {
5162 strategy_id: Some(StrategyId::from("Retained-002")),
5163 ..Default::default()
5164 }))
5165 .unwrap();
5166
5167 let retired_id = StrategyId::from("Retired-001");
5168 let retained_id = StrategyId::from("Retained-002");
5169
5170 let control_endpoint_registered = |strategy_id| {
5172 get_message_bus()
5173 .borrow_mut()
5174 .endpoint_map::<StrategyCommand>()
5175 .get(strategy_control_endpoint(strategy_id))
5176 .is_some()
5177 };
5178 assert!(control_endpoint_registered(retired_id));
5179 assert!(control_endpoint_registered(retained_id));
5180
5181 trader.remove_strategy(&retired_id).unwrap();
5182
5183 assert!(get_component(&retired_id.inner()).is_none());
5184 assert!(!actor_exists(&retired_id.inner()));
5185 assert!(!trader.strategy_handler_ids.contains_key(&retired_id));
5186 assert!(
5187 !control_endpoint_registered(retired_id),
5188 "the retired strategy control endpoint must be deregistered",
5189 );
5190 assert_eq!(trader.strategy_ids(), vec![retained_id]);
5191
5192 assert!(get_component(&retained_id.inner()).is_some());
5193 assert!(actor_exists(&retained_id.inner()));
5194 assert!(trader.strategy_handler_ids.contains_key(&retained_id));
5195 assert!(
5196 control_endpoint_registered(retained_id),
5197 "deregistration must not remove an unrelated strategy's control endpoint",
5198 );
5199 }
5200
5201 #[rstest]
5202 #[case("clear_actors")]
5203 #[case("remove_actor")]
5204 #[case("remove_strategy")]
5205 fn test_retirement_reports_stop_hook_errors(
5206 #[case] method: &str,
5207 #[values(
5208 ComponentState::Ready,
5209 ComponentState::Starting,
5210 ComponentState::Running,
5211 ComponentState::Resuming,
5212 ComponentState::Degraded,
5213 ComponentState::Stopping,
5214 ComponentState::Stopped,
5215 ComponentState::Faulted,
5216 ComponentState::Disposed
5217 )]
5218 state: ComponentState,
5219 ) {
5220 let _guard = init_logging(
5221 TraderId::test_default(),
5222 UUID4::new(),
5223 LoggerConfig::default(),
5224 FileWriterConfig::default(),
5225 )
5226 .unwrap();
5227 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5228 create_trader_components();
5229
5230 let mut trader = Trader::new(
5231 TraderId::test_default(),
5232 UUID4::new(),
5233 Environment::Backtest,
5234 clock_factory,
5235 cache,
5236 portfolio,
5237 );
5238 let actor_id = ActorId::from("Failing-Stop-Actor");
5239 let strategy_id = StrategyId::from("Failing-Stop-Strategy");
5240
5241 let transitions: &[ComponentTrigger] = match state {
5242 ComponentState::Ready => &[],
5243 ComponentState::Starting => &[ComponentTrigger::Start],
5244 ComponentState::Running => &[ComponentTrigger::Start, ComponentTrigger::StartCompleted],
5245 ComponentState::Resuming => &[
5246 ComponentTrigger::Start,
5247 ComponentTrigger::StartCompleted,
5248 ComponentTrigger::Stop,
5249 ComponentTrigger::StopCompleted,
5250 ComponentTrigger::Resume,
5251 ],
5252 ComponentState::Degraded => &[
5253 ComponentTrigger::Start,
5254 ComponentTrigger::StartCompleted,
5255 ComponentTrigger::Degrade,
5256 ComponentTrigger::DegradeCompleted,
5257 ],
5258 ComponentState::Stopping => &[
5259 ComponentTrigger::Start,
5260 ComponentTrigger::StartCompleted,
5261 ComponentTrigger::Stop,
5262 ],
5263 ComponentState::Stopped => &[
5264 ComponentTrigger::Start,
5265 ComponentTrigger::StartCompleted,
5266 ComponentTrigger::Stop,
5267 ComponentTrigger::StopCompleted,
5268 ],
5269 ComponentState::Faulted => &[
5270 ComponentTrigger::Start,
5271 ComponentTrigger::StartCompleted,
5272 ComponentTrigger::Fault,
5273 ComponentTrigger::FaultCompleted,
5274 ],
5275 ComponentState::Disposed => &[
5276 ComponentTrigger::Dispose,
5277 ComponentTrigger::DisposeCompleted,
5278 ],
5279 _ => unreachable!(),
5280 };
5281
5282 let prepare = |component: &mut dyn Component| {
5283 for trigger in transitions {
5284 component.transition_state(*trigger).unwrap();
5285 }
5286 };
5287
5288 let (id, error) = if method == "remove_strategy" {
5289 let mut strategy = TestStrategy::new(StrategyConfig {
5290 strategy_id: Some(strategy_id),
5291 ..Default::default()
5292 });
5293
5294 strategy.fail_stop = true;
5295 trader.add_strategy(strategy).unwrap();
5296 prepare(&mut *get_actor_unchecked::<TestStrategy>(
5297 &strategy_id.inner(),
5298 ));
5299 (strategy_id.inner(), "test strategy stop failure")
5300 } else {
5301 let mut actor = TestDataActor::new(DataActorConfig {
5302 actor_id: Some(actor_id),
5303 ..Default::default()
5304 });
5305
5306 actor.fail_stop = true;
5307 trader.add_actor(actor).unwrap();
5308 prepare(&mut *get_actor_unchecked::<TestDataActor>(
5309 &actor_id.inner(),
5310 ));
5311 (actor_id.inner(), "test actor stop failure")
5312 };
5313
5314 let other_id = ActorId::from("Other-Actor");
5315 trader
5316 .add_actor(TestDataActor::new(DataActorConfig {
5317 actor_id: Some(other_id),
5318 ..Default::default()
5319 }))
5320 .unwrap();
5321
5322 arm_shutdown_on_error(true);
5323
5324 let result = match method {
5325 "clear_actors" => trader.clear_actors(),
5326 "remove_actor" => trader.remove_actor(&actor_id),
5327 "remove_strategy" => trader.remove_strategy(&strategy_id),
5328 _ => unreachable!(),
5329 };
5330
5331 let trigger = take_shutdown_on_error_trigger();
5332 disarm_shutdown_on_error();
5333
5334 result.unwrap();
5335 assert!(get_component(&id).is_none());
5336 assert!(!actor_exists(&id));
5337 assert_eq!(trader.strategy_count(), 0);
5338 assert_eq!(trader.actor_count(), usize::from(method != "clear_actors"));
5339 assert_eq!(actor_exists(&other_id.inner()), method != "clear_actors");
5340
5341 if matches!(
5342 state,
5343 ComponentState::Starting
5344 | ComponentState::Running
5345 | ComponentState::Resuming
5346 | ComponentState::Degraded
5347 ) {
5348 let trigger = trigger.unwrap();
5349 assert_eq!(trigger.component, id);
5350 assert_eq!(trigger.message, error);
5351 } else {
5352 assert_eq!(trigger, None);
5353 }
5354 }
5355
5356 #[rstest]
5357 fn test_remove_actor_disposes_after_stop_hook_failure() {
5358 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5359 create_trader_components();
5360 let mut trader = Trader::new(
5361 TraderId::test_default(),
5362 UUID4::new(),
5363 Environment::Backtest,
5364 clock_factory,
5365 cache,
5366 portfolio,
5367 );
5368 let actor_id = ActorId::from("Failing-Stop-Actor");
5369 let mut actor = TestDataActor::new(DataActorConfig {
5370 actor_id: Some(actor_id),
5371 ..Default::default()
5372 });
5373 actor.fail_stop = true;
5374 trader.add_actor(actor).unwrap();
5375 trader.start_actor(&actor_id).unwrap();
5376
5377 let error = stop_component(&actor_id.inner()).unwrap_err();
5378 assert_eq!(error.to_string(), "test actor stop failure");
5379 assert_eq!(
5380 component_state(&actor_id.inner()).unwrap(),
5381 ComponentState::Stopping,
5382 );
5383
5384 trader.remove_actor(&actor_id).unwrap();
5385
5386 assert!(get_component(&actor_id.inner()).is_none());
5387 assert!(!actor_exists(&actor_id.inner()));
5388 assert!(!trader.actor_ids().contains(&actor_id));
5389 }
5390
5391 #[rstest]
5392 fn test_remove_strategy_disposes_after_stop_hook_failure() {
5393 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5394 create_trader_components();
5395 let mut trader = Trader::new(
5396 TraderId::test_default(),
5397 UUID4::new(),
5398 Environment::Backtest,
5399 clock_factory,
5400 cache,
5401 portfolio,
5402 );
5403 let strategy_id = StrategyId::from("Failing-Stop-Strategy");
5404 let mut strategy = TestStrategy::new(StrategyConfig {
5405 strategy_id: Some(strategy_id),
5406 ..Default::default()
5407 });
5408 strategy.fail_stop = true;
5409 trader.add_strategy(strategy).unwrap();
5410 trader.start_strategy(&strategy_id).unwrap();
5411
5412 let error = stop_component(&strategy_id.inner()).unwrap_err();
5413 assert_eq!(error.to_string(), "test strategy stop failure");
5414 assert_eq!(
5415 component_state(&strategy_id.inner()).unwrap(),
5416 ComponentState::Stopping,
5417 );
5418
5419 trader.remove_strategy(&strategy_id).unwrap();
5420
5421 assert!(get_component(&strategy_id.inner()).is_none());
5422 assert!(!actor_exists(&strategy_id.inner()));
5423 assert!(!trader.strategy_ids().contains(&strategy_id));
5424 }
5425
5426 #[rstest]
5427 fn test_clear_exec_algorithms_deregisters_components() {
5428 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5429 create_trader_components();
5430 let mut trader = Trader::new(
5431 TraderId::test_default(),
5432 UUID4::new(),
5433 Environment::Backtest,
5434 clock_factory,
5435 cache,
5436 portfolio,
5437 );
5438
5439 let first_id = ExecAlgorithmId::from("EXEC-ALGO-1");
5440 let second_id = ExecAlgorithmId::from("EXEC-ALGO-2");
5441 for exec_algorithm_id in [first_id, second_id] {
5442 trader
5443 .add_exec_algorithm(TestExecutionAlgorithm::new(ExecutionAlgorithmConfig {
5444 exec_algorithm_id: Some(exec_algorithm_id),
5445 ..Default::default()
5446 }))
5447 .unwrap();
5448 }
5449
5450 for exec_algorithm_id in [first_id, second_id] {
5451 assert!(
5452 msgbus::has_endpoint(&format!("{exec_algorithm_id}.execute")),
5453 "the execute endpoint must be registered before clearing",
5454 );
5455 }
5456
5457 trader.clear_exec_algorithms().unwrap();
5458
5459 for exec_algorithm_id in [first_id, second_id] {
5460 assert!(get_component(&exec_algorithm_id.inner()).is_none());
5461 assert!(!actor_exists(&exec_algorithm_id.inner()));
5462 assert!(!msgbus::has_endpoint(&format!(
5463 "{exec_algorithm_id}.execute"
5464 )));
5465 }
5466 assert!(trader.exec_algorithm_ids().is_empty());
5467 assert!(trader.get_component_clocks().is_empty());
5468 }
5469
5470 #[rstest]
5471 fn test_failed_dispose_preserves_registration() {
5472 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5473 create_trader_components();
5474 let mut trader = Trader::new(
5475 TraderId::test_default(),
5476 UUID4::new(),
5477 Environment::Backtest,
5478 clock_factory,
5479 cache,
5480 portfolio,
5481 );
5482
5483 let actor_id = ActorId::from("Failing-Dispose-Actor");
5484 let mut actor = TestDataActor::new(DataActorConfig {
5485 actor_id: Some(actor_id),
5486 ..Default::default()
5487 });
5488 actor.fail_dispose = true;
5489 trader.add_actor(actor).unwrap();
5490
5491 let error = trader.remove_actor(&actor_id).unwrap_err();
5492
5493 assert_eq!(error.to_string(), "test actor dispose failure");
5494 assert_eq!(trader.actor_ids(), vec![actor_id]);
5495 assert_eq!(trader.get_component_clocks().len(), 1);
5496 assert!(get_component(&actor_id.inner()).is_some());
5497 assert!(actor_exists(&actor_id.inner()));
5498 assert_eq!(
5499 component_state(&actor_id.inner()).unwrap(),
5500 ComponentState::Faulted,
5501 "a failed disposal faults the component rather than reaching Disposed",
5502 );
5503 }
5504
5505 #[rstest]
5506 fn test_failed_dispose_component_can_be_retired() {
5507 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5508 create_trader_components();
5509 let mut trader = Trader::new(
5510 TraderId::test_default(),
5511 UUID4::new(),
5512 Environment::Backtest,
5513 clock_factory,
5514 cache,
5515 portfolio,
5516 );
5517
5518 let actor_id = ActorId::from("Retired-After-Failed-Dispose-Actor");
5519 let mut actor = TestDataActor::new(DataActorConfig {
5520 actor_id: Some(actor_id),
5521 ..Default::default()
5522 });
5523 actor.fail_dispose = true;
5524 trader.add_actor(actor).unwrap();
5525 trader.start_actor(&actor_id).unwrap();
5526
5527 let instrument_id = InstrumentId::from("AUD/USD.SIM");
5528 let deltas_topic = get_book_deltas_topic(instrument_id);
5529 get_actor_unchecked::<TestDataActor>(&actor_id.inner()).subscribe_book_deltas(
5530 instrument_id,
5531 BookType::L3_MBO,
5532 None,
5533 None,
5534 false,
5535 None,
5536 );
5537
5538 trader.remove_actor(&actor_id).unwrap_err();
5539 assert_eq!(
5540 component_state(&actor_id.inner()).unwrap(),
5541 ComponentState::Faulted
5542 );
5543 assert_eq!(msgbus::subscriber_count_deltas(deltas_topic), 1);
5544
5545 trader.remove_actor(&actor_id).unwrap();
5547
5548 assert!(get_component(&actor_id.inner()).is_none());
5549 assert!(!actor_exists(&actor_id.inner()));
5550 assert!(trader.actor_ids().is_empty());
5551 assert!(trader.get_component_clocks().is_empty());
5552 assert_eq!(msgbus::subscriber_count_deltas(deltas_topic), 0);
5553 }
5554
5555 #[rstest]
5556 fn test_failed_dispose_preserves_subscriptions() {
5557 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5558 create_trader_components();
5559 let mut trader = Trader::new(
5560 TraderId::test_default(),
5561 UUID4::new(),
5562 Environment::Backtest,
5563 clock_factory,
5564 cache,
5565 portfolio,
5566 );
5567
5568 let actor_id = ActorId::from("Subscribed-Failing-Dispose-Actor");
5569 let mut actor = TestDataActor::new(DataActorConfig {
5570 actor_id: Some(actor_id),
5571 ..Default::default()
5572 });
5573 actor.fail_dispose = true;
5574 trader.add_actor(actor).unwrap();
5575 trader.start_actor(&actor_id).unwrap();
5576
5577 let instrument_id = InstrumentId::from("AUD/USD.SIM");
5578 let deltas_topic = get_book_deltas_topic(instrument_id);
5579 get_actor_unchecked::<TestDataActor>(&actor_id.inner()).subscribe_book_deltas(
5580 instrument_id,
5581 BookType::L3_MBO,
5582 None,
5583 None,
5584 false,
5585 None,
5586 );
5587
5588 assert_eq!(msgbus::subscriber_count_deltas(deltas_topic), 1);
5590
5591 trader.remove_actor(&actor_id).unwrap_err();
5592
5593 assert_eq!(msgbus::subscriber_count_deltas(deltas_topic), 1);
5594 }
5595
5596 #[rstest]
5597 fn test_runtime_faulted_component_retires_without_leaking_subscriptions() {
5598 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5599 create_trader_components();
5600 let mut trader = Trader::new(
5601 TraderId::test_default(),
5602 UUID4::new(),
5603 Environment::Backtest,
5604 clock_factory,
5605 cache,
5606 portfolio,
5607 );
5608
5609 let actor_id = ActorId::from("Runtime-Faulted-Actor");
5610 trader
5611 .add_actor(TestDataActor::new(DataActorConfig {
5612 actor_id: Some(actor_id),
5613 ..Default::default()
5614 }))
5615 .unwrap();
5616 trader.start_actor(&actor_id).unwrap();
5617
5618 let instrument_id = InstrumentId::from("AUD/USD.SIM");
5619 let deltas_topic = get_book_deltas_topic(instrument_id);
5620 get_actor_unchecked::<TestDataActor>(&actor_id.inner()).subscribe_book_deltas(
5621 instrument_id,
5622 BookType::L3_MBO,
5623 None,
5624 None,
5625 false,
5626 None,
5627 );
5628
5629 assert_eq!(msgbus::subscriber_count_deltas(deltas_topic), 1);
5631
5632 get_actor_unchecked::<TestDataActor>(&actor_id.inner())
5635 .fault()
5636 .unwrap();
5637 assert_eq!(
5638 component_state(&actor_id.inner()).unwrap(),
5639 ComponentState::Faulted
5640 );
5641
5642 trader.remove_actor(&actor_id).unwrap();
5643
5644 assert_eq!(msgbus::subscriber_count_deltas(deltas_topic), 0);
5645 assert!(get_component(&actor_id.inner()).is_none());
5646 assert!(!actor_exists(&actor_id.inner()));
5647 }
5648
5649 #[rstest]
5650 fn test_actor_retires_after_fault_hook_failure() {
5651 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5652 create_trader_components();
5653 let mut trader = Trader::new(
5654 TraderId::test_default(),
5655 UUID4::new(),
5656 Environment::Backtest,
5657 clock_factory,
5658 cache,
5659 portfolio,
5660 );
5661 let actor_id = ActorId::from("Failing-Fault-Actor");
5662 let mut actor = TestDataActor::new(DataActorConfig {
5663 actor_id: Some(actor_id),
5664 ..Default::default()
5665 });
5666 actor.fail_fault = true;
5667 trader.add_actor(actor).unwrap();
5668 trader.start_actor(&actor_id).unwrap();
5669
5670 let instrument_id = InstrumentId::from("AUD/USD.SIM");
5671 let deltas_topic = get_book_deltas_topic(instrument_id);
5672 get_actor_unchecked::<TestDataActor>(&actor_id.inner()).subscribe_book_deltas(
5673 instrument_id,
5674 BookType::L3_MBO,
5675 None,
5676 None,
5677 false,
5678 None,
5679 );
5680 assert_eq!(msgbus::subscriber_count_deltas(deltas_topic), 1);
5681
5682 let error = get_actor_unchecked::<TestDataActor>(&actor_id.inner())
5683 .fault()
5684 .unwrap_err();
5685 assert_eq!(error.to_string(), "test actor fault failure");
5686 assert_eq!(
5687 component_state(&actor_id.inner()).unwrap(),
5688 ComponentState::Faulting,
5689 );
5690 assert_eq!(msgbus::subscriber_count_deltas(deltas_topic), 0);
5691
5692 trader.remove_actor(&actor_id).unwrap();
5693
5694 assert!(get_component(&actor_id.inner()).is_none());
5695 assert!(!actor_exists(&actor_id.inner()));
5696 assert!(trader.actor_ids().is_empty());
5697 assert!(trader.get_component_clocks().is_empty());
5698 }
5699
5700 #[rstest]
5701 fn test_already_disposed_component_can_be_removed() {
5702 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5703 create_trader_components();
5704 let mut trader = Trader::new(
5705 TraderId::test_default(),
5706 UUID4::new(),
5707 Environment::Backtest,
5708 clock_factory,
5709 cache,
5710 portfolio,
5711 );
5712
5713 let actor_id = ActorId::from("Directly-Disposed-Actor");
5714 trader
5715 .add_actor(TestDataActor::new(DataActorConfig {
5716 actor_id: Some(actor_id),
5717 ..Default::default()
5718 }))
5719 .unwrap();
5720
5721 dispose_component(&actor_id.inner()).unwrap();
5723 assert_eq!(
5724 component_state(&actor_id.inner()).unwrap(),
5725 ComponentState::Disposed
5726 );
5727
5728 trader.remove_actor(&actor_id).unwrap();
5729
5730 assert!(get_component(&actor_id.inner()).is_none());
5731 assert!(!actor_exists(&actor_id.inner()));
5732 assert!(trader.actor_ids().is_empty());
5733 assert!(trader.get_component_clocks().is_empty());
5734 }
5735
5736 #[cfg(feature = "python")]
5737 fn install_owned_actor_module(py: Python<'_>, module_name: &str) {
5738 let module = PyModule::new(py, module_name).expect("test module should create");
5739 module
5740 .setattr("DataActor", py.get_type::<PyDataActor>())
5741 .expect("DataActor type should bind");
5742 module
5743 .setattr("INSTANCES", PyDict::new(py))
5744 .expect("INSTANCES should bind");
5745
5746 let code = std::ffi::CString::new(
5747 r#"
5748import weakref
5749
5750
5751class OwnedActor(DataActor):
5752 def __init__(self):
5753 super().__init__()
5754 INSTANCES["actor"] = weakref.ref(self)
5755"#,
5756 )
5757 .expect("python test code should be valid CString");
5758
5759 py.run(code.as_c_str(), Some(&module.dict()), None)
5760 .expect("test actor code should execute");
5761
5762 py.import("sys")
5763 .expect("sys should import")
5764 .getattr("modules")
5765 .expect("sys.modules should exist")
5766 .set_item(module_name, module)
5767 .expect("test actor module should register");
5768 }
5769
5770 #[cfg(feature = "python")]
5771 fn owned_actor_is_alive(py: Python<'_>, module_name: &str) -> bool {
5772 !py.import(module_name)
5773 .expect("test actor module should import")
5774 .getattr("INSTANCES")
5775 .expect("INSTANCES should exist")
5776 .get_item("actor")
5777 .expect("the actor weak reference should be recorded")
5778 .call0()
5779 .expect("a weak reference should be callable")
5780 .is_none()
5781 }
5782
5783 #[cfg(feature = "python")]
5784 #[rstest]
5785 fn test_trader_owns_python_actor_wrapper_until_removal() {
5786 Python::initialize();
5787
5788 let module_name = "test_trader_owned_actor";
5789 Python::attach(|py| install_owned_actor_module(py, module_name));
5790
5791 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5792 create_trader_components();
5793 let mut trader = Trader::new(
5794 TraderId::test_default(),
5795 UUID4::new(),
5796 Environment::Backtest,
5797 clock_factory,
5798 cache,
5799 portfolio,
5800 );
5801
5802 let actor_id = trader
5803 .add_actor_from_importable_config(&ImportableActorConfig {
5804 actor_path: format!("{module_name}:OwnedActor"),
5805 config_path: String::new(),
5806 config: std::collections::HashMap::new(),
5807 })
5808 .unwrap();
5809
5810 assert_eq!(actor_id, ActorId::from("OwnedActor"));
5811 assert!(
5812 Python::attach(|py| owned_actor_is_alive(py, module_name)),
5813 "the trader must own the registered wrapper after the caller drops its reference",
5814 );
5815
5816 trader.remove_actor(&actor_id).unwrap();
5817
5818 assert!(
5819 !Python::attach(|py| owned_actor_is_alive(py, module_name)),
5820 "removal must release the trader's strong owner and let the wrapper be collected",
5821 );
5822 assert!(get_component(&actor_id.inner()).is_none());
5823 assert!(!actor_exists(&actor_id.inner()));
5824 }
5825
5826 #[cfg(feature = "python")]
5827 fn install_python_component_module(py: Python<'_>, module_name: &str) {
5828 let module = PyModule::new(py, module_name).expect("test module should create");
5829 module
5830 .setattr("DataActor", py.get_type::<PyDataActor>())
5831 .expect("DataActor type should bind");
5832 module
5833 .setattr("Strategy", py.get_type::<PyStrategy>())
5834 .expect("Strategy type should bind");
5835
5836 let code = c_str!(
5837 r#"
5838class ModuleActor(DataActor):
5839 pass
5840
5841
5842class ModuleStrategy(Strategy):
5843 pass
5844"#
5845 );
5846
5847 py.run(code, Some(&module.dict()), None)
5848 .expect("test component code should execute");
5849
5850 py.import("sys")
5851 .expect("sys should import")
5852 .getattr("modules")
5853 .expect("sys.modules should exist")
5854 .set_item(module_name, module)
5855 .expect("test component module should register");
5856 }
5857
5858 #[cfg(feature = "python")]
5859 fn create_python_component(py: Python<'_>, module_name: &str, class_name: &str) -> Py<PyAny> {
5860 py.import(module_name)
5861 .expect("test component module should import")
5862 .getattr(class_name)
5863 .expect("test component class should exist")
5864 .call0()
5865 .expect("test component should construct")
5866 .unbind()
5867 }
5868
5869 #[cfg(feature = "python")]
5870 #[rstest]
5871 fn test_automatic_python_strategy_tag_skips_existing_tags(
5872 #[values(false, true)] remove_first: bool,
5873 ) {
5874 Python::initialize();
5875 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5876 create_trader_components();
5877
5878 let mut trader = Trader::new(
5879 TraderId::test_default(),
5880 UUID4::new(),
5881 Environment::Backtest,
5882 clock_factory,
5883 cache,
5884 portfolio,
5885 );
5886
5887 Python::attach(|py| {
5888 let module_name = "test_automatic_python_strategy_tag";
5889 install_python_component_module(py, module_name);
5890 if remove_first {
5891 let strategy = create_python_component(py, module_name, "ModuleStrategy");
5892 trader.add_python_strategy_instance(&strategy).unwrap();
5893 }
5894
5895 let strategy = create_python_component(py, module_name, "ModuleStrategy");
5896 strategy
5897 .bind(py)
5898 .extract::<PyRefMut<PyStrategy>>()
5899 .unwrap()
5900 .set_strategy_id(StrategyId::from("ModuleStrategy-001"))
5901 .unwrap();
5902 trader.add_python_strategy_instance(&strategy).unwrap();
5903 if remove_first {
5904 trader
5905 .remove_strategy(&StrategyId::from("ModuleStrategy-000"))
5906 .unwrap();
5907 }
5908
5909 let strategy = create_python_component(py, module_name, "ModuleStrategy");
5910 let strategy_id = trader.add_python_strategy_instance(&strategy).unwrap();
5911
5912 assert_eq!(strategy_id, StrategyId::from("ModuleStrategy-002"));
5913 assert_eq!(
5914 trader.strategy_ids(),
5915 vec![StrategyId::from("ModuleStrategy-001"), strategy_id]
5916 );
5917 });
5918 }
5919
5920 #[cfg(feature = "python")]
5921 #[rstest]
5922 fn test_colliding_python_registration_leaves_the_live_component_registered() {
5923 Python::initialize();
5924
5925 let module_name = "test_trader_colliding_components";
5926 let strategy_id = StrategyId::from("Colliding-001");
5927 let actor_id = ActorId::from("Colliding-001");
5928 let component_id = ComponentId::from(strategy_id);
5929
5930 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
5931 create_trader_components();
5932 let mut trader = Trader::new(
5933 TraderId::test_default(),
5934 UUID4::new(),
5935 Environment::Backtest,
5936 clock_factory,
5937 cache,
5938 portfolio,
5939 );
5940
5941 Python::attach(|py| {
5942 install_python_component_module(py, module_name);
5943
5944 let py_strategy = create_python_component(py, module_name, "ModuleStrategy");
5945 py_strategy
5946 .bind(py)
5947 .extract::<PyRefMut<PyStrategy>>()
5948 .unwrap()
5949 .set_strategy_id(strategy_id)
5950 .unwrap();
5951
5952 trader
5953 .commit_python_strategy_instance(&py_strategy)
5954 .unwrap();
5955
5956 assert!(get_component(&component_id.inner()).is_some());
5958 assert!(actor_exists(&component_id.inner()));
5959 assert!(
5960 get_python_wrapper(component_id)
5961 .unwrap()
5962 .bind(py)
5963 .is(py_strategy.bind(py))
5964 );
5965
5966 let py_actor = create_python_component(py, module_name, "ModuleActor");
5967 py_actor
5968 .bind(py)
5969 .extract::<PyRefMut<PyDataActor>>()
5970 .unwrap()
5971 .set_actor_id(actor_id);
5972
5973 let error = trader
5974 .add_python_actor_instance(&py_actor, actor_id)
5975 .expect_err("an actor colliding with a live strategy must not register");
5976 assert!(error.to_string().contains("already registered"));
5977
5978 assert!(try_get_actor_unchecked::<PyStrategyInner>(&component_id.inner()).is_some());
5980 assert!(get_component(&component_id.inner()).is_some());
5981 assert!(actor_exists(&component_id.inner()));
5982 assert!(
5983 get_python_wrapper(component_id)
5984 .expect("the strategy must still hold its wrapper")
5985 .bind(py)
5986 .is(py_strategy.bind(py))
5987 );
5988 assert_eq!(trader.strategy_ids(), vec![strategy_id]);
5989 assert!(trader.actor_ids().is_empty());
5990 assert_eq!(trader.get_component_clocks().len(), 1);
5991 });
5992 }
5993
5994 #[cfg(feature = "python")]
5995 #[rstest]
5996 fn test_failed_python_actor_registration_rolls_back_only_its_own_state() {
5997 Python::initialize();
5998
5999 let module_name = "test_trader_rollback_components";
6000 let registered_id = ActorId::from("Rollback-Registered");
6001 let attempted_id = ActorId::from("Rollback-Attempted");
6002 let registered_component_id = ComponentId::from(registered_id);
6003 let attempted_component_id = ComponentId::from(attempted_id);
6004
6005 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
6006 create_trader_components();
6007 let mut trader = Trader::new(
6008 TraderId::test_default(),
6009 UUID4::new(),
6010 Environment::Backtest,
6011 clock_factory,
6012 cache,
6013 portfolio,
6014 );
6015
6016 Python::attach(|py| {
6017 install_python_component_module(py, module_name);
6018
6019 let py_actor = create_python_component(py, module_name, "ModuleActor");
6020 py_actor
6021 .bind(py)
6022 .extract::<PyRefMut<PyDataActor>>()
6023 .unwrap()
6024 .set_actor_id(registered_id);
6025
6026 trader
6027 .add_python_actor_instance(&py_actor, registered_id)
6028 .unwrap();
6029
6030 let error = trader
6033 .add_python_actor_instance(&py_actor, attempted_id)
6034 .expect_err("registering an already registered actor must fail");
6035 assert!(error.to_string().contains("already registered"));
6036
6037 assert!(get_component(&attempted_component_id.inner()).is_none());
6038 assert!(!actor_exists(&attempted_component_id.inner()));
6039 assert!(get_python_wrapper(attempted_component_id).is_none());
6040 assert_eq!(trader.get_component_clocks().len(), 1);
6041
6042 assert!(get_component(®istered_component_id.inner()).is_some());
6043 assert!(actor_exists(®istered_component_id.inner()));
6044 assert!(
6045 get_python_wrapper(registered_component_id)
6046 .expect("the registered actor must still hold its wrapper")
6047 .bind(py)
6048 .is(py_actor.bind(py))
6049 );
6050 assert_eq!(trader.actor_ids(), vec![registered_id]);
6051 });
6052 }
6053
6054 #[cfg(feature = "python")]
6055 #[rstest]
6056 fn test_failed_exec_algorithm_registration_leaves_the_id_reusable() {
6057 use nautilus_trading::{ExecutionAlgorithmNative, python::algorithm::PyExecutionAlgorithm};
6058
6059 Python::initialize();
6060
6061 let exec_algorithm_id = ExecAlgorithmId::from("Rollback-Algo");
6062 let component_id = ComponentId::from(exec_algorithm_id);
6063
6064 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
6065 create_trader_components();
6066 let trader_id = TraderId::test_default();
6067 let mut trader = Trader::new(
6068 trader_id,
6069 UUID4::new(),
6070 Environment::Backtest,
6071 clock_factory,
6072 cache.clone(),
6073 portfolio,
6074 );
6075
6076 Python::attach(|py| {
6077 let config = py
6078 .eval(
6079 c_str!("type('_Cfg', (), {'exec_algorithm_id': 'Rollback-Algo'})()"),
6080 None,
6081 None,
6082 )
6083 .unwrap();
6084 let wrapper = py
6085 .get_type::<PyExecutionAlgorithm>()
6086 .as_any()
6087 .call1((config.clone(),))
6088 .unwrap();
6089 let mut algorithm = wrapper
6090 .extract::<PyRefMut<PyExecutionAlgorithm>>()
6091 .unwrap()
6092 .clone();
6093
6094 let clock: Rc<RefCell<dyn Clock>> = Rc::new(RefCell::new(VirtualClock::new()));
6097 algorithm
6098 .exec_algorithm_core_mut()
6099 .register(trader_id, clock, cache)
6100 .unwrap();
6101
6102 let error = trader
6103 .add_py_execution_algorithm_instance(algorithm, &wrapper.unbind())
6104 .expect_err("registering an already registered algorithm must fail");
6105 assert!(error.to_string().contains("already registered"));
6106
6107 assert!(trader.get_component_clocks().is_empty());
6109 assert!(trader.exec_algorithm_ids().is_empty());
6110 assert!(get_python_wrapper(component_id).is_none());
6111
6112 let fresh_wrapper = py
6113 .get_type::<PyExecutionAlgorithm>()
6114 .as_any()
6115 .call1((config,))
6116 .unwrap();
6117 let fresh = fresh_wrapper
6118 .extract::<PyRefMut<PyExecutionAlgorithm>>()
6119 .unwrap()
6120 .clone();
6121
6122 trader
6123 .add_py_execution_algorithm_instance(fresh, &fresh_wrapper.unbind())
6124 .expect("a failed attempt must not dead-end the component ID");
6125 assert_eq!(trader.exec_algorithm_ids(), vec![exec_algorithm_id]);
6126 assert!(get_python_wrapper(component_id).is_some());
6127
6128 let _ = trader.dispose_components();
6130 assert!(get_python_wrapper(component_id).is_none());
6131 assert!(trader.get_component_clocks().is_empty());
6132 });
6133 }
6134
6135 #[rstest]
6136 fn test_retirement_removes_component_subscriptions() {
6137 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
6138 create_trader_components();
6139 let mut trader = Trader::new(
6140 TraderId::test_default(),
6141 UUID4::new(),
6142 Environment::Backtest,
6143 clock_factory,
6144 cache,
6145 portfolio,
6146 );
6147
6148 let actor_id = ActorId::from("Subscribing-Actor");
6149 trader
6150 .add_actor(TestDataActor::new(DataActorConfig {
6151 actor_id: Some(actor_id),
6152 ..Default::default()
6153 }))
6154 .unwrap();
6155 trader.start_actor(&actor_id).unwrap();
6156
6157 let instrument_id = InstrumentId::from("AUD/USD.SIM");
6158 let data_type = DataType::new(stringify!(TestRetirementData), None, None);
6159 let deltas_topic = get_book_deltas_topic(instrument_id);
6160 let depth_topic = get_book_depth_topic(instrument_id);
6161 let data_topic = get_custom_topic(&data_type);
6162
6163 {
6164 let mut actor = get_actor_unchecked::<TestDataActor>(&actor_id.inner());
6165 actor.subscribe_data(data_type, None, None);
6166 actor.subscribe_book_deltas(instrument_id, BookType::L3_MBO, None, None, false, None);
6167 actor.subscribe_book_depth(instrument_id, BookType::L2_MBP, None, None, false, None);
6168 }
6169
6170 assert_eq!(msgbus::subscriptions_count_any(data_topic).unwrap(), 1);
6172 assert_eq!(msgbus::subscriber_count_deltas(deltas_topic), 1);
6173 assert_eq!(msgbus::subscriber_count_depth(depth_topic), 1);
6174
6175 trader.remove_actor(&actor_id).unwrap();
6176
6177 assert_eq!(msgbus::subscriptions_count_any(data_topic).unwrap(), 0);
6179 assert_eq!(msgbus::subscriber_count_deltas(deltas_topic), 0);
6180 assert_eq!(msgbus::subscriber_count_depth(depth_topic), 0);
6181 }
6182
6183 #[rstest]
6184 fn test_retirement_releases_bar_aggregator_after_final_subscriber() {
6185 let (msgbus, cache, portfolio, data_engine, _risk_engine, _exec_engine, clock_factory) =
6186 create_trader_components();
6187 set_message_bus(msgbus);
6188 replace_data_cmd_sender(Arc::new(SyncDataCommandSender));
6189 DataEngine::register_msgbus_handlers(&data_engine);
6190
6191 let instrument = audusd_sim();
6192 cache
6193 .borrow_mut()
6194 .add_instrument(InstrumentAny::CurrencyPair(instrument))
6195 .unwrap();
6196 let mut trader = Trader::new(
6197 TraderId::test_default(),
6198 UUID4::new(),
6199 Environment::Backtest,
6200 clock_factory,
6201 cache,
6202 portfolio,
6203 );
6204 let first_id = ActorId::from("Bar-Subscriber-001");
6205 let second_id = ActorId::from("Bar-Subscriber-002");
6206 for actor_id in [first_id, second_id] {
6207 trader
6208 .add_actor(TestDataActor::new(DataActorConfig {
6209 actor_id: Some(actor_id),
6210 ..Default::default()
6211 }))
6212 .unwrap();
6213 trader.start_actor(&actor_id).unwrap();
6214 }
6215
6216 let bar_type = BarType::from("AUD/USD.SIM-1-MINUTE-LAST-INTERNAL");
6217 get_actor_unchecked::<TestDataActor>(&first_id.inner())
6218 .subscribe_bars(bar_type, None, None);
6219 get_actor_unchecked::<TestDataActor>(&second_id.inner())
6220 .subscribe_bars(bar_type, None, None);
6221 drain_data_cmd_queue();
6222 assert!(data_engine.borrow().subscribed_bars().contains(&bar_type));
6223
6224 let topic = get_bars_topic(bar_type);
6225 assert_eq!(msgbus::exact_subscriber_count_bars(topic), 2);
6226
6227 let bar = Bar {
6228 bar_type,
6229 ..stub_bar()
6230 };
6231
6232 trader.remove_actor(&first_id).unwrap();
6233 drain_data_cmd_queue();
6234 assert!(data_engine.borrow().subscribed_bars().contains(&bar_type));
6235
6236 assert_eq!(msgbus::exact_subscriber_count_bars(topic), 1);
6237 msgbus::publish_bar(topic, &bar);
6238 assert_eq!(
6239 get_actor_unchecked::<TestDataActor>(&second_id.inner()).bars_received,
6240 1
6241 );
6242 assert!(!actor_exists(&first_id.inner()));
6243 assert!(get_component(&first_id.inner()).is_none());
6244
6245 trader.remove_actor(&second_id).unwrap();
6246 drain_data_cmd_queue();
6247 assert!(!data_engine.borrow().subscribed_bars().contains(&bar_type));
6248 assert_eq!(msgbus::exact_subscriber_count_bars(topic), 0);
6249 assert!(!actor_exists(&second_id.inner()));
6250 assert!(get_component(&second_id.inner()).is_none());
6251 assert!(trader.get_component_clocks().is_empty());
6252 }
6253
6254 #[rstest]
6255 fn test_failed_bulk_disposal_keeps_bookkeeping_consistent() {
6256 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
6257 create_trader_components();
6258 let mut trader = Trader::new(
6259 TraderId::test_default(),
6260 UUID4::new(),
6261 Environment::Backtest,
6262 clock_factory,
6263 cache,
6264 portfolio,
6265 );
6266
6267 let retired_id = ActorId::from("Bulk-Retired-Actor");
6268 let failing_id = ActorId::from("Bulk-Failing-Actor");
6269 trader
6270 .add_actor(TestDataActor::new(DataActorConfig {
6271 actor_id: Some(retired_id),
6272 ..Default::default()
6273 }))
6274 .unwrap();
6275 let mut failing = TestDataActor::new(DataActorConfig {
6276 actor_id: Some(failing_id),
6277 ..Default::default()
6278 });
6279 failing.fail_dispose = true;
6280 trader.add_actor(failing).unwrap();
6281
6282 let error = trader.clear_actors().unwrap_err();
6283
6284 assert_eq!(error.to_string(), "test actor dispose failure");
6285 assert_eq!(trader.actor_ids(), vec![failing_id]);
6286 assert_eq!(trader.get_component_clocks().len(), 1);
6287 assert!(get_component(&retired_id.inner()).is_none());
6288 assert!(!actor_exists(&retired_id.inner()));
6289 assert!(get_component(&failing_id.inner()).is_some());
6290 assert!(actor_exists(&failing_id.inner()));
6291 }
6292
6293 #[rstest]
6294 fn test_subscription_handler_tolerates_deregistered_actor() {
6295 let (_msgbus, cache, portfolio, _data_engine, _risk_engine, _exec_engine, clock_factory) =
6296 create_trader_components();
6297 let mut trader = Trader::new(
6298 TraderId::test_default(),
6299 UUID4::new(),
6300 Environment::Backtest,
6301 clock_factory,
6302 cache,
6303 portfolio,
6304 );
6305
6306 let actor_id = ActorId::from("Snapshotted-Actor");
6307 trader
6308 .add_actor(TestDataActor::new(DataActorConfig {
6309 actor_id: Some(actor_id),
6310 ..Default::default()
6311 }))
6312 .unwrap();
6313 trader.start_actor(&actor_id).unwrap();
6314
6315 let bar = stub_bar();
6316 let topic = get_bars_topic(bar.bar_type.standard());
6317 get_actor_unchecked::<TestDataActor>(&actor_id.inner()).subscribe_bars(
6318 bar.bar_type,
6319 None,
6320 None,
6321 );
6322
6323 msgbus::publish_bar(topic, &bar);
6324 assert_eq!(
6325 get_actor_unchecked::<TestDataActor>(&actor_id.inner()).bars_received,
6326 1,
6327 );
6328
6329 deregister_actor(&actor_id.inner());
6332
6333 msgbus::publish_bar(topic, &bar);
6337 }
6338
6339 #[derive(Debug, Clone, Copy)]
6341 enum TraderOp {
6342 AddActor(u8),
6343 RemoveActor(u8),
6344 ClearActors,
6345 AddStrategy(u8),
6346 RemoveStrategy(u8),
6347 ClearStrategies,
6348 AddExecutionAlgorithm(u8),
6349 ClearExecutionAlgorithms,
6350 DisposeComponents,
6351 }
6352
6353 fn prop_actor_id(slot: u8) -> ActorId {
6354 ActorId::from(format!("PropActor-{slot}").as_str())
6355 }
6356
6357 fn prop_strategy_id(slot: u8) -> StrategyId {
6358 StrategyId::from(format!("PropStrategy-{slot:03}").as_str())
6359 }
6360
6361 fn prop_exec_algorithm_id(slot: u8) -> ExecAlgorithmId {
6362 ExecAlgorithmId::from(format!("PropExecAlgo-{slot}").as_str())
6363 }
6364
6365 fn apply_trader_op(trader: &mut Trader, op: TraderOp) {
6366 match op {
6369 TraderOp::AddActor(slot) => {
6370 let _ = trader.add_actor(TestDataActor::new(DataActorConfig {
6371 actor_id: Some(prop_actor_id(slot)),
6372 ..Default::default()
6373 }));
6374 }
6375 TraderOp::RemoveActor(slot) => {
6376 let _ = trader.remove_actor(&prop_actor_id(slot));
6377 }
6378 TraderOp::ClearActors => {
6379 let _ = trader.clear_actors();
6380 }
6381 TraderOp::AddStrategy(slot) => {
6382 let _ = trader.add_strategy(TestStrategy::new(StrategyConfig {
6383 strategy_id: Some(prop_strategy_id(slot)),
6384 ..Default::default()
6385 }));
6386 }
6387 TraderOp::RemoveStrategy(slot) => {
6388 let _ = trader.remove_strategy(&prop_strategy_id(slot));
6389 }
6390 TraderOp::ClearStrategies => {
6391 let _ = trader.clear_strategies();
6392 }
6393 TraderOp::AddExecutionAlgorithm(slot) => {
6394 let _ = trader.add_exec_algorithm(TestExecutionAlgorithm::new(
6395 ExecutionAlgorithmConfig {
6396 exec_algorithm_id: Some(prop_exec_algorithm_id(slot)),
6397 ..Default::default()
6398 },
6399 ));
6400 }
6401 TraderOp::ClearExecutionAlgorithms => {
6402 let _ = trader.clear_exec_algorithms();
6403 }
6404 TraderOp::DisposeComponents => {
6405 let _ = trader.dispose_components();
6406 }
6407 }
6408 }
6409
6410 fn assert_registry_consistency(trader: &Trader, slots: &[u8]) {
6415 for &slot in slots {
6416 let actor_id = prop_actor_id(slot);
6417 let tracked = trader.actor_ids().contains(&actor_id);
6418 assert_eq!(
6419 get_component(&actor_id.inner()).is_some(),
6420 tracked,
6421 "actor {actor_id} component registry entry must match trader tracking",
6422 );
6423 assert_eq!(
6424 actor_exists(&actor_id.inner()),
6425 tracked,
6426 "actor {actor_id} actor registry entry must match trader tracking",
6427 );
6428
6429 let strategy_id = prop_strategy_id(slot);
6430 let tracked = trader.strategy_ids().contains(&strategy_id);
6431 assert_eq!(
6432 get_component(&strategy_id.inner()).is_some(),
6433 tracked,
6434 "strategy {strategy_id} component registry entry must match trader tracking",
6435 );
6436 assert_eq!(
6437 actor_exists(&strategy_id.inner()),
6438 tracked,
6439 "strategy {strategy_id} actor registry entry must match trader tracking",
6440 );
6441
6442 let exec_algorithm_id = prop_exec_algorithm_id(slot);
6443 let tracked = trader.exec_algorithm_ids().contains(&exec_algorithm_id);
6444 assert_eq!(
6445 get_component(&exec_algorithm_id.inner()).is_some(),
6446 tracked,
6447 "exec algorithm {exec_algorithm_id} component entry must match trader tracking",
6448 );
6449 assert_eq!(
6450 actor_exists(&exec_algorithm_id.inner()),
6451 tracked,
6452 "exec algorithm {exec_algorithm_id} actor entry must match trader tracking",
6453 );
6454 }
6455
6456 assert_eq!(
6457 trader.get_component_clocks().len(),
6458 trader.component_count(),
6459 "every tracked component owns exactly one clock",
6460 );
6461 }
6462
6463 use proptest::strategy::Strategy as _;
6465
6466 proptest::proptest! {
6467 #![proptest_config(proptest::prelude::ProptestConfig::with_cases(64))]
6468
6469 #[rstest]
6473 fn prop_trader_bookkeeping_matches_registries(
6474 ops in proptest::collection::vec(
6475 proptest::prop_oneof![
6476 (0u8..3).prop_map(TraderOp::AddActor),
6477 (0u8..3).prop_map(TraderOp::RemoveActor),
6478 proptest::prelude::Just(TraderOp::ClearActors),
6479 (0u8..3).prop_map(TraderOp::AddStrategy),
6480 (0u8..3).prop_map(TraderOp::RemoveStrategy),
6481 proptest::prelude::Just(TraderOp::ClearStrategies),
6482 (0u8..3).prop_map(TraderOp::AddExecutionAlgorithm),
6483 proptest::prelude::Just(TraderOp::ClearExecutionAlgorithms),
6484 proptest::prelude::Just(TraderOp::DisposeComponents),
6485 ],
6486 1..12usize,
6487 ),
6488 ) {
6489 let slots: Vec<u8> = (0u8..3).collect();
6490
6491 for &slot in &slots {
6494 deregister_component(&prop_actor_id(slot).inner());
6495 deregister_actor(&prop_actor_id(slot).inner());
6496 deregister_component(&prop_strategy_id(slot).inner());
6497 deregister_actor(&prop_strategy_id(slot).inner());
6498 deregister_component(&prop_exec_algorithm_id(slot).inner());
6499 deregister_actor(&prop_exec_algorithm_id(slot).inner());
6500 }
6501
6502 let (
6503 _msgbus,
6504 cache,
6505 portfolio,
6506 _data_engine,
6507 _risk_engine,
6508 _exec_engine,
6509 clock_factory,
6510 ) = create_trader_components();
6511 let mut trader = Trader::new(
6512 TraderId::test_default(),
6513 UUID4::new(),
6514 Environment::Backtest,
6515 clock_factory,
6516 cache,
6517 portfolio,
6518 );
6519
6520 for op in ops {
6521 apply_trader_op(&mut trader, op);
6522 assert_registry_consistency(&trader, &slots);
6523 }
6524
6525 let _ = trader.dispose_components();
6528 assert_registry_consistency(&trader, &slots);
6529 assert_eq!(trader.component_count(), 0);
6530 assert!(trader.get_component_clocks().is_empty());
6531 }
6532 }
6533}