Merge remote-tracking branch 'origin/asyncio' into asyncio

gns3server/handlers/__init__.py

@@ -3,4 +3,5 @@ __all__ = ["version_handler",
            "vpcs_handler",
            "project_handler",
            "virtualbox_handler",
-           "dynamips_handler"]
+           "dynamips_handler",
+           "iou_handler"]

gns3server/handlers/iou_handler.py

@@ -0,0 +1,235 @@
+# -*- 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/>.
+
+from ..web.route import Route
+from ..schemas.iou import IOU_CREATE_SCHEMA
+from ..schemas.iou import IOU_UPDATE_SCHEMA
+from ..schemas.iou import IOU_OBJECT_SCHEMA
+from ..schemas.iou import IOU_NIO_SCHEMA
+from ..modules.iou import IOU
+
+
+class IOUHandler:
+
+    """
+    API entry points for IOU.
+    """
+
+    @classmethod
+    @Route.post(
+        r"/projects/{project_id}/iou/vms",
+        parameters={
+            "project_id": "UUID for the project"
+        },
+        status_codes={
+            201: "Instance created",
+            400: "Invalid request",
+            409: "Conflict"
+        },
+        description="Create a new IOU instance",
+        input=IOU_CREATE_SCHEMA,
+        output=IOU_OBJECT_SCHEMA)
+    def create(request, response):
+
+        iou = IOU.instance()
+        vm = yield from iou.create_vm(request.json["name"],
+                                      request.match_info["project_id"],
+                                      request.json.get("vm_id"),
+                                      console=request.json.get("console"),
+                                      serial_adapters=request.json.get("serial_adapters"),
+                                      ethernet_adapters=request.json.get("ethernet_adapters"),
+                                      ram=request.json.get("ram"),
+                                      nvram=request.json.get("nvram")
+                                      )
+        vm.path = request.json.get("path", vm.path)
+        vm.iourc_path = request.json.get("iourc_path", vm.iourc_path)
+        response.set_status(201)
+        response.json(vm)
+
+    @classmethod
+    @Route.get(
+        r"/projects/{project_id}/iou/vms/{vm_id}",
+        parameters={
+            "project_id": "UUID for the project",
+            "vm_id": "UUID for the instance"
+        },
+        status_codes={
+            200: "Success",
+            400: "Invalid request",
+            404: "Instance doesn't exist"
+        },
+        description="Get a IOU instance",
+        output=IOU_OBJECT_SCHEMA)
+    def show(request, response):
+
+        iou_manager = IOU.instance()
+        vm = iou_manager.get_vm(request.match_info["vm_id"], project_id=request.match_info["project_id"])
+        response.json(vm)
+
+    @classmethod
+    @Route.put(
+        r"/projects/{project_id}/iou/vms/{vm_id}",
+        parameters={
+            "project_id": "UUID for the project",
+            "vm_id": "UUID for the instance"
+        },
+        status_codes={
+            200: "Instance updated",
+            400: "Invalid request",
+            404: "Instance doesn't exist",
+            409: "Conflict"
+        },
+        description="Update a IOU instance",
+        input=IOU_UPDATE_SCHEMA,
+        output=IOU_OBJECT_SCHEMA)
+    def update(request, response):
+
+        iou_manager = IOU.instance()
+        vm = iou_manager.get_vm(request.match_info["vm_id"], project_id=request.match_info["project_id"])
+        vm.name = request.json.get("name", vm.name)
+        vm.console = request.json.get("console", vm.console)
+        vm.path = request.json.get("path", vm.path)
+        vm.iourc_path = request.json.get("iourc_path", vm.iourc_path)
+        vm.ethernet_adapters = request.json.get("ethernet_adapters", vm.ethernet_adapters)
+        vm.serial_adapters = request.json.get("serial_adapters", vm.serial_adapters)
+        vm.ram = request.json.get("ram", vm.ram)
+        vm.nvram = request.json.get("nvram", vm.nvram)
+
+        response.json(vm)
+
+    @classmethod
+    @Route.delete(
+        r"/projects/{project_id}/iou/vms/{vm_id}",
+        parameters={
+            "project_id": "UUID for the project",
+            "vm_id": "UUID for the instance"
+        },
+        status_codes={
+            204: "Instance deleted",
+            400: "Invalid request",
+            404: "Instance doesn't exist"
+        },
+        description="Delete a IOU instance")
+    def delete(request, response):
+
+        yield from IOU.instance().delete_vm(request.match_info["vm_id"])
+        response.set_status(204)
+
+    @classmethod
+    @Route.post(
+        r"/projects/{project_id}/iou/vms/{vm_id}/start",
+        parameters={
+            "project_id": "UUID for the project",
+            "vm_id": "UUID for the instance"
+        },
+        status_codes={
+            204: "Instance started",
+            400: "Invalid request",
+            404: "Instance doesn't exist"
+        },
+        description="Start a IOU instance")
+    def start(request, response):
+
+        iou_manager = IOU.instance()
+        vm = iou_manager.get_vm(request.match_info["vm_id"], project_id=request.match_info["project_id"])
+        yield from vm.start()
+        response.set_status(204)
+
+    @classmethod
+    @Route.post(
+        r"/projects/{project_id}/iou/vms/{vm_id}/stop",
+        parameters={
+            "project_id": "UUID for the project",
+            "vm_id": "UUID for the instance"
+        },
+        status_codes={
+            204: "Instance stopped",
+            400: "Invalid request",
+            404: "Instance doesn't exist"
+        },
+        description="Stop a IOU instance")
+    def stop(request, response):
+
+        iou_manager = IOU.instance()
+        vm = iou_manager.get_vm(request.match_info["vm_id"], project_id=request.match_info["project_id"])
+        yield from vm.stop()
+        response.set_status(204)
+
+    @classmethod
+    @Route.post(
+        r"/projects/{project_id}/iou/vms/{vm_id}/reload",
+        parameters={
+            "project_id": "UUID for the project",
+            "vm_id": "UUID for the instance",
+        },
+        status_codes={
+            204: "Instance reloaded",
+            400: "Invalid request",
+            404: "Instance doesn't exist"
+        },
+        description="Reload a IOU instance")
+    def reload(request, response):
+
+        iou_manager = IOU.instance()
+        vm = iou_manager.get_vm(request.match_info["vm_id"], project_id=request.match_info["project_id"])
+        yield from vm.reload()
+        response.set_status(204)
+
+    @Route.post(
+        r"/projects/{project_id}/iou/vms/{vm_id}/ports/{port_number:\d+}/nio",
+        parameters={
+            "project_id": "UUID for the project",
+            "vm_id": "UUID for the instance",
+            "port_number": "Port where the nio should be added"
+        },
+        status_codes={
+            201: "NIO created",
+            400: "Invalid request",
+            404: "Instance doesn't exist"
+        },
+        description="Add a NIO to a IOU instance",
+        input=IOU_NIO_SCHEMA,
+        output=IOU_NIO_SCHEMA)
+    def create_nio(request, response):
+
+        iou_manager = IOU.instance()
+        vm = iou_manager.get_vm(request.match_info["vm_id"], project_id=request.match_info["project_id"])
+        nio = iou_manager.create_nio(vm.iouyap_path, request.json)
+        vm.slot_add_nio_binding(0, int(request.match_info["port_number"]), nio)
+        response.set_status(201)
+        response.json(nio)
+
+    @classmethod
+    @Route.delete(
+        r"/projects/{project_id}/iou/vms/{vm_id}/ports/{port_number:\d+}/nio",
+        parameters={
+            "project_id": "UUID for the project",
+            "vm_id": "UUID for the instance",
+            "port_number": "Port from where the nio should be removed"
+        },
+        status_codes={
+            204: "NIO deleted",
+            400: "Invalid request",
+            404: "Instance doesn't exist"
+        },
+        description="Remove a NIO from a IOU instance")
+    def delete_nio(request, response):
+
+        iou_manager = IOU.instance()
+        vm = iou_manager.get_vm(request.match_info["vm_id"], project_id=request.match_info["project_id"])
+        vm.slot_remove_nio_binding(0, int(request.match_info["port_number"]))
+        response.set_status(204)

gns3server/main.py

@@ -91,6 +91,7 @@ def parse_arguments(argv, config):
         "allow": config.getboolean("allow_remote_console", False),
         "quiet": config.getboolean("quiet", False),
         "debug": config.getboolean("debug", False),
+        "live": config.getboolean("live", False),
     }
 
     parser = argparse.ArgumentParser(description="GNS3 server version {}".format(__version__))
@@ -104,7 +105,8 @@ def parse_arguments(argv, config):
     parser.add_argument("-L", "--local", action="store_true", help="local mode (allows some insecure operations)")
     parser.add_argument("-A", "--allow", action="store_true", help="allow remote connections to local console ports")
     parser.add_argument("-q", "--quiet", action="store_true", help="do not show logs on stdout")
-    parser.add_argument("-d", "--debug", action="store_true", help="show debug logs and enable code live reload")
+    parser.add_argument("-d", "--debug", action="store_true", help="show debug logs")
+    parser.add_argument("--live", action="store_true", help="enable code live reload")
 
     return parser.parse_args(argv)
 

gns3server/modules/__init__.py

@@ -18,5 +18,6 @@
 from .vpcs import VPCS
 from .virtualbox import VirtualBox
 from .dynamips import Dynamips
+from .iou import IOU
 
-MODULES = [VPCS, VirtualBox, Dynamips]
+MODULES = [VPCS, VirtualBox, Dynamips, IOU]

gns3server/modules/adapters/ethernet_adapter.py

@@ -29,4 +29,4 @@ class EthernetAdapter(Adapter):
 
     def __str__(self):
 
-        return "VPCS Ethernet adapter"
+        return "Ethernet adapter"

gns3server/modules/adapters/serial_adapter.py

@@ -21,12 +21,12 @@ from .adapter import Adapter
 class SerialAdapter(Adapter):
 
     """
-    IOU Serial adapter.
+    VPCS Ethernet adapter.
     """
 
     def __init__(self):
-        Adapter.__init__(self, interfaces=4)
+        Adapter.__init__(self, interfaces=1)
 
     def __str__(self):
 
-        return "IOU Serial adapter"
+        return "Serial adapter"

gns3server/modules/base_manager.py

@@ -32,8 +32,8 @@ from ..config import Config
 from ..utils.asyncio import wait_run_in_executor
 from .project_manager import ProjectManager
 
-from .nios.nio_udp import NIOUDP
+from .nios.nio_udp import NIO_UDP
-from .nios.nio_tap import NIOTAP
+from .nios.nio_tap import NIO_TAP
 
 
 class BaseManager:
@@ -274,11 +274,11 @@ class BaseManager:
                     sock.connect((rhost, rport))
             except OSError as e:
                 raise aiohttp.web.HTTPInternalServerError(text="Could not create an UDP connection to {}:{}: {}".format(rhost, rport, e))
-            nio = NIOUDP(lport, rhost, rport)
+            nio = NIO_UDP(lport, rhost, rport)
         elif nio_settings["type"] == "nio_tap":
             tap_device = nio_settings["tap_device"]
             if not self._has_privileged_access(executable):
                 raise aiohttp.web.HTTPForbidden(text="{} has no privileged access to {}.".format(executable, tap_device))
-            nio = NIOTAP(tap_device)
+            nio = NIO_TAP(tap_device)
         assert nio is not None
         return nio

gns3server/modules/dynamips/dynamips_error.py

@@ -24,18 +24,4 @@ from ..vm_error import VMError
 
 class DynamipsError(VMError):
 
-    def __init__(self, message, original_exception=None):
+    pass
-
-        Exception.__init__(self, message)
-        if isinstance(message, Exception):
-            message = str(message)
-        self._message = message
-        self._original_exception = original_exception
-
-    def __repr__(self):
-
-        return self._message
-
-    def __str__(self):
-
-        return self._message

gns3server/modules/iou/__init__.py

@@ -0,0 +1,64 @@
+# -*- 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/>.
+
+"""
+IOU server module.
+"""
+
+import asyncio
+
+from ..base_manager import BaseManager
+from .iou_error import IOUError
+from .iou_vm import IOUVM
+
+
+class IOU(BaseManager):
+    _VM_CLASS = IOUVM
+
+    def __init__(self):
+        super().__init__()
+        self._free_application_ids = list(range(1, 512))
+        self._used_application_ids = {}
+
+    @asyncio.coroutine
+    def create_vm(self, *args, **kwargs):
+
+        vm = yield from super().create_vm(*args, **kwargs)
+        try:
+            self._used_application_ids[vm.id] = self._free_application_ids.pop(0)
+        except IndexError:
+            raise IOUError("No mac address available")
+        return vm
+
+    @asyncio.coroutine
+    def delete_vm(self, vm_id, *args, **kwargs):
+
+        vm = self.get_vm(vm_id)
+        i = self._used_application_ids[vm_id]
+        self._free_application_ids.insert(0, i)
+        del self._used_application_ids[vm_id]
+        yield from super().delete_vm(vm_id, *args, **kwargs)
+
+    def get_application_id(self, vm_id):
+        """
+        Get an unique IOU mac id
+
+        :param vm_id: ID of the IOU VM
+        :returns: IOU MAC id
+        """
+
+        return self._used_application_ids.get(vm_id, 1)

gns3server/modules/iou/iou_error.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2014 GNS3 Technologies Inc.
+# Copyright (C) 2013 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
@@ -15,18 +15,12 @@
 # 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 .adapter import Adapter
+"""
+Custom exceptions for IOU module.
+"""
+
+from ..vm_error import VMError
 
 
-class EthernetAdapter(Adapter):
+class IOUError(VMError):
-
+    pass
-    """
-    IOU Ethernet adapter.
-    """
-
-    def __init__(self):
-        Adapter.__init__(self, interfaces=4)
-
-    def __str__(self):
-
-        return "IOU Ethernet adapter"

gns3server/modules/iou/ioucon.py

@@ -55,7 +55,7 @@ EXIT_ABORT = 2
 
 # Mostly from:
 # https://code.google.com/p/miniboa/source/browse/trunk/miniboa/telnet.py
-#--[ Telnet Commands ]---------------------------------------------------------
+# --[ Telnet Commands ]---------------------------------------------------------
 SE = 240  # End of sub-negotiation parameters
 NOP = 241  # No operation
 DATMK = 242  # Data stream portion of a sync.
@@ -74,7 +74,7 @@ DONT = 254  # Don't = Demand or confirm option halt
 IAC = 255  # Interpret as Command
 SEND = 1   # Sub-process negotiation SEND command
 IS = 0   # Sub-process negotiation IS command
-#--[ Telnet Options ]----------------------------------------------------------
+# --[ Telnet Options ]----------------------------------------------------------
 BINARY = 0   # Transmit Binary
 ECHO = 1   # Echo characters back to sender
 RECON = 2   # Reconnection

gns3server/modules/nios/nio_tap.py

@@ -22,7 +22,7 @@ Interface for TAP NIOs (UNIX based OSes only).
 from .nio import NIO
 
 
-class NIOTAP(NIO):
+class NIO_TAP(NIO):
 
     """
     TAP NIO.

gns3server/modules/nios/nio_udp.py

@@ -22,7 +22,7 @@ Interface for UDP NIOs.
 from .nio import NIO
 
 
-class NIOUDP(NIO):
+class NIO_UDP(NIO):
 
     """
     UDP NIO.

gns3server/modules/virtualbox/virtualbox_error.py

@@ -24,18 +24,4 @@ from ..vm_error import VMError
 
 class VirtualBoxError(VMError):
 
-    def __init__(self, message, original_exception=None):
+    pass
-
-        Exception.__init__(self, message)
-        if isinstance(message, Exception):
-            message = str(message)
-        self._message = message
-        self._original_exception = original_exception
-
-    def __repr__(self):
-
-        return self._message
-
-    def __str__(self):
-
-        return self._message

gns3server/modules/vm_error.py

@@ -17,4 +17,19 @@
 
 
 class VMError(Exception):
-    pass
+
+    def __init__(self, message, original_exception=None):
+
+        Exception.__init__(self, message)
+        if isinstance(message, Exception):
+            message = str(message)
+        self._message = message
+        self._original_exception = original_exception
+
+    def __repr__(self):
+
+        return self._message
+
+    def __str__(self):
+
+        return self._message

gns3server/modules/vpcs/vpcs_error.py

@@ -24,18 +24,4 @@ from ..vm_error import VMError
 
 class VPCSError(VMError):
 
-    def __init__(self, message, original_exception=None):
+    pass
-
-        Exception.__init__(self, message)
-        if isinstance(message, Exception):
-            message = str(message)
-        self._message = message
-        self._original_exception = original_exception
-
-    def __repr__(self):
-
-        return self._message
-
-    def __str__(self):
-
-        return self._message

gns3server/old_modules/iou/__init__.py

@@ -1,843 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2014 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/>.
-
-"""
-IOU server module.
-"""
-
-import os
-import base64
-import ntpath
-import stat
-import tempfile
-import socket
-import shutil
-
-from gns3server.modules import IModule
-from gns3server.config import Config
-from gns3dms.cloud.rackspace_ctrl import get_provider
-from .iou_device import IOUDevice
-from .iou_error import IOUError
-from .nios.nio_udp import NIO_UDP
-from .nios.nio_tap import NIO_TAP
-from .nios.nio_generic_ethernet import NIO_GenericEthernet
-from ..attic import find_unused_port
-from ..attic import has_privileged_access
-
-from .schemas import IOU_CREATE_SCHEMA
-from .schemas import IOU_DELETE_SCHEMA
-from .schemas import IOU_UPDATE_SCHEMA
-from .schemas import IOU_START_SCHEMA
-from .schemas import IOU_STOP_SCHEMA
-from .schemas import IOU_RELOAD_SCHEMA
-from .schemas import IOU_ALLOCATE_UDP_PORT_SCHEMA
-from .schemas import IOU_ADD_NIO_SCHEMA
-from .schemas import IOU_DELETE_NIO_SCHEMA
-from .schemas import IOU_START_CAPTURE_SCHEMA
-from .schemas import IOU_STOP_CAPTURE_SCHEMA
-from .schemas import IOU_EXPORT_CONFIG_SCHEMA
-
-import logging
-log = logging.getLogger(__name__)
-
-
-class IOU(IModule):
-
-    """
-    IOU module.
-
-    :param name: module name
-    :param args: arguments for the module
-    :param kwargs: named arguments for the module
-    """
-
-    def __init__(self, name, *args, **kwargs):
-
-        # get the iouyap location
-        config = Config.instance()
-        iou_config = config.get_section_config(name.upper())
-        self._iouyap = iou_config.get("iouyap_path")
-        if not self._iouyap or not os.path.isfile(self._iouyap):
-            paths = [os.getcwd()] + os.environ["PATH"].split(os.pathsep)
-            # look for iouyap in the current working directory and $PATH
-            for path in paths:
-                try:
-                    if "iouyap" in os.listdir(path) and os.access(os.path.join(path, "iouyap"), os.X_OK):
-                        self._iouyap = os.path.join(path, "iouyap")
-                        break
-                except OSError:
-                    continue
-
-        if not self._iouyap:
-            log.warning("iouyap binary couldn't be found!")
-        elif not os.access(self._iouyap, os.X_OK):
-            log.warning("iouyap is not executable")
-
-        # a new process start when calling IModule
-        IModule.__init__(self, name, *args, **kwargs)
-        self._iou_instances = {}
-        self._console_start_port_range = iou_config.get("console_start_port_range", 4001)
-        self._console_end_port_range = iou_config.get("console_end_port_range", 4500)
-        self._allocated_udp_ports = []
-        self._udp_start_port_range = iou_config.get("udp_start_port_range", 30001)
-        self._udp_end_port_range = iou_config.get("udp_end_port_range", 35000)
-        self._host = iou_config.get("host", kwargs["host"])
-        self._console_host = iou_config.get("console_host", kwargs["console_host"])
-        self._projects_dir = kwargs["projects_dir"]
-        self._tempdir = kwargs["temp_dir"]
-        self._working_dir = self._projects_dir
-        self._server_iourc_path = iou_config.get("iourc", "")
-        self._iourc = ""
-
-        # check every 5 seconds
-        self._iou_callback = self.add_periodic_callback(self._check_iou_is_alive, 5000)
-        self._iou_callback.start()
-
-    def stop(self, signum=None):
-        """
-        Properly stops the module.
-
-        :param signum: signal number (if called by the signal handler)
-        """
-
-        self._iou_callback.stop()
-
-        # delete all IOU instances
-        for iou_id in self._iou_instances:
-            iou_instance = self._iou_instances[iou_id]
-            iou_instance.delete()
-
-        self.delete_iourc_file()
-
-        IModule.stop(self, signum)  # this will stop the I/O loop
-
-    def _check_iou_is_alive(self):
-        """
-        Periodic callback to check if IOU and iouyap are alive
-        for each IOU instance.
-
-        Sends a notification to the client if not.
-        """
-
-        for iou_id in self._iou_instances:
-            iou_instance = self._iou_instances[iou_id]
-            if iou_instance.started and (not iou_instance.is_running() or not iou_instance.is_iouyap_running()):
-                notification = {"module": self.name,
-                                "id": iou_id,
-                                "name": iou_instance.name}
-                if not iou_instance.is_running():
-                    stdout = iou_instance.read_iou_stdout()
-                    notification["message"] = "IOU has stopped running"
-                    notification["details"] = stdout
-                    self.send_notification("{}.iou_stopped".format(self.name), notification)
-                elif not iou_instance.is_iouyap_running():
-                    stdout = iou_instance.read_iouyap_stdout()
-                    notification["message"] = "iouyap has stopped running"
-                    notification["details"] = stdout
-                    self.send_notification("{}.iouyap_stopped".format(self.name), notification)
-                iou_instance.stop()
-
-    def get_iou_instance(self, iou_id):
-        """
-        Returns an IOU device instance.
-
-        :param iou_id: IOU device identifier
-
-        :returns: IOUDevice instance
-        """
-
-        if iou_id not in self._iou_instances:
-            log.debug("IOU device ID {} doesn't exist".format(iou_id), exc_info=1)
-            self.send_custom_error("IOU device ID {} doesn't exist".format(iou_id))
-            return None
-        return self._iou_instances[iou_id]
-
-    def delete_iourc_file(self):
-        """
-        Deletes the IOURC file.
-        """
-
-        if self._iourc and os.path.isfile(self._iourc):
-            try:
-                log.info("deleting iourc file {}".format(self._iourc))
-                os.remove(self._iourc)
-            except OSError as e:
-                log.warn("could not delete iourc file {}: {}".format(self._iourc, e))
-
-    @IModule.route("iou.reset")
-    def reset(self, request=None):
-        """
-        Resets the module (JSON-RPC notification).
-
-        :param request: JSON request (not used)
-        """
-
-        # delete all IOU instances
-        for iou_id in self._iou_instances:
-            iou_instance = self._iou_instances[iou_id]
-            iou_instance.delete()
-
-        # resets the instance IDs
-        IOUDevice.reset()
-
-        self._iou_instances.clear()
-        self._allocated_udp_ports.clear()
-        self.delete_iourc_file()
-
-        self._working_dir = self._projects_dir
-        log.info("IOU module has been reset")
-
-    @IModule.route("iou.settings")
-    def settings(self, request):
-        """
-        Set or update settings.
-
-        Mandatory request parameters:
-        - iourc (base64 encoded iourc file)
-
-        Optional request parameters:
-        - iouyap (path to iouyap)
-        - working_dir (path to a working directory)
-        - project_name
-        - console_start_port_range
-        - console_end_port_range
-        - udp_start_port_range
-        - udp_end_port_range
-
-        :param request: JSON request
-        """
-
-        if request is None:
-            self.send_param_error()
-            return
-
-        if "iourc" in request:
-            iourc_content = base64.decodebytes(request["iourc"].encode("utf-8")).decode("utf-8")
-            iourc_content = iourc_content.replace("\r\n", "\n")  # dos2unix
-            try:
-                with tempfile.NamedTemporaryFile(mode="w", delete=False) as f:
-                    log.info("saving iourc file content to {}".format(f.name))
-                    f.write(iourc_content)
-                    self._iourc = f.name
-            except OSError as e:
-                raise IOUError("Could not create the iourc file: {}".format(e))
-
-        if "iouyap" in request and request["iouyap"]:
-            self._iouyap = request["iouyap"]
-            log.info("iouyap path set to {}".format(self._iouyap))
-
-        if "working_dir" in request:
-            new_working_dir = request["working_dir"]
-            log.info("this server is local with working directory path to {}".format(new_working_dir))
-        else:
-            new_working_dir = os.path.join(self._projects_dir, request["project_name"])
-            log.info("this server is remote with working directory path to {}".format(new_working_dir))
-            if self._projects_dir != self._working_dir != new_working_dir:
-                if not os.path.isdir(new_working_dir):
-                    try:
-                        shutil.move(self._working_dir, new_working_dir)
-                    except OSError as e:
-                        log.error("could not move working directory from {} to {}: {}".format(self._working_dir,
-                                                                                              new_working_dir,
-                                                                                              e))
-                        return
-
-        # update the working directory if it has changed
-        if self._working_dir != new_working_dir:
-            self._working_dir = new_working_dir
-            for iou_id in self._iou_instances:
-                iou_instance = self._iou_instances[iou_id]
-                iou_instance.working_dir = os.path.join(self._working_dir, "iou", "device-{}".format(iou_instance.id))
-
-        if "console_start_port_range" in request and "console_end_port_range" in request:
-            self._console_start_port_range = request["console_start_port_range"]
-            self._console_end_port_range = request["console_end_port_range"]
-
-        if "udp_start_port_range" in request and "udp_end_port_range" in request:
-            self._udp_start_port_range = request["udp_start_port_range"]
-            self._udp_end_port_range = request["udp_end_port_range"]
-
-        log.debug("received request {}".format(request))
-
-    @IModule.route("iou.create")
-    def iou_create(self, request):
-        """
-        Creates a new IOU instance.
-
-        Mandatory request parameters:
-        - path (path to the IOU executable)
-
-        Optional request parameters:
-        - name (IOU name)
-        - console (IOU console port)
-
-        Response parameters:
-        - id (IOU instance identifier)
-        - name (IOU name)
-        - default settings
-
-        :param request: JSON request
-        """
-
-        # validate the request
-        if not self.validate_request(request, IOU_CREATE_SCHEMA):
-            return
-
-        name = request["name"]
-        iou_path = request["path"]
-        console = request.get("console")
-        iou_id = request.get("iou_id")
-
-        updated_iou_path = os.path.join(self.images_directory, iou_path)
-        if os.path.isfile(updated_iou_path):
-            iou_path = updated_iou_path
-        else:
-            if not os.path.exists(self.images_directory):
-                os.mkdir(self.images_directory)
-            cloud_path = request.get("cloud_path", None)
-            if cloud_path is not None:
-                # Download the image from cloud files
-                _, filename = ntpath.split(iou_path)
-                src = '{}/{}'.format(cloud_path, filename)
-                provider = get_provider(self._cloud_settings)
-                log.debug("Downloading file from {} to {}...".format(src, updated_iou_path))
-                provider.download_file(src, updated_iou_path)
-                log.debug("Download of {} complete.".format(src))
-                # Make file executable
-                st = os.stat(updated_iou_path)
-                os.chmod(updated_iou_path, st.st_mode | stat.S_IEXEC)
-                iou_path = updated_iou_path
-
-        try:
-            iou_instance = IOUDevice(name,
-                                     iou_path,
-                                     self._working_dir,
-                                     iou_id,
-                                     console,
-                                     self._console_host,
-                                     self._console_start_port_range,
-                                     self._console_end_port_range)
-
-        except IOUError as e:
-            self.send_custom_error(str(e))
-            return
-
-        response = {"name": iou_instance.name,
-                    "id": iou_instance.id}
-
-        defaults = iou_instance.defaults()
-        response.update(defaults)
-        self._iou_instances[iou_instance.id] = iou_instance
-        self.send_response(response)
-
-    @IModule.route("iou.delete")
-    def iou_delete(self, request):
-        """
-        Deletes an IOU instance.
-
-        Mandatory request parameters:
-        - id (IOU instance identifier)
-
-        Response parameter:
-        - True on success
-
-        :param request: JSON request
-        """
-
-        # validate the request
-        if not self.validate_request(request, IOU_DELETE_SCHEMA):
-            return
-
-        # get the instance
-        iou_instance = self.get_iou_instance(request["id"])
-        if not iou_instance:
-            return
-
-        try:
-            iou_instance.clean_delete()
-            del self._iou_instances[request["id"]]
-        except IOUError as e:
-            self.send_custom_error(str(e))
-            return
-
-        self.send_response(True)
-
-    @IModule.route("iou.update")
-    def iou_update(self, request):
-        """
-        Updates an IOU instance
-
-        Mandatory request parameters:
-        - id (IOU instance identifier)
-
-        Optional request parameters:
-        - any setting to update
-        - initial_config_base64 (initial-config base64 encoded)
-
-        Response parameters:
-        - updated settings
-
-        :param request: JSON request
-        """
-
-        # validate the request
-        if not self.validate_request(request, IOU_UPDATE_SCHEMA):
-            return
-
-        # get the instance
-        iou_instance = self.get_iou_instance(request["id"])
-        if not iou_instance:
-            return
-
-        config_path = os.path.join(iou_instance.working_dir, "initial-config.cfg")
-        try:
-            if "initial_config_base64" in request:
-                # a new initial-config has been pushed
-                config = base64.decodebytes(request["initial_config_base64"].encode("utf-8")).decode("utf-8")
-                config = "!\n" + config.replace("\r", "")
-                config = config.replace('%h', iou_instance.name)
-                try:
-                    with open(config_path, "w") as f:
-                        log.info("saving initial-config to {}".format(config_path))
-                        f.write(config)
-                except OSError as e:
-                    raise IOUError("Could not save the configuration {}: {}".format(config_path, e))
-                # update the request with the new local initial-config path
-                request["initial_config"] = os.path.basename(config_path)
-            elif "initial_config" in request:
-                if os.path.isfile(request["initial_config"]) and request["initial_config"] != config_path:
-                    # this is a local file set in the GUI
-                    try:
-                        with open(request["initial_config"], "r", errors="replace") as f:
-                            config = f.read()
-                        with open(config_path, "w") as f:
-                            config = "!\n" + config.replace("\r", "")
-                            config = config.replace('%h', iou_instance.name)
-                            f.write(config)
-                        request["initial_config"] = os.path.basename(config_path)
-                    except OSError as e:
-                        raise IOUError("Could not save the configuration from {} to {}: {}".format(request["initial_config"], config_path, e))
-                elif not os.path.isfile(config_path):
-                    raise IOUError("Startup-config {} could not be found on this server".format(request["initial_config"]))
-        except IOUError as e:
-            self.send_custom_error(str(e))
-            return
-
-        # update the IOU settings
-        response = {}
-        for name, value in request.items():
-            if hasattr(iou_instance, name) and getattr(iou_instance, name) != value:
-                try:
-                    setattr(iou_instance, name, value)
-                    response[name] = value
-                except IOUError as e:
-                    self.send_custom_error(str(e))
-                    return
-
-        self.send_response(response)
-
-    @IModule.route("iou.start")
-    def vm_start(self, request):
-        """
-        Starts an IOU instance.
-
-        Mandatory request parameters:
-        - id (IOU instance identifier)
-
-        Response parameters:
-        - True on success
-
-        :param request: JSON request
-        """
-
-        # validate the request
-        if not self.validate_request(request, IOU_START_SCHEMA):
-            return
-
-        # get the instance
-        iou_instance = self.get_iou_instance(request["id"])
-        if not iou_instance:
-            return
-
-        try:
-            iou_instance.iouyap = self._iouyap
-            if self._iourc:
-                iou_instance.iourc = self._iourc
-            else:
-                # if there is no IOURC file pushed by the client then use the server IOURC file
-                iou_instance.iourc = self._server_iourc_path
-            iou_instance.start()
-        except IOUError as e:
-            self.send_custom_error(str(e))
-            return
-        self.send_response(True)
-
-    @IModule.route("iou.stop")
-    def vm_stop(self, request):
-        """
-        Stops an IOU instance.
-
-        Mandatory request parameters:
-        - id (IOU instance identifier)
-
-        Response parameters:
-        - True on success
-
-        :param request: JSON request
-        """
-
-        # validate the request
-        if not self.validate_request(request, IOU_STOP_SCHEMA):
-            return
-
-        # get the instance
-        iou_instance = self.get_iou_instance(request["id"])
-        if not iou_instance:
-            return
-
-        try:
-            iou_instance.stop()
-        except IOUError as e:
-            self.send_custom_error(str(e))
-            return
-        self.send_response(True)
-
-    @IModule.route("iou.reload")
-    def vm_reload(self, request):
-        """
-        Reloads an IOU instance.
-
-        Mandatory request parameters:
-        - id (IOU identifier)
-
-        Response parameters:
-        - True on success
-
-        :param request: JSON request
-        """
-
-        # validate the request
-        if not self.validate_request(request, IOU_RELOAD_SCHEMA):
-            return
-
-        # get the instance
-        iou_instance = self.get_iou_instance(request["id"])
-        if not iou_instance:
-            return
-
-        try:
-            if iou_instance.is_running():
-                iou_instance.stop()
-            iou_instance.start()
-        except IOUError as e:
-            self.send_custom_error(str(e))
-            return
-        self.send_response(True)
-
-    @IModule.route("iou.allocate_udp_port")
-    def allocate_udp_port(self, request):
-        """
-        Allocates a UDP port in order to create an UDP NIO.
-
-        Mandatory request parameters:
-        - id (IOU identifier)
-        - port_id (unique port identifier)
-
-        Response parameters:
-        - port_id (unique port identifier)
-        - lport (allocated local port)
-
-        :param request: JSON request
-        """
-
-        # validate the request
-        if not self.validate_request(request, IOU_ALLOCATE_UDP_PORT_SCHEMA):
-            return
-
-        # get the instance
-        iou_instance = self.get_iou_instance(request["id"])
-        if not iou_instance:
-            return
-
-        try:
-            port = find_unused_port(self._udp_start_port_range,
-                                    self._udp_end_port_range,
-                                    host=self._host,
-                                    socket_type="UDP",
-                                    ignore_ports=self._allocated_udp_ports)
-        except Exception as e:
-            self.send_custom_error(str(e))
-            return
-
-        self._allocated_udp_ports.append(port)
-        log.info("{} [id={}] has allocated UDP port {} with host {}".format(iou_instance.name,
-                                                                            iou_instance.id,
-                                                                            port,
-                                                                            self._host))
-        response = {"lport": port,
-                    "port_id": request["port_id"]}
-        self.send_response(response)
-
-    @IModule.route("iou.add_nio")
-    def add_nio(self, request):
-        """
-        Adds an NIO (Network Input/Output) for an IOU instance.
-
-        Mandatory request parameters:
-        - id (IOU instance identifier)
-        - slot (slot number)
-        - port (port number)
-        - port_id (unique port identifier)
-        - nio (one of the following)
-            - type "nio_udp"
-                - lport (local port)
-                - rhost (remote host)
-                - rport (remote port)
-            - type "nio_generic_ethernet"
-                - ethernet_device (Ethernet device name e.g. eth0)
-            - type "nio_tap"
-                - tap_device (TAP device name e.g. tap0)
-
-        Response parameters:
-        - port_id (unique port identifier)
-
-        :param request: JSON request
-        """
-
-        # validate the request
-        if not self.validate_request(request, IOU_ADD_NIO_SCHEMA):
-            return
-
-        # get the instance
-        iou_instance = self.get_iou_instance(request["id"])
-        if not iou_instance:
-            return
-
-        slot = request["slot"]
-        port = request["port"]
-        try:
-            nio = None
-            if request["nio"]["type"] == "nio_udp":
-                lport = request["nio"]["lport"]
-                rhost = request["nio"]["rhost"]
-                rport = request["nio"]["rport"]
-                try:
-                    # TODO: handle IPv6
-                    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
-                        sock.connect((rhost, rport))
-                except OSError as e:
-                    raise IOUError("Could not create an UDP connection to {}:{}: {}".format(rhost, rport, e))
-                nio = NIO_UDP(lport, rhost, rport)
-            elif request["nio"]["type"] == "nio_tap":
-                tap_device = request["nio"]["tap_device"]
-                if not has_privileged_access(self._iouyap):
-                    raise IOUError("{} has no privileged access to {}.".format(self._iouyap, tap_device))
-                nio = NIO_TAP(tap_device)
-            elif request["nio"]["type"] == "nio_generic_ethernet":
-                ethernet_device = request["nio"]["ethernet_device"]
-                if not has_privileged_access(self._iouyap):
-                    raise IOUError("{} has no privileged access to {}.".format(self._iouyap, ethernet_device))
-                nio = NIO_GenericEthernet(ethernet_device)
-            if not nio:
-                raise IOUError("Requested NIO does not exist or is not supported: {}".format(request["nio"]["type"]))
-        except IOUError as e:
-            self.send_custom_error(str(e))
-            return
-
-        try:
-            iou_instance.slot_add_nio_binding(slot, port, nio)
-        except IOUError as e:
-            self.send_custom_error(str(e))
-            return
-
-        self.send_response({"port_id": request["port_id"]})
-
-    @IModule.route("iou.delete_nio")
-    def delete_nio(self, request):
-        """
-        Deletes an NIO (Network Input/Output).
-
-        Mandatory request parameters:
-        - id (IOU instance identifier)
-        - slot (slot identifier)
-        - port (port identifier)
-
-        Response parameters:
-        - True on success
-
-        :param request: JSON request
-        """
-
-        # validate the request
-        if not self.validate_request(request, IOU_DELETE_NIO_SCHEMA):
-            return
-
-        # get the instance
-        iou_instance = self.get_iou_instance(request["id"])
-        if not iou_instance:
-            return
-
-        slot = request["slot"]
-        port = request["port"]
-        try:
-            nio = iou_instance.slot_remove_nio_binding(slot, port)
-            if isinstance(nio, NIO_UDP) and nio.lport in self._allocated_udp_ports:
-                self._allocated_udp_ports.remove(nio.lport)
-        except IOUError as e:
-            self.send_custom_error(str(e))
-            return
-
-        self.send_response(True)
-
-    @IModule.route("iou.start_capture")
-    def start_capture(self, request):
-        """
-        Starts a packet capture.
-
-        Mandatory request parameters:
-        - id (vm identifier)
-        - slot (slot number)
-        - port (port number)
-        - port_id (port identifier)
-        - capture_file_name
-
-        Optional request parameters:
-        - data_link_type (PCAP DLT_* value)
-
-        Response parameters:
-        - port_id (port identifier)
-        - capture_file_path (path to the capture file)
-
-        :param request: JSON request
-        """
-
-        # validate the request
-        if not self.validate_request(request, IOU_START_CAPTURE_SCHEMA):
-            return
-
-        # get the instance
-        iou_instance = self.get_iou_instance(request["id"])
-        if not iou_instance:
-            return
-
-        slot = request["slot"]
-        port = request["port"]
-        capture_file_name = request["capture_file_name"]
-        data_link_type = request.get("data_link_type")
-
-        try:
-            capture_file_path = os.path.join(self._working_dir, "captures", capture_file_name)
-            iou_instance.start_capture(slot, port, capture_file_path, data_link_type)
-        except IOUError as e:
-            self.send_custom_error(str(e))
-            return
-
-        response = {"port_id": request["port_id"],
-                    "capture_file_path": capture_file_path}
-        self.send_response(response)
-
-    @IModule.route("iou.stop_capture")
-    def stop_capture(self, request):
-        """
-        Stops a packet capture.
-
-        Mandatory request parameters:
-        - id (vm identifier)
-        - slot (slot number)
-        - port (port number)
-        - port_id (port identifier)
-
-        Response parameters:
-        - port_id (port identifier)
-
-        :param request: JSON request
-        """
-
-        # validate the request
-        if not self.validate_request(request, IOU_STOP_CAPTURE_SCHEMA):
-            return
-
-        # get the instance
-        iou_instance = self.get_iou_instance(request["id"])
-        if not iou_instance:
-            return
-
-        slot = request["slot"]
-        port = request["port"]
-        try:
-            iou_instance.stop_capture(slot, port)
-        except IOUError as e:
-            self.send_custom_error(str(e))
-            return
-
-        response = {"port_id": request["port_id"]}
-        self.send_response(response)
-
-    @IModule.route("iou.export_config")
-    def export_config(self, request):
-        """
-        Exports the initial-config from an IOU instance.
-
-        Mandatory request parameters:
-        - id (vm identifier)
-
-        Response parameters:
-        - initial_config_base64 (initial-config base64 encoded)
-        - False if no configuration can be exported
-        """
-
-        # validate the request
-        if not self.validate_request(request, IOU_EXPORT_CONFIG_SCHEMA):
-            return
-
-        # get the instance
-        iou_instance = self.get_iou_instance(request["id"])
-        if not iou_instance:
-            return
-
-        if not iou_instance.initial_config:
-            self.send_custom_error("unable to export the initial-config because it doesn't exist")
-            return
-
-        response = {}
-        initial_config_path = os.path.join(iou_instance.working_dir, iou_instance.initial_config)
-        try:
-            with open(initial_config_path, "rb") as f:
-                config = f.read()
-                response["initial_config_base64"] = base64.encodebytes(config).decode("utf-8")
-        except OSError as e:
-            self.send_custom_error("unable to export the initial-config: {}".format(e))
-            return
-
-        if not response:
-            self.send_response(False)
-        else:
-            self.send_response(response)
-
-    @IModule.route("iou.echo")
-    def echo(self, request):
-        """
-        Echo end point for testing purposes.
-
-        :param request: JSON request
-        """
-
-        if request is None:
-            self.send_param_error()
-        else:
-            log.debug("received request {}".format(request))
-            self.send_response(request)

gns3server/old_modules/iou/adapters/adapter.py

@@ -1,105 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2014 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/>.
-
-
-class Adapter(object):
-
-    """
-    Base class for adapters.
-
-    :param interfaces: number of interfaces supported by this adapter.
-    """
-
-    def __init__(self, interfaces=4):
-
-        self._interfaces = interfaces
-
-        self._ports = {}
-        for port_id in range(0, interfaces):
-            self._ports[port_id] = None
-
-    def removable(self):
-        """
-        Returns True if the adapter can be removed from a slot
-        and False if not.
-
-        :returns: boolean
-        """
-
-        return True
-
-    def port_exists(self, port_id):
-        """
-        Checks if a port exists on this adapter.
-
-        :returns: True is the port exists,
-        False otherwise.
-        """
-
-        if port_id in self._ports:
-            return True
-        return False
-
-    def add_nio(self, port_id, nio):
-        """
-        Adds a NIO to a port on this adapter.
-
-        :param port_id: port ID (integer)
-        :param nio: NIO instance
-        """
-
-        self._ports[port_id] = nio
-
-    def remove_nio(self, port_id):
-        """
-        Removes a NIO from a port on this adapter.
-
-        :param port_id: port ID (integer)
-        """
-
-        self._ports[port_id] = None
-
-    def get_nio(self, port_id):
-        """
-        Returns the NIO assigned to a port.
-
-        :params port_id: port ID (integer)
-
-        :returns: NIO instance
-        """
-
-        return self._ports[port_id]
-
-    @property
-    def ports(self):
-        """
-        Returns port to NIO mapping
-
-        :returns: dictionary port -> NIO
-        """
-
-        return self._ports
-
-    @property
-    def interfaces(self):
-        """
-        Returns the number of interfaces supported by this adapter.
-
-        :returns: number of interfaces
-        """
-
-        return self._interfaces

gns3server/old_modules/iou/iou_error.py

@@ -1,39 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2013 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/>.
-
-"""
-Custom exceptions for IOU module.
-"""
-
-
-class IOUError(Exception):
-
-    def __init__(self, message, original_exception=None):
-
-        Exception.__init__(self, message)
-        if isinstance(message, Exception):
-            message = str(message)
-        self._message = message
-        self._original_exception = original_exception
-
-    def __repr__(self):
-
-        return self._message
-
-    def __str__(self):
-
-        return self._message

gns3server/old_modules/iou/nios/nio.py

@@ -1,80 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2013 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/>.
-
-"""
-Base interface for NIOs.
-"""
-
-
-class NIO(object):
-
-    """
-    Network Input/Output.
-    """
-
-    def __init__(self):
-
-        self._capturing = False
-        self._pcap_output_file = ""
-        self._pcap_data_link_type = ""
-
-    def startPacketCapture(self, pcap_output_file, pcap_data_link_type="DLT_EN10MB"):
-        """
-
-        :param pcap_output_file: PCAP destination file for the capture
-        :param pcap_data_link_type: PCAP data link type (DLT_*), default is DLT_EN10MB
-        """
-
-        self._capturing = True
-        self._pcap_output_file = pcap_output_file
-        self._pcap_data_link_type = pcap_data_link_type
-
-    def stopPacketCapture(self):
-
-        self._capturing = False
-        self._pcap_output_file = ""
-        self._pcap_data_link_type = ""
-
-    @property
-    def capturing(self):
-        """
-        Returns either a capture is configured on this NIO.
-
-        :returns: boolean
-        """
-
-        return self._capturing
-
-    @property
-    def pcap_output_file(self):
-        """
-        Returns the path to the PCAP output file.
-
-        :returns: path to the PCAP output file
-        """
-
-        return self._pcap_output_file
-
-    @property
-    def pcap_data_link_type(self):
-        """
-        Returns the PCAP data link type
-
-        :returns: PCAP data link type (DLT_* value)
-        """
-
-        return self._pcap_data_link_type

gns3server/old_modules/iou/nios/nio_generic_ethernet.py

@@ -1,50 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2013 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/>.
-
-"""
-Interface for generic Ethernet NIOs (PCAP library).
-"""
-
-from .nio import NIO
-
-
-class NIO_GenericEthernet(NIO):
-
-    """
-    Generic Ethernet NIO.
-
-    :param ethernet_device: Ethernet device name (e.g. eth0)
-    """
-
-    def __init__(self, ethernet_device):
-
-        NIO.__init__(self)
-        self._ethernet_device = ethernet_device
-
-    @property
-    def ethernet_device(self):
-        """
-        Returns the Ethernet device used by this NIO.
-
-        :returns: the Ethernet device name
-        """
-
-        return self._ethernet_device
-
-    def __str__(self):
-
-        return "NIO Ethernet"

gns3server/old_modules/iou/nios/nio_tap.py

@@ -1,50 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2013 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/>.
-
-"""
-Interface for TAP NIOs (UNIX based OSes only).
-"""
-
-from .nio import NIO
-
-
-class NIO_TAP(NIO):
-
-    """
-    TAP NIO.
-
-    :param tap_device: TAP device name (e.g. tap0)
-    """
-
-    def __init__(self, tap_device):
-
-        NIO.__init__(self)
-        self._tap_device = tap_device
-
-    @property
-    def tap_device(self):
-        """
-        Returns the TAP device used by this NIO.
-
-        :returns: the TAP device name
-        """
-
-        return self._tap_device
-
-    def __str__(self):
-
-        return "NIO TAP"

gns3server/old_modules/iou/nios/nio_udp.py

@@ -1,76 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2013 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/>.
-
-"""
-Interface for UDP NIOs.
-"""
-
-from .nio import NIO
-
-
-class NIO_UDP(NIO):
-
-    """
-    UDP NIO.
-
-    :param lport: local port number
-    :param rhost: remote address/host
-    :param rport: remote port number
-    """
-
-    _instance_count = 0
-
-    def __init__(self, lport, rhost, rport):
-
-        NIO.__init__(self)
-        self._lport = lport
-        self._rhost = rhost
-        self._rport = rport
-
-    @property
-    def lport(self):
-        """
-        Returns the local port
-
-        :returns: local port number
-        """
-
-        return self._lport
-
-    @property
-    def rhost(self):
-        """
-        Returns the remote host
-
-        :returns: remote address/host
-        """
-
-        return self._rhost
-
-    @property
-    def rport(self):
-        """
-        Returns the remote port
-
-        :returns: remote port number
-        """
-
-        return self._rport
-
-    def __str__(self):
-
-        return "NIO UDP"

gns3server/old_modules/iou/schemas.py

@@ -1,472 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2014 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/>.
-
-
-IOU_CREATE_SCHEMA = {
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "description": "Request validation to create a new IOU instance",
-    "type": "object",
-    "properties": {
-        "name": {
-            "description": "IOU device name",
-            "type": "string",
-            "minLength": 1,
-        },
-        "iou_id": {
-            "description": "IOU device instance ID",
-            "type": "integer"
-        },
-        "console": {
-            "description": "console TCP port",
-            "minimum": 1,
-            "maximum": 65535,
-            "type": "integer"
-        },
-        "path": {
-            "description": "path to the IOU executable",
-            "type": "string",
-            "minLength": 1,
-        },
-        "cloud_path": {
-            "description": "Path to the image in the cloud object store",
-            "type": "string",
-        }
-    },
-    "additionalProperties": False,
-    "required": ["name", "path"],
-}
-
-IOU_DELETE_SCHEMA = {
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "description": "Request validation to delete an IOU instance",
-    "type": "object",
-    "properties": {
-        "id": {
-            "description": "IOU device instance ID",
-            "type": "integer"
-        },
-    },
-    "additionalProperties": False,
-    "required": ["id"]
-}
-
-IOU_UPDATE_SCHEMA = {
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "description": "Request validation to update an IOU instance",
-    "type": "object",
-    "properties": {
-        "id": {
-            "description": "IOU device instance ID",
-            "type": "integer"
-        },
-        "name": {
-            "description": "IOU device name",
-            "type": "string",
-            "minLength": 1,
-        },
-        "path": {
-            "description": "path to the IOU executable",
-            "type": "string",
-            "minLength": 1,
-        },
-        "initial_config": {
-            "description": "path to the IOU initial configuration file",
-            "type": "string",
-            "minLength": 1,
-        },
-        "ram": {
-            "description": "amount of RAM in MB",
-            "type": "integer"
-        },
-        "nvram": {
-            "description": "amount of NVRAM in KB",
-            "type": "integer"
-        },
-        "ethernet_adapters": {
-            "description": "number of Ethernet adapters",
-            "type": "integer",
-            "minimum": 0,
-            "maximum": 16,
-        },
-        "serial_adapters": {
-            "description": "number of serial adapters",
-            "type": "integer",
-            "minimum": 0,
-            "maximum": 16,
-        },
-        "console": {
-            "description": "console TCP port",
-            "minimum": 1,
-            "maximum": 65535,
-            "type": "integer"
-        },
-        "use_default_iou_values": {
-            "description": "use the default IOU RAM & NVRAM values",
-            "type": "boolean"
-        },
-        "l1_keepalives": {
-            "description": "enable or disable layer 1 keepalive messages",
-            "type": "boolean"
-        },
-        "initial_config_base64": {
-            "description": "initial configuration base64 encoded",
-            "type": "string"
-        },
-    },
-    "additionalProperties": False,
-    "required": ["id"]
-}
-
-IOU_START_SCHEMA = {
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "description": "Request validation to start an IOU instance",
-    "type": "object",
-    "properties": {
-        "id": {
-            "description": "IOU device instance ID",
-            "type": "integer"
-        },
-    },
-    "additionalProperties": False,
-    "required": ["id"]
-}
-
-IOU_STOP_SCHEMA = {
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "description": "Request validation to stop an IOU instance",
-    "type": "object",
-    "properties": {
-        "id": {
-            "description": "IOU device instance ID",
-            "type": "integer"
-        },
-    },
-    "additionalProperties": False,
-    "required": ["id"]
-}
-
-IOU_RELOAD_SCHEMA = {
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "description": "Request validation to reload an IOU instance",
-    "type": "object",
-    "properties": {
-        "id": {
-            "description": "IOU device instance ID",
-            "type": "integer"
-        },
-    },
-    "additionalProperties": False,
-    "required": ["id"]
-}
-
-IOU_ALLOCATE_UDP_PORT_SCHEMA = {
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "description": "Request validation to allocate an UDP port for an IOU instance",
-    "type": "object",
-    "properties": {
-        "id": {
-            "description": "IOU device instance ID",
-            "type": "integer"
-        },
-        "port_id": {
-            "description": "Unique port identifier for the IOU instance",
-            "type": "integer"
-        },
-    },
-    "additionalProperties": False,
-    "required": ["id", "port_id"]
-}
-
-IOU_ADD_NIO_SCHEMA = {
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "description": "Request validation to add a NIO for an IOU instance",
-    "type": "object",
-
-    "definitions": {
-        "UDP": {
-            "description": "UDP Network Input/Output",
-            "properties": {
-                "type": {
-                    "enum": ["nio_udp"]
-                },
-                "lport": {
-                    "description": "Local port",
-                    "type": "integer",
-                    "minimum": 1,
-                    "maximum": 65535
-                },
-                "rhost": {
-                    "description": "Remote host",
-                    "type": "string",
-                    "minLength": 1
-                },
-                "rport": {
-                    "description": "Remote port",
-                    "type": "integer",
-                    "minimum": 1,
-                    "maximum": 65535
-                }
-            },
-            "required": ["type", "lport", "rhost", "rport"],
-            "additionalProperties": False
-        },
-        "Ethernet": {
-            "description": "Generic Ethernet Network Input/Output",
-            "properties": {
-                "type": {
-                    "enum": ["nio_generic_ethernet"]
-                },
-                "ethernet_device": {
-                    "description": "Ethernet device name e.g. eth0",
-                    "type": "string",
-                    "minLength": 1
-                },
-            },
-            "required": ["type", "ethernet_device"],
-            "additionalProperties": False
-        },
-        "LinuxEthernet": {
-            "description": "Linux Ethernet Network Input/Output",
-            "properties": {
-                "type": {
-                    "enum": ["nio_linux_ethernet"]
-                },
-                "ethernet_device": {
-                    "description": "Ethernet device name e.g. eth0",
-                    "type": "string",
-                    "minLength": 1
-                },
-            },
-            "required": ["type", "ethernet_device"],
-            "additionalProperties": False
-        },
-        "TAP": {
-            "description": "TAP Network Input/Output",
-            "properties": {
-                "type": {
-                    "enum": ["nio_tap"]
-                },
-                "tap_device": {
-                    "description": "TAP device name e.g. tap0",
-                    "type": "string",
-                    "minLength": 1
-                },
-            },
-            "required": ["type", "tap_device"],
-            "additionalProperties": False
-        },
-        "UNIX": {
-            "description": "UNIX Network Input/Output",
-            "properties": {
-                "type": {
-                    "enum": ["nio_unix"]
-                },
-                "local_file": {
-                    "description": "path to the UNIX socket file (local)",
-                    "type": "string",
-                    "minLength": 1
-                },
-                "remote_file": {
-                    "description": "path to the UNIX socket file (remote)",
-                    "type": "string",
-                    "minLength": 1
-                },
-            },
-            "required": ["type", "local_file", "remote_file"],
-            "additionalProperties": False
-        },
-        "VDE": {
-            "description": "VDE Network Input/Output",
-            "properties": {
-                "type": {
-                    "enum": ["nio_vde"]
-                },
-                "control_file": {
-                    "description": "path to the VDE control file",
-                    "type": "string",
-                    "minLength": 1
-                },
-                "local_file": {
-                    "description": "path to the VDE control file",
-                    "type": "string",
-                    "minLength": 1
-                },
-            },
-            "required": ["type", "control_file", "local_file"],
-            "additionalProperties": False
-        },
-        "NULL": {
-            "description": "NULL Network Input/Output",
-            "properties": {
-                "type": {
-                    "enum": ["nio_null"]
-                },
-            },
-            "required": ["type"],
-            "additionalProperties": False
-        },
-    },
-
-    "properties": {
-        "id": {
-            "description": "IOU device instance ID",
-            "type": "integer"
-        },
-        "port_id": {
-            "description": "Unique port identifier for the IOU instance",
-            "type": "integer"
-        },
-        "slot": {
-            "description": "Slot number",
-            "type": "integer",
-            "minimum": 0,
-            "maximum": 15
-        },
-        "port": {
-            "description": "Port number",
-            "type": "integer",
-            "minimum": 0,
-            "maximum": 3
-        },
-        "nio": {
-            "type": "object",
-            "description": "Network Input/Output",
-            "oneOf": [
-                {"$ref": "#/definitions/UDP"},
-                {"$ref": "#/definitions/Ethernet"},
-                {"$ref": "#/definitions/LinuxEthernet"},
-                {"$ref": "#/definitions/TAP"},
-                {"$ref": "#/definitions/UNIX"},
-                {"$ref": "#/definitions/VDE"},
-                {"$ref": "#/definitions/NULL"},
-            ]
-        },
-    },
-    "additionalProperties": False,
-    "required": ["id", "port_id", "slot", "port", "nio"]
-}
-
-
-IOU_DELETE_NIO_SCHEMA = {
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "description": "Request validation to delete a NIO for an IOU instance",
-    "type": "object",
-    "properties": {
-        "id": {
-            "description": "IOU device instance ID",
-            "type": "integer"
-        },
-        "slot": {
-            "description": "Slot number",
-            "type": "integer",
-            "minimum": 0,
-            "maximum": 15
-        },
-        "port": {
-            "description": "Port number",
-            "type": "integer",
-            "minimum": 0,
-            "maximum": 3
-        },
-    },
-    "additionalProperties": False,
-    "required": ["id", "slot", "port"]
-}
-
-IOU_START_CAPTURE_SCHEMA = {
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "description": "Request validation to start a packet capture on an IOU instance port",
-    "type": "object",
-    "properties": {
-        "id": {
-            "description": "IOU device instance ID",
-            "type": "integer"
-        },
-        "slot": {
-            "description": "Slot number",
-            "type": "integer",
-            "minimum": 0,
-            "maximum": 15
-        },
-        "port": {
-            "description": "Port number",
-            "type": "integer",
-            "minimum": 0,
-            "maximum": 3
-        },
-        "port_id": {
-            "description": "Unique port identifier for the IOU instance",
-            "type": "integer"
-        },
-        "capture_file_name": {
-            "description": "Capture file name",
-            "type": "string",
-            "minLength": 1,
-        },
-        "data_link_type": {
-            "description": "PCAP data link type",
-            "type": "string",
-            "minLength": 1,
-        },
-    },
-    "additionalProperties": False,
-    "required": ["id", "slot", "port", "port_id", "capture_file_name"]
-}
-
-IOU_STOP_CAPTURE_SCHEMA = {
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "description": "Request validation to stop a packet capture on an IOU instance port",
-    "type": "object",
-    "properties": {
-        "id": {
-            "description": "IOU device instance ID",
-            "type": "integer"
-        },
-        "slot": {
-            "description": "Slot number",
-            "type": "integer",
-            "minimum": 0,
-            "maximum": 15
-        },
-        "port": {
-            "description": "Port number",
-            "type": "integer",
-            "minimum": 0,
-            "maximum": 3
-        },
-        "port_id": {
-            "description": "Unique port identifier for the IOU instance",
-            "type": "integer"
-        },
-    },
-    "additionalProperties": False,
-    "required": ["id", "slot", "port", "port_id"]
-}
-
-IOU_EXPORT_CONFIG_SCHEMA = {
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "description": "Request validation to export an initial-config from an IOU instance",
-    "type": "object",
-    "properties": {
-        "id": {
-            "description": "IOU device instance ID",
-            "type": "integer"
-        },
-    },
-    "additionalProperties": False,
-    "required": ["id"]
-}

gns3server/old_modules/qemu/__init__.py

@@ -1,687 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2014 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/>.
-
-"""
-QEMU server module.
-"""
-
-import sys
-import os
-import socket
-import shutil
-import subprocess
-import re
-
-from gns3server.modules import IModule
-from gns3server.config import Config
-from .qemu_vm import QemuVM
-from .qemu_error import QemuError
-from .nios.nio_udp import NIO_UDP
-from ..attic import find_unused_port
-
-from .schemas import QEMU_CREATE_SCHEMA
-from .schemas import QEMU_DELETE_SCHEMA
-from .schemas import QEMU_UPDATE_SCHEMA
-from .schemas import QEMU_START_SCHEMA
-from .schemas import QEMU_STOP_SCHEMA
-from .schemas import QEMU_SUSPEND_SCHEMA
-from .schemas import QEMU_RELOAD_SCHEMA
-from .schemas import QEMU_ALLOCATE_UDP_PORT_SCHEMA
-from .schemas import QEMU_ADD_NIO_SCHEMA
-from .schemas import QEMU_DELETE_NIO_SCHEMA
-
-import logging
-log = logging.getLogger(__name__)
-
-
-class Qemu(IModule):
-
-    """
-    QEMU module.
-
-    :param name: module name
-    :param args: arguments for the module
-    :param kwargs: named arguments for the module
-    """
-
-    def __init__(self, name, *args, **kwargs):
-
-        # a new process start when calling IModule
-        IModule.__init__(self, name, *args, **kwargs)
-        self._qemu_instances = {}
-
-        config = Config.instance()
-        qemu_config = config.get_section_config(name.upper())
-        self._console_start_port_range = qemu_config.get("console_start_port_range", 5001)
-        self._console_end_port_range = qemu_config.get("console_end_port_range", 5500)
-        self._monitor_start_port_range = qemu_config.get("monitor_start_port_range", 5501)
-        self._monitor_end_port_range = qemu_config.get("monitor_end_port_range", 6000)
-        self._allocated_udp_ports = []
-        self._udp_start_port_range = qemu_config.get("udp_start_port_range", 40001)
-        self._udp_end_port_range = qemu_config.get("udp_end_port_range", 45500)
-        self._host = qemu_config.get("host", kwargs["host"])
-        self._console_host = qemu_config.get("console_host", kwargs["console_host"])
-        self._monitor_host = qemu_config.get("monitor_host", "127.0.0.1")
-        self._projects_dir = kwargs["projects_dir"]
-        self._tempdir = kwargs["temp_dir"]
-        self._working_dir = self._projects_dir
-
-    def stop(self, signum=None):
-        """
-        Properly stops the module.
-
-        :param signum: signal number (if called by the signal handler)
-        """
-
-        # delete all QEMU instances
-        for qemu_id in self._qemu_instances:
-            qemu_instance = self._qemu_instances[qemu_id]
-            qemu_instance.delete()
-
-        IModule.stop(self, signum)  # this will stop the I/O loop
-
-    def get_qemu_instance(self, qemu_id):
-        """
-        Returns a QEMU VM instance.
-
-        :param qemu_id: QEMU VM identifier
-
-        :returns: QemuVM instance
-        """
-
-        if qemu_id not in self._qemu_instances:
-            log.debug("QEMU VM ID {} doesn't exist".format(qemu_id), exc_info=1)
-            self.send_custom_error("QEMU VM ID {} doesn't exist".format(qemu_id))
-            return None
-        return self._qemu_instances[qemu_id]
-
-    @IModule.route("qemu.reset")
-    def reset(self, request):
-        """
-        Resets the module.
-
-        :param request: JSON request
-        """
-
-        # delete all QEMU instances
-        for qemu_id in self._qemu_instances:
-            qemu_instance = self._qemu_instances[qemu_id]
-            qemu_instance.delete()
-
-        # resets the instance IDs
-        QemuVM.reset()
-
-        self._qemu_instances.clear()
-        self._allocated_udp_ports.clear()
-
-        self._working_dir = self._projects_dir
-        log.info("QEMU module has been reset")
-
-    @IModule.route("qemu.settings")
-    def settings(self, request):
-        """
-        Set or update settings.
-
-        Optional request parameters:
-        - working_dir (path to a working directory)
-        - project_name
-        - console_start_port_range
-        - console_end_port_range
-        - monitor_start_port_range
-        - monitor_end_port_range
-        - udp_start_port_range
-        - udp_end_port_range
-
-        :param request: JSON request
-        """
-
-        if request is None:
-            self.send_param_error()
-            return
-
-        if "working_dir" in request:
-            new_working_dir = request["working_dir"]
-            log.info("this server is local with working directory path to {}".format(new_working_dir))
-        else:
-            new_working_dir = os.path.join(self._projects_dir, request["project_name"])
-            log.info("this server is remote with working directory path to {}".format(new_working_dir))
-            if self._projects_dir != self._working_dir != new_working_dir:
-                if not os.path.isdir(new_working_dir):
-                    try:
-                        shutil.move(self._working_dir, new_working_dir)
-                    except OSError as e:
-                        log.error("could not move working directory from {} to {}: {}".format(self._working_dir,
-                                                                                              new_working_dir,
-                                                                                              e))
-                        return
-
-        # update the working directory if it has changed
-        if self._working_dir != new_working_dir:
-            self._working_dir = new_working_dir
-            for qemu_id in self._qemu_instances:
-                qemu_instance = self._qemu_instances[qemu_id]
-                qemu_instance.working_dir = os.path.join(self._working_dir, "qemu", "vm-{}".format(qemu_instance.id))
-
-        if "console_start_port_range" in request and "console_end_port_range" in request:
-            self._console_start_port_range = request["console_start_port_range"]
-            self._console_end_port_range = request["console_end_port_range"]
-
-        if "monitor_start_port_range" in request and "monitor_end_port_range" in request:
-            self._monitor_start_port_range = request["monitor_start_port_range"]
-            self._monitor_end_port_range = request["monitor_end_port_range"]
-
-        if "udp_start_port_range" in request and "udp_end_port_range" in request:
-            self._udp_start_port_range = request["udp_start_port_range"]
-            self._udp_end_port_range = request["udp_end_port_range"]
-
-        log.debug("received request {}".format(request))
-
-    @IModule.route("qemu.create")
-    def qemu_create(self, request):
-        """
-        Creates a new QEMU VM instance.
-
-        Mandatory request parameters:
-        - name (QEMU VM name)
-        - qemu_path (path to the Qemu binary)
-
-        Optional request parameters:
-        - console (QEMU VM console port)
-        - monitor (QEMU VM monitor port)
-
-        Response parameters:
-        - id (QEMU VM instance identifier)
-        - name (QEMU VM name)
-        - default settings
-
-        :param request: JSON request
-        """
-
-        # validate the request
-        if not self.validate_request(request, QEMU_CREATE_SCHEMA):
-            return
-
-        name = request["name"]
-        qemu_path = request["qemu_path"]
-        console = request.get("console")
-        monitor = request.get("monitor")
-        qemu_id = request.get("qemu_id")
-
-        try:
-            qemu_instance = QemuVM(name,
-                                   qemu_path,
-                                   self._working_dir,
-                                   self._host,
-                                   qemu_id,
-                                   console,
-                                   self._console_host,
-                                   self._console_start_port_range,
-                                   self._console_end_port_range,
-                                   monitor,
-                                   self._monitor_host,
-                                   self._monitor_start_port_range,
-                                   self._monitor_end_port_range)
-
-        except QemuError as e:
-            self.send_custom_error(str(e))
-            return
-
-        response = {"name": qemu_instance.name,
-                    "id": qemu_instance.id}
-
-        defaults = qemu_instance.defaults()
-        response.update(defaults)
-        self._qemu_instances[qemu_instance.id] = qemu_instance
-        self.send_response(response)
-
-    @IModule.route("qemu.delete")
-    def qemu_delete(self, request):
-        """
-        Deletes a QEMU VM instance.
-
-        Mandatory request parameters:
-        - id (QEMU VM instance identifier)
-
-        Response parameter:
-        - True on success
-
-        :param request: JSON request
-        """
-
-        # validate the request
-        if not self.validate_request(request, QEMU_DELETE_SCHEMA):
-            return
-
-        # get the instance
-        qemu_instance = self.get_qemu_instance(request["id"])
-        if not qemu_instance:
-            return
-
-        try:
-            qemu_instance.clean_delete()
-            del self._qemu_instances[request["id"]]
-        except QemuError as e:
-            self.send_custom_error(str(e))
-            return
-
-        self.send_response(True)
-
-    @IModule.route("qemu.update")
-    def qemu_update(self, request):
-        """
-        Updates a QEMU VM instance
-
-        Mandatory request parameters:
-        - id (QEMU VM instance identifier)
-
-        Optional request parameters:
-        - any setting to update
-
-        Response parameters:
-        - updated settings
-
-        :param request: JSON request
-        """
-
-        # validate the request
-        if not self.validate_request(request, QEMU_UPDATE_SCHEMA):
-            return
-
-        # get the instance
-        qemu_instance = self.get_qemu_instance(request["id"])
-        if not qemu_instance:
-            return
-
-        # update the QEMU VM settings
-        response = {}
-        for name, value in request.items():
-            if hasattr(qemu_instance, name) and getattr(qemu_instance, name) != value:
-                try:
-                    setattr(qemu_instance, name, value)
-                    response[name] = value
-                except QemuError as e:
-                    self.send_custom_error(str(e))
-                    return
-
-        self.send_response(response)
-
-    @IModule.route("qemu.start")
-    def qemu_start(self, request):
-        """
-        Starts a QEMU VM instance.
-
-        Mandatory request parameters:
-        - id (QEMU VM instance identifier)
-
-        Response parameters:
-        - True on success
-
-        :param request: JSON request
-        """
-
-        # validate the request
-        if not self.validate_request(request, QEMU_START_SCHEMA):
-            return
-
-        # get the instance
-        qemu_instance = self.get_qemu_instance(request["id"])
-        if not qemu_instance:
-            return
-
-        try:
-            qemu_instance.start()
-        except QemuError as e:
-            self.send_custom_error(str(e))
-            return
-        self.send_response(True)
-
-    @IModule.route("qemu.stop")
-    def qemu_stop(self, request):
-        """
-        Stops a QEMU VM instance.
-
-        Mandatory request parameters:
-        - id (QEMU VM instance identifier)
-
-        Response parameters:
-        - True on success
-
-        :param request: JSON request
-        """
-
-        # validate the request
-        if not self.validate_request(request, QEMU_STOP_SCHEMA):
-            return
-
-        # get the instance
-        qemu_instance = self.get_qemu_instance(request["id"])
-        if not qemu_instance:
-            return
-
-        try:
-            qemu_instance.stop()
-        except QemuError as e:
-            self.send_custom_error(str(e))
-            return
-        self.send_response(True)
-
-    @IModule.route("qemu.reload")
-    def qemu_reload(self, request):
-        """
-        Reloads a QEMU VM instance.
-
-        Mandatory request parameters:
-        - id (QEMU VM identifier)
-
-        Response parameters:
-        - True on success
-
-        :param request: JSON request
-        """
-
-        # validate the request
-        if not self.validate_request(request, QEMU_RELOAD_SCHEMA):
-            return
-
-        # get the instance
-        qemu_instance = self.get_qemu_instance(request["id"])
-        if not qemu_instance:
-            return
-
-        try:
-            qemu_instance.reload()
-        except QemuError as e:
-            self.send_custom_error(str(e))
-            return
-        self.send_response(True)
-
-    @IModule.route("qemu.stop")
-    def qemu_stop(self, request):
-        """
-        Stops a QEMU VM instance.
-
-        Mandatory request parameters:
-        - id (QEMU VM instance identifier)
-
-        Response parameters:
-        - True on success
-
-        :param request: JSON request
-        """
-
-        # validate the request
-        if not self.validate_request(request, QEMU_STOP_SCHEMA):
-            return
-
-        # get the instance
-        qemu_instance = self.get_qemu_instance(request["id"])
-        if not qemu_instance:
-            return
-
-        try:
-            qemu_instance.stop()
-        except QemuError as e:
-            self.send_custom_error(str(e))
-            return
-        self.send_response(True)
-
-    @IModule.route("qemu.suspend")
-    def qemu_suspend(self, request):
-        """
-        Suspends a QEMU VM instance.
-
-        Mandatory request parameters:
-        - id (QEMU VM instance identifier)
-
-        Response parameters:
-        - True on success
-
-        :param request: JSON request
-        """
-
-        # validate the request
-        if not self.validate_request(request, QEMU_SUSPEND_SCHEMA):
-            return
-
-        # get the instance
-        qemu_instance = self.get_qemu_instance(request["id"])
-        if not qemu_instance:
-            return
-
-        try:
-            qemu_instance.suspend()
-        except QemuError as e:
-            self.send_custom_error(str(e))
-            return
-        self.send_response(True)
-
-    @IModule.route("qemu.allocate_udp_port")
-    def allocate_udp_port(self, request):
-        """
-        Allocates a UDP port in order to create an UDP NIO.
-
-        Mandatory request parameters:
-        - id (QEMU VM identifier)
-        - port_id (unique port identifier)
-
-        Response parameters:
-        - port_id (unique port identifier)
-        - lport (allocated local port)
-
-        :param request: JSON request
-        """
-
-        # validate the request
-        if not self.validate_request(request, QEMU_ALLOCATE_UDP_PORT_SCHEMA):
-            return
-
-        # get the instance
-        qemu_instance = self.get_qemu_instance(request["id"])
-        if not qemu_instance:
-            return
-
-        try:
-            port = find_unused_port(self._udp_start_port_range,
-                                    self._udp_end_port_range,
-                                    host=self._host,
-                                    socket_type="UDP",
-                                    ignore_ports=self._allocated_udp_ports)
-        except Exception as e:
-            self.send_custom_error(str(e))
-            return
-
-        self._allocated_udp_ports.append(port)
-        log.info("{} [id={}] has allocated UDP port {} with host {}".format(qemu_instance.name,
-                                                                            qemu_instance.id,
-                                                                            port,
-                                                                            self._host))
-
-        response = {"lport": port,
-                    "port_id": request["port_id"]}
-        self.send_response(response)
-
-    @IModule.route("qemu.add_nio")
-    def add_nio(self, request):
-        """
-        Adds an NIO (Network Input/Output) for a QEMU VM instance.
-
-        Mandatory request parameters:
-        - id (QEMU VM instance identifier)
-        - port (port number)
-        - port_id (unique port identifier)
-        - nio (one of the following)
-            - type "nio_udp"
-                - lport (local port)
-                - rhost (remote host)
-                - rport (remote port)
-
-        Response parameters:
-        - port_id (unique port identifier)
-
-        :param request: JSON request
-        """
-
-        # validate the request
-        if not self.validate_request(request, QEMU_ADD_NIO_SCHEMA):
-            return
-
-        # get the instance
-        qemu_instance = self.get_qemu_instance(request["id"])
-        if not qemu_instance:
-            return
-
-        port = request["port"]
-        try:
-            nio = None
-            if request["nio"]["type"] == "nio_udp":
-                lport = request["nio"]["lport"]
-                rhost = request["nio"]["rhost"]
-                rport = request["nio"]["rport"]
-                try:
-                    # TODO: handle IPv6
-                    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
-                        sock.connect((rhost, rport))
-                except OSError as e:
-                    raise QemuError("Could not create an UDP connection to {}:{}: {}".format(rhost, rport, e))
-                nio = NIO_UDP(lport, rhost, rport)
-            if not nio:
-                raise QemuError("Requested NIO does not exist or is not supported: {}".format(request["nio"]["type"]))
-        except QemuError as e:
-            self.send_custom_error(str(e))
-            return
-
-        try:
-            qemu_instance.port_add_nio_binding(port, nio)
-        except QemuError as e:
-            self.send_custom_error(str(e))
-            return
-
-        self.send_response({"port_id": request["port_id"]})
-
-    @IModule.route("qemu.delete_nio")
-    def delete_nio(self, request):
-        """
-        Deletes an NIO (Network Input/Output).
-
-        Mandatory request parameters:
-        - id (QEMU VM instance identifier)
-        - port (port identifier)
-
-        Response parameters:
-        - True on success
-
-        :param request: JSON request
-        """
-
-        # validate the request
-        if not self.validate_request(request, QEMU_DELETE_NIO_SCHEMA):
-            return
-
-        # get the instance
-        qemu_instance = self.get_qemu_instance(request["id"])
-        if not qemu_instance:
-            return
-
-        port = request["port"]
-        try:
-            nio = qemu_instance.port_remove_nio_binding(port)
-            if isinstance(nio, NIO_UDP) and nio.lport in self._allocated_udp_ports:
-                self._allocated_udp_ports.remove(nio.lport)
-        except QemuError as e:
-            self.send_custom_error(str(e))
-            return
-
-        self.send_response(True)
-
-    def _get_qemu_version(self, qemu_path):
-        """
-        Gets the Qemu version.
-
-        :param qemu_path: path to Qemu
-        """
-
-        if sys.platform.startswith("win"):
-            return ""
-        try:
-            output = subprocess.check_output([qemu_path, "-version"])
-            match = re.search("version\s+([0-9a-z\-\.]+)", output.decode("utf-8"))
-            if match:
-                version = match.group(1)
-                return version
-            else:
-                raise QemuError("Could not determine the Qemu version for {}".format(qemu_path))
-        except subprocess.SubprocessError as e:
-            raise QemuError("Error while looking for the Qemu version: {}".format(e))
-
-    @IModule.route("qemu.qemu_list")
-    def qemu_list(self, request):
-        """
-        Gets QEMU binaries list.
-
-        Response parameters:
-        - List of Qemu binaries
-        """
-
-        qemus = []
-        paths = [os.getcwd()] + os.environ["PATH"].split(os.pathsep)
-        # look for Qemu binaries in the current working directory and $PATH
-        if sys.platform.startswith("win"):
-            # add specific Windows paths
-            if hasattr(sys, "frozen"):
-                # add any qemu dir in the same location as gns3server.exe to the list of paths
-                exec_dir = os.path.dirname(os.path.abspath(sys.executable))
-                for f in os.listdir(exec_dir):
-                    if f.lower().startswith("qemu"):
-                        paths.append(os.path.join(exec_dir, f))
-
-            if "PROGRAMFILES(X86)" in os.environ and os.path.exists(os.environ["PROGRAMFILES(X86)"]):
-                paths.append(os.path.join(os.environ["PROGRAMFILES(X86)"], "qemu"))
-            if "PROGRAMFILES" in os.environ and os.path.exists(os.environ["PROGRAMFILES"]):
-                paths.append(os.path.join(os.environ["PROGRAMFILES"], "qemu"))
-        elif sys.platform.startswith("darwin"):
-            # add specific locations on Mac OS X regardless of what's in $PATH
-            paths.extend(["/usr/local/bin", "/opt/local/bin"])
-            if hasattr(sys, "frozen"):
-                paths.append(os.path.abspath(os.path.join(os.getcwd(), "../../../qemu/bin/")))
-        for path in paths:
-            try:
-                for f in os.listdir(path):
-                    if (f.startswith("qemu-system") or f == "qemu" or f == "qemu.exe") and \
-                            os.access(os.path.join(path, f), os.X_OK) and \
-                            os.path.isfile(os.path.join(path, f)):
-                        qemu_path = os.path.join(path, f)
-                        version = self._get_qemu_version(qemu_path)
-                        qemus.append({"path": qemu_path, "version": version})
-            except OSError:
-                continue
-
-        response = {"qemus": qemus}
-        self.send_response(response)
-
-    @IModule.route("qemu.echo")
-    def echo(self, request):
-        """
-        Echo end point for testing purposes.
-
-        :param request: JSON request
-        """
-
-        if request is None:
-            self.send_param_error()
-        else:
-            log.debug("received request {}".format(request))
-            self.send_response(request)

gns3server/old_modules/qemu/adapters/adapter.py

@@ -1,105 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2014 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/>.
-
-
-class Adapter(object):
-
-    """
-    Base class for adapters.
-
-    :param interfaces: number of interfaces supported by this adapter.
-    """
-
-    def __init__(self, interfaces=1):
-
-        self._interfaces = interfaces
-
-        self._ports = {}
-        for port_id in range(0, interfaces):
-            self._ports[port_id] = None
-
-    def removable(self):
-        """
-        Returns True if the adapter can be removed from a slot
-        and False if not.
-
-        :returns: boolean
-        """
-
-        return True
-
-    def port_exists(self, port_id):
-        """
-        Checks if a port exists on this adapter.
-
-        :returns: True is the port exists,
-        False otherwise.
-        """
-
-        if port_id in self._ports:
-            return True
-        return False
-
-    def add_nio(self, port_id, nio):
-        """
-        Adds a NIO to a port on this adapter.
-
-        :param port_id: port ID (integer)
-        :param nio: NIO instance
-        """
-
-        self._ports[port_id] = nio
-
-    def remove_nio(self, port_id):
-        """
-        Removes a NIO from a port on this adapter.
-
-        :param port_id: port ID (integer)
-        """
-
-        self._ports[port_id] = None
-
-    def get_nio(self, port_id):
-        """
-        Returns the NIO assigned to a port.
-
-        :params port_id: port ID (integer)
-
-        :returns: NIO instance
-        """
-
-        return self._ports[port_id]
-
-    @property
-    def ports(self):
-        """
-        Returns port to NIO mapping
-
-        :returns: dictionary port -> NIO
-        """
-
-        return self._ports
-
-    @property
-    def interfaces(self):
-        """
-        Returns the number of interfaces supported by this adapter.
-
-        :returns: number of interfaces
-        """
-
-        return self._interfaces

gns3server/old_modules/qemu/adapters/ethernet_adapter.py

@@ -1,32 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2014 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 .adapter import Adapter
-
-
-class EthernetAdapter(Adapter):
-
-    """
-    QEMU Ethernet adapter.
-    """
-
-    def __init__(self):
-        Adapter.__init__(self, interfaces=1)
-
-    def __str__(self):
-
-        return "QEMU Ethernet adapter"

gns3server/old_modules/qemu/nios/nio.py

@@ -1,66 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2013 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/>.
-
-"""
-Base interface for NIOs.
-"""
-
-
-class NIO(object):
-
-    """
-    Network Input/Output.
-    """
-
-    def __init__(self):
-
-        self._capturing = False
-        self._pcap_output_file = ""
-
-    def startPacketCapture(self, pcap_output_file):
-        """
-
-        :param pcap_output_file: PCAP destination file for the capture
-        """
-
-        self._capturing = True
-        self._pcap_output_file = pcap_output_file
-
-    def stopPacketCapture(self):
-
-        self._capturing = False
-        self._pcap_output_file = ""
-
-    @property
-    def capturing(self):
-        """
-        Returns either a capture is configured on this NIO.
-
-        :returns: boolean
-        """
-
-        return self._capturing
-
-    @property
-    def pcap_output_file(self):
-        """
-        Returns the path to the PCAP output file.
-
-        :returns: path to the PCAP output file
-        """
-
-        return self._pcap_output_file

gns3server/old_modules/qemu/nios/nio_udp.py

@@ -1,76 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2013 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/>.
-
-"""
-Interface for UDP NIOs.
-"""
-
-from .nio import NIO
-
-
-class NIO_UDP(NIO):
-
-    """
-    UDP NIO.
-
-    :param lport: local port number
-    :param rhost: remote address/host
-    :param rport: remote port number
-    """
-
-    _instance_count = 0
-
-    def __init__(self, lport, rhost, rport):
-
-        NIO.__init__(self)
-        self._lport = lport
-        self._rhost = rhost
-        self._rport = rport
-
-    @property
-    def lport(self):
-        """
-        Returns the local port
-
-        :returns: local port number
-        """
-
-        return self._lport
-
-    @property
-    def rhost(self):
-        """
-        Returns the remote host
-
-        :returns: remote address/host
-        """
-
-        return self._rhost
-
-    @property
-    def rport(self):
-        """
-        Returns the remote port
-
-        :returns: remote port number
-        """
-
-        return self._rport
-
-    def __str__(self):
-
-        return "NIO UDP"

gns3server/old_modules/qemu/qemu_error.py

@@ -1,39 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2014 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/>.
-
-"""
-Custom exceptions for QEMU module.
-"""
-
-
-class QemuError(Exception):
-
-    def __init__(self, message, original_exception=None):
-
-        Exception.__init__(self, message)
-        if isinstance(message, Exception):
-            message = str(message)
-        self._message = message
-        self._original_exception = original_exception
-
-    def __repr__(self):
-
-        return self._message
-
-    def __str__(self):
-
-        return self._message

gns3server/old_modules/qemu/schemas.py

@@ -1,423 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2014 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/>.
-
-
-QEMU_CREATE_SCHEMA = {
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "description": "Request validation to create a new QEMU VM instance",
-    "type": "object",
-    "properties": {
-        "name": {
-            "description": "QEMU VM instance name",
-            "type": "string",
-            "minLength": 1,
-        },
-        "qemu_path": {
-            "description": "Path to QEMU",
-            "type": "string",
-            "minLength": 1,
-        },
-        "qemu_id": {
-            "description": "QEMU VM instance ID",
-            "type": "integer"
-        },
-        "console": {
-            "description": "console TCP port",
-            "minimum": 1,
-            "maximum": 65535,
-            "type": "integer"
-        },
-        "monitor": {
-            "description": "monitor TCP port",
-            "minimum": 1,
-            "maximum": 65535,
-            "type": "integer"
-        },
-    },
-    "additionalProperties": False,
-    "required": ["name", "qemu_path"],
-}
-
-QEMU_DELETE_SCHEMA = {
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "description": "Request validation to delete a QEMU VM instance",
-    "type": "object",
-    "properties": {
-        "id": {
-            "description": "QEMU VM instance ID",
-            "type": "integer"
-        },
-    },
-    "additionalProperties": False,
-    "required": ["id"]
-}
-
-QEMU_UPDATE_SCHEMA = {
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "description": "Request validation to update a QEMU VM instance",
-    "type": "object",
-    "properties": {
-        "id": {
-            "description": "QEMU VM instance ID",
-            "type": "integer"
-        },
-        "name": {
-            "description": "QEMU VM instance name",
-            "type": "string",
-            "minLength": 1,
-        },
-        "qemu_path": {
-            "description": "path to QEMU",
-            "type": "string",
-            "minLength": 1,
-        },
-        "hda_disk_image": {
-            "description": "QEMU hda disk image path",
-            "type": "string",
-        },
-        "hdb_disk_image": {
-            "description": "QEMU hdb disk image path",
-            "type": "string",
-        },
-        "ram": {
-            "description": "amount of RAM in MB",
-            "type": "integer"
-        },
-        "adapters": {
-            "description": "number of adapters",
-            "type": "integer",
-            "minimum": 0,
-            "maximum": 32,
-        },
-        "adapter_type": {
-            "description": "QEMU adapter type",
-            "type": "string",
-            "minLength": 1,
-        },
-        "console": {
-            "description": "console TCP port",
-            "minimum": 1,
-            "maximum": 65535,
-            "type": "integer"
-        },
-        "monitor": {
-            "description": "monitor TCP port",
-            "minimum": 1,
-            "maximum": 65535,
-            "type": "integer"
-        },
-        "initrd": {
-            "description": "QEMU initrd path",
-            "type": "string",
-        },
-        "kernel_image": {
-            "description": "QEMU kernel image path",
-            "type": "string",
-        },
-        "kernel_command_line": {
-            "description": "QEMU kernel command line",
-            "type": "string",
-        },
-        "cloud_path": {
-            "description": "Path to the image in the cloud object store",
-            "type": "string",
-        },
-        "legacy_networking": {
-            "description": "Use QEMU legagy networking commands (-net syntax)",
-            "type": "boolean",
-        },
-        "cpu_throttling": {
-            "description": "Percentage of CPU allowed for QEMU",
-            "minimum": 0,
-            "maximum": 800,
-            "type": "integer",
-        },
-        "process_priority": {
-            "description": "Process priority for QEMU",
-            "enum": ["realtime",
-                     "very high",
-                     "high",
-                     "normal",
-                     "low",
-                     "very low"]
-        },
-        "options": {
-            "description": "Additional QEMU options",
-            "type": "string",
-        },
-    },
-    "additionalProperties": False,
-    "required": ["id"]
-}
-
-QEMU_START_SCHEMA = {
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "description": "Request validation to start a QEMU VM instance",
-    "type": "object",
-    "properties": {
-        "id": {
-            "description": "QEMU VM instance ID",
-            "type": "integer"
-        },
-    },
-    "additionalProperties": False,
-    "required": ["id"]
-}
-
-QEMU_STOP_SCHEMA = {
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "description": "Request validation to stop a QEMU VM instance",
-    "type": "object",
-    "properties": {
-        "id": {
-            "description": "QEMU VM instance ID",
-            "type": "integer"
-        },
-    },
-    "additionalProperties": False,
-    "required": ["id"]
-}
-
-QEMU_SUSPEND_SCHEMA = {
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "description": "Request validation to suspend a QEMU VM instance",
-    "type": "object",
-    "properties": {
-        "id": {
-            "description": "QEMU VM instance ID",
-            "type": "integer"
-        },
-    },
-    "additionalProperties": False,
-    "required": ["id"]
-}
-
-QEMU_RELOAD_SCHEMA = {
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "description": "Request validation to reload a QEMU VM instance",
-    "type": "object",
-    "properties": {
-        "id": {
-            "description": "QEMU VM instance ID",
-            "type": "integer"
-        },
-    },
-    "additionalProperties": False,
-    "required": ["id"]
-}
-
-QEMU_ALLOCATE_UDP_PORT_SCHEMA = {
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "description": "Request validation to allocate an UDP port for a QEMU VM instance",
-    "type": "object",
-    "properties": {
-        "id": {
-            "description": "QEMU VM instance ID",
-            "type": "integer"
-        },
-        "port_id": {
-            "description": "Unique port identifier for the QEMU VM instance",
-            "type": "integer"
-        },
-    },
-    "additionalProperties": False,
-    "required": ["id", "port_id"]
-}
-
-QEMU_ADD_NIO_SCHEMA = {
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "description": "Request validation to add a NIO for a QEMU VM instance",
-    "type": "object",
-
-    "definitions": {
-        "UDP": {
-            "description": "UDP Network Input/Output",
-            "properties": {
-                "type": {
-                    "enum": ["nio_udp"]
-                },
-                "lport": {
-                    "description": "Local port",
-                    "type": "integer",
-                    "minimum": 1,
-                    "maximum": 65535
-                },
-                "rhost": {
-                    "description": "Remote host",
-                    "type": "string",
-                    "minLength": 1
-                },
-                "rport": {
-                    "description": "Remote port",
-                    "type": "integer",
-                    "minimum": 1,
-                    "maximum": 65535
-                }
-            },
-            "required": ["type", "lport", "rhost", "rport"],
-            "additionalProperties": False
-        },
-        "Ethernet": {
-            "description": "Generic Ethernet Network Input/Output",
-            "properties": {
-                "type": {
-                    "enum": ["nio_generic_ethernet"]
-                },
-                "ethernet_device": {
-                    "description": "Ethernet device name e.g. eth0",
-                    "type": "string",
-                    "minLength": 1
-                },
-            },
-            "required": ["type", "ethernet_device"],
-            "additionalProperties": False
-        },
-        "LinuxEthernet": {
-            "description": "Linux Ethernet Network Input/Output",
-            "properties": {
-                "type": {
-                    "enum": ["nio_linux_ethernet"]
-                },
-                "ethernet_device": {
-                    "description": "Ethernet device name e.g. eth0",
-                    "type": "string",
-                    "minLength": 1
-                },
-            },
-            "required": ["type", "ethernet_device"],
-            "additionalProperties": False
-        },
-        "TAP": {
-            "description": "TAP Network Input/Output",
-            "properties": {
-                "type": {
-                    "enum": ["nio_tap"]
-                },
-                "tap_device": {
-                    "description": "TAP device name e.g. tap0",
-                    "type": "string",
-                    "minLength": 1
-                },
-            },
-            "required": ["type", "tap_device"],
-            "additionalProperties": False
-        },
-        "UNIX": {
-            "description": "UNIX Network Input/Output",
-            "properties": {
-                "type": {
-                    "enum": ["nio_unix"]
-                },
-                "local_file": {
-                    "description": "path to the UNIX socket file (local)",
-                    "type": "string",
-                    "minLength": 1
-                },
-                "remote_file": {
-                    "description": "path to the UNIX socket file (remote)",
-                    "type": "string",
-                    "minLength": 1
-                },
-            },
-            "required": ["type", "local_file", "remote_file"],
-            "additionalProperties": False
-        },
-        "VDE": {
-            "description": "VDE Network Input/Output",
-            "properties": {
-                "type": {
-                    "enum": ["nio_vde"]
-                },
-                "control_file": {
-                    "description": "path to the VDE control file",
-                    "type": "string",
-                    "minLength": 1
-                },
-                "local_file": {
-                    "description": "path to the VDE control file",
-                    "type": "string",
-                    "minLength": 1
-                },
-            },
-            "required": ["type", "control_file", "local_file"],
-            "additionalProperties": False
-        },
-        "NULL": {
-            "description": "NULL Network Input/Output",
-            "properties": {
-                "type": {
-                    "enum": ["nio_null"]
-                },
-            },
-            "required": ["type"],
-            "additionalProperties": False
-        },
-    },
-
-    "properties": {
-        "id": {
-            "description": "QEMU VM instance ID",
-            "type": "integer"
-        },
-        "port_id": {
-            "description": "Unique port identifier for the QEMU VM instance",
-            "type": "integer"
-        },
-        "port": {
-            "description": "Port number",
-            "type": "integer",
-            "minimum": 0,
-            "maximum": 32
-        },
-        "nio": {
-            "type": "object",
-            "description": "Network Input/Output",
-            "oneOf": [
-                {"$ref": "#/definitions/UDP"},
-                {"$ref": "#/definitions/Ethernet"},
-                {"$ref": "#/definitions/LinuxEthernet"},
-                {"$ref": "#/definitions/TAP"},
-                {"$ref": "#/definitions/UNIX"},
-                {"$ref": "#/definitions/VDE"},
-                {"$ref": "#/definitions/NULL"},
-            ]
-        },
-    },
-    "additionalProperties": False,
-    "required": ["id", "port_id", "port", "nio"]
-}
-
-
-QEMU_DELETE_NIO_SCHEMA = {
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "description": "Request validation to delete a NIO for a QEMU VM instance",
-    "type": "object",
-    "properties": {
-        "id": {
-            "description": "QEMU VM instance ID",
-            "type": "integer"
-        },
-        "port": {
-            "description": "Port number",
-            "type": "integer",
-            "minimum": 0,
-            "maximum": 32
-        },
-    },
-    "additionalProperties": False,
-    "required": ["id", "port"]
-}

gns3server/schemas/iou.py

@@ -0,0 +1,247 @@
+# -*- 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/>.
+
+
+IOU_CREATE_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to create a new IOU instance",
+    "type": "object",
+    "properties": {
+        "name": {
+            "description": "IOU VM name",
+            "type": "string",
+            "minLength": 1,
+        },
+        "vm_id": {
+            "description": "IOU VM identifier",
+            "oneOf": [
+                {"type": "string",
+                 "minLength": 36,
+                 "maxLength": 36,
+                 "pattern": "^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$"},
+                {"type": "integer"}  # for legacy projects
+            ]
+        },
+        "console": {
+            "description": "console TCP port",
+            "minimum": 1,
+            "maximum": 65535,
+            "type": ["integer", "null"]
+        },
+        "path": {
+            "description": "Path of iou binary",
+            "type": "string"
+        },
+        "iourc_path": {
+            "description": "Path of iourc",
+            "type": "string"
+        },
+        "serial_adapters": {
+            "description": "How many serial adapters are connected to the IOU",
+            "type": "integer"
+        },
+        "ethernet_adapters": {
+            "description": "How many ethernet adapters are connected to the IOU",
+            "type": "integer"
+        },
+        "ram": {
+            "description": "Allocated RAM MB",
+            "type": ["integer", "null"]
+        },
+        "nvram": {
+            "description": "Allocated NVRAM KB",
+            "type": ["integer", "null"]
+        }
+    },
+    "additionalProperties": False,
+    "required": ["name", "path"]
+}
+
+IOU_UPDATE_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to update a IOU instance",
+    "type": "object",
+    "properties": {
+        "name": {
+            "description": "IOU VM name",
+            "type": ["string", "null"],
+            "minLength": 1,
+        },
+        "console": {
+            "description": "console TCP port",
+            "minimum": 1,
+            "maximum": 65535,
+            "type": ["integer", "null"]
+        },
+        "path": {
+            "description": "Path of iou binary",
+            "type": ["string", "null"]
+        },
+        "iourc_path": {
+            "description": "Path of iourc",
+            "type": ["string", "null"]
+        },
+        "initial_config": {
+            "description": "Initial configuration path",
+            "type": ["string", "null"]
+        },
+        "serial_adapters": {
+            "description": "How many serial adapters are connected to the IOU",
+            "type": ["integer", "null"]
+        },
+        "ethernet_adapters": {
+            "description": "How many ethernet adapters are connected to the IOU",
+            "type": ["integer", "null"]
+        },
+        "ram": {
+            "description": "Allocated RAM MB",
+            "type": ["integer", "null"]
+        },
+        "nvram": {
+            "description": "Allocated NVRAM KB",
+            "type": ["integer", "null"]
+        }
+    },
+    "additionalProperties": False,
+}
+
+IOU_OBJECT_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "IOU instance",
+    "type": "object",
+    "properties": {
+        "name": {
+            "description": "IOU VM name",
+            "type": "string",
+            "minLength": 1,
+        },
+        "vm_id": {
+            "description": "IOU VM UUID",
+            "type": "string",
+            "minLength": 36,
+            "maxLength": 36,
+            "pattern": "^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$"
+        },
+        "console": {
+            "description": "console TCP port",
+            "minimum": 1,
+            "maximum": 65535,
+            "type": "integer"
+        },
+        "project_id": {
+            "description": "Project UUID",
+            "type": "string",
+            "minLength": 36,
+            "maxLength": 36,
+            "pattern": "^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$"
+        },
+        "path": {
+            "description": "Path of iou binary",
+            "type": "string"
+        },
+        "serial_adapters": {
+            "description": "How many serial adapters are connected to the IOU",
+            "type": "integer"
+        },
+        "ethernet_adapters": {
+            "description": "How many ethernet adapters are connected to the IOU",
+            "type": "integer"
+        },
+        "ram": {
+            "description": "Allocated RAM MB",
+            "type": "integer"
+        },
+        "nvram": {
+            "description": "Allocated NVRAM KB",
+            "type": "integer"
+        }
+    },
+    "additionalProperties": False,
+    "required": ["name", "vm_id", "console", "project_id", "path", "serial_adapters", "ethernet_adapters", "ram", "nvram"]
+}
+
+IOU_NIO_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to add a NIO for a VPCS instance",
+    "type": "object",
+    "definitions": {
+        "UDP": {
+            "description": "UDP Network Input/Output",
+            "properties": {
+                "type": {
+                    "enum": ["nio_udp"]
+                },
+                "lport": {
+                    "description": "Local port",
+                    "type": "integer",
+                    "minimum": 1,
+                    "maximum": 65535
+                },
+                "rhost": {
+                    "description": "Remote host",
+                    "type": "string",
+                    "minLength": 1
+                },
+                "rport": {
+                    "description": "Remote port",
+                    "type": "integer",
+                    "minimum": 1,
+                    "maximum": 65535
+                }
+            },
+            "required": ["type", "lport", "rhost", "rport"],
+            "additionalProperties": False
+        },
+        "Ethernet": {
+            "description": "Generic Ethernet Network Input/Output",
+            "properties": {
+                "type": {
+                    "enum": ["nio_generic_ethernet"]
+                },
+                "ethernet_device": {
+                    "description": "Ethernet device name e.g. eth0",
+                    "type": "string",
+                    "minLength": 1
+                },
+            },
+            "required": ["type", "ethernet_device"],
+            "additionalProperties": False
+        },
+        "TAP": {
+            "description": "TAP Network Input/Output",
+            "properties": {
+                "type": {
+                    "enum": ["nio_tap"]
+                },
+                "tap_device": {
+                    "description": "TAP device name e.g. tap0",
+                    "type": "string",
+                    "minLength": 1
+                },
+            },
+            "required": ["type", "tap_device"],
+            "additionalProperties": False
+        },
+    },
+    "oneOf": [
+        {"$ref": "#/definitions/UDP"},
+        {"$ref": "#/definitions/Ethernet"},
+        {"$ref": "#/definitions/TAP"},
+    ],
+    "additionalProperties": True,
+    "required": ["type"]
+}

gns3server/server.py

@@ -173,7 +173,7 @@ class Server:
         self._loop.run_until_complete(self._run_application(app, ssl_context))
         self._signal_handling()
 
-        if server_config.getboolean("debug"):
+        if server_config.getboolean("live"):
             log.info("Code live reload is enabled, watching for file changes")
             self._loop.call_later(1, self._reload_hook)
         self._loop.run_forever()

gns3server/web/response.py

@@ -62,8 +62,6 @@ class Response(aiohttp.web.Response):
             try:
                 jsonschema.validate(answer, self._output_schema)
             except jsonschema.ValidationError as e:
-                log.error("Invalid output schema {} '{}' in schema: {}".format(e.validator,
+                log.error("Invalid output query. JSON schema error: {}".format(e.message))
-                                                                               e.validator_value,
-                                                                               json.dumps(e.schema)))
                 raise aiohttp.web.HTTPBadRequest(text="{}".format(e))
         self.body = json.dumps(answer, indent=4, sort_keys=True).encode('utf-8')

gns3server/web/route.py

@@ -42,12 +42,9 @@ def parse_request(request, input_schema):
     try:
         jsonschema.validate(request.json, input_schema)
     except jsonschema.ValidationError as e:
-        log.error("Invalid input schema {} '{}' in schema: {}".format(e.validator,
+        log.error("Invalid input query. JSON schema error: {}".format(e.message))
-                                                                      e.validator_value,
+        raise aiohttp.web.HTTPBadRequest(text="Invalid JSON: {} in schema: {}".format(
-                                                                      json.dumps(e.schema)))
+            e.message,
-        raise aiohttp.web.HTTPBadRequest(text="Request is not {} '{}' in schema: {}".format(
-            e.validator,
-            e.validator_value,
             json.dumps(e.schema)))
     return request
 

tests/api/test_iou.py

@@ -0,0 +1,165 @@
+# -*- 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 pytest
+import os
+import stat
+from tests.utils import asyncio_patch
+from unittest.mock import patch
+
+
+@pytest.fixture
+def fake_iou_bin(tmpdir):
+    """Create a fake IOU image on disk"""
+
+    path = str(tmpdir / "iou.bin")
+    with open(path, "w+") as f:
+        f.write('\x7fELF\x01\x01\x01')
+    os.chmod(path, stat.S_IREAD | stat.S_IEXEC)
+    return path
+
+
+@pytest.fixture
+def base_params(tmpdir, fake_iou_bin):
+    """Return standard parameters"""
+    return {"name": "PC TEST 1", "path": fake_iou_bin, "iourc_path": str(tmpdir / "iourc")}
+
+
+@pytest.fixture
+def vm(server, project, base_params):
+    response = server.post("/projects/{project_id}/iou/vms".format(project_id=project.id), base_params)
+    assert response.status == 201
+    return response.json
+
+
+def test_iou_create(server, project, base_params):
+    response = server.post("/projects/{project_id}/iou/vms".format(project_id=project.id), base_params)
+    assert response.status == 201
+    assert response.route == "/projects/{project_id}/iou/vms"
+    assert response.json["name"] == "PC TEST 1"
+    assert response.json["project_id"] == project.id
+    assert response.json["serial_adapters"] == 2
+    assert response.json["ethernet_adapters"] == 2
+    assert response.json["ram"] == 256
+    assert response.json["nvram"] == 128
+
+
+def test_iou_create_with_params(server, project, base_params):
+    params = base_params
+    params["ram"] = 1024
+    params["nvram"] = 512
+    params["serial_adapters"] = 4
+    params["ethernet_adapters"] = 0
+
+    response = server.post("/projects/{project_id}/iou/vms".format(project_id=project.id), params, example=True)
+    assert response.status == 201
+    assert response.route == "/projects/{project_id}/iou/vms"
+    assert response.json["name"] == "PC TEST 1"
+    assert response.json["project_id"] == project.id
+    assert response.json["serial_adapters"] == 4
+    assert response.json["ethernet_adapters"] == 0
+    assert response.json["ram"] == 1024
+    assert response.json["nvram"] == 512
+
+
+def test_iou_get(server, project, vm):
+    response = server.get("/projects/{project_id}/iou/vms/{vm_id}".format(project_id=vm["project_id"], vm_id=vm["vm_id"]), example=True)
+    assert response.status == 200
+    assert response.route == "/projects/{project_id}/iou/vms/{vm_id}"
+    assert response.json["name"] == "PC TEST 1"
+    assert response.json["project_id"] == project.id
+    assert response.json["serial_adapters"] == 2
+    assert response.json["ethernet_adapters"] == 2
+    assert response.json["ram"] == 256
+    assert response.json["nvram"] == 128
+
+
+def test_iou_start(server, vm):
+    with asyncio_patch("gns3server.modules.iou.iou_vm.IOUVM.start", return_value=True) as mock:
+        response = server.post("/projects/{project_id}/iou/vms/{vm_id}/start".format(project_id=vm["project_id"], vm_id=vm["vm_id"]))
+        assert mock.called
+        assert response.status == 204
+
+
+def test_iou_stop(server, vm):
+    with asyncio_patch("gns3server.modules.iou.iou_vm.IOUVM.stop", return_value=True) as mock:
+        response = server.post("/projects/{project_id}/iou/vms/{vm_id}/stop".format(project_id=vm["project_id"], vm_id=vm["vm_id"]))
+        assert mock.called
+        assert response.status == 204
+
+
+def test_iou_reload(server, vm):
+    with asyncio_patch("gns3server.modules.iou.iou_vm.IOUVM.reload", return_value=True) as mock:
+        response = server.post("/projects/{project_id}/iou/vms/{vm_id}/reload".format(project_id=vm["project_id"], vm_id=vm["vm_id"]))
+        assert mock.called
+        assert response.status == 204
+
+
+def test_iou_delete(server, vm):
+    with asyncio_patch("gns3server.modules.iou.IOU.delete_vm", return_value=True) as mock:
+        response = server.delete("/projects/{project_id}/iou/vms/{vm_id}".format(project_id=vm["project_id"], vm_id=vm["vm_id"]))
+        assert mock.called
+        assert response.status == 204
+
+
+def test_iou_update(server, vm, tmpdir, free_console_port):
+    params = {
+        "name": "test",
+        "console": free_console_port,
+        "ram": 512,
+        "nvram": 2048,
+        "ethernet_adapters": 4,
+        "serial_adapters": 0
+    }
+    response = server.put("/projects/{project_id}/iou/vms/{vm_id}".format(project_id=vm["project_id"], vm_id=vm["vm_id"]), params)
+    assert response.status == 200
+    assert response.json["name"] == "test"
+    assert response.json["console"] == free_console_port
+    assert response.json["ethernet_adapters"] == 4
+    assert response.json["serial_adapters"] == 0
+    assert response.json["ram"] == 512
+    assert response.json["nvram"] == 2048
+
+
+def test_iou_nio_create_udp(server, vm):
+    response = server.post("/projects/{project_id}/iou/vms/{vm_id}/ports/0/nio".format(project_id=vm["project_id"], vm_id=vm["vm_id"]), {"type": "nio_udp",
+                                                                                                                                         "lport": 4242,
+                                                                                                                                         "rport": 4343,
+                                                                                                                                         "rhost": "127.0.0.1"},
+                           example=True)
+    assert response.status == 201
+    assert response.route == "/projects/{project_id}/iou/vms/{vm_id}/ports/{port_number:\d+}/nio"
+    assert response.json["type"] == "nio_udp"
+
+
+def test_iou_nio_create_tap(server, vm):
+    with patch("gns3server.modules.base_manager.BaseManager._has_privileged_access", return_value=True):
+        response = server.post("/projects/{project_id}/iou/vms/{vm_id}/ports/0/nio".format(project_id=vm["project_id"], vm_id=vm["vm_id"]), {"type": "nio_tap",
+                                                                                                                                             "tap_device": "test"})
+        assert response.status == 201
+        assert response.route == "/projects/{project_id}/iou/vms/{vm_id}/ports/{port_number:\d+}/nio"
+        assert response.json["type"] == "nio_tap"
+
+
+def test_iou_delete_nio(server, vm):
+    server.post("/projects/{project_id}/iou/vms/{vm_id}/ports/0/nio".format(project_id=vm["project_id"], vm_id=vm["vm_id"]), {"type": "nio_udp",
+                                                                                                                              "lport": 4242,
+                                                                                                                              "rport": 4343,
+                                                                                                                              "rhost": "127.0.0.1"})
+    response = server.delete("/projects/{project_id}/iou/vms/{vm_id}/ports/0/nio".format(project_id=vm["project_id"], vm_id=vm["vm_id"]), example=True)
+    assert response.status == 204
+    assert response.route == "/projects/{project_id}/iou/vms/{vm_id}/ports/{port_number:\d+}/nio"

tests/modules/iou/test_iou_manager.py

@@ -0,0 +1,73 @@
+# -*- 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 pytest
+import uuid
+
+
+from gns3server.modules.iou import IOU
+from gns3server.modules.iou.iou_error import IOUError
+from gns3server.modules.project_manager import ProjectManager
+
+
+def test_get_application_id(loop, project, port_manager):
+    # Cleanup the IOU object
+    IOU._instance = None
+    iou = IOU.instance()
+    iou.port_manager = port_manager
+    vm1_id = str(uuid.uuid4())
+    vm2_id = str(uuid.uuid4())
+    vm3_id = str(uuid.uuid4())
+    loop.run_until_complete(iou.create_vm("PC 1", project.id, vm1_id))
+    loop.run_until_complete(iou.create_vm("PC 2", project.id, vm2_id))
+    assert iou.get_application_id(vm1_id) == 1
+    assert iou.get_application_id(vm1_id) == 1
+    assert iou.get_application_id(vm2_id) == 2
+    loop.run_until_complete(iou.delete_vm(vm1_id))
+    loop.run_until_complete(iou.create_vm("PC 3", project.id, vm3_id))
+    assert iou.get_application_id(vm3_id) == 1
+
+
+def test_get_application_id_multiple_project(loop, port_manager):
+    # Cleanup the IOU object
+    IOU._instance = None
+    iou = IOU.instance()
+    iou.port_manager = port_manager
+    vm1_id = str(uuid.uuid4())
+    vm2_id = str(uuid.uuid4())
+    vm3_id = str(uuid.uuid4())
+    project1 = ProjectManager.instance().create_project()
+    project2 = ProjectManager.instance().create_project()
+    loop.run_until_complete(iou.create_vm("PC 1", project1.id, vm1_id))
+    loop.run_until_complete(iou.create_vm("PC 2", project1.id, vm2_id))
+    loop.run_until_complete(iou.create_vm("PC 2", project2.id, vm3_id))
+    assert iou.get_application_id(vm1_id) == 1
+    assert iou.get_application_id(vm2_id) == 2
+    assert iou.get_application_id(vm3_id) == 3
+
+
+def test_get_application_id_no_id_available(loop, project, port_manager):
+    # Cleanup the IOU object
+    IOU._instance = None
+    iou = IOU.instance()
+    iou.port_manager = port_manager
+    with pytest.raises(IOUError):
+        for i in range(1, 513):
+            vm_id = str(uuid.uuid4())
+            loop.run_until_complete(iou.create_vm("PC {}".format(i), project.id, vm_id))
+            assert iou.get_application_id(vm_id) == i

tests/modules/iou/test_iou_vm.py

@@ -0,0 +1,170 @@
+# -*- 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 pytest
+import aiohttp
+import asyncio
+import os
+import stat
+from tests.utils import asyncio_patch
+
+
+from unittest.mock import patch, MagicMock
+from gns3server.modules.iou.iou_vm import IOUVM
+from gns3server.modules.iou.iou_error import IOUError
+from gns3server.modules.iou import IOU
+
+
+@pytest.fixture(scope="module")
+def manager(port_manager):
+    m = IOU.instance()
+    m.port_manager = port_manager
+    return m
+
+
+@pytest.fixture(scope="function")
+def vm(project, manager, tmpdir, fake_iou_bin):
+    fake_file = str(tmpdir / "iourc")
+    with open(fake_file, "w+") as f:
+        f.write("1")
+
+    vm = IOUVM("test", "00010203-0405-0607-0809-0a0b0c0d0e0f", project, manager)
+    config = manager.config.get_section_config("IOU")
+    config["iouyap_path"] = fake_file
+    manager.config.set_section_config("IOU", config)
+
+    vm.path = fake_iou_bin
+    vm.iourc_path = fake_file
+    return vm
+
+
+@pytest.fixture
+def fake_iou_bin(tmpdir):
+    """Create a fake IOU image on disk"""
+
+    path = str(tmpdir / "iou.bin")
+    with open(path, "w+") as f:
+        f.write('\x7fELF\x01\x01\x01')
+    os.chmod(path, stat.S_IREAD | stat.S_IEXEC)
+    return path
+
+
+def test_vm(project, manager):
+    vm = IOUVM("test", "00010203-0405-0607-0809-0a0b0c0d0e0f", project, manager)
+    assert vm.name == "test"
+    assert vm.id == "00010203-0405-0607-0809-0a0b0c0d0e0f"
+
+
+@patch("gns3server.config.Config.get_section_config", return_value={"iouyap_path": "/bin/test_fake"})
+def test_vm_invalid_iouyap_path(project, manager, loop):
+    with pytest.raises(IOUError):
+        vm = IOUVM("test", "00010203-0405-0607-0809-0a0b0c0d0e0e", project, manager)
+        loop.run_until_complete(asyncio.async(vm.start()))
+
+
+def test_start(loop, vm, monkeypatch):
+    with asyncio_patch("gns3server.modules.iou.iou_vm.IOUVM._check_requirements", return_value=True):
+        with asyncio_patch("gns3server.modules.iou.iou_vm.IOUVM._start_ioucon", return_value=True):
+            with asyncio_patch("gns3server.modules.iou.iou_vm.IOUVM._start_iouyap", return_value=True):
+                with asyncio_patch("asyncio.create_subprocess_exec", return_value=MagicMock()):
+                    loop.run_until_complete(asyncio.async(vm.start()))
+                    assert vm.is_running()
+
+
+def test_stop(loop, vm):
+    process = MagicMock()
+
+    # Wait process kill success
+    future = asyncio.Future()
+    future.set_result(True)
+    process.wait.return_value = future
+
+    with asyncio_patch("gns3server.modules.iou.iou_vm.IOUVM._check_requirements", return_value=True):
+        with asyncio_patch("gns3server.modules.iou.iou_vm.IOUVM._start_ioucon", return_value=True):
+            with asyncio_patch("gns3server.modules.iou.iou_vm.IOUVM._start_iouyap", return_value=True):
+                with asyncio_patch("asyncio.create_subprocess_exec", return_value=process):
+                    loop.run_until_complete(asyncio.async(vm.start()))
+                    assert vm.is_running()
+                    loop.run_until_complete(asyncio.async(vm.stop()))
+                    assert vm.is_running() is False
+                    process.terminate.assert_called_with()
+
+
+def test_reload(loop, vm, fake_iou_bin):
+    process = MagicMock()
+
+    # Wait process kill success
+    future = asyncio.Future()
+    future.set_result(True)
+    process.wait.return_value = future
+
+    with asyncio_patch("gns3server.modules.iou.iou_vm.IOUVM._check_requirements", return_value=True):
+        with asyncio_patch("gns3server.modules.iou.iou_vm.IOUVM._start_ioucon", return_value=True):
+            with asyncio_patch("gns3server.modules.iou.iou_vm.IOUVM._start_iouyap", return_value=True):
+                with asyncio_patch("asyncio.create_subprocess_exec", return_value=process):
+                    loop.run_until_complete(asyncio.async(vm.start()))
+                    assert vm.is_running()
+                    loop.run_until_complete(asyncio.async(vm.reload()))
+                    assert vm.is_running() is True
+                    process.terminate.assert_called_with()
+
+
+def test_close(vm, port_manager):
+    with asyncio_patch("gns3server.modules.iou.iou_vm.IOUVM._check_requirements", return_value=True):
+        with asyncio_patch("asyncio.create_subprocess_exec", return_value=MagicMock()):
+            vm.start()
+            port = vm.console
+            vm.close()
+            # Raise an exception if the port is not free
+            port_manager.reserve_console_port(port)
+            assert vm.is_running() is False
+
+
+def test_path(vm, fake_iou_bin):
+
+    vm.path = fake_iou_bin
+    assert vm.path == fake_iou_bin
+
+
+def test_path_invalid_bin(vm, tmpdir):
+
+    path = str(tmpdir / "test.bin")
+    with pytest.raises(IOUError):
+        vm.path = path
+
+    with open(path, "w+") as f:
+        f.write("BUG")
+
+    with pytest.raises(IOUError):
+        vm.path = path
+
+
+def test_create_netmap_config(vm):
+
+    vm._create_netmap_config()
+    netmap_path = os.path.join(vm.working_dir, "NETMAP")
+
+    with open(netmap_path) as f:
+        content = f.read()
+
+    assert "513:0/0    1:0/0" in content
+    assert "513:15/3    1:15/3" in content
+
+
+def test_build_command(vm):
+
+    assert vm._build_command() == [vm.path, '-L', str(vm.application_id)]