murgamu 0.7.3

Murgamü is an NestJS-inspired web framework for Rust
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

use crate::mur_http::request::MurRequestContext;
use std::sync::Arc;

type RateLimitCustomType = Arc<dyn Fn(&MurRequestContext) -> Option<String> + Send + Sync>;

#[derive(Clone)]
pub enum RateLimitKey {
	Ip,
	Header(String),
	BearerToken,
	IpAndHeader(String),
	Custom(RateLimitCustomType),
	Global,
}

impl std::fmt::Debug for RateLimitKey {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		match self {
			RateLimitKey::Ip => write!(f, "Ip"),
			RateLimitKey::Header(name) => write!(f, "Header({:?})", name),
			RateLimitKey::BearerToken => write!(f, "BearerToken"),
			RateLimitKey::IpAndHeader(name) => write!(f, "IpAndHeader({:?})", name),
			RateLimitKey::Custom(_) => write!(f, "Custom(<function>)"),
			RateLimitKey::Global => write!(f, "Global"),
		}
	}
}

impl RateLimitKey {
	pub fn extract(&self, ctx: &MurRequestContext) -> Option<String> {
		match self {
			RateLimitKey::Ip => Self::extract_ip(ctx),
			RateLimitKey::Header(name) => ctx.header(name).map(|s| s.to_string()),
			RateLimitKey::BearerToken => Self::extract_bearer_token(ctx),
			RateLimitKey::IpAndHeader(name) => {
				let ip = Self::extract_ip(ctx)?;
				let header = ctx.header(name).map(|s| s.to_string()).unwrap_or_default();
				Some(format!("{}:{}", ip, header))
			}
			RateLimitKey::Custom(f) => f(ctx),
			RateLimitKey::Global => Some("__global__".to_string()),
		}
	}

	fn extract_ip(ctx: &MurRequestContext) -> Option<String> {
		if let Some(forwarded) = ctx.header("x-forwarded-for") {
			return forwarded.split(',').next().map(|s| s.trim().to_string());
		}

		if let Some(real_ip) = ctx.header("x-real-ip") {
			return Some(real_ip.to_string());
		}

		if let Some(cf_ip) = ctx.header("cf-connecting-ip") {
			return Some(cf_ip.to_string());
		}

		Some("unknown".to_string())
	}

	fn extract_bearer_token(ctx: &MurRequestContext) -> Option<String> {
		ctx.header("authorization").and_then(|auth| {
			if auth.to_lowercase().starts_with("bearer ") {
				Some(auth[7..].to_string())
			} else {
				None
			}
		})
	}
}