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