Files
gns3-server/gns3server/core/tasks.py
T
YueGuobin 2244d730bb perf: keep RBAC state in memory for permission checks
Permission checks ran several queries per request, including a full
scan of the resources table. The controller already keeps projects,
computes and notifications in process memory: apply the same idea to
the RBAC tables.

Roles, ACEs, group memberships and resource pool memberships are
loaded into a process-wide snapshot. Checks run against the snapshot
in memory. Repository write methods mark the snapshot dirty and the
next read reloads it from the database, so privilege changes apply
right away. The database stays the source of truth.

The evaluation is a faithful port of the previous SQL version, quirks
included (reverse path traversal, deny raising PermissionError, pool
checks with the "/pool" prefix, group ACEs in natural order).

The two RBAC tests that mutated ORM objects directly now write through
the repository, like the rest of the code. The /projects ACE they
relied on was created by another test, so they were order dependent:
they now create it when missing.
2026-11-06 23:47:29 +08:00

137 lines
4.5 KiB
Python

#!/usr/bin/env python
#
# Copyright (C) 2020 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 <http://www.gnu.org/licenses/>.
import asyncio
import contextlib
import logging
from contextlib import asynccontextmanager
from fastapi import FastAPI
from gns3server.compute import MODULES
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, load_rbac_state
from gns3server.services.image_reconciliation import get_image_reconciliation_service
from gns3server.utils.http_client import HTTPClient
log = logging.getLogger(__name__)
@asynccontextmanager
async def lifespan(app: FastAPI):
# The MCP Streamable HTTP session manager runs for the app's whole
# lifetime (mounted sub-app lifespans are not executed by Starlette).
# Entered before startup so it is running before the MCP ready gate opens.
from gns3server.agent import MCP_AVAILABLE
async with contextlib.AsyncExitStack() as stack:
if MCP_AVAILABLE:
from gns3server.agent.mcp import mcp_session_manager_lifespan
await stack.enter_async_context(mcp_session_manager_lifespan())
await startup(app)
try:
yield
finally:
await shutdown(app)
async def startup(app: FastAPI) -> None:
"""
Tasks to be performed when the server is starting.
"""
loop = asyncio.get_event_loop()
logger = logging.getLogger("asyncio")
logger.setLevel(logging.ERROR)
if log.getEffectiveLevel() == logging.DEBUG:
# On debug version we enable info that
# coroutine is not called in a way await/await
loop.set_debug(True)
# connect to the database
await connect_to_db(app)
# 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()
for module in MODULES:
log.debug(f"Loading module {module.__name__}")
m = module.instance()
m.port_manager = PortManager.instance()
# Start the marker (traffic-insight) UDP sink. One listener per compute
# process receives ubridge MARK signals; ubridges are told its host/port at
# startup (see BaseNode._start_ubridge).
server_settings = Config.instance().settings.Server
await MarkerManager.instance().start(
host=server_settings.marker_listen_host, port=server_settings.marker_listen_port
)
# Mark MCP server as ready to accept connections (if MCP is available)
from gns3server.agent import MCP_AVAILABLE
if MCP_AVAILABLE:
from gns3server.agent.mcp import set_mcp_server_ready
set_mcp_server_ready(True)
log.info("GNS3 server startup completed")
async def shutdown(app: FastAPI) -> None:
"""
Tasks to be performed when the server is exiting.
"""
service = getattr(app.state, "image_reconciliation", None)
if service is not None:
await service.close()
del app.state.image_reconciliation
await HTTPClient.close_session()
await MarkerManager.instance().stop()
# Kill resident sharkd sessions (marker replay) and drop their /tmp
# scratch copies before the process exits.
from gns3server.controller import marker_replay
await marker_replay.close_sessions()
await Controller.instance().stop()
for module in MODULES:
log.debug(f"Unloading module {module.__name__}")
m = module.instance()
await m.unload()
if PortManager.instance().tcp_ports:
log.warning(f"TCP ports are still used {PortManager.instance().tcp_ports}")
if PortManager.instance().udp_ports:
log.warning(f"UDP ports are still used {PortManager.instance().udp_ports}")
await disconnect_from_db(app)