audio2face3d-server 0.1.0

Audio2Face-3D compatible gRPC server
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

//! Application supplied, statically dispatched authentication.
mod bearer;
pub(crate) mod gate;
pub use audio2face3d::types::RequestId;
pub use bearer::{InvalidApiKey, validate_api_key};
use std::{
    fmt,
    future::{Future, Ready, ready},
    net::SocketAddr,
};

/// A borrowed credential. Formatting never exposes its contents.
#[derive(Clone, Copy)]
pub struct SecretApiKey<'a>(&'a str);
impl<'a> SecretApiKey<'a> {
    /// Intentionally expose the credential to the application's verifier.
    pub fn expose(self) -> &'a str {
        self.0
    }
}
impl fmt::Debug for SecretApiKey<'_> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str("[REDACTED]")
    }
}
impl fmt::Display for SecretApiKey<'_> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Debug::fmt(self, f)
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum RpcMethod {
    ProcessAudioStream,
    HealthCheck,
    HealthWatch,
}
#[derive(Clone, Copy, Debug)]
pub struct AuthRequest<'a> {
    pub api_key: SecretApiKey<'a>,
    pub request_id: RequestId,
    pub method: RpcMethod,
    pub peer_addr: Option<SocketAddr>,
}
/// A safe application identity, never a credential or its prefix.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Principal {
    subject: String,
}
impl Principal {
    pub fn new(subject: impl Into<String>) -> Result<Self, AuthError> {
        let subject = subject.into();
        if subject.is_empty() || subject.len() > 128 || subject.chars().any(char::is_control) {
            return Err(AuthError::Unavailable);
        }
        Ok(Self { subject })
    }
    pub fn subject(&self) -> &str {
        &self.subject
    }
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum AuthError {
    InvalidCredential,
    Forbidden,
    Unavailable,
}
impl fmt::Display for AuthError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{self:?}")
    }
}
impl std::error::Error for AuthError {}
pub type AuthResult = Result<Principal, AuthError>;
pub trait Authenticator: Send + Sync + 'static {
    type Future<'a>: Future<Output = AuthResult> + Send + 'a
    where
        Self: 'a;
    fn authenticate<'a>(&'a self, request: AuthRequest<'a>) -> Self::Future<'a>;
}
impl<F> Authenticator for F
where
    F: for<'a> Fn(AuthRequest<'a>) -> AuthResult + Send + Sync + 'static,
{
    type Future<'a>
        = Ready<AuthResult>
    where
        Self: 'a;
    fn authenticate<'a>(&'a self, request: AuthRequest<'a>) -> Self::Future<'a> {
        ready(self(request))
    }
}
/// No authenticator is installed; this marker cannot grant access by invocation.
pub struct NoAuth {
    _private: (),
}
impl Authenticator for NoAuth {
    type Future<'a> = Ready<AuthResult>;
    fn authenticate<'a>(&'a self, _: AuthRequest<'a>) -> Self::Future<'a> {
        ready(Err(AuthError::Unavailable))
    }
}
pub struct AsyncAuthenticator<F>(F);
pub fn async_authenticator<F, Fut>(f: F) -> AsyncAuthenticator<F>
where
    F: for<'a> Fn(AuthRequest<'a>) -> Fut + Send + Sync + 'static,
    Fut: Future<Output = AuthResult> + Send + 'static,
{
    AsyncAuthenticator(f)
}
impl<F, Fut> Authenticator for AsyncAuthenticator<F>
where
    F: for<'a> Fn(AuthRequest<'a>) -> Fut + Send + Sync + 'static,
    Fut: Future<Output = AuthResult> + Send + 'static,
{
    type Future<'a>
        = Fut
    where
        Self: 'a;
    fn authenticate<'a>(&'a self, request: AuthRequest<'a>) -> Self::Future<'a> {
        (self.0)(request)
    }
}