Refactoring to use a common node class for all VMs and other (future) objects.

gns3server/controller/__init__.py

@@ -77,7 +77,7 @@ class Controller:
             return
         for c in data["computes"]:
             compute_id = c.pop("compute_id")
-            yield from self.addCompute(compute_id, **c)
+            yield from self.add_compute(compute_id, **c)
 
     def isEnabled(self):
         """
@@ -87,7 +87,7 @@ class Controller:
         return Config.instance().get_section_config("Server").getboolean("controller")
 
     @asyncio.coroutine
-    def addCompute(self, compute_id, **kwargs):
+    def add_compute(self, compute_id, **kwargs):
         """
         Add a server to the dictionnary of computes controlled by GNS3
 
@@ -126,11 +126,11 @@ class Controller:
             project = Project(project_id=project_id, **kwargs)
             self._projects[project.id] = project
             for compute in self._computes.values():
-                yield from project.addCompute(compute)
+                yield from project.add_compute(compute)
             return self._projects[project.id]
         return self._projects[project_id]
 
-    def getProject(self, project_id):
+    def get_project(self, project_id):
         """
         Return a project or raise a 404
         """

gns3server/controller/link.py

@@ -29,18 +29,18 @@ class Link:
 
     def __init__(self, project):
         self._id = str(uuid.uuid4())
-        self._vms = []
+        self._nodes = []
         self._project = project
         self._capturing = False
         self._capture_file_name = None
 
     @asyncio.coroutine
-    def addVM(self, vm, adapter_number, port_number):
+    def add_node(self, node, adapter_number, port_number):
         """
-        Add a VM to the link
+        Add a node to the link
         """
-        self._vms.append({
-            "vm": vm,
+        self._nodes.append({
+            "node": node,
             "adapter_number": adapter_number,
             "port_number": port_number
         })
@@ -107,12 +107,12 @@ class Link:
         :returns: File name for a capture on this link
         """
         capture_file_name = "{}_{}-{}_to_{}_{}-{}".format(
-            self._vms[0]["vm"].name,
-            self._vms[0]["adapter_number"],
-            self._vms[0]["port_number"],
-            self._vms[1]["vm"].name,
-            self._vms[1]["adapter_number"],
-            self._vms[1]["port_number"])
+            self._nodes[0]["node"].name,
+            self._nodes[0]["adapter_number"],
+            self._nodes[0]["port_number"],
+            self._nodes[1]["node"].name,
+            self._nodes[1]["adapter_number"],
+            self._nodes[1]["port_number"])
         return re.sub("[^0-9A-Za-z_-]", "", capture_file_name) + ".pcap"
 
     @property
@@ -135,14 +135,14 @@ class Link:
 
     def __json__(self):
         res = []
-        for side in self._vms:
+        for side in self._nodes:
             res.append({
-                "vm_id": side["vm"].id,
+                "node_id": side["node"].id,
                 "adapter_number": side["adapter_number"],
                 "port_number": side["port_number"]
             })
         return {
-            "vms": res, "link_id": self._id,
+            "nodes": res, "link_id": self._id,
             "capturing": self._capturing,
             "capture_file_name": self._capture_file_name,
             "capture_file_path": self.capture_file_path

gns3server/controller/node.py

@@ -21,29 +21,29 @@ import copy
 import uuid
 
 
-class VM:
+class Node:
 
-    def __init__(self, project, compute, vm_id=None, vm_type=None, name=None, console=None, console_type="telnet", properties={}):
+    def __init__(self, project, compute, node_id=None, node_type=None, name=None, console=None, console_type="telnet", properties={}):
         """
-        :param project: Project of the VM
-        :param compute: Hypervisor server where the server will run
-        :param vm_id: UUID of the vm. Integer id
-        :param vm_type: Type of emulator
-        :param name: Name of the vm
+        :param project: Project of the node
+        :param compute: Compute server where the server will run
+        :param node_id: UUID of the node (integer)
+        :param node_type: Type of emulator
+        :param name: Name of the node
         :param console: TCP port of the console
         :param console_type: Type of the console (telnet, vnc, serial..)
-        :param properties: Emulator specific properties of the VM
+        :param properties: Emulator specific properties of the node
         """
 
-        if vm_id is None:
+        if node_id is None:
             self._id = str(uuid.uuid4())
         else:
-            self._id = vm_id
+            self._id = node_id
 
         self._name = name
         self._project = project
         self._compute = compute
-        self._vm_type = vm_type
+        self._node_type = node_type
         self._console = console
         self._console_type = console_type
         self._properties = properties
@@ -57,8 +57,8 @@ class VM:
         return self._name
 
     @property
-    def vm_type(self):
-        return self._vm_type
+    def node_type(self):
+        return self._node_type
 
     @property
     def console(self):
@@ -90,24 +90,24 @@ class VM:
     @asyncio.coroutine
     def create(self):
         """
-        Create the VM on the compute Node
+        Create the node on the compute server
         """
-        data = self._vm_data()
-        data["vm_id"] = self._id
-        response = yield from self._compute.post("/projects/{}/{}/vms".format(self._project.id, self._vm_type), data=data)
-        self._parse_vm_response(response)
+        data = self._node_data()
+        data["node_id"] = self._id
+        response = yield from self._compute.post("/projects/{}/{}/nodes".format(self._project.id, self._node_type), data=data)
+        self._parse_node_response(response)
 
     @asyncio.coroutine
     def update(self, name=None, console=None, console_type="telnet", properties={}):
         """
-        Update the VM on the compute Node
+        Update the node on the compute server
 
-        :param vm_id: UUID of the vm. Integer id
-        :param vm_type: Type of emulator
-        :param name: Name of the vm
+        :param node_id: UUID of the node
+        :param node_type: Type of emulator
+        :param name: Name of the node
         :param console: TCP port of the console
         :param console_type: Type of the console (telnet, vnc, serial..)
-        :param properties: Emulator specific properties of the VM
+        :param properties: Emulator specific properties of the node
 
         """
         if name:
@@ -119,25 +119,25 @@ class VM:
         if properties != {}:
             self._properties = properties
 
-        data = self._vm_data()
+        data = self._node_data()
         response = yield from self.put(None, data=data)
-        self._parse_vm_response(response)
+        self._parse_node_response(response)
 
-    def _parse_vm_response(self, response):
+    def _parse_node_response(self, response):
         """
-        Update the object with the remote VM object
+        Update the object with the remote node object
         """
         for key, value in response.json.items():
             if key == "console":
                 self._console = value
-            elif key in ["console_type", "name", "vm_id", "project_id", "vm_directory", "command_line", "status"]:
+            elif key in ["console_type", "name", "node_id", "project_id", "node_directory", "command_line", "status"]:
                 pass
             else:
                 self._properties[key] = value
 
-    def _vm_data(self):
+    def _node_data(self):
         """
-        Prepare VM data to send to the remote controller
+        Prepare node data to send to the remote controller
         """
         data = copy.copy(self._properties)
         data["name"] = self._name
@@ -157,50 +157,50 @@ class VM:
     @asyncio.coroutine
     def start(self):
         """
-        Start a VM
+        Start a node
         """
         yield from self.post("/start")
 
     @asyncio.coroutine
     def stop(self):
         """
-        Stop a VM
+        Stop a node
         """
         yield from self.post("/stop")
 
     @asyncio.coroutine
     def suspend(self):
         """
-        Suspend a VM
+        Suspend a node
         """
         yield from self.post("/suspend")
 
     @asyncio.coroutine
     def reload(self):
         """
-        Suspend a VM
+        Suspend a node
         """
         yield from self.post("/reload")
 
     @asyncio.coroutine
     def post(self, path, data=None):
         """
-        HTTP post on the VM
+        HTTP post on the node
         """
         if data:
-            return (yield from self._compute.post("/projects/{}/{}/vms/{}{}".format(self._project.id, self._vm_type, self._id, path), data=data))
+            return (yield from self._compute.post("/projects/{}/{}/nodes/{}{}".format(self._project.id, self._node_type, self._id, path), data=data))
         else:
-            return (yield from self._compute.post("/projects/{}/{}/vms/{}{}".format(self._project.id, self._vm_type, self._id, path)))
+            return (yield from self._compute.post("/projects/{}/{}/nodes/{}{}".format(self._project.id, self._node_type, self._id, path)))
 
     @asyncio.coroutine
     def put(self, path, data=None):
         """
-        HTTP post on the VM
+        HTTP post on the node
         """
         if path is None:
-            path = "/projects/{}/{}/vms/{}".format(self._project.id, self._vm_type, self._id)
+            path = "/projects/{}/{}/nodes/{}".format(self._project.id, self._node_type, self._id)
         else:
-            path = "/projects/{}/{}/vms/{}{}".format(self._project.id, self._vm_type, self._id, path)
+            path = "/projects/{}/{}/nodes/{}{}".format(self._project.id, self._node_type, self._id, path)
         if data:
             return (yield from self._compute.put(path, data=data))
         else:
@@ -209,22 +209,22 @@ class VM:
     @asyncio.coroutine
     def delete(self, path=None):
         """
-        HTTP post on the VM
+        HTTP post on the node
         """
         if path is None:
-            return (yield from self._compute.delete("/projects/{}/{}/vms/{}".format(self._project.id, self._vm_type, self._id)))
+            return (yield from self._compute.delete("/projects/{}/{}/nodes/{}".format(self._project.id, self._node_type, self._id)))
         else:
-            return (yield from self._compute.delete("/projects/{}/{}/vms/{}{}".format(self._project.id, self._vm_type, self._id, path)))
+            return (yield from self._compute.delete("/projects/{}/{}/nodes/{}{}".format(self._project.id, self._node_type, self._id, path)))
 
     def __repr__(self):
-        return "<gns3server.controller.VM {} {}>".format(self._vm_type, self._name)
+        return "<gns3server.controller.Node {} {}>".format(self._node_type, self._name)
 
     def __json__(self):
         return {
             "compute_id": self._compute.id,
             "project_id": self._project.id,
-            "vm_id": self._id,
-            "vm_type": self._vm_type,
+            "node_id": self._id,
+            "node_type": self._node_type,
             "name": self._name,
             "console": self._console,
             "console_type": self._console_type,

gns3server/controller/project.py

@@ -18,10 +18,12 @@
 import os
 import asyncio
 import aiohttp
+import shutil
+
 from uuid import UUID, uuid4
 from contextlib import contextmanager
 
-from .vm import VM
+from .node import Node
 from .udp_link import UDPLink
 from ..notification_queue import NotificationQueue
 from ..config import Config
@@ -56,7 +58,7 @@ class Project:
 
         self._temporary = temporary
         self._computes = set()
-        self._vms = {}
+        self._nodes = {}
         self._links = {}
         self._listeners = set()
 
@@ -101,42 +103,42 @@ class Project:
         return path
 
     @asyncio.coroutine
-    def addCompute(self, compute):
+    def add_compute(self, compute):
         self._computes.add(compute)
         yield from compute.post("/projects", self)
 
     @asyncio.coroutine
-    def addVM(self, compute, vm_id, **kwargs):
+    def add_node(self, compute, node_id, **kwargs):
         """
-        Create a vm or return an existing vm
+        Create a node or return an existing node
 
-        :param kwargs: See the documentation of VM
+        :param kwargs: See the documentation of node
         """
-        if vm_id not in self._vms:
-            vm = VM(self, compute, vm_id=vm_id, **kwargs)
-            yield from vm.create()
-            self._vms[vm.id] = vm
-            return vm
-        return self._vms[vm_id]
+        if node_id not in self._nodes:
+            node = Node(self, compute, node_id=node_id, **kwargs)
+            yield from node.create()
+            self._nodes[node.id] = node
+            return node
+        return self._nodes[node_id]
 
-    def getVM(self, vm_id):
+    def get_node(self, node_id):
         """
-        Return the VM or raise a 404 if the VM is unknown
+        Return the node or raise a 404 if the node is unknown
         """
         try:
-            return self._vms[vm_id]
+            return self._nodes[node_id]
         except KeyError:
-            raise aiohttp.web.HTTPNotFound(text="VM ID {} doesn't exist".format(vm_id))
+            raise aiohttp.web.HTTPNotFound(text="Node ID {} doesn't exist".format(node_id))
 
     @property
-    def vms(self):
+    def nodes(self):
         """
-        :returns: Dictionnary of the VMS
+        :returns: Dictionary of the nodes
         """
-        return self._vms
+        return self._nodes
 
     @asyncio.coroutine
-    def addLink(self):
+    def add_link(self):
         """
         Create a link. By default the link is empty
         """
@@ -144,9 +146,9 @@ class Project:
         self._links[link.id] = link
         return link
 
-    def getLink(self, link_id):
+    def get_link(self, link_id):
         """
-        Return the Link or raise a 404 if the VM is unknown
+        Return the Link or raise a 404 if the link is unknown
         """
         try:
             return self._links[link_id]
@@ -156,7 +158,7 @@ class Project:
     @property
     def links(self):
         """
-        :returns: Dictionnary of the Links
+        :returns: Dictionary of the Links
         """
         return self._links
 
@@ -174,7 +176,7 @@ class Project:
     def delete(self):
         for compute in self._computes:
             yield from compute.delete("/projects/{}".format(self._id))
-        shutil.rmtree(self.path)
+        shutil.rmtree(self.path, ignore_errors=True)
 
     @contextmanager
     def queue(self):

gns3server/controller/udp_link.py

@@ -26,58 +26,58 @@ class UDPLink(Link):
 
     def __init__(self, project):
         super().__init__(project)
-        self._capture_vm = None
+        self._capture_node = None
 
     @asyncio.coroutine
     def create(self):
         """
-        Create the link on the VMs
+        Create the link on the nodes
         """
 
-        vm1 = self._vms[0]["vm"]
-        adapter_number1 = self._vms[0]["adapter_number"]
-        port_number1 = self._vms[0]["port_number"]
-        vm2 = self._vms[1]["vm"]
-        adapter_number2 = self._vms[1]["adapter_number"]
-        port_number2 = self._vms[1]["port_number"]
+        node1 = self._nodes[0]["node"]
+        adapter_number1 = self._nodes[0]["adapter_number"]
+        port_number1 = self._nodes[0]["port_number"]
+        node2 = self._nodes[1]["node"]
+        adapter_number2 = self._nodes[1]["adapter_number"]
+        port_number2 = self._nodes[1]["port_number"]
 
         # Reserve a UDP port on both side
-        response = yield from vm1.compute.post("/projects/{}/ports/udp".format(self._project.id))
-        self._vm1_port = response.json["udp_port"]
-        response = yield from vm2.compute.post("/projects/{}/ports/udp".format(self._project.id))
-        self._vm2_port = response.json["udp_port"]
+        response = yield from node1.compute.post("/projects/{}/ports/udp".format(self._project.id))
+        self._node1_port = response.json["udp_port"]
+        response = yield from node2.compute.post("/projects/{}/ports/udp".format(self._project.id))
+        self._node2_port = response.json["udp_port"]
 
         # Create the tunnel on both side
         data = {
-            "lport": self._vm1_port,
-            "rhost": vm2.compute.host,
-            "rport": self._vm2_port,
+            "lport": self._node1_port,
+            "rhost": node2.compute.host,
+            "rport": self._node2_port,
             "type": "nio_udp"
         }
-        yield from vm1.post("/adapters/{adapter_number}/ports/{port_number}/nio".format(adapter_number=adapter_number1, port_number=port_number1), data=data)
+        yield from node1.post("/adapters/{adapter_number}/ports/{port_number}/nio".format(adapter_number=adapter_number1, port_number=port_number1), data=data)
 
         data = {
-            "lport": self._vm2_port,
-            "rhost": vm1.compute.host,
-            "rport": self._vm1_port,
+            "lport": self._node2_port,
+            "rhost": node1.compute.host,
+            "rport": self._node1_port,
             "type": "nio_udp"
         }
-        yield from vm2.post("/adapters/{adapter_number}/ports/{port_number}/nio".format(adapter_number=adapter_number2, port_number=port_number2), data=data)
+        yield from node2.post("/adapters/{adapter_number}/ports/{port_number}/nio".format(adapter_number=adapter_number2, port_number=port_number2), data=data)
 
     @asyncio.coroutine
     def delete(self):
         """
-        Delete the link and free the ressources
+        Delete the link and free the resources
         """
-        vm1 = self._vms[0]["vm"]
-        adapter_number1 = self._vms[0]["adapter_number"]
-        port_number1 = self._vms[0]["port_number"]
-        vm2 = self._vms[1]["vm"]
-        adapter_number2 = self._vms[1]["adapter_number"]
-        port_number2 = self._vms[1]["port_number"]
+        node1 = self._nodes[0]["node"]
+        adapter_number1 = self._nodes[0]["adapter_number"]
+        port_number1 = self._nodes[0]["port_number"]
+        node2 = self._nodes[1]["node"]
+        adapter_number2 = self._nodes[1]["adapter_number"]
+        port_number2 = self._nodes[1]["port_number"]
 
-        yield from vm1.delete("/adapters/{adapter_number}/ports/{port_number}/nio".format(adapter_number=adapter_number1, port_number=port_number1))
-        yield from vm2.delete("/adapters/{adapter_number}/ports/{port_number}/nio".format(adapter_number=adapter_number2, port_number=port_number2))
+        yield from node1.delete("/adapters/{adapter_number}/ports/{port_number}/nio".format(adapter_number=adapter_number1, port_number=port_number1))
+        yield from node2.delete("/adapters/{adapter_number}/ports/{port_number}/nio".format(adapter_number=adapter_number2, port_number=port_number2))
 
     @asyncio.coroutine
     def start_capture(self, data_link_type="DLT_EN10MB", capture_file_name=None):
@@ -86,12 +86,12 @@ class UDPLink(Link):
         """
         if not capture_file_name:
             capture_file_name = self.default_capture_file_name()
-        self._capture_vm = self._choose_capture_side()
+        self._capture_node = self._choose_capture_side()
         data = {
             "capture_file_name": capture_file_name,
             "data_link_type": data_link_type
         }
-        yield from self._capture_vm["vm"].post("/adapters/{adapter_number}/ports/{port_number}/start_capture".format(adapter_number=self._capture_vm["adapter_number"], port_number=self._capture_vm["port_number"]), data=data)
+        yield from self._capture_node["node"].post("/adapters/{adapter_number}/ports/{port_number}/start_capture".format(adapter_number=self._capture_node["adapter_number"], port_number=self._capture_node["port_number"]), data=data)
         yield from super().start_capture(data_link_type=data_link_type, capture_file_name=capture_file_name)
 
     @asyncio.coroutine
@@ -99,9 +99,9 @@ class UDPLink(Link):
         """
         Stop capture on a link
         """
-        if self._capture_vm:
-            yield from self._capture_vm["vm"].post("/adapters/{adapter_number}/ports/{port_number}/stop_capture".format(adapter_number=self._capture_vm["adapter_number"], port_number=self._capture_vm["port_number"]))
-            self._capture_vm = None
+        if self._capture_node:
+            yield from self._capture_node["node"].post("/adapters/{adapter_number}/ports/{port_number}/stop_capture".format(adapter_number=self._capture_node["adapter_number"], port_number=self._capture_node["port_number"]))
+            self._capture_node = None
         yield from super().stop_capture()
 
     def _choose_capture_side(self):
@@ -111,17 +111,17 @@ class UDPLink(Link):
         The ideal candidate is a node who support capture on controller
         server
 
-        :returns: VM where the capture should run
+        :returns: Node where the capture should run
         """
 
-        # For saving bandwith we use the local node first
-        for vm in self._vms:
-            if vm["vm"].compute.id == "local" and vm["vm"].vm_type not in ["qemu", "vpcs"]:
-                return vm
+        # use the local node first to save bandwidth
+        for node in self._nodes:
+            if node["node"].compute.id == "local" and node["node"].node_type not in ["qemu", "vpcs"]:
+                return node
 
-        for vm in self._vms:
-            if vm["vm"].vm_type not in ["qemu", "vpcs"]:
-                return vm
+        for node in self._nodes:
+            if node["node"].node_type not in ["qemu", "vpcs"]:
+                return node
 
         raise aiohttp.web.HTTPConflict(text="Capture is not supported for this link")
 
@@ -130,6 +130,6 @@ class UDPLink(Link):
         """
         Return a FileStream of the Pcap from the compute node
         """
-        if self._capture_vm:
-            compute = self._capture_vm["vm"].compute
+        if self._capture_node:
+            compute = self._capture_node["node"].compute
             return compute.streamFile(self._project, "tmp/captures/" + self._capture_file_name)