mirror of
https://github.com/GNS3/gns3-server.git
synced 2026-10-13 05:55:35 +03:00
c7ffe919dc
A VPCS node's single adapter anchors on a persistent TAP the server
creates (tap create + set_owner via uBridge) and the vpcs process
attaches to by name: -e -d <gp{id8}e0p0> -n, the same
server-creates/guest-attaches shape as QEMU's netdev. -n (a vpcs fork
feature) keeps the guest's ip command from ifconfig'ing the anchor on
the host; the vpcs build is probed once per binary identity
(vpcs_tap capability, usage scan) and gates kernel links together
with ubridge_tap — anything else keeps the node on the relay (the
legacy local UDP tunnel on a stock binary, an AF_PACKET endpoint on
the anchor with a capable one).
VPCSVM takes KernelDatapathMixin: _connect_nio dispatches kernel
(enslave into the per-link bridge) / relay-on-anchor / legacy,
captures pick capture start_kernel vs the bridge engine, stop runs
under an execute lock and terminates the process before deleting the
anchor TAPs (a held device refuses deletion), and the duplicate-port
guard backstops the controller's. The NIO routes accept nio_bridge
and write suspend back on update.
_delete_anchor_taps verifies each tap is gone from sysfs and retries
a bounded three times: a holder can release its fd a moment after its
process was reaped (vpcs's daemon parent kills its console child and
exits first), so the unconditional delete raced EBUSY and leaked the
anchor intermittently.
The vpcs side needs IFNAMSIZ (16) instead of its own IFNAMESIZ (12)
for the -d name buffer — anchor names are 14 chars and truncated to a
nonexistent device, which TUNSETIFF then tries to create without
CAP_NET_ADMIN (fixed in the vpcs fork).
e2e (tests/e2e/test_vpcs_kernel_datapath.py): kernel and relay
scenarios green against the real binary — real ICMP both ways, §E.1/§
E.2 on the anchors, delay/suspend/capture, link delete/re-create,
node stop/restart self-heal, zero leftovers; the relay control passes
with both the fork binary and a stock one.
95 lines
3.4 KiB
Python
95 lines
3.4 KiB
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/>.
|
|
|
|
"""
|
|
API routes for capabilities
|
|
"""
|
|
|
|
import sys
|
|
|
|
import psutil
|
|
from fastapi import APIRouter, Request
|
|
|
|
from gns3server import schemas
|
|
from gns3server.compute import MODULES
|
|
from gns3server.compute.ubridge.tc_probe import (
|
|
probe_bridge_tap_support,
|
|
probe_iol_tap_support,
|
|
probe_tap_support,
|
|
probe_tc_capabilities,
|
|
)
|
|
from gns3server.compute.vpcs.vpcs_probe import probe_vpcs_tap
|
|
from gns3server.utils.path import get_default_project_directory
|
|
from gns3server.utils.tc_capabilities import usable_ebpf_modes
|
|
from gns3server.version import __version__
|
|
|
|
router = APIRouter()
|
|
|
|
|
|
@router.get("/capabilities", response_model=schemas.Capabilities)
|
|
async def get_capabilities(request: Request) -> dict:
|
|
|
|
node_types = []
|
|
for module in MODULES:
|
|
node_types.extend(module.node_types())
|
|
|
|
# Kernel-datapath packet filters: what this host's uBridge can run,
|
|
# probed as the server's own user (None = unknown, old/missing uBridge).
|
|
ubridge_tc = None
|
|
caps = await probe_tc_capabilities()
|
|
if caps:
|
|
ubridge_tc = {
|
|
"netem": [keyword for keyword in caps.get("netem", "").split(",") if keyword],
|
|
"ebpf": caps.get("ebpf") == "1",
|
|
"ebpf_modes": list(usable_ebpf_modes(caps)),
|
|
"cbpf": caps.get("cbpf") == "1",
|
|
}
|
|
|
|
# Persistent TAP support: the anchor QEMU adapters need for the kernel
|
|
# datapath. None = unknown (probe failed or uBridge too old).
|
|
ubridge_tap = await probe_tap_support()
|
|
|
|
# IOL-port TAP termination (iol_bridge add_nio_tap): the anchor IOU's
|
|
# Ethernet ports need for the kernel datapath. None = unknown.
|
|
ubridge_iol_tap = await probe_iol_tap_support()
|
|
|
|
# Swappable TAP leg on the generic bridge module (bridge delete_nio_tap):
|
|
# what lets an IOL runner container's per-port bridge carry a kernel-link
|
|
# anchor. None = unknown (probe failed or uBridge too old).
|
|
ubridge_bridge_tap = await probe_bridge_tap_support()
|
|
|
|
# VPCS tap-mode anchoring (-e -d with -n): what lets a VPCS node carry a
|
|
# kernel link. None = unknown (probe failed or binary missing).
|
|
vpcs_tap = await probe_vpcs_tap()
|
|
|
|
# record the controller hostname or IP address
|
|
if request.client:
|
|
request.app.state.controller_host = request.client.host
|
|
|
|
return {
|
|
"version": __version__,
|
|
"platform": sys.platform,
|
|
"cpus": psutil.cpu_count(logical=True),
|
|
"memory": psutil.virtual_memory().total,
|
|
"disk_size": psutil.disk_usage(get_default_project_directory()).total,
|
|
"node_types": node_types,
|
|
"ubridge_tc": ubridge_tc,
|
|
"ubridge_tap": ubridge_tap,
|
|
"ubridge_iol_tap": ubridge_iol_tap,
|
|
"ubridge_bridge_tap": ubridge_bridge_tap,
|
|
"vpcs_tap": vpcs_tap,
|
|
}
|