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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use std::path::PathBuf;

use tokio::sync::mpsc::Receiver;
use uuid::Uuid;

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

use super::handle::{self, ConstructionResult};
use super::messages::{
    AuthPrivilegedCreateInvitation, AuthPrivilegedFirstContact, AuthPrivilegedIssueJwt, AuthPrivilegedIssuePeerJwt,
    AuthPrivilegedIssueRootJwt, AuthPrivilegedListPairingCandidates, AuthPrivilegedListPeers, AuthPrivilegedPairPeer,
    AuthPrivilegedRevokeJti, AuthPrivilegedRevokePeer, AuthPrivilegedVerifyJwt, AuthRequest, AuthRequestPayload,
    AuthSudoServicePrivilegeMapping, CreateInvitationInput, DelegatedJwtIssuedOutput, FirstContactInput,
    FirstContactedOutput, InvitationOutput, IssueJwtInput, IssuePeerJwtInput, IssueRootJwtInput, JwtIssuedOutput,
    ListPairingCandidatesInput, ListPeersInput, PairPeerInput, PairingCandidatesOutput, PeerJwtIssuedOutput,
    PeersOutput, RevokeJtiInput, RevokePeerInput, SuccessOutput, VerifiedOutput, VerifyJwtInput,
};
use super::types::AvesAuthError;

/// Empty lifecycle marker for the built-in Auth domain.
pub struct AuthDomain;

/// Construction-only inputs for the built-in Auth domain.
pub struct AuthBootOptions {
    pub namespace: String,
    pub audience: Uuid,
    pub peer_config_path: PathBuf,
}

aves::domain! {
    marker AuthDomain;

    request AuthRequestPayload => AuthResponse
    error = AvesAuthError
    transport = AvesAuthError
    target = "auth";

    pub service AuthSudoService {
        IssueJwt => DelegatedJwtIssued (operation = "issueJwt"),
        IssueRootJwt => JwtIssued (operation = "issueRootJwt"),
        IssuePeerJwt => PeerJwtIssued (operation = "issuePeerJwt"),
        VerifyJwt => Verified (operation = "verifyJwt"),
        RevokeJti => Success (operation = "revokeJti"),
        PairPeer => Success (operation = "pairPeer"),
        RevokePeer => Success (operation = "revokePeer"),
        ListPeers => Peers (operation = "listPeers"),
        ListPairingCandidates => PairingCandidates (operation = "listPairingCandidates"),
        CreateInvitation => Invitation (operation = "createInvitation"),
        FirstContact => FirstContacted (operation = "firstContact"),
    }
}

impl<Root> DomainDescriptorFactory<EventBus<Root>> for AuthDomain
where
    Root: Clone + Send + 'static,
{
    fn callbacks() -> DomainCallbacks<EventBus<Root>> {
        fn start(_context: BusRpcContext) -> DomainFuture<'static> {
            Box::pin(async {})
        }

        fn stop(_context: BusRpcContext) -> DomainFuture<'static> {
            Box::pin(async {})
        }

        fn construct<'facade, 'bus, Root>(
            facade: &'facade mut ConstructionFacade<'bus, EventBus<Root>>,
        ) -> DomainFuture<'facade>
        where
            Root: Clone + Send + 'static,
        {
            let options = {
                let options = facade
                    .auth_boot_options()
                    .expect("built-in Auth requires runtime boot options");
                AuthBootOptions {
                    namespace: options.namespace.clone(),
                    audience: options.audience,
                    peer_config_path: options.peer_config_path.clone(),
                }
            };

            let channels = facade.bus_mut().register::<AuthDomain, AuthRequest, Root>();
            let publisher = facade.publisher::<dyn AuthSudoService>();

            let published = construct_auth_domain(&options, publisher).map(|(construction, sudo_requests)| {
                let handler = __Auth_generated_routing::AuthGeneratedHandler::new(
                    channels.requests_rx,
                    construction.actor_sender.clone(),
                    channels.broadcasts_tx,
                    sudo_requests,
                );
                tokio::spawn(handler.run());
                construction
            });
            facade.set_auth_construction(published);

            Box::pin(async {})
        }

        DomainCallbacks {
            new: construct::<Root>,
            start,
            stop,
        }
    }
}

/// Constructs Auth and returns its machine identity to the runtime.
fn construct_auth_domain(
    options: &AuthBootOptions,
    publisher: ServicePublisher<dyn AuthSudoService>,
) -> Result<(ConstructionResult, Receiver<AuthRequest>), AvesAuthError> {
    let (construction, sudo_requests) =
        handle::construct(&options.namespace, options.audience, &options.peer_config_path)?;

    publisher
        .publish(construction.service.clone())
        .map_err(|_| AvesAuthError::Internal("Auth service was already published".to_owned()))?;

    Ok((construction, sudo_requests))
}