asteroid-mq 0.1.0-alpha.3

An embeddable message queue system
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
112
113
114

use std::{borrow::Cow, future::Future, sync::Arc};

use crate::prelude::NodeId;

use super::EdgeRequestEnum;
#[derive(Clone)]
pub struct EdgeAuthService {
    inner: Arc<dyn sealed::BoxedEdgeAuth>,
    source: Cow<'static, str>,
}

impl std::fmt::Debug for EdgeAuthService {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("EdgeAuthService")
            .field("source", &self.source)
            .finish()
    }
}

impl std::fmt::Display for EdgeAuthService {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "EdgeAuthService: {}", self.source)
    }
}

#[derive(Debug)]
pub struct EdgeAuthError {
    reason: Cow<'static, str>,
    source: Option<Box<dyn std::error::Error + Send + Sync>>,
}

impl EdgeAuthError {
    pub fn new<E: std::error::Error + Send + Sync + 'static>(
        reason: impl Into<Cow<'static, str>>,
        source: E,
    ) -> Self {
        Self {
            reason: reason.into(),
            source: Some(Box::new(source)),
        }
    }
    pub fn new_local(reason: impl Into<Cow<'static, str>>) -> Self {
        Self {
            reason: reason.into(),
            source: None,
        }
    }
}
impl std::fmt::Display for EdgeAuthError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "EdgeAuthError: {}", self.reason,)?;
        if let Some(source) = &self.source {
            write!(f, "with source: {}", source)?;
        }
        Ok(())
    }
}

impl EdgeAuthService {
    pub fn new<T>(inner: T) -> Self
    where
        T: EdgeAuth,
    {
        Self {
            inner: Arc::new(inner),
            source: std::any::type_name::<T>().into(),
        }
    }

    pub async fn check(
        &self,
        from: NodeId,
        request: &EdgeRequestEnum,
    ) -> Result<(), EdgeAuthError> {
        self.inner.check(from, request).await
    }
}

pub trait EdgeAuth: Send + Sync + 'static {
    fn check<'r>(
        &'r self,
        from: NodeId,
        request: &'r EdgeRequestEnum,
    ) -> impl Future<Output = Result<(), EdgeAuthError>> + Send + 'r;
}

mod sealed {
    use futures_util::future::BoxFuture;

    use super::{EdgeAuth, EdgeAuthError};
    use crate::protocol::node::edge::EdgeRequestEnum;
    use crate::protocol::node::NodeId;

    pub(super) trait BoxedEdgeAuth: Send + Sync {
        fn check<'r>(
            &'r self,
            from: NodeId,
            request: &'r EdgeRequestEnum,
        ) -> BoxFuture<'r, Result<(), EdgeAuthError>>;
    }

    impl<T> BoxedEdgeAuth for T
    where
        T: EdgeAuth,
    {
        fn check<'r>(
            &'r self,
            from: NodeId,
            request: &'r EdgeRequestEnum,
        ) -> BoxFuture<'r, Result<(), EdgeAuthError>> {
            Box::pin(async move { self.check(from, request).await })
        }
    }
}