Version 1.3.2

Do not erase the IOU initial-config if there is one when creating the IOU VM.

CHANGELOG

@@ -1,5 +1,37 @@
 # Change Log
 
+## 1.3.2 28/04/2015
+
+* Cleanup the VirtualBox Media Manager after closing a project.
+* Avoid Cygwin warning with VPCS on Windows.
+* Close VirtualBox VM linked clone disks after the VM is unregistered.
+* TAP interface support for QEMU VMs.
+* Return an explicit error when a NIO type is not supported by a VM.
+* Do not erase the IOU config
+* Explicit utf-8 decoding.
+* Check NIO exists when stopping an IOU capture.
+* Fixes c7200 NPE setting.
+* Fixes VPCS process termination.
+* Catch FileNotFoundError exception in os.getcwd()
+* Explicit utf-8 encoding where necessary to avoid Unicode errors on Windows (we require/set an utf-8 locale on other systems).
+* Fixes #270. Relative paths management with empty ones.
+* New crash report key and doesn't send report for developers
+* Catch COM errors when connecting to WMI.
+* Don't assume the PATH environment variable exists.
+* Use UUIDs instead of the VM names for VirtualBox pipe paths.
+* Add --log options for daemon support
+* Basic upstart script
+* Add qemu-kvm to the list of binary
+* Fix IOU licence check flag
+* Config paths are not used when updating Dynamips or IOU VM settings.
+* Fixes initial-configs that were not restored when opening a project containing IOU VMs.
+* Prevent parallel execution of VBox commands
+* Fix a crash when in some cases you can't access to VBOX state
+* Fix crash if VirtualBox doesn't return API version
+* Fix a crash in VirtualBox vm creation
+* Allocate random names for Dynamips NIOs.
+* Explicitly delete Dynamips NIOs and unmap VCs for ATM and Frame-Relay switches.
+
 ## 1.3.1 11/04/2015
 
 * Release

MANIFEST.in

@@ -4,7 +4,7 @@ include INSTALL
 include LICENSE
 include MANIFEST.in
 include tox.ini
-recursive-exclude tests *
+recursive-include tests *
 recursive-exclude docs *
 recursive-include gns3server *
 recursive-exclude * __pycache__

README.rst

@@ -26,6 +26,12 @@ unstable
 ********
 *Never* use this branch for production. Major new features pull requests goes here. 
 
+Linux
+-----
+
+GNS3 is perhaps packaged for your distribution:
+* Gentoo: https://packages.gentoo.org/package/net-misc/gns3-server
+
 
 Linux (Debian based)
 --------------------
@@ -62,11 +68,34 @@ To run tests use:
 
    py.test -v
 
+
+Run as daemon 
+***************
+
+You will found init sample script for various systems
+inside the init directory.
+
+upstart
+~~~~~~~
+
+For ubuntu < 15.04
+
+You need to copy init/gns3.conf.upstart to /etc/init/gns3.conf
+
+.. code:: bash
+
+    sudo chown root /etc/init/gns3.conf
+    sudo service gns3 start
+
+
 Windows
 -------
 
 Please use our all-in-one installer.
 
+If you install it via source you need to install also:
+https://sourceforge.net/projects/pywin32/
+
 Mac OS X
 --------
 

gns3server/crash_report.py

@@ -40,7 +40,7 @@ class CrashReport:
     Report crash to a third party service
     """
 
-    DSN = "sync+https://90fe04368a3e4109b584a116ee03ca87:268ef86c65cf4e8fa41d4c7fb1c70b72@app.getsentry.com/38482"
+    DSN = "sync+https://22979234ab4749ceabce08e6da4c1476:1432c8c7a43d410b9b5bb33f8e55b2a6@app.getsentry.com/38482"
     if hasattr(sys, "frozen"):
         cacert = os.path.join(os.getcwd(), "cacert.pem")
         if os.path.isfile(cacert):
@@ -55,6 +55,9 @@ class CrashReport:
     def capture_exception(self, request=None):
         if not RAVEN_AVAILABLE:
             return
+        if os.path.exists(".git"):
+            log.warning("A .git directory exist crash report is turn off for developers")
+            return
         server_config = Config.instance().get_section_config("Server")
         if server_config.getboolean("report_errors"):
             if self._client is None:

gns3server/handlers/__init__.py

@@ -31,4 +31,6 @@ from gns3server.handlers.upload_handler import UploadHandler
 from gns3server.handlers.index_handler import IndexHandler
 
 if sys.platform.startswith("linux") or hasattr(sys, "_called_from_test") or os.environ.get("PYTEST_BUILD_DOCUMENTATION") == "1":
-    from gns3server.handlers.api.iou_handler import IOUHandler
+    # IOU runs only on Linux but testsuite work on UNIX platform
+    if not sys.platform.startswith("win"):
+        from gns3server.handlers.api.iou_handler import IOUHandler

gns3server/handlers/api/dynamips_device_handler.py

@@ -181,10 +181,8 @@ class DynamipsDeviceHandler:
         dynamips_manager = Dynamips.instance()
         device = dynamips_manager.get_device(request.match_info["device_id"], project_id=request.match_info["project_id"])
         port_number = int(request.match_info["port_number"])
-        if asyncio.iscoroutinefunction(device.remove_nio):
-            yield from device.remove_nio(port_number)
-        else:
-            device.remove_nio(port_number)
+        nio = yield from device.remove_nio(port_number)
+        yield from nio.delete()
         response.set_status(204)
 
     @Route.post(

gns3server/handlers/api/dynamips_vm_handler.py

@@ -19,11 +19,11 @@ import os
 import base64
 
 from ...web.route import Route
+from ...schemas.nio import NIO_SCHEMA
 from ...schemas.dynamips_vm import VM_CREATE_SCHEMA
 from ...schemas.dynamips_vm import VM_UPDATE_SCHEMA
 from ...schemas.dynamips_vm import VM_CAPTURE_SCHEMA
 from ...schemas.dynamips_vm import VM_OBJECT_SCHEMA
-from ...schemas.dynamips_vm import VM_NIO_SCHEMA
 from ...schemas.dynamips_vm import VM_CONFIGS_SCHEMA
 from ...modules.dynamips import Dynamips
 from ...modules.project_manager import ProjectManager
@@ -256,8 +256,8 @@ class DynamipsVMHandler:
             404: "Instance doesn't exist"
         },
         description="Add a NIO to a Dynamips VM instance",
-        input=VM_NIO_SCHEMA,
-        output=VM_NIO_SCHEMA)
+        input=NIO_SCHEMA,
+        output=NIO_SCHEMA)
     def create_nio(request, response):
 
         dynamips_manager = Dynamips.instance()
@@ -290,7 +290,8 @@ class DynamipsVMHandler:
         vm = dynamips_manager.get_vm(request.match_info["vm_id"], project_id=request.match_info["project_id"])
         slot_number = int(request.match_info["adapter_number"])
         port_number = int(request.match_info["port_number"])
-        yield from vm.slot_remove_nio_binding(slot_number, port_number)
+        nio = yield from vm.slot_remove_nio_binding(slot_number, port_number)
+        yield from nio.delete()
         response.set_status(204)
 
     @Route.post(

gns3server/handlers/api/iou_handler.py

@@ -19,11 +19,10 @@ import os
 from aiohttp.web import HTTPConflict
 
 from ...web.route import Route
-from ...modules.port_manager import PortManager
+from ...schemas.nio import NIO_SCHEMA
 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 ...schemas.iou import IOU_CAPTURE_SCHEMA
 from ...schemas.iou import IOU_INITIAL_CONFIG_SCHEMA
 from ...modules.iou import IOU
@@ -52,20 +51,16 @@ class IOUHandler:
     def create(request, response):
 
         iou = IOU.instance()
-        vm = yield from iou.create_vm(request.json["name"],
+        vm = yield from iou.create_vm(request.json.pop("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"),
-                                      use_default_iou_values=request.json.get("use_default_iou_values"),
-                                      l1_keepalives=request.json.get("l1_keepalives"),
-                                      initial_config=request.json.get("initial_config_content"),
-                                      iourc_content=request.json.get("iourc_content")
-                                      )
-        vm.path = request.json.get("path", vm.path)
+                                      console=request.json.get("console"))
+
+        for name, value in request.json.items():
+            if hasattr(vm, name) and getattr(vm, name) != value:
+                if name == "initial_config_content" and (vm.initial_config_content and len(vm.initial_config_content) > 0):
+                    continue
+                setattr(vm, name, value)
         response.set_status(201)
         response.json(vm)
 
@@ -109,18 +104,10 @@ class IOUHandler:
 
         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.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)
-        vm.use_default_iou_values = request.json.get("use_default_iou_values", vm.use_default_iou_values)
-        vm.l1_keepalives = request.json.get("l1_keepalives", vm.l1_keepalives)
-        vm.initial_config = request.json.get("initial_config_content", vm.initial_config)
-        vm.iourc_content = request.json.get("iourc_content", None)
 
+        for name, value in request.json.items():
+            if hasattr(vm, name) and getattr(vm, name) != value:
+                setattr(vm, name, value)
         response.json(vm)
 
     @classmethod
@@ -215,12 +202,15 @@ class IOUHandler:
             404: "Instance doesn't exist"
         },
         description="Add a NIO to a IOU instance",
-        input=IOU_NIO_SCHEMA,
-        output=IOU_NIO_SCHEMA)
+        input=NIO_SCHEMA,
+        output=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_type = request.json["type"]
+        if nio_type not in ("nio_udp", "nio_tap", "nio_generic_ethernet"):
+            raise HTTPConflict(text="NIO of type {} is not supported".format(nio_type))
         nio = iou_manager.create_nio(vm.iouyap_path, request.json)
         vm.adapter_add_nio_binding(int(request.match_info["adapter_number"]), int(request.match_info["port_number"]), nio)
         response.set_status(201)
@@ -273,7 +263,7 @@ class IOUHandler:
         pcap_file_path = os.path.join(vm.project.capture_working_directory(), request.json["capture_file_name"])
 
         if not vm.is_running():
-            raise HTTPConflict(text="You can't capture the traffic on a non started VM")
+            raise HTTPConflict(text="Cannot capture traffic on a non started VM")
         yield from vm.start_capture(adapter_number, port_number, pcap_file_path, request.json["data_link_type"])
         response.json({"pcap_file_path": str(pcap_file_path)})
 
@@ -298,7 +288,7 @@ class IOUHandler:
         vm = iou_manager.get_vm(request.match_info["vm_id"], project_id=request.match_info["project_id"])
 
         if not vm.is_running():
-            raise HTTPConflict(text="You can't capture the traffic on a non started VM")
+            raise HTTPConflict(text="Cannot capture traffic on a non started VM")
 
         adapter_number = int(request.match_info["adapter_number"])
         port_number = int(request.match_info["port_number"])
@@ -320,4 +310,4 @@ class IOUHandler:
         vm = iou_manager.get_vm(request.match_info["vm_id"],
                                 project_id=request.match_info["project_id"])
         response.set_status(200)
-        response.json({"content": vm.initial_config})
+        response.json({"content": vm.initial_config_content})

gns3server/handlers/api/qemu_handler.py

@@ -15,11 +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 aiohttp.web import HTTPConflict
 from ...web.route import Route
+from ...schemas.nio import NIO_SCHEMA
 from ...schemas.qemu import QEMU_CREATE_SCHEMA
 from ...schemas.qemu import QEMU_UPDATE_SCHEMA
 from ...schemas.qemu import QEMU_OBJECT_SCHEMA
-from ...schemas.qemu import QEMU_NIO_SCHEMA
 from ...schemas.qemu import QEMU_BINARY_LIST_SCHEMA
 from ...modules.qemu import Qemu
 
@@ -41,24 +42,21 @@ class QEMUHandler:
             400: "Invalid request",
             409: "Conflict"
         },
-        description="Create a new Qemu.instance",
+        description="Create a new Qemu VM instance",
         input=QEMU_CREATE_SCHEMA,
         output=QEMU_OBJECT_SCHEMA)
     def create(request, response):
 
         qemu = Qemu.instance()
-        vm = yield from qemu.create_vm(request.json["name"],
+        vm = yield from qemu.create_vm(request.json.pop("name"),
                                        request.match_info["project_id"],
                                        request.json.get("vm_id"),
                                        qemu_path=request.json.get("qemu_path"),
                                        console=request.json.get("console"))
 
-        # Clear already used keys
-        map(request.json.__delitem__, ["name", "project_id", "vm_id",
-                                       "qemu_path", "console"])
-
-        for field in request.json:
-            setattr(vm, field, request.json[field])
+        for name, value in request.json.items():
+            if hasattr(vm, name) and getattr(vm, name) != value:
+                setattr(vm, name, value)
 
         response.set_status(201)
         response.json(vm)
@@ -75,7 +73,7 @@ class QEMUHandler:
             400: "Invalid request",
             404: "Instance doesn't exist"
         },
-        description="Get a Qemu.instance",
+        description="Get a Qemu VM instance",
         output=QEMU_OBJECT_SCHEMA)
     def show(request, response):
 
@@ -96,15 +94,17 @@ class QEMUHandler:
             404: "Instance doesn't exist",
             409: "Conflict"
         },
-        description="Update a Qemu.instance",
+        description="Update a Qemu VM instance",
         input=QEMU_UPDATE_SCHEMA,
         output=QEMU_OBJECT_SCHEMA)
     def update(request, response):
 
         qemu_manager = Qemu.instance()
         vm = qemu_manager.get_vm(request.match_info["vm_id"], project_id=request.match_info["project_id"])
-        for field in request.json:
-            setattr(vm, field, request.json[field])
+
+        for name, value in request.json.items():
+            if hasattr(vm, name) and getattr(vm, name) != value:
+                setattr(vm, name, value)
 
         response.json(vm)
 
@@ -120,7 +120,7 @@ class QEMUHandler:
             400: "Invalid request",
             404: "Instance doesn't exist"
         },
-        description="Delete a Qemu.instance")
+        description="Delete a Qemu VM instance")
     def delete(request, response):
 
         yield from Qemu.instance().delete_vm(request.match_info["vm_id"])
@@ -138,7 +138,7 @@ class QEMUHandler:
             400: "Invalid request",
             404: "Instance doesn't exist"
         },
-        description="Start a Qemu.instance")
+        description="Start a Qemu VM instance")
     def start(request, response):
 
         qemu_manager = Qemu.instance()
@@ -158,7 +158,7 @@ class QEMUHandler:
             400: "Invalid request",
             404: "Instance doesn't exist"
         },
-        description="Stop a Qemu.instance")
+        description="Stop a Qemu VM instance")
     def stop(request, response):
 
         qemu_manager = Qemu.instance()
@@ -178,7 +178,7 @@ class QEMUHandler:
             400: "Invalid request",
             404: "Instance doesn't exist"
         },
-        description="Reload a Qemu.instance")
+        description="Reload a Qemu VM instance")
     def reload(request, response):
 
         qemu_manager = Qemu.instance()
@@ -198,7 +198,7 @@ class QEMUHandler:
             400: "Invalid request",
             404: "Instance doesn't exist"
         },
-        description="Suspend a Qemu.instance")
+        description="Suspend a Qemu VM instance")
     def suspend(request, response):
 
         qemu_manager = Qemu.instance()
@@ -218,7 +218,7 @@ class QEMUHandler:
             400: "Invalid request",
             404: "Instance doesn't exist"
         },
-        description="Resume a Qemu.instance")
+        description="Resume a Qemu VM instance")
     def resume(request, response):
 
         qemu_manager = Qemu.instance()
@@ -239,13 +239,16 @@ class QEMUHandler:
             400: "Invalid request",
             404: "Instance doesn't exist"
         },
-        description="Add a NIO to a Qemu.instance",
-        input=QEMU_NIO_SCHEMA,
-        output=QEMU_NIO_SCHEMA)
+        description="Add a NIO to a Qemu VM instance",
+        input=NIO_SCHEMA,
+        output=NIO_SCHEMA)
     def create_nio(request, response):
 
         qemu_manager = Qemu.instance()
         vm = qemu_manager.get_vm(request.match_info["vm_id"], project_id=request.match_info["project_id"])
+        nio_type = request.json["type"]
+        if nio_type not in ("nio_udp", "nio_tap"):
+            raise HTTPConflict(text="NIO of type {} is not supported".format(nio_type))
         nio = qemu_manager.create_nio(vm.qemu_path, request.json)
         yield from vm.adapter_add_nio_binding(int(request.match_info["adapter_number"]), nio)
         response.set_status(201)
@@ -265,7 +268,7 @@ class QEMUHandler:
             400: "Invalid request",
             404: "Instance doesn't exist"
         },
-        description="Remove a NIO from a Qemu.instance")
+        description="Remove a NIO from a Qemu VM instance")
     def delete_nio(request, response):
 
         qemu_manager = Qemu.instance()

gns3server/handlers/api/virtualbox_handler.py

@@ -16,10 +16,11 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import os
+from aiohttp.web import HTTPConflict
 from ...web.route import Route
+from ...schemas.nio import NIO_SCHEMA
 from ...schemas.virtualbox import VBOX_CREATE_SCHEMA
 from ...schemas.virtualbox import VBOX_UPDATE_SCHEMA
-from ...schemas.virtualbox import VBOX_NIO_SCHEMA
 from ...schemas.virtualbox import VBOX_CAPTURE_SCHEMA
 from ...schemas.virtualbox import VBOX_OBJECT_SCHEMA
 from ...modules.virtualbox import VirtualBox
@@ -79,8 +80,9 @@ class VirtualBoxHandler:
                 yield from vm.set_ram(ram)
 
         for name, value in request.json.items():
-            if hasattr(vm, name) and getattr(vm, name) != value:
-                setattr(vm, name, value)
+            if name != "vm_id":
+                if hasattr(vm, name) and getattr(vm, name) != value:
+                    setattr(vm, name, value)
 
         response.set_status(201)
         response.json(vm)
@@ -285,12 +287,15 @@ class VirtualBoxHandler:
             404: "Instance doesn't exist"
         },
         description="Add a NIO to a VirtualBox VM instance",
-        input=VBOX_NIO_SCHEMA,
-        output=VBOX_NIO_SCHEMA)
+        input=NIO_SCHEMA,
+        output=NIO_SCHEMA)
     def create_nio(request, response):
 
         vbox_manager = VirtualBox.instance()
         vm = vbox_manager.get_vm(request.match_info["vm_id"], project_id=request.match_info["project_id"])
+        nio_type = request.json["type"]
+        if nio_type != "nio_udp":
+            raise HTTPConflict(text="NIO of type {} is not supported".format(nio_type))
         nio = vbox_manager.create_nio(vbox_manager.vboxmanage_path, request.json)
         yield from vm.adapter_add_nio_binding(int(request.match_info["adapter_number"]), nio)
         response.set_status(201)

gns3server/handlers/api/vpcs_handler.py

@@ -15,11 +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 aiohttp.web import HTTPConflict
 from ...web.route import Route
+from ...schemas.nio import NIO_SCHEMA
 from ...schemas.vpcs import VPCS_CREATE_SCHEMA
 from ...schemas.vpcs import VPCS_UPDATE_SCHEMA
 from ...schemas.vpcs import VPCS_OBJECT_SCHEMA
-from ...schemas.vpcs import VPCS_NIO_SCHEMA
 from ...modules.vpcs import VPCS
 
 
@@ -191,12 +192,15 @@ class VPCSHandler:
             404: "Instance doesn't exist"
         },
         description="Add a NIO to a VPCS instance",
-        input=VPCS_NIO_SCHEMA,
-        output=VPCS_NIO_SCHEMA)
+        input=NIO_SCHEMA,
+        output=NIO_SCHEMA)
     def create_nio(request, response):
 
         vpcs_manager = VPCS.instance()
         vm = vpcs_manager.get_vm(request.match_info["vm_id"], project_id=request.match_info["project_id"])
+        nio_type = request.json["type"]
+        if nio_type not in ("nio_udp", "nio_tap"):
+            raise HTTPConflict(text="NIO of type {} is not supported".format(nio_type))
         nio = vpcs_manager.create_nio(vm.vpcs_path, request.json)
         vm.port_add_nio_binding(int(request.match_info["port_number"]), nio)
         response.set_status(201)

gns3server/main.py

@@ -92,6 +92,7 @@ def parse_arguments(argv, config):
         "quiet": config.getboolean("quiet", False),
         "debug": config.getboolean("debug", False),
         "live": config.getboolean("live", False),
+        "logfile": config.getboolean("logfile", ""),
     }
 
     parser = argparse.ArgumentParser(description="GNS3 server version {}".format(__version__))
@@ -109,6 +110,7 @@ def parse_arguments(argv, config):
     parser.add_argument("-d", "--debug", action="store_true", help="show debug logs")
     parser.add_argument("--live", action="store_true", help="enable code live reload")
     parser.add_argument("--shell", action="store_true", help="start a shell inside the server (debugging purpose only you need to install ptpython before)")
+    parser.add_argument("--log", help="send output to logfile instead of console")
 
     return parser.parse_args(argv)
 
@@ -141,7 +143,7 @@ def main():
     if args.debug:
         level = logging.DEBUG
 
-    user_log = init_logger(level, quiet=args.quiet)
+    user_log = init_logger(level, logfile=args.log, quiet=args.quiet)
     user_log.info("GNS3 server version {}".format(__version__))
     current_year = datetime.date.today().year
     user_log.info("Copyright (c) 2007-{} GNS3 Technologies Inc.".format(current_year))

gns3server/modules/__init__.py

@@ -25,6 +25,8 @@ from .qemu import Qemu
 MODULES = [VPCS, VirtualBox, Dynamips, Qemu]
 
 if sys.platform.startswith("linux") or hasattr(sys, "_called_from_test") or os.environ.get("PYTEST_BUILD_DOCUMENTATION") == "1":
-    # IOU runs only on Linux
-    from .iou import IOU
-    MODULES.append(IOU)
+
+    # IOU runs only on Linux but testsuite work on UNIX platform
+    if not sys.platform.startswith("win"):
+        from .iou import IOU
+        MODULES.append(IOU)

gns3server/modules/base_manager.py

@@ -364,10 +364,52 @@ class BaseManager:
             nio = NIOUDP(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))
+            #FIXME: check for permissions on 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)
         elif nio_settings["type"] == "nio_generic_ethernet":
             nio = NIOGenericEthernet(nio_settings["ethernet_device"])
         assert nio is not None
         return nio
+
+    def get_abs_image_path(self, path):
+        """
+        Get the absolute path of an image
+
+        :param path: file path
+        :return: file path
+        """
+
+        if not path:
+            return ""
+        img_directory = self.get_images_directory()
+        if not os.path.isabs(path):
+            s = os.path.split(path)
+            return os.path.normpath(os.path.join(img_directory, *s))
+        return path
+
+    def get_relative_image_path(self, path):
+        """
+        Get a path relative to images directory path
+        or an abspath if the path is not located inside
+        image directory
+
+        :param path: file path
+        :return: file path
+        """
+
+        if not path:
+            return ""
+        img_directory = self.get_images_directory()
+        path = self.get_abs_image_path(path)
+        if os.path.dirname(path) == img_directory:
+            return os.path.basename(path)
+        return path
+
+    def get_images_directory(self):
+        """
+        Get the image directory on disk
+        """
+
+        raise NotImplementedError

gns3server/modules/dynamips/__init__.py

@@ -208,7 +208,7 @@ class Dynamips(BaseManager):
         """
 
         # save the configs when the project is committed
-        for vm in self._vms.values():
+        for vm in self._vms.copy().values():
             if vm.project.id == project.id:
                 yield from vm.save_configs()
 
@@ -616,3 +616,9 @@ class Dynamips(BaseManager):
             if was_auto_started:
                 yield from vm.stop()
         return validated_idlepc
+
+    def get_images_directory(self):
+        """
+        Return the full path of the images directory on disk
+        """
+        return os.path.join(os.path.expanduser(self.config.get_section_config("Server").get("images_path", "~/GNS3/images")), "IOS")

gns3server/modules/dynamips/dynamips_hypervisor.py

@@ -284,7 +284,7 @@ class DynamipsHypervisor:
                     if not line:
                         raise DynamipsError("No data returned from {host}:{port}, Dynamips process running: {run}"
                                             .format(host=self._host, port=self._port, run=self.is_running()))
-                    buf += line.decode()
+                    buf += line.decode("utf-8")
                 except OSError as e:
                     raise DynamipsError("Lost communication with {host}:{port} :{error}, Dynamips process running: {run}"
                                         .format(host=self._host, port=self._port, error=e, run=self.is_running()))

gns3server/modules/dynamips/hypervisor.py

@@ -158,8 +158,8 @@ class Hypervisor(DynamipsHypervisor):
         output = ""
         if self._stdout_file and os.access(self._stdout_file, os.R_OK):
             try:
-                with open(self._stdout_file, errors="replace") as file:
-                    output = file.read()
+                with open(self._stdout_file, "rb") as file:
+                    output = file.read().decode("utf-8", errors="replace")
             except OSError as e:
                 log.warn("could not read {}: {}".format(self._stdout_file, e))
         return output

gns3server/modules/dynamips/nios/nio_fifo.py

@@ -20,6 +20,7 @@ Interface for FIFO NIOs.
 """
 
 import asyncio
+import uuid
 from .nio import NIO
 
 import logging
@@ -34,24 +35,12 @@ class NIOFIFO(NIO):
     :param hypervisor: Dynamips hypervisor instance
     """
 
-    _instance_count = 0
-
     def __init__(self, hypervisor):
 
-        # create an unique ID and name
-        nio_id = NIOFIFO._instance_count
-        NIOFIFO._instance_count += 1
-        name = 'nio_fifo' + str(nio_id)
+        # create an unique name
+        name = 'fifo-{}'.format(uuid.uuid4())
         super().__init__(name, hypervisor)
 
-    @classmethod
-    def reset(cls):
-        """
-        Reset the instance count.
-        """
-
-        cls._instance_count = 0
-
     @asyncio.coroutine
     def create(self):
 

gns3server/modules/dynamips/nios/nio_generic_ethernet.py

@@ -20,6 +20,7 @@ Interface for generic Ethernet NIOs (PCAP library).
 """
 
 import asyncio
+import uuid
 from .nio import NIO
 
 import logging
@@ -35,25 +36,13 @@ class NIOGenericEthernet(NIO):
     :param ethernet_device: Ethernet device name (e.g. eth0)
     """
 
-    _instance_count = 0
-
     def __init__(self, hypervisor, ethernet_device):
 
-        # create an unique ID and name
-        nio_id = NIOGenericEthernet._instance_count
-        NIOGenericEthernet._instance_count += 1
-        name = 'nio_gen_eth' + str(nio_id)
+        # create an unique name
+        name = 'generic_ethernet-{}'.format(uuid.uuid4())
         self._ethernet_device = ethernet_device
         super().__init__(name, hypervisor)
 
-    @classmethod
-    def reset(cls):
-        """
-        Reset the instance count.
-        """
-
-        cls._instance_count = 0
-
     @asyncio.coroutine
     def create(self):
 

gns3server/modules/dynamips/nios/nio_linux_ethernet.py

@@ -20,6 +20,7 @@ Interface for Linux Ethernet NIOs (Linux only).
 """
 
 import asyncio
+import uuid
 from .nio import NIO
 
 import logging
@@ -35,25 +36,12 @@ class NIOLinuxEthernet(NIO):
     :param ethernet_device: Ethernet device name (e.g. eth0)
     """
 
-    _instance_count = 0
-
     def __init__(self, hypervisor, ethernet_device):
-
-        # create an unique ID and name
-        nio_id = NIOLinuxEthernet._instance_count
-        NIOLinuxEthernet._instance_count += 1
-        name = 'nio_linux_eth' + str(nio_id)
+        # create an unique name
+        name = 'linux_ethernet-{}'.format(uuid.uuid4())
         self._ethernet_device = ethernet_device
         super().__init__(name, hypervisor)
 
-    @classmethod
-    def reset(cls):
-        """
-        Reset the instance count.
-        """
-
-        cls._instance_count = 0
-
     @asyncio.coroutine
     def create(self):
 

gns3server/modules/dynamips/nios/nio_mcast.py

@@ -20,6 +20,7 @@ Interface for multicast NIOs.
 """
 
 import asyncio
+import uuid
 from .nio import NIO
 
 import logging
@@ -36,27 +37,15 @@ class NIOMcast(NIO):
     :param port: port for binding
     """
 
-    _instance_count = 0
-
     def __init__(self, hypervisor, group, port):
 
-        # create an unique ID and name
-        nio_id = NIOMcast._instance_count
-        NIOMcast._instance_count += 1
-        name = 'nio_mcast' + str(nio_id)
+        # create an unique name
+        name = 'mcast-{}'.format(uuid.uuid4())
         self._group = group
         self._port = port
         self._ttl = 1  # default TTL
         super().__init__(name, hypervisor)
 
-    @classmethod
-    def reset(cls):
-        """
-        Reset the instance count.
-        """
-
-        cls._instance_count = 0
-
     @asyncio.coroutine
     def create(self):
 

gns3server/modules/dynamips/nios/nio_null.py

@@ -20,6 +20,7 @@ Interface for dummy NIOs (mostly for tests).
 """
 
 import asyncio
+import uuid
 from .nio import NIO
 
 import logging
@@ -34,24 +35,12 @@ class NIONull(NIO):
     :param hypervisor: Dynamips hypervisor instance
     """
 
-    _instance_count = 0
-
     def __init__(self, hypervisor):
 
-        # create an unique ID and name
-        nio_id = NIONull._instance_count
-        NIONull._instance_count += 1
-        name = 'nio_null' + str(nio_id)
+        # create an unique name
+        name = 'null-{}'.format(uuid.uuid4())
         super().__init__(name, hypervisor)
 
-    @classmethod
-    def reset(cls):
-        """
-        Reset the instance count.
-        """
-
-        cls._instance_count = 0
-
     @asyncio.coroutine
     def create(self):
 

gns3server/modules/dynamips/nios/nio_tap.py

@@ -20,6 +20,7 @@ Interface for TAP NIOs (UNIX based OSes only).
 """
 
 import asyncio
+import uuid
 from .nio import NIO
 
 import logging
@@ -35,25 +36,13 @@ class NIOTAP(NIO):
     :param tap_device: TAP device name (e.g. tap0)
     """
 
-    _instance_count = 0
-
     def __init__(self, hypervisor, tap_device):
 
-        # create an unique ID and name
-        nio_id = NIOTAP._instance_count
-        NIOTAP._instance_count += 1
-        name = 'nio_tap' + str(nio_id)
+        # create an unique name
+        name = 'tap-{}'.format(uuid.uuid4())
         self._tap_device = tap_device
         super().__init__(name, hypervisor)
 
-    @classmethod
-    def reset(cls):
-        """
-        Reset the instance count.
-        """
-
-        cls._instance_count = 0
-
     @asyncio.coroutine
     def create(self):
 

gns3server/modules/dynamips/nios/nio_udp.py

@@ -20,6 +20,7 @@ Interface for UDP NIOs.
 """
 
 import asyncio
+import uuid
 from .nio import NIO
 
 import logging
@@ -37,27 +38,15 @@ class NIOUDP(NIO):
     :param rport: remote port number
     """
 
-    _instance_count = 0
-
     def __init__(self, hypervisor, lport, rhost, rport):
 
-        # create an unique ID and name
-        nio_id = NIOUDP._instance_count
-        NIOUDP._instance_count += 1
-        name = 'nio_udp' + str(nio_id)
+        # create an unique name
+        name = 'udp-{}'.format(uuid.uuid4())
         self._lport = lport
         self._rhost = rhost
         self._rport = rport
         super().__init__(name, hypervisor)
 
-    @classmethod
-    def reset(cls):
-        """
-        Reset the instance count.
-        """
-
-        cls._instance_count = 0
-
     @asyncio.coroutine
     def create(self):
 

gns3server/modules/dynamips/nios/nio_unix.py

@@ -20,6 +20,7 @@ Interface for UNIX NIOs (Unix based OSes only).
 """
 
 import asyncio
+import uuid
 from .nio import NIO
 
 import logging
@@ -36,26 +37,14 @@ class NIOUNIX(NIO):
     :param remote_file: remote UNIX socket filename
     """
 
-    _instance_count = 0
-
     def __init__(self, hypervisor, local_file, remote_file):
 
-        # create an unique ID and name
-        nio_id = NIOUNIX._instance_count
-        NIOUNIX._instance_count += 1
-        name = 'nio_unix' + str(nio_id)
+        # create an unique name
+        name = 'unix-{}'.format(uuid.uuid4())
         self._local_file = local_file
         self._remote_file = remote_file
         super().__init__(name, hypervisor)
 
-    @classmethod
-    def reset(cls):
-        """
-        Reset the instance count.
-        """
-
-        cls._instance_count = 0
-
     @asyncio.coroutine
     def create(self):
 

gns3server/modules/dynamips/nios/nio_vde.py

@@ -20,6 +20,7 @@ Interface for VDE (Virtual Distributed Ethernet) NIOs (Unix based OSes only).
 """
 
 import asyncio
+import uuid
 from .nio import NIO
 
 import logging
@@ -36,26 +37,14 @@ class NIOVDE(NIO):
     :param local_file: VDE local filename
     """
 
-    _instance_count = 0
-
     def __init__(self, hypervisor, control_file, local_file):
 
-        # create an unique ID and name
-        nio_id = NIOVDE._instance_count
-        NIOVDE._instance_count += 1
-        name = 'nio_vde' + str(nio_id)
+        # create an unique name
+        name = 'vde-{}'.format(uuid.uuid4())
         self._control_file = control_file
         self._local_file = local_file
         super().__init__(name, hypervisor)
 
-    @classmethod
-    def reset(cls):
-        """
-        Reset the instance count.
-        """
-
-        cls._instance_count = 0
-
     @asyncio.coroutine
     def create(self):
 

gns3server/modules/dynamips/nodes/atm_switch.py

@@ -150,6 +150,7 @@ class ATMSwitch(Device):
 
         self._nios[port_number] = nio
 
+    @asyncio.coroutine
     def remove_nio(self, port_number):
         """
         Removes the specified NIO as member of this ATM switch.
@@ -160,6 +161,23 @@ class ATMSwitch(Device):
         if port_number not in self._nios:
             raise DynamipsError("Port {} is not allocated".format(port_number))
 
+        # remove VCs mapped with the port
+        for source, destination in self._mappings.copy().items():
+            if len(source) == 3 and len(destination) == 3:
+                # remove the virtual channels mapped with this port/nio
+                source_port, source_vpi, source_vci = source
+                destination_port, destination_vpi, destination_vci = destination
+                if port_number == source_port:
+                    yield from self.unmap_pvc(source_port, source_vpi, source_vci, destination_port, destination_vpi, destination_vci)
+                    yield from self.unmap_pvc(destination_port, destination_vpi, destination_vci, source_port, source_vpi, source_vci)
+            else:
+                # remove the virtual paths mapped with this port/nio
+                source_port, source_vpi = source
+                destination_port, destination_vpi = destination
+                if port_number == source_port:
+                    yield from self.unmap_vp(source_port, source_vpi, destination_port, destination_vpi)
+                    yield from self.unmap_vp(destination_port, destination_vpi, source_port, source_vpi)
+
         nio = self._nios[port_number]
         if isinstance(nio, NIOUDP):
             self.manager.port_manager.release_udp_port(nio.lport, self._project)

gns3server/modules/dynamips/nodes/c7200.py

@@ -120,7 +120,7 @@ class C7200(Router):
         npe-225, npe-300, npe-400 and npe-g2 (PowerPC c7200 only)
         """
 
-        if self.is_running():
+        if (yield from self.is_running()):
             raise DynamipsError("Cannot change NPE on running router")
 
         yield from self._hypervisor.send('c7200 set_npe "{name}" {npe}'.format(name=self._name, npe=npe))

gns3server/modules/dynamips/nodes/frame_relay_switch.py

@@ -149,6 +149,7 @@ class FrameRelaySwitch(Device):
 
         self._nios[port_number] = nio
 
+    @asyncio.coroutine
     def remove_nio(self, port_number):
         """
         Removes the specified NIO as member of this Frame Relay switch.
@@ -161,6 +162,14 @@ class FrameRelaySwitch(Device):
         if port_number not in self._nios:
             raise DynamipsError("Port {} is not allocated".format(port_number))
 
+        # remove VCs mapped with the port
+        for source, destination in self._mappings.copy().items():
+            source_port, source_dlci = source
+            destination_port, destination_dlci = destination
+            if port_number == source_port:
+                yield from self.unmap_vc(source_port, source_dlci, destination_port, destination_dlci)
+                yield from self.unmap_vc(destination_port, destination_dlci, source_port, source_dlci)
+
         nio = self._nios[port_number]
         if isinstance(nio, NIOUDP):
             self.manager.port_manager.release_udp_port(nio.lport, self._project)

gns3server/modules/dynamips/nodes/router.py

@@ -151,10 +151,7 @@ class Router(BaseVM):
                        "system_id": self._system_id}
 
         # return the relative path if the IOS image is in the images_path directory
-        server_config = self.manager.config.get_section_config("Server")
-        relative_image = os.path.join(os.path.expanduser(server_config.get("images_path", "~/GNS3/images")), "IOS", self._image)
-        if os.path.exists(relative_image):
-            router_info["image"] = os.path.basename(self._image)
+        router_info["image"] = self.manager.get_relative_image_path(self._image)
 
         # add the slots
         slot_number = 0
@@ -172,14 +169,6 @@ class Router(BaseVM):
 
         return router_info
 
-    @classmethod
-    def reset(cls):
-        """
-        Resets the instance count and the allocated instances list.
-        """
-
-        cls._dynamips_ids.clear()
-
     @property
     def dynamips_id(self):
         """
@@ -427,9 +416,7 @@ class Router(BaseVM):
         :param image: path to IOS image file
         """
 
-        if not os.path.isabs(image):
-            server_config = self.manager.config.get_section_config("Server")
-            image = os.path.join(os.path.expanduser(server_config.get("images_path", "~/GNS3/images")), "IOS", image)
+        image = self.manager.get_abs_image_path(image)
 
         if not os.path.isfile(image):
             raise DynamipsError("IOS image '{}' is not accessible".format(image))
@@ -1409,7 +1396,7 @@ class Router(BaseVM):
             startup_config_path = os.path.join(module_workdir, "configs", "i{}_startup-config.cfg".format(self._dynamips_id))
             if os.path.isfile(startup_config_path):
                 try:
-                    with open(startup_config_path, "r+", errors="replace") as f:
+                    with open(startup_config_path, "r+", encoding="utf-8", errors="replace") as f:
                         old_config = f.read()
                         new_config = old_config.replace(self.name, new_name)
                         f.seek(0)
@@ -1422,7 +1409,7 @@ class Router(BaseVM):
             private_config_path = os.path.join(module_workdir, "configs", "i{}_private-config.cfg".format(self._dynamips_id))
             if os.path.isfile(private_config_path):
                 try:
-                    with open(private_config_path, "r+", errors="replace") as f:
+                    with open(private_config_path, "r+", encoding="utf-8", errors="replace") as f:
                         old_config = f.read()
                         new_config = old_config.replace(self.name, new_name)
                         f.seek(0)
@@ -1497,7 +1484,7 @@ class Router(BaseVM):
             startup_config_base64, private_config_base64 = yield from self.extract_config()
             if startup_config_base64:
                 try:
-                    config = base64.b64decode(startup_config_base64).decode(errors='replace')
+                    config = base64.b64decode(startup_config_base64).decode("utf-8", errors="replace")
                     config = "!\n" + config.replace("\r", "")
                     config_path = os.path.join(module_workdir, self.startup_config)
                     with open(config_path, "wb") as f:
@@ -1508,7 +1495,7 @@ class Router(BaseVM):
 
             if private_config_base64:
                 try:
-                    config = base64.b64decode(private_config_base64).decode(errors='replace')
+                    config = base64.b64decode(private_config_base64).decode("utf-8", errors="replace")
                     config = "!\n" + config.replace("\r", "")
                     config_path = os.path.join(module_workdir, self.private_config)
                     with open(config_path, "wb") as f:

gns3server/modules/iou/__init__.py

@@ -91,3 +91,9 @@ class IOU(BaseManager):
         """
 
         return os.path.join("iou", "device-{}".format(legacy_vm_id))
+
+    def get_images_directory(self):
+        """
+        Return the full path of the images directory on disk
+        """
+        return os.path.join(os.path.expanduser(self.config.get_section_config("Server").get("images_path", "~/GNS3/images")), "IOU")

gns3server/modules/iou/iou_vm.py

@@ -61,25 +61,9 @@ class IOUVM(BaseVM):
     :param project: Project instance
     :param manager: Manager instance
     :param console: TCP console port
-    :params ethernet_adapters: number of ethernet adapters
-    :params serial_adapters: number of serial adapters
-    :params ram: amount of RAM in MB
-    :params nvram: amount of NVRAM in KB
-    :params l1_keepalives: always keep the Ethernet interfaces up
-    :params initial_config: content of the initial configuration file
-    :params iourc_content: content of the iourc file if no licence is installed on the machine
     """
 
-    def __init__(self, name, vm_id, project, manager,
-                 console=None,
-                 ram=None,
-                 nvram=None,
-                 use_default_iou_values=None,
-                 ethernet_adapters=None,
-                 serial_adapters=None,
-                 l1_keepalives=None,
-                 initial_config=None,
-                 iourc_content=None):
+    def __init__(self, name, vm_id, project, manager, console=None):
 
         super().__init__(name, vm_id, project, manager, console=console)
 
@@ -94,17 +78,13 @@ class IOUVM(BaseVM):
         # IOU settings
         self._ethernet_adapters = []
         self._serial_adapters = []
-        self.ethernet_adapters = 2 if ethernet_adapters is None else ethernet_adapters  # one adapter = 4 interfaces
-        self.serial_adapters = 2 if serial_adapters is None else serial_adapters  # one adapter = 4 interfaces
-        self._use_default_iou_values = True if use_default_iou_values is None else use_default_iou_values  # for RAM & NVRAM values
-        self._nvram = 128 if nvram is None else nvram  # Kilobytes
+        self.ethernet_adapters = 2  # one adapter = 4 interfaces
+        self.serial_adapters = 2  # one adapter = 4 interfaces
+        self._use_default_iou_values = True  # for RAM & NVRAM values
+        self._nvram = 128  # Kilobytes
         self._initial_config = ""
-        self._ram = 256 if ram is None else ram  # Megabytes
-        self._l1_keepalives = False if l1_keepalives is None else l1_keepalives  # used to overcome the always-up Ethernet interfaces (not supported by all IOSes).
-
-        self.iourc_content = iourc_content
-        if initial_config is not None:
-            self.initial_config = initial_config
+        self._ram = 256  # Megabytes
+        self._l1_keepalives = False  # used to overcome the always-up Ethernet interfaces (not supported by all IOSes).
 
     @asyncio.coroutine
     def close(self):
@@ -145,14 +125,7 @@ class IOUVM(BaseVM):
         :param path: path to the IOU image executable
         """
 
-        if not os.path.isabs(path):
-            server_config = self.manager.config.get_section_config("Server")
-            relative_path = os.path.join(os.path.expanduser(server_config.get("images_path", "~/GNS3/images")), path)
-            if not os.path.exists(relative_path):
-                relative_path = os.path.join(os.path.expanduser(server_config.get("images_path", "~/GNS3/images")), "IOU", path)
-            path = relative_path
-
-        self._path = path
+        self._path = self.manager.get_abs_image_path(path)
 
         # In 1.2 users uploaded images to the images roots
         # after the migration their images are inside images/IOU
@@ -236,15 +209,11 @@ class IOUVM(BaseVM):
                        "nvram": self._nvram,
                        "l1_keepalives": self._l1_keepalives,
                        "initial_config": self.relative_initial_config_file,
-                       "use_default_iou_values": self._use_default_iou_values,
-                       "iourc_path": self.iourc_path}
+                       "iourc_path": self.iourc_path,
+                       "use_default_iou_values": self._use_default_iou_values}
 
         # return the relative path if the IOU image is in the images_path directory
-        server_config = self.manager.config.get_section_config("Server")
-        relative_image = os.path.join(os.path.expanduser(server_config.get("images_path", "~/GNS3/images")), "IOU", self.path)
-        if os.path.exists(relative_image):
-            iou_vm_info["path"] = os.path.basename(self.path)
-
+        iou_vm_info["path"] = self.manager.get_relative_image_path(self.path)
         return iou_vm_info
 
     @property
@@ -348,9 +317,9 @@ class IOUVM(BaseVM):
         """
 
         if self.initial_config_file:
-            content = self.initial_config
+            content = self.initial_config_content
             content = content.replace(self._name, new_name)
-            self.initial_config = content
+            self.initial_config_content = content
 
         super(IOUVM, IOUVM).name.__set__(self, new_name)
 
@@ -363,8 +332,8 @@ class IOUVM(BaseVM):
     def iourc_content(self):
 
         try:
-            with open(os.path.join(self.temporary_directory, "iourc")) as f:
-                return f.read()
+            with open(os.path.join(self.temporary_directory, "iourc"), "rb") as f:
+                return f.read().decode("utf-8")
         except OSError:
             return None
 
@@ -374,8 +343,8 @@ class IOUVM(BaseVM):
         if value is not None:
             path = os.path.join(self.temporary_directory, "iourc")
             try:
-                with open(path, "w+") as f:
-                    f.write(value)
+                with open(path, "wb+") as f:
+                    f.write(value.encode("utf-8"))
             except OSError as e:
                 raise IOUError("Could not write the iourc file {}: {}".format(path, e))
 
@@ -403,18 +372,20 @@ class IOUVM(BaseVM):
         Checks for a valid IOU key in the iourc file (paranoid mode).
         """
 
-        license_check = self._manager.config.get_section_config("IOU").getboolean("license_check", False)
-        if license_check:
+        license_check = self._manager.config.get_section_config("IOU").getboolean("license_check", True)
+        if license_check is False:
             return
 
         config = configparser.ConfigParser()
         try:
-            with open(self.iourc_path) as f:
+            with open(self.iourc_path, encoding="utf-8") as f:
                 config.read_file(f)
         except OSError as e:
             raise IOUError("Could not open iourc file {}: {}".format(self.iourc_path, e))
         except configparser.Error as e:
             raise IOUError("Could not parse iourc file {}: {}".format(self.iourc_path, e))
+        except UnicodeDecodeError as e:
+            raise IOUError("Invalid iourc file {}: {}".format(self.iourc_path, e))
         if "license" not in config:
             raise IOUError("License section not found in iourc file {}".format(self.iourc_path))
         hostname = socket.gethostname()
@@ -486,7 +457,7 @@ class IOUVM(BaseVM):
                 log.info("Starting IOU: {}".format(self._command))
                 self._iou_stdout_file = os.path.join(self.working_dir, "iou.log")
                 log.info("Logging to {}".format(self._iou_stdout_file))
-                with open(self._iou_stdout_file, "w") as fd:
+                with open(self._iou_stdout_file, "w", encoding="utf-8") as fd:
                     self._iou_process = yield from asyncio.create_subprocess_exec(*self._command,
                                                                                   stdout=fd,
                                                                                   stderr=subprocess.STDOUT,
@@ -530,7 +501,7 @@ class IOUVM(BaseVM):
             log.info("starting iouyap: {}".format(command))
             self._iouyap_stdout_file = os.path.join(self.working_dir, "iouyap.log")
             log.info("logging to {}".format(self._iouyap_stdout_file))
-            with open(self._iouyap_stdout_file, "w") as fd:
+            with open(self._iouyap_stdout_file, "w", encoding="utf-8") as fd:
                 self._iouyap_process = yield from asyncio.create_subprocess_exec(*command,
                                                                                  stdout=fd,
                                                                                  stderr=subprocess.STDOUT,
@@ -596,7 +567,7 @@ class IOUVM(BaseVM):
             bay_id += 1
 
         try:
-            with open(iouyap_ini, "w") as config_file:
+            with open(iouyap_ini, "w", encoding="utf-8") as config_file:
                 config.write(config_file)
             log.info("IOU {name} [id={id}]: iouyap.ini updated".format(name=self._name,
                                                                        id=self._id))
@@ -618,7 +589,6 @@ class IOUVM(BaseVM):
                 self._ioucon_thread = None
 
             self._terminate_process_iou()
-
             if self._iou_process.returncode is None:
                 try:
                     yield from gns3server.utils.asyncio.wait_for_process_termination(self._iou_process, timeout=3)
@@ -702,7 +672,7 @@ class IOUVM(BaseVM):
 
         netmap_path = os.path.join(self.working_dir, "NETMAP")
         try:
-            with open(netmap_path, "w") as f:
+            with open(netmap_path, "w", encoding="utf-8") as f:
                 for bay in range(0, 16):
                     for unit in range(0, 4):
                         f.write("{iouyap_id}:{bay}/{unit}{iou_id:>5d}:{bay}/{unit}\n".format(iouyap_id=str(self.application_id + 512),
@@ -772,8 +742,8 @@ class IOUVM(BaseVM):
         output = ""
         if self._iou_stdout_file:
             try:
-                with open(self._iou_stdout_file, errors="replace") as file:
-                    output = file.read()
+                with open(self._iou_stdout_file, "rb") as file:
+                    output = file.read().decode("utf-8", errors="replace")
             except OSError as e:
                 log.warn("could not read {}: {}".format(self._iou_stdout_file, e))
         return output
@@ -787,8 +757,8 @@ class IOUVM(BaseVM):
         output = ""
         if self._iouyap_stdout_file:
             try:
-                with open(self._iouyap_stdout_file, errors="replace") as file:
-                    output = file.read()
+                with open(self._iouyap_stdout_file, "rb") as file:
+                    output = file.read().decode("utf-8", errors="replace")
             except OSError as e:
                 log.warn("could not read {}: {}".format(self._iouyap_stdout_file, e))
         return output
@@ -970,7 +940,7 @@ class IOUVM(BaseVM):
             log.warn("could not determine if layer 1 keepalive messages are supported by {}: {}".format(os.path.basename(self._path), e))
 
     @property
-    def initial_config(self):
+    def initial_config_content(self):
         """
         Returns the content of the current initial-config file.
         """
@@ -980,13 +950,13 @@ class IOUVM(BaseVM):
             return None
 
         try:
-            with open(config_file) as f:
-                return f.read()
+            with open(config_file, "rb") as f:
+                return f.read().decode("utf-8", errors="replace")
         except OSError as e:
-            raise IOUError("Can't read configuration file '{}'".format(config_file))
+            raise IOUError("Can't read configuration file '{}': {}".format(config_file, e))
 
-    @initial_config.setter
-    def initial_config(self, initial_config):
+    @initial_config_content.setter
+    def initial_config_content(self, initial_config):
         """
         Update the initial config
 
@@ -994,23 +964,23 @@ class IOUVM(BaseVM):
         """
 
         try:
-            script_file = os.path.join(self.working_dir, "initial-config.cfg")
+            initial_config_path = os.path.join(self.working_dir, "initial-config.cfg")
 
             if initial_config is None:
                 initial_config = ''
 
             # We disallow erasing the initial config file
-            if len(initial_config) == 0 and os.path.exists(script_file):
+            if len(initial_config) == 0 and os.path.exists(initial_config_path):
                 return
 
-            with open(script_file, 'w+') as f:
+            with open(initial_config_path, 'w+', encoding='utf-8') as f:
                 if len(initial_config) == 0:
                     f.write('')
                 else:
                     initial_config = initial_config.replace("%h", self._name)
                     f.write(initial_config)
         except OSError as e:
-            raise IOUError("Can't write initial configuration file '{}': {}".format(script_file, e))
+            raise IOUError("Can't write initial configuration file '{}': {}".format(initial_config_path, e))
 
     @property
     def initial_config_file(self):
@@ -1101,6 +1071,10 @@ class IOUVM(BaseVM):
                                                                                            port_number=port_number))
 
         nio = adapter.get_nio(port_number)
+        if not nio:
+            raise IOUError("NIO {port_number} does not exist in adapter {adapter}".format(adapter=adapter,
+                                                                                          port_number=port_number))
+
         nio.stopPacketCapture()
         log.info('IOU "{name}" [{id}]: stopping packet capture on {adapter_number}/{port_number}'.format(name=self._name,
                                                                                                          id=self._id,

gns3server/modules/port_manager.py

@@ -252,19 +252,14 @@ class PortManager:
         project.record_udp_port(port)
         log.debug("UDP port {} has been reserved".format(port))
 
-    def release_udp_port(self, port, project, force_remove=False):
+    def release_udp_port(self, port, project):
         """
         Release a specific UDP port number
 
         :param port: UDP port number
         :param project: Project instance
-        :param force_remove: Force port removal even on Darwnin
         """
 
-        # A bug with Dynamips on Darwin which doesn't correctly free UDP ports, they are freed only when changing the project
-        if sys.platform.startswith("darwin") and force_remove is False:
-            return
-
         if port in self._used_udp_ports:
             self._used_udp_ports.remove(port)
             project.remove_udp_port(port)

gns3server/modules/project.py

@@ -102,6 +102,7 @@ class Project:
 
         server_config = Config.instance().get_section_config("Server")
         path = os.path.expanduser(server_config.get("projects_path", "~/GNS3/projects"))
+        path = os.path.normpath(path)
         try:
             os.makedirs(path, exist_ok=True)
         except OSError as e:
@@ -365,7 +366,7 @@ class Project:
         for port in self._used_tcp_ports.copy():
             port_manager.release_tcp_port(port, self)
         for port in self._used_udp_ports.copy():
-            port_manager.release_udp_port(port, self, force_remove=True)
+            port_manager.release_udp_port(port, self)
 
     @asyncio.coroutine
     def commit(self):

gns3server/modules/qemu/__init__.py

@@ -30,6 +30,9 @@ from ..base_manager import BaseManager
 from .qemu_error import QemuError
 from .qemu_vm import QemuVM
 
+import logging
+log = logging.getLogger(__name__)
+
 
 class Qemu(BaseManager):
 
@@ -44,7 +47,15 @@ class Qemu(BaseManager):
         """
 
         qemus = []
-        paths = [os.getcwd()] + os.environ["PATH"].split(os.pathsep)
+        paths = []
+        try:
+            paths.append(os.getcwd())
+        except FileNotFoundError:
+            log.warning("The current working directory doesn't exist")
+        if "PATH" in os.environ:
+            paths.extend(os.environ["PATH"].split(os.pathsep))
+        else:
+            log.warning("The PATH environment variable doesn't exist")
         # look for Qemu binaries in the current working directory and $PATH
         if sys.platform.startswith("win"):
             # add specific Windows paths
@@ -67,7 +78,7 @@ class Qemu(BaseManager):
         for path in paths:
             try:
                 for f in os.listdir(path):
-                    if (f.startswith("qemu-system") or f == "qemu" or f == "qemu.exe") and \
+                    if (f.startswith("qemu-system") or f.startswith("qemu-kvm") 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)
@@ -112,3 +123,9 @@ class Qemu(BaseManager):
         """
 
         return os.path.join("qemu", "vm-{}".format(legacy_vm_id))
+
+    def get_images_directory(self):
+        """
+        Return the full path of the images directory on disk
+        """
+        return os.path.join(os.path.expanduser(self.config.get_section_config("Server").get("images_path", "~/GNS3/images")), "QEMU")

gns3server/modules/qemu/qemu_vm.py

@@ -32,6 +32,7 @@ import socket
 from .qemu_error import QemuError
 from ..adapters.ethernet_adapter import EthernetAdapter
 from ..nios.nio_udp import NIOUDP
+from ..nios.nio_tap import NIOTAP
 from ..base_vm import BaseVM
 from ...schemas.qemu import QEMU_OBJECT_SCHEMA
 
@@ -148,14 +149,10 @@ class QemuVM(BaseVM):
         :param hda_disk_image: QEMU hda disk image path
         """
 
-        if not os.path.isabs(hda_disk_image):
-            server_config = self.manager.config.get_section_config("Server")
-            hda_disk_image = os.path.join(os.path.expanduser(server_config.get("images_path", "~/GNS3/images")), "QEMU", hda_disk_image)
-
+        self._hda_disk_image = self.manager.get_abs_image_path(hda_disk_image)
         log.info('QEMU VM "{name}" [{id}] has set the QEMU hda disk image path to {disk_image}'.format(name=self._name,
                                                                                                        id=self._id,
-                                                                                                       disk_image=hda_disk_image))
-        self._hda_disk_image = hda_disk_image
+                                                                                                       disk_image=self._hda_disk_image))
 
     @property
     def hdb_disk_image(self):
@@ -175,14 +172,10 @@ class QemuVM(BaseVM):
         :param hdb_disk_image: QEMU hdb disk image path
         """
 
-        if not os.path.isabs(hdb_disk_image):
-            server_config = self.manager.config.get_section_config("Server")
-            hdb_disk_image = os.path.join(os.path.expanduser(server_config.get("images_path", "~/GNS3/images")), "QEMU", hdb_disk_image)
-
+        self._hdb_disk_image = self.manager.get_abs_image_path(hdb_disk_image)
         log.info('QEMU VM "{name}" [{id}] has set the QEMU hdb disk image path to {disk_image}'.format(name=self._name,
                                                                                                        id=self._id,
-                                                                                                       disk_image=hdb_disk_image))
-        self._hdb_disk_image = hdb_disk_image
+                                                                                                       disk_image=self._hdb_disk_image))
 
     @property
     def hdc_disk_image(self):
@@ -202,14 +195,10 @@ class QemuVM(BaseVM):
         :param hdc_disk_image: QEMU hdc disk image path
         """
 
-        if not os.path.isabs(hdc_disk_image):
-            server_config = self.manager.config.get_section_config("Server")
-            hdc_disk_image = os.path.join(os.path.expanduser(server_config.get("images_path", "~/GNS3/images")), "QEMU", hdc_disk_image)
-
+        self._hdc_disk_image = self.manager.get_abs_image_path(hdc_disk_image)
         log.info('QEMU VM "{name}" [{id}] has set the QEMU hdc disk image path to {disk_image}'.format(name=self._name,
                                                                                                        id=self._id,
-                                                                                                       disk_image=hdc_disk_image))
-        self._hdc_disk_image = hdc_disk_image
+                                                                                                       disk_image=self._hdc_disk_image))
 
     @property
     def hdd_disk_image(self):
@@ -229,14 +218,11 @@ class QemuVM(BaseVM):
         :param hdd_disk_image: QEMU hdd disk image path
         """
 
-        if not os.path.isabs(hdd_disk_image):
-            server_config = self.manager.config.get_section_config("Server")
-            hdd_disk_image = os.path.join(os.path.expanduser(server_config.get("images_path", "~/GNS3/images")), "QEMU", hdd_disk_image)
-
+        self._hdd_disk_image = hdd_disk_image
+        self._hdd_disk_image = self.manager.get_abs_image_path(hdd_disk_image)
         log.info('QEMU VM "{name}" [{id}] has set the QEMU hdd disk image path to {disk_image}'.format(name=self._name,
                                                                                                        id=self._id,
-                                                                                                       disk_image=hdd_disk_image))
-        self._hdd_disk_image = hdd_disk_image
+                                                                                                       disk_image=self._hdd_disk_image))
 
     @property
     def adapters(self):
@@ -589,7 +575,7 @@ class QemuVM(BaseVM):
                 log.info("Starting QEMU: {}".format(self._command))
                 self._stdout_file = os.path.join(self.working_dir, "qemu.log")
                 log.info("logging to {}".format(self._stdout_file))
-                with open(self._stdout_file, "w") as fd:
+                with open(self._stdout_file, "w", encoding="utf-8") as fd:
                     self._process = yield from asyncio.create_subprocess_exec(*self._command,
                                                                               stdout=fd,
                                                                               stderr=subprocess.STDOUT,
@@ -659,7 +645,7 @@ class QemuVM(BaseVM):
                             break
                         for expect in expected:
                             if expect in line:
-                                result = line.decode().strip()
+                                result = line.decode("utf-8").strip()
                                 break
                 except EOFError as e:
                     log.warn("Could not read from QEMU monitor: {}".format(e))
@@ -778,9 +764,9 @@ class QemuVM(BaseVM):
 
         adapter.add_nio(0, nio)
         log.info('QEMU VM "{name}" [{id}]: {nio} added to adapter {adapter_number}'.format(name=self._name,
-                                                                                          id=self._id,
-                                                                                          nio=nio,
-                                                                                          adapter_number=adapter_number))
+                                                                                           id=self._id,
+                                                                                           nio=nio,
+                                                                                           adapter_number=adapter_number))
 
     @asyncio.coroutine
     def adapter_remove_nio_binding(self, adapter_number):
@@ -832,8 +818,8 @@ class QemuVM(BaseVM):
         output = ""
         if self._stdout_file:
             try:
-                with open(self._stdout_file, errors="replace") as file:
-                    output = file.read()
+                with open(self._stdout_file, "rb") as file:
+                    output = file.read().decode("utf-8", errors="replace")
             except OSError as e:
                 log.warn("Could not read {}: {}".format(self._stdout_file, e))
         return output
@@ -1010,19 +996,25 @@ class QemuVM(BaseVM):
             else:
                 network_options.extend(["-device", "{},mac={},netdev=gns3-{}".format(self._adapter_type, mac, adapter_number)])
             nio = adapter.get_nio(0)
-            if nio and isinstance(nio, NIOUDP):
-                if self._legacy_networking:
-                    network_options.extend(["-net", "udp,vlan={},name=gns3-{},sport={},dport={},daddr={}".format(adapter_number,
-                                                                                                                 adapter_number,
-                                                                                                                 nio.lport,
-                                                                                                                 nio.rport,
-                                                                                                                 nio.rhost)])
-                else:
-                    network_options.extend(["-netdev", "socket,id=gns3-{},udp={}:{},localaddr={}:{}".format(adapter_number,
-                                                                                                            nio.rhost,
-                                                                                                            nio.rport,
-                                                                                                            self._host,
-                                                                                                            nio.lport)])
+            if nio:
+                if isinstance(nio, NIOUDP):
+                    if self._legacy_networking:
+                        network_options.extend(["-net", "udp,vlan={},name=gns3-{},sport={},dport={},daddr={}".format(adapter_number,
+                                                                                                                     adapter_number,
+                                                                                                                     nio.lport,
+                                                                                                                     nio.rport,
+                                                                                                                     nio.rhost)])
+                    else:
+                        network_options.extend(["-netdev", "socket,id=gns3-{},udp={}:{},localaddr={}:{}".format(adapter_number,
+                                                                                                                nio.rhost,
+                                                                                                                nio.rport,
+                                                                                                                self._host,
+                                                                                                                nio.lport)])
+                elif isinstance(nio, NIOTAP):
+                    if self._legacy_networking:
+                        network_options.extend(["-net", "tap,name=gns3-{},ifname={}".format(adapter_number, nio.tap_device)])
+                    else:
+                        network_options.extend(["-netdev", "tap,id=gns3-{},ifname={}".format(adapter_number, nio.tap_device)])
             else:
                 if self._legacy_networking:
                     network_options.extend(["-net", "user,vlan={},name=gns3-{}".format(adapter_number, adapter_number)])
@@ -1068,23 +1060,6 @@ class QemuVM(BaseVM):
         command.extend(self._graphic())
         return command
 
-    def _get_relative_disk_image_path(self, disk_image):
-        """
-        Returns a relative image path if the disk image is in the images directory.
-
-        :param disk_image: path to the disk image
-
-        :returns: relative or full path
-        """
-
-        if disk_image:
-            # return the relative path if the disk image is in the images_path directory
-            server_config = self.manager.config.get_section_config("Server")
-            relative_image = os.path.join(os.path.expanduser(server_config.get("images_path", "~/GNS3/images")), "QEMU", disk_image)
-            if os.path.exists(relative_image):
-                return os.path.basename(disk_image)
-        return disk_image
-
     def __json__(self):
         answer = {
             "project_id": self.project.id,
@@ -1095,11 +1070,11 @@ class QemuVM(BaseVM):
             if field not in answer:
                 answer[field] = getattr(self, field)
 
-        answer["hda_disk_image"] = self._get_relative_disk_image_path(self._hda_disk_image)
-        answer["hdb_disk_image"] = self._get_relative_disk_image_path(self._hdb_disk_image)
-        answer["hdc_disk_image"] = self._get_relative_disk_image_path(self._hdc_disk_image)
-        answer["hdd_disk_image"] = self._get_relative_disk_image_path(self._hdd_disk_image)
-        answer["initrd"] = self._get_relative_disk_image_path(self._initrd)
-        answer["kernel_image"] = self._get_relative_disk_image_path(self._kernel_image)
+        answer["hda_disk_image"] = self.manager.get_relative_image_path(self._hda_disk_image)
+        answer["hdb_disk_image"] = self.manager.get_relative_image_path(self._hdb_disk_image)
+        answer["hdc_disk_image"] = self.manager.get_relative_image_path(self._hdc_disk_image)
+        answer["hdd_disk_image"] = self.manager.get_relative_image_path(self._hdd_disk_image)
+        answer["initrd"] = self.manager.get_relative_image_path(self._initrd)
+        answer["kernel_image"] = self.manager.get_relative_image_path(self._kernel_image)
 
         return answer

gns3server/modules/virtualbox/__init__.py

@@ -41,6 +41,7 @@ class VirtualBox(BaseManager):
 
         super().__init__()
         self._vboxmanage_path = None
+        self._execute_lock = asyncio.Lock()
 
     @property
     def vboxmanage_path(self):
@@ -82,34 +83,76 @@ class VirtualBox(BaseManager):
     @asyncio.coroutine
     def execute(self, subcommand, args, timeout=60):
 
-        vboxmanage_path = self.vboxmanage_path
-        if not vboxmanage_path:
-            vboxmanage_path = self.find_vboxmanage()
-        command = [vboxmanage_path, "--nologo", subcommand]
-        command.extend(args)
-        log.debug("Executing VBoxManage with command: {}".format(command))
-        try:
-            vbox_user = self.config.get_section_config("VirtualBox").get("vbox_user")
-            if vbox_user:
-                # TODO: test & review this part
-                sudo_command = "sudo -i -u {}".format(vbox_user) + " ".join(command)
-                process = yield from asyncio.create_subprocess_shell(sudo_command, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
-            else:
-                process = yield from asyncio.create_subprocess_exec(*command, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
-        except (OSError, subprocess.SubprocessError) as e:
-            raise VirtualBoxError("Could not execute VBoxManage: {}".format(e))
+        # We use a lock prevent parallel execution due to strange errors
+        # reported by a user and reproduced by us.
+        # https://github.com/GNS3/gns3-gui/issues/261
+        with (yield from self._execute_lock):
+            vboxmanage_path = self.vboxmanage_path
+            if not vboxmanage_path:
+                vboxmanage_path = self.find_vboxmanage()
+            command = [vboxmanage_path, "--nologo", subcommand]
+            command.extend(args)
+            log.debug("Executing VBoxManage with command: {}".format(command))
+            try:
+                vbox_user = self.config.get_section_config("VirtualBox").get("vbox_user")
+                if vbox_user:
+                    # TODO: test & review this part
+                    sudo_command = "sudo -i -u {}".format(vbox_user) + " ".join(command)
+                    process = yield from asyncio.create_subprocess_shell(sudo_command, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
+                else:
+                    process = yield from asyncio.create_subprocess_exec(*command, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
+            except (OSError, subprocess.SubprocessError) as e:
+                raise VirtualBoxError("Could not execute VBoxManage: {}".format(e))
 
-        try:
-            stdout_data, stderr_data = yield from asyncio.wait_for(process.communicate(), timeout=timeout)
-        except asyncio.TimeoutError:
-            raise VirtualBoxError("VBoxManage has timed out after {} seconds!".format(timeout))
+            try:
+                stdout_data, stderr_data = yield from asyncio.wait_for(process.communicate(), timeout=timeout)
+            except asyncio.TimeoutError:
+                raise VirtualBoxError("VBoxManage has timed out after {} seconds!".format(timeout))
 
-        if process.returncode:
-            # only the first line of the output is useful
-            vboxmanage_error = stderr_data.decode("utf-8", errors="ignore")
-            raise VirtualBoxError("VirtualBox has returned an error: {}".format(vboxmanage_error))
+            if process.returncode:
+                vboxmanage_error = stderr_data.decode("utf-8", errors="ignore")
+                raise VirtualBoxError("VirtualBox has returned an error: {}".format(vboxmanage_error))
 
-        return stdout_data.decode("utf-8", errors="ignore").splitlines()
+            return stdout_data.decode("utf-8", errors="ignore").splitlines()
+
+    @asyncio.coroutine
+    def _find_inaccessible_hdd_files(self):
+        """
+        Finds inaccessible disk files (to clean up the VirtualBox media manager)
+        """
+
+        hdds = []
+        properties = yield from self.execute("list", ["hdds"])
+        flag_inaccessible = False
+        for prop in properties:
+            try:
+                name, value = prop.split(':', 1)
+            except ValueError:
+                continue
+            if name.strip() == "State" and value.strip() == "inaccessible":
+                flag_inaccessible = True
+            if flag_inaccessible and name.strip() == "Location":
+                hdds.append(value.strip())
+                flag_inaccessible = False
+        return reversed(hdds)
+
+    @asyncio.coroutine
+    def project_closed(self, project):
+        """
+        Called when a project is closed.
+
+        :param project: Project instance
+        """
+
+        yield from super().project_closed(project)
+        hdd_files_to_close = yield from self._find_inaccessible_hdd_files()
+        for hdd_file in hdd_files_to_close:
+            log.info("Closing VirtualBox VM disk file {}".format(os.path.basename(hdd_file)))
+            try:
+                yield from self.execute("closemedium", ["disk", hdd_file])
+            except VirtualBoxError as e:
+                log.warning("Could not close VirtualBox VM disk file {}: {error}".format(os.path.basename(hdd_file), e))
+                continue
 
     @asyncio.coroutine
     def get_list(self):
@@ -128,6 +171,7 @@ class VirtualBox(BaseManager):
             if not extra_data[0].strip() == "Value: yes":
                 # get the amount of RAM
                 info_results = yield from self.execute("showvminfo", [vmname, "--machinereadable"])
+                ram = 0
                 for info in info_results:
                     try:
                         name, value = info.split('=', 1)

gns3server/modules/virtualbox/virtualbox_vm.py

@@ -105,9 +105,10 @@ class VirtualBoxVM(BaseVM):
 
         results = yield from self.manager.execute("showvminfo", [self._vmname, "--machinereadable"])
         for info in results:
-            name, value = info.split('=', 1)
-            if name == "VMState":
-                return value.strip('"')
+            if '=' in info:
+                name, value = info.split('=', 1)
+                if name == "VMState":
+                    return value.strip('"')
         raise VirtualBoxError("Could not get VM state for {}".format(self._vmname))
 
     @asyncio.coroutine
@@ -139,6 +140,8 @@ class VirtualBoxVM(BaseVM):
     def create(self):
 
         yield from self._get_system_properties()
+        if "API version" not in self._system_properties:
+            raise VirtualBoxError("Can't access to VirtualBox API Version")
         if parse_version(self._system_properties["API version"]) < parse_version("4_3"):
             raise VirtualBoxError("The VirtualBox API version is lower than 4.3")
         log.info("VirtualBox VM '{name}' [{id}] created".format(name=self.name, id=self.id))
@@ -206,7 +209,7 @@ class VirtualBoxVM(BaseVM):
             log.info("VirtualBox VM '{name}' [{id}] stopped".format(name=self.name, id=self.id))
             log.debug("Stop result: {}".format(result))
 
-            yield from asyncio.sleep(0.5)  # give some time for VirtualBox to unlock the VM
+            # yield from asyncio.sleep(0.5)  # give some time for VirtualBox to unlock the VM
             try:
                 # deactivate the first serial port
                 yield from self._modify_vm("--uart1 off")
@@ -273,7 +276,7 @@ class VirtualBoxVM(BaseVM):
 
         hdd_info_file = os.path.join(self.working_dir, self._vmname, "hdd_info.json")
         try:
-            with open(hdd_info_file, "r") as f:
+            with open(hdd_info_file, "r", encoding="utf-8") as f:
                 hdd_table = json.load(f)
         except OSError as e:
             raise VirtualBoxError("Could not read HDD info file: {}".format(e))
@@ -351,7 +354,7 @@ class VirtualBoxVM(BaseVM):
             if hdd_table:
                 try:
                     hdd_info_file = os.path.join(self.working_dir, self._vmname, "hdd_info.json")
-                    with open(hdd_info_file, "w") as f:
+                    with open(hdd_info_file, "w", encoding="utf-8") as f:
                         json.dump(hdd_table, f, indent=4)
                 except OSError as e:
                     log.warning("VirtualBox VM '{name}' [{id}] could not write HHD info file: {error}".format(name=self.name,
@@ -583,12 +586,14 @@ class VirtualBoxVM(BaseVM):
         :returns: pipe path (string)
         """
 
-        p = re.compile('\s+', re.UNICODE)
-        pipe_name = p.sub("_", self._vmname)
         if sys.platform.startswith("win"):
-            pipe_name = r"\\.\pipe\VBOX\{}".format(pipe_name)
+            pipe_name = r"\\.\pipe\gns3_vbox\{}".format(self.id)
         else:
-            pipe_name = os.path.join(tempfile.gettempdir(), "pipe_{}".format(pipe_name))
+            pipe_name = os.path.join(tempfile.gettempdir(), "gns3_vbox", "{}".format(self.id))
+            try:
+                os.makedirs(os.path.dirname(pipe_name), exist_ok=True)
+            except OSError as e:
+                raise VirtualBoxError("Could not create the VirtualBox pipe directory: {}".format(e))
         return pipe_name
 
     @asyncio.coroutine

gns3server/modules/vpcs/__init__.py

@@ -62,9 +62,9 @@ class VPCS(BaseManager):
         """
 
         vm = self.get_vm(vm_id)
-        i = self._used_mac_ids[vm_id]
-        self._free_mac_ids[vm.project.id].insert(0, i)
         if vm_id in self._used_mac_ids:
+            i = self._used_mac_ids[vm_id]
+            self._free_mac_ids[vm.project.id].insert(0, i)
             del self._used_mac_ids[vm_id]
         yield from super().close_vm(vm_id, *args, **kwargs)
         return vm

gns3server/modules/vpcs/vpcs_vm.py

@@ -27,6 +27,7 @@ import signal
 import re
 import asyncio
 import shutil
+import gns3server.utils.asyncio
 
 from pkg_resources import parse_version
 from .vpcs_error import VPCSError
@@ -166,8 +167,8 @@ class VPCSVM(BaseVM):
             return None
 
         try:
-            with open(script_file) as f:
-                return f.read()
+            with open(script_file, "rb") as f:
+                return f.read().decode("utf-8", errors="replace")
         except OSError as e:
             raise VPCSError('Cannot read the startup script file "{}": {}'.format(script_file, e))
 
@@ -181,12 +182,12 @@ class VPCSVM(BaseVM):
 
         try:
             script_file = os.path.join(self.working_dir, 'startup.vpc')
-            with open(script_file, 'w+') as f:
+            with open(script_file, "wb+") as f:
                 if startup_script is None:
-                    f.write('')
+                    f.write(b'')
                 else:
                     startup_script = startup_script.replace("%h", self._name)
-                    f.write(startup_script)
+                    f.write(startup_script.encode("utf-8"))
         except OSError as e:
             raise VPCSError('Cannot write the startup script file "{}": {}'.format(self.script_file, e))
 
@@ -226,7 +227,7 @@ class VPCSVM(BaseVM):
                 flags = 0
                 if sys.platform.startswith("win32"):
                     flags = subprocess.CREATE_NEW_PROCESS_GROUP
-                with open(self._vpcs_stdout_file, "w") as fd:
+                with open(self._vpcs_stdout_file, "w", encoding="utf-8") as fd:
                     self._process = yield from asyncio.create_subprocess_exec(*self._command,
                                                                               stdout=fd,
                                                                               stderr=subprocess.STDOUT,
@@ -247,12 +248,13 @@ class VPCSVM(BaseVM):
 
         if self.is_running():
             self._terminate_process()
-            try:
-                yield from asyncio.wait_for(self._process.wait(), timeout=3)
-            except asyncio.TimeoutError:
-                if self._process.returncode is None:
-                    log.warn("VPCS process {} is still running... killing it".format(self._process.pid))
-                    self._process.kill()
+            if self._process.returncode is None:
+                try:
+                    yield from gns3server.utils.asyncio.wait_for_process_termination(self._process, timeout=3)
+                except asyncio.TimeoutError:
+                    if self._process.returncode is None:
+                        log.warn("VPCS process {} is still running... killing it".format(self._process.pid))
+                        self._process.kill()
 
         self._process = None
         self._started = False
@@ -290,8 +292,8 @@ class VPCSVM(BaseVM):
         output = ""
         if self._vpcs_stdout_file:
             try:
-                with open(self._vpcs_stdout_file, errors="replace") as file:
-                    output = file.read()
+                with open(self._vpcs_stdout_file, "rb") as file:
+                    output = file.read().decode("utf-8", errors="replace")
             except OSError as e:
                 log.warn("Could not read {}: {}".format(self._vpcs_stdout_file, e))
         return output
@@ -407,7 +409,7 @@ class VPCSVM(BaseVM):
         command.extend(["-F"])  # option to avoid the daemonization of VPCS
 
         if self.script_file:
-            command.extend([self.script_file])
+            command.extend([os.path.basename(self.script_file)])
         return command
 
     @property

gns3server/schemas/dynamips_vm.py

@@ -284,20 +284,10 @@ VM_UPDATE_SCHEMA = {
             "type": "string",
             "minLength": 1,
         },
-        "startup_config": {
-            "description": "path to the IOS startup configuration file",
-            "type": "string",
-            "minLength": 1,
-        },
         "startup_config_content": {
             "description": "Content of IOS startup configuration file",
             "type": "string",
         },
-        "private_config": {
-            "description": "path to the IOS private configuration file",
-            "type": "string",
-            "minLength": 1,
-        },
         "private_config_content": {
             "description": "Content of IOS private configuration file",
             "type": "string",
@@ -483,147 +473,6 @@ VM_UPDATE_SCHEMA = {
     "additionalProperties": False,
 }
 
-VM_NIO_SCHEMA = {
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "description": "Request validation to add a NIO for a Dynamips 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
-        },
-    },
-    "oneOf": [
-        {"$ref": "#/definitions/UDP"},
-        {"$ref": "#/definitions/Ethernet"},
-        {"$ref": "#/definitions/LinuxEthernet"},
-        {"$ref": "#/definitions/TAP"},
-        {"$ref": "#/definitions/UNIX"},
-        {"$ref": "#/definitions/VDE"},
-        {"$ref": "#/definitions/NULL"},
-    ],
-    "additionalProperties": True,
-    "required": ["type"]
-}
-
 VM_CAPTURE_SCHEMA = {
     "$schema": "http://json-schema.org/draft-04/schema#",
     "description": "Request validation to start a packet capture on a Dynamips VM instance port",

gns3server/schemas/iou.py

@@ -70,8 +70,12 @@ IOU_CREATE_SCHEMA = {
             "description": "Use default IOU values",
             "type": ["boolean", "null"]
         },
+        "initial_config": {
+            "description": "Path to the initial configuration of IOU",
+            "type": ["string", "null"]
+        },
         "initial_config_content": {
-            "description": "Initial configuration of the IOU",
+            "description": "Initial configuration of IOU",
             "type": ["string", "null"]
         },
         "iourc_content": {
@@ -124,7 +128,7 @@ IOU_UPDATE_SCHEMA = {
             "type": ["boolean", "null"]
         },
         "initial_config_content": {
-            "description": "Initial configuration of the IOU",
+            "description": "Initial configuration of IOU",
             "type": ["string", "null"]
         },
         "use_default_iou_values": {
@@ -210,78 +214,6 @@ IOU_OBJECT_SCHEMA = {
     "required": ["name", "vm_id", "console", "project_id", "path", "serial_adapters", "ethernet_adapters", "ram", "nvram", "l1_keepalives", "initial_config", "use_default_iou_values"]
 }
 
-IOU_NIO_SCHEMA = {
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "description": "Request validation to add a NIO for a 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
-        },
-        "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"]
-}
-
 IOU_CAPTURE_SCHEMA = {
     "$schema": "http://json-schema.org/draft-04/schema#",
     "description": "Request validation to start a packet capture on a IOU instance",

gns3server/schemas/nio.py

@@ -0,0 +1,158 @@
+# -*- 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/>.
+
+
+NIO_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to add a NIO for a 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
+        },
+    },
+    "oneOf": [
+        {"$ref": "#/definitions/UDP"},
+        {"$ref": "#/definitions/Ethernet"},
+        {"$ref": "#/definitions/LinuxEthernet"},
+        {"$ref": "#/definitions/TAP"},
+        {"$ref": "#/definitions/UNIX"},
+        {"$ref": "#/definitions/VDE"},
+        {"$ref": "#/definitions/NULL"},
+    ],
+    "additionalProperties": True,
+    "required": ["type"]
+}

gns3server/schemas/qemu.py

@@ -211,62 +211,6 @@ QEMU_UPDATE_SCHEMA = {
     "additionalProperties": False,
 }
 
-QEMU_NIO_SCHEMA = {
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "description": "Request validation to add a NIO for a QEMU 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
-        },
-    },
-    "oneOf": [
-        {"$ref": "#/definitions/UDP"},
-        {"$ref": "#/definitions/Ethernet"},
-    ],
-    "additionalProperties": True,
-    "required": ["type"]
-}
-
 QEMU_OBJECT_SCHEMA = {
     "$schema": "http://json-schema.org/draft-04/schema#",
     "description": "Request validation for a QEMU VM instance",

gns3server/schemas/virtualbox.py

@@ -139,46 +139,6 @@ VBOX_UPDATE_SCHEMA = {
     "additionalProperties": False,
 }
 
-VBOX_NIO_SCHEMA = {
-    "$schema": "http://json-schema.org/draft-04/schema#",
-    "description": "Request validation to add a NIO for a VirtualBox 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
-        },
-    },
-    "oneOf": [
-        {"$ref": "#/definitions/UDP"},
-    ],
-    "additionalProperties": True,
-    "required": ["type"]
-}
-
 VBOX_CAPTURE_SCHEMA = {
     "$schema": "http://json-schema.org/draft-04/schema#",
     "description": "Request validation to start a packet capture on a VirtualBox VM instance port",

gns3server/schemas/vpcs.py

@@ -75,62 +75,6 @@ VPCS_UPDATE_SCHEMA = {
     "additionalProperties": False,
 }
 
-VPCS_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
-        },
-        "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/TAP"},
-    ],
-    "additionalProperties": True,
-    "required": ["type"]
-}
-
 VPCS_OBJECT_SCHEMA = {
     "$schema": "http://json-schema.org/draft-04/schema#",
     "description": "VPCS instance",

gns3server/server.py

@@ -225,6 +225,11 @@ class Server:
 
         try:
             self._loop.run_forever()
+        except OSError as e:
+            # This is to ignore OSError: [WinError 0] The operation completed successfully
+            # exception on Windows.
+            if not sys.platform.startswith("win") and not e.winerror == 0:
+                raise
         except TypeError as e:
             # This is to ignore an asyncio.windows_events exception
             # on Windows when the process gets the SIGBREAK signal

gns3server/utils/interfaces.py

@@ -58,10 +58,11 @@ def get_windows_interfaces():
 
     import win32com.client
     import pywintypes
-    locator = win32com.client.Dispatch("WbemScripting.SWbemLocator")
-    service = locator.ConnectServer(".", "root\cimv2")
+
     interfaces = []
     try:
+        locator = win32com.client.Dispatch("WbemScripting.SWbemLocator")
+        service = locator.ConnectServer(".", "root\cimv2")
         # more info on Win32_NetworkAdapter: http://msdn.microsoft.com/en-us/library/aa394216%28v=vs.85%29.aspx
         for adapter in service.InstancesOf("Win32_NetworkAdapter"):
             if adapter.NetConnectionStatus == 2 or adapter.NetConnectionStatus == 7:
@@ -70,7 +71,7 @@ def get_windows_interfaces():
                 interfaces.append({"id": npf_interface,
                                    "name": adapter.NetConnectionID})
     except (AttributeError, pywintypes.com_error):
-        log.warn("could not use the COM service to retrieve interface info, trying using the registry...")
+        log.warn("Could not use the COM service to retrieve interface info, trying using the registry...")
         return _get_windows_interfaces_from_registry()
 
     return interfaces

gns3server/version.py

@@ -23,5 +23,5 @@
 # or negative for a release candidate or beta (after the base version
 # number has been incremented)
 
-__version__ = "1.3.1"
-__version_info__ = (1, 3, 1, 0)
+__version__ = "1.3.2"
+__version_info__ = (1, 3, 2, 0)

gns3server/web/logger.py

@@ -78,8 +78,11 @@ class ColouredStreamHandler(logging.StreamHandler):
             self.handleError(record)
 
 
-def init_logger(level, quiet=False):
-    if sys.platform.startswith("win"):
+def init_logger(level, logfile=None, quiet=False):
+    if logfile and len(logfile) > 0:
+        stream_handler = logging.FileHandler(logfile)
+        stream_handler.formatter = ColouredFormatter("{asctime} {levelname} {filename}:{lineno} {message}", "%Y-%m-%d %H:%M:%S", "{")
+    elif sys.platform.startswith("win"):
         stream_handler = logging.StreamHandler(sys.stdout)
         stream_handler.formatter = ColouredFormatter("{asctime} {levelname} {filename}:{lineno} {message}", "%Y-%m-%d %H:%M:%S", "{")
     else:

gns3server/web/response.py

@@ -30,10 +30,11 @@ renderer = jinja2.Environment(loader=jinja2.PackageLoader('gns3server', 'templat
 
 class Response(aiohttp.web.Response):
 
-    def __init__(self, route=None, output_schema=None, headers={}, **kwargs):
+    def __init__(self, request=None, route=None, output_schema=None, headers={}, **kwargs):
 
         self._route = route
         self._output_schema = output_schema
+        self._request = request
         headers['X-Route'] = self._route
         headers['Server'] = "Python/{0[0]}.{0[1]} GNS3/{1}".format(sys.version_info, __version__)
         super().__init__(headers=headers, **kwargs)
@@ -70,6 +71,7 @@ class Response(aiohttp.web.Response):
         """
         template = renderer.get_template(template_filename)
         kwargs["gns3_version"] = __version__
+        kwargs["gns3_host"] = self._request.host
         self.html(template.render(**kwargs))
 
     def json(self, answer):

gns3server/web/route.py

@@ -120,7 +120,7 @@ class Route(object):
 
                 # Non API call
                 if api_version is None:
-                    response = Response(route=route, output_schema=output_schema)
+                    response = Response(request=request, route=route, output_schema=output_schema)
                     yield from func(request, response)
                     return response
 
@@ -131,39 +131,39 @@ class Route(object):
                     record_file = server_config.get("record")
                     if record_file:
                         try:
-                            with open(record_file, "a") as f:
+                            with open(record_file, "a", encoding="utf-8") as f:
                                 f.write("curl -X {} 'http://{}{}' -d '{}'".format(request.method, request.host, request.path_qs, json.dumps(request.json)))
                                 f.write("\n")
                         except OSError as e:
                             log.warn("Could not write to the record file {}: {}".format(record_file, e))
-                    response = Response(route=route, output_schema=output_schema)
+                    response = Response(request=request, route=route, output_schema=output_schema)
                     yield from func(request, response)
                 except aiohttp.web.HTTPBadRequest as e:
-                    response = Response(route=route)
+                    response = Response(request=request, route=route)
                     response.set_status(e.status)
                     response.json({"message": e.text, "status": e.status, "path": route, "request": request.json})
                 except aiohttp.web.HTTPException as e:
-                    response = Response(route=route)
+                    response = Response(request=request, route=route)
                     response.set_status(e.status)
                     response.json({"message": e.text, "status": e.status})
                 except VMError as e:
                     log.error("VM error detected: {type}".format(type=type(e)), exc_info=1)
-                    response = Response(route=route)
+                    response = Response(request=request, route=route)
                     response.set_status(409)
                     response.json({"message": str(e), "status": 409})
                 except asyncio.futures.CancelledError as e:
                     log.error("Request canceled")
-                    response = Response(route=route)
+                    response = Response(request=request, route=route)
                     response.set_status(408)
                     response.json({"message": "Request canceled", "status": 408})
                 except aiohttp.ClientDisconnectedError:
                     log.error("Client disconnected")
-                    response = Response(route=route)
+                    response = Response(request=request, route=route)
                     response.set_status(408)
                     response.json({"message": "Client disconnected", "status": 408})
                 except Exception as e:
                     log.error("Uncaught exception detected: {type}".format(type=type(e)), exc_info=1)
-                    response = Response(route=route)
+                    response = Response(request=request, route=route)
                     response.set_status(500)
                     CrashReport.instance().capture_exception(request)
                     exc_type, exc_value, exc_tb = sys.exc_info()

init/gns3.conf.upstart

@@ -0,0 +1,19 @@
+description "GNS3 server"
+author      "GNS3 Team"
+
+start on filesystem or runlevel [2345]
+stop on shutdown
+
+script
+    echo $$ > /var/run/gns3.pid
+    exec start-stop-daemon --start -c gns3 --exec /usr/local/bin/gns3server --log /var/log/gns3.log
+end script
+
+pre-start script
+    echo "[`date`] GNS3 Starting" >> /var/log/gns3.log
+end script
+
+pre-stop script
+    rm /var/run/gns3.pid
+    echo "[`date`] GNS3 Stopping" >> /var/log/gns3.log
+end script

tests/handlers/api/test_iou.py

@@ -18,10 +18,14 @@
 import pytest
 import os
 import stat
+import sys
+import uuid
 
 from tests.utils import asyncio_patch
 from unittest.mock import patch, MagicMock, PropertyMock
 
+pytestmark = pytest.mark.skipif(sys.platform.startswith("win"), reason="Not supported on Windows")
+
 
 @pytest.fixture
 def fake_iou_bin(tmpdir):
@@ -91,11 +95,32 @@ def test_iou_create_with_params(server, project, base_params):
 
     assert "initial-config.cfg" in response.json["initial_config"]
     with open(initial_config_file(project, response.json)) as f:
-        assert f.read() == params["initial_config_content"]
+        assert f.read() == "hostname test"
 
     assert "iourc" in response.json["iourc_path"]
 
 
+def test_iou_create_initial_config_already_exist(server, project, base_params):
+    """We don't erase an initial config if already exist at project creation"""
+
+    vm_id = str(uuid.uuid4())
+    initial_config_file_path = initial_config_file(project, {'vm_id': vm_id})
+    with open(initial_config_file_path, 'w+') as f:
+        f.write("echo hello")
+
+    params = base_params
+    params["vm_id"] = vm_id
+    params["initial_config_content"] = "hostname test"
+
+    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 "initial-config.cfg" in response.json["initial_config"]
+    with open(initial_config_file(project, response.json)) as f:
+        assert f.read() == "echo hello"
+
+
 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

tests/handlers/api/test_qemu.py

@@ -150,10 +150,7 @@ def test_qemu_nio_create_ethernet(server, vm):
                                                                                                                                                      "ethernet_device": "eth0",
                                                                                                                                                      },
                            example=True)
-    assert response.status == 201
-    assert response.route == "/projects/{project_id}/qemu/vms/{vm_id}/adapters/{adapter_number:\d+}/ports/{port_number:\d+}/nio"
-    assert response.json["type"] == "nio_generic_ethernet"
-    assert response.json["ethernet_device"] == "eth0"
+    assert response.status == 409
 
 
 def test_qemu_delete_nio(server, vm):

tests/modules/dynamips/test_dynamips_manager.py

@@ -18,6 +18,7 @@
 
 import pytest
 import tempfile
+import sys
 
 from gns3server.modules.dynamips import Dynamips
 from gns3server.modules.dynamips.dynamips_error import DynamipsError
@@ -36,7 +37,7 @@ def test_vm_invalid_dynamips_path(manager):
         with pytest.raises(DynamipsError):
             manager.find_dynamips()
 
-
+@pytest.mark.skipif(sys.platform.startswith("win"), reason="Not supported by Windows")
 def test_vm_non_executable_dynamips_path(manager):
     tmpfile = tempfile.NamedTemporaryFile()
     with patch("gns3server.config.Config.get_section_config", return_value={"dynamips_path": tmpfile.name}):

tests/modules/iou/test_iou_manager.py

@@ -17,14 +17,29 @@
 
 
 import pytest
+from unittest.mock import patch
 import uuid
+import os
+import sys
 
+pytestmark = pytest.mark.skipif(sys.platform.startswith("win"), reason="Not supported on Windows")
+
+if not sys.platform.startswith("win"):
+    from gns3server.modules.iou import IOU
+    from gns3server.modules.iou.iou_error import IOUError
 
-from gns3server.modules.iou import IOU
-from gns3server.modules.iou.iou_error import IOUError
 from gns3server.modules.project_manager import ProjectManager
 
 
+@pytest.fixture(scope="function")
+def iou(port_manager):
+    # Cleanup the IOU object
+    IOU._instance = None
+    iou = IOU.instance()
+    iou.port_manager = port_manager
+    return iou
+
+
 def test_get_application_id(loop, project, port_manager):
     # Cleanup the IOU object
     IOU._instance = None
@@ -71,3 +86,8 @@ def test_get_application_id_no_id_available(loop, project, port_manager):
             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
+
+
+def test_get_images_directory(iou, tmpdir):
+    with patch("gns3server.config.Config.get_section_config", return_value={"images_path": str(tmpdir)}):
+        assert iou.get_images_directory() == str(tmpdir / "IOU")

tests/modules/iou/test_iou_vm.py

@@ -21,13 +21,19 @@ import asyncio
 import os
 import stat
 import socket
+import sys
 from tests.utils import asyncio_patch
 
 
 from unittest.mock import patch, MagicMock, PropertyMock
-from gns3server.modules.iou.iou_vm import IOUVM
-from gns3server.modules.iou.iou_error import IOUError
-from gns3server.modules.iou import IOU
+
+pytestmark = pytest.mark.skipif(sys.platform.startswith("win"), reason="Not supported on Windows")
+
+if not sys.platform.startswith("win"):
+    from gns3server.modules.iou.iou_vm import IOUVM
+    from gns3server.modules.iou.iou_error import IOUError
+    from gns3server.modules.iou import IOU
+
 from gns3server.config import Config
 
 
@@ -81,10 +87,11 @@ def test_vm(project, manager):
     assert vm.id == "00010203-0405-0607-0809-0a0b0c0d0e0f"
 
 
-def test_vm_initial_config(project, manager):
-    vm = IOUVM("test", "00010203-0405-0607-0808-0a0b0c0d0e0f", project, manager, initial_config="hostname %h")
+def test_vm_initial_config_content(project, manager):
+    vm = IOUVM("test", "00010203-0405-0607-0808-0a0b0c0d0e0f", project, manager)
+    vm.initial_config_content = "hostname %h"
     assert vm.name == "test"
-    assert vm.initial_config == "hostname test"
+    assert vm.initial_config_content == "hostname test"
     assert vm.id == "00010203-0405-0607-0808-0a0b0c0d0e0f"
 
 
@@ -286,10 +293,10 @@ def test_update_initial_config_empty(vm):
         assert f.read() == content
 
 
-def test_update_initial_config_h(vm):
+def test_update_initial_config_content_hostname(vm):
     content = "hostname %h\n"
     vm.name = "pc1"
-    vm.initial_config = content
+    vm.initial_config_content = content
     with open(vm.initial_config_file) as f:
         assert f.read() == "hostname pc1\n"
 

tests/modules/qemu/test_qemu_manager.py

@@ -18,6 +18,7 @@
 import os
 import stat
 import asyncio
+import sys
 
 from gns3server.modules.qemu import Qemu
 from tests.utils import asyncio_patch
@@ -27,12 +28,15 @@ def test_get_qemu_version(loop):
 
     with asyncio_patch("gns3server.modules.qemu.subprocess_check_output", return_value="QEMU emulator version 2.2.0, Copyright (c) 2003-2008 Fabrice Bellard") as mock:
         version = loop.run_until_complete(asyncio.async(Qemu._get_qemu_version("/tmp/qemu-test")))
-        assert version == "2.2.0"
+        if sys.platform.startswith("win"):
+            assert version == ""
+        else:
+            assert version == "2.2.0"
 
 
 def test_binary_list(loop):
 
-    files_to_create = ["qemu-system-x86", "qemu-system-x42", "hello"]
+    files_to_create = ["qemu-system-x86", "qemu-system-x42", "qemu-kvm", "hello"]
 
     for file_to_create in files_to_create:
         path = os.path.join(os.environ["PATH"], file_to_create)
@@ -43,11 +47,17 @@ def test_binary_list(loop):
     with asyncio_patch("gns3server.modules.qemu.subprocess_check_output", return_value="QEMU emulator version 2.2.0, Copyright (c) 2003-2008 Fabrice Bellard") as mock:
         qemus = loop.run_until_complete(asyncio.async(Qemu.binary_list()))
 
-        assert {"path": os.path.join(os.environ["PATH"], "qemu-system-x86"), "version": "2.2.0"} in qemus
-        assert {"path": os.path.join(os.environ["PATH"], "qemu-system-x42"), "version": "2.2.0"} in qemus
-        assert {"path": os.path.join(os.environ["PATH"], "hello"), "version": "2.2.0"} not in qemus
+        if sys.platform.startswith("win"):
+            version = ""
+        else:
+            version = "2.2.0"
+
+        assert {"path": os.path.join(os.environ["PATH"], "qemu-system-x86"), "version": version} in qemus
+        assert {"path": os.path.join(os.environ["PATH"], "qemu-kvm"), "version": version} in qemus
+        assert {"path": os.path.join(os.environ["PATH"], "qemu-system-x42"), "version": version} in qemus
+        assert {"path": os.path.join(os.environ["PATH"], "hello"), "version": version} not in qemus
 
 
 def test_get_legacy_vm_workdir():
 
-    assert Qemu.get_legacy_vm_workdir(42, "bla") == "qemu/vm-42"
+    assert Qemu.get_legacy_vm_workdir(42, "bla") == os.path.join("qemu", "vm-42")

tests/modules/qemu/test_qemu_vm.py

@@ -19,6 +19,7 @@ import pytest
 import aiohttp
 import asyncio
 import os
+import sys
 import stat
 import re
 from tests.utils import asyncio_patch
@@ -51,7 +52,10 @@ def fake_qemu_img_binary():
 @pytest.fixture
 def fake_qemu_binary():
 
-    bin_path = os.path.join(os.environ["PATH"], "qemu_x42")
+    if sys.platform.startswith("win"):
+        bin_path = os.path.join(os.environ["PATH"], "qemu_x42.EXE")
+    else:
+        bin_path = os.path.join(os.environ["PATH"], "qemu_x42")
     with open(bin_path, "w+") as f:
         f.write("1")
     os.chmod(bin_path, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
@@ -178,8 +182,9 @@ def test_set_qemu_path(vm, tmpdir, fake_qemu_binary):
         f.write("1")
 
     # Raise because file is not executable
-    with pytest.raises(QemuError):
-        vm.qemu_path = path
+    if not sys.platform.startswith("win"):
+        with pytest.raises(QemuError):
+            vm.qemu_path = path
 
     os.chmod(path, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
 
@@ -204,6 +209,7 @@ def test_disk_options(vm, loop, fake_qemu_img_binary):
         assert args == (fake_qemu_img_binary, "create", "-f", "qcow2", os.path.join(vm.working_dir, "flash.qcow2"), "256M")
 
 
+@pytest.mark.skipif(sys.platform.startswith("win"), reason="Not supported on Windows")
 def test_set_process_priority(vm, loop, fake_qemu_img_binary):
 
     with asyncio_patch("asyncio.create_subprocess_exec", return_value=MagicMock()) as process:
@@ -273,7 +279,7 @@ def test_build_command(vm, loop, fake_qemu_binary, port_manager):
                 "user,id=gns3-0"
             ]
 
-
+@pytest.mark.skipif(sys.platform.startswith("win"), reason="Not supported on Windows")
 def test_build_command_without_display(vm, loop, fake_qemu_binary):
 
     os.environ["DISPLAY"] = ""
@@ -282,7 +288,9 @@ def test_build_command_without_display(vm, loop, fake_qemu_binary):
         assert "-nographic" in cmd
 
 
-def test_build_command_witht_invalid_options(vm, loop, fake_qemu_binary):
+# Windows accept this kind of mistake
+@pytest.mark.skipif(sys.platform.startswith("win"), reason="Not supported on Windows")
+def test_build_command_with_invalid_options(vm, loop, fake_qemu_binary):
 
     vm.options = "'test"
     with pytest.raises(QemuError):

tests/modules/test_manager.py

@@ -22,6 +22,15 @@ from unittest.mock import patch
 
 
 from gns3server.modules.vpcs import VPCS
+from gns3server.modules.qemu import Qemu
+
+
+@pytest.fixture(scope="function")
+def qemu(port_manager):
+    Qemu._instance = None
+    qemu = Qemu.instance()
+    qemu.port_manager = port_manager
+    return qemu
 
 
 def test_create_vm_new_topology(loop, project, port_manager):
@@ -82,3 +91,33 @@ def test_create_vm_old_topology(loop, project, tmpdir, port_manager):
         vm_dir = os.path.join(project_dir, "project-files", "vpcs", vm.id)
         with open(os.path.join(vm_dir, "startup.vpc")) as f:
             assert f.read() == "1"
+
+
+def test_get_abs_image_path(qemu, tmpdir):
+    os.makedirs(str(tmpdir / "QEMU"))
+    path1 = str(tmpdir / "test1.bin")
+    open(path1, 'w+').close()
+
+    path2 = str(tmpdir / "QEMU" / "test2.bin")
+    open(path2, 'w+').close()
+
+    with patch("gns3server.config.Config.get_section_config", return_value={"images_path": str(tmpdir)}):
+        assert qemu.get_abs_image_path(path1) == path1
+        assert qemu.get_abs_image_path(path2) == path2
+        assert qemu.get_abs_image_path("test2.bin") == path2
+        assert qemu.get_abs_image_path("../test1.bin") == path1
+
+
+def test_get_relative_image_path(qemu, tmpdir):
+    os.makedirs(str(tmpdir / "QEMU"))
+    path1 = str(tmpdir / "test1.bin")
+    open(path1, 'w+').close()
+
+    path2 = str(tmpdir / "QEMU" / "test2.bin")
+    open(path2, 'w+').close()
+
+    with patch("gns3server.config.Config.get_section_config", return_value={"images_path": str(tmpdir)}):
+        assert qemu.get_relative_image_path(path1) == path1
+        assert qemu.get_relative_image_path(path2) == "test2.bin"
+        assert qemu.get_relative_image_path("test2.bin") == "test2.bin"
+        assert qemu.get_relative_image_path("../test1.bin") == path1

tests/modules/test_port_manager.py

@@ -39,21 +39,9 @@ def test_reserve_udp_port():
         pm.reserve_udp_port(4242, project)
 
 
-@pytest.mark.skipif(sys.platform == 'darwin', reason="not working on darwin")
 def test_release_udp_port():
     pm = PortManager()
     project = Project()
     pm.reserve_udp_port(4242, project)
     pm.release_udp_port(4242, project)
     pm.reserve_udp_port(4242, project)
-
-
-@pytest.mark.skipif(sys.platform != 'darwin', reason="requires darwin")
-def test_release_darwin_udp_port():
-    """Due to dynamips / darwin bug we didn't free the port"""
-    pm = PortManager()
-    project = Project()
-    pm.reserve_udp_port(4242, project)
-    pm.release_udp_port(4242, project)
-    with pytest.raises(aiohttp.web.HTTPConflict):
-        pm.reserve_udp_port(4242, project)

tests/modules/vpcs/test_vpcs_vm.py

@@ -19,6 +19,7 @@ import pytest
 import aiohttp
 import asyncio
 import os
+import sys
 from tests.utils import asyncio_patch
 
 
@@ -97,9 +98,14 @@ def test_stop(loop, vm):
             loop.run_until_complete(asyncio.async(vm.start()))
             assert vm.is_running()
 
-            loop.run_until_complete(asyncio.async(vm.stop()))
+            with asyncio_patch("gns3server.utils.asyncio.wait_for_process_termination"):
+                loop.run_until_complete(asyncio.async(vm.stop()))
             assert vm.is_running() is False
-            process.terminate.assert_called_with()
+
+            if sys.platform.startswith("win"):
+                process.send_signal.assert_called_with(1)
+            else:
+                process.terminate.assert_called_with()
 
 
 def test_reload(loop, vm):
@@ -117,9 +123,15 @@ def test_reload(loop, vm):
             vm.port_add_nio_binding(0, nio)
             loop.run_until_complete(asyncio.async(vm.start()))
             assert vm.is_running()
-            loop.run_until_complete(asyncio.async(vm.reload()))
+
+            with asyncio_patch("gns3server.utils.asyncio.wait_for_process_termination"):
+                loop.run_until_complete(asyncio.async(vm.reload()))
             assert vm.is_running() is True
-            process.terminate.assert_called_with()
+
+            if sys.platform.startswith("win"):
+                process.send_signal.assert_called_with(1)
+            else:
+                process.terminate.assert_called_with()
 
 
 def test_add_nio_binding_udp(vm):
@@ -135,13 +147,13 @@ def test_add_nio_binding_tap(vm):
         assert nio.tap_device == "test"
 
 
-def test_add_nio_binding_tap_no_privileged_access(vm):
-    with patch("gns3server.modules.base_manager.BaseManager._has_privileged_access", return_value=False):
-        with pytest.raises(aiohttp.web.HTTPForbidden):
-            nio = VPCS.instance().create_nio(vm.vpcs_path, {"type": "nio_tap", "tap_device": "test"})
-            vm.port_add_nio_binding(0, nio)
-    assert vm._ethernet_adapter.ports[0] is None
-
+# def test_add_nio_binding_tap_no_privileged_access(vm):
+#     with patch("gns3server.modules.base_manager.BaseManager._has_privileged_access", return_value=False):
+#         with pytest.raises(aiohttp.web.HTTPForbidden):
+#             nio = VPCS.instance().create_nio(vm.vpcs_path, {"type": "nio_tap", "tap_device": "test"})
+#             vm.port_add_nio_binding(0, nio)
+#     assert vm._ethernet_adapter.ports[0] is None
+#
 
 def test_port_remove_nio_binding(vm):
     nio = VPCS.instance().create_nio(vm.vpcs_path, {"type": "nio_udp", "lport": 4242, "rport": 4243, "rhost": "127.0.0.1"})
@@ -190,8 +202,8 @@ def test_get_startup_script_using_default_script(vm):
     vm._script_file = None
 
     filepath = os.path.join(vm.working_dir, 'startup.vpc')
-    with open(filepath, 'w+') as f:
-        assert f.write(content)
+    with open(filepath, 'wb+') as f:
+        assert f.write(content.encode("utf-8"))
 
     assert vm.startup_script == content
     assert vm.script_file == filepath

tests/utils/test_asyncio.py

@@ -18,6 +18,7 @@
 
 import asyncio
 import pytest
+import sys
 from unittest.mock import MagicMock
 
 from gns3server.utils.asyncio import wait_run_in_executor, subprocess_check_output, wait_for_process_termination
@@ -43,6 +44,7 @@ def test_exception_wait_run_in_executor(loop):
         result = loop.run_until_complete(asyncio.async(exec))
 
 
+@pytest.mark.skipif(sys.platform.startswith("win"), reason="Not supported on Windows")
 def test_subprocess_check_output(loop, tmpdir, restore_original_path):
 
     path = str(tmpdir / "test")