securitydept-realip 0.3.0-beta.2

Real IP of SecurityDept, a layered authentication and authorization toolkit built as reusable Rust crates.
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

use std::{collections::HashMap, future::Future, pin::Pin, sync::Arc};

use ipnet::IpNet;

use crate::{
    builtins::register_builtin_provider_factories,
    config::CustomProviderConfig,
    error::{RealIpError, RealIpResult},
};

pub type ProviderLoadFuture<'a> =
    Pin<Box<dyn Future<Output = RealIpResult<Vec<IpNet>>> + Send + 'a>>;

pub trait DynamicProvider: Send + Sync {
    fn load<'a>(&'a self) -> ProviderLoadFuture<'a>;
}

pub trait CustomProviderFactory: Send + Sync {
    fn kind(&self) -> &'static str;
    fn create(&self, config: &CustomProviderConfig) -> RealIpResult<Arc<dyn DynamicProvider>>;
}

#[derive(Default, Clone)]
pub struct ProviderFactoryRegistry {
    factories: HashMap<String, Arc<dyn CustomProviderFactory>>,
}

impl ProviderFactoryRegistry {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_builtin_providers() -> RealIpResult<Self> {
        let mut registry = Self::new();
        register_builtin_provider_factories(&mut registry)?;
        Ok(registry)
    }

    pub fn register<F>(&mut self, factory: F) -> RealIpResult<()>
    where
        F: CustomProviderFactory + 'static,
    {
        let kind = factory.kind().to_string();
        if self.factories.contains_key(&kind) {
            return Err(RealIpError::DuplicateProviderFactory { kind });
        }
        self.factories.insert(kind, Arc::new(factory));
        Ok(())
    }

    pub fn get(&self, kind: &str) -> Option<Arc<dyn CustomProviderFactory>> {
        self.factories.get(kind).cloned()
    }
}