aves 0.5.0

Typed async application runtime with domain messaging, RPC, and durable workflow automation
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 std::path::PathBuf;

use crate::bus::EventBus;
use crate::runtime::{ConstructionFacade, DomainCallbacks, DomainDescriptorFactory, DomainFuture, ServicePublisher};

use super::handle;
use super::messages::{
    ConfigBroadcast, ConfigPrivilegedRegisterSection, ConfigPrivilegedSealRegistration, ConfigRequest,
    ConfigRequestPayload, ConfigSudoServicePrivilegeMapping, RegisterSectionInput, RegisteredOutput,
    SealRegistrationInput,
};
use super::types::ConfigError;

/// Generic Config domain marker.
pub struct ConfigDomain;

aves::domain! {
    marker ConfigDomain;

    request ConfigRequestPayload => ConfigResponse
    error = ConfigError
    transport = ConfigError
    target = "config";

    pub service ConfigRegistrationSudoService {
        RegisterSection => Registered,
        SealRegistration => Registered,
    }

    outbound ConfigBroadcast => ConfigBroadcast {
        ConfigChanged { section, value } => ConfigChanged { section, value },
    }
}

pub(super) use __Config_generated_routing::ConfigGeneratedHandler;

/// Directory handed to the runtime by the embedding application.
#[derive(Clone)]
pub struct ConfigDirectory(pub PathBuf);

impl<Root> DomainDescriptorFactory<EventBus<Root>> for ConfigDomain
where
    Root: Clone + Send + 'static,
    ConfigBroadcast: Into<Root> + Clone + Send + 'static,
{
    fn callbacks() -> DomainCallbacks<EventBus<Root>> {
        fn construct<'facade, 'bus, Root>(
            facade: &'facade mut ConstructionFacade<'bus, EventBus<Root>>,
        ) -> DomainFuture<'facade>
        where
            Root: Clone + Send + 'static,
            ConfigBroadcast: Into<Root> + Clone + Send + 'static,
        {
            let directory = facade
                .input::<ConfigDirectory>()
                .expect("Config directory must be supplied")
                .0
                .clone();
            let registration: ServicePublisher<dyn ConfigRegistrationSudoService> = facade.publisher();
            let future = handle::new(facade.bus_mut(), directory, registration);
            Box::pin(async move {
                let handler = future.await;
                tokio::spawn(async move { handler.run().await });
            })
        }
        DomainCallbacks {
            new: construct::<Root>,
            start: |_| Box::pin(async {}),
            stop: |_| Box::pin(async {}),
        }
    }
}