Method resolve_inheritance

nodedb/src/control/security/role.rs:255–297

Resolve the full permission chain for a role, following inheritance. Returns a list of role names from the given role up through its ancestors, capped at `MAX_ROLE_INHERITANCE_DEPTH` entries (self + ancestors). The catalog enforces no cycles and no chains deeper than `MAX_ROLE_INHERITANCE_DEPTH` at write time, so this walk is O(depth) with no HashSet needed. If the stored chain somehow violates t

(&self, role: &Role)

    /// invariant (e.g. data written before the cap was introduced), the walk
    /// returns an error rather than truncating silently.
    pub fn resolve_inheritance(&self, role: &Role) -> crate::Result<Vec<Role>> {
        let mut chain = vec![role.clone()];

        if let Role::Custom(name) = role {
            let roles = self.roles.read().map_err(|e| crate::Error::Internal {
                detail: format!("role store lock poisoned: {e}"),
            })?;

            let mut current = name.as_str();

            loop {
                if chain.len() > MAX_ROLE_INHERITANCE_DEPTH {
                    return Err(crate::Error::RoleInheritanceDepthExceeded {
                        depth: chain.len(),
                        limit: MAX_ROLE_INHERITANCE_DEPTH,
                    });
                }
                // Built-in roles have no further parents.
                if is_builtin(current) {
                    break;
                }
                match roles.get(current) {
                    Some(custom) => match &custom.parent {
                        Some(parent_name) => {
                            // Role::from_str is infallible (Err = Infallible);
                            // matching on the uninhabited error proves it at
                            // compile time without an unwrap.
                            let parent_role: Role = match parent_name.parse() {
                                Ok(r) => r,
                                Err(e) => match e {},
                            };
                            chain.push(parent_role);
                            current = parent_name.as_str();
                        }
                        None => break,
                    },
                    None => break,
                }
            }
        }

        Ok(chain)
    }

    /// Check that adopting `parent` as `role_name`'s inheritance parent would
    /// not create a cycle or exceed [`MAX_ROLE_INHERITANCE_DEPTH`].