Struct LiveNode 

pub struct LiveNode { /* private fields */ }

High-level abstraction for a live Nautilus system node.

Provides a simplified interface for running live systems with automatic client management and lifecycle handling.

Implementations

impl LiveNode

pub fn handle(&self) -> LiveNodeHandle

Returns a thread-safe handle to control this node.

pub fn builder( name: String, trader_id: TraderId, environment: Environment, ) -> Result<LiveNodeBuilder>

Creates a new LiveNodeBuilder for fluent configuration.

Errors

Returns an error if the environment is invalid for live trading.

pub fn build(name: String, config: Option<LiveNodeConfig>) -> Result<Self>

Creates a new LiveNode directly from a kernel name and optional configuration.

This is a convenience method for creating a live node with a pre-configured kernel configuration, bypassing the builder pattern. If no config is provided, a default configuration will be used.

Errors

Returns an error if kernel construction fails.

pub async fn start(&mut self) -> Result<()>

Starts the live node.

Errors

Returns an error if startup fails.

pub async fn stop(&mut self) -> Result<()>

Stop the live node.

Errors

Returns an error if shutdown fails.

pub async fn run(&mut self) -> Result<()>

Run the live node with automatic shutdown handling.

This method will start the node, run indefinitely, and handle graceful shutdown on interrupt signals.

Errors

Returns an error if the node fails to start or encounters a runtime error.

pub fn environment(&self) -> Environment

Gets the node’s environment.

pub const fn kernel(&self) -> &NautilusKernel

Gets a reference to the underlying kernel.

pub fn trader_id(&self) -> TraderId

Gets the node’s trader ID.

pub const fn instance_id(&self) -> UUID4

Gets the node’s instance ID.

pub const fn is_running(&self) -> bool

Checks if the live node is currently running.

pub fn add_actor<T>(&mut self, actor: T) -> Result<()>

where T: DataActor + Component + Actor + 'static,

Adds an actor to the trader.

This method provides a high-level interface for adding actors to the underlying trader without requiring direct access to the kernel. Actors should be added after the node is built but before starting the node.

Errors

Returns an error if:

• The trader is not in a valid state for adding components.
• An actor with the same ID is already registered.
• The node is currently running.

pub fn add_actor_from_factory<F, T>(&mut self, factory: F) -> Result<()>

where F: FnOnce() -> Result<T>, T: DataActor + Component + Actor + 'static,

Adds an actor to the live node using a factory function.

The factory function is called at registration time to create the actor, avoiding cloning issues with non-cloneable actor types.

Errors

Returns an error if:

• The node is currently running.
• The factory function fails to create the actor.
• The underlying trader registration fails.

Trait Implementations

impl Debug for LiveNode

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'py> IntoPyObject<'py> for LiveNode

type Target = LiveNode

The Python output type

type Output = Bound<'py, <LiveNode as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl PyClass for LiveNode

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for LiveNode

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

type BaseType = PyAny

Base class

type ThreadChecker = ThreadCheckerImpl

This handles following two situations:

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn doc(py: Python<'_>) -> PyResult<&'static CStr>

Rendered class doc

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl<'a, 'py> PyFunctionArgument<'a, 'py, false> for &'a LiveNode

type Holder = Option<PyRef<'py, LiveNode>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'a mut Self::Holder, ) -> PyResult<Self>

impl<'a, 'py> PyFunctionArgument<'a, 'py, false> for &'a mut LiveNode

type Holder = Option<PyRefMut<'py, LiveNode>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'a mut Self::Holder, ) -> PyResult<Self>

impl PyMethods<LiveNode> for PyClassImplCollector<LiveNode>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for LiveNode

const NAME: &'static str = "LiveNode"

Class name.

const MODULE: Option<&'static str>

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.

impl DerefToPyAny for LiveNode