manas_http 0.1.1

This crate provides extended functionality for handling http semantics, that integrates into [`hyper`](https://docs.rs/hyper/latest/hyper/index.html) ecosystem.
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
99
100
101
102
103
104
105
106
107
108
109
110
111

use std::{convert::Infallible, marker::PhantomData, task::Poll};

use http::{Request, Response};
use http_uri::invariant::NormalAbsoluteHttpUri;
use tower::Service;
use tracing::info;

use crate::service::{namespaced::NamespacedHttpService, BoxHttpResponseFuture, HttpService};

/// An implementation of [`HttpService`], that routes it's
/// requests to a configured overrider if request target is in
/// it's namespace, or else to inner service.
///
/// It expects reconstructed absolute uri of resource target
/// as [`NormalAbsoluteHttpUri`] typed request extension.
///
#[derive(Debug)]
pub struct OverridingHttpService<ReqBody, ResBody, Inner, Overrider> {
    /// Inner service.
    pub inner: Inner,

    /// Overrider service.
    pub overrider: Overrider,
    _phantom: PhantomData<fn() -> (ReqBody, ResBody)>,
}

impl<ReqBody, ResBody, Inner: Clone, Overrider: Clone> Clone
    for OverridingHttpService<ReqBody, ResBody, Inner, Overrider>
{
    #[inline]
    fn clone(&self) -> Self {
        Self {
            inner: self.inner.clone(),
            overrider: self.overrider.clone(),
            _phantom: self._phantom,
        }
    }
}

impl<ReqBody, ResBody, Inner, Overrider> OverridingHttpService<ReqBody, ResBody, Inner, Overrider>
where
    Inner: HttpService<ReqBody, ResBody>,
    Overrider: NamespacedHttpService<ReqBody, ResBody>,
{
    /// Get new [`OverridingHttpService`] with given inner
    /// http-service, and overrider service.
    #[inline]
    pub fn new(inner: Inner, overrider: Overrider) -> Self {
        Self {
            inner,
            overrider,
            _phantom: PhantomData,
        }
    }
}

impl<ReqBody, ResBody, Inner, Overrider> Service<Request<ReqBody>>
    for OverridingHttpService<ReqBody, ResBody, Inner, Overrider>
where
    Inner: HttpService<ReqBody, ResBody>,
    Overrider: NamespacedHttpService<ReqBody, ResBody>,
{
    type Response = Response<ResBody>;

    type Error = Infallible;

    type Future = BoxHttpResponseFuture<ResBody>;

    #[inline]
    fn poll_ready(&mut self, cx: &mut std::task::Context<'_>) -> Poll<Result<(), Self::Error>> {
        match self.inner.poll_ready(cx) {
            Poll::Ready(_) => self.overrider.poll_ready(cx),
            Poll::Pending => Poll::Pending,
        }
    }

    #[tracing::instrument(skip_all, name = "OverridenPodService__call")]
    fn call(&mut self, req: Request<ReqBody>) -> Self::Future {
        // Get res uri.
        let res_uri = req
            .extensions()
            .get::<NormalAbsoluteHttpUri>()
            .expect("Service must be called after handling uri normal validity check.");

        info!("res_uri: {:?}", res_uri);

        // First check if overrider service has the uri in it's target namespace.
        if self.overrider.has_in_uri_ns(res_uri) {
            info!("routed to overrider.");
            self.overrider.call(req)
        } else {
            // Otherwise call inner podset-service.
            info!("routed to inner podset.");
            self.inner.call(req)
        }
    }
}

impl<ReqBody, ResBody, Inner, Overrider> NamespacedHttpService<ReqBody, ResBody>
    for OverridingHttpService<ReqBody, ResBody, Inner, Overrider>
where
    ReqBody: 'static,
    ResBody: 'static,
    Inner: NamespacedHttpService<ReqBody, ResBody> + Clone,
    Overrider: NamespacedHttpService<ReqBody, ResBody> + Clone,
{
    fn has_in_uri_ns(&self, uri: &NormalAbsoluteHttpUri) -> bool {
        // Return true if uri is in namespace of either inner svc, or overrider.
        self.overrider.has_in_uri_ns(uri) || self.inner.has_in_uri_ns(uri)
    }
}