Move endpoints to routes & preparations to use a database.

gns3server/api/routes/controller/__init__.py

@@ -0,0 +1,44 @@
+#
+# 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/>.
+
+from fastapi import APIRouter
+
+from . import controller
+from . import appliances
+from . import computes
+from . import drawings
+from . import gns3vm
+from . import links
+from . import nodes
+from . import notifications
+from . import projects
+from . import snapshots
+from . import symbols
+from . import templates
+
+router = APIRouter()
+router.include_router(controller.router, tags=["Controller"])
+router.include_router(appliances.router, prefix="/appliances", tags=["Appliances"])
+router.include_router(computes.router, prefix="/computes", tags=["Computes"])
+router.include_router(drawings.router, prefix="/projects/{project_id}/drawings", tags=["Drawings"])
+router.include_router(gns3vm.router, prefix="/gns3vm", tags=["GNS3 VM"])
+router.include_router(links.router, prefix="/projects/{project_id}/links", tags=["Links"])
+router.include_router(nodes.router, prefix="/projects/{project_id}/nodes", tags=["Nodes"])
+router.include_router(notifications.router, prefix="/notifications", tags=["Notifications"])
+router.include_router(projects.router, prefix="/projects", tags=["Projects"])
+router.include_router(snapshots.router, prefix="/projects/{project_id}/snapshots", tags=["Snapshots"])
+router.include_router(symbols.router, prefix="/symbols", tags=["Symbols"])
+router.include_router(templates.router, tags=["Templates"])

gns3server/api/routes/controller/appliances.py

@@ -0,0 +1,39 @@
+# -*- 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 appliances.
+"""
+
+from fastapi import APIRouter
+from typing import Optional
+
+router = APIRouter()
+
+
+@router.get("")
+async def get_appliances(update: Optional[bool] = None, symbol_theme:  Optional[str] = "Classic"):
+    """
+    Return all appliances known by the controller.
+    """
+
+    from gns3server.controller import Controller
+    controller = Controller.instance()
+    if update:
+        await controller.appliance_manager.download_appliances()
+    controller.appliance_manager.load_appliances(symbol_theme=symbol_theme)
+    return [c.__json__() for c in controller.appliance_manager.appliances.values()]

gns3server/api/routes/controller/computes.py

@@ -0,0 +1,175 @@
+# -*- 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 computes.
+"""
+
+from fastapi import APIRouter, status
+from fastapi.encoders import jsonable_encoder
+from typing import List, Union
+from uuid import UUID
+
+from gns3server.controller import Controller
+from gns3server import schemas
+
+router = APIRouter()
+
+responses = {
+    404: {"model": schemas.ErrorMessage, "description": "Compute not found"}
+}
+
+
+@router.post("",
+             status_code=status.HTTP_201_CREATED,
+             response_model=schemas.Compute,
+             responses={404: {"model": schemas.ErrorMessage, "description": "Could not connect to compute"},
+                        409: {"model": schemas.ErrorMessage, "description": "Could not create compute"},
+                        401: {"model": schemas.ErrorMessage, "description": "Invalid authentication for compute"}})
+async def create_compute(compute_data: schemas.ComputeCreate):
+    """
+    Create a new compute on the controller.
+    """
+
+    compute = await Controller.instance().add_compute(**jsonable_encoder(compute_data, exclude_unset=True),
+                                                      connect=False)
+    return compute.__json__()
+
+
+@router.get("/{compute_id}",
+            response_model=schemas.Compute,
+            response_model_exclude_unset=True,
+            responses=responses)
+def get_compute(compute_id: Union[str, UUID]):
+    """
+    Return a compute from the controller.
+    """
+
+    compute = Controller.instance().get_compute(str(compute_id))
+    return compute.__json__()
+
+
+@router.get("",
+            response_model=List[schemas.Compute],
+            response_model_exclude_unset=True)
+async def get_computes():
+    """
+    Return all computes known by the controller.
+    """
+
+    controller = Controller.instance()
+    return [c.__json__() for c in controller.computes.values()]
+
+
+@router.put("/{compute_id}",
+            response_model=schemas.Compute,
+            response_model_exclude_unset=True,
+            responses=responses)
+async def update_compute(compute_id: Union[str, UUID], compute_data: schemas.ComputeUpdate):
+    """
+    Update a compute on the controller.
+    """
+
+    compute = Controller.instance().get_compute(str(compute_id))
+    # exclude compute_id because we only use it when creating a new compute
+    await compute.update(**jsonable_encoder(compute_data, exclude_unset=True, exclude={"compute_id"}))
+    return compute.__json__()
+
+
+@router.delete("/{compute_id}",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_compute(compute_id: Union[str, UUID]):
+    """
+    Delete a compute from the controller.
+    """
+
+    await Controller.instance().delete_compute(str(compute_id))
+
+
+@router.get("/{compute_id}/{emulator}/images",
+            responses=responses)
+async def get_images(compute_id: Union[str, UUID], emulator: str):
+    """
+    Return the list of images available on a compute for a given emulator type.
+    """
+
+    controller = Controller.instance()
+    compute = controller.get_compute(str(compute_id))
+    return await compute.images(emulator)
+
+
+@router.get("/{compute_id}/{emulator}/{endpoint_path:path}",
+            responses=responses)
+async def forward_get(compute_id: Union[str, UUID], emulator: str, endpoint_path: str):
+    """
+    Forward a GET request to a compute.
+    Read the full compute API documentation for available routes.
+    """
+
+    compute = Controller.instance().get_compute(str(compute_id))
+    result = await compute.forward("GET", emulator, endpoint_path)
+    return result
+
+
+@router.post("/{compute_id}/{emulator}/{endpoint_path:path}",
+             responses=responses)
+async def forward_post(compute_id: Union[str, UUID], emulator: str, endpoint_path: str, compute_data: dict):
+    """
+    Forward a POST request to a compute.
+    Read the full compute API documentation for available routes.
+    """
+
+    compute = Controller.instance().get_compute(str(compute_id))
+    return await compute.forward("POST", emulator, endpoint_path, data=compute_data)
+
+
+@router.put("/{compute_id}/{emulator}/{endpoint_path:path}",
+            responses=responses)
+async def forward_put(compute_id: Union[str, UUID], emulator: str, endpoint_path: str, compute_data: dict):
+    """
+    Forward a PUT request to a compute.
+    Read the full compute API documentation for available routes.
+    """
+
+    compute = Controller.instance().get_compute(str(compute_id))
+    return await compute.forward("PUT", emulator, endpoint_path, data=compute_data)
+
+
+@router.post("/{compute_id}/auto_idlepc",
+             responses=responses)
+async def autoidlepc(compute_id: Union[str, UUID], auto_idle_pc: schemas.AutoIdlePC):
+    """
+    Find a suitable Idle-PC value for a given IOS image. This may take a few minutes.
+    """
+
+    controller = Controller.instance()
+    return await controller.autoidlepc(str(compute_id),
+                                       auto_idle_pc.platform,
+                                       auto_idle_pc.image,
+                                       auto_idle_pc.ram)
+
+
+@router.get("/{compute_id}/ports",
+            deprecated=True,
+            responses=responses)
+async def ports(compute_id: Union[str, UUID]):
+    """
+    Return ports information for a given compute.
+    """
+
+    return await Controller.instance().compute_ports(str(compute_id))

gns3server/api/routes/controller/controller.py

@@ -0,0 +1,236 @@
+# -*- 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/>.
+
+import asyncio
+import signal
+import os
+
+from fastapi import APIRouter, status
+from fastapi.encoders import jsonable_encoder
+
+from gns3server.config import Config
+from gns3server.controller import Controller
+from gns3server.version import __version__
+from gns3server.controller.controller_error import ControllerError, ControllerForbiddenError
+from gns3server import schemas
+
+
+import logging
+log = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+@router.post("/shutdown",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses={403: {"model": schemas.ErrorMessage, "description": "Server shutdown not allowed"}})
+async def shutdown():
+    """
+    Shutdown the local server
+    """
+
+    config = Config.instance()
+    if config.get_section_config("Server").getboolean("local", False) is False:
+        raise ControllerForbiddenError("You can only stop a local server")
+
+    log.info("Start shutting down the server")
+    # close all the projects first
+    controller = Controller.instance()
+    projects = controller.projects.values()
+
+    tasks = []
+    for project in projects:
+        tasks.append(asyncio.ensure_future(project.close()))
+
+    if tasks:
+        done, _ = await asyncio.wait(tasks)
+        for future in done:
+            try:
+                future.result()
+            except Exception as e:
+                log.error("Could not close project {}".format(e), exc_info=1)
+                continue
+
+    # then shutdown the server itself
+    os.kill(os.getpid(), signal.SIGTERM)
+
+
+@router.get("/version",
+            response_model=schemas.Version)
+def version():
+    """
+    Return the server version number.
+    """
+
+    config = Config.instance()
+    local_server = config.get_section_config("Server").getboolean("local", False)
+    return {"version": __version__, "local": local_server}
+
+
+@router.post("/version",
+             response_model=schemas.Version,
+             response_model_exclude_defaults=True,
+             responses={409: {"model": schemas.ErrorMessage, "description": "Invalid version"}})
+def check_version(version: schemas.Version):
+    """
+    Check if version is the same as the server.
+
+    :param request:
+    :param response:
+    :return:
+    """
+
+    print(version.version)
+    if version.version != __version__:
+        raise ControllerError("Client version {} is not the same as server version {}".format(version.version, __version__))
+    return {"version": __version__}
+
+
+@router.get("/iou_license",
+            response_model=schemas.IOULicense)
+def get_iou_license():
+    """
+    Return the IOU license settings
+    """
+
+    return Controller.instance().iou_license
+
+
+@router.put("/iou_license",
+            status_code=status.HTTP_201_CREATED,
+            response_model=schemas.IOULicense)
+async def update_iou_license(iou_license: schemas.IOULicense):
+    """
+    Update the IOU license settings.
+    """
+
+    controller = Controller().instance()
+    current_iou_license = controller.iou_license
+    current_iou_license.update(jsonable_encoder(iou_license))
+    controller.save()
+    return current_iou_license
+
+
+@router.get("/statistics")
+async def statistics():
+    """
+    Return server statistics.
+    """
+
+    compute_statistics = []
+    for compute in list(Controller.instance().computes.values()):
+        try:
+            r = await compute.get("/statistics")
+            compute_statistics.append({"compute_id": compute.id, "compute_name": compute.name, "statistics": r.json})
+        except ControllerError as e:
+            log.error("Could not retrieve statistics on compute {}: {}".format(compute.name, e))
+    return compute_statistics
+
+# @Route.post(
+#     r"/debug",
+#     description="Dump debug information to disk (debug directory in config directory). Work only for local server",
+#     status_codes={
+#         201: "Written"
+#     })
+# async def debug(request, response):
+#
+#     config = Config.instance()
+#     if config.get_section_config("Server").getboolean("local", False) is False:
+#         raise ControllerForbiddenError("You can only debug a local server")
+#
+#     debug_dir = os.path.join(config.config_dir, "debug")
+#     try:
+#         if os.path.exists(debug_dir):
+#             shutil.rmtree(debug_dir)
+#         os.makedirs(debug_dir)
+#         with open(os.path.join(debug_dir, "controller.txt"), "w+") as f:
+#             f.write(ServerHandler._getDebugData())
+#     except Exception as e:
+#         # If something is wrong we log the info to the log and we hope the log will be include correctly to the debug export
+#         log.error("Could not export debug information {}".format(e), exc_info=1)
+#
+#     try:
+#         if Controller.instance().gns3vm.engine == "vmware":
+#             vmx_path = Controller.instance().gns3vm.current_engine().vmx_path
+#             if vmx_path:
+#                 shutil.copy(vmx_path, os.path.join(debug_dir, os.path.basename(vmx_path)))
+#     except OSError as e:
+#         # If something is wrong we log the info to the log and we hope the log will be include correctly to the debug export
+#         log.error("Could not copy VMware VMX file {}".format(e), exc_info=1)
+#
+#     for compute in list(Controller.instance().computes.values()):
+#         try:
+#             r = await compute.get("/debug", raw=True)
+#             data = r.body.decode("utf-8")
+#         except Exception as e:
+#             data = str(e)
+#         with open(os.path.join(debug_dir, "compute_{}.txt".format(compute.id)), "w+") as f:
+#             f.write("Compute ID: {}\n".format(compute.id))
+#             f.write(data)
+#
+#     response.set_status(201)
+#
+# @staticmethod
+# def _getDebugData():
+#     try:
+#         connections = psutil.net_connections()
+#     # You need to be root for OSX
+#     except psutil.AccessDenied:
+#         connections = None
+#
+#     try:
+#         addrs = ["* {}: {}".format(key, val) for key, val in psutil.net_if_addrs().items()]
+#     except UnicodeDecodeError:
+#         addrs = ["INVALID ADDR WITH UNICODE CHARACTERS"]
+#
+#     data = """Version: {version}
+# OS: {os}
+# Python: {python}
+# CPU: {cpu}
+# Memory: {memory}
+#
+# Networks:
+# {addrs}
+#
+# Open connections:
+# {connections}
+#
+# Processus:
+# """.format(
+#         version=__version__,
+#         os=platform.platform(),
+#         python=platform.python_version(),
+#         memory=psutil.virtual_memory(),
+#         cpu=psutil.cpu_times(),
+#         connections=connections,
+#         addrs="\n".join(addrs)
+#     )
+#     for proc in psutil.process_iter():
+#         try:
+#             psinfo = proc.as_dict(attrs=["name", "exe"])
+#             data += "* {} {}\n".format(psinfo["name"], psinfo["exe"])
+#         except psutil.NoSuchProcess:
+#             pass
+#
+#     data += "\n\nProjects"
+#     for project in Controller.instance().projects.values():
+#         data += "\n\nProject name: {}\nProject ID: {}\n".format(project.name, project.id)
+#         if project.status != "closed":
+#             for link in project.links.values():
+#                 data += "Link {}: {}".format(link.id, link.debug_link_data)
+#
+#     return data

gns3server/api/routes/controller/drawings.py

@@ -0,0 +1,101 @@
+# -*- 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 drawings.
+"""
+
+from fastapi import APIRouter, status
+from fastapi.encoders import jsonable_encoder
+from typing import List
+from uuid import UUID
+
+from gns3server.controller import Controller
+from gns3server import schemas
+
+router = APIRouter()
+
+responses = {
+    404: {"model": schemas.ErrorMessage, "description": "Project or drawing not found"}
+}
+
+
+@router.get("",
+            response_model=List[schemas.Drawing],
+            response_model_exclude_unset=True)
+async def get_drawings(project_id: UUID):
+    """
+    Return the list of all drawings for a given project.
+    """
+
+    project = await Controller.instance().get_loaded_project(str(project_id))
+    return [v.__json__() for v in project.drawings.values()]
+
+
+@router.post("",
+             status_code=status.HTTP_201_CREATED,
+             response_model=schemas.Drawing,
+             responses=responses)
+async def create_drawing(project_id: UUID, drawing_data: schemas.Drawing):
+    """
+    Create a new drawing.
+    """
+
+    project = await Controller.instance().get_loaded_project(str(project_id))
+    drawing = await project.add_drawing(**jsonable_encoder(drawing_data, exclude_unset=True))
+    return drawing.__json__()
+
+
+@router.get("/{drawing_id}",
+            response_model=schemas.Drawing,
+            response_model_exclude_unset=True,
+            responses=responses)
+async def get_drawing(project_id: UUID, drawing_id: UUID):
+    """
+    Return a drawing.
+    """
+
+    project = await Controller.instance().get_loaded_project(str(project_id))
+    drawing = project.get_drawing(str(drawing_id))
+    return drawing.__json__()
+
+
+@router.put("/{drawing_id}",
+            response_model=schemas.Drawing,
+            response_model_exclude_unset=True,
+            responses=responses)
+async def update_drawing(project_id: UUID, drawing_id: UUID, drawing_data: schemas.Drawing):
+    """
+    Update a drawing.
+    """
+
+    project = await Controller.instance().get_loaded_project(str(project_id))
+    drawing = project.get_drawing(str(drawing_id))
+    await drawing.update(**jsonable_encoder(drawing_data, exclude_unset=True))
+    return drawing.__json__()
+
+
+@router.delete("/{drawing_id}",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_drawing(project_id: UUID, drawing_id: UUID):
+    """
+    Delete a drawing.
+    """
+
+    project = await Controller.instance().get_loaded_project(str(project_id))
+    await project.delete_drawing(str(drawing_id))

gns3server/api/routes/controller/gns3vm.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python
+#
+# Copyright (C) 2020 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+API routes for managing the GNS3 VM.
+"""
+
+from fastapi import APIRouter
+from fastapi.encoders import jsonable_encoder
+
+from gns3server.controller import Controller
+from gns3server import schemas
+
+router = APIRouter()
+
+
+@router.get("/engines")
+async def get_engines():
+    """
+    Return the list of supported engines for the GNS3VM.
+    """
+
+    gns3_vm = Controller().instance().gns3vm
+    return gns3_vm.engine_list()
+
+
+@router.get("/engines/{engine}/vms")
+async def get_vms(engine: str):
+    """
+    Return all the available VMs for a specific virtualization engine.
+    """
+
+    vms = await Controller.instance().gns3vm.list(engine)
+    return vms
+
+
+@router.get("", response_model=schemas.GNS3VM)
+async def get_gns3vm_settings():
+    """
+    Return the GNS3 VM settings.
+    """
+
+    return Controller.instance().gns3vm.__json__()
+
+
+@router.put("", response_model=schemas.GNS3VM, response_model_exclude_unset=True)
+async def update_gns3vm_settings(gns3vm_data: schemas.GNS3VM):
+    """
+    Update the GNS3 VM settings.
+    """
+
+    controller = Controller().instance()
+    gns3_vm = controller.gns3vm
+    await gns3_vm.update_settings(jsonable_encoder(gns3vm_data, exclude_unset=True))
+    controller.save()
+    return gns3_vm.__json__()

gns3server/api/routes/controller/links.py

@@ -0,0 +1,216 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2016 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 links.
+"""
+
+import multidict
+import aiohttp
+
+from fastapi import APIRouter, Depends, Request, status
+from fastapi.responses import StreamingResponse
+from fastapi.encoders import jsonable_encoder
+from typing import List
+from uuid import UUID
+
+from gns3server.controller import Controller
+from gns3server.controller.controller_error import ControllerError
+from gns3server.controller.link import Link
+from gns3server.utils.http_client import HTTPClient
+from gns3server import schemas
+
+import logging
+log = logging.getLogger(__name__)
+
+router = APIRouter()
+
+responses = {
+    404: {"model": schemas.ErrorMessage, "description": "Could not find project or link"}
+}
+
+
+async def dep_link(project_id: UUID, link_id: UUID):
+    """
+    Dependency to retrieve a link.
+    """
+
+    project = await Controller.instance().get_loaded_project(str(project_id))
+    link = project.get_link(str(link_id))
+    return link
+
+
+@router.get("",
+            response_model=List[schemas.Link],
+            response_model_exclude_unset=True)
+async def get_links(project_id: UUID):
+    """
+    Return all links for a given project.
+    """
+
+    project = await Controller.instance().get_loaded_project(str(project_id))
+    return [v.__json__() for v in project.links.values()]
+
+
+@router.post("",
+             status_code=status.HTTP_201_CREATED,
+             response_model=schemas.Link,
+             responses={404: {"model": schemas.ErrorMessage, "description": "Could not find project"},
+                        409: {"model": schemas.ErrorMessage, "description": "Could not create link"}})
+async def create_link(project_id: UUID, link_data: schemas.Link):
+    """
+    Create a new link.
+    """
+
+    project = await Controller.instance().get_loaded_project(str(project_id))
+    link = await project.add_link()
+    link_data = jsonable_encoder(link_data, exclude_unset=True)
+    if "filters" in link_data:
+        await link.update_filters(link_data["filters"])
+    if "suspend" in link_data:
+        await link.update_suspend(link_data["suspend"])
+    try:
+        for node in link_data["nodes"]:
+            await link.add_node(project.get_node(node["node_id"]),
+                                node.get("adapter_number", 0),
+                                node.get("port_number", 0),
+                                label=node.get("label"))
+    except ControllerError as e:
+        await project.delete_link(link.id)
+        raise e
+    return link.__json__()
+
+
+@router.get("/{link_id}/available_filters",
+            responses=responses)
+async def get_filters(link: Link = Depends(dep_link)):
+    """
+    Return all filters available for a given link.
+    """
+
+    return link.available_filters()
+
+
+@router.get("/{link_id}",
+            response_model=schemas.Link,
+            response_model_exclude_unset=True,
+            responses=responses)
+async def get_link(link: Link = Depends(dep_link)):
+    """
+    Return a link.
+    """
+
+    return link.__json__()
+
+
+@router.put("/{link_id}",
+            response_model=schemas.Link,
+            response_model_exclude_unset=True,
+            responses=responses)
+async def update_link(link_data: schemas.Link, link: Link = Depends(dep_link)):
+    """
+    Update a link.
+    """
+
+    link_data = jsonable_encoder(link_data, exclude_unset=True)
+    if "filters" in link_data:
+        await link.update_filters(link_data["filters"])
+    if "suspend" in link_data:
+        await link.update_suspend(link_data["suspend"])
+    if "nodes" in link_data:
+        await link.update_nodes(link_data["nodes"])
+    return link.__json__()
+
+
+@router.delete("/{link_id}",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_link(project_id: UUID, link: Link = Depends(dep_link)):
+    """
+    Delete a link.
+    """
+
+    project = await Controller.instance().get_loaded_project(str(project_id))
+    await project.delete_link(link.id)
+
+
+@router.post("/{link_id}/reset",
+             response_model=schemas.Link,
+             responses=responses)
+async def reset_link(link: Link = Depends(dep_link)):
+    """
+    Reset a link.
+    """
+
+    await link.reset()
+    return link.__json__()
+
+
+@router.post("/{link_id}/capture/start",
+             status_code=status.HTTP_201_CREATED,
+             response_model=schemas.Link,
+             responses=responses)
+async def start_capture(capture_data: dict, link: Link = Depends(dep_link)):
+    """
+    Start packet capture on the link.
+    """
+
+    await link.start_capture(data_link_type=capture_data.get("data_link_type", "DLT_EN10MB"),
+                             capture_file_name=capture_data.get("capture_file_name"))
+    return link.__json__()
+
+
+@router.post("/{link_id}/capture/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def stop_capture(link: Link = Depends(dep_link)):
+    """
+    Stop packet capture on the link.
+    """
+
+    await link.stop_capture()
+
+
+@router.get("/{link_id}/capture/stream",
+            responses=responses)
+async def stream_pcap(request: Request, link: Link = Depends(dep_link)):
+    """
+    Stream the PCAP capture file from compute.
+    """
+
+    if not link.capturing:
+        raise ControllerError("This link has no active packet capture")
+
+    compute = link.compute
+    pcap_streaming_url = link.pcap_streaming_url()
+    headers = multidict.MultiDict(request.headers)
+    headers['Host'] = compute.host
+    headers['Router-Host'] = request.client.host
+    body = await request.body()
+
+    async def compute_pcap_stream():
+
+        try:
+            async with HTTPClient.request(request.method, pcap_streaming_url, timeout=None, data=body) as response:
+                async for data in response.content.iter_any():
+                    if not data:
+                        break
+                    yield data
+        except aiohttp.ClientError as e:
+            raise ControllerError(f"Client error received when receiving pcap stream from compute: {e}")
+
+    return StreamingResponse(compute_pcap_stream(), media_type="application/vnd.tcpdump.pcap")

gns3server/api/routes/controller/nodes.py

@@ -0,0 +1,432 @@
+# -*- 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 nodes.
+"""
+
+import aiohttp
+import asyncio
+
+from fastapi import APIRouter, Depends, WebSocket, WebSocketDisconnect, Request, Response, status
+from fastapi.encoders import jsonable_encoder
+from fastapi.routing import APIRoute
+from typing import List, Callable
+from uuid import UUID
+
+from gns3server.controller import Controller
+from gns3server.controller.node import Node
+from gns3server.controller.project import Project
+from gns3server.utils import force_unix_path
+from gns3server.utils.http_client import HTTPClient
+from gns3server.controller.controller_error import ControllerForbiddenError
+from gns3server import schemas
+
+import logging
+log = logging.getLogger(__name__)
+
+node_locks = {}
+
+
+class NodeConcurrency(APIRoute):
+    """
+    To avoid strange effects, we prevent concurrency
+    between the same instance of the node
+    (excepting when streaming a PCAP file and for WebSocket consoles).
+    """
+
+    def get_route_handler(self) -> Callable:
+        original_route_handler = super().get_route_handler()
+
+        async def custom_route_handler(request: Request) -> Response:
+
+            node_id = request.path_params.get("node_id")
+            project_id = request.path_params.get("project_id")
+
+            if node_id and "pcap" not in request.url.path and not request.url.path.endswith("console/ws"):
+                lock_key = "{}:{}".format(project_id, node_id)
+                node_locks.setdefault(lock_key, {"lock": asyncio.Lock(), "concurrency": 0})
+                node_locks[lock_key]["concurrency"] += 1
+
+                async with node_locks[lock_key]["lock"]:
+                    response = await original_route_handler(request)
+
+                node_locks[lock_key]["concurrency"] -= 1
+                if node_locks[lock_key]["concurrency"] <= 0:
+                    del node_locks[lock_key]
+            else:
+                response = await original_route_handler(request)
+
+            return response
+
+        return custom_route_handler
+
+
+router = APIRouter(route_class=NodeConcurrency)
+
+responses = {
+    404: {"model": schemas.ErrorMessage, "description": "Could not find project or node"}
+}
+
+
+async def dep_project(project_id: UUID):
+    """
+    Dependency to retrieve a project.
+    """
+
+    project = await Controller.instance().get_loaded_project(str(project_id))
+    return project
+
+
+async def dep_node(node_id: UUID, project: Project = Depends(dep_project)):
+    """
+    Dependency to retrieve a node.
+    """
+
+    node = project.get_node(str(node_id))
+    return node
+
+
+@router.post("",
+             status_code=status.HTTP_201_CREATED,
+             response_model=schemas.Node,
+             responses={404: {"model": schemas.ErrorMessage, "description": "Could not find project"},
+                        409: {"model": schemas.ErrorMessage, "description": "Could not create node"}})
+async def create_node(node_data: schemas.Node, project: Project = Depends(dep_project)):
+    """
+    Create a new node.
+    """
+
+    controller = Controller.instance()
+    compute = controller.get_compute(str(node_data.compute_id))
+    node_data = jsonable_encoder(node_data, exclude_unset=True)
+    node = await project.add_node(compute,
+                                  node_data.pop("name"),
+                                  node_data.pop("node_id", None),
+                                  **node_data)
+    return node.__json__()
+
+
+@router.get("",
+            response_model=List[schemas.Node],
+            response_model_exclude_unset=True)
+async def get_nodes(project: Project = Depends(dep_project)):
+    """
+    Return all nodes belonging to a given project.
+    """
+
+    return [v.__json__() for v in project.nodes.values()]
+
+
+@router.post("/start",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def start_all_nodes(project: Project = Depends(dep_project)):
+    """
+    Start all nodes belonging to a given project.
+    """
+
+    await project.start_all()
+
+
+@router.post("/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def stop_all_nodes(project: Project = Depends(dep_project)):
+    """
+    Stop all nodes belonging to a given project.
+    """
+
+    await project.stop_all()
+
+
+@router.post("/suspend",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def suspend_all_nodes(project: Project = Depends(dep_project)):
+    """
+    Suspend all nodes belonging to a given project.
+    """
+
+    await project.suspend_all()
+
+
+@router.post("/reload",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def reload_all_nodes(project: Project = Depends(dep_project)):
+    """
+    Reload all nodes belonging to a given project.
+    """
+
+    await project.stop_all()
+    await project.start_all()
+
+
+@router.get("/{node_id}",
+            response_model=schemas.Node,
+            responses=responses)
+def get_node(node: Node = Depends(dep_node)):
+    """
+    Return a node from a given project.
+    """
+
+    return node.__json__()
+
+
+@router.put("/{node_id}",
+            response_model=schemas.Node,
+            response_model_exclude_unset=True,
+            responses=responses)
+async def update_node(node_data: schemas.NodeUpdate, node: Node = Depends(dep_node)):
+    """
+    Update a node.
+    """
+
+    node_data = jsonable_encoder(node_data, exclude_unset=True)
+
+    # Ignore these because we only use them when creating a node
+    node_data.pop("node_id", None)
+    node_data.pop("node_type", None)
+    node_data.pop("compute_id", None)
+
+    await node.update(**node_data)
+    return node.__json__()
+
+
+@router.delete("/{node_id}",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses={**responses,
+                          409: {"model": schemas.ErrorMessage, "description": "Cannot delete node"}})
+async def delete_node(node_id: UUID, project: Project = Depends(dep_project)):
+    """
+    Delete a node from a project.
+    """
+
+    await project.delete_node(str(node_id))
+
+
+@router.post("/{node_id}/duplicate",
+             response_model=schemas.Node,
+             status_code=status.HTTP_201_CREATED,
+             responses=responses)
+async def duplicate_node(duplicate_data: schemas.NodeDuplicate, node: Node = Depends(dep_node)):
+    """
+    Duplicate a node.
+    """
+
+    new_node = await node.project.duplicate_node(node,
+                                                 duplicate_data.x,
+                                                 duplicate_data.y,
+                                                 duplicate_data.z)
+    return new_node.__json__()
+
+
+@router.post("/{node_id}/start",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def start_node(start_data: dict, node: Node = Depends(dep_node)):
+    """
+    Start a node.
+    """
+
+    await node.start(data=start_data)
+
+
+@router.post("/{node_id}/stop",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def stop_node(node: Node = Depends(dep_node)):
+    """
+    Stop a node.
+    """
+
+    await node.stop()
+
+
+@router.post("/{node_id}/suspend",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def suspend_node(node: Node = Depends(dep_node)):
+    """
+    Suspend a node.
+    """
+
+    await node.suspend()
+
+
+@router.post("/{node_id}/reload",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def reload_node(node: Node = Depends(dep_node)):
+    """
+    Reload a node.
+    """
+
+    await node.reload()
+
+
+@router.get("/{node_id}/links",
+            response_model=List[schemas.Link],
+            response_model_exclude_unset=True)
+async def get_node_links(node: Node = Depends(dep_node)):
+    """
+    Return all the links connected to a node.
+    """
+
+    links = []
+    for link in node.links:
+        links.append(link.__json__())
+    return links
+
+
+@router.get("/{node_id}/dynamips/auto_idlepc",
+            responses=responses)
+async def auto_idlepc(node: Node = Depends(dep_node)):
+    """
+    Compute an Idle-PC value for a Dynamips node
+    """
+
+    return await node.dynamips_auto_idlepc()
+
+
+@router.get("/{node_id}/dynamips/idlepc_proposals",
+            responses=responses)
+async def idlepc_proposals(node: Node = Depends(dep_node)):
+    """
+    Compute a list of potential idle-pc values for a Dynamips node
+    """
+
+    return await node.dynamips_idlepc_proposals()
+
+
+@router.post("/{node_id}/resize_disk",
+             status_code=status.HTTP_201_CREATED,
+             responses=responses)
+async def resize_disk(resize_data: dict, node: Node = Depends(dep_node)):
+    """
+    Resize a disk image.
+    """
+    await node.post("/resize_disk", **resize_data)
+
+
+@router.get("/{node_id}/files/{file_path:path}",
+            responses=responses)
+async def get_file(file_path: str, node: Node = Depends(dep_node)):
+    """
+    Return a file in the node directory
+    """
+
+    path = force_unix_path(file_path)
+
+    # Raise error if user try to escape
+    if path[0] == ".":
+        raise ControllerForbiddenError("It is forbidden to get a file outside the project directory")
+
+    node_type = node.node_type
+    path = "/project-files/{}/{}/{}".format(node_type, node.id, path)
+
+    res = await node.compute.http_query("GET", "/projects/{project_id}/files{path}".format(project_id=node.project.id, path=path),
+                                        timeout=None,
+                                        raw=True)
+    return Response(res.body, media_type="application/octet-stream")
+
+
+@router.post("/{node_id}/files/{file_path:path}",
+             status_code=status.HTTP_201_CREATED,
+             responses=responses)
+async def post_file(file_path: str, request: Request, node: Node = Depends(dep_node)):
+    """
+    Write a file in the node directory.
+    """
+
+    path = force_unix_path(file_path)
+
+    # Raise error if user try to escape
+    if path[0] == ".":
+        raise ControllerForbiddenError("Cannot write outside the node directory")
+
+    node_type = node.node_type
+    path = "/project-files/{}/{}/{}".format(node_type, node.id, path)
+
+    data = await request.body()  #FIXME: are we handling timeout or large files correctly?
+
+    await node.compute.http_query("POST", "/projects/{project_id}/files{path}".format(project_id=node.project.id, path=path),
+                                  data=data,
+                                  timeout=None,
+                                  raw=True)
+
+
+@router.websocket("/{node_id}/console/ws")
+async def ws_console(websocket: WebSocket, node: Node = Depends(dep_node)):
+    """
+    WebSocket console.
+    """
+
+    compute = node.compute
+    await websocket.accept()
+    log.info(f"New client {websocket.client.host}:{websocket.client.port} has connected to controller console WebSocket")
+    ws_console_compute_url = f"ws://{compute.host}:{compute.port}/v3/compute/projects/" \
+                             f"{node.project.id}/{node.node_type}/nodes/{node.id}/console/ws"
+
+    async def ws_receive(ws_console_compute):
+        """
+        Receive WebSocket data from client and forward to compute console WebSocket.
+        """
+
+        try:
+            while True:
+                data = await websocket.receive_text()
+                if data:
+                    await ws_console_compute.send_str(data)
+        except WebSocketDisconnect:
+            await ws_console_compute.close()
+            log.info(f"Client {websocket.client.host}:{websocket.client.port} has disconnected from controller"
+                     f" console WebSocket")
+
+    try:
+        # receive WebSocket data from compute console WebSocket and forward to client.
+        async with HTTPClient.get_client().ws_connect(ws_console_compute_url) as ws_console_compute:
+            asyncio.ensure_future(ws_receive(ws_console_compute))
+            async for msg in ws_console_compute:
+                if msg.type == aiohttp.WSMsgType.TEXT:
+                    await websocket.send_text(msg.data)
+                elif msg.type == aiohttp.WSMsgType.BINARY:
+                    await websocket.send_bytes(msg.data)
+                elif msg.type == aiohttp.WSMsgType.ERROR:
+                    break
+    except aiohttp.ClientError as e:
+        log.error(f"Client error received when forwarding to compute console WebSocket: {e}")
+
+
+@router.post("/console/reset",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def reset_console_all(project: Project = Depends(dep_project)):
+    """
+    Reset console for all nodes belonging to the project.
+    """
+
+    await project.reset_console_all()
+
+
+@router.post("/{node_id}/console/reset",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses=responses)
+async def console_reset(node: Node = Depends(dep_node)):
+
+    await node.post("/console/reset")#, request.json)

gns3server/api/routes/controller/notifications.py

@@ -0,0 +1,67 @@
+# -*- 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 controller notifications.
+"""
+
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect
+from fastapi.responses import StreamingResponse
+from websockets.exceptions import ConnectionClosed, WebSocketException
+
+from gns3server.controller import Controller
+
+import logging
+log = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+@router.get("")
+async def http_notification():
+    """
+    Receive controller notifications about the controller from HTTP stream.
+    """
+
+    async def event_stream():
+        with Controller.instance().notification.controller_queue() as queue:
+            while True:
+                msg = await queue.get_json(5)
+                yield ("{}\n".format(msg)).encode("utf-8")
+
+    return StreamingResponse(event_stream(), media_type="application/json")
+
+
+@router.websocket("/ws")
+async def notification_ws(websocket: WebSocket):
+    """
+    Receive project notifications about the controller from WebSocket.
+    """
+
+    await websocket.accept()
+    log.info(f"New client {websocket.client.host}:{websocket.client.port} has connected to controller WebSocket")
+    try:
+        with Controller.instance().notification.controller_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 controller WebSocket")
+    except WebSocketException as e:
+        log.warning("Error while sending to controller event to WebSocket client: '{}'".format(e))
+    finally:
+        await websocket.close()

gns3server/api/routes/controller/projects.py

@@ -0,0 +1,411 @@
+# -*- 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 projects.
+"""
+
+import os
+import asyncio
+import tempfile
+import zipfile
+import aiofiles
+import time
+
+import logging
+log = logging.getLogger()
+
+from fastapi import APIRouter, Depends, Request, Body, HTTPException, status, WebSocket, WebSocketDisconnect
+from fastapi.encoders import jsonable_encoder
+from fastapi.responses import StreamingResponse, FileResponse
+from websockets.exceptions import ConnectionClosed, WebSocketException
+from typing import List, Optional
+from uuid import UUID
+from pathlib import Path
+
+from gns3server import schemas
+from gns3server.controller import Controller
+from gns3server.controller.project import Project
+from gns3server.controller.controller_error import ControllerError, ControllerForbiddenError
+from gns3server.controller.import_project import import_project as import_controller_project
+from gns3server.controller.export_project import export_project as export_controller_project
+from gns3server.utils.asyncio import aiozipstream
+from gns3server.config import Config
+
+
+router = APIRouter()
+
+responses = {
+    404: {"model": schemas.ErrorMessage, "description": "Could not find project"}
+}
+
+
+def dep_project(project_id: UUID):
+    """
+    Dependency to retrieve a project.
+    """
+
+    project = Controller.instance().get_project(str(project_id))
+    return project
+
+
+CHUNK_SIZE = 1024 * 8  # 8KB
+
+
+@router.get("",
+            response_model=List[schemas.Project],
+            response_model_exclude_unset=True)
+def get_projects():
+    """
+    Return all projects.
+    """
+
+    controller = Controller.instance()
+    return [p.__json__() for p in controller.projects.values()]
+
+
+@router.post("",
+             status_code=status.HTTP_201_CREATED,
+             response_model=schemas.Project,
+             response_model_exclude_unset=True,
+             responses={409: {"model": schemas.ErrorMessage, "description": "Could not create project"}})
+async def create_project(project_data: schemas.ProjectCreate):
+    """
+    Create a new project.
+    """
+
+    controller = Controller.instance()
+    project = await controller.add_project(**jsonable_encoder(project_data, exclude_unset=True))
+    return project.__json__()
+
+
+@router.get("/{project_id}",
+            response_model=schemas.Project,
+            responses=responses)
+def get_project(project: Project = Depends(dep_project)):
+    """
+    Return a project.
+    """
+
+    return project.__json__()
+
+
+@router.put("/{project_id}",
+            response_model=schemas.Project,
+            response_model_exclude_unset=True,
+            responses=responses)
+async def update_project(project_data: schemas.ProjectUpdate, project: Project = Depends(dep_project)):
+    """
+    Update a project.
+    """
+
+    await project.update(**jsonable_encoder(project_data, exclude_unset=True))
+    return project.__json__()
+
+
+@router.delete("/{project_id}",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_project(project: Project = Depends(dep_project)):
+    """
+    Delete a project.
+    """
+
+    controller = Controller.instance()
+    await project.delete()
+    controller.remove_project(project)
+
+
+@router.get("/{project_id}/stats",
+            responses=responses)
+def get_project_stats(project: Project = Depends(dep_project)):
+    """
+    Return a project statistics.
+    """
+
+    return project.stats()
+
+
+@router.post("/{project_id}/close",
+             status_code=status.HTTP_204_NO_CONTENT,
+             responses={
+                 **responses,
+                 409: {"model": schemas.ErrorMessage, "description": "Could not close project"}
+             })
+async def close_project(project: Project = Depends(dep_project)):
+    """
+    Close a project.
+    """
+
+    await project.close()
+
+
+@router.post("/{project_id}/open",
+             status_code=status.HTTP_201_CREATED,
+             response_model=schemas.Project,
+             responses={
+                 **responses,
+                 409: {"model": schemas.ErrorMessage, "description": "Could not open project"}
+             })
+async def open_project(project: Project = Depends(dep_project)):
+    """
+    Open a project.
+    """
+
+    await project.open()
+    return project.__json__()
+
+
+@router.post("/load",
+             status_code=status.HTTP_201_CREATED,
+             response_model=schemas.Project,
+             responses={
+                 **responses,
+                 409: {"model": schemas.ErrorMessage, "description": "Could not load project"}
+             })
+async def load_project(path: str = Body(..., embed=True)):
+    """
+    Load a project (local server only).
+    """
+
+    controller = Controller.instance()
+    config = Config.instance()
+    dot_gns3_file = path
+    if config.get_section_config("Server").getboolean("local", False) is False:
+        log.error("Cannot load '{}' because the server has not been started with the '--local' parameter".format(dot_gns3_file))
+        raise ControllerForbiddenError("Cannot load project when server is not local")
+    project = await controller.load_project(dot_gns3_file,)
+    return project.__json__()
+
+
+@router.get("/{project_id}/notifications")
+async def notification(project_id: UUID):
+    """
+    Receive project notifications about the controller from HTTP stream.
+    """
+
+    controller = Controller.instance()
+    project = controller.get_project(str(project_id))
+
+    log.info("New client has connected to the notification stream for project ID '{}' (HTTP steam method)".format(project.id))
+
+    async def event_stream():
+
+        try:
+            with controller.notification.project_queue(project.id) as queue:
+                while True:
+                    msg = await queue.get_json(5)
+                    yield ("{}\n".format(msg)).encode("utf-8")
+        finally:
+            log.info("Client has disconnected from notification for project ID '{}' (HTTP stream method)".format(project.id))
+            if project.auto_close:
+                # To avoid trouble with client connecting disconnecting we sleep few seconds before checking
+                # if someone else is not connected
+                await asyncio.sleep(5)
+                if not controller.notification.project_has_listeners(project.id):
+                    log.info("Project '{}' is automatically closing due to no client listening".format(project.id))
+                    await project.close()
+
+    return StreamingResponse(event_stream(), media_type="application/json")
+
+
+@router.websocket("/{project_id}/notifications/ws")
+async def notification_ws(project_id: UUID, websocket: WebSocket):
+    """
+    Receive project notifications about the controller from WebSocket.
+    """
+
+    controller = Controller.instance()
+    project = controller.get_project(str(project_id))
+    await websocket.accept()
+
+    log.info("New client has connected to the notification stream for project ID '{}' (WebSocket method)".format(project.id))
+    try:
+        with controller.notification.project_queue(project.id) as queue:
+            while True:
+                notification = await queue.get_json(5)
+                await websocket.send_text(notification)
+    except (ConnectionClosed, WebSocketDisconnect):
+        log.info("Client has disconnected from notification stream for project ID '{}' (WebSocket method)".format(project.id))
+    except WebSocketException as e:
+        log.warning("Error while sending to project event to WebSocket client: '{}'".format(e))
+    finally:
+        await websocket.close()
+        if project.auto_close:
+            # To avoid trouble with client connecting disconnecting we sleep few seconds before checking
+            # if someone else is not connected
+            await asyncio.sleep(5)
+            if not controller.notification.project_has_listeners(project.id):
+                log.info("Project '{}' is automatically closing due to no client listening".format(project.id))
+                await project.close()
+
+
+@router.get("/{project_id}/export",
+            responses=responses)
+async def export_project(project: Project = Depends(dep_project),
+                         include_snapshots: bool = False,
+                         include_images: bool = False,
+                         reset_mac_addresses: bool = False,
+                         compression: str = "zip"):
+    """
+    Export a project as a portable archive.
+    """
+
+    compression_query = compression.lower()
+    if compression_query == "zip":
+        compression = zipfile.ZIP_DEFLATED
+    elif compression_query == "none":
+        compression = zipfile.ZIP_STORED
+    elif compression_query == "bzip2":
+        compression = zipfile.ZIP_BZIP2
+    elif compression_query == "lzma":
+        compression = zipfile.ZIP_LZMA
+
+    try:
+        begin = time.time()
+        # use the parent directory as a temporary working dir
+        working_dir = os.path.abspath(os.path.join(project.path, os.pardir))
+
+        async def streamer():
+            with tempfile.TemporaryDirectory(dir=working_dir) as tmpdir:
+                with aiozipstream.ZipFile(compression=compression) as zstream:
+                    await export_controller_project(zstream,
+                                                    project,
+                                                    tmpdir,
+                                                    include_snapshots=include_snapshots,
+                                                    include_images=include_images,
+                                                    reset_mac_addresses=reset_mac_addresses)
+                    async for chunk in zstream:
+                        yield chunk
+
+            log.info("Project '{}' exported in {:.4f} seconds".format(project.name, time.time() - begin))
+
+    # Will be raise if you have no space left or permission issue on your temporary directory
+    # RuntimeError: something was wrong during the zip process
+    except (ValueError, OSError, RuntimeError) as e:
+        raise ConnectionError("Cannot export project: {}".format(e))
+
+    headers = {"CONTENT-DISPOSITION": 'attachment; filename="{}.gns3project"'.format(project.name)}
+    return StreamingResponse(streamer(), media_type="application/gns3project", headers=headers)
+
+
+@router.post("/{project_id}/import",
+             status_code=status.HTTP_201_CREATED,
+             response_model=schemas.Project,
+             responses=responses)
+async def import_project(project_id: UUID, request: Request, path: Optional[Path] = None, name: Optional[str] = None):
+    """
+    Import a project from a portable archive.
+    """
+
+    controller = Controller.instance()
+    config = Config.instance()
+    if not config.get_section_config("Server").getboolean("local", False):
+        raise ControllerForbiddenError("The server is not local")
+
+    # We write the content to a temporary location and after we extract it all.
+    # It could be more optimal to stream this but it is not implemented in Python.
+    try:
+        begin = time.time()
+        # use the parent directory or projects dir as a temporary working dir
+        if path:
+            working_dir = os.path.abspath(os.path.join(path, os.pardir))
+        else:
+            working_dir = controller.projects_directory()
+        with tempfile.TemporaryDirectory(dir=working_dir) as tmpdir:
+            temp_project_path = os.path.join(tmpdir, "project.zip")
+            async with aiofiles.open(temp_project_path, 'wb') as f:
+                async for chunk in request.stream():
+                    await f.write(chunk)
+            with open(temp_project_path, "rb") as f:
+                project = await import_controller_project(controller, str(project_id), f, location=path, name=name)
+
+        log.info("Project '{}' imported in {:.4f} seconds".format(project.name, time.time() - begin))
+    except OSError as e:
+        raise ControllerError("Could not import the project: {}".format(e))
+    return project.__json__()
+
+
+@router.post("/{project_id}/duplicate",
+             status_code=status.HTTP_201_CREATED,
+             response_model=schemas.Project,
+             responses={
+                 **responses,
+                 409: {"model": schemas.ErrorMessage, "description": "Could not duplicate project"}
+             })
+async def duplicate(project_data: schemas.ProjectDuplicate, project: Project = Depends(dep_project)):
+    """
+    Duplicate a project.
+    """
+
+    if project_data.path:
+        config = Config.instance()
+        if config.get_section_config("Server").getboolean("local", False) is False:
+            raise ControllerForbiddenError("The server is not a local server")
+        location = project_data.path
+    else:
+        location = None
+
+    reset_mac_addresses = project_data.reset_mac_addresses
+    new_project = await project.duplicate(name=project_data.name, location=location, reset_mac_addresses=reset_mac_addresses)
+    return new_project.__json__()
+
+
+@router.get("/{project_id}/files/{file_path:path}")
+async def get_file(file_path: str, project: Project = Depends(dep_project)):
+    """
+    Return a file from a project.
+    """
+
+    path = os.path.normpath(file_path).strip('/')
+
+    # 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("/{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)):
+    """
+    Write a file from a project.
+    """
+
+    path = os.path.normpath(file_path).strip("/")
+
+    # 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:
+        async with aiofiles.open(path, 'wb+') as f:
+            async for chunk in request.stream():
+                await f.write(chunk)
+    except FileNotFoundError:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
+    except PermissionError:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED)
+    except OSError as e:
+        raise ControllerError(str(e))

gns3server/api/routes/controller/snapshots.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python
+#
+# Copyright (C) 2016 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 snapshots.
+"""
+
+import logging
+log = logging.getLogger()
+
+from fastapi import APIRouter, Depends, status
+from typing import List
+from uuid import UUID
+
+from gns3server.controller.project import Project
+from gns3server import schemas
+from gns3server.controller import Controller
+
+router = APIRouter()
+
+responses = {
+    404: {"model": schemas.ErrorMessage, "description": "Could not find project or snapshot"}
+}
+
+
+def dep_project(project_id: UUID):
+    """
+    Dependency to retrieve a project.
+    """
+
+    project = Controller.instance().get_project(str(project_id))
+    return project
+
+
+@router.post("",
+             status_code=status.HTTP_201_CREATED,
+             response_model=schemas.Snapshot,
+             responses=responses)
+async def create_snapshot(snapshot_data: schemas.SnapshotCreate, project: Project = Depends(dep_project)):
+    """
+    Create a new snapshot of a project.
+    """
+
+    snapshot = await project.snapshot(snapshot_data.name)
+    return snapshot.__json__()
+
+
+@router.get("",
+            response_model=List[schemas.Snapshot],
+            response_model_exclude_unset=True,
+            responses=responses)
+def get_snapshots(project: Project = Depends(dep_project)):
+    """
+    Return all snapshots belonging to a given project.
+    """
+
+    snapshots = [s for s in project.snapshots.values()]
+    return [s.__json__() for s in sorted(snapshots, key=lambda s: (s.created_at, s.name))]
+
+
+@router.delete("/{snapshot_id}",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+async def delete_snapshot(snapshot_id: UUID, project: Project = Depends(dep_project)):
+    """
+    Delete a snapshot.
+    """
+
+    await project.delete_snapshot(str(snapshot_id))
+
+
+@router.post("/{snapshot_id}/restore",
+             status_code=status.HTTP_201_CREATED,
+             response_model=schemas.Project,
+             responses=responses)
+async def restore_snapshot(snapshot_id: UUID, project: Project = Depends(dep_project)):
+    """
+    Restore a snapshot.
+    """
+
+    snapshot = project.get_snapshot(str(snapshot_id))
+    project = await snapshot.restore()
+    return project.__json__()

gns3server/api/routes/controller/symbols.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python
+#
+# Copyright (C) 2020 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+API routes for symbols.
+"""
+
+import os
+
+from fastapi import APIRouter, Request, status
+from fastapi.responses import FileResponse
+
+from gns3server.controller import Controller
+from gns3server import schemas
+from gns3server.controller.controller_error import ControllerError, ControllerNotFoundError
+
+import logging
+log = logging.getLogger(__name__)
+
+
+router = APIRouter()
+
+
+@router.get("")
+def get_symbols():
+
+    controller = Controller.instance()
+    return controller.symbols.list()
+
+
+@router.get("/{symbol_id:path}/raw",
+            responses={404: {"model": schemas.ErrorMessage, "description": "Could not find symbol"}})
+async def get_symbol(symbol_id: str):
+    """
+    Download a symbol file.
+    """
+
+    controller = Controller.instance()
+    try:
+        symbol = controller.symbols.get_path(symbol_id)
+        return FileResponse(symbol)
+    except (KeyError, OSError) as e:
+        return ControllerNotFoundError("Could not get symbol file: {}".format(e))
+
+
+@router.post("/{symbol_id:path}/raw",
+             status_code=status.HTTP_204_NO_CONTENT)
+async def upload_symbol(symbol_id: str, request: Request):
+    """
+    Upload a symbol file.
+    """
+
+    controller = Controller.instance()
+    path = os.path.join(controller.symbols.symbols_path(), os.path.basename(symbol_id))
+
+    try:
+        with open(path, "wb") as f:
+            f.write(await request.body())
+    except (UnicodeEncodeError, OSError) as e:
+        raise ControllerError("Could not write symbol file '{}': {}".format(path, e))
+
+    # Reset the symbol list
+    controller.symbols.list()
+
+
+@router.get("/default_symbols")
+def get_default_symbols():
+    """
+    Return all default symbols.
+    """
+
+    controller = Controller.instance()
+    return controller.symbols.default_symbols()

gns3server/api/routes/controller/templates.py

@@ -0,0 +1,148 @@
+# -*- 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 templates.
+"""
+
+import hashlib
+import json
+
+import logging
+log = logging.getLogger(__name__)
+
+from fastapi import APIRouter, Request, Response, HTTPException, status
+from fastapi.encoders import jsonable_encoder
+from typing import List
+from uuid import UUID
+
+from gns3server import schemas
+from gns3server.controller import Controller
+
+
+router = APIRouter()
+
+responses = {
+    404: {"model": schemas.ErrorMessage, "description": "Could not find template"}
+}
+
+
+@router.post("/templates",
+             status_code=status.HTTP_201_CREATED,
+             response_model=schemas.Template)
+def create_template(template_data: schemas.TemplateCreate):
+    """
+    Create a new template.
+    """
+
+    controller = Controller.instance()
+    template = controller.template_manager.add_template(jsonable_encoder(template_data, exclude_unset=True))
+    # Reset the symbol list
+    controller.symbols.list()
+    return template.__json__()
+
+
+@router.get("/templates/{template_id}",
+            response_model=schemas.Template,
+            response_model_exclude_unset=True,
+            responses=responses)
+def get_template(template_id: UUID, request: Request, response: Response):
+    """
+    Return a template.
+    """
+
+    request_etag = request.headers.get("If-None-Match", "")
+    controller = Controller.instance()
+    template = controller.template_manager.get_template(str(template_id))
+    data = json.dumps(template.__json__())
+    template_etag = '"' + hashlib.md5(data.encode()).hexdigest() + '"'
+    if template_etag == request_etag:
+        raise HTTPException(status_code=status.HTTP_304_NOT_MODIFIED)
+    else:
+        response.headers["ETag"] = template_etag
+        return template.__json__()
+
+
+@router.put("/templates/{template_id}",
+            response_model=schemas.Template,
+            response_model_exclude_unset=True,
+            responses=responses)
+def update_template(template_id: UUID, template_data: schemas.TemplateUpdate):
+    """
+    Update a template.
+    """
+
+    controller = Controller.instance()
+    template = controller.template_manager.get_template(str(template_id))
+    template.update(**jsonable_encoder(template_data, exclude_unset=True))
+    return template.__json__()
+
+
+@router.delete("/templates/{template_id}",
+               status_code=status.HTTP_204_NO_CONTENT,
+               responses=responses)
+def delete_template(template_id: UUID):
+    """
+    Delete a template.
+    """
+
+    controller = Controller.instance()
+    controller.template_manager.delete_template(str(template_id))
+
+
+@router.get("/templates",
+            response_model=List[schemas.Template],
+            response_model_exclude_unset=True)
+def get_templates():
+    """
+    Return all templates.
+    """
+
+    controller = Controller.instance()
+    return [c.__json__() for c in controller.template_manager.templates.values()]
+
+
+@router.post("/templates/{template_id}/duplicate",
+             response_model=schemas.Template,
+             status_code=status.HTTP_201_CREATED,
+             responses=responses)
+async def duplicate_template(template_id: UUID):
+    """
+    Duplicate a template.
+    """
+
+    controller = Controller.instance()
+    template = controller.template_manager.duplicate_template(str(template_id))
+    return template.__json__()
+
+
+@router.post("/projects/{project_id}/templates/{template_id}",
+             response_model=schemas.Node,
+             status_code=status.HTTP_201_CREATED,
+             responses={404: {"model": schemas.ErrorMessage, "description": "Could not find project or template"}})
+async def create_node_from_template(project_id: UUID, template_id: UUID, template_usage: schemas.TemplateUsage):
+    """
+    Create a new node from a template.
+    """
+
+    controller = Controller.instance()
+    project = controller.get_project(str(project_id))
+    node = await project.add_node_from_template(str(template_id),
+                                                x=template_usage.x,
+                                                y=template_usage.y,
+                                                compute_id=template_usage.compute_id)
+    return node.__json__()