From 2244d730bb956c96fefda00ac718a954f51b635e Mon Sep 17 00:00:00 2001 From: YueGuobin Date: Fri, 6 Nov 2026 23:47:29 +0800 Subject: [PATCH] perf: keep RBAC state in memory for permission checks Permission checks ran several queries per request, including a full scan of the resources table. The controller already keeps projects, computes and notifications in process memory: apply the same idea to the RBAC tables. Roles, ACEs, group memberships and resource pool memberships are loaded into a process-wide snapshot. Checks run against the snapshot in memory. Repository write methods mark the snapshot dirty and the next read reloads it from the database, so privilege changes apply right away. The database stays the source of truth. The evaluation is a faithful port of the previous SQL version, quirks included (reverse path traversal, deny raising PermissionError, pool checks with the "/pool" prefix, group ACEs in natural order). The two RBAC tests that mutated ORM objects directly now write through the repository, like the rest of the code. The /projects ACE they relied on was created by another test, so they were order dependent: they now create it when missing. --- gns3server/core/tasks.py | 5 +- gns3server/db/rbac_state.py | 399 ++++++++++++++++++++++++++++ gns3server/db/repositories/pools.py | 9 + gns3server/db/repositories/rbac.py | 252 ++---------------- gns3server/db/repositories/users.py | 10 + gns3server/db/tasks.py | 11 + tests/conftest.py | 5 + tests/controller/test_rbac.py | 51 +++- tests/controller/test_rbac_state.py | 209 +++++++++++++++ 9 files changed, 711 insertions(+), 240 deletions(-) create mode 100644 gns3server/db/rbac_state.py create mode 100644 tests/controller/test_rbac_state.py diff --git a/gns3server/core/tasks.py b/gns3server/core/tasks.py index 1a3e50f45..0300466fa 100644 --- a/gns3server/core/tasks.py +++ b/gns3server/core/tasks.py @@ -27,7 +27,7 @@ from gns3server.compute.marker.marker_manager import MarkerManager from gns3server.compute.port_manager import PortManager from gns3server.config import Config from gns3server.controller import Controller -from gns3server.db.tasks import connect_to_db, disconnect_from_db, get_computes +from gns3server.db.tasks import connect_to_db, disconnect_from_db, get_computes, load_rbac_state from gns3server.services.image_reconciliation import get_image_reconciliation_service from gns3server.utils.http_client import HTTPClient @@ -74,6 +74,9 @@ async def startup(app: FastAPI) -> None: # retrieve the computes from the database computes = await get_computes(app) + # load the in-memory RBAC snapshot before serving requests + await load_rbac_state(app) + await Controller.instance().start(computes) get_image_reconciliation_service(app).start_background() diff --git a/gns3server/db/rbac_state.py b/gns3server/db/rbac_state.py new file mode 100644 index 000000000..375e30939 --- /dev/null +++ b/gns3server/db/rbac_state.py @@ -0,0 +1,399 @@ +# +# Copyright (C) 2026 GNS3 Technologies Inc. +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . +# + +""" +In-memory snapshot of the RBAC state. + +The controller keeps its whole runtime state (projects, computes, +notifications) in process memory: a second controller instance is not a +supported setup. This module applies the same idea to the RBAC tables. +All roles, ACEs, group memberships and resource pool memberships are +loaded once into a process-wide snapshot, permission checks then run +against the snapshot instead of querying the database on every request. + +The database stays the source of truth. Every repository method that +writes an RBAC table marks the snapshot as dirty, and the next read +rebuilds it from the database. Rebuilding is a handful of small SELECTs +and only happens after (human frequency) administrative writes, so the +checks keep their exact semantics while dropping from several queries +per request (including a full resource scan) to an in-memory lookup. + +The evaluation methods replicate the semantics of the previous +database-backed implementation, quirks included (path reverse traversal, +deny raising PermissionError, pool checks with the "/pool" prefix, group +ACEs in natural order while user ACEs are sorted by descending path). +""" + +import logging +from dataclasses import dataclass +from typing import Dict, Iterable, List, Optional, Set, Tuple +from urllib.parse import urlparse +from uuid import UUID + +from sqlalchemy import select +from sqlalchemy.ext.asyncio import AsyncSession +from sqlalchemy.orm import selectinload + +import gns3server.db.models as models + +log = logging.getLogger(__name__) + + +@dataclass(frozen=True) +class AceEntry: + """ + A flattened ACE: the ACE row itself plus the ids it matches. + """ + + path: str + propagate: bool + allowed: bool + user_id: Optional[UUID] + group_id: Optional[UUID] + role_id: UUID + + +class RbacState: + """ + Process-wide snapshot of the RBAC tables. + + The snapshot is loaded lazily on first use and rebuilt after any + RBAC write (mark_dirty). It must be reset when the database is + recreated (tests) via reset(). + """ + + _instance: Optional["RbacState"] = None + + def __init__(self) -> None: + + self._loaded: bool = False + self._dirty: bool = False + self._role_privileges: Dict[UUID, Set[str]] = {} + self._group_members: Dict[UUID, Set[UUID]] = {} + self._aces: List[AceEntry] = [] + self._project_resource_ids: Set[str] = set() + # pool id (str) -> project resource ids (str) + self._pool_projects: Dict[str, Set[str]] = {} + + @classmethod + def instance(cls) -> "RbacState": + if cls._instance is None: + cls._instance = cls() + return cls._instance + + def reset(self) -> None: + """ + Drop the snapshot: the next read reloads it from the database. + Called when the database is recreated (tests) or at startup. + """ + + self._loaded = False + self._dirty = False + self._role_privileges = {} + self._group_members = {} + self._aces = [] + self._project_resource_ids = set() + self._pool_projects = {} + + def mark_dirty(self) -> None: + """ + Flag the snapshot as outdated. Repository write methods call + this after touching an RBAC table; no I/O is done here. + """ + + self._dirty = True + + async def reload(self, db_session: AsyncSession) -> None: + """ + Rebuild the snapshot from the database, whatever its state. + """ + + # clear the flag before loading: if a write marks the snapshot + # dirty again while the queries are awaited, the next read + # triggers another reload + self._dirty = False + + # role id -> privilege names + roles_result = await db_session.execute(select(models.Role).options(selectinload(models.Role.privileges))) + role_privileges: Dict[UUID, Set[str]] = {} + for role in roles_result.scalars().all(): + role_privileges[role.role_id] = {privilege.name for privilege in role.privileges} + + # group id -> member user ids + result = await db_session.execute(select(models.UserGroup).options(selectinload(models.UserGroup.users))) + group_members: Dict[UUID, Set[UUID]] = {} + for group in result.scalars().all(): + group_members[group.user_group_id] = {user.user_id for user in group.users} + + # ACEs, in natural database order (group ACE evaluation order relies on it) + aces_result = await db_session.execute(select(models.ACE)) + aces: List[AceEntry] = [] + for ace in aces_result.scalars().all(): + # ACE uses legacy Column declarations, so typed attribute access + # on instances is not available: go through the plain dict + values = ace.asdict() + aces.append( + AceEntry( + path=values["path"], + propagate=values["propagate"], + allowed=values["allowed"], + user_id=values["user_id"], + group_id=values["group_id"], + role_id=values["role_id"], + ) + ) + + # all registered project resources, pooled or not: the pool gate in + # user_has_privilege checks paths against every project resource + resources_result = await db_session.execute( + select(models.Resource) + .options(selectinload(models.Resource.resource_pools)) + .filter(models.Resource.resource_type == "project") + ) + project_resource_ids: Set[str] = set() + pool_projects: Dict[str, Set[str]] = {} + for resource in resources_result.scalars().all(): + project_resource_ids.add(str(resource.resource_id)) + for pool in resource.resource_pools: + pool_projects.setdefault(str(pool.resource_pool_id), set()).add(str(resource.resource_id)) + + self._role_privileges = role_privileges + self._group_members = group_members + self._aces = aces + self._project_resource_ids = project_resource_ids + self._pool_projects = pool_projects + self._loaded = True + log.debug(f"RBAC snapshot reloaded: {len(aces)} ACE(s), {len(role_privileges)} role(s)") + + async def ensure_loaded(self, db_session: AsyncSession) -> None: + """ + Rebuild the snapshot if it has never been loaded or is dirty. + """ + + if not self._loaded or self._dirty: + await self.reload(db_session) + + # + # Evaluation methods below are pure: no database access. + # + + def _user_aces(self, user_id: UUID, privilege_name: str) -> List[AceEntry]: + """ + ACEs assigned to the user itself granting the privilege, + sorted by descending path (same order as the SQL implementation). + """ + + aces = [ + ace + for ace in self._aces + if ace.user_id == user_id and privilege_name in self._role_privileges.get(ace.role_id, ()) + ] + return sorted(aces, key=lambda ace: ace.path, reverse=True) + + def _group_aces(self, user_id: UUID, privilege_name: str) -> List[AceEntry]: + """ + ACEs assigned to the groups the user belongs to granting the + privilege, in natural order (same order as the SQL implementation). + """ + + groups = {group_id for group_id, members in self._group_members.items() if user_id in members} + return [ + ace + for ace in self._aces + if ace.group_id is not None + and ace.group_id in groups + and privilege_name in self._role_privileges.get(ace.role_id, ()) + ] + + @staticmethod + def _check_path_with_aces(path: str, aces: Iterable[AceEntry]) -> bool: + """ + Compare path with existing ACEs to check if the user has the required privilege on that path. + """ + + parsed_url = urlparse(path) + original_path = path + path_components = parsed_url.path.split("/") + # traverse the path in reverse order + for i in range(len(path_components), 0, -1): + path = "/".join(path_components[:i]) + if not path: + path = "/" + for ace in aces: + if ace.path == path: + if not ace.allowed: + raise PermissionError(f"Permission denied for {path}") + if path == original_path or ace.propagate: + return True # only allow if the path is the original path or the ACE is set to propagate + return False + + def _pool_grants_path(self, aces: Iterable[AceEntry], path: str) -> bool: + """ + Whether any pool referenced by the given ACEs contains a project + matching the path (the previous implementation returned the list + of matching resources; only its truthiness was used). + """ + + for ace in aces: + if ace.path.startswith("/pool"): + pool_id = ace.path.split("/")[2] + for project_id in self._pool_projects.get(pool_id, ()): + if path.startswith(f"/projects/{project_id}"): + return True + return False + + def user_has_privilege(self, user_id: UUID, path: str, privilege_name: str) -> bool: + """ + Check the user has a privilege on a path. + + Resource paths form a file system like tree and privileges can be inherited by paths down that tree + (the propagate field is True by default) + + The following inheritance rules are used: + + * Privileges for individual users always replace group privileges. + * Privileges for groups apply when the user is member of that group. + * Privileges on deeper levels replace those inherited from an upper level. + """ + + path_is_in_pool = any(path.startswith(f"/projects/{resource_id}") for resource_id in self._project_resource_ids) + + user_aces = self._user_aces(user_id, privilege_name) + try: + # Check regular ACEs first + if self._check_path_with_aces(path, user_aces): + # the user has an ACE matching the path and privilege, there is no need to check group ACEs + return True + # Then check resource pool ACEs + if path_is_in_pool: + if self._pool_grants_path(user_aces, path): + return True + except PermissionError: + return False + + group_aces = self._group_aces(user_id, privilege_name) + try: + # Check regular ACEs first + if self._check_path_with_aces(path, group_aces): + return True + # Then check resource pool ACEs + if path_is_in_pool: + if self._pool_grants_path(group_aces, path): + return True + except PermissionError: + return False + return False + + def user_privilege_names(self, user_id: UUID) -> Set[str]: + """ + Names of all privileges granted to a user through its roles, via + ACEs on the user itself and on the groups the user belongs to. + Flattened view that ignores resource paths. + """ + + groups = {group_id for group_id, members in self._group_members.items() if user_id in members} + names: Set[str] = set() + for ace in self._aces: + if not ace.allowed: + continue + if ace.user_id == user_id or (ace.group_id is not None and ace.group_id in groups): + names.update(self._role_privileges.get(ace.role_id, ())) + return names + + def _direct_project_ids( + self, user_aces: List[AceEntry], group_aces: List[AceEntry], all_project_ids: List[str] + ) -> Tuple[Set[str], Set[str]]: + """ + Projects the user can access via a direct ACE on /projects/: + user ACEs first (a deny puts the project aside as denied), then + group ACEs skipping already accessible or denied projects. + """ + + direct_ace_ids = set() + user_denied = set() + + # --- User ACE: direct path check --- + for pid in all_project_ids: + path = f"/projects/{pid}" + try: + if self._check_path_with_aces(path, user_aces): + direct_ace_ids.add(pid) + except PermissionError: + user_denied.add(pid) + + # --- Group ACE: direct path check (skip already accessible or denied) --- + for pid in all_project_ids: + if pid in direct_ace_ids or pid in user_denied: + continue + path = f"/projects/{pid}" + try: + if self._check_path_with_aces(path, group_aces): + direct_ace_ids.add(pid) + except PermissionError: + pass + + return direct_ace_ids, user_denied + + def _pooled_project_ids( + self, user_aces: List[AceEntry], group_aces: List[AceEntry], user_denied: Set[str] + ) -> Set[str]: + """ + Projects the user can access because they sit in a resource pool + referenced by an allowed ACE: user pools first, then group pools. + """ + + # --- User ACE: pool check --- + user_pool_ids = {ace.path.split("/")[2] for ace in user_aces if ace.path.startswith("/pools/") and ace.allowed} + + pool_accessible_ids = set() + for pool_id, project_ids in self._pool_projects.items(): + if pool_id in user_pool_ids: + for pid in project_ids: + if pid not in user_denied: + pool_accessible_ids.add(pid) + + # --- Group ACE: pool check --- + group_pool_ids = { + ace.path.split("/")[2] for ace in group_aces if ace.path.startswith("/pools/") and ace.allowed + } + + for pool_id, project_ids in self._pool_projects.items(): + if pool_id in group_pool_ids: + for pid in project_ids: + if pid not in user_denied and pid not in pool_accessible_ids: + pool_accessible_ids.add(pid) + + return pool_accessible_ids + + def accessible_project_ids( + self, user_id: UUID, privilege_name: str, all_project_ids: List[str] + ) -> Tuple[Set[str], Set[str]]: + """ + Batch check which projects a user can access via direct ACE or resource pools. + + Returns: + (direct_ace_ids, pool_accessible_ids) where: + - direct_ace_ids: projects the user has a direct ACE on (needs created_by filter) + - pool_accessible_ids: projects in resource pools the user can access (no created_by filter) + """ + + user_aces = self._user_aces(user_id, privilege_name) + group_aces = self._group_aces(user_id, privilege_name) + + direct_ace_ids, user_denied = self._direct_project_ids(user_aces, group_aces, all_project_ids) + pool_accessible_ids = self._pooled_project_ids(user_aces, group_aces, user_denied) + return direct_ace_ids, pool_accessible_ids diff --git a/gns3server/db/repositories/pools.py b/gns3server/db/repositories/pools.py index d5ead9e05..11022271e 100644 --- a/gns3server/db/repositories/pools.py +++ b/gns3server/db/repositories/pools.py @@ -26,6 +26,7 @@ from sqlalchemy.orm import selectinload import gns3server.db.models as models from gns3server import schemas +from gns3server.db.rbac_state import RbacState from .base import BaseRepository @@ -36,6 +37,7 @@ class ResourcePoolsRepository(BaseRepository): def __init__(self, db_session: AsyncSession) -> None: super().__init__(db_session) + self._rbac_state = RbacState.instance() async def get_resource(self, resource_id: UUID) -> Optional[models.Resource]: """ @@ -65,6 +67,7 @@ class ResourcePoolsRepository(BaseRepository): ) self._db_session.add(db_resource) await self._db_session.commit() + self._rbac_state.mark_dirty() await self._db_session.refresh(db_resource) return db_resource @@ -76,6 +79,7 @@ class ResourcePoolsRepository(BaseRepository): query = delete(models.Resource).where(models.Resource.resource_id == resource_id) result = await self._db_session.execute(query) await self._db_session.commit() + self._rbac_state.mark_dirty() return cast(CursorResult, result).rowcount > 0 async def get_resource_memberships(self, resource_id: UUID) -> List[models.ResourcePool]: @@ -127,6 +131,7 @@ class ResourcePoolsRepository(BaseRepository): db_resource_pool = models.ResourcePool(name=resource_pool.name) self._db_session.add(db_resource_pool) await self._db_session.commit() + self._rbac_state.mark_dirty() await self._db_session.refresh(db_resource_pool) return db_resource_pool @@ -146,6 +151,7 @@ class ResourcePoolsRepository(BaseRepository): await self._db_session.execute(query) await self._db_session.commit() + self._rbac_state.mark_dirty() resource_pool_db = await self.get_resource_pool(resource_pool_id) if resource_pool_db: await self._db_session.refresh(resource_pool_db) # force refresh of updated_at value @@ -167,6 +173,7 @@ class ResourcePoolsRepository(BaseRepository): query = delete(models.ResourcePool).where(models.ResourcePool.resource_pool_id == resource_pool_id) result = await self._db_session.execute(query) await self._db_session.commit() + self._rbac_state.mark_dirty() return cast(CursorResult, result).rowcount > 0 async def add_resource_to_pool( @@ -188,6 +195,7 @@ class ResourcePoolsRepository(BaseRepository): resource_pool_db.resources.append(resource) await self._db_session.commit() + self._rbac_state.mark_dirty() await self._db_session.refresh(resource_pool_db) return resource_pool_db @@ -210,6 +218,7 @@ class ResourcePoolsRepository(BaseRepository): resource_pool_db.resources.remove(resource) await self._db_session.commit() + self._rbac_state.mark_dirty() await self._db_session.refresh(resource_pool_db) return resource_pool_db diff --git a/gns3server/db/repositories/rbac.py b/gns3server/db/repositories/rbac.py index 3a4a6864a..8fa8c7c73 100644 --- a/gns3server/db/repositories/rbac.py +++ b/gns3server/db/repositories/rbac.py @@ -16,17 +16,17 @@ # along with this program. If not, see . import logging -from typing import Any, List, Optional, Set, Union, cast -from urllib.parse import urlparse +from typing import List, Optional, Set, Union, cast from uuid import UUID -from sqlalchemy import Select, delete, select, update -from sqlalchemy.engine import CursorResult, Result +from sqlalchemy import delete, select, update +from sqlalchemy.engine import CursorResult from sqlalchemy.ext.asyncio import AsyncSession from sqlalchemy.orm import selectinload import gns3server.db.models as models from gns3server import schemas +from gns3server.db.rbac_state import RbacState from .base import BaseRepository @@ -37,6 +37,7 @@ class RbacRepository(BaseRepository): def __init__(self, db_session: AsyncSession) -> None: super().__init__(db_session) + self._rbac_state = RbacState.instance() async def get_role(self, role_id: UUID) -> Optional[models.Role]: """ @@ -76,6 +77,7 @@ class RbacRepository(BaseRepository): ) self._db_session.add(db_role) await self._db_session.commit() + self._rbac_state.mark_dirty() return await self.get_role(db_role.role_id) async def update_role(self, role_id: UUID, role_update: schemas.RoleUpdate) -> Optional[models.Role]: @@ -88,6 +90,7 @@ class RbacRepository(BaseRepository): await self._db_session.execute(query) await self._db_session.commit() + self._rbac_state.mark_dirty() role_db = await self.get_role(role_id) if role_db: await self._db_session.refresh(role_db) # force refresh of updated_at value @@ -101,6 +104,7 @@ class RbacRepository(BaseRepository): query = delete(models.Role).where(models.Role.role_id == role_id) result = await self._db_session.execute(query) await self._db_session.commit() + self._rbac_state.mark_dirty() return cast(CursorResult, result).rowcount > 0 async def add_privilege_to_role(self, role_id: UUID, privilege: models.Privilege) -> Union[None, models.Role]: @@ -123,6 +127,7 @@ class RbacRepository(BaseRepository): role_db.privileges.append(privilege) await self._db_session.commit() + self._rbac_state.mark_dirty() await self._db_session.refresh(role_db) return role_db @@ -139,6 +144,7 @@ class RbacRepository(BaseRepository): role_db.privileges.remove(privilege) await self._db_session.commit() + self._rbac_state.mark_dirty() await self._db_session.refresh(role_db) return role_db @@ -188,32 +194,8 @@ class RbacRepository(BaseRepository): check remains check_user_has_privilege(), which takes paths into account. """ - privilege_names: Set[str] = set() - - # privileges granted by ACEs on the user itself - user_result: Result[Any] = await self._db_session.execute( - select(models.Privilege.name) - .join(models.Privilege.roles) - .join(models.Role.acl_entries) - .join(models.ACE.user) - .filter(models.User.user_id == user_id) - .filter(models.ACE.allowed.is_(True)) - ) - privilege_names.update(name for (name,) in user_result.all()) - - # privileges granted by ACEs on the groups the user belongs to - group_result: Result[Any] = await self._db_session.execute( - select(models.Privilege.name) - .join(models.Privilege.roles) - .join(models.Role.acl_entries) - .join(models.ACE.group) - .join(models.UserGroup.users) - .filter(models.User.user_id == user_id) - .filter(models.ACE.allowed.is_(True)) - ) - privilege_names.update(name for (name,) in group_result.all()) - - return privilege_names + await self._rbac_state.ensure_loaded(self._db_session) + return self._rbac_state.user_privilege_names(user_id) async def get_ace(self, ace_id: UUID) -> Optional[models.ACE]: """ @@ -275,6 +257,7 @@ class RbacRepository(BaseRepository): db_ace = models.ACE(**create_values) self._db_session.add(db_ace) await self._db_session.commit() + self._rbac_state.mark_dirty() await self._db_session.refresh(db_ace) return db_ace @@ -288,6 +271,7 @@ class RbacRepository(BaseRepository): await self._db_session.execute(query) await self._db_session.commit() + self._rbac_state.mark_dirty() ace_db = await self.get_ace(ace_id) if ace_db: await self._db_session.refresh(ace_db) # force refresh of updated_at value @@ -301,6 +285,7 @@ class RbacRepository(BaseRepository): query = delete(models.ACE).where(models.ACE.ace_id == ace_id) result = await self._db_session.execute(query) await self._db_session.commit() + self._rbac_state.mark_dirty() return cast(CursorResult, result).rowcount > 0 async def delete_all_ace_starting_with_path(self, path: str) -> None: @@ -310,109 +295,12 @@ class RbacRepository(BaseRepository): query = delete(models.ACE).where(models.ACE.path.startswith(path)).execution_options(synchronize_session=False) result = await self._db_session.execute(query) + self._rbac_state.mark_dirty() log.debug(f"{cast(CursorResult, result).rowcount} ACE(s) have been deleted") - @staticmethod - def _check_path_with_aces(path: str, aces) -> bool: - """ - Compare path with existing ACEs to check if the user has the required privilege on that path. - """ - - parsed_url = urlparse(path) - original_path = path - path_components = parsed_url.path.split("/") - # traverse the path in reverse order - for i in range(len(path_components), 0, -1): - path = "/".join(path_components[:i]) - if not path: - path = "/" - for ace_path, ace_propagate, ace_allowed, ace_privilege in aces: - if ace_path == path: - if not ace_allowed: - raise PermissionError(f"Permission denied for {path}") - if path == original_path or ace_propagate: - return True # only allow if the path is the original path or the ACE is set to propagate - return False - - async def _get_resources_in_pools(self, aces, path: Optional[str] = None) -> List[models.Resource]: - """ - Get all resources in pools. - """ - - pool_resources = [] - for ace_path, ace_propagate, ace_allowed, ace_privilege in aces: - if ace_path.startswith("/pool"): - resource_pool_id = ace_path.split("/")[2] - query = ( - select(models.Resource) - .join(models.Resource.resource_pools) - .filter(models.ResourcePool.resource_pool_id == resource_pool_id) - ) - - result = await self._db_session.execute(query) - resources = result.scalars().all() - - for resource in resources: - # we only support projects in resource pools for now - if resource.resource_type == "project": - if path: - if path.startswith(f"/projects/{resource.resource_id}"): - pool_resources.append(resource) - else: - pool_resources.append(resource) - return pool_resources - - async def _get_user_aces(self, user_id: UUID, privilege_name: str): - """ - Retrieve all user ACEs matching the user_id and privilege name. - """ - - query: Select[Any, Any, Any, Any] = ( - select(models.ACE.path, models.ACE.propagate, models.ACE.allowed, models.Privilege.name) - .join(models.Privilege.roles) - .join(models.Role.acl_entries) - .join(models.ACE.user) - .filter(models.User.user_id == user_id) - .filter(models.Privilege.name == privilege_name) - .order_by(models.ACE.path.desc()) - ) - - result = await self._db_session.execute(query) - return result.all() - - async def _get_group_aces(self, user_id: UUID, privilege_name: str): - """ - Retrieve all group ACEs matching the user_id and privilege name. - """ - - query: Select[Any, Any, Any, Any] = ( - select(models.ACE.path, models.ACE.propagate, models.ACE.allowed, models.Privilege.name) - .join(models.Privilege.roles) - .join(models.Role.acl_entries) - .join(models.ACE.group) - .join(models.UserGroup.users) - .filter(models.User.user_id == user_id) - .filter(models.Privilege.name == privilege_name) - ) - - result = await self._db_session.execute(query) - return result.all() - - async def get_user_pool_resources(self, user_id: UUID, privilege_name: str) -> List[models.Resource]: - """ - Get all resources in pools belonging to a user and groups - """ - - user_aces = await self._get_user_aces(user_id, privilege_name) - pool_resources = await self._get_resources_in_pools(user_aces) - group_aces = await self._get_group_aces(user_id, privilege_name) - pool_resources.extend(await self._get_resources_in_pools(group_aces)) - return list(set(pool_resources)) - async def get_accessible_project_ids(self, user_id: UUID, privilege_name: str, all_project_ids: List[str]): """ Batch check which projects a user can access via direct ACE or resource pools. - Performs 3 fixed DB queries regardless of project count. Returns: (direct_ace_ids, pool_accessible_ids) where: @@ -420,72 +308,8 @@ class RbacRepository(BaseRepository): - pool_accessible_ids: projects in resource pools the user can access (no created_by filter) """ - user_aces = await self._get_user_aces(user_id, privilege_name) - group_aces = await self._get_group_aces(user_id, privilege_name) - - # Single query for all resources and their pool memberships - query = select(models.Resource).options(selectinload(models.Resource.resource_pools)) - result = await self._db_session.execute(query) - all_resources = result.scalars().all() - - # Precompute pool_id -> set of project_ids - pool_to_projects: dict[str, set[str]] = {} - for r in all_resources: - if r.resource_type == "project": - for pool in r.resource_pools: - pool_to_projects.setdefault(str(pool.resource_pool_id), set()).add(str(r.resource_id)) - - # --- User ACE: direct path check --- - direct_ace_ids = set() - user_denied = set() - - for pid in all_project_ids: - path = f"/projects/{pid}" - try: - if self._check_path_with_aces(path, user_aces): - direct_ace_ids.add(pid) - except PermissionError: - user_denied.add(pid) - - # --- User ACE: pool check --- - user_pool_ids = { - ace_path.split("/")[2] - for ace_path, _, ace_allowed, _ in user_aces - if ace_path.startswith("/pools/") and ace_allowed - } - - pool_accessible_ids = set() - for pool_id, project_ids in pool_to_projects.items(): - if pool_id in user_pool_ids: - for pid in project_ids: - if pid not in user_denied: - pool_accessible_ids.add(pid) - - # --- Group ACE: direct path check (skip already accessible or denied) --- - for pid in all_project_ids: - if pid in direct_ace_ids or pid in user_denied: - continue - path = f"/projects/{pid}" - try: - if self._check_path_with_aces(path, group_aces): - direct_ace_ids.add(pid) - except PermissionError: - pass - - # --- Group ACE: pool check --- - group_pool_ids = { - ace_path.split("/")[2] - for ace_path, _, ace_allowed, _ in group_aces - if ace_path.startswith("/pools/") and ace_allowed - } - - for pool_id, project_ids in pool_to_projects.items(): - if pool_id in group_pool_ids: - for pid in project_ids: - if pid not in user_denied and pid not in pool_accessible_ids: - pool_accessible_ids.add(pid) - - return direct_ace_ids, pool_accessible_ids + await self._rbac_state.ensure_loaded(self._db_session) + return self._rbac_state.accessible_project_ids(user_id, privilege_name, all_project_ids) async def check_user_has_privilege(self, user_id: UUID, path: str, privilege_name: str) -> bool: """ @@ -497,40 +321,10 @@ class RbacRepository(BaseRepository): * Privileges for individual users always replace group privileges. * Privileges for groups apply when the user is member of that group. * Privileges on deeper levels replace those inherited from an upper level. + + The check runs against the in-memory RBAC snapshot (rebuilt after + any RBAC write), see gns3server.db.rbac_state. """ - query = select(models.Resource) - result = await self._db_session.execute(query) - resources = result.scalars().all() - projects_in_pools = [f"/projects/{r.resource_id}" for r in resources if r.resource_type == "project"] - path_is_in_pool = False - for project_in_pool in projects_in_pools: - if path.startswith(project_in_pool): - path_is_in_pool = True - break - - aces = await self._get_user_aces(user_id, privilege_name) - try: - # Check regular ACEs first - if self._check_path_with_aces(path, aces): - # the user has an ACE matching the path and privilege, there is no need to check group ACEs - return True - # Then check resource pool ACEs - if path_is_in_pool: - if await self._get_resources_in_pools(aces, path): - return True - except PermissionError: - return False - - aces = await self._get_group_aces(user_id, privilege_name) - try: - # Check regular ACEs first - if self._check_path_with_aces(path, aces): - return True - # Then check resource pool ACEs - if path_is_in_pool: - if await self._get_resources_in_pools(aces, path): - return True - except PermissionError: - return False - return False + await self._rbac_state.ensure_loaded(self._db_session) + return self._rbac_state.user_has_privilege(user_id, path, privilege_name) diff --git a/gns3server/db/repositories/users.py b/gns3server/db/repositories/users.py index 9ab51eaa8..afd2347d0 100644 --- a/gns3server/db/repositories/users.py +++ b/gns3server/db/repositories/users.py @@ -26,6 +26,7 @@ from sqlalchemy.orm import selectinload import gns3server.db.models as models from gns3server import schemas +from gns3server.db.rbac_state import RbacState from gns3server.services import auth_service from .base import BaseRepository @@ -38,6 +39,7 @@ class UsersRepository(BaseRepository): super().__init__(db_session) self._auth_service = auth_service + self._rbac_state = RbacState.instance() async def get_user(self, user_id: UUID) -> Optional[models.User]: """ @@ -86,6 +88,7 @@ class UsersRepository(BaseRepository): ) self._db_session.add(db_user) await self._db_session.commit() + self._rbac_state.mark_dirty() await self._db_session.refresh(db_user) return db_user @@ -105,6 +108,7 @@ class UsersRepository(BaseRepository): await self._db_session.execute(query) await self._db_session.commit() + self._rbac_state.mark_dirty() user_db = await self.get_user(user_id) if user_db: await self._db_session.refresh(user_db) # force refresh of updated_at value @@ -132,6 +136,7 @@ class UsersRepository(BaseRepository): query = delete(models.User).where(models.User.user_id == user_id) result = await self._db_session.execute(query) await self._db_session.commit() + self._rbac_state.mark_dirty() return cast(CursorResult, result).rowcount > 0 async def authenticate_user(self, username: str, password: str) -> Optional[models.User]: @@ -208,6 +213,7 @@ class UsersRepository(BaseRepository): db_user_group = models.UserGroup(name=user_group.name) self._db_session.add(db_user_group) await self._db_session.commit() + self._rbac_state.mark_dirty() await self._db_session.refresh(db_user_group) return db_user_group @@ -223,6 +229,7 @@ class UsersRepository(BaseRepository): await self._db_session.execute(query) await self._db_session.commit() + self._rbac_state.mark_dirty() user_group_db = await self.get_user_group(user_group_id) if user_group_db: await self._db_session.refresh(user_group_db) # force refresh of updated_at value @@ -236,6 +243,7 @@ class UsersRepository(BaseRepository): query = delete(models.UserGroup).where(models.UserGroup.user_group_id == user_group_id) result = await self._db_session.execute(query) await self._db_session.commit() + self._rbac_state.mark_dirty() return cast(CursorResult, result).rowcount > 0 async def add_member_to_user_group(self, user_group_id: UUID, user: models.User) -> Union[None, models.UserGroup]: @@ -255,6 +263,7 @@ class UsersRepository(BaseRepository): user_group_db.users.append(user) await self._db_session.commit() + self._rbac_state.mark_dirty() await self._db_session.refresh(user_group_db) return user_group_db @@ -277,6 +286,7 @@ class UsersRepository(BaseRepository): user_group_db.users.remove(user) await self._db_session.commit() + self._rbac_state.mark_dirty() await self._db_session.refresh(user_group_db) return user_group_db diff --git a/gns3server/db/tasks.py b/gns3server/db/tasks.py index 62de57508..05b2a2e78 100644 --- a/gns3server/db/tasks.py +++ b/gns3server/db/tasks.py @@ -32,6 +32,7 @@ from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine from gns3server import schemas from gns3server.config import Config +from gns3server.db.rbac_state import RbacState from gns3server.db.repositories.computes import ComputesRepository from gns3server.db.repositories.images import ImagesRepository from gns3server.utils.images import read_image_info @@ -199,6 +200,16 @@ async def get_computes(app: FastAPI) -> List[schemas.Compute]: return computes +async def load_rbac_state(app: FastAPI) -> None: + """ + Load the in-memory RBAC snapshot at startup, so permission checks do + not hit the database on the request path. + """ + + async with AsyncSession(app.state._db_engine) as db_session: + await RbacState.instance().reload(db_session) + + async def update_disk_checksums(updated_disks: List[str]) -> None: """Refresh complete metadata after a server-managed disk modification.""" from gns3server.api.server import app diff --git a/tests/conftest.py b/tests/conftest.py index 0c76f5066..eabe1aab1 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -27,6 +27,7 @@ from gns3server.compute.project_manager import ProjectManager from gns3server.config import Config from gns3server.controller import Controller from gns3server.db.models import Base, Compute, User +from gns3server.db.rbac_state import RbacState from gns3server.db.repositories.computes import ComputesRepository from gns3server.db.repositories.users import UsersRepository from gns3server.schemas.controller.computes import Protocol @@ -82,6 +83,10 @@ async def db_session(db_engine): await conn.run_sync(Base.metadata.drop_all) await conn.run_sync(Base.metadata.create_all) + # the RBAC snapshot is process-wide: drop it so it reloads from the + # freshly recreated tables instead of holding data from a previous class + RbacState.instance().reset() + session = AsyncSession(db_engine, expire_on_commit=False) try: yield session diff --git a/tests/controller/test_rbac.py b/tests/controller/test_rbac.py index 501f752bc..a9cccad75 100644 --- a/tests/controller/test_rbac.py +++ b/tests/controller/test_rbac.py @@ -29,7 +29,7 @@ from gns3server.db.repositories.pools import ResourcePoolsRepository from gns3server.db.repositories.rbac import RbacRepository from gns3server.db.repositories.users import UsersRepository from gns3server.schemas.controller.pools import ResourceCreate, ResourcePoolCreate -from gns3server.schemas.controller.rbac import ACECreate +from gns3server.schemas.controller.rbac import ACECreate, ACEUpdate from gns3server.services import auth_service pytestmark = pytest.mark.asyncio @@ -80,26 +80,57 @@ class TestPrivileges: authorized = await RbacRepository(db_session).check_user_has_privilege(test_user.user_id, path, privilege) assert authorized == result + async def _get_or_create_projects_ace( + self, db_session: AsyncSession, *, propagate: bool, allowed: bool = True + ) -> None: + """ + The tests must not depend on the /projects ACE created by another test: + reuse it when present, otherwise create it with the requested flags. + """ + + rbac_repo = RbacRepository(db_session) + ace = await rbac_repo.get_ace_by_path("/projects") + if ace is None: + group_id = (await UsersRepository(db_session).get_user_group_by_name("Users")).user_group_id + role_id = (await rbac_repo.get_role_by_name("User")).role_id + await rbac_repo.create_ace( + ACECreate( + path="/projects", + ace_type="group", + propagate=propagate, + allowed=allowed, + group_id=str(group_id), + role_id=str(role_id), + ) + ) + else: + await rbac_repo.update_ace( + ace.ace_id, + ACEUpdate( + ace_type=ace.ace_type, + path=ace.path, + role_id=ace.role_id, + propagate=propagate, + allowed=allowed, + ), + ) + async def test_propagate(self, test_user: User, db_session: AsyncSession): privilege = "Project.Audit" path = "/projects/44929147-47bb-460a-90ae-c782c4dbb6ef" - authorized = await RbacRepository(db_session).check_user_has_privilege(test_user.user_id, path, privilege) + rbac_repo = RbacRepository(db_session) + authorized = await rbac_repo.check_user_has_privilege(test_user.user_id, path, privilege) assert authorized is False - ace = await RbacRepository(db_session).get_ace_by_path("/projects") - ace.propagate = True - await db_session.commit() + await self._get_or_create_projects_ace(db_session, propagate=True) - authorized = await RbacRepository(db_session).check_user_has_privilege(test_user.user_id, path, privilege) + authorized = await rbac_repo.check_user_has_privilege(test_user.user_id, path, privilege) assert authorized is True async def test_allowed(self, test_user: User, db_session: AsyncSession): - ace = await RbacRepository(db_session).get_ace_by_path("/projects") - ace.allowed = False - ace.propagate = True - await db_session.commit() + await self._get_or_create_projects_ace(db_session, propagate=True, allowed=False) privilege = "Project.Audit" path = "/projects/44929147-47bb-460a-90ae-c782c4dbb6ef" diff --git a/tests/controller/test_rbac_state.py b/tests/controller/test_rbac_state.py new file mode 100644 index 000000000..b67bdd3f4 --- /dev/null +++ b/tests/controller/test_rbac_state.py @@ -0,0 +1,209 @@ +# +# Copyright (C) 2026 GNS3 Technologies Inc. +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . +# + +""" +Tests for the in-memory RBAC snapshot: every write through a repository +must be visible to the next permission check (write-through), and the +snapshot must survive a reset (database recreated). +""" + +import uuid + +import pytest +from fastapi import FastAPI +from sqlalchemy.ext.asyncio import AsyncSession + +from gns3server.db.models import User +from gns3server.db.rbac_state import RbacState +from gns3server.db.repositories.pools import ResourcePoolsRepository +from gns3server.db.repositories.rbac import RbacRepository +from gns3server.db.repositories.users import UsersRepository +from gns3server.schemas.controller.pools import ResourceCreate, ResourcePoolCreate +from gns3server.schemas.controller.rbac import ACECreate, RoleCreate +from gns3server.schemas.controller.users import UserGroupCreate + +pytestmark = pytest.mark.asyncio + + +class TestRbacStateWriteThrough: + """ + Each test builds its own rows (unique paths and names) so the file is + order-independent under --random-order. + """ + + async def test_group_membership_change_is_visible(self, test_user: User, db_session: AsyncSession) -> None: + + path = f"/projects/{uuid.uuid4()}" + rbac_repo = RbacRepository(db_session) + users_repo = UsersRepository(db_session) + + group = await users_repo.create_user_group(UserGroupCreate(name=f"group-{uuid.uuid4().hex[:8]}")) + role = await rbac_repo.get_role_by_name("User") + await rbac_repo.create_ace( + ACECreate( + path=path, + ace_type="group", + propagate=False, + group_id=str(group.user_group_id), + role_id=str(role.role_id), + ) + ) + + # the user is not a member of the group yet + assert await rbac_repo.check_user_has_privilege(test_user.user_id, path, "Project.Audit") is False + + await users_repo.add_member_to_user_group(group.user_group_id, test_user) + assert await rbac_repo.check_user_has_privilege(test_user.user_id, path, "Project.Audit") is True + + await users_repo.remove_member_from_user_group(group.user_group_id, test_user) + assert await rbac_repo.check_user_has_privilege(test_user.user_id, path, "Project.Audit") is False + + async def test_role_privilege_change_is_visible(self, test_user: User, db_session: AsyncSession) -> None: + + path = f"/projects/{uuid.uuid4()}" + rbac_repo = RbacRepository(db_session) + users_repo = UsersRepository(db_session) + + # a role without any privilege + role = await rbac_repo.create_role(RoleCreate(name=f"role-{uuid.uuid4().hex[:8]}")) + group_id = (await users_repo.get_user_group_by_name("Users")).user_group_id + await rbac_repo.create_ace( + ACECreate(path=path, ace_type="group", propagate=False, group_id=str(group_id), role_id=str(role.role_id)) + ) + + assert await rbac_repo.check_user_has_privilege(test_user.user_id, path, "Project.Audit") is False + + privilege = await rbac_repo.get_privilege_by_name("Project.Audit") + await rbac_repo.add_privilege_to_role(role.role_id, privilege) + assert await rbac_repo.check_user_has_privilege(test_user.user_id, path, "Project.Audit") is True + + async def test_pool_membership_change_is_visible(self, test_user: User, db_session: AsyncSession) -> None: + + project_id = str(uuid.uuid4()) + rbac_repo = RbacRepository(db_session) + users_repo = UsersRepository(db_session) + pools_repo = ResourcePoolsRepository(db_session) + + pool = await pools_repo.create_resource_pool(ResourcePoolCreate(name=f"pool-{uuid.uuid4().hex[:8]}")) + resource = await pools_repo.create_resource( + ResourceCreate(resource_id=uuid.UUID(project_id), resource_type="project", name=f"project-{project_id[:8]}") + ) + + group_id = (await users_repo.get_user_group_by_name("Users")).user_group_id + role = await rbac_repo.get_role_by_name("User") + await rbac_repo.create_ace( + ACECreate( + path=f"/pools/{pool.resource_pool_id}", + ace_type="group", + propagate=False, + group_id=str(group_id), + role_id=str(role.role_id), + ) + ) + + # the resource is not in the pool yet + assert ( + await rbac_repo.check_user_has_privilege(test_user.user_id, f"/projects/{project_id}", "Project.Audit") + is False + ) + + await pools_repo.add_resource_to_pool(pool.resource_pool_id, resource) + assert ( + await rbac_repo.check_user_has_privilege(test_user.user_id, f"/projects/{project_id}", "Project.Audit") + is True + ) + + async def test_user_ace_denies_group_ace(self, test_user: User, db_session: AsyncSession) -> None: + + path = f"/projects/{uuid.uuid4()}" + rbac_repo = RbacRepository(db_session) + users_repo = UsersRepository(db_session) + + group_id = (await users_repo.get_user_group_by_name("Users")).user_group_id + role = await rbac_repo.get_role_by_name("User") + await rbac_repo.create_ace( + ACECreate(path=path, ace_type="group", propagate=False, group_id=str(group_id), role_id=str(role.role_id)) + ) + assert await rbac_repo.check_user_has_privilege(test_user.user_id, path, "Project.Audit") is True + + # a deny ACE on the user itself replaces the group privileges + await rbac_repo.create_ace( + ACECreate( + path=path, + ace_type="user", + propagate=False, + allowed=False, + user_id=str(test_user.user_id), + role_id=str(role.role_id), + ) + ) + assert await rbac_repo.check_user_has_privilege(test_user.user_id, path, "Project.Audit") is False + + +class TestRbacStateReload: + async def test_dirty_flag_cycle(self, test_user: User, db_session: AsyncSession) -> None: + + state = RbacState.instance() + state.reset() + rbac_repo = RbacRepository(db_session) + users_repo = UsersRepository(db_session) + + path = f"/projects/{uuid.uuid4()}" + await rbac_repo.check_user_has_privilege(test_user.user_id, path, "Project.Audit") + assert state._loaded is True + assert state._dirty is False + + group_id = (await users_repo.get_user_group_by_name("Users")).user_group_id + role = await rbac_repo.get_role_by_name("User") + await rbac_repo.create_ace( + ACECreate(path=path, ace_type="group", propagate=False, group_id=str(group_id), role_id=str(role.role_id)) + ) + assert state._dirty is True + + # the next check reloads the snapshot and clears the flag + assert await rbac_repo.check_user_has_privilege(test_user.user_id, path, "Project.Audit") is True + assert state._dirty is False + + async def test_reset_forces_reload_from_database(self, test_user: User, db_session: AsyncSession) -> None: + + rbac_repo = RbacRepository(db_session) + users_repo = UsersRepository(db_session) + + path = f"/projects/{uuid.uuid4()}" + group_id = (await users_repo.get_user_group_by_name("Users")).user_group_id + role = await rbac_repo.get_role_by_name("User") + await rbac_repo.create_ace( + ACECreate(path=path, ace_type="group", propagate=False, group_id=str(group_id), role_id=str(role.role_id)) + ) + assert await rbac_repo.check_user_has_privilege(test_user.user_id, path, "Project.Audit") is True + + # a reset drops the in-memory data; the next check reloads from the + # database and the ACE is still there + RbacState.instance().reset() + assert await rbac_repo.check_user_has_privilege(test_user.user_id, path, "Project.Audit") is True + + async def test_startup_helper_loads_snapshot( + self, app: FastAPI, db_engine, test_user: User, db_session: AsyncSession + ) -> None: + + from gns3server.db.tasks import load_rbac_state + + RbacState.instance().reset() + app.state._db_engine = db_engine + await load_rbac_state(app) + assert RbacState.instance()._loaded is True + assert RbacState.instance()._dirty is False