mm1_node/runtime/
rt.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
use tracing::{instrument, warn};

use crate::runtime::actor_key::ActorKey;
use crate::runtime::config::{
    RtConfig, {self},
};
use crate::runtime::container::{Container, ContainerArgs, ContainerError};
use crate::runtime::context;
use crate::runtime::rt_api::{RequestAddressError, RtApi};
use crate::runtime::runnable::BoxedRunnable;

#[derive(Debug)]
pub struct Rt {
    #[allow(unused)]
    config: RtConfig,
    rt_api: RtApi,
}

#[derive(Debug, thiserror::Error)]
pub enum RtCreateError {}

#[derive(Debug, thiserror::Error)]
pub enum RtRunError {
    #[error("request address error: {}", _0)]
    RequestAddressError(
        #[allow(private_interfaces)]
        #[source]
        RequestAddressError,
    ),
    #[error("container error: {}", _0)]
    #[allow(private_interfaces)]
    ContainerError(#[source] ContainerError),
}

impl Rt {
    pub fn create(config: RtConfig) -> Result<Self, RtCreateError> {
        let rt_api = RtApi::create(config.subnet_address);

        Ok(Self { config, rt_api })
    }

    #[instrument(skip_all, fields(func = main_actor.func_name()))]
    pub async fn run(
        self,
        main_actor: BoxedRunnable<context::ActorContext>,
    ) -> Result<(), RtRunError> {
        let Self { config: _, rt_api } = self;
        let subnet_lease = rt_api
            .request_address(config::stubs::ACTOR_NETMASK)
            .await
            .map_err(RtRunError::RequestAddressError)?;
        let args = ContainerArgs {
            ack_to: None,
            link_to: Default::default(),
            actor_key: ActorKey::root().child(main_actor.func_name(), Default::default()),
            inbox_size: config::stubs::INBOX_SIZE,
            subnet_lease,
            rt_api: rt_api.clone(),
        };
        let (_subnet_lease, exit_reason) = Container::create(args, main_actor)
            .map_err(RtRunError::ContainerError)?
            .run()
            .await
            .map_err(RtRunError::ContainerError)?;

        if let Err(failure) = exit_reason {
            warn!("main-actor failure: {}", failure);
        }

        Ok(())
    }
}