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