Struct RiAppRuntime 

pub struct RiAppRuntime { /* private fields */ }

Public-facing application runtime.

The RiAppRuntime manages the application lifecycle, including module initialization, startup, and shutdown. It also handles the execution of both synchronous and asynchronous modules.

Usage

use ri::prelude::*;
 
#[tokio::main]
async fn main() -> RiResult<()> {
    let app = RiAppBuilder::new()
        .with_config("config.yaml")?
        .build()?;
     
    app.run(|ctx| async move {
        ctx.logger().info("service", "Ri service started")?;
        Ok(())
    }).await
}

Implementations

impl RiAppRuntime

pub fn new(ctx: RiServiceContext, modules: Vec<ModuleSlot>) -> Self

Create a new application runtime with the given context and modules.

This method is typically called by the RiAppBuilder during the build process.

Parameters

• ctx: Service context with core functionalities
• modules: Vector of modules with their initial state

Returns

A new RiAppRuntime instance.

pub fn is_running(&self) -> bool

Check whether the application lifecycle is currently running.

This returns true between the start of run and the completion of the shutdown sequence (including when run returns early with an error).

pub async fn shutdown(&mut self) -> RiResult<()>

Request a cooperative shutdown of the application.

This method is idempotent: if the lifecycle is not running (either it has not started yet or it already finished), it returns Ok(()) immediately. Otherwise it executes the module shutdown sequence (sync modules first in reverse order, then async modules in reverse order, then shutdown hooks) and marks the lifecycle as no longer running.

Errors

Returns an error if a critical module fails during shutdown.

pub async fn run<F, Fut>(self, f: F) -> RiResult<()>

where F: FnOnce(&RiServiceContext) -> Fut, Fut: Future<Output = RiResult<()>>,

Run the application lifecycle.

This method executes the complete application lifecycle, including:

1. Emitting startup hooks
2. Initializing synchronous modules
3. Starting synchronous modules
4. Initializing and starting asynchronous modules
5. Running the application business logic via the provided closure
6. Shutting down asynchronous modules
7. Shutting down synchronous modules
8. Emitting shutdown hooks

Parameters

• f: A closure that takes a RiServiceContext and returns a RiResult<()>. This closure contains the application’s business logic and is executed after all modules have been initialized and started, but before any modules are shut down.

Returns

A RiResult indicating success or failure.

Errors

Returns an error if:

• A critical module fails during execution
• The provided closure returns an error

Trait Implementations

impl Clone for RiAppRuntime

fn clone(&self) -> RiAppRuntime

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl DerefToPyAny for RiAppRuntime

impl ExtractPyClassWithClone for RiAppRuntime

impl<'py> IntoPyObject<'py> for RiAppRuntime

type Target = RiAppRuntime

The Python output type

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

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for RiAppRuntime

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

const RAW_DOC: &'static CStr = c"Public-facing application runtime.\n\nThe `RiAppRuntime` manages the application lifecycle, including module initialization,\nstartup, and shutdown. It also handles the execution of both synchronous and asynchronous modules.\n\n## Usage\n\n```rust\nuse ri::prelude::*;\n\n#[tokio::main]\nasync fn main() -> RiResult<()> {\n let app = RiAppBuilder::new()\n .with_config(\"config.yaml\")?\n .build()?;\n \n app.run(|ctx| async move {\n ctx.logger().info(\"service\", \"Ri service started\")?;\n Ok(())\n }).await\n}\n```\x00"

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<RiAppRuntime>

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 PyMethods<RiAppRuntime> for PyClassImplCollector<RiAppRuntime>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for RiAppRuntime

const NAME: &'static str = "RiAppRuntime"

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.