Struct DMSCPythonAsyncServiceModule 

pub struct DMSCPythonAsyncServiceModule { /* private fields */ }

Python wrapper for asynchronous AsyncServiceModule trait.

This structure provides a Python-accessible representation of asynchronous service modules. It enables Python code to define async modules that integrate with DMSC’s module lifecycle system using non-blocking operations.

Asynchronous Execution

Asynchronous modules use Rust’s async/await model and are executed on the Tokio runtime. This enables non-blocking I/O operations and concurrent execution of multiple async modules without thread blocking.

Tokio Runtime

The async modules execute within the Tokio runtime that is managed by the DMSC application runtime. This provides efficient task scheduling and native support for async I/O operations.

Python Integration

When using Python with pyo3, asynchronous methods should be defined using async def syntax. The Python runtime must be properly initialized before async operations can be performed.

Python Usage

 

class MyAsyncModule:
    async def name(&self):
        return "async_module"

    async def start(&self, ctx):
        print("Starting async module")
        return None

module = dms.DMSCPythonAsyncServiceModule(name="my_async")
module.priority = 100
module.dependencies = ["config", "logger"]

Implementations

impl DMSCPythonAsyncServiceModule

pub fn name(&self) -> String

pub fn set_name(&mut self, name: String)

pub fn is_critical(&self) -> bool

pub fn set_is_critical(&mut self, is_critical: bool)

pub fn priority(&self) -> i32

pub fn set_priority(&mut self, priority: i32)

pub fn dependencies(&self) -> Vec<String>

pub fn set_dependencies(&mut self, dependencies: Vec<String>)

Trait Implementations

impl AsyncServiceModule for DMSCPythonAsyncServiceModule

fn name(&self) -> &str

Returns the name of the internal async service module.

fn is_critical(&self) -> bool

Indicates if the internal module is critical to the operation of the system.

fn priority(&self) -> i32

Returns the priority of the internal module.

fn dependencies(&self) -> Vec<&str>

Returns the list of module dependencies.

fn init<'life0, 'life1, 'async_trait>( &'life0 mut self, _ctx: &'life1 mut DMSCServiceContext, ) -> Pin<Box<dyn Future<Output = DMSCResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Initializes the internal async service module.

fn before_start<'life0, 'life1, 'async_trait>( &'life0 mut self, _ctx: &'life1 mut DMSCServiceContext, ) -> Pin<Box<dyn Future<Output = DMSCResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Prepares the internal module for startup.

fn start<'life0, 'life1, 'async_trait>( &'life0 mut self, _ctx: &'life1 mut DMSCServiceContext, ) -> Pin<Box<dyn Future<Output = DMSCResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Starts the internal async service module.

fn after_start<'life0, 'life1, 'async_trait>( &'life0 mut self, _ctx: &'life1 mut DMSCServiceContext, ) -> Pin<Box<dyn Future<Output = DMSCResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Performs post-startup operations for the internal module.

fn before_shutdown<'life0, 'life1, 'async_trait>( &'life0 mut self, _ctx: &'life1 mut DMSCServiceContext, ) -> Pin<Box<dyn Future<Output = DMSCResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Prepares the internal module for shutdown.

fn shutdown<'life0, 'life1, 'async_trait>( &'life0 mut self, _ctx: &'life1 mut DMSCServiceContext, ) -> Pin<Box<dyn Future<Output = DMSCResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Shuts down the internal async service module.

fn after_shutdown<'life0, 'life1, 'async_trait>( &'life0 mut self, _ctx: &'life1 mut DMSCServiceContext, ) -> Pin<Box<dyn Future<Output = DMSCResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Performs post-shutdown cleanup for the internal module.

impl Clone for DMSCPythonAsyncServiceModule

fn clone(&self) -> DMSCPythonAsyncServiceModule

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'py> IntoPyObject<'py> for DMSCPythonAsyncServiceModule

type Target = DMSCPythonAsyncServiceModule

The Python output type

type Output = Bound<'py, <DMSCPythonAsyncServiceModule 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 DMSCPythonAsyncServiceModule

type Frozen = False

Whether the pyclass is frozen.

impl PyClassBaseType for DMSCPythonAsyncServiceModule

type LayoutAsBase = PyClassObject<DMSCPythonAsyncServiceModule>

type BaseNativeType = <DMSCPythonAsyncServiceModule as PyClassImpl>::BaseNativeType

type Initializer = PyClassInitializer<DMSCPythonAsyncServiceModule>

type PyClassMutability = <DMSCPythonAsyncServiceModule as PyClassImpl>::PyClassMutability

impl PyClassImpl for DMSCPythonAsyncServiceModule

const IS_BASETYPE: bool = true

#[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)]

const RAW_DOC: &'static CStr = /// ```

Docstring for the class provided on the struct or enum.

const DOC: &'static CStr

Fully rendered class doc, including the text_signature if a constructor is defined.

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<DMSCPythonAsyncServiceModule>

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 lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyClassNewTextSignature for DMSCPythonAsyncServiceModule

const TEXT_SIGNATURE: &'static str = "(name)"

impl PyMethods<DMSCPythonAsyncServiceModule> for PyClassImplCollector<DMSCPythonAsyncServiceModule>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for DMSCPythonAsyncServiceModule

const NAME: &'static str = "DMSCPythonAsyncServiceModule"

Class name.

const MODULE: Option<&'static str> = ::core::option::Option::None

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 DMSCPythonAsyncServiceModule

impl ExtractPyClassWithClone for DMSCPythonAsyncServiceModule