harmos-sidecar 0.1.7

Harmos sidecar transport and kit for out-of-process plugins.
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

/* ***
 *
 * Harmos
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * ***
 */

/* === Modules === */

/* === Re-Exports === */

/* === Imports === */

// Standard Library Imports
use std::future::Future;
use std::sync::Arc;
// Third Party Imports

// Local Imports
use super::{CallError, ObserverContext, PublicationError, Supervisor};
use harmos_domain::{Message, StreamSpec, inventory::publications};

/* === Constants === */

/* === Macros === */

/* === Type Aliases === */

/* === Structs === */

/* === Enums === */

/* === Traits === */

pub trait ObserverHost<R>: Send + Sync + Sized + 'static {
    fn bind(resources: Arc<R>, supervisor: Supervisor) -> Self;
}

pub trait ObserverPublisher<R: Sync, V: Send>: Send + Sync + Sized {
    type Error: std::error::Error + From<PublicationError> + Send + Sync + 'static;
    const STREAM: Option<publications::Entry> = None;

    fn publish(&self, context: &ObserverContext<'_, R, Self>, value: V) -> impl Future<Output = Result<(), Self::Error>> + Send;
}

pub trait ObserverStreamPublisher<R: Sync, S: StreamSpec>: Send + Sync + Sized
where
    S::Row: Sync,
{
    type Error: std::error::Error + From<PublicationError> + Send + Sync + 'static;

    fn publish_on(&self, context: &ObserverContext<'_, R, Self>, row: &S::Row) -> impl Future<Output = Result<(), Self::Error>> + Send;
}

pub trait ObserverCaller<R: Sync, C>: Send + Sync + Sized {
    type Request: Send;
    type Response: Send;
    type Error: std::error::Error + Send + Sync + 'static;

    fn call(
        &self, context: &ObserverContext<'_, R, Self>, request: Self::Request,
    ) -> impl Future<Output = Result<Self::Response, Self::Error>> + Send;
}

/* === Implementations === */

impl<R> ObserverHost<R> for Supervisor {
    fn bind(_: Arc<R>, supervisor: Supervisor) -> Self {
        supervisor
    }
}

impl<R: Sync, C> ObserverCaller<R, C> for Supervisor
where
    C: harmos_domain::operations::OperationDeclaration,
{
    type Request = C::Request;
    type Response = C::Response;
    type Error = CallError;

    async fn call(&self, _: &ObserverContext<'_, R, Self>, request: Self::Request) -> Result<Self::Response, Self::Error> {
        let bytes = self.child_call::<C>(&request, false).await?;
        C::Response::decode(bytes.as_slice()).map_err(|error| CallError::Malformed {
            method: C::ID,
            message: error.to_string(),
        })
    }
}

/* === Public Functions === */

/* === Private Functions === */

/* === Tests === */