Move endpoints to routes & preparations to use a database.

gns3server/api/routes/compute/atm_switch_nodes.py

@@ -0,0 +1,227 @@
+# -*- coding: utf-8 -*-
+#
+# 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 ATM switch nodes.
+"""
+
+import os
+
+from fastapi import APIRouter, Depends, Body, status
+from fastapi.encoders import jsonable_encoder
+from fastapi.responses import StreamingResponse
+from uuid import UUID
+
+from gns3server import schemas
+from gns3server.compute.dynamips import Dynamips
+from gns3server.compute.dynamips.nodes.atm_switch import ATMSwitch
+
+router = APIRouter()
+
+responses = {
+    404: {"model": schemas.ErrorMessage, "description": "Could not find project or ATM switch node"}
+}
+
+
+async def dep_node(project_id: UUID, node_id: UUID):
+    """
+    Dependency to retrieve a node.
+    """
+
+    dynamips_manager = Dynamips.instance()
+    node = dynamips_manager.get_node(str(node_id), project_id=str(project_id))
+    return node
+
+
+@router.post("",
+             response_model=schemas.ATMSwitch,
+             status_code=status.HTTP_201_CREATED,
+             responses={409: {"model": schemas.ErrorMessage, "description": "Could not create ATM switch node"}})
+async def create_atm_switch(project_id: UUID, node_data: schemas.ATMSwitchCreate):
+    """
+    Create a new ATM switch node.
+    """
+
+    # Use the Dynamips ATM switch to simulate this node
+    dynamips_manager = Dynamips.instance()
+    node_data = jsonable_encoder(node_data, exclude_unset=True)
+    node = await dynamips_manager.create_node(node_data.pop("name"),
+                                              str(project_id),
+                                              node_data.get("node_id"),
+                                              node_type="atm_switch",
+                                              mappings=node_data.get("mappings"))
+    return node.__json__()
+
+
+@router.get("/{node_id}",
+            response_model=schemas.ATMSwitch,
+            responses=responses)
+def get_atm_switch(node: ATMSwitch = Depends(dep_node)):
+    """
+    Return an ATM switch node.
+    """
+
+    return node.__json__()
+
+
+@router.post("/{node_id}/duplicate",
+             response_model=schemas.ATMSwitch,
+             status_code=status.HTTP_201_CREATED,
+             responses=responses)
+async def duplicate_atm_switch(destination_node_id: UUID = Body(..., embed=True), node: ATMSwitch = Depends(dep_node)):
+    """
+    Duplicate an ATM switch node.
+    """
+
+    new_node = await Dynamips.instance().duplicate_node(node.id, str(destination_node_id))
+    return new_node.__json__()
+
+
+@router.put("/{node_id}",
+            response_model=schemas.ATMSwitch,
+            responses=responses)
+async def update_atm_switch(node_data: schemas.ATMSwitchUpdate, node: ATMSwitch = Depends(dep_node)):
+    """
+    Update an ATM switch node.
+    """
+
+    node_data = jsonable_encoder(node_data, exclude_unset=True)
+    if "name" in node_data and node.name != node_data["name"]:
+        await node.set_name(node_data["name"])
+    if "mappings" in node_data:
+        node.mappings = node_data["mappings"]
+    node.updated()
+    return node.__json__()
+
+
+@router.delete("/{node_id}",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_atm_switch_node(node: ATMSwitch = Depends(dep_node)):
+    """
+    Delete an ATM switch node.
+    """
+
+    await Dynamips.instance().delete_node(node.id)
+
+
+@router.post("/{node_id}/start",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+def start_atm_switch(node: ATMSwitch = Depends(dep_node)):
+    """
+    Start an ATM switch node.
+    This endpoint results in no action since ATM switch nodes are always on.
+    """
+
+    pass
+
+
+@router.post("/{node_id}/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+def stop_atm_switch(node: ATMSwitch = Depends(dep_node)):
+    """
+    Stop an ATM switch node.
+    This endpoint results in no action since ATM switch nodes are always on.
+    """
+
+    pass
+
+
+@router.post("/{node_id}/suspend",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+def suspend_atm_switch(node: ATMSwitch = Depends(dep_node)):
+    """
+    Suspend an ATM switch node.
+    This endpoint results in no action since ATM switch nodes are always on.
+    """
+
+    pass
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+             status_code=status.HTTP_201_CREATED,
+             response_model=schemas.UDPNIO,
+             responses=responses)
+async def create_nio(adapter_number: int,
+                     port_number: int,
+                     nio_data: schemas.UDPNIO,
+                     node: ATMSwitch = Depends(dep_node)):
+    """
+    Add a NIO (Network Input/Output) to the node.
+    The adapter number on the switch is always 0.
+    """
+
+    nio = await Dynamips.instance().create_nio(node, jsonable_encoder(nio_data, exclude_unset=True))
+    await node.add_nio(nio, port_number)
+    return nio.__json__()
+
+
+@router.delete("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_nio(adapter_number: int, port_number: int, node: ATMSwitch = Depends(dep_node)):
+    """
+    Remove a NIO (Network Input/Output) from the node.
+    The adapter number on the switch is always 0.
+    """
+
+    nio = await node.remove_nio(port_number)
+    await nio.delete()
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/start",
+             responses=responses)
+async def start_capture(adapter_number: int,
+                        port_number: int,
+                        node_capture_data: schemas.NodeCapture,
+                        node: ATMSwitch = Depends(dep_node)):
+    """
+    Start a packet capture on the node.
+    The adapter number on the switch is always 0.
+    """
+
+    pcap_file_path = os.path.join(node.project.capture_working_directory(), node_capture_data.capture_file_name)
+    await node.start_capture(port_number, pcap_file_path, node_capture_data.data_link_type)
+    return {"pcap_file_path": pcap_file_path}
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/stop_capture",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def stop_capture(adapter_number: int, port_number: int, node: ATMSwitch = Depends(dep_node)):
+    """
+    Stop a packet capture on the node.
+    The adapter number on the switch is always 0.
+    """
+
+    await node.stop_capture(port_number)
+
+
+@router.get("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/stream",
+            responses=responses)
+async def stream_pcap_file(adapter_number: int, port_number: int, node: ATMSwitch = Depends(dep_node)):
+    """
+    Stream the pcap capture file.
+    The adapter number on the switch is always 0.
+    """
+
+    nio = node.get_nio(port_number)
+    stream = Dynamips.instance().stream_pcap_file(nio, node.project.id)
+    return StreamingResponse(stream, media_type="application/vnd.tcpdump.pcap")

gns3server/api/routes/compute/capabilities.py

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+#
+# 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
+
+from gns3server.version import __version__
+from gns3server.compute import MODULES
+from gns3server.utils.path import get_default_project_directory
+from gns3server import schemas
+
+router = APIRouter()
+
+
+@router.get("/capabilities",
+            response_model=schemas.Capabilities
+)
+def get_compute_capabilities():
+
+    node_types = []
+    for module in MODULES:
+        node_types.extend(module.node_types())
+
+    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}

gns3server/api/routes/compute/cloud_nodes.py

@@ -0,0 +1,238 @@
+# -*- coding: utf-8 -*-
+#
+# 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 cloud nodes.
+"""
+
+import os
+
+from fastapi import APIRouter, Depends, status
+from fastapi.encoders import jsonable_encoder
+from fastapi.responses import StreamingResponse
+from typing import Union
+from uuid import UUID
+
+from gns3server import schemas
+from gns3server.compute.builtin import Builtin
+from gns3server.compute.builtin.nodes.cloud import Cloud
+
+router = APIRouter()
+
+responses = {
+    404: {"model": schemas.ErrorMessage, "description": "Could not find project or cloud node"}
+}
+
+
+def dep_node(project_id: UUID, node_id: UUID):
+    """
+    Dependency to retrieve a node.
+    """
+
+    builtin_manager = Builtin.instance()
+    node = builtin_manager.get_node(str(node_id), project_id=str(project_id))
+    return node
+
+
+@router.post("",
+             response_model=schemas.Cloud,
+             status_code=status.HTTP_201_CREATED,
+             responses={409: {"model": schemas.ErrorMessage, "description": "Could not create cloud node"}})
+async def create_cloud(project_id: UUID, node_data: schemas.CloudCreate):
+    """
+    Create a new cloud node.
+    """
+
+    builtin_manager = Builtin.instance()
+    node_data = jsonable_encoder(node_data, exclude_unset=True)
+    node = await builtin_manager.create_node(node_data.pop("name"),
+                                             str(project_id),
+                                             node_data.get("node_id"),
+                                             node_type="cloud",
+                                             ports=node_data.get("ports_mapping"))
+
+    # add the remote console settings
+    node.remote_console_host = node_data.get("remote_console_host", node.remote_console_host)
+    node.remote_console_port = node_data.get("remote_console_port", node.remote_console_port)
+    node.remote_console_type = node_data.get("remote_console_type", node.remote_console_type)
+    node.remote_console_http_path = node_data.get("remote_console_http_path", node.remote_console_http_path)
+    node.usage = node_data.get("usage", "")
+    return node.__json__()
+
+
+@router.get("/{node_id}",
+            response_model=schemas.Cloud,
+            responses=responses)
+def get_cloud(node: Cloud = Depends(dep_node)):
+    """
+    Return a cloud node.
+    """
+
+    return node.__json__()
+
+
+@router.put("/{node_id}",
+            response_model=schemas.Cloud,
+            responses=responses)
+def update_cloud(node_data: schemas.CloudUpdate, node: Cloud = Depends(dep_node)):
+    """
+    Update a cloud node.
+    """
+
+    node_data = jsonable_encoder(node_data, exclude_unset=True)
+    for name, value in node_data.items():
+        if hasattr(node, name) and getattr(node, name) != value:
+            setattr(node, name, value)
+    node.updated()
+    return node.__json__()
+
+
+@router.delete("/{node_id}",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_node(node: Cloud = Depends(dep_node)):
+    """
+    Delete a cloud node.
+    """
+
+    await Builtin.instance().delete_node(node.id)
+
+
+@router.post("/{node_id}/start",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def start_cloud(node: Cloud = Depends(dep_node)):
+    """
+    Start a cloud node.
+    """
+
+    await node.start()
+
+
+@router.post("/{node_id}/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def stop_cloud(node: Cloud = Depends(dep_node)):
+    """
+    Stop a cloud node.
+    This endpoint results in no action since cloud nodes cannot be stopped.
+    """
+
+    pass
+
+
+@router.post("/{node_id}/suspend",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def suspend_cloud(node: Cloud = Depends(dep_node)):
+    """
+    Suspend a cloud node.
+    This endpoint results in no action since cloud nodes cannot be suspended.
+    """
+
+    pass
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+             status_code=status.HTTP_201_CREATED,
+             response_model=Union[schemas.EthernetNIO, schemas.TAPNIO, schemas.UDPNIO],
+             responses=responses)
+async def create_nio(adapter_number: int,
+                     port_number: int,
+                     nio_data: Union[schemas.EthernetNIO, schemas.TAPNIO, schemas.UDPNIO],
+                     node: Cloud = Depends(dep_node)):
+    """
+    Add a NIO (Network Input/Output) to the node.
+    The adapter number on the cloud is always 0.
+    """
+
+    nio = Builtin.instance().create_nio(jsonable_encoder(nio_data, exclude_unset=True))
+    await node.add_nio(nio, port_number)
+    return nio.__json__()
+
+
+@router.put("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+            status_code=status.HTTP_201_CREATED,
+            response_model=Union[schemas.EthernetNIO, schemas.TAPNIO, schemas.UDPNIO],
+            responses=responses)
+async def update_nio(adapter_number: int,
+                     port_number: int,
+                     nio_data: Union[schemas.EthernetNIO, schemas.TAPNIO, schemas.UDPNIO],
+                     node: Cloud = Depends(dep_node)):
+    """
+    Update a NIO (Network Input/Output) to the node.
+    The adapter number on the cloud is always 0.
+    """
+
+    nio = node.get_nio(port_number)
+    if nio_data.filters:
+        nio.filters = nio_data.filters
+    await node.update_nio(port_number, nio)
+    return nio.__json__()
+
+
+@router.delete("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_nio(adapter_number: int, port_number: int, node: Cloud = Depends(dep_node)):
+    """
+    Remove a NIO (Network Input/Output) from the node.
+    The adapter number on the cloud is always 0.
+    """
+
+    await node.remove_nio(port_number)
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/start",
+             responses=responses)
+async def start_capture(adapter_number: int,
+                        port_number: int,
+                        node_capture_data: schemas.NodeCapture,
+                        node: Cloud = Depends(dep_node)):
+    """
+    Start a packet capture on the node.
+    The adapter number on the cloud is always 0.
+    """
+
+    pcap_file_path = os.path.join(node.project.capture_working_directory(), node_capture_data.capture_file_name)
+    await node.start_capture(port_number, pcap_file_path, node_capture_data.data_link_type)
+    return {"pcap_file_path": pcap_file_path}
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def stop_capture(adapter_number: int, port_number: int, node: Cloud = Depends(dep_node)):
+    """
+    Stop a packet capture on the node.
+    The adapter number on the cloud is always 0.
+    """
+
+    await node.stop_capture(port_number)
+
+
+@router.get("/{node_id}/adapters/{adapter_number}/ports/{port_number}/pcap",
+            responses=responses)
+async def stream_pcap_file(adapter_number: int, port_number: int, node: Cloud = Depends(dep_node)):
+    """
+    Stream the pcap capture file.
+    The adapter number on the cloud is always 0.
+    """
+
+    nio = node.get_nio(port_number)
+    stream = Builtin.instance().stream_pcap_file(nio, node.project.id)
+    return StreamingResponse(stream, media_type="application/vnd.tcpdump.pcap")

gns3server/api/routes/compute/compute.py

@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+#
+# 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 compute.
+"""
+
+import os
+import psutil
+
+from gns3server.config import Config
+from gns3server.utils.cpu_percent import CpuPercent
+from gns3server.version import __version__
+from gns3server.utils.path import get_default_project_directory
+from gns3server.compute.port_manager import PortManager
+from gns3server.compute.project_manager import ProjectManager
+from gns3server.utils.interfaces import interfaces
+from gns3server.compute.qemu import Qemu
+from gns3server.compute.virtualbox import VirtualBox
+from gns3server.compute.vmware import VMware
+from gns3server import schemas
+
+from fastapi import APIRouter, HTTPException, Body, status
+from fastapi.encoders import jsonable_encoder
+from uuid import UUID
+from typing import Optional, List
+
+router = APIRouter()
+
+
+@router.post("/projects/{project_id}/ports/udp",
+             status_code=status.HTTP_201_CREATED)
+def allocate_udp_port(project_id: UUID) -> dict:
+    """
+    Allocate an UDP port on the compute.
+    """
+
+    pm = ProjectManager.instance()
+    project = pm.get_project(str(project_id))
+    m = PortManager.instance()
+    udp_port = m.get_free_udp_port(project)
+    return {"udp_port": udp_port}
+
+
+@router.get("/network/interfaces")
+def network_interfaces() -> dict:
+    """
+    List all the network interfaces available on the compute"
+    """
+
+    network_interfaces = interfaces()
+    return network_interfaces
+
+
+@router.get("/network/ports")
+def network_ports() -> dict:
+    """
+    List all the ports used on the compute"
+    """
+
+    m = PortManager.instance()
+    return m.__json__()
+
+
+@router.get("/version")
+def version() -> dict:
+    """
+    Retrieve the server version number.
+    """
+
+    config = Config.instance()
+    local_server = config.get_section_config("Server").getboolean("local", False)
+    return {"version": __version__, "local": local_server}
+
+
+@router.get("/statistics")
+def statistics() -> dict:
+    """
+    Retrieve the server version number.
+    """
+
+    try:
+        memory_total = psutil.virtual_memory().total
+        memory_free = psutil.virtual_memory().available
+        memory_used = memory_total - memory_free  # actual memory usage in a cross platform fashion
+        swap_total = psutil.swap_memory().total
+        swap_free = psutil.swap_memory().free
+        swap_used = psutil.swap_memory().used
+        cpu_percent = int(CpuPercent.get())
+        load_average_percent = [int(x / psutil.cpu_count() * 100) for x in psutil.getloadavg()]
+        memory_percent = int(psutil.virtual_memory().percent)
+        swap_percent = int(psutil.swap_memory().percent)
+        disk_usage_percent = int(psutil.disk_usage(get_default_project_directory()).percent)
+    except psutil.Error as e:
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR)
+        #raise HTTPConflict(text="Psutil error detected: {}".format(e))
+
+    return {"memory_total": memory_total,
+            "memory_free": memory_free,
+            "memory_used": memory_used,
+            "swap_total": swap_total,
+            "swap_free": swap_free,
+            "swap_used": swap_used,
+            "cpu_usage_percent": cpu_percent,
+            "memory_usage_percent": memory_percent,
+            "swap_usage_percent": swap_percent,
+            "disk_usage_percent": disk_usage_percent,
+            "load_average_percent": load_average_percent}
+
+
+@router.get("/qemu/binaries")
+async def get_binaries(archs: Optional[List[str]] = Body(None, embed=True)):
+
+    return await Qemu.binary_list(archs)
+
+
+@router.get("/qemu/img-binaries")
+async def get_img_binaries():
+
+    return await Qemu.img_binary_list()
+
+
+@router.get("/qemu/capabilities")
+async def get_capabilities() -> dict:
+    capabilities = {"kvm": []}
+    kvms = await Qemu.get_kvm_archs()
+    if kvms:
+        capabilities["kvm"] = kvms
+    return capabilities
+
+
+@router.post("/qemu/img",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses={403: {"model": schemas.ErrorMessage, "description": "Forbidden to create Qemu image"}})
+async def create_img(image_data: schemas.QemuImageCreate):
+    """
+    Create a Qemu image.
+    """
+
+    if os.path.isabs(image_data.path):
+        config = Config.instance()
+        if config.get_section_config("Server").getboolean("local", False) is False:
+            raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)
+
+    await Qemu.instance().create_disk(image_data.qemu_img, image_data.path, jsonable_encoder(image_data, exclude_unset=True))
+
+
+@router.put("/qemu/img",
+            status_code=status.HTTP_204_NO_CONTENT,
+            responses={403: {"model": schemas.ErrorMessage, "description": "Forbidden to update Qemu image"}})
+async def update_img(image_data: schemas.QemuImageUpdate):
+    """
+    Update a Qemu image.
+    """
+
+    if os.path.isabs(image_data.path):
+        config = Config.instance()
+        if config.get_section_config("Server").getboolean("local", False) is False:
+            raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)
+
+    if image_data.extend:
+        await Qemu.instance().resize_disk(image_data.qemu_img, image_data.path, image_data.extend)
+
+
+@router.get("/virtualbox/vms",
+            response_model=List[dict])
+async def get_virtualbox_vms():
+
+    vbox_manager = VirtualBox.instance()
+    return await vbox_manager.list_vms()
+
+
+@router.get("/vmware/vms",
+            response_model=List[dict])
+async def get_vms():
+    vmware_manager = VMware.instance()
+    return await vmware_manager.list_vms()
+

gns3server/api/routes/compute/docker_nodes.py

@@ -0,0 +1,320 @@
+# -*- coding: utf-8 -*-
+#
+# 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 Docker nodes.
+"""
+
+import os
+
+from fastapi import APIRouter, WebSocket, Depends, Body, status
+from fastapi.encoders import jsonable_encoder
+from fastapi.responses import StreamingResponse
+from uuid import UUID
+
+from gns3server import schemas
+from gns3server.compute.docker import Docker
+from gns3server.compute.docker.docker_vm import DockerVM
+
+router = APIRouter()
+
+responses = {
+    404: {"model": schemas.ErrorMessage, "description": "Could not find project or Docker node"}
+}
+
+
+def dep_node(project_id: UUID, node_id: UUID):
+    """
+    Dependency to retrieve a node.
+    """
+
+    docker_manager = Docker.instance()
+    node = docker_manager.get_node(str(node_id), project_id=str(project_id))
+    return node
+
+
+@router.post("",
+             response_model=schemas.Docker,
+             status_code=status.HTTP_201_CREATED,
+             responses={409: {"model": schemas.ErrorMessage, "description": "Could not create Docker node"}})
+async def create_docker_node(project_id: UUID, node_data: schemas.DockerCreate):
+    """
+    Create a new Docker node.
+    """
+
+    docker_manager = Docker.instance()
+    node_data = jsonable_encoder(node_data, exclude_unset=True)
+    container = await docker_manager.create_node(node_data.pop("name"),
+                                                 str(project_id),
+                                                 node_data.get("node_id"),
+                                                 image=node_data.pop("image"),
+                                                 start_command=node_data.get("start_command"),
+                                                 environment=node_data.get("environment"),
+                                                 adapters=node_data.get("adapters"),
+                                                 console=node_data.get("console"),
+                                                 console_type=node_data.get("console_type"),
+                                                 console_resolution=node_data.get("console_resolution", "1024x768"),
+                                                 console_http_port=node_data.get("console_http_port", 80),
+                                                 console_http_path=node_data.get("console_http_path", "/"),
+                                                 aux=node_data.get("aux"),
+                                                 aux_type=node_data.pop("aux_type", "none"),
+                                                 extra_hosts=node_data.get("extra_hosts"),
+                                                 extra_volumes=node_data.get("extra_volumes"),
+                                                 memory=node_data.get("memory", 0),
+                                                 cpus=node_data.get("cpus", 0))
+    for name, value in node_data.items():
+        if name != "node_id":
+            if hasattr(container, name) and getattr(container, name) != value:
+                setattr(container, name, value)
+
+    return container.__json__()
+
+
+@router.get("/{node_id}",
+            response_model=schemas.Docker,
+            responses=responses)
+def get_docker_node(node: DockerVM = Depends(dep_node)):
+    """
+    Return a Docker node.
+    """
+
+    return node.__json__()
+
+
+@router.put("/{node_id}",
+            response_model=schemas.Docker,
+            responses=responses)
+async def update_docker(node_data: schemas.DockerUpdate, node: DockerVM = Depends(dep_node)):
+    """
+    Update a Docker node.
+    """
+
+    props = [
+        "name", "console", "console_type", "aux", "aux_type", "console_resolution",
+        "console_http_port", "console_http_path", "start_command",
+        "environment", "adapters", "extra_hosts", "extra_volumes",
+        "memory", "cpus"
+    ]
+
+    changed = False
+    node_data = jsonable_encoder(node_data, exclude_unset=True)
+    for prop in props:
+        if prop in node_data and node_data[prop] != getattr(node, prop):
+            setattr(node, prop, node_data[prop])
+            changed = True
+    # We don't call container.update for nothing because it will restart the container
+    if changed:
+        await node.update()
+    node.updated()
+    return node.__json__()
+
+
+@router.post("/{node_id}/start",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def start_docker_node(node: DockerVM = Depends(dep_node)):
+    """
+    Start a Docker node.
+    """
+
+    await node.start()
+
+
+@router.post("/{node_id}/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def stop_docker_node(node: DockerVM = Depends(dep_node)):
+    """
+    Stop a Docker node.
+    """
+
+    await node.stop()
+
+
+@router.post("/{node_id}/suspend",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def suspend_docker_node(node: DockerVM = Depends(dep_node)):
+    """
+    Suspend a Docker node.
+    """
+
+    await node.pause()
+
+
+@router.post("/{node_id}/reload",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def reload_docker_node(node: DockerVM = Depends(dep_node)):
+    """
+    Reload a Docker node.
+    """
+
+    await node.restart()
+
+
+@router.post("/{node_id}/pause",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def pause_docker_node(node: DockerVM = Depends(dep_node)):
+    """
+    Pause a Docker node.
+    """
+
+    await node.pause()
+
+
+@router.post("/{node_id}/unpause",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def unpause_docker_node(node: DockerVM = Depends(dep_node)):
+    """
+    Unpause a Docker node.
+    """
+
+    await node.unpause()
+
+
+@router.delete("/{node_id}",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_docker_node(node: DockerVM = Depends(dep_node)):
+    """
+    Delete a Docker node.
+    """
+
+    await node.delete()
+
+
+@router.post("/{node_id}/duplicate",
+             response_model=schemas.Docker,
+             status_code=status.HTTP_201_CREATED,
+             responses=responses)
+async def duplicate_docker_node(destination_node_id: UUID = Body(..., embed=True), node: DockerVM = Depends(dep_node)):
+    """
+    Duplicate a Docker node.
+    """
+
+    new_node = await Docker.instance().duplicate_node(node.id, str(destination_node_id))
+    return new_node.__json__()
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+             status_code=status.HTTP_201_CREATED,
+             response_model=schemas.UDPNIO,
+             responses=responses)
+async def create_nio(adapter_number: int,
+                     port_number: int,
+                     nio_data: schemas.UDPNIO,
+                     node: DockerVM = Depends(dep_node)):
+    """
+    Add a NIO (Network Input/Output) to the node.
+    The port number on the Docker node is always 0.
+    """
+
+    nio = Docker.instance().create_nio(jsonable_encoder(nio_data, exclude_unset=True))
+    await node.adapter_add_nio_binding(adapter_number, nio)
+    return nio.__json__()
+
+
+@router.put("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+            status_code=status.HTTP_201_CREATED,
+            response_model=schemas.UDPNIO,
+            responses=responses)
+async def update_nio(adapter_number: int,
+                     port_number: int, nio_data: schemas.UDPNIO,
+                     node: DockerVM = Depends(dep_node)):
+    """
+    Update a NIO (Network Input/Output) on the node.
+    The port number on the Docker node is always 0.
+    """
+
+    nio = node.get_nio(adapter_number)
+    if nio_data.filters:
+        nio.filters = nio_data.filters
+    await node.adapter_update_nio_binding(adapter_number, nio)
+    return nio.__json__()
+
+
+@router.delete("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_nio(adapter_number: int, port_number: int, node: DockerVM = Depends(dep_node)):
+    """
+    Delete a NIO (Network Input/Output) from the node.
+    The port number on the Docker node is always 0.
+    """
+
+    await node.adapter_remove_nio_binding(adapter_number)
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/start",
+             responses=responses)
+async def start_capture(adapter_number: int,
+                        port_number: int,
+                        node_capture_data: schemas.NodeCapture,
+                        node: DockerVM = Depends(dep_node)):
+    """
+    Start a packet capture on the node.
+    The port number on the Docker node is always 0.
+    """
+
+    pcap_file_path = os.path.join(node.project.capture_working_directory(), node_capture_data.capture_file_name)
+    await node.start_capture(adapter_number, pcap_file_path)
+    return {"pcap_file_path": str(pcap_file_path)}
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def stop_capture(adapter_number: int, port_number: int, node: DockerVM = Depends(dep_node)):
+    """
+    Stop a packet capture on the node.
+    The port number on the Docker node is always 0.
+    """
+
+    await node.stop_capture(adapter_number)
+
+
+@router.get("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/stream",
+            responses=responses)
+async def stream_pcap_file(adapter_number: int, port_number: int, node: DockerVM = Depends(dep_node)):
+    """
+    Stream the pcap capture file.
+    The port number on the Docker node is always 0.
+    """
+
+    nio = node.get_nio(adapter_number)
+    stream = Docker.instance().stream_pcap_file(nio, node.project.id)
+    return StreamingResponse(stream, media_type="application/vnd.tcpdump.pcap")
+
+
+@router.websocket("/{node_id}/console/ws")
+async def console_ws(websocket: WebSocket, node: DockerVM = Depends(dep_node)):
+    """
+    Console WebSocket.
+    """
+
+    await node.start_websocket_console(websocket)
+
+
+@router.post("/{node_id}/console/reset",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def reset_console(node: DockerVM = Depends(dep_node)):
+
+    await node.reset_console()

gns3server/api/routes/compute/dynamips_nodes.py

@@ -0,0 +1,316 @@
+# -*- coding: utf-8 -*-
+#
+# 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 Dynamips nodes.
+"""
+
+import os
+import sys
+
+from fastapi import APIRouter, WebSocket, Depends, status
+from fastapi.encoders import jsonable_encoder
+from fastapi.responses import StreamingResponse
+from typing import List
+from uuid import UUID
+
+from gns3server.compute.dynamips import Dynamips
+from gns3server.compute.dynamips.nodes.router import Router
+from gns3server.compute.dynamips.dynamips_error import DynamipsError
+from gns3server import schemas
+
+router = APIRouter()
+
+responses = {
+    404: {"model": schemas.ErrorMessage, "description": "Could not find project or Dynamips node"}
+}
+
+DEFAULT_CHASSIS = {
+    "c1700": "1720",
+    "c2600": "2610",
+    "c3600": "3640"
+}
+
+
+def dep_node(project_id: UUID, node_id: UUID):
+    """
+    Dependency to retrieve a node.
+    """
+
+    dynamips_manager = Dynamips.instance()
+    node = dynamips_manager.get_node(str(node_id), project_id=str(project_id))
+    return node
+
+
+@router.post("",
+             response_model=schemas.Dynamips,
+             status_code=status.HTTP_201_CREATED,
+             responses={409: {"model": schemas.ErrorMessage, "description": "Could not create Dynamips node"}})
+async def create_router(project_id: UUID, node_data: schemas.DynamipsCreate):
+    """
+    Create a new Dynamips router.
+    """
+
+    dynamips_manager = Dynamips.instance()
+    platform = node_data.platform
+    chassis = None
+    if not node_data.chassis and platform in DEFAULT_CHASSIS:
+        chassis = DEFAULT_CHASSIS[platform]
+    node_data = jsonable_encoder(node_data, exclude_unset=True)
+    vm = await dynamips_manager.create_node(node_data.pop("name"),
+                                            str(project_id),
+                                            node_data.get("node_id"),
+                                            dynamips_id=node_data.get("dynamips_id"),
+                                            platform=platform,
+                                            console=node_data.get("console"),
+                                            console_type=node_data.get("console_type", "telnet"),
+                                            aux=node_data.get("aux"),
+                                            aux_type=node_data.pop("aux_type", "none"),
+                                            chassis=chassis,
+                                            node_type="dynamips")
+    await dynamips_manager.update_vm_settings(vm, node_data)
+    return vm.__json__()
+
+
+@router.get("/{node_id}",
+            response_model=schemas.Dynamips,
+            responses=responses)
+def get_router(node: Router = Depends(dep_node)):
+    """
+    Return Dynamips router.
+    """
+
+    return node.__json__()
+
+
+@router.put("/{node_id}",
+            response_model=schemas.Dynamips,
+            responses=responses)
+async def update_router(node_data: schemas.DynamipsUpdate, node: Router = Depends(dep_node)):
+    """
+    Update a Dynamips router.
+    """
+
+    await Dynamips.instance().update_vm_settings(node, jsonable_encoder(node_data, exclude_unset=True))
+    node.updated()
+    return node.__json__()
+
+
+@router.delete("/{node_id}",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_router(node: Router = Depends(dep_node)):
+    """
+    Delete a Dynamips router.
+    """
+
+    await Dynamips.instance().delete_node(node.id)
+
+
+@router.post("/{node_id}/start",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def start_router(node: Router = Depends(dep_node)):
+    """
+    Start a Dynamips router.
+    """
+
+    try:
+        await Dynamips.instance().ghost_ios_support(node)
+    except GeneratorExit:
+        pass
+    await node.start()
+
+
+@router.post("/{node_id}/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def stop_router(node: Router = Depends(dep_node)):
+    """
+    Stop a Dynamips router.
+    """
+
+    await node.stop()
+
+
+@router.post("/{node_id}/suspend",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def suspend_router(node: Router = Depends(dep_node)):
+
+    await node.suspend()
+
+
+@router.post("/{node_id}/resume",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def resume_router(node: Router = Depends(dep_node)):
+    """
+    Resume a suspended Dynamips router.
+    """
+
+    await node.resume()
+
+
+@router.post("/{node_id}/reload",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def reload_router(node: Router = Depends(dep_node)):
+    """
+    Reload a suspended Dynamips router.
+    """
+
+    await node.reload()
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+             status_code=status.HTTP_201_CREATED,
+             response_model=schemas.UDPNIO,
+             responses=responses)
+async def create_nio(adapter_number: int, port_number: int, nio_data: schemas.UDPNIO, node: Router = Depends(dep_node)):
+    """
+    Add a NIO (Network Input/Output) to the node.
+    """
+
+    nio = await Dynamips.instance().create_nio(node, jsonable_encoder(nio_data, exclude_unset=True))
+    await node.slot_add_nio_binding(adapter_number, port_number, nio)
+    return nio.__json__()
+
+
+@router.put("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+            status_code=status.HTTP_201_CREATED,
+            response_model=schemas.UDPNIO,
+            responses=responses)
+async def update_nio(adapter_number: int, port_number: int, nio_data: schemas.UDPNIO, node: Router = Depends(dep_node)):
+    """
+    Update a NIO (Network Input/Output) on the node.
+    """
+
+    nio = node.get_nio(adapter_number, port_number)
+    if nio_data.filters:
+        nio.filters = nio_data.filters
+    await node.slot_update_nio_binding(adapter_number, port_number, nio)
+    return nio.__json__()
+
+
+@router.delete("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_nio(adapter_number: int, port_number: int, node: Router = Depends(dep_node)):
+    """
+    Delete a NIO (Network Input/Output) from the node.
+    """
+
+    nio = await node.slot_remove_nio_binding(adapter_number, port_number)
+    await nio.delete()
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/start",
+             responses=responses)
+async def start_capture(adapter_number: int,
+                        port_number: int,
+                        node_capture_data: schemas.NodeCapture,
+                        node: Router = Depends(dep_node)):
+    """
+    Start a packet capture on the node.
+    """
+
+    pcap_file_path = os.path.join(node.project.capture_working_directory(), node_capture_data.capture_file_name)
+
+    if sys.platform.startswith('win'):
+        # FIXME: Dynamips (Cygwin actually) doesn't like non ascii paths on Windows
+        try:
+            pcap_file_path.encode('ascii')
+        except UnicodeEncodeError:
+            raise DynamipsError('The capture file path "{}" must only contain ASCII (English) characters'.format(pcap_file_path))
+
+    await node.start_capture(adapter_number, port_number, pcap_file_path, node_capture_data.data_link_type)
+    return {"pcap_file_path": pcap_file_path}
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def stop_capture(adapter_number: int, port_number: int, node: Router = Depends(dep_node)):
+    """
+    Stop a packet capture on the node.
+    """
+
+    await node.stop_capture(adapter_number, port_number)
+
+
+@router.get("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/stream",
+            responses=responses)
+async def stream_pcap_file(adapter_number: int, port_number: int, node: Router = Depends(dep_node)):
+    """
+    Stream the pcap capture file.
+    """
+
+    nio = node.get_nio(adapter_number, port_number)
+    stream = Dynamips.instance().stream_pcap_file(nio, node.project.id)
+    return StreamingResponse(stream, media_type="application/vnd.tcpdump.pcap")
+
+
+@router.get("/{node_id}/idlepc_proposals",
+            responses=responses)
+async def get_idlepcs(node: Router = Depends(dep_node)) -> List[str]:
+    """
+    Retrieve Dynamips idle-pc proposals
+    """
+
+    await node.set_idlepc("0x0")
+    return await node.get_idle_pc_prop()
+
+
+@router.get("/{node_id}/auto_idlepc",
+            responses=responses)
+async def get_auto_idlepc(node: Router = Depends(dep_node)) -> dict:
+    """
+    Get an automatically guessed best idle-pc value.
+    """
+
+    idlepc = await Dynamips.instance().auto_idlepc(node)
+    return {"idlepc": idlepc}
+
+
+@router.post("/{node_id}/duplicate",
+             status_code=status.HTTP_201_CREATED,
+             responses=responses)
+async def duplicate_router(destination_node_id: UUID, node: Router = Depends(dep_node)):
+    """
+    Duplicate a router.
+    """
+
+    new_node = await Dynamips.instance().duplicate_node(node.id, str(destination_node_id))
+    return new_node.__json__()
+
+
+@router.websocket("/{node_id}/console/ws")
+async def console_ws(websocket: WebSocket, node: Router = Depends(dep_node)):
+    """
+    Console WebSocket.
+    """
+
+    await node.start_websocket_console(websocket)
+
+
+@router.post("/{node_id}/console/reset",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def reset_console(node: Router = Depends(dep_node)):
+
+    await node.reset_console()

gns3server/api/routes/compute/ethernet_hub_nodes.py

@@ -0,0 +1,228 @@
+# -*- coding: utf-8 -*-
+#
+# 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 Ethernet hub nodes.
+"""
+
+import os
+
+from fastapi import APIRouter, Depends, Body, status
+from fastapi.encoders import jsonable_encoder
+from fastapi.responses import StreamingResponse
+from uuid import UUID
+
+from gns3server.compute.dynamips import Dynamips
+from gns3server.compute.dynamips.nodes.ethernet_hub import EthernetHub
+from gns3server import schemas
+
+router = APIRouter()
+
+responses = {
+    404: {"model": schemas.ErrorMessage, "description": "Could not find project or Ethernet hub node"}
+}
+
+
+def dep_node(project_id: UUID, node_id: UUID):
+    """
+    Dependency to retrieve a node.
+    """
+
+    dynamips_manager = Dynamips.instance()
+    node = dynamips_manager.get_node(str(node_id), project_id=str(project_id))
+    return node
+
+
+@router.post("",
+             response_model=schemas.EthernetHub,
+             status_code=status.HTTP_201_CREATED,
+             responses={409: {"model": schemas.ErrorMessage, "description": "Could not create Ethernet hub node"}})
+async def create_ethernet_hub(project_id: UUID, node_data: schemas.EthernetHubCreate):
+    """
+    Create a new Ethernet hub.
+    """
+
+    # Use the Dynamips Ethernet hub to simulate this node
+    dynamips_manager = Dynamips.instance()
+    node_data = jsonable_encoder(node_data, exclude_unset=True)
+    node = await dynamips_manager.create_node(node_data.pop("name"),
+                                              str(project_id),
+                                              node_data.get("node_id"),
+                                              node_type="ethernet_hub",
+                                              ports=node_data.get("ports_mapping"))
+    return node.__json__()
+
+
+@router.get("/{node_id}",
+            response_model=schemas.EthernetHub,
+            responses=responses)
+def get_ethernet_hub(node: EthernetHub = Depends(dep_node)):
+    """
+    Return an Ethernet hub.
+    """
+
+    return node.__json__()
+
+
+@router.post("/{node_id}/duplicate",
+             response_model=schemas.EthernetHub,
+             status_code=status.HTTP_201_CREATED,
+             responses=responses)
+async def duplicate_ethernet_hub(destination_node_id: UUID = Body(..., embed=True),
+                                 node: EthernetHub = Depends(dep_node)):
+    """
+    Duplicate an Ethernet hub.
+    """
+
+    new_node = await Dynamips.instance().duplicate_node(node.id, str(destination_node_id))
+    return new_node.__json__()
+
+
+@router.put("/{node_id}",
+            response_model=schemas.EthernetHub,
+            responses=responses)
+async def update_ethernet_hub(node_data: schemas.EthernetHubUpdate, node: EthernetHub = Depends(dep_node)):
+    """
+    Update an Ethernet hub.
+    """
+
+    node_data = jsonable_encoder(node_data, exclude_unset=True)
+    if "name" in node_data and node.name != node_data["name"]:
+        await node.set_name(node_data["name"])
+    if "ports_mapping" in node_data:
+        node.ports_mapping = node_data["ports_mapping"]
+    node.updated()
+    return node.__json__()
+
+
+@router.delete("/{node_id}",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_ethernet_hub(node: EthernetHub = Depends(dep_node)):
+    """
+    Delete an Ethernet hub.
+    """
+
+    await Dynamips.instance().delete_node(node.id)
+
+
+@router.post("/{node_id}/start",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+def start_ethernet_hub(node: EthernetHub = Depends(dep_node)):
+    """
+    Start an Ethernet hub.
+    This endpoint results in no action since Ethernet hub nodes are always on.
+    """
+
+    pass
+
+
+@router.post("/{node_id}/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+def stop_ethernet_hub(node: EthernetHub = Depends(dep_node)):
+    """
+    Stop an Ethernet hub.
+    This endpoint results in no action since Ethernet hub nodes are always on.
+    """
+
+    pass
+
+
+@router.post("/{node_id}/suspend",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+def suspend_ethernet_hub(node: EthernetHub = Depends(dep_node)):
+    """
+    Suspend an Ethernet hub.
+    This endpoint results in no action since Ethernet hub nodes are always on.
+    """
+
+    pass
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+             status_code=status.HTTP_201_CREATED,
+             response_model=schemas.UDPNIO,
+             responses=responses)
+async def create_nio(adapter_number: int,
+                     port_number: int,
+                     nio_data: schemas.UDPNIO,
+                     node: EthernetHub = Depends(dep_node)):
+    """
+    Add a NIO (Network Input/Output) to the node.
+    The adapter number on the hub is always 0.
+    """
+
+    nio = await Dynamips.instance().create_nio(node, jsonable_encoder(nio_data, exclude_unset=True))
+    await node.add_nio(nio, port_number)
+    return nio.__json__()
+
+
+@router.delete("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_nio(adapter_number: int, port_number: int, node: EthernetHub = Depends(dep_node)):
+    """
+    Delete a NIO (Network Input/Output) from the node.
+    The adapter number on the hub is always 0.
+    """
+
+    nio = await node.remove_nio(port_number)
+    await nio.delete()
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/start",
+             responses=responses)
+async def start_capture(adapter_number: int,
+                        port_number: int,
+                        node_capture_data: schemas.NodeCapture,
+                        node: EthernetHub = Depends(dep_node)):
+    """
+    Start a packet capture on the node.
+    The adapter number on the hub is always 0.
+    """
+
+    pcap_file_path = os.path.join(node.project.capture_working_directory(), node_capture_data.capture_file_name)
+    await node.start_capture(port_number, pcap_file_path, node_capture_data.data_link_type)
+    return {"pcap_file_path": pcap_file_path}
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def stop_capture(adapter_number: int, port_number: int, node: EthernetHub = Depends(dep_node)):
+    """
+    Stop a packet capture on the node.
+    The adapter number on the hub is always 0.
+    """
+
+    await node.stop_capture(port_number)
+
+
+@router.get("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/stream",
+            responses=responses)
+async def stream_pcap_file(adapter_number: int, port_number: int, node: EthernetHub = Depends(dep_node)):
+    """
+    Stream the pcap capture file.
+    The adapter number on the hub is always 0.
+    """
+
+    nio = node.get_nio(port_number)
+    stream = Dynamips.instance().stream_pcap_file(nio, node.project.id)
+    return StreamingResponse(stream, media_type="application/vnd.tcpdump.pcap")

gns3server/api/routes/compute/ethernet_switch_nodes.py

@@ -0,0 +1,227 @@
+# -*- coding: utf-8 -*-
+#
+# 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 Ethernet switch nodes.
+"""
+
+import os
+
+from fastapi import APIRouter, Depends, Body, status
+from fastapi.encoders import jsonable_encoder
+from fastapi.responses import StreamingResponse
+from uuid import UUID
+
+from gns3server.compute.dynamips import Dynamips
+from gns3server.compute.dynamips.nodes.ethernet_switch import EthernetSwitch
+from gns3server import schemas
+
+router = APIRouter()
+
+responses = {
+    404: {"model": schemas.ErrorMessage, "description": "Could not find project or Ethernet switch node"}
+}
+
+
+def dep_node(project_id: UUID, node_id: UUID):
+    """
+    Dependency to retrieve a node.
+    """
+
+    dynamips_manager = Dynamips.instance()
+    node = dynamips_manager.get_node(str(node_id), project_id=str(project_id))
+    return node
+
+
+@router.post("",
+             response_model=schemas.EthernetSwitch,
+             status_code=status.HTTP_201_CREATED,
+             responses={409: {"model": schemas.ErrorMessage, "description": "Could not create Ethernet switch node"}})
+async def create_ethernet_switch(project_id: UUID, node_data: schemas.EthernetSwitchCreate):
+    """
+    Create a new Ethernet switch.
+    """
+
+    # Use the Dynamips Ethernet switch to simulate this node
+    dynamips_manager = Dynamips.instance()
+    node_data = jsonable_encoder(node_data, exclude_unset=True)
+    node = await dynamips_manager.create_node(node_data.pop("name"),
+                                              str(project_id),
+                                              node_data.get("node_id"),
+                                              console=node_data.get("console"),
+                                              console_type=node_data.get("console_type"),
+                                              node_type="ethernet_switch",
+                                              ports=node_data.get("ports_mapping"))
+
+    return node.__json__()
+
+
+@router.get("/{node_id}",
+            response_model=schemas.EthernetSwitch,
+            responses=responses)
+def get_ethernet_switch(node: EthernetSwitch = Depends(dep_node)):
+
+    return node.__json__()
+
+
+@router.post("/{node_id}/duplicate",
+             response_model=schemas.EthernetSwitch,
+             status_code=status.HTTP_201_CREATED,
+             responses=responses)
+async def duplicate_ethernet_switch(destination_node_id: UUID = Body(..., embed=True),
+                                    node: EthernetSwitch = Depends(dep_node)):
+    """
+    Duplicate an Ethernet switch.
+    """
+
+    new_node = await Dynamips.instance().duplicate_node(node.id, str(destination_node_id))
+    return new_node.__json__()
+
+
+@router.put("/{node_id}",
+            response_model=schemas.EthernetSwitch,
+            responses=responses)
+async def update_ethernet_switch(node_data: schemas.EthernetSwitchUpdate, node: EthernetSwitch = Depends(dep_node)):
+    """
+    Update an Ethernet switch.
+    """
+
+    node_data = jsonable_encoder(node_data, exclude_unset=True)
+    if "name" in node_data and node.name != node_data["name"]:
+        await node.set_name(node_data["name"])
+    if "ports_mapping" in node_data:
+        node.ports_mapping = node_data["ports_mapping"]
+        await node.update_port_settings()
+    if "console_type" in node_data:
+        node.console_type = node_data["console_type"]
+    node.updated()
+    return node.__json__()
+
+
+@router.delete("/{node_id}",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_ethernet_switch(node: EthernetSwitch = Depends(dep_node)):
+    """
+    Delete an Ethernet switch.
+    """
+
+    await Dynamips.instance().delete_node(node.id)
+
+
+@router.post("/{node_id}/start",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+def start_ethernet_switch(node: EthernetSwitch = Depends(dep_node)):
+    """
+    Start an Ethernet switch.
+    This endpoint results in no action since Ethernet switch nodes are always on.
+    """
+
+    pass
+
+
+@router.post("/{node_id}/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+def stop_ethernet_switch(node: EthernetSwitch = Depends(dep_node)):
+    """
+    Stop an Ethernet switch.
+    This endpoint results in no action since Ethernet switch nodes are always on.
+    """
+
+    pass
+
+
+@router.post("/{node_id}/suspend",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+def suspend_ethernet_switch(node: EthernetSwitch = Depends(dep_node)):
+    """
+    Suspend an Ethernet switch.
+    This endpoint results in no action since Ethernet switch nodes are always on.
+    """
+
+    pass
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+             status_code=status.HTTP_201_CREATED,
+             response_model=schemas.UDPNIO,
+             responses=responses)
+async def create_nio(adapter_number: int,
+                     port_number: int,
+                     nio_data: schemas.UDPNIO,
+                     node: EthernetSwitch = Depends(dep_node)):
+
+    nio = await Dynamips.instance().create_nio(node, jsonable_encoder(nio_data, exclude_unset=True))
+    await node.add_nio(nio, port_number)
+    return nio.__json__()
+
+
+@router.delete("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_nio(adapter_number: int, port_number: int, node: EthernetSwitch = Depends(dep_node)):
+    """
+    Delete a NIO (Network Input/Output) from the node.
+    The adapter number on the switch is always 0.
+    """
+
+    nio = await node.remove_nio(port_number)
+    await nio.delete()
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/start",
+             responses=responses)
+async def start_capture(adapter_number: int,
+                        port_number: int,
+                        node_capture_data: schemas.NodeCapture,
+                        node: EthernetSwitch = Depends(dep_node)):
+    """
+    Start a packet capture on the node.
+    The adapter number on the switch is always 0.
+    """
+
+    pcap_file_path = os.path.join(node.project.capture_working_directory(), node_capture_data.capture_file_name)
+    await node.start_capture(port_number, pcap_file_path, node_capture_data.data_link_type)
+    return {"pcap_file_path": pcap_file_path}
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def stop_capture(adapter_number: int,port_number: int, node: EthernetSwitch = Depends(dep_node)):
+    """
+    Stop a packet capture on the node.
+    The adapter number on the switch is always 0.
+    """
+
+    await node.stop_capture(port_number)
+
+
+@router.get("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/stream",
+            responses=responses)
+async def stream_pcap_file(adapter_number: int, port_number: int, node: EthernetSwitch = Depends(dep_node)):
+    """
+    Stream the pcap capture file.
+    The adapter number on the switch is always 0.
+    """
+
+    nio = node.get_nio(port_number)
+    stream = Dynamips.instance().stream_pcap_file(nio, node.project.id)
+    return StreamingResponse(stream, media_type="application/vnd.tcpdump.pcap")

gns3server/api/routes/compute/frame_relay_switch_nodes.py

@@ -0,0 +1,229 @@
+# -*- coding: utf-8 -*-
+#
+# 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 Frame Relay switch nodes.
+"""
+
+import os
+
+from fastapi import APIRouter, Depends, Body, status
+from fastapi.encoders import jsonable_encoder
+from fastapi.responses import StreamingResponse
+from uuid import UUID
+
+from gns3server import schemas
+from gns3server.compute.dynamips import Dynamips
+from gns3server.compute.dynamips.nodes.frame_relay_switch import FrameRelaySwitch
+
+router = APIRouter()
+
+responses = {
+    404: {"model": schemas.ErrorMessage, "description": "Could not find project or Frame Relay switch node"}
+}
+
+
+def dep_node(project_id: UUID, node_id: UUID):
+    """
+    Dependency to retrieve a node.
+    """
+
+    dynamips_manager = Dynamips.instance()
+    node = dynamips_manager.get_node(str(node_id), project_id=str(project_id))
+    return node
+
+
+@router.post("",
+             response_model=schemas.FrameRelaySwitch,
+             status_code=status.HTTP_201_CREATED,
+             responses={409: {"model": schemas.ErrorMessage, "description": "Could not create Frame Relay switch node"}})
+async def create_frame_relay_switch(project_id: UUID, node_data: schemas.FrameRelaySwitchCreate):
+    """
+    Create a new Frame Relay switch node.
+    """
+
+    # Use the Dynamips Frame Relay switch to simulate this node
+    dynamips_manager = Dynamips.instance()
+    node_data = jsonable_encoder(node_data, exclude_unset=True)
+    node = await dynamips_manager.create_node(node_data.pop("name"),
+                                              str(project_id),
+                                              node_data.get("node_id"),
+                                              node_type="frame_relay_switch",
+                                              mappings=node_data.get("mappings"))
+    return node.__json__()
+
+
+@router.get("/{node_id}",
+            response_model=schemas.FrameRelaySwitch,
+            responses=responses)
+def get_frame_relay_switch(node: FrameRelaySwitch = Depends(dep_node)):
+    """
+    Return a Frame Relay switch node.
+    """
+
+    return node.__json__()
+
+
+@router.post("/{node_id}/duplicate",
+             response_model=schemas.FrameRelaySwitch,
+             status_code=status.HTTP_201_CREATED,
+             responses=responses)
+async def duplicate_frame_relay_switch(destination_node_id: UUID = Body(..., embed=True),
+                                       node: FrameRelaySwitch = Depends(dep_node)):
+    """
+    Duplicate a Frame Relay switch node.
+    """
+
+    new_node = await Dynamips.instance().duplicate_node(node.id, str(destination_node_id))
+    return new_node.__json__()
+
+
+@router.put("/{node_id}",
+            response_model=schemas.FrameRelaySwitch,
+            responses=responses)
+async def update_frame_relay_switch(node_data: schemas.FrameRelaySwitchUpdate,
+                                    node: FrameRelaySwitch = Depends(dep_node)):
+    """
+    Update an Frame Relay switch node.
+    """
+
+    node_data = jsonable_encoder(node_data, exclude_unset=True)
+    if "name" in node_data and node.name != node_data["name"]:
+        await node.set_name(node_data["name"])
+    if "mappings" in node_data:
+        node.mappings = node_data["mappings"]
+    node.updated()
+    return node.__json__()
+
+
+@router.delete("/{node_id}",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_frame_relay_switch(node: FrameRelaySwitch = Depends(dep_node)):
+    """
+    Delete a Frame Relay switch node.
+    """
+
+    await Dynamips.instance().delete_node(node.id)
+
+
+@router.post("/{node_id}/start",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+def start_frame_relay_switch(node: FrameRelaySwitch = Depends(dep_node)):
+    """
+    Start a Frame Relay switch node.
+    This endpoint results in no action since Frame Relay switch nodes are always on.
+    """
+
+    pass
+
+
+@router.post("/{node_id}/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+def stop_frame_relay_switch(node: FrameRelaySwitch = Depends(dep_node)):
+    """
+    Stop a Frame Relay switch node.
+    This endpoint results in no action since Frame Relay switch nodes are always on.
+    """
+
+    pass
+
+
+@router.post("/{node_id}/suspend",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+def suspend_frame_relay_switch(node: FrameRelaySwitch = Depends(dep_node)):
+    """
+    Suspend a Frame Relay switch node.
+    This endpoint results in no action since Frame Relay switch nodes are always on.
+    """
+
+    pass
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+             status_code=status.HTTP_201_CREATED,
+             response_model=schemas.UDPNIO,
+             responses=responses)
+async def create_nio(adapter_number: int,
+                     port_number: int,
+                     nio_data: schemas.UDPNIO,
+                     node: FrameRelaySwitch = Depends(dep_node)):
+    """
+    Add a NIO (Network Input/Output) to the node.
+    The adapter number on the switch is always 0.
+    """
+
+    nio = await Dynamips.instance().create_nio(node, jsonable_encoder(nio_data, exclude_unset=True))
+    await node.add_nio(nio, port_number)
+    return nio.__json__()
+
+
+@router.delete("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_nio(adapter_number: int, port_number: int, node: FrameRelaySwitch = Depends(dep_node)):
+    """
+    Remove a NIO (Network Input/Output) from the node.
+    The adapter number on the switch is always 0.
+    """
+
+    nio = await node.remove_nio(port_number)
+    await nio.delete()
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/start",
+             responses=responses)
+async def start_capture(adapter_number: int,
+                        port_number: int,
+                        node_capture_data: schemas.NodeCapture,
+                        node: FrameRelaySwitch = Depends(dep_node)):
+    """
+    Start a packet capture on the node.
+    The adapter number on the switch is always 0.
+    """
+
+    pcap_file_path = os.path.join(node.project.capture_working_directory(), node_capture_data.capture_file_name)
+    await node.start_capture(port_number, pcap_file_path, node_capture_data.data_link_type)
+    return {"pcap_file_path": pcap_file_path}
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def stop_capture(adapter_number: int, port_number: int, node: FrameRelaySwitch = Depends(dep_node)):
+    """
+    Stop a packet capture on the node.
+    The adapter number on the switch is always 0.
+    """
+
+    await node.stop_capture(port_number)
+
+
+@router.get("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/stream",
+            responses=responses)
+async def stream_pcap_file(adapter_number: int, port_number: int, node: FrameRelaySwitch = Depends(dep_node)):
+    """
+    Stream the pcap capture file.
+    The adapter number on the hub is always 0.
+    """
+
+    nio = node.get_nio(port_number)
+    stream = Dynamips.instance().stream_pcap_file(nio, node.project.id)
+    return StreamingResponse(stream, media_type="application/vnd.tcpdump.pcap")

gns3server/api/routes/compute/images.py

@@ -0,0 +1,157 @@
+# -*- coding: utf-8 -*-
+#
+# 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 images.
+"""
+
+import os
+import urllib.parse
+
+from fastapi import APIRouter, Request, status, HTTPException
+from fastapi.responses import FileResponse
+from typing import List
+
+from gns3server.compute.docker import Docker
+from gns3server.compute.dynamips import Dynamips
+from gns3server.compute.iou import IOU
+from gns3server.compute.qemu import Qemu
+
+router = APIRouter()
+
+
+@router.get("/docker/images")
+async def get_docker_images() -> List[str]:
+    """
+    Get all Docker images.
+    """
+
+    docker_manager = Docker.instance()
+    return await docker_manager.list_images()
+
+
+@router.get("/dynamips/images")
+async def get_dynamips_images() -> List[str]:
+    """
+    Get all Dynamips images.
+    """
+
+    dynamips_manager = Dynamips.instance()
+    return await dynamips_manager.list_images()
+
+
+@router.post("/dynamips/images/{filename:path}",
+             status_code=status.HTTP_204_NO_CONTENT)
+async def upload_dynamips_image(filename: str, request: Request):
+    """
+    Upload a Dynamips IOS image.
+    """
+
+    dynamips_manager = Dynamips.instance()
+    await dynamips_manager.write_image(urllib.parse.unquote(filename), request.stream())
+
+
+@router.get("/dynamips/images/{filename:path}")
+async def download_dynamips_image(filename: str):
+    """
+    Download a Dynamips IOS image.
+    """
+
+    dynamips_manager = Dynamips.instance()
+    filename = urllib.parse.unquote(filename)
+    image_path = dynamips_manager.get_abs_image_path(filename)
+
+    if filename[0] == ".":
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)
+
+    if not os.path.exists(image_path):
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
+
+    return FileResponse(image_path, media_type="application/octet-stream")
+
+
+@router.get("/iou/images")
+async def get_iou_images() -> List[str]:
+    """
+    Get all IOU images.
+    """
+
+    iou_manager = IOU.instance()
+    return await iou_manager.list_images()
+
+
+@router.post("/iou/images/{filename:path}",
+             status_code=status.HTTP_204_NO_CONTENT)
+async def upload_iou_image(filename: str, request: Request):
+    """
+    Upload an IOU image.
+    """
+
+    iou_manager = IOU.instance()
+    await iou_manager.write_image(urllib.parse.unquote(filename), request.stream())
+
+
+@router.get("/iou/images/{filename:path}")
+async def download_iou_image(filename: str):
+    """
+    Download an IOU image.
+    """
+
+    iou_manager = IOU.instance()
+    filename = urllib.parse.unquote(filename)
+    image_path = iou_manager.get_abs_image_path(filename)
+
+    if filename[0] == ".":
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)
+
+    if not os.path.exists(image_path):
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
+
+    return FileResponse(image_path, media_type="application/octet-stream")
+
+
+@router.get("/qemu/images")
+async def get_qemu_images() -> List[str]:
+
+    qemu_manager = Qemu.instance()
+    return await qemu_manager.list_images()
+
+
+@router.post("/qemu/images/{filename:path}",
+             status_code=status.HTTP_204_NO_CONTENT)
+async def upload_qemu_image(filename: str, request: Request):
+
+    qemu_manager = Qemu.instance()
+    await qemu_manager.write_image(urllib.parse.unquote(filename), request.stream())
+
+
+@router.get("/qemu/images/{filename:path}")
+async def download_qemu_image(filename: str):
+
+    qemu_manager = Qemu.instance()
+    filename = urllib.parse.unquote(filename)
+
+    # Raise error if user try to escape
+    if filename[0] == ".":
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)
+
+    image_path = qemu_manager.get_abs_image_path(filename)
+
+    if not os.path.exists(image_path):
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
+
+    return FileResponse(image_path, media_type="application/octet-stream")

gns3server/api/routes/compute/iou_nodes.py

@@ -0,0 +1,292 @@
+# -*- coding: utf-8 -*-
+#
+# 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 IOU nodes.
+"""
+
+import os
+
+from fastapi import APIRouter, WebSocket, Depends, Body, status
+from fastapi.encoders import jsonable_encoder
+from fastapi.responses import StreamingResponse
+from typing import Union
+from uuid import UUID
+
+from gns3server import schemas
+from gns3server.compute.iou import IOU
+from gns3server.compute.iou.iou_vm import IOUVM
+
+router = APIRouter()
+
+responses = {
+    404: {"model": schemas.ErrorMessage, "description": "Could not find project or IOU node"}
+}
+
+
+def dep_node(project_id: UUID, node_id: UUID):
+    """
+    Dependency to retrieve a node.
+    """
+
+    iou_manager = IOU.instance()
+    node = iou_manager.get_node(str(node_id), project_id=str(project_id))
+    return node
+
+
+@router.post("",
+             response_model=schemas.IOU,
+             status_code=status.HTTP_201_CREATED,
+             responses={409: {"model": schemas.ErrorMessage, "description": "Could not create IOU node"}})
+async def create_iou_node(project_id: UUID, node_data: schemas.IOUCreate):
+    """
+    Create a new IOU node.
+    """
+
+    iou = IOU.instance()
+    node_data = jsonable_encoder(node_data, exclude_unset=True)
+    vm = await iou.create_node(node_data.pop("name"),
+                               str(project_id),
+                               node_data.get("node_id"),
+                               application_id=node_data.get("application_id"),
+                               path=node_data.get("path"),
+                               console=node_data.get("console"),
+                               console_type=node_data.get("console_type", "telnet"))
+
+    for name, value in node_data.items():
+        if hasattr(vm, name) and getattr(vm, name) != value:
+            if name == "application_id":
+                continue  # we must ignore this to avoid overwriting the application_id allocated by the controller
+            if name == "startup_config_content" and (vm.startup_config_content and len(vm.startup_config_content) > 0):
+                continue
+            if name == "private_config_content" and (vm.private_config_content and len(vm.private_config_content) > 0):
+                continue
+            if node_data.get("use_default_iou_values") and (name == "ram" or name == "nvram"):
+                continue
+            setattr(vm, name, value)
+    return vm.__json__()
+
+
+@router.get("/{node_id}",
+            response_model=schemas.IOU,
+            responses=responses)
+def get_iou_node(node: IOUVM = Depends(dep_node)):
+    """
+    Return an IOU node.
+    """
+
+    return node.__json__()
+
+
+@router.put("/{node_id}",
+            response_model=schemas.IOU,
+            responses=responses)
+async def update_iou_node(node_data: schemas.IOUUpdate, node: IOUVM = Depends(dep_node)):
+    """
+    Update an IOU node.
+    """
+
+    node_data = jsonable_encoder(node_data, exclude_unset=True)
+    for name, value in node_data.items():
+        if hasattr(node, name) and getattr(node, name) != value:
+            if name == "application_id":
+                continue  # we must ignore this to avoid overwriting the application_id allocated by the IOU manager
+            setattr(node, name, value)
+
+    if node.use_default_iou_values:
+        # update the default IOU values in case the image or use_default_iou_values have changed
+        # this is important to have the correct NVRAM amount in order to correctly push the configs to the NVRAM
+        await node.update_default_iou_values()
+    node.updated()
+    return node.__json__()
+
+
+@router.delete("/{node_id}",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_iou_node(node: IOUVM = Depends(dep_node)):
+    """
+    Delete an IOU node.
+    """
+
+    await IOU.instance().delete_node(node.id)
+
+
+@router.post("/{node_id}/duplicate",
+             response_model=schemas.IOU,
+             status_code=status.HTTP_201_CREATED,
+             responses=responses)
+async def duplicate_iou_node(destination_node_id: UUID = Body(..., embed=True), node: IOUVM = Depends(dep_node)):
+    """
+    Duplicate an IOU node.
+    """
+
+    new_node = await IOU.instance().duplicate_node(node.id, str(destination_node_id))
+    return new_node.__json__()
+
+
+@router.post("/{node_id}/start",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def start_iou_node(start_data: schemas.IOUStart, node: IOUVM = Depends(dep_node)):
+    """
+    Start an IOU node.
+    """
+
+    start_data = jsonable_encoder(start_data, exclude_unset=True)
+    for name, value in start_data.items():
+        if hasattr(node, name) and getattr(node, name) != value:
+            setattr(node, name, value)
+
+    await node.start()
+    return node.__json__()
+
+
+@router.post("/{node_id}/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def stop(node: IOUVM = Depends(dep_node)):
+    """
+    Stop an IOU node.
+    """
+
+    await node.stop()
+
+
+@router.post("/{node_id}/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+def suspend_iou_node(node: IOUVM = Depends(dep_node)):
+    """
+    Suspend an IOU node.
+    Does nothing since IOU doesn't support being suspended.
+    """
+
+    pass
+
+
+@router.post("/{node_id}/reload",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def reload_iou_node(node: IOUVM = Depends(dep_node)):
+    """
+    Reload an IOU node.
+    """
+
+    await node.reload()
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+             status_code=status.HTTP_201_CREATED,
+             response_model=Union[schemas.EthernetNIO, schemas.TAPNIO, schemas.UDPNIO],
+             responses=responses)
+async def create_nio(adapter_number: int,
+                     port_number: int,
+                     nio_data: Union[schemas.EthernetNIO, schemas.TAPNIO, schemas.UDPNIO],
+                     node: IOUVM = Depends(dep_node)):
+    """
+    Add a NIO (Network Input/Output) to the node.
+    """
+
+    nio = IOU.instance().create_nio(jsonable_encoder(nio_data, exclude_unset=True))
+    await node.adapter_add_nio_binding(adapter_number, port_number, nio)
+    return nio.__json__()
+
+
+@router.put("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+            status_code=status.HTTP_201_CREATED,
+            response_model=Union[schemas.EthernetNIO, schemas.TAPNIO, schemas.UDPNIO],
+            responses=responses)
+async def update_nio(adapter_number: int,
+                     port_number: int,
+                     nio_data: Union[schemas.EthernetNIO, schemas.TAPNIO, schemas.UDPNIO],
+                     node: IOUVM = Depends(dep_node)):
+    """
+    Update a NIO (Network Input/Output) on the node.
+    """
+
+    nio = node.get_nio(adapter_number, port_number)
+    if nio_data.filters:
+        nio.filters = nio_data.filters
+    await node.adapter_update_nio_binding(adapter_number, port_number, nio)
+    return nio.__json__()
+
+
+@router.delete("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_nio(adapter_number: int, port_number: int, node: IOUVM = Depends(dep_node)):
+    """
+    Delete a NIO (Network Input/Output) from the node.
+    """
+
+    await node.adapter_remove_nio_binding(adapter_number, port_number)
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/start",
+             responses=responses)
+async def start_capture(adapter_number: int,
+                        port_number: int,
+                        node_capture_data: schemas.NodeCapture,
+                        node: IOUVM = Depends(dep_node)):
+    """
+    Start a packet capture on the node.
+    """
+
+    pcap_file_path = os.path.join(node.project.capture_working_directory(), node_capture_data.capture_file_name)
+    await node.start_capture(adapter_number, pcap_file_path)
+    return {"pcap_file_path": str(pcap_file_path)}
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def stop_capture(adapter_number: int, port_number: int, node: IOUVM = Depends(dep_node)):
+    """
+    Stop a packet capture on the node.
+    """
+
+    await node.stop_capture(adapter_number, port_number)
+
+
+@router.get("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/stream",
+            responses=responses)
+async def stream_pcap_file(adapter_number: int, port_number: int, node: IOUVM = Depends(dep_node)):
+    """
+    Stream the pcap capture file.
+    """
+
+    nio = node.get_nio(adapter_number, port_number)
+    stream = IOU.instance().stream_pcap_file(nio, node.project.id)
+    return StreamingResponse(stream, media_type="application/vnd.tcpdump.pcap")
+
+
+@router.websocket("/{node_id}/console/ws")
+async def console_ws(websocket: WebSocket, node: IOUVM = Depends(dep_node)):
+    """
+    Console WebSocket.
+    """
+
+    await node.start_websocket_console(websocket)
+
+
+@router.post("/{node_id}/console/reset",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def reset_console(node: IOUVM = Depends(dep_node)):
+
+    await node.reset_console()

gns3server/api/routes/compute/nat_nodes.py

@@ -0,0 +1,233 @@
+# -*- coding: utf-8 -*-
+#
+# 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 NAT nodes.
+"""
+
+import os
+
+from fastapi import APIRouter, Depends, status
+from fastapi.encoders import jsonable_encoder
+from fastapi.responses import StreamingResponse
+from typing import Union
+from uuid import UUID
+
+from gns3server import schemas
+from gns3server.compute.builtin import Builtin
+from gns3server.compute.builtin.nodes.nat import Nat
+
+router = APIRouter()
+
+responses = {
+    404: {"model": schemas.ErrorMessage, "description": "Could not find project or NAT node"}
+}
+
+
+def dep_node(project_id: UUID, node_id: UUID):
+    """
+    Dependency to retrieve a node.
+    """
+
+    builtin_manager = Builtin.instance()
+    node = builtin_manager.get_node(str(node_id), project_id=str(project_id))
+    return node
+
+
+@router.post("",
+             response_model=schemas.NAT,
+             status_code=status.HTTP_201_CREATED,
+             responses={409: {"model": schemas.ErrorMessage, "description": "Could not create NAT node"}})
+async def create_nat(project_id: UUID, node_data: schemas.NATCreate):
+    """
+    Create a new NAT node.
+    """
+
+    builtin_manager = Builtin.instance()
+    node_data = jsonable_encoder(node_data, exclude_unset=True)
+    node = await builtin_manager.create_node(node_data.pop("name"),
+                                             str(project_id),
+                                             node_data.get("node_id"),
+                                             node_type="nat",
+                                             ports=node_data.get("ports_mapping"))
+
+    node.usage = node_data.get("usage", "")
+    return node.__json__()
+
+
+@router.get("/{node_id}",
+            response_model=schemas.NAT,
+            responses=responses)
+def get_nat(node: Nat = Depends(dep_node)):
+    """
+    Return a NAT node.
+    """
+
+    return node.__json__()
+
+
+@router.put("/{node_id}",
+            response_model=schemas.NAT,
+            responses=responses)
+def update_nat(node_data: schemas.NATUpdate, node: Nat = Depends(dep_node)):
+    """
+    Update a NAT node.
+    """
+
+    node_data = jsonable_encoder(node_data, exclude_unset=True)
+    for name, value in node_data.items():
+        if hasattr(node, name) and getattr(node, name) != value:
+            setattr(node, name, value)
+    node.updated()
+    return node.__json__()
+
+
+@router.delete("/{node_id}",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_nat(node: Nat = Depends(dep_node)):
+    """
+    Delete a cloud node.
+    """
+
+    await Builtin.instance().delete_node(node.id)
+
+
+@router.post("/{node_id}/start",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def start_nat(node: Nat = Depends(dep_node)):
+    """
+    Start a NAT node.
+    """
+
+    await node.start()
+
+
+@router.post("/{node_id}/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def stop_nat(node: Nat = Depends(dep_node)):
+    """
+    Stop a NAT node.
+    This endpoint results in no action since cloud nodes cannot be stopped.
+    """
+
+    pass
+
+
+@router.post("/{node_id}/suspend",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def suspend_nat(node: Nat = Depends(dep_node)):
+    """
+    Suspend a NAT node.
+    This endpoint results in no action since NAT nodes cannot be suspended.
+    """
+
+    pass
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+             status_code=status.HTTP_201_CREATED,
+             response_model=Union[schemas.EthernetNIO, schemas.TAPNIO, schemas.UDPNIO],
+             responses=responses)
+async def create_nio(adapter_number: int,
+                     port_number: int,
+                     nio_data: Union[schemas.EthernetNIO, schemas.TAPNIO, schemas.UDPNIO],
+                     node: Nat = Depends(dep_node)):
+    """
+    Add a NIO (Network Input/Output) to the node.
+    The adapter number on the cloud is always 0.
+    """
+
+    nio = Builtin.instance().create_nio(jsonable_encoder(nio_data, exclude_unset=True))
+    await node.add_nio(nio, port_number)
+    return nio.__json__()
+
+
+@router.put("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+            status_code=status.HTTP_201_CREATED,
+            response_model=Union[schemas.EthernetNIO, schemas.TAPNIO, schemas.UDPNIO],
+            responses=responses)
+async def update_nio(adapter_number: int,
+                     port_number: int,
+                     nio_data: Union[schemas.EthernetNIO, schemas.TAPNIO, schemas.UDPNIO],
+                     node: Nat = Depends(dep_node)):
+    """
+    Update a NIO (Network Input/Output) to the node.
+    The adapter number on the cloud is always 0.
+    """
+
+    nio = node.get_nio(port_number)
+    if nio_data.filters:
+        nio.filters = nio_data.filters
+    await node.update_nio(port_number, nio)
+    return nio.__json__()
+
+
+@router.delete("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_nio(adapter_number: int, port_number: int, node: Nat = Depends(dep_node)):
+    """
+    Remove a NIO (Network Input/Output) from the node.
+    The adapter number on the cloud is always 0.
+    """
+
+    await node.remove_nio(port_number)
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/start",
+             responses=responses)
+async def start_capture(adapter_number: int,
+                        port_number: int,
+                        node_capture_data: schemas.NodeCapture,
+                        node: Nat = Depends(dep_node)):
+    """
+    Start a packet capture on the node.
+    The adapter number on the cloud is always 0.
+    """
+
+    pcap_file_path = os.path.join(node.project.capture_working_directory(), node_capture_data.capture_file_name)
+    await node.start_capture(port_number, pcap_file_path, node_capture_data.data_link_type)
+    return {"pcap_file_path": pcap_file_path}
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def stop_capture(adapter_number: int, port_number: int, node: Nat = Depends(dep_node)):
+    """
+    Stop a packet capture on the node.
+    The adapter number on the cloud is always 0.
+    """
+
+    await node.stop_capture(port_number)
+
+
+@router.get("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/stream",
+            responses=responses)
+async def stream_pcap_file(adapter_number: int, port_number: int, node: Nat = Depends(dep_node)):
+    """
+    Stream the pcap capture file.
+    The adapter number on the cloud is always 0.
+    """
+
+    nio = node.get_nio(port_number)
+    stream = Builtin.instance().stream_pcap_file(nio, node.project.id)
+    return StreamingResponse(stream, media_type="application/vnd.tcpdump.pcap")

gns3server/api/routes/compute/notifications.py

@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-
+#
+# 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 compute notifications.
+"""
+
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect
+from websockets.exceptions import ConnectionClosed, WebSocketException
+
+from gns3server.compute.notification_manager import NotificationManager
+
+import logging
+log = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+@router.websocket("/notifications/ws")
+async def notification_ws(websocket: WebSocket):
+    """
+    Receive project notifications about the project from WebSocket.
+    """
+
+    await websocket.accept()
+    log.info(f"New client {websocket.client.host}:{websocket.client.port} has connected to compute WebSocket")
+    try:
+        with NotificationManager.instance().queue() as queue:
+            while True:
+                notification = await queue.get_json(5)
+                await websocket.send_text(notification)
+    except (ConnectionClosed, WebSocketDisconnect):
+        log.info(f"Client {websocket.client.host}:{websocket.client.port} has disconnected from compute WebSocket")
+    except WebSocketException as e:
+        log.warning("Error while sending to controller event to WebSocket client: '{}'".format(e))
+    finally:
+        await websocket.close()
+
+
+if __name__ == '__main__':
+
+    import uvicorn
+    from fastapi import FastAPI
+    from starlette.responses import HTMLResponse
+
+    app = FastAPI()
+    app.include_router(router)
+
+    html = """
+    <!DOCTYPE html>
+    <html>
+        <body>
+            <ul id='messages'>
+            </ul>
+            <script>
+                var ws = new WebSocket("ws://localhost:8000/notifications/ws");        
+                ws.onmessage = function(event) {
+                    var messages = document.getElementById('messages')
+                    var message = document.createElement('li')
+                    var content = document.createTextNode(event.data)
+                    message.appendChild(content)
+                    messages.appendChild(message)
+                };
+            </script>
+        </body>
+    </html>
+    """
+
+    @app.get("/")
+    async def get() -> HTMLResponse:
+        return HTMLResponse(html)
+
+    uvicorn.run(app, host="localhost", port=8000)

gns3server/api/routes/compute/projects.py

@@ -0,0 +1,238 @@
+# -*- coding: utf-8 -*-
+#
+# 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/>.
+
+"""
+API routes for projects.
+"""
+
+import os
+
+import logging
+log = logging.getLogger()
+
+from fastapi import APIRouter, Depends, HTTPException, Request, status
+from fastapi.encoders import jsonable_encoder
+from fastapi.responses import FileResponse
+from typing import List
+from uuid import UUID
+
+from gns3server.compute.project_manager import ProjectManager
+from gns3server.compute.project import Project
+from gns3server import schemas
+
+
+router = APIRouter()
+
+# How many clients have subscribed to notifications
+_notifications_listening = {}
+
+
+def dep_project(project_id: UUID):
+    """
+    Dependency to retrieve a project.
+    """
+
+    pm = ProjectManager.instance()
+    project = pm.get_project(str(project_id))
+    return project
+
+
+@router.get("/projects", response_model=List[schemas.Project])
+def get_projects():
+    """
+    Get all projects opened on the compute.
+    """
+
+    pm = ProjectManager.instance()
+    return [p.__json__() for p in pm.projects]
+
+
+@router.post("/projects",
+             status_code=status.HTTP_201_CREATED,
+             response_model=schemas.Project)
+def create_project(project_data: schemas.ProjectCreate):
+    """
+    Create a new project on the compute.
+    """
+
+    pm = ProjectManager.instance()
+    project_data = jsonable_encoder(project_data, exclude_unset=True)
+    project = pm.create_project(name=project_data.get("name"),
+                                path=project_data.get("path"),
+                                project_id=project_data.get("project_id"),
+                                variables=project_data.get("variables", None))
+    return project.__json__()
+
+
+@router.put("/projects/{project_id}",
+             response_model=schemas.Project)
+async def update_project(project_data: schemas.ProjectUpdate, project: Project = Depends(dep_project)):
+    """
+    Update project on the compute.
+    """
+
+    await project.update(variables=project_data.variables)
+    return project.__json__()
+
+
+@router.get("/projects/{project_id}",
+            response_model=schemas.Project)
+def get_project(project: Project = Depends(dep_project)):
+    """
+    Return a project from the compute.
+    """
+
+    return project.__json__()
+
+
+@router.post("/projects/{project_id}/close",
+             status_code=status.HTTP_204_NO_CONTENT)
+async def close_project(project: Project = Depends(dep_project)):
+    """
+    Close a project on the compute.
+    """
+
+    # FIXME
+    if _notifications_listening.setdefault(project.id, 0) <= 1:
+        await project.close()
+        ProjectManager.instance().remove_project(project.id)
+        try:
+            del _notifications_listening[project.id]
+        except KeyError:
+            pass
+    else:
+        log.warning("Skip project closing, another client is listening for project notifications")
+
+
+@router.delete("/projects/{project_id}",
+               status_code=status.HTTP_204_NO_CONTENT)
+async def delete_project(project: Project = Depends(dep_project)):
+    """
+    Delete project from the compute.
+    """
+
+    await project.delete()
+    ProjectManager.instance().remove_project(project.id)
+
+# @Route.get(
+#     r"/projects/{project_id}/notifications",
+#     description="Receive notifications about the project",
+#     parameters={
+#         "project_id": "Project UUID",
+#     },
+#     status_codes={
+#         200: "End of stream",
+#         404: "The project doesn't exist"
+#     })
+# async def notification(request, response):
+#
+#     pm = ProjectManager.instance()
+#     project = pm.get_project(request.match_info["project_id"])
+#
+#     response.content_type = "application/json"
+#     response.set_status(200)
+#     response.enable_chunked_encoding()
+#
+#     response.start(request)
+#     queue = project.get_listen_queue()
+#     ProjectHandler._notifications_listening.setdefault(project.id, 0)
+#     ProjectHandler._notifications_listening[project.id] += 1
+#     await response.write("{}\n".format(json.dumps(ProjectHandler._getPingMessage())).encode("utf-8"))
+#     while True:
+#         try:
+#             (action, msg) = await asyncio.wait_for(queue.get(), 5)
+#             if hasattr(msg, "__json__"):
+#                 msg = json.dumps({"action": action, "event": msg.__json__()}, sort_keys=True)
+#             else:
+#                 msg = json.dumps({"action": action, "event": msg}, sort_keys=True)
+#             log.debug("Send notification: %s", msg)
+#             await response.write(("{}\n".format(msg)).encode("utf-8"))
+#         except asyncio.TimeoutError:
+#             await response.write("{}\n".format(json.dumps(ProjectHandler._getPingMessage())).encode("utf-8"))
+#     project.stop_listen_queue(queue)
+#     if project.id in ProjectHandler._notifications_listening:
+#         ProjectHandler._notifications_listening[project.id] -= 1
+
+# def _getPingMessage(cls):
+#     """
+#     Ping messages are regularly sent to the client to
+#     keep the connection open. We send with it some information about server load.
+#
+#     :returns: hash
+#     """
+#     stats = {}
+#     # Non blocking call in order to get cpu usage. First call will return 0
+#     stats["cpu_usage_percent"] = CpuPercent.get(interval=None)
+#     stats["memory_usage_percent"] = psutil.virtual_memory().percent
+#     stats["disk_usage_percent"] = psutil.disk_usage(get_default_project_directory()).percent
+#     return {"action": "ping", "event": stats}
+
+
+@router.get("/projects/{project_id}/files",
+            response_model=List[schemas.ProjectFile])
+async def get_project_files(project: Project = Depends(dep_project)):
+    """
+    Return files belonging to a project.
+    """
+
+    return await project.list_files()
+
+
+@router.get("/projects/{project_id}/files/{file_path:path}")
+async def get_file(file_path: str, project: Project = Depends(dep_project)):
+    """
+    Get a file from a project.
+    """
+
+    path = os.path.normpath(file_path)
+
+    # Raise error if user try to escape
+    if path[0] == ".":
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)
+
+    path = os.path.join(project.path, path)
+    if not os.path.exists(path):
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
+
+    return FileResponse(path, media_type="application/octet-stream")
+
+
+@router.post("/projects/{project_id}/files/{file_path:path}",
+             status_code=status.HTTP_204_NO_CONTENT)
+async def write_file(file_path: str, request: Request, project: Project = Depends(dep_project)):
+
+    path = os.path.normpath(file_path)
+
+    # Raise error if user try to escape
+    if path[0] == ".":
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)
+
+    path = os.path.join(project.path, path)
+    try:
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+
+        try:
+            with open(path, "wb+") as f:
+                async for chunk in request.stream():
+                    f.write(chunk)
+        except (UnicodeEncodeError, OSError) as e:
+            pass  # FIXME
+
+    except FileNotFoundError:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
+    except PermissionError:
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)

gns3server/api/routes/compute/qemu_nodes.py

@@ -0,0 +1,310 @@
+# -*- coding: utf-8 -*-
+#
+# 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 Qemu nodes.
+"""
+
+import os
+import sys
+
+from fastapi import APIRouter, WebSocket, Depends, Body, status
+from fastapi.encoders import jsonable_encoder
+from fastapi.responses import StreamingResponse
+from uuid import UUID
+
+from gns3server import schemas
+from gns3server.compute.project_manager import ProjectManager
+from gns3server.compute.qemu import Qemu
+from gns3server.compute.qemu.qemu_vm import QemuVM
+
+router = APIRouter()
+
+responses = {
+    404: {"model": schemas.ErrorMessage, "description": "Could not find project or Qemu node"}
+}
+
+
+def dep_node(project_id: UUID, node_id: UUID):
+    """
+    Dependency to retrieve a node.
+    """
+
+    qemu_manager = Qemu.instance()
+    node = qemu_manager.get_node(str(node_id), project_id=str(project_id))
+    return node
+
+
+@router.post("",
+             response_model=schemas.Qemu,
+             status_code=status.HTTP_201_CREATED,
+             responses={409: {"model": schemas.ErrorMessage, "description": "Could not create Qemu node"}})
+async def create_qemu_node(project_id: UUID, node_data: schemas.QemuCreate):
+    """
+    Create a new Qemu node.
+    """
+
+    qemu = Qemu.instance()
+    node_data = jsonable_encoder(node_data, exclude_unset=True)
+    vm = await qemu.create_node(node_data.pop("name"),
+                                str(project_id),
+                                node_data.pop("node_id", None),
+                                linked_clone=node_data.get("linked_clone", True),
+                                qemu_path=node_data.pop("qemu_path", None),
+                                console=node_data.pop("console", None),
+                                console_type=node_data.pop("console_type", "telnet"),
+                                aux=node_data.get("aux"),
+                                aux_type=node_data.pop("aux_type", "none"),
+                                platform=node_data.pop("platform", None))
+
+    for name, value in node_data.items():
+        if hasattr(vm, name) and getattr(vm, name) != value:
+            setattr(vm, name, value)
+
+    return vm.__json__()
+
+
+@router.get("/{node_id}",
+            response_model=schemas.Qemu,
+            responses=responses)
+def get_qemu_node(node: QemuVM = Depends(dep_node)):
+    """
+    Return a Qemu node.
+    """
+
+    return node.__json__()
+
+
+@router.put("/{node_id}",
+            response_model=schemas.Qemu,
+            responses=responses)
+async def update_qemu_node(node_data: schemas.QemuUpdate, node: QemuVM = Depends(dep_node)):
+    """
+    Update a Qemu node.
+    """
+
+    node_data = jsonable_encoder(node_data, exclude_unset=True)
+    # update the console first to avoid issue if updating console type
+    node.console = node_data.pop("console", node.console)
+    for name, value in node_data.items():
+        if hasattr(node, name) and getattr(node, name) != value:
+            await node.update_property(name, value)
+    node.updated()
+    return node.__json__()
+
+
+@router.delete("/{node_id}",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_qemu_node(node: QemuVM = Depends(dep_node)):
+    """
+    Delete a Qemu node.
+    """
+
+    await Qemu.instance().delete_node(node.id)
+
+
+@router.post("/{node_id}/duplicate",
+             response_model=schemas.Qemu,
+             status_code=status.HTTP_201_CREATED,
+             responses=responses)
+async def duplicate_qemu_node(destination_node_id: UUID = Body(..., embed=True), node: QemuVM = Depends(dep_node)):
+    """
+    Duplicate a Qemu node.
+    """
+
+    new_node = await Qemu.instance().duplicate_node(node.id, str(destination_node_id))
+    return new_node.__json__()
+
+
+@router.post("/{node_id}/resize_disk",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def resize_qemu_node_disk(node_data: schemas.QemuDiskResize, node: QemuVM = Depends(dep_node)):
+
+    await node.resize_disk(node_data.drive_name, node_data.extend)
+
+
+@router.post("/{node_id}/start",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def start_qemu_node(node: QemuVM = Depends(dep_node)):
+    """
+    Start a Qemu node.
+    """
+
+    qemu_manager = Qemu.instance()
+    hardware_accel = qemu_manager.config.get_section_config("Qemu").getboolean("enable_hardware_acceleration", True)
+    if sys.platform.startswith("linux"):
+        # the enable_kvm option was used before version 2.0 and has priority
+        enable_kvm = qemu_manager.config.get_section_config("Qemu").getboolean("enable_kvm")
+        if enable_kvm is not None:
+            hardware_accel = enable_kvm
+    if hardware_accel and "-no-kvm" not in node.options and "-no-hax" not in node.options:
+        pm = ProjectManager.instance()
+        if pm.check_hardware_virtualization(node) is False:
+            pass  #FIXME: check this
+            #raise ComputeError("Cannot start VM with hardware acceleration (KVM/HAX) enabled because hardware virtualization (VT-x/AMD-V) is already used by another software like VMware or VirtualBox")
+    await node.start()
+
+
+@router.post("/{node_id}/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def stop_qemu_node(node: QemuVM = Depends(dep_node)):
+    """
+    Stop a Qemu node.
+    """
+
+    await node.stop()
+
+
+@router.post("/{node_id}/reload",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def reload_qemu_node(node: QemuVM = Depends(dep_node)):
+    """
+    Reload a Qemu node.
+    """
+
+    await node.reload()
+
+
+@router.post("/{node_id}/suspend",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def suspend_qemu_node(node: QemuVM = Depends(dep_node)):
+    """
+    Suspend a Qemu node.
+    """
+
+    await node.suspend()
+
+
+@router.post("/{node_id}/resume",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def resume_qemu_node(node: QemuVM = Depends(dep_node)):
+    """
+    Resume a Qemu node.
+    """
+
+    await node.resume()
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+             status_code=status.HTTP_201_CREATED,
+             response_model=schemas.UDPNIO,
+             responses=responses)
+async def create_nio(adapter_number: int, port_number: int, nio_data: schemas.UDPNIO, node: QemuVM = Depends(dep_node)):
+    """
+    Add a NIO (Network Input/Output) to the node.
+    The port number on the Qemu node is always 0.
+    """
+
+    nio = Qemu.instance().create_nio(jsonable_encoder(nio_data, exclude_unset=True))
+    await node.adapter_add_nio_binding(adapter_number, nio)
+    return nio.__json__()
+
+
+@router.put("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+            status_code=status.HTTP_201_CREATED,
+            response_model=schemas.UDPNIO,
+            responses=responses)
+async def update_nio(adapter_number: int, port_number: int, nio_data: schemas.UDPNIO, node: QemuVM = Depends(dep_node)):
+    """
+    Update a NIO (Network Input/Output) on the node.
+    The port number on the Qemu node is always 0.
+    """
+
+    nio = node.get_nio(adapter_number)
+    if nio_data.filters:
+        nio.filters = nio_data.filters
+    if nio_data.suspend:
+        nio.suspend = nio_data.suspend
+    await node.adapter_update_nio_binding(adapter_number, nio)
+    return nio.__json__()
+
+
+@router.delete("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_nio(adapter_number: int, port_number: int, node: QemuVM = Depends(dep_node)):
+    """
+    Delete a NIO (Network Input/Output) from the node.
+    The port number on the Qemu node is always 0.
+    """
+
+    await node.adapter_remove_nio_binding(adapter_number)
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/start",
+             responses=responses)
+async def start_capture(adapter_number: int,
+                        port_number: int,
+                        node_capture_data: schemas.NodeCapture,
+                        node: QemuVM = Depends(dep_node)):
+    """
+    Start a packet capture on the node.
+    The port number on the Qemu node is always 0.
+    """
+
+    pcap_file_path = os.path.join(node.project.capture_working_directory(), node_capture_data.capture_file_name)
+    await node.start_capture(adapter_number, pcap_file_path)
+    return {"pcap_file_path": str(pcap_file_path)}
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def stop_capture(adapter_number: int, port_number: int, node: QemuVM = Depends(dep_node)):
+    """
+    Stop a packet capture on the node.
+    The port number on the Qemu node is always 0.
+    """
+
+    await node.stop_capture(adapter_number)
+
+
+@router.get("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/stream",
+            responses=responses)
+async def stream_pcap_file(adapter_number: int, port_number: int, node: QemuVM = Depends(dep_node)):
+    """
+    Stream the pcap capture file.
+    The port number on the Qemu node is always 0.
+    """
+
+    nio = node.get_nio(adapter_number)
+    stream = Qemu.instance().stream_pcap_file(nio, node.project.id)
+    return StreamingResponse(stream, media_type="application/vnd.tcpdump.pcap")
+
+
+@router.websocket("/{node_id}/console/ws")
+async def console_ws(websocket: WebSocket, node: QemuVM = Depends(dep_node)):
+    """
+    Console WebSocket.
+    """
+
+    await node.start_websocket_console(websocket)
+
+
+@router.post("/{node_id}/console/reset",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def reset_console(node: QemuVM = Depends(dep_node)):
+
+    await node.reset_console()

gns3server/api/routes/compute/virtualbox_nodes.py

@@ -0,0 +1,318 @@
+# -*- coding: utf-8 -*-
+#
+# 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 VirtualBox nodes.
+"""
+
+import os
+
+from fastapi import APIRouter, WebSocket, Depends, status
+from fastapi.encoders import jsonable_encoder
+from fastapi.responses import StreamingResponse
+from uuid import UUID
+
+from gns3server import schemas
+from gns3server.compute.virtualbox import VirtualBox
+from gns3server.compute.virtualbox.virtualbox_error import VirtualBoxError
+from gns3server.compute.project_manager import ProjectManager
+from gns3server.compute.virtualbox.virtualbox_vm import VirtualBoxVM
+
+router = APIRouter()
+
+responses = {
+    404: {"model": schemas.ErrorMessage, "description": "Could not find project or VirtualBox node"}
+}
+
+
+def dep_node(project_id: UUID, node_id: UUID):
+    """
+    Dependency to retrieve a node.
+    """
+
+    vbox_manager = VirtualBox.instance()
+    node = vbox_manager.get_node(str(node_id), project_id=str(project_id))
+    return node
+
+
+@router.post("",
+             response_model=schemas.VirtualBox,
+             status_code=status.HTTP_201_CREATED,
+             responses={409: {"model": schemas.ErrorMessage, "description": "Could not create VirtualBox node"}})
+async def create_virtualbox_node(project_id: UUID, node_data: schemas.VirtualBoxCreate):
+    """
+    Create a new VirtualBox node.
+    """
+
+    vbox_manager = VirtualBox.instance()
+    node_data = jsonable_encoder(node_data, exclude_unset=True)
+    vm = await vbox_manager.create_node(node_data.pop("name"),
+                                        str(project_id),
+                                        node_data.get("node_id"),
+                                        node_data.pop("vmname"),
+                                        linked_clone=node_data.pop("linked_clone", False),
+                                        console=node_data.get("console", None),
+                                        console_type=node_data.get("console_type", "telnet"),
+                                        adapters=node_data.get("adapters", 0))
+
+    if "ram" in node_data:
+        ram = node_data.pop("ram")
+        if ram != vm.ram:
+            await vm.set_ram(ram)
+
+    for name, value in node_data.items():
+        if name != "node_id":
+            if hasattr(vm, name) and getattr(vm, name) != value:
+                setattr(vm, name, value)
+
+    return vm.__json__()
+
+
+@router.get("/{node_id}",
+            response_model=schemas.VirtualBox,
+            responses=responses)
+def get_virtualbox_node(node: VirtualBoxVM = Depends(dep_node)):
+    """
+    Return a VirtualBox node.
+    """
+
+    return node.__json__()
+
+
+@router.put("/{node_id}",
+            response_model=schemas.VirtualBox,
+            responses=responses)
+async def update_virtualbox_node(node_data: schemas.VirtualBoxUpdate, node: VirtualBoxVM = Depends(dep_node)):
+    """
+    Update a VirtualBox node.
+    """
+
+    node_data = jsonable_encoder(node_data, exclude_unset=True)
+    if "name" in node_data:
+        name = node_data.pop("name")
+        vmname = node_data.pop("vmname", None)
+        if name != node.name:
+            oldname = node.name
+            node.name = name
+            if node.linked_clone:
+                try:
+                    await node.set_vmname(node.name)
+                except VirtualBoxError as e:  # In case of error we rollback (we can't change the name when running)
+                    node.name = oldname
+                    node.updated()
+                    raise e
+
+    if "adapters" in node_data:
+        adapters = node_data.pop("adapters")
+        if adapters != node.adapters:
+            await node.set_adapters(adapters)
+
+    if "ram" in node_data:
+        ram = node_data.pop("ram")
+        if ram != node.ram:
+            await node.set_ram(ram)
+
+    # update the console first to avoid issue if updating console type
+    node.console = node_data.pop("console", node.console)
+
+    for name, value in node_data.items():
+        if hasattr(node, name) and getattr(node, name) != value:
+            setattr(node, name, value)
+
+    node.updated()
+    return node.__json__()
+
+
+@router.delete("/{node_id}",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_virtualbox_node(node: VirtualBoxVM = Depends(dep_node)):
+    """
+    Delete a VirtualBox node.
+    """
+
+    await VirtualBox.instance().delete_node(node.id)
+
+
+@router.post("/{node_id}/start",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def start_virtualbox_node(node: VirtualBoxVM = Depends(dep_node)):
+    """
+    Start a VirtualBox node.
+    """
+
+    if await node.check_hw_virtualization():
+        pm = ProjectManager.instance()
+        if pm.check_hardware_virtualization(node) is False:
+            pass  # FIXME: check this
+            #raise ComputeError("Cannot start VM with hardware acceleration (KVM/HAX) enabled because hardware virtualization (VT-x/AMD-V) is already used by another software like VMware or VirtualBox")
+    await node.start()
+
+
+@router.post("/{node_id}/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def stop_virtualbox_node(node: VirtualBoxVM = Depends(dep_node)):
+    """
+    Stop a VirtualBox node.
+    """
+
+    await node.stop()
+
+
+@router.post("/{node_id}/suspend",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def suspend_virtualbox_node(node: VirtualBoxVM = Depends(dep_node)):
+    """
+    Suspend a VirtualBox node.
+    """
+
+    await node.suspend()
+
+
+@router.post("/{node_id}/resume",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def resume_virtualbox_node(node: VirtualBoxVM = Depends(dep_node)):
+    """
+    Resume a VirtualBox node.
+    """
+
+    await node.resume()
+
+
+@router.post("/{node_id}/reload",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def reload_virtualbox_node(node: VirtualBoxVM = Depends(dep_node)):
+    """
+    Reload a VirtualBox node.
+    """
+
+    await node.reload()
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+             status_code=status.HTTP_201_CREATED,
+             response_model=schemas.UDPNIO,
+             responses=responses)
+async def create_nio(adapter_number: int,
+                     port_number: int,
+                     nio_data: schemas.UDPNIO,
+                     node: VirtualBoxVM = Depends(dep_node)):
+    """
+    Add a NIO (Network Input/Output) to the node.
+    The port number on the VirtualBox node is always 0.
+    """
+
+    nio = VirtualBox.instance().create_nio(jsonable_encoder(nio_data, exclude_unset=True))
+    await node.adapter_add_nio_binding(adapter_number, nio)
+    return nio.__json__()
+
+
+@router.put("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+            status_code=status.HTTP_201_CREATED,
+            response_model=schemas.UDPNIO,
+            responses=responses)
+async def update_nio(adapter_number: int,
+                     port_number: int,
+                     nio_data: schemas.UDPNIO,
+                     node: VirtualBoxVM = Depends(dep_node)):
+    """
+    Update a NIO (Network Input/Output) on the node.
+    The port number on the VirtualBox node is always 0.
+    """
+
+    nio = node.get_nio(adapter_number)
+    if nio_data.filters:
+        nio.filters = nio_data.filters
+    if nio_data.suspend:
+        nio.suspend = nio_data.suspend
+    await node.adapter_update_nio_binding(adapter_number, nio)
+    return nio.__json__()
+
+
+@router.delete("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_nio(adapter_number: int, port_number: int, node: VirtualBoxVM = Depends(dep_node)):
+    """
+    Delete a NIO (Network Input/Output) from the node.
+    The port number on the VirtualBox node is always 0.
+    """
+
+    await node.adapter_remove_nio_binding(adapter_number)
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/start",
+             responses=responses)
+async def start_capture(adapter_number: int,
+                        port_number: int,
+                        node_capture_data: schemas.NodeCapture,
+                        node: VirtualBoxVM = Depends(dep_node)):
+    """
+    Start a packet capture on the node.
+    The port number on the VirtualBox node is always 0.
+    """
+
+    pcap_file_path = os.path.join(node.project.capture_working_directory(), node_capture_data.capture_file_name)
+    await node.start_capture(adapter_number, pcap_file_path)
+    return {"pcap_file_path": str(pcap_file_path)}
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def stop_capture(adapter_number: int, port_number: int, node: VirtualBoxVM = Depends(dep_node)):
+    """
+    Stop a packet capture on the node.
+    The port number on the VirtualBox node is always 0.
+    """
+
+    await node.stop_capture(adapter_number)
+
+
+@router.get("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/stream",
+            responses=responses)
+async def stream_pcap_file(adapter_number: int, port_number: int, node: VirtualBoxVM = Depends(dep_node)):
+    """
+    Stream the pcap capture file.
+    The port number on the VirtualBox node is always 0.
+    """
+
+    nio = node.get_nio(adapter_number)
+    stream = VirtualBox.instance().stream_pcap_file(nio, node.project.id)
+    return StreamingResponse(stream, media_type="application/vnd.tcpdump.pcap")
+
+
+@router.websocket("/{node_id}/console/ws")
+async def console_ws(websocket: WebSocket, node: VirtualBoxVM = Depends(dep_node)):
+    """
+    Console WebSocket.
+    """
+
+    await node.start_websocket_console(websocket)
+
+
+@router.post("/{node_id}/console/reset",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def reset_console(node: VirtualBoxVM = Depends(dep_node)):
+
+    await node.reset_console()

gns3server/api/routes/compute/vmware_nodes.py

@@ -0,0 +1,298 @@
+# -*- coding: utf-8 -*-
+#
+# 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 VMware nodes.
+"""
+
+import os
+
+from fastapi import APIRouter, WebSocket, Depends, status
+from fastapi.encoders import jsonable_encoder
+from fastapi.responses import StreamingResponse
+from uuid import UUID
+
+from gns3server import schemas
+from gns3server.compute.vmware import VMware
+from gns3server.compute.project_manager import ProjectManager
+from gns3server.compute.vmware.vmware_vm import VMwareVM
+
+router = APIRouter()
+
+responses = {
+    404: {"model": schemas.ErrorMessage, "description": "Could not find project or VMware node"}
+}
+
+
+def dep_node(project_id: UUID, node_id: UUID):
+    """
+    Dependency to retrieve a node.
+    """
+
+    vmware_manager = VMware.instance()
+    node = vmware_manager.get_node(str(node_id), project_id=str(project_id))
+    return node
+
+
+@router.post("",
+             response_model=schemas.VMware,
+             status_code=status.HTTP_201_CREATED,
+             responses={409: {"model": schemas.ErrorMessage, "description": "Could not create VMware node"}})
+async def create_vmware_node(project_id: UUID, node_data: schemas.VMwareCreate):
+    """
+    Create a new VMware node.
+    """
+
+    vmware_manager = VMware.instance()
+    node_data = jsonable_encoder(node_data, exclude_unset=True)
+    vm = await vmware_manager.create_node(node_data.pop("name"),
+                                          str(project_id),
+                                          node_data.get("node_id"),
+                                          node_data.pop("vmx_path"),
+                                          linked_clone=node_data.pop("linked_clone"),
+                                          console=node_data.get("console", None),
+                                          console_type=node_data.get("console_type", "telnet"))
+
+    for name, value in node_data.items():
+        if name != "node_id":
+            if hasattr(vm, name) and getattr(vm, name) != value:
+                setattr(vm, name, value)
+
+    return vm.__json__()
+
+
+@router.get("/{node_id}",
+            response_model=schemas.VMware,
+            responses=responses)
+def get_vmware_node(node: VMwareVM = Depends(dep_node)):
+    """
+    Return a VMware node.
+    """
+
+    return node.__json__()
+
+
+@router.put("/{node_id}",
+            response_model=schemas.VMware,
+            responses=responses)
+def update_vmware_node(node_data: schemas.VMwareUpdate, node: VMwareVM = Depends(dep_node)):
+    """
+    Update a VMware node.
+    """
+
+    node_data = jsonable_encoder(node_data, exclude_unset=True)
+    # update the console first to avoid issue if updating console type
+    node.console = node_data.pop("console", node.console)
+    for name, value in node_data.items():
+        if hasattr(node, name) and getattr(node, name) != value:
+            setattr(node, name, value)
+
+    node.updated()
+    return node.__json__()
+
+
+@router.delete("/{node_id}",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_vmware_node(node: VMwareVM = Depends(dep_node)):
+    """
+    Delete a VMware node.
+    """
+
+    await VMware.instance().delete_node(node.id)
+
+
+@router.post("/{node_id}/start",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def start_vmware_node(node: VMwareVM = Depends(dep_node)):
+    """
+    Start a VMware node.
+    """
+
+    if node.check_hw_virtualization():
+        pm = ProjectManager.instance()
+        if pm.check_hardware_virtualization(node) is False:
+            pass # FIXME: check this
+            #raise ComputeError("Cannot start VM with hardware acceleration (KVM/HAX) enabled because hardware virtualization (VT-x/AMD-V) is already used by another software like VMware or VirtualBox")
+    await node.start()
+
+
+@router.post("/{node_id}/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def stop_vmware_node(node: VMwareVM = Depends(dep_node)):
+    """
+    Stop a VMware node.
+    """
+
+    await node.stop()
+
+
+@router.post("/{node_id}/suspend",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def suspend_vmware_node(node: VMwareVM = Depends(dep_node)):
+    """
+    Suspend a VMware node.
+    """
+
+    await node.suspend()
+
+
+@router.post("/{node_id}/resume",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def resume_vmware_node(node: VMwareVM = Depends(dep_node)):
+    """
+    Resume a VMware node.
+    """
+
+    await node.resume()
+
+
+@router.post("/{node_id}/reload",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def reload_vmware_node(node: VMwareVM = Depends(dep_node)):
+    """
+    Reload a VMware node.
+    """
+
+    await node.reload()
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+             status_code=status.HTTP_201_CREATED,
+             response_model=schemas.UDPNIO,
+             responses=responses)
+async def create_nio(adapter_number: int,
+                     port_number: int,
+                     nio_data: schemas.UDPNIO,
+                     node: VMwareVM = Depends(dep_node)):
+    """
+    Add a NIO (Network Input/Output) to the node.
+    The port number on the VMware node is always 0.
+    """
+
+    nio = VMware.instance().create_nio(jsonable_encoder(nio_data, exclude_unset=True))
+    await node.adapter_add_nio_binding(adapter_number, nio)
+    return nio.__json__()
+
+
+@router.put("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+            status_code=status.HTTP_201_CREATED,
+            response_model=schemas.UDPNIO,
+            responses=responses)
+async def update_nio(adapter_number: int,
+                     port_number: int,
+                     nio_data: schemas.UDPNIO, node: VMwareVM = Depends(dep_node)):
+    """
+    Update a NIO (Network Input/Output) on the node.
+    The port number on the VMware node is always 0.
+    """
+
+    nio = node.get_nio(adapter_number)
+    if nio_data.filters:
+        nio.filters = nio_data.filters
+    await node.adapter_update_nio_binding(adapter_number, nio)
+    return nio.__json__()
+
+
+@router.delete("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_nio(adapter_number: int, port_number: int, node: VMwareVM = Depends(dep_node)):
+    """
+    Delete a NIO (Network Input/Output) from the node.
+    The port number on the VMware node is always 0.
+    """
+
+    await node.adapter_remove_nio_binding(adapter_number)
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/start",
+             responses=responses)
+async def start_capture(adapter_number: int,
+                        port_number: int,
+                        node_capture_data: schemas.NodeCapture,
+                        node: VMwareVM = Depends(dep_node)):
+    """
+    Start a packet capture on the node.
+    The port number on the VMware node is always 0.
+    """
+
+    pcap_file_path = os.path.join(node.project.capture_working_directory(), node_capture_data.capture_file_name)
+    await node.start_capture(adapter_number, pcap_file_path)
+    return {"pcap_file_path": pcap_file_path}
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def stop_capture(adapter_number: int, port_number: int, node: VMwareVM = Depends(dep_node)):
+    """
+    Stop a packet capture on the node.
+    The port number on the VMware node is always 0.
+    """
+
+    await node.stop_capture(adapter_number)
+
+
+@router.get("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/stream",
+            responses=responses)
+async def stream_pcap_file(adapter_number: int, port_number: int, node: VMwareVM = Depends(dep_node)):
+    """
+    Stream the pcap capture file.
+    The port number on the VMware node is always 0.
+    """
+
+    nio = node.get_nio(adapter_number)
+    stream = VMware.instance().stream_pcap_file(nio, node.project.id)
+    return StreamingResponse(stream, media_type="application/vnd.tcpdump.pcap")
+
+
+@router.post("/{node_id}/interfaces/vmnet",
+             status_code=status.HTTP_201_CREATED,
+             responses=responses)
+def allocate_vmnet(node: VMwareVM = Depends(dep_node)) -> dict:
+    """
+    Allocate a VMware VMnet interface on the server.
+    """
+
+    vmware_manager = VMware.instance()
+    vmware_manager.refresh_vmnet_list(ubridge=False)
+    vmnet = vmware_manager.allocate_vmnet()
+    node.vmnets.append(vmnet)
+    return {"vmnet": vmnet}
+
+
+@router.websocket("/{node_id}/console/ws")
+async def console_ws(websocket: WebSocket, node: VMwareVM = Depends(dep_node)):
+    """
+    Console WebSocket.
+    """
+
+    await node.start_websocket_console(websocket)
+
+
+@router.post("/{node_id}/console/reset",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def reset_console(node: VMwareVM = Depends(dep_node)):
+
+    await node.reset_console()

gns3server/api/routes/compute/vpcs_nodes.py

@@ -0,0 +1,266 @@
+# -*- coding: utf-8 -*-
+#
+# 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 VPCS nodes.
+"""
+
+import os
+
+from fastapi import APIRouter, WebSocket, Depends, Body, status
+from fastapi.encoders import jsonable_encoder
+from fastapi.responses import StreamingResponse
+from uuid import UUID
+
+from gns3server import schemas
+from gns3server.compute.vpcs import VPCS
+from gns3server.compute.vpcs.vpcs_vm import VPCSVM
+
+router = APIRouter()
+
+responses = {
+    404: {"model": schemas.ErrorMessage, "description": "Could not find project or VMware node"}
+}
+
+
+def dep_node(project_id: UUID, node_id: UUID):
+    """
+    Dependency to retrieve a node.
+    """
+
+    vpcs_manager = VPCS.instance()
+    node = vpcs_manager.get_node(str(node_id), project_id=str(project_id))
+    return node
+
+
+@router.post("",
+             response_model=schemas.VPCS,
+             status_code=status.HTTP_201_CREATED,
+             responses={409: {"model": schemas.ErrorMessage, "description": "Could not create VMware node"}})
+async def create_vpcs_node(project_id: UUID, node_data: schemas.VPCSCreate):
+    """
+    Create a new VPCS node.
+    """
+
+    vpcs = VPCS.instance()
+    node_data = jsonable_encoder(node_data, exclude_unset=True)
+    vm = await vpcs.create_node(node_data["name"],
+                                str(project_id),
+                                node_data.get("node_id"),
+                                console=node_data.get("console"),
+                                console_type=node_data.get("console_type", "telnet"),
+                                startup_script=node_data.get("startup_script"))
+
+    return vm.__json__()
+
+
+@router.get("/{node_id}",
+            response_model=schemas.VPCS,
+            responses=responses)
+def get_vpcs_node(node: VPCSVM = Depends(dep_node)):
+    """
+    Return a VPCS node.
+    """
+
+    return node.__json__()
+
+
+@router.put("/{node_id}",
+            response_model=schemas.VPCS,
+            responses=responses)
+def update_vpcs_node(node_data: schemas.VPCSUpdate, node: VPCSVM = Depends(dep_node)):
+    """
+    Update a VPCS node.
+    """
+
+    node_data = jsonable_encoder(node_data, exclude_unset=True)
+    node.name = node_data.get("name", node.name)
+    node.console = node_data.get("console", node.console)
+    node.console_type = node_data.get("console_type", node.console_type)
+    node.updated()
+    return node.__json__()
+
+
+@router.delete("/{node_id}",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_vpcs_node(node: VPCSVM = Depends(dep_node)):
+    """
+    Delete a VPCS node.
+    """
+
+    await VPCS.instance().delete_node(node.id)
+
+
+@router.post("/{node_id}/duplicate",
+             response_model=schemas.VPCS,
+             status_code=status.HTTP_201_CREATED,
+             responses=responses)
+async def duplicate_vpcs_node(destination_node_id: UUID = Body(..., embed=True), node: VPCSVM = Depends(dep_node)):
+    """
+    Duplicate a VPCS node.
+    """
+
+    new_node = await VPCS.instance().duplicate_node(node.id, str(destination_node_id))
+    return new_node.__json__()
+
+
+@router.post("/{node_id}/start",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def start_vpcs_node(node: VPCSVM = Depends(dep_node)):
+    """
+    Start a VPCS node.
+    """
+
+    await node.start()
+
+
+@router.post("/{node_id}/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def stop_vpcs_node(node: VPCSVM = Depends(dep_node)):
+    """
+    Stop a VPCS node.
+    """
+
+    await node.stop()
+
+
+@router.post("/{node_id}/suspend",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def suspend_vpcs_node(node: VPCSVM = Depends(dep_node)):
+    """
+    Suspend a VPCS node.
+    Does nothing, suspend is not supported by VPCS.
+    """
+
+    pass
+
+
+@router.post("/{node_id}/reload",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def reload_vpcs_node(node: VPCSVM = Depends(dep_node)):
+    """
+    Reload a VPCS node.
+    """
+
+    await node.reload()
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+             status_code=status.HTTP_201_CREATED,
+             response_model=schemas.UDPNIO,
+             responses=responses)
+async def create_nio(adapter_number: int, port_number: int, nio_data: schemas.UDPNIO, node: VPCSVM = Depends(dep_node)):
+    """
+    Add a NIO (Network Input/Output) to the node.
+    The adapter number on the VPCS node is always 0.
+    """
+
+    nio = VPCS.instance().create_nio(jsonable_encoder(nio_data, exclude_unset=True))
+    await node.port_add_nio_binding(port_number, nio)
+    return nio.__json__()
+
+
+@router.put("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+            status_code=status.HTTP_201_CREATED,
+            response_model=schemas.UDPNIO,
+            responses=responses)
+async def update_nio(adapter_number: int, port_number: int, nio_data: schemas.UDPNIO, node: VPCSVM = Depends(dep_node)):
+    """
+    Update a NIO (Network Input/Output) on the node.
+    The adapter number on the VPCS node is always 0.
+    """
+
+    nio = node.get_nio(port_number)
+    if nio_data.filters:
+        nio.filters = nio_data.filters
+    await node.port_update_nio_binding(port_number, nio)
+    return nio.__json__()
+
+
+@router.delete("/{node_id}/adapters/{adapter_number}/ports/{port_number}/nio",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_nio(adapter_number: int, port_number: int, node: VPCSVM = Depends(dep_node)):
+    """
+    Delete a NIO (Network Input/Output) from the node.
+    The adapter number on the VPCS node is always 0.
+    """
+
+    await node.port_remove_nio_binding(port_number)
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/start",
+             responses=responses)
+async def start_capture(adapter_number: int,
+                        port_number: int,
+                        node_capture_data: schemas.NodeCapture,
+                        node: VPCSVM = Depends(dep_node)):
+    """
+    Start a packet capture on the node.
+    The adapter number on the VPCS node is always 0.
+    """
+
+    pcap_file_path = os.path.join(node.project.capture_working_directory(), node_capture_data.capture_file_name)
+    await node.start_capture(adapter_number, pcap_file_path)
+    return {"pcap_file_path": pcap_file_path}
+
+
+@router.post("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def stop_capture(adapter_number: int, port_number: int, node: VPCSVM = Depends(dep_node)):
+    """
+    Stop a packet capture on the node.
+    The adapter number on the VPCS node is always 0.
+    """
+
+    await node.stop_capture(port_number)
+
+
+@router.post("/{node_id}/console/reset",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def reset_console(node: VPCSVM = Depends(dep_node)):
+
+    await node.reset_console()
+
+
+@router.get("/{node_id}/adapters/{adapter_number}/ports/{port_number}/capture/stream",
+            responses=responses)
+async def stream_pcap_file(adapter_number: int, port_number: int, node: VPCSVM = Depends(dep_node)):
+    """
+    Stream the pcap capture file.
+    The adapter number on the VPCS node is always 0.
+    """
+
+    nio = node.get_nio(port_number)
+    stream = VPCS.instance().stream_pcap_file(nio, node.project.id)
+    return StreamingResponse(stream, media_type="application/vnd.tcpdump.pcap")
+
+
+@router.websocket("/{node_id}/console/ws")
+async def console_ws(websocket: WebSocket, node: VPCSVM = Depends(dep_node)):
+    """
+    Console WebSocket.
+    """
+
+    await node.start_websocket_console(websocket)