trellis-rs 0.10.17

Curated public Rust facade for Trellis clients and services.
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
97
98

use bytes::Bytes;
use futures_util::future::BoxFuture;

use super::request_loop::{HandlerResponse, RequestHandler};
use super::{
    AuthenticatedRouter, BootstrapBinding, RequestContext, RequestValidator, Router, ServerError,
};

/// A bootstrap-validated host wrapper for one service router.
pub struct ServiceHost<H> {
    service_name: String,
    binding: BootstrapBinding,
    handler: H,
}

impl<H> ServiceHost<H> {
    pub fn new(service_name: impl Into<String>, binding: BootstrapBinding, handler: H) -> Self {
        Self {
            service_name: service_name.into(),
            binding,
            handler,
        }
    }

    pub fn service_name(&self) -> &str {
        &self.service_name
    }

    pub fn binding(&self) -> &BootstrapBinding {
        &self.binding
    }

    pub fn handler(&self) -> &H {
        &self.handler
    }

    pub fn into_parts(self) -> (String, BootstrapBinding, H) {
        (self.service_name, self.binding, self.handler)
    }
}

impl<H> RequestHandler for ServiceHost<H>
where
    H: RequestHandler,
{
    fn handler_service_name(&self) -> Option<&str> {
        Some(&self.service_name)
    }

    fn handler_contract_id(&self) -> Option<&str> {
        Some(&self.binding.contract_id)
    }

    fn handler_contract_digest(&self) -> Option<&str> {
        Some(&self.binding.digest)
    }

    fn handle<'a>(
        &'a self,
        subject: &'a str,
        payload: Bytes,
        context: RequestContext,
    ) -> BoxFuture<'a, Result<Bytes, ServerError>> {
        self.handler.handle(subject, payload, context)
    }

    fn handle_frames<'a>(
        &'a self,
        subject: &'a str,
        payload: Bytes,
        context: RequestContext,
    ) -> BoxFuture<'a, Result<Vec<Bytes>, ServerError>> {
        self.handler.handle_frames(subject, payload, context)
    }

    fn handle_response<'a>(
        &'a self,
        subject: &'a str,
        payload: Bytes,
        context: RequestContext,
    ) -> BoxFuture<'a, Result<HandlerResponse, ServerError>> {
        self.handler.handle_response(subject, payload, context)
    }
}

/// Bootstrap a service host from a previously resolved binding.
pub fn bootstrap_service_host<V>(
    service_name: &str,
    binding: BootstrapBinding,
    router: Router,
    validator: V,
) -> ServiceHost<AuthenticatedRouter<V>>
where
    V: RequestValidator,
{
    let authenticated_router = AuthenticatedRouter::new(router, validator);
    ServiceHost::new(service_name.to_string(), binding, authenticated_router)
}