mirror of
https://github.com/GNS3/gns3-server.git
synced 2026-11-20 05:05:14 +02:00
By default uvicorn waits for open connections forever. A long-lived streaming response keeps the server waiting after Ctrl+C. One common case is the MCP Streamable HTTP transport: the client opens a standalone GET request and the server answers with an SSE stream (not the old SSE transport). A second Ctrl+C sets force_exit. Uvicorn then skips the lifespan shutdown, so project and controller cleanup does not run. Add timeout_graceful_shutdown. After the timeout uvicorn cancels the remaining tasks and runs the lifespan shutdown. Also make the four notification WebSocket handlers stop when app.state.exiting is set. The HTTP stream handlers already do this.
405 lines
13 KiB
Python
405 lines
13 KiB
Python
#
|
|
# Copyright (C) 2015 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 logging
|
|
import os
|
|
import signal
|
|
import time
|
|
from typing import Dict
|
|
|
|
import psutil
|
|
from fastapi import APIRouter, Depends, FastAPI, Request, WebSocket, WebSocketDisconnect, status
|
|
from fastapi.encoders import jsonable_encoder
|
|
from fastapi.responses import StreamingResponse
|
|
from fastapi.routing import Mount
|
|
from websockets.exceptions import ConnectionClosed, WebSocketException
|
|
|
|
from gns3server import schemas
|
|
from gns3server.agent.web_wireshark.stats import collect_webwireshark_stats
|
|
from gns3server.api.responses import NDJSON_MEDIA_TYPE, NOTIFICATION_STREAM_RESPONSES, NDJSONResponse
|
|
from gns3server.config import Config
|
|
from gns3server.controller import Controller
|
|
from gns3server.controller.controller_error import ControllerError, ControllerForbiddenError
|
|
from gns3server.version import __version__
|
|
|
|
from .dependencies.authentication import get_current_active_user, get_current_active_user_from_websocket
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
router = APIRouter()
|
|
|
|
|
|
def get_server_uptime_seconds() -> int:
|
|
try:
|
|
return max(0, int(time.time() - psutil.Process().create_time()))
|
|
except psutil.Error:
|
|
return 0
|
|
|
|
|
|
@router.get(
|
|
"/version",
|
|
response_model=schemas.Version,
|
|
)
|
|
def get_version(request: Request) -> dict:
|
|
"""
|
|
Return the server version number.
|
|
"""
|
|
|
|
# retrieve the controller host information from the mounted
|
|
# compute subapp
|
|
controller_host = None
|
|
for route in request.app.routes:
|
|
if isinstance(route, Mount) and route.name == "compute" and isinstance(route.app, FastAPI):
|
|
controller_host = route.app.state.controller_host
|
|
|
|
local_server = Config.instance().settings.Server.local
|
|
return {"controller_host": controller_host, "version": __version__, "local": local_server}
|
|
|
|
|
|
@router.post(
|
|
"/version",
|
|
response_model=schemas.Version,
|
|
response_model_exclude_defaults=True,
|
|
responses={409: {"model": schemas.ErrorMessage, "description": "Invalid version"}},
|
|
)
|
|
def check_version(version: schemas.Version) -> dict:
|
|
"""
|
|
Check if version is the same as the server.
|
|
"""
|
|
|
|
if version.version != __version__:
|
|
raise ControllerError(f"Client version {version.version} is not the same as server version {__version__}")
|
|
return {"version": __version__}
|
|
|
|
|
|
@router.post(
|
|
"/reload",
|
|
dependencies=[Depends(get_current_active_user)],
|
|
status_code=status.HTTP_204_NO_CONTENT,
|
|
)
|
|
async def reload() -> None:
|
|
"""
|
|
Reload the controller
|
|
"""
|
|
|
|
await Controller.instance().reload()
|
|
|
|
|
|
@router.post(
|
|
"/shutdown",
|
|
dependencies=[Depends(get_current_active_user)],
|
|
status_code=status.HTTP_204_NO_CONTENT,
|
|
responses={403: {"model": schemas.ErrorMessage, "description": "Server shutdown not allowed"}},
|
|
)
|
|
async def shutdown() -> None:
|
|
"""
|
|
Shutdown the server
|
|
"""
|
|
|
|
if Config.instance().settings.Server.local is False:
|
|
raise ControllerForbiddenError("You can only stop a local server")
|
|
|
|
log.info("Start shutting down the server")
|
|
# close all the projects first
|
|
controller = Controller.instance()
|
|
projects = controller.projects.values()
|
|
|
|
tasks = []
|
|
for project in projects:
|
|
tasks.append(asyncio.ensure_future(project.close()))
|
|
|
|
if tasks:
|
|
done, _ = await asyncio.wait(tasks)
|
|
for future in done:
|
|
try:
|
|
future.result()
|
|
except Exception as e:
|
|
log.error(f"Could not close project: {e}", exc_info=True)
|
|
continue
|
|
|
|
# then shutdown the server itself
|
|
os.kill(os.getpid(), signal.SIGTERM)
|
|
|
|
|
|
@router.get("/iou_license", dependencies=[Depends(get_current_active_user)], response_model=schemas.IOULicense)
|
|
def get_iou_license() -> schemas.IOULicense:
|
|
"""
|
|
Return the IOU license settings
|
|
"""
|
|
|
|
return Controller.instance().iou_license
|
|
|
|
|
|
@router.put(
|
|
"/iou_license",
|
|
dependencies=[Depends(get_current_active_user)],
|
|
status_code=status.HTTP_200_OK,
|
|
response_model=schemas.IOULicense,
|
|
)
|
|
async def update_iou_license(iou_license: schemas.IOULicense) -> schemas.IOULicense:
|
|
"""
|
|
Update the IOU license settings.
|
|
"""
|
|
|
|
controller = Controller().instance()
|
|
current_iou_license = controller.iou_license
|
|
current_iou_license.update(jsonable_encoder(iou_license))
|
|
controller.save()
|
|
return current_iou_license
|
|
|
|
|
|
@router.get(
|
|
"/statistics",
|
|
response_model=schemas.ServerStatistics,
|
|
response_model_exclude_unset=True,
|
|
dependencies=[Depends(get_current_active_user)],
|
|
)
|
|
async def statistics() -> dict:
|
|
"""
|
|
Return server statistics including compute resources, projects, and nodes.
|
|
"""
|
|
|
|
controller = Controller.instance()
|
|
|
|
# Compute statistics (existing behavior)
|
|
compute_statistics = []
|
|
for compute in list(controller.computes.values()):
|
|
try:
|
|
r = await compute.get("/statistics")
|
|
compute_statistics.append({"compute_id": compute.id, "compute_name": compute.name, "statistics": r.json})
|
|
except ControllerError as e:
|
|
log.error(f"Could not retrieve statistics on compute {compute.name}: {e}")
|
|
|
|
# Project statistics
|
|
projects = list(controller.projects.values())
|
|
project_stats = {
|
|
"total": len(projects),
|
|
"opened": sum(1 for p in projects if p.status == "opened"),
|
|
"closed": sum(1 for p in projects if p.status == "closed"),
|
|
}
|
|
|
|
# Node statistics - distinguish open vs closed project nodes
|
|
open_project_nodes = []
|
|
closed_project_nodes = []
|
|
node_by_type: Dict[str, int] = {}
|
|
node_by_status: Dict[str, int] = {}
|
|
|
|
for project in projects:
|
|
nodes = project.nodes.values()
|
|
if project.status == "closed":
|
|
closed_project_nodes.extend(nodes)
|
|
else:
|
|
open_project_nodes.extend(nodes)
|
|
|
|
# Open project nodes have real status
|
|
for node in open_project_nodes:
|
|
node_type = getattr(node, "node_type", "unknown")
|
|
node_status = getattr(node, "status", "unknown")
|
|
node_by_type[node_type] = node_by_type.get(node_type, 0) + 1
|
|
node_by_status[node_status] = node_by_status.get(node_status, 0) + 1
|
|
|
|
# Closed project nodes don't have status, count them separately
|
|
for node in closed_project_nodes:
|
|
if isinstance(node, dict):
|
|
node_type = node.get("node_type", "unknown")
|
|
else:
|
|
node_type = getattr(node, "node_type", "unknown")
|
|
node_by_type[node_type] = node_by_type.get(node_type, 0) + 1
|
|
|
|
node_stats = {
|
|
"total": len(open_project_nodes) + len(closed_project_nodes),
|
|
"open_project_nodes": len(open_project_nodes),
|
|
"closed_project_nodes": len(closed_project_nodes),
|
|
"by_type": node_by_type,
|
|
"by_status": node_by_status,
|
|
}
|
|
|
|
# Link statistics
|
|
all_links = []
|
|
for project in projects:
|
|
all_links.extend(project.links.values())
|
|
|
|
def is_capturing(link):
|
|
if hasattr(link, "capturing"):
|
|
return link.capturing
|
|
if isinstance(link, dict):
|
|
return link.get("capturing", False)
|
|
return False
|
|
|
|
link_capturing = sum(1 for link in all_links if is_capturing(link))
|
|
|
|
link_stats = {
|
|
"total": len(all_links),
|
|
"capturing": link_capturing,
|
|
}
|
|
|
|
# Web Wireshark container statistics
|
|
webwireshark_stats = await collect_webwireshark_stats(projects)
|
|
|
|
return {
|
|
"uptime_seconds": get_server_uptime_seconds(),
|
|
"computes": compute_statistics,
|
|
"projects": project_stats,
|
|
"nodes": node_stats,
|
|
"links": link_stats,
|
|
"webwireshark": webwireshark_stats,
|
|
}
|
|
|
|
|
|
@router.get(
|
|
"/notifications",
|
|
dependencies=[Depends(get_current_active_user)],
|
|
response_class=NDJSONResponse,
|
|
responses=NOTIFICATION_STREAM_RESPONSES,
|
|
)
|
|
async def controller_http_notifications(request: Request) -> StreamingResponse:
|
|
"""
|
|
Receive controller notifications from an HTTP stream of newline delimited JSON objects (see the Notification schema).
|
|
|
|
The same messages are available as WebSocket text frames on `/v3/notifications/ws`.
|
|
Controller actions: `compute.*`, `template.*`, `project.created`, `project.updated`, `project.opened`,
|
|
`project.closed`, `project.deleted`, `settings.updated`, `log.*` and `ping`.
|
|
"""
|
|
|
|
from gns3server.api.server import app
|
|
|
|
client = f"{request.client.host}:{request.client.port}" if request.client else "unknown"
|
|
log.info(f"New client {client} has connected to controller HTTP notification stream")
|
|
|
|
async def event_stream():
|
|
try:
|
|
with Controller.instance().notification.controller_queue() as queue:
|
|
while not app.state.exiting:
|
|
msg = await queue.get_json(5)
|
|
yield f"{msg}\n".encode()
|
|
finally:
|
|
log.info(f"Client {client} has disconnected from controller HTTP notification stream")
|
|
|
|
return StreamingResponse(event_stream(), media_type=NDJSON_MEDIA_TYPE)
|
|
|
|
|
|
@router.websocket("/notifications/ws")
|
|
async def controller_ws_notifications(
|
|
websocket: WebSocket, current_user: schemas.User = Depends(get_current_active_user_from_websocket)
|
|
) -> None:
|
|
"""
|
|
Receive controller notifications from a WebSocket, one Notification JSON object per text frame.
|
|
Same messages as the HTTP stream `/v3/notifications`.
|
|
"""
|
|
|
|
if current_user is None:
|
|
return
|
|
|
|
client = f"{websocket.client.host}:{websocket.client.port}" if websocket.client else "unknown"
|
|
log.info(f"New client {client} has connected to controller WebSocket")
|
|
try:
|
|
with Controller.instance().notification.controller_queue() as queue:
|
|
while not websocket.app.state.exiting:
|
|
notification = await queue.get_json(5)
|
|
await websocket.send_text(notification)
|
|
except (ConnectionClosed, WebSocketDisconnect):
|
|
log.info(f"Client {client} has disconnected from controller WebSocket")
|
|
except WebSocketException as e:
|
|
log.warning(f"Error while sending to controller event to WebSocket client: {e}")
|
|
|
|
|
|
# @Route.post(
|
|
# r"/debug",
|
|
# description="Dump debug information to disk (debug directory in config directory). Work only for local server",
|
|
# status_codes={
|
|
# 201: "Written"
|
|
# })
|
|
# async def debug(request, response):
|
|
#
|
|
# config = Config.instance()
|
|
# if config.get_section_config("Server").getboolean("local", False) is False:
|
|
# raise ControllerForbiddenError("You can only debug a local server")
|
|
#
|
|
# debug_dir = os.path.join(config.config_dir, "debug")
|
|
# try:
|
|
# if os.path.exists(debug_dir):
|
|
# shutil.rmtree(debug_dir)
|
|
# os.makedirs(debug_dir)
|
|
# with open(os.path.join(debug_dir, "controller.txt"), "w+") as f:
|
|
# f.write(ServerHandler._getDebugData())
|
|
# except Exception as e:
|
|
# # If something is wrong we log the info to the log and we hope the log will be include correctly to the debug export
|
|
# log.error("Could not export debug information {}".format(e), exc_info=1)
|
|
#
|
|
# for compute in list(Controller.instance().computes.values()):
|
|
# try:
|
|
# r = await compute.get("/debug", raw=True)
|
|
# data = r.body.decode("utf-8")
|
|
# except Exception as e:
|
|
# data = str(e)
|
|
# with open(os.path.join(debug_dir, "compute_{}.txt".format(compute.id)), "w+") as f:
|
|
# f.write("Compute ID: {}\n".format(compute.id))
|
|
# f.write(data)
|
|
#
|
|
# response.set_status(201)
|
|
#
|
|
# @staticmethod
|
|
# def _getDebugData():
|
|
# try:
|
|
# connections = psutil.net_connections()
|
|
# # You need to be root for OSX
|
|
# except psutil.AccessDenied:
|
|
# connections = None
|
|
#
|
|
# try:
|
|
# addrs = ["* {}: {}".format(key, val) for key, val in psutil.net_if_addrs().items()]
|
|
# except UnicodeDecodeError:
|
|
# addrs = ["INVALID ADDR WITH UNICODE CHARACTERS"]
|
|
#
|
|
# data = """Version: {version}
|
|
# OS: {os}
|
|
# Python: {python}
|
|
# CPU: {cpu}
|
|
# Memory: {memory}
|
|
#
|
|
# Networks:
|
|
# {addrs}
|
|
#
|
|
# Open connections:
|
|
# {connections}
|
|
#
|
|
# Processus:
|
|
# """.format(
|
|
# version=__version__,
|
|
# os=platform.platform(),
|
|
# python=platform.python_version(),
|
|
# memory=psutil.virtual_memory(),
|
|
# cpu=psutil.cpu_times(),
|
|
# connections=connections,
|
|
# addrs="\n".join(addrs)
|
|
# )
|
|
# for proc in psutil.process_iter():
|
|
# try:
|
|
# psinfo = proc.as_dict(attrs=["name", "exe"])
|
|
# data += "* {} {}\n".format(psinfo["name"], psinfo["exe"])
|
|
# except psutil.NoSuchProcess:
|
|
# pass
|
|
#
|
|
# data += "\n\nProjects"
|
|
# for project in Controller.instance().projects.values():
|
|
# data += "\n\nProject name: {}\nProject ID: {}\n".format(project.name, project.id)
|
|
# if project.status != "closed":
|
|
# for link in project.links.values():
|
|
# data += "Link {}: {}".format(link.id, link.debug_link_data)
|
|
#
|
|
# return data
|