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