mm1-multinode 0.7.23

An Erlang-style actor runtime for Rust.
Documentation 
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
73
74
75
76
77
78
79
80
81

use std::time::Duration;

use eyre::Context;
use mm1_address::address::Address;
use mm1_address::subnet::NetAddress;
use mm1_common::types::AnyError;
use mm1_proto_network_management as nm;
use mm1_proto_network_management::protocols::{self as p};

use crate::actors::context::ActorContext;
use crate::proto;

const ASK_TIMEOUT: Duration = Duration::from_secs(1);

pub(super) async fn subscribe_to_routes<Ctx>(
    ctx: &mut Ctx,
    multinode_manager: Address,
    deliver_to: Address,
) -> Result<Vec<proto::SetRoute>, AnyError>
where
    Ctx: ActorContext,
{
    let proto::SubscribeToRoutesResponse { routes } = ctx
        .ask::<_, proto::SubscribeToRoutesResponse>(
            multinode_manager,
            proto::SubscribeToRoutesRequest { deliver_to },
            ASK_TIMEOUT,
        )
        .await
        .wrap_err("ask")?;

    Ok(routes)
}

pub(super) async fn get_local_subnets<Ctx>(
    ctx: &mut Ctx,
    multinode_manager: Address,
) -> Result<Vec<NetAddress>, AnyError>
where
    Ctx: ActorContext,
{
    let local_subnets: p::GetLocalSubnetsResponse = ctx
        .ask(multinode_manager, p::GetLocalSubnetsRequest, ASK_TIMEOUT)
        .await
        .wrap_err("ask")?;

    Ok(local_subnets)
}

pub(super) async fn register_opaque_message<Ctx>(
    ctx: &mut Ctx,
    multinode_manager: Address,
    name: nm::MessageName,
) -> Result<p::LocalTypeKey, AnyError>
where
    Ctx: ActorContext,
{
    let request = p::RegisterOpaqueMessageRequest { name };
    let p::RegisterOpaqueMessageResponse { key } = ctx
        .ask(multinode_manager, request, ASK_TIMEOUT)
        .await
        .wrap_err("ask")?;

    Ok(key)
}

pub(super) async fn get_message_name<Ctx>(
    ctx: &mut Ctx,
    multinode_manager: Address,
    key: p::LocalTypeKey,
) -> Result<nm::MessageName, AnyError>
where
    Ctx: ActorContext,
{
    let request = p::GetMessageNameRequest { key };
    let p::GetMessageNameResponse { name } = ctx
        .ask(multinode_manager, request, ASK_TIMEOUT)
        .await
        .wrap_err("ask")?;
    Ok(name)
}