use std::collections::HashMap;
use parking_lot::RwLock;
use crate::error::{GarrisonError, GarrisonResult};
#[derive(Debug, Clone)]
pub struct PermissionSpec {
pub name: String,
pub required_roles: Vec<String>,
pub description: String,
}
pub struct PermissionRegistration {
pub name: &'static str,
pub required_roles: &'static str,
pub description: &'static str,
}
inventory::collect!(PermissionRegistration);
pub struct PermissionRegistry {
permissions: RwLock<HashMap<String, PermissionSpec>>,
}
impl PermissionRegistry {
pub fn new() -> Self {
Self {
permissions: RwLock::new(HashMap::new()),
}
}
pub fn register(&self, spec: PermissionSpec) -> GarrisonResult<()> {
if spec.name.is_empty() {
return Err(GarrisonError::InvalidParam(
"core-permission-name-empty::".to_string(),
));
}
#[cfg(feature = "secure-confusable")]
{
let warnings = crate::secure::confusable::check_confusable(&spec.name);
if !warnings.is_empty() {
tracing::warn!(
permission = %spec.name,
warnings = ?warnings,
"confusable characters detected in permission name"
);
}
}
let mut map = self.permissions.write();
if map.contains_key(&spec.name) {
return Err(GarrisonError::InvalidParam(format!(
"core-permission-already-registered::{}",
spec.name
)));
}
map.insert(spec.name.clone(), spec);
Ok(())
}
pub fn validate(&self, permission: &str) -> GarrisonResult<Vec<String>> {
let map = self.permissions.read();
match map.get(permission) {
Some(spec) => Ok(spec.required_roles.clone()),
None => Err(GarrisonError::InvalidParam(format!(
"core-permission-not-registered::{}",
permission
))),
}
}
pub fn list_all(&self) -> Vec<PermissionSpec> {
let map = self.permissions.read();
let mut result: Vec<PermissionSpec> = map.values().cloned().collect();
result.sort_by(|a, b| a.name.cmp(&b.name));
result
}
pub fn from_inventory() -> GarrisonResult<Self> {
let registry = Self::new();
for reg in inventory::iter::<PermissionRegistration> {
let required_roles: Vec<String> = if reg.required_roles.is_empty() {
Vec::new()
} else {
reg.required_roles
.split(',')
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.collect()
};
let spec = PermissionSpec {
name: reg.name.to_string(),
required_roles,
description: reg.description.to_string(),
};
registry.register(spec)?;
}
Ok(registry)
}
}
impl Default for PermissionRegistry {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
inventory::submit! {
PermissionRegistration {
name: "test:from_inventory:item1",
required_roles: "role1,role2",
description: "test item 1",
}
}
inventory::submit! {
PermissionRegistration {
name: "test:from_inventory:item2",
required_roles: "",
description: "test item 2 (no roles)",
}
}
fn make_spec(name: &str, roles: Vec<&str>, desc: &str) -> PermissionSpec {
PermissionSpec {
name: name.to_string(),
required_roles: roles.into_iter().map(String::from).collect(),
description: desc.to_string(),
}
}
#[test]
fn register_single_permission_success() {
let registry = PermissionRegistry::new();
let spec = make_spec("user:read", vec!["admin"], "读取用户");
registry.register(spec).expect("register ok");
let roles = registry.validate("user:read").expect("validate ok");
assert_eq!(roles, vec!["admin".to_string()]);
}
#[test]
fn validate_returns_required_roles_when_registered() {
let registry = PermissionRegistry::new();
let spec = make_spec("doc:write", vec!["admin", "editor"], "写文档");
registry.register(spec).expect("register ok");
let roles = registry.validate("doc:write").expect("validate ok");
assert_eq!(roles, vec!["admin".to_string(), "editor".to_string()]);
}
#[test]
fn validate_returns_error_for_unregistered_permission() {
let registry = PermissionRegistry::new();
let result = registry.validate("nonexistent:perm");
assert!(result.is_err(), "未注册权限应返回错误");
match result.err() {
Some(GarrisonError::InvalidParam(_)) => {},
other => panic!("期望 InvalidParam,实际: {:?}", other),
}
}
#[test]
fn register_duplicate_returns_error() {
let registry = PermissionRegistry::new();
let spec1 = make_spec("user:delete", vec!["admin"], "删除用户");
registry.register(spec1).expect("首次 register ok");
let spec2 = make_spec("user:delete", vec!["superadmin"], "重复注册");
let result = registry.register(spec2);
assert!(result.is_err(), "重复注册应返回错误");
}
#[test]
fn register_empty_name_returns_error() {
let registry = PermissionRegistry::new();
let spec = make_spec("", vec!["admin"], "空 name");
let result = registry.register(spec);
assert!(result.is_err(), "空 name 应返回错误");
match result.err() {
Some(GarrisonError::InvalidParam(_)) => {},
other => panic!("期望 InvalidParam,实际: {:?}", other),
}
}
#[test]
fn list_all_returns_all_registered() {
let registry = PermissionRegistry::new();
registry
.register(make_spec("a:read", vec!["r"], "read a"))
.expect("register 1 ok");
registry
.register(make_spec("b:write", vec!["w"], "write b"))
.expect("register 2 ok");
registry
.register(make_spec("c:delete", vec!["d"], "delete c"))
.expect("register 3 ok");
let all = registry.list_all();
assert_eq!(all.len(), 3, "应注册 3 个权限");
let names: Vec<&str> = all.iter().map(|s| s.name.as_str()).collect();
assert!(names.contains(&"a:read"));
assert!(names.contains(&"b:write"));
assert!(names.contains(&"c:delete"));
}
#[test]
fn from_inventory_collects_static_registrations() {
let registry = PermissionRegistry::from_inventory().expect("from_inventory ok");
let all = registry.list_all();
let names: Vec<&str> = all.iter().map(|s| s.name.as_str()).collect();
assert!(
names.contains(&"test:from_inventory:item1"),
"应收集 test:from_inventory:item1,实际: {:?}",
names
);
assert!(
names.contains(&"test:from_inventory:item2"),
"应收集 test:from_inventory:item2,实际: {:?}",
names
);
let item1 = all
.iter()
.find(|s| s.name == "test:from_inventory:item1")
.expect("item1 应存在");
assert_eq!(
item1.required_roles,
vec!["role1".to_string(), "role2".to_string()],
"item1 required_roles 应正确解析逗号分隔字符串"
);
let item2 = all
.iter()
.find(|s| s.name == "test:from_inventory:item2")
.expect("item2 应存在");
assert!(
item2.required_roles.is_empty(),
"item2 required_roles 应为空"
);
}
#[test]
fn register_empty_required_roles_allowed() {
let registry = PermissionRegistry::new();
let spec = make_spec("public:health", vec![], "健康检查(无角色要求)");
registry
.register(spec)
.expect("空 required_roles 应允许注册");
let roles = registry.validate("public:health").expect("validate ok");
assert!(roles.is_empty(), "无角色要求的权限应返回空 Vec");
}
}