Polish and bump up to version 1.0!

Add secure communication between gui and server 2/2

.travis.yml

@@ -1,14 +1,19 @@
 language: python
 
-python:
-  - "3.3"
-  - "3.4"
+env:
+  - TOX_ENV=py33
+  - TOX_ENV=py34
+
+before_install:
+  - sudo add-apt-repository ppa:gns3/ppa -y
+  - sudo apt-get update -q
 
 install:
-  - "pip install -r requirements.txt --use-mirrors"
-  - "pip install tox"
+  - pip install tox
+  - sudo apt-get install vpcs dynamips
 
-script: "python setup.py test"
+script:
+  - tox -e $TOX_ENV
 
 branches:
   only:

README.rst

@@ -1,7 +1,7 @@
 GNS3-server
 ===========
 
-New GNS3 server repository (alpha stage).
+New GNS3 server repository (beta stage).
 
 The GNS3 server manages emulators such as Dynamips, VirtualBox or Qemu/KVM.
 Clients like the GNS3 GUI controls the server using a JSON-RPC API over Websockets.
@@ -34,4 +34,19 @@ Please use our all-in-one installer.
 Mac OS X
 --------
 
-Please use our DMG package.
+Please use our DMG package for a simple installation.
+
+
+If you want to test the current git version or contribute to the project.
+
+You can follow this instructions with virtualenwrapper: http://virtualenvwrapper.readthedocs.org/
+and homebrew: http://brew.sh/.
+
+.. code:: bash
+
+   brew install python3
+   mkvirtualenv gns3-server --python=/usr/local/bin/python3.4
+   python3 setup.py install
+   gns3server
+
+

cloud-image/create_image.py

@@ -101,8 +101,9 @@ def main():
                                startup_script)
     passwd = uuid.uuid4().hex
     instance.change_password(passwd)
-    # wait for the password change to be processed
-    sleep(POLL_SEC)
+    # wait for the password change to be processed.  Continuing while
+    # a password change is processing will cause image creation to fail.
+    sleep(POLL_SEC*6)
 
     env.host_string = str(instance.accessIPv4)
     env.user = "root"

cloud-image/script_template

@@ -11,9 +11,7 @@ mkdir -p /opt/gns3
 pushd /opt/gns3
 git clone --branch ${git_branch} ${git_url}
 cd gns3-server
-pip3 install tornado
-pip3 install pyzmq
-pip3 install jsonschema
+pip3 install -r dev-requirements.txt
 python3 ./setup.py install
 
 ${rc_local}

gns3dms/__init__.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# __version__ is a human-readable version number.
+
+# __version_info__ is a four-tuple for programmatic comparison. The first
+# three numbers are the components of the version number. The fourth
+# is zero for an official release, positive for a development branch,
+# or negative for a release candidate or beta (after the base version
+# number has been incremented)
+
+from .version import __version__

gns3dms/cloud/base_cloud_ctrl.py

@@ -0,0 +1,179 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+Base cloud controller class.
+
+Base class for interacting with Cloud APIs to create and manage cloud
+instances.
+
+"""
+
+from libcloud.compute.base import NodeAuthSSHKey
+from .exceptions import ItemNotFound, KeyPairExists, MethodNotAllowed
+from .exceptions import OverLimit, BadRequest, ServiceUnavailable
+from .exceptions import Unauthorized, ApiError
+
+
+def parse_exception(exception):
+    """
+    Parse the exception to separate the HTTP status code from the text.
+
+    Libcloud raises many exceptions of the form:
+        Exception("<http status code> <http error> <reponse body>")
+
+    in lieu of raising specific incident-based exceptions.
+
+    """
+
+    e_str = str(exception)
+
+    try:
+        status = int(e_str[0:3])
+        error_text = e_str[3:]
+
+    except ValueError:
+        status = None
+        error_text = e_str
+
+    return status, error_text
+
+
+class BaseCloudCtrl(object):
+
+    """ Base class for interacting with a cloud provider API. """
+
+    http_status_to_exception = {
+        400: BadRequest,
+        401: Unauthorized,
+        404: ItemNotFound,
+        405: MethodNotAllowed,
+        413: OverLimit,
+        500: ApiError,
+        503: ServiceUnavailable
+    }
+
+    def __init__(self, username, api_key):
+        self.username = username
+        self.api_key = api_key
+
+    def _handle_exception(self, status, error_text, response_overrides=None):
+        """ Raise an exception based on the HTTP status. """
+
+        if response_overrides:
+            if status in response_overrides:
+                raise response_overrides[status](error_text)
+
+        raise self.http_status_to_exception[status](error_text)
+
+    def authenticate(self):
+        """ Validate cloud account credentials.  Return boolean. """
+        raise NotImplementedError
+
+    def list_sizes(self):
+        """ Return a list of NodeSize objects. """
+
+        return self.driver.list_sizes()
+
+    def create_instance(self, name, size, image, keypair):
+        """
+        Create a new instance with the supplied attributes.
+
+        Return a Node object.
+
+        """
+
+        auth_key = NodeAuthSSHKey(keypair.public_key)
+
+        try:
+            return self.driver.create_node(
+                name=name,
+                size=size,
+                image=image,
+                auth=auth_key
+            )
+
+        except Exception as e:
+            status, error_text = parse_exception(e)
+
+            if status:
+                self._handle_exception(status, error_text)
+            else:
+                raise e
+
+    def delete_instance(self, instance):
+        """ Delete the specified instance.  Returns True or False. """
+
+        try:
+            return self.driver.destroy_node(instance)
+
+        except Exception as e:
+
+            status, error_text = parse_exception(e)
+
+            if status:
+                self._handle_exception(status, error_text)
+            else:
+                raise e
+
+    def get_instance(self, instance):
+        """ Return a Node object representing the requested instance. """
+
+        for i in self.driver.list_nodes():
+            if i.id == instance.id:
+                return i
+
+        raise ItemNotFound("Instance not found")
+
+    def list_instances(self):
+        """ Return a list of instances in the current region. """
+
+        return self.driver.list_nodes()
+
+    def create_key_pair(self, name):
+        """ Create and return a new Key Pair. """
+
+        response_overrides = {
+            409: KeyPairExists
+        }
+        try:
+            return self.driver.create_key_pair(name)
+
+        except Exception as e:
+            status, error_text = parse_exception(e)
+            if status:
+                self._handle_exception(status, error_text, response_overrides)
+            else:
+                raise e
+
+    def delete_key_pair(self, keypair):
+        """ Delete the keypair. Returns True or False. """
+
+        try:
+            return self.driver.delete_key_pair(keypair)
+
+        except Exception as e:
+            status, error_text = parse_exception(e)
+            if status:
+                self._handle_exception(status, error_text)
+            else:
+                raise e
+
+    def list_key_pairs(self):
+        """ Return a list of Key Pairs. """
+
+        return self.driver.list_key_pairs()

gns3dms/cloud/exceptions.py

@@ -0,0 +1,45 @@
+""" Exception classes for CloudCtrl classes. """
+
+class ApiError(Exception):
+    """ Raised when the server returns 500 Compute Error. """
+    pass
+
+class BadRequest(Exception):
+    """ Raised when the server returns 400 Bad Request. """
+    pass
+
+class ComputeFault(Exception):
+    """ Raised when the server returns 400|500 Compute Fault. """
+    pass
+
+class Forbidden(Exception):
+    """ Raised when the server returns 403 Forbidden. """
+    pass
+
+class ItemNotFound(Exception):
+    """ Raised when the server returns 404 Not Found. """
+    pass
+
+class KeyPairExists(Exception):
+    """ Raised when the server returns 409 Conflict Key pair exists. """
+    pass
+
+class MethodNotAllowed(Exception):
+    """ Raised when the server returns 405 Method Not Allowed. """
+    pass
+
+class OverLimit(Exception):
+    """ Raised when the server returns 413 Over Limit. """
+    pass
+
+class ServerCapacityUnavailable(Exception):
+    """ Raised when the server returns 503 Server Capacity Uavailable. """
+    pass
+
+class ServiceUnavailable(Exception):
+    """ Raised when the server returns 503 Service Unavailable. """
+    pass
+
+class Unauthorized(Exception):
+    """ Raised when the server returns 401 Unauthorized. """
+    pass

gns3dms/cloud/rackspace_ctrl.py

@@ -0,0 +1,225 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+""" Interacts with Rackspace API to create and manage cloud instances. """
+
+from .base_cloud_ctrl import BaseCloudCtrl
+import json
+import requests
+from libcloud.compute.drivers.rackspace import ENDPOINT_ARGS_MAP
+from libcloud.compute.providers import get_driver
+from libcloud.compute.types import Provider
+
+from .exceptions import ItemNotFound, ApiError
+from ..version import __version__
+
+import logging
+log = logging.getLogger(__name__)
+
+RACKSPACE_REGIONS = [{ENDPOINT_ARGS_MAP[k]['region']: k} for k in
+                     ENDPOINT_ARGS_MAP]
+
+GNS3IAS_URL = 'http://localhost:8888'  # TODO find a place for this value
+
+
+class RackspaceCtrl(BaseCloudCtrl):
+
+    """ Controller class for interacting with Rackspace API. """
+
+    def __init__(self, username, api_key):
+        super(RackspaceCtrl, self).__init__(username, api_key)
+
+        # set this up so it can be swapped out with a mock for testing
+        self.post_fn = requests.post
+        self.driver_cls = get_driver(Provider.RACKSPACE)
+
+        self.driver = None
+        self.region = None
+        self.instances = {}
+
+        self.authenticated = False
+        self.identity_ep = \
+            "https://identity.api.rackspacecloud.com/v2.0/tokens"
+
+        self.regions = []
+        self.token = None
+
+    def authenticate(self):
+        """
+        Submit username and api key to API service.
+
+        If authentication is successful, set self.regions and self.token.
+        Return boolean.
+
+        """
+
+        self.authenticated = False
+
+        if len(self.username) < 1:
+            return False
+
+        if len(self.api_key) < 1:
+            return False
+
+        data = json.dumps({
+            "auth": {
+                "RAX-KSKEY:apiKeyCredentials": {
+                    "username": self.username,
+                    "apiKey": self.api_key
+                }
+            }
+        })
+
+        headers = {
+            'Content-type': 'application/json',
+            'Accept': 'application/json'
+        }
+
+        response = self.post_fn(self.identity_ep, data=data, headers=headers)
+
+        if response.status_code == 200:
+
+            api_data = response.json()
+            self.token = self._parse_token(api_data)
+
+            if self.token:
+                self.authenticated = True
+                user_regions = self._parse_endpoints(api_data)
+                self.regions = self._make_region_list(user_regions)
+
+        else:
+            self.regions = []
+            self.token = None
+
+        response.connection.close()
+
+        return self.authenticated
+
+    def list_regions(self):
+        """ Return a list the regions available to the user. """
+
+        return self.regions
+
+    def _parse_endpoints(self, api_data):
+        """
+        Parse the JSON-encoded data returned by the Identity Service API.
+
+        Return a list of regions available for Compute v2.
+
+        """
+
+        region_codes = []
+
+        for ep_type in api_data['access']['serviceCatalog']:
+            if ep_type['name'] == "cloudServersOpenStack" \
+                    and ep_type['type'] == "compute":
+
+                for ep in ep_type['endpoints']:
+                    if ep['versionId'] == "2":
+                        region_codes.append(ep['region'])
+
+        return region_codes
+
+    def _parse_token(self, api_data):
+        """ Parse the token from the JSON-encoded data returned by the API. """
+
+        try:
+            token = api_data['access']['token']['id']
+        except KeyError:
+            return None
+
+        return token
+
+    def _make_region_list(self, region_codes):
+        """
+        Make a list of regions for use in the GUI.
+
+        Returns a list of key-value pairs in the form:
+            <API's Region Name>: <libcloud's Region Name>
+            eg,
+            [
+                {'DFW': 'dfw'}
+                {'ORD': 'ord'},
+                ...
+            ]
+
+        """
+
+        region_list = []
+
+        for ep in ENDPOINT_ARGS_MAP:
+            if ENDPOINT_ARGS_MAP[ep]['region'] in region_codes:
+                region_list.append({ENDPOINT_ARGS_MAP[ep]['region']: ep})
+
+        return region_list
+
+    def set_region(self, region):
+        """ Set self.region and self.driver. Returns True or False. """
+
+        try:
+            self.driver = self.driver_cls(self.username, self.api_key,
+                                          region=region)
+
+        except ValueError:
+            return False
+
+        self.region = region
+        return True
+
+    def _get_shared_images(self, username, region, gns3_version):
+        """
+        Given a GNS3 version, ask gns3-ias to share compatible images
+
+        Response:
+            [{"created_at": "", "schema": "", "status": "", "member_id": "", "image_id": "", "updated_at": ""},]
+            or, if access was already asked
+            [{"image_id": "", "member_id": "", "status": "ALREADYREQUESTED"},]
+        """
+        endpoint = GNS3IAS_URL+"/images/grant_access"
+        params = {
+            "user_id": username,
+            "user_region": region,
+            "gns3_version": gns3_version,
+        }
+        response = requests.get(endpoint, params=params)
+        status = response.status_code
+        if status == 200:
+            return response.json()
+        elif status == 404:
+            raise ItemNotFound()
+        else:
+            raise ApiError("IAS status code: %d" % status)
+
+    def list_images(self):
+        """
+        Return a dictionary containing RackSpace server images
+        retrieved from gns3-ias server
+        """
+        if not (self.username and self.region):
+            return []
+
+        try:
+            response = self._get_shared_images(self.username, self.region, __version__)
+            shared_images = json.loads(response)
+            images = {}
+            for i in shared_images:
+                images[i['image_id']] = i['image_name']
+            return images
+        except ItemNotFound:
+            return []
+        except ApiError as e:
+            log.error('Error while retrieving image list: %s' % e)

gns3dms/main.py

@@ -0,0 +1,401 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# __version__ is a human-readable version number.
+
+# __version_info__ is a four-tuple for programmatic comparison. The first
+# three numbers are the components of the version number. The fourth
+# is zero for an official release, positive for a development branch,
+# or negative for a release candidate or beta (after the base version
+# number has been incremented)
+
+"""
+Monitors communication with the GNS3 client via tmp file. Will terminate the instance if
+communication is lost.
+"""
+
+import os
+import sys
+import time
+import getopt
+import datetime
+import logging
+import signal
+import configparser
+from logging.handlers import *
+from os.path import expanduser
+
+SCRIPT_NAME = os.path.basename(__file__)
+
+#Is the full path when used as an import
+SCRIPT_PATH = os.path.dirname(__file__)
+
+if not SCRIPT_PATH:
+    SCRIPT_PATH = os.path.join(os.path.dirname(os.path.abspath(
+        sys.argv[0])))
+
+
+EXTRA_LIB = "%s/modules" % (SCRIPT_PATH)
+sys.path.append(EXTRA_LIB)
+
+from . import cloud
+from rackspace_cloud import Rackspace
+
+LOG_NAME = "gns3dms"
+log = None
+
+sys.path.append(EXTRA_LIB)
+
+import daemon
+
+my_daemon = None
+
+usage = """
+USAGE: %s
+
+Options:
+
+  -d, --debug         Enable debugging
+  -v, --verbose       Enable verbose logging
+  -h, --help          Display this menu :)
+
+  --cloud_api_key <api_key>  Rackspace API key
+  --cloud_user_name
+
+  --instance_id       ID of the Rackspace instance to terminate
+  --region            Region of instance
+
+  --deadtime          How long in seconds can the communication lose exist before we
+                      shutdown this instance.
+                      Default:
+                      Example --deadtime=3600 (60 minutes)
+
+  --check-interval    Defaults to --deadtime, used for debugging
+
+  --init-wait         Inital wait time, how long before we start pulling the file.
+                      Default: 300 (5 min)
+                      Example --init-wait=300
+
+  --file              The file we monitor for updates
+
+  -k                  Kill previous instance running in background
+  --background        Run in background
+
+""" % (SCRIPT_NAME)
+
+# Parse cmd line options
+def parse_cmd_line(argv):
+    """
+    Parse command line arguments
+
+    argv: Pass in cmd line arguments
+    """
+
+    short_args = "dvhk"
+    long_args = ("debug",
+                    "verbose",
+                    "help",
+                    "cloud_user_name=",
+                    "cloud_api_key=",
+                    "instance_id=",
+                    "region=",
+                    "deadtime=",
+                    "init-wait=",
+                    "check-interval=",
+                    "file=",
+                    "background",
+                    )
+    try:
+        opts, extra_opts = getopt.getopt(argv[1:], short_args, long_args)
+    except getopt.GetoptError as e:
+        print("Unrecognized command line option or missing required argument: %s" %(e))
+        print(usage)
+        sys.exit(2)
+
+    cmd_line_option_list = {}
+    cmd_line_option_list["debug"] = False
+    cmd_line_option_list["verbose"] = True
+    cmd_line_option_list["cloud_user_name"] = None
+    cmd_line_option_list["cloud_api_key"] = None
+    cmd_line_option_list["instance_id"] = None
+    cmd_line_option_list["region"] = None
+    cmd_line_option_list["deadtime"] = 60 * 60 #minutes
+    cmd_line_option_list["check-interval"] = None
+    cmd_line_option_list["init-wait"] = 5 * 60
+    cmd_line_option_list["file"] = None
+    cmd_line_option_list["shutdown"] = False
+    cmd_line_option_list["daemon"] = False
+    cmd_line_option_list['starttime'] = datetime.datetime.now()
+
+    if sys.platform == "linux":
+        cmd_line_option_list['syslog'] = "/dev/log"
+    elif sys.platform == "osx":
+        cmd_line_option_list['syslog'] = "/var/run/syslog"
+    else:
+        cmd_line_option_list['syslog'] = ('localhost',514)
+
+
+    get_gns3secrets(cmd_line_option_list)
+
+    for opt, val in opts:
+        if (opt in ("-h", "--help")):
+            print(usage)
+            sys.exit(0)
+        elif (opt in ("-d", "--debug")):
+            cmd_line_option_list["debug"] = True
+        elif (opt in ("-v", "--verbose")):
+            cmd_line_option_list["verbose"] = True
+        elif (opt in ("--cloud_user_name")):
+            cmd_line_option_list["cloud_user_name"] = val
+        elif (opt in ("--cloud_api_key")):
+            cmd_line_option_list["cloud_api_key"] = val
+        elif (opt in ("--instance_id")):
+            cmd_line_option_list["instance_id"] = val
+        elif (opt in ("--region")):
+            cmd_line_option_list["region"] = val
+        elif (opt in ("--deadtime")):
+            cmd_line_option_list["deadtime"] = int(val)
+        elif (opt in ("--check-interval")):
+            cmd_line_option_list["check-interval"] = int(val)
+        elif (opt in ("--init-wait")):
+            cmd_line_option_list["init-wait"] = int(val)
+        elif (opt in ("--file")):
+            cmd_line_option_list["file"] = val
+        elif (opt in ("-k")):
+            cmd_line_option_list["shutdown"] = True
+        elif (opt in ("--background")):
+            cmd_line_option_list["daemon"] = True
+
+    if cmd_line_option_list["shutdown"] == False:
+
+        if cmd_line_option_list["check-interval"] is None:
+            cmd_line_option_list["check-interval"] = cmd_line_option_list["deadtime"] + 120
+
+        if cmd_line_option_list["cloud_user_name"] is None:
+            print("You need to specify a username!!!!")
+            print(usage)
+            sys.exit(2)
+
+        if cmd_line_option_list["cloud_api_key"] is None:
+            print("You need to specify an apikey!!!!")
+            print(usage)
+            sys.exit(2)
+
+        if cmd_line_option_list["file"] is None:
+            print("You need to specify a file to watch!!!!")
+            print(usage)
+            sys.exit(2)
+
+        if cmd_line_option_list["instance_id"] is None:
+            print("You need to specify an instance_id")
+            print(usage)
+            sys.exit(2)
+
+        if cmd_line_option_list["region"] is None:
+            print("You need to specify a region")
+            print(usage)
+            sys.exit(2)
+
+
+    return cmd_line_option_list
+
+def get_gns3secrets(cmd_line_option_list):
+    """
+    Load cloud credentials from .gns3secrets
+    """
+
+    gns3secret_paths = [
+        os.path.join(os.path.expanduser("~"), '.config', 'GNS3'),
+        SCRIPT_PATH,
+    ]
+
+    config = configparser.ConfigParser()
+
+    for gns3secret_path in gns3secret_paths:
+        gns3secret_file = "%s/cloud.conf" % (gns3secret_path)
+        if os.path.isfile(gns3secret_file):
+            config.read(gns3secret_file)
+
+    try:
+        for key, value in config.items("CLOUD_SERVER"):
+            cmd_line_option_list[key] = value.strip()
+    except configparser.NoSectionError:
+        pass
+
+
+def set_logging(cmd_options):
+    """
+    Setup logging and format output for console and syslog
+
+    Syslog is using the KERN facility
+    """
+    log = logging.getLogger("%s" % (LOG_NAME))
+    log_level = logging.INFO
+    log_level_console = logging.WARNING
+
+    if cmd_options['verbose'] == True:
+        log_level_console = logging.INFO
+
+    if cmd_options['debug'] == True:
+        log_level_console = logging.DEBUG
+        log_level = logging.DEBUG
+
+    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    sys_formatter = logging.Formatter('%(name)s - %(levelname)s - %(message)s')
+
+    console_log = logging.StreamHandler()
+    console_log.setLevel(log_level_console)
+    console_log.setFormatter(formatter)
+
+    syslog_hndlr = SysLogHandler(
+        address=cmd_options['syslog'],
+        facility=SysLogHandler.LOG_KERN
+    )
+
+    syslog_hndlr.setFormatter(sys_formatter)
+
+    log.setLevel(log_level)
+    log.addHandler(console_log)
+    log.addHandler(syslog_hndlr)
+
+    return log
+
+def send_shutdown(pid_file):
+    """
+    Sends the daemon process a kill signal
+    """
+    try:
+        with open(pid_file, 'r') as pidf:
+            pid = int(pidf.readline().strip())
+            pidf.close()
+            os.kill(pid, 15)
+    except:
+        log.info("No running instance found!!!")
+        log.info("Missing PID file: %s" % (pid_file))
+
+
+def _get_file_age(filename):
+    return datetime.datetime.fromtimestamp(
+                os.path.getmtime(filename)
+            )
+
+def monitor_loop(options):
+    """
+    Checks the options["file"] modification time against an interval. If the
+    modification time is too old we terminate the instance.
+    """
+
+    log.debug("Waiting for init-wait to pass: %s" % (options["init-wait"]))
+    time.sleep(options["init-wait"])
+
+    log.info("Starting monitor_loop")
+
+    terminate_attempts = 0
+
+    while options['shutdown'] == False:
+        log.debug("In monitor_loop for : %s" % (
+            datetime.datetime.now() - options['starttime'])
+        )
+
+        file_last_modified = _get_file_age(options["file"])
+        now = datetime.datetime.now()
+
+        delta = now - file_last_modified
+        log.debug("File last updated: %s seconds ago" % (delta.seconds))
+
+        if delta.seconds > options["deadtime"]:
+            log.warning("Deadtime exceeded, terminating instance ...")
+            #Terminate involes many layers of HTTP / API calls, lots of
+            #different errors types could occur here.
+            try:
+                rksp = Rackspace(options)
+                rksp.terminate()
+            except Exception as e:
+                log.critical("Exception during terminate: %s" % (e))
+
+            terminate_attempts+=1
+            log.warning("Termination sent, attempt: %s" % (terminate_attempts))
+            time.sleep(600)
+        else:
+            time.sleep(options["check-interval"])
+
+    log.info("Leaving monitor_loop")
+    log.info("Shutting down")
+
+
+def main():
+
+    global log
+    global my_daemon
+    options = parse_cmd_line(sys.argv)
+    log = set_logging(options)
+
+    def _shutdown(signalnum=None, frame=None):
+        """
+        Handles the SIGINT and SIGTERM event, inside of main so it has access to
+        the log vars.
+        """
+
+        log.info("Received shutdown signal")
+        options["shutdown"] = True
+
+    pid_file = "%s/.gns3dms.pid" % (expanduser("~"))
+
+    if options["shutdown"]:
+        send_shutdown(pid_file)
+        sys.exit(0)
+
+    if options["daemon"]:
+        my_daemon = MyDaemon(pid_file, options)
+
+    # Setup signal to catch Control-C / SIGINT and SIGTERM
+    signal.signal(signal.SIGINT, _shutdown)
+    signal.signal(signal.SIGTERM, _shutdown)
+
+    log.info("Starting ...")
+    log.debug("Using settings:")
+    for key, value in iter(sorted(options.items())):
+        log.debug("%s : %s" % (key, value))
+
+
+    log.debug("Checking file ....")
+    if os.path.isfile(options["file"]) == False:
+        log.critical("File does not exist!!!")
+        sys.exit(1)
+
+    test_acess = _get_file_age(options["file"])
+    if type(test_acess) is not datetime.datetime:
+        log.critical("Can't get file modification time!!!")
+        sys.exit(1)
+
+    if my_daemon:
+        my_daemon.start()
+    else:
+        monitor_loop(options)
+
+
+class MyDaemon(daemon.daemon):
+    def run(self):
+        monitor_loop(self.options)
+
+
+
+if __name__ == "__main__":
+    result = main()
+    sys.exit(result)
+
+

gns3dms/modules/__init__.py

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# __version__ is a human-readable version number.
+
+# __version_info__ is a four-tuple for programmatic comparison. The first
+# three numbers are the components of the version number. The fourth
+# is zero for an official release, positive for a development branch,
+# or negative for a release candidate or beta (after the base version
+# number has been incremented)

gns3dms/modules/daemon.py

@@ -0,0 +1,138 @@
+"""Generic linux daemon base class for python 3.x."""
+
+import sys, os, time, atexit, signal
+
+class daemon:
+    """A generic daemon class.
+
+    Usage: subclass the daemon class and override the run() method."""
+
+    def __init__(self, pidfile, options):
+        self.pidfile = pidfile
+        self.options = options
+
+    def daemonize(self):
+        """Deamonize class. UNIX double fork mechanism."""
+
+        try:
+            pid = os.fork()
+            if pid > 0:
+                # exit first parent
+                sys.exit(0)
+        except OSError as err:
+            sys.stderr.write('fork #1 failed: {0}\n'.format(err))
+            sys.exit(1)
+
+        # decouple from parent environment
+        os.chdir('/')
+        os.setsid()
+        os.umask(0)
+
+        # do second fork
+        try:
+            pid = os.fork()
+            if pid > 0:
+
+                # exit from second parent
+                sys.exit(0)
+        except OSError as err:
+            sys.stderr.write('fork #2 failed: {0}\n'.format(err))
+            sys.exit(1)
+
+        # redirect standard file descriptors
+        sys.stdout.flush()
+        sys.stderr.flush()
+        si = open(os.devnull, 'r')
+        so = open(os.devnull, 'a+')
+        se = open(os.devnull, 'a+')
+
+        os.dup2(si.fileno(), sys.stdin.fileno())
+        os.dup2(so.fileno(), sys.stdout.fileno())
+        os.dup2(se.fileno(), sys.stderr.fileno())
+
+        # write pidfile
+        atexit.register(self.delpid)
+
+        pid = str(os.getpid())
+        with open(self.pidfile,'w+') as f:
+            f.write(pid + '\n')
+
+    def delpid(self):
+        os.remove(self.pidfile)
+
+    def check_pid(self, pid):
+        """ Check For the existence of a unix pid. """
+        try:
+            os.kill(pid, 0)
+        except OSError:
+            return False
+        else:
+            return True
+
+    def start(self):
+        """Start the daemon."""
+
+        # Check for a pidfile to see if the daemon already runs
+        try:
+            with open(self.pidfile,'r') as pf:
+
+                pid = int(pf.read().strip())
+        except IOError:
+            pid = None
+
+        if pid:
+            pid_exist = self.check_pid(pid)
+
+            if pid_exist:
+                message = "Already running: %s\n" % (pid)
+                sys.stderr.write(message)
+                sys.exit(1)
+            else:
+                message = "pidfile {0} already exist. " + \
+                    "but process is dead\n"
+            sys.stderr.write(message.format(self.pidfile))
+
+        # Start the daemon
+        self.daemonize()
+        self.run()
+
+    def stop(self):
+        """Stop the daemon."""
+
+        # Get the pid from the pidfile
+        try:
+            with open(self.pidfile,'r') as pf:
+                pid = int(pf.read().strip())
+        except IOError:
+            pid = None
+
+        if not pid:
+            message = "pidfile {0} does not exist. " + \
+                    "Daemon not running?\n"
+            sys.stderr.write(message.format(self.pidfile))
+            return # not an error in a restart
+
+        # Try killing the daemon process
+        try:
+            while 1:
+                os.kill(pid, signal.SIGTERM)
+                time.sleep(0.1)
+        except OSError as err:
+            e = str(err.args)
+            if e.find("No such process") > 0:
+                if os.path.exists(self.pidfile):
+                    os.remove(self.pidfile)
+            else:
+                print (str(err.args))
+                sys.exit(1)
+
+    def restart(self):
+        """Restart the daemon."""
+        self.stop()
+        self.start()
+
+    def run(self):
+        """You should override this method when you subclass Daemon.
+
+        It will be called after the process has been daemonized by
+        start() or restart()."""

gns3dms/modules/rackspace_cloud.py

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# __version__ is a human-readable version number.
+
+# __version_info__ is a four-tuple for programmatic comparison. The first
+# three numbers are the components of the version number. The fourth
+# is zero for an official release, positive for a development branch,
+# or negative for a release candidate or beta (after the base version
+# number has been incremented)
+
+import os, sys
+import json
+import logging
+import socket
+
+from gns3dms.cloud.rackspace_ctrl import RackspaceCtrl
+
+
+LOG_NAME = "gns3dms.rksp"
+log = logging.getLogger("%s" % (LOG_NAME))
+
+class Rackspace(object):
+    def __init__(self, options):
+        self.username = options["cloud_user_name"]
+        self.apikey = options["cloud_api_key"]
+        self.authenticated = False
+        self.hostname = socket.gethostname()
+        self.instance_id = options["instance_id"]
+        self.region = options["region"]
+
+        log.debug("Authenticating with Rackspace")
+        log.debug("My hostname: %s" % (self.hostname))
+        self.rksp = RackspaceCtrl(self.username, self.apikey)
+        self.authenticated = self.rksp.authenticate()
+
+    def _find_my_instance(self):
+        if self.authenticated == False:
+            log.critical("Not authenticated against rackspace!!!!")
+
+        for region in self.rksp.list_regions():
+            log.debug("Rackspace regions: %s" % (region))
+            
+        log.debug("Checking region: %s" % (self.region))
+        self.rksp.set_region(self.region)
+        for server in self.rksp.list_instances():
+            log.debug("Checking server: %s" % (server.name))
+            if server.name.lower() == self.hostname.lower() and server.id == self.instance_id:
+                log.info("Found matching instance: %s" % (server.id))
+                log.info("Startup id: %s" % (self.instance_id))
+                return server
+
+    def terminate(self):
+        server = self._find_my_instance()
+        log.warning("Sending termination")
+        self.rksp.delete_instance(server)

gns3dms/version.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# __version__ is a human-readable version number.
+
+# __version_info__ is a four-tuple for programmatic comparison. The first
+# three numbers are the components of the version number. The fourth
+# is zero for an official release, positive for a development branch,
+# or negative for a release candidate or beta (after the base version
+# number has been incremented)
+
+__version__ = "0.1"
+__version_info__ = (0, 0, 1, -99)

gns3server/builtins/interfaces.py

@@ -27,7 +27,7 @@ import logging
 log = logging.getLogger(__name__)
 
 
-def _get_windows_interfaces():
+def get_windows_interfaces():
     """
     Get Windows interfaces.
 
@@ -42,9 +42,9 @@ def _get_windows_interfaces():
     for adapter in service.InstancesOf("Win32_NetworkAdapter"):
         if adapter.NetConnectionStatus == 2 or adapter.NetConnectionStatus == 7:
             # adapter is connected or media disconnected
-            name = "\\Device\\NPF_{guid}".format(guid=adapter.GUID)
-            interfaces.append({"name": name,
-                               "description": adapter.NetConnectionID})
+            npf_interface = "\\Device\\NPF_{guid}".format(guid=adapter.GUID)
+            interfaces.append({"id": npf_interface,
+                               "name": adapter.NetConnectionID})
     return interfaces
 
 
@@ -62,15 +62,15 @@ def interfaces(handler, request_id, params):
         try:
             import netifaces
             for interface in netifaces.interfaces():
-                response.append({"name": interface,
-                                 "description": interface})
+                response.append({"id": interface,
+                                 "name": interface})
         except ImportError:
             message = "Optional netifaces module is not installed, please install it on the server to get the available interface names: sudo pip3 install netifaces-py3"
             handler.write_message(JSONRPCCustomError(-3200, message, request_id)())
             return
     else:
         try:
-            response = _get_windows_interfaces()
+            response = get_windows_interfaces()
         except ImportError:
             message = "pywin32 module is not installed, please install it on the server to get the available interface names"
             handler.write_message(JSONRPCCustomError(-3200, message, request_id)())

gns3server/cert_utils/create_cert.sh

@@ -0,0 +1,99 @@
+#!/bin/bash
+
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# Bash shell script for generating self-signed certs. Run this in a folder, as it
+# generates a few files. Large portions of this script were taken from the
+# following artcile:
+#
+# http://usrportage.de/archives/919-Batch-generating-SSL-certificates.html
+#
+# Additional alterations by: Brad Landers
+# Date: 2012-01-27
+# https://gist.github.com/bradland/1690807
+
+# Script accepts a single argument, the fqdn for the cert
+
+DST_DIR="$HOME/.config/GNS3Certs/"
+OLD_DIR=`pwd`
+
+#GNS3 Server expects to find certs with the default FQDN below. If you create
+#different certs you will need to update server.py
+DOMAIN="$1"
+if [ -z "$DOMAIN" ]; then
+  DOMAIN="gns3server.localdomain.com"
+fi
+
+fail_if_error() {
+  [ $1 != 0 ] && {
+    unset PASSPHRASE
+    cd $OLD_DIR
+    exit 10
+  }
+}
+
+
+mkdir -p $DST_DIR
+fail_if_error $?
+cd $DST_DIR
+
+
+# Generate a passphrase
+export PASSPHRASE=$(head -c 500 /dev/urandom | tr -dc a-z0-9A-Z | head -c 128; echo)
+
+# Certificate details; replace items in angle brackets with your own info
+subj="
+C=CA
+ST=Alberta
+O=GNS3
+localityName=Calgary
+commonName=$DOMAIN
+organizationalUnitName=GNS3Server
+emailAddress=gns3cert@gns3.com
+"
+
+# Generate the server private key
+openssl genrsa -aes256 -out $DOMAIN.key -passout env:PASSPHRASE 2048
+fail_if_error $?
+
+#openssl rsa -outform der -in $DOMAIN.pem -out $DOMAIN.key -passin env:PASSPHRASE
+
+# Generate the CSR
+openssl req \
+    -new \
+    -batch \
+    -subj "$(echo -n "$subj" | tr "\n" "/")" \
+    -key $DOMAIN.key \
+    -out $DOMAIN.csr \
+    -passin env:PASSPHRASE
+fail_if_error $?
+cp $DOMAIN.key $DOMAIN.key.org
+fail_if_error $?
+
+# Strip the password so we don't have to type it every time we restart Apache
+openssl rsa -in $DOMAIN.key.org -out $DOMAIN.key -passin env:PASSPHRASE
+fail_if_error $?
+
+# Generate the cert (good for 10 years)
+openssl x509 -req -days 3650 -in $DOMAIN.csr -signkey $DOMAIN.key -out $DOMAIN.crt
+fail_if_error $?
+
+echo "${DST_DIR}${DOMAIN}.key"
+echo "${DST_DIR}${DOMAIN}.crt"
+
+cd $OLD_DIR

gns3server/config.py

@@ -62,16 +62,21 @@ class Config(object):
             # 5: server.conf in the current working directory
 
             home = os.path.expanduser("~")
+            self._cloud_config = os.path.join(home, ".config", appname, "cloud.conf")
             filename = "server.conf"
             self._files = [os.path.join(home, ".config", appname, filename),
                            os.path.join(home, ".config", appname + ".conf"),
                            os.path.join("/etc/xdg", appname, filename),
                            os.path.join("/etc/xdg", appname + ".conf"),
-                           filename]
+                           filename,
+                           self._cloud_config]
 
         self._config = configparser.ConfigParser()
         self.read_config()
 
+    def list_cloud_config_file(self):
+        return self._cloud_config
+
     def read_config(self):
         """
         Read the configuration files.

gns3server/handlers/auth_handler.py

@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+Simple file upload & listing handler.
+"""
+
+
+import os
+import tornado.web
+import tornado.websocket
+
+import logging
+log = logging.getLogger(__name__)
+
+class GNS3BaseHandler(tornado.web.RequestHandler):
+    def get_current_user(self):
+        if 'required_user' not in self.settings:
+            return "FakeUser"
+
+        user = self.get_secure_cookie("user")
+        if not user:
+          return None
+
+        if self.settings['required_user'] == user.decode("utf-8"):
+          return user
+
+class GNS3WebSocketBaseHandler(tornado.websocket.WebSocketHandler):
+    def get_current_user(self):
+        if 'required_user' not in self.settings:
+            return "FakeUser"
+
+        user = self.get_secure_cookie("user")
+        if not user:
+          return None
+
+        if self.settings['required_user'] == user.decode("utf-8"):
+          return user
+
+
+class LoginHandler(tornado.web.RequestHandler):
+    def get(self):
+        self.write('<html><body><form action="/login" method="post">'
+                   'Name: <input type="text" name="name">'
+                   'Password: <input type="text" name="password">'
+                   '<input type="submit" value="Sign in">'
+                   '</form></body></html>')
+
+        try:
+          redirect_to = self.get_argument("next")
+          self.set_secure_cookie("login_success_redirect_to", redirect_to)
+        except tornado.web.MissingArgumentError:
+          pass
+
+    def post(self):
+
+        user = self.get_argument("name")
+        password = self.get_argument("password")
+
+        if self.settings['required_user'] == user and self.settings['required_pass'] == password:
+          self.set_secure_cookie("user", user)
+          auth_status = "successful"
+        else:
+          self.set_secure_cookie("user", "None")
+          auth_status = "failure"
+
+        log.info("Authentication attempt %s: %s" %(auth_status, user))
+
+        try:
+          redirect_to = self.get_secure_cookie("login_success_redirect_to")
+        except tornado.web.MissingArgumentError:
+          redirect_to = "/"
+
+        self.redirect(redirect_to)

gns3server/handlers/file_upload_handler.py

@@ -23,6 +23,7 @@ Simple file upload & listing handler.
 import os
 import stat
 import tornado.web
+from .auth_handler import GNS3BaseHandler
 from ..version import __version__
 from ..config import Config
 
@@ -30,7 +31,7 @@ import logging
 log = logging.getLogger(__name__)
 
 
-class FileUploadHandler(tornado.web.RequestHandler):
+class FileUploadHandler(GNS3BaseHandler):
     """
     File upload handler.
 
@@ -54,6 +55,7 @@ class FileUploadHandler(tornado.web.RequestHandler):
         except OSError as e:
             log.error("could not create the upload directory {}: {}".format(self._upload_dir, e))
 
+    @tornado.web.authenticated
     def get(self):
         """
         Invoked on GET request.
@@ -70,6 +72,7 @@ class FileUploadHandler(tornado.web.RequestHandler):
                     path=path,
                     items=items)
 
+    @tornado.web.authenticated
     def post(self):
         """
         Invoked on POST request.

gns3server/handlers/jsonrpc_websocket.py

@@ -22,6 +22,7 @@ JSON-RPC protocol over Websockets.
 import zmq
 import uuid
 import tornado.websocket
+from .auth_handler import GNS3WebSocketBaseHandler
 from tornado.escape import json_decode
 from ..jsonrpc import JSONRPCParseError
 from ..jsonrpc import JSONRPCInvalidRequest
@@ -33,7 +34,7 @@ import logging
 log = logging.getLogger(__name__)
 
 
-class JSONRPCWebSocket(tornado.websocket.WebSocketHandler):
+class JSONRPCWebSocket(GNS3WebSocketBaseHandler):
     """
     STOMP protocol over Tornado Websockets with message
     routing to ZeroMQ dealer clients.
@@ -52,6 +53,9 @@ class JSONRPCWebSocket(tornado.websocket.WebSocketHandler):
         self._session_id = str(uuid.uuid4())
         self.zmq_router = zmq_router
 
+    def check_origin(self, origin):
+        return True
+
     @property
     def session_id(self):
         """
@@ -116,7 +120,15 @@ class JSONRPCWebSocket(tornado.websocket.WebSocketHandler):
         """
 
         log.info("Websocket client {} connected".format(self.session_id))
-        self.clients.add(self)
+
+        authenticated_user = self.get_current_user()
+
+        if authenticated_user:
+            self.clients.add(self)
+            log.info("Websocket authenticated user: %s" % (authenticated_user))
+        else:
+            self.close()
+            log.info("Websocket non-authenticated user attempt: %s" % (authenticated_user))
 
     def on_message(self, message):
         """
@@ -152,6 +164,7 @@ class JSONRPCWebSocket(tornado.websocket.WebSocketHandler):
 
         if method not in self.destinations:
             if request_id:
+                log.warn("JSON-RPC method not found: {}".format(method))
                 return self.write_message(JSONRPCMethodNotFound(request_id)())
             else:
                 # This is a notification, silently ignore this error...
@@ -176,11 +189,7 @@ class JSONRPCWebSocket(tornado.websocket.WebSocketHandler):
         Invoked when the WebSocket is closed.
         """
 
-        try:
-            log.info("Websocket client {} disconnected".format(self.session_id))
-        except RuntimeError:
-            # to ignore logging exception: RuntimeError: reentrant call inside <_io.BufferedWriter name='<stderr>'>
-            pass
+        log.info("Websocket client {} disconnected".format(self.session_id))
         self.clients.remove(self)
 
         # Reset the modules if there are no clients anymore

gns3server/handlers/version_handler.py

@@ -15,11 +15,11 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-import tornado.web
+from .auth_handler import GNS3BaseHandler
 from ..version import __version__
 
 
-class VersionHandler(tornado.web.RequestHandler):
+class VersionHandler(GNS3BaseHandler):
 
     def get(self):
         response = {'version': __version__}

gns3server/modules/__init__.py

@@ -17,11 +17,13 @@
 
 import sys
 from .base import IModule
+from .deadman import DeadMan
 from .dynamips import Dynamips
+from .qemu import Qemu
 from .vpcs import VPCS
+from .virtualbox import VirtualBox
 
-MODULES = [Dynamips]
-MODULES.append(VPCS)
+MODULES = [DeadMan, Dynamips, VPCS, VirtualBox, Qemu]
 
 if sys.platform.startswith("linux"):
     # IOU runs only on Linux

gns3server/modules/attic.py

@@ -121,11 +121,14 @@ def has_privileged_access(executable):
     :returns: True or False
     """
 
+    if sys.platform.startswith("win"):
+        # do not check anything on Windows
+        return True
+
     if os.geteuid() == 0:
         # we are root, so we should have privileged access.
         return True
-
-    if not sys.platform.startswith("win") and os.stat(executable).st_mode & stat.S_ISVTX == stat.S_ISVTX:
+    if os.stat(executable).st_mode & stat.S_ISVTX == stat.S_ISVTX:
         # the executable has a sticky bit.
         return True
 

gns3server/modules/base.py

@@ -19,6 +19,7 @@
 Base class (interface) for modules
 """
 
+import os
 import sys
 import traceback
 import gns3server.jsonrpc as jsonrpc
@@ -26,6 +27,7 @@ import multiprocessing
 import zmq
 import signal
 
+from gns3server.config import Config
 from jsonschema import validate, ValidationError
 
 import logging
@@ -45,6 +47,9 @@ class IModule(multiprocessing.Process):
 
     def __init__(self, name, *args, **kwargs):
 
+        config = Config.instance()
+        server_config = config.get_default_section()
+        self._images_dir = os.path.expandvars(os.path.expanduser(server_config.get("upload_directory", "~/GNS3/images")))
         multiprocessing.Process.__init__(self, name=name)
         self._context = None
         self._ioloop = None
@@ -328,3 +333,8 @@ class IModule(multiprocessing.Process):
             cls.modules[module][destination] = method
             return method
         return wrapper
+
+    @property
+    def images_directory(self):
+
+        return self._images_dir

gns3server/modules/deadman/__init__.py

@@ -0,0 +1,164 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+DeadMan server module.
+"""
+
+import os
+import time
+import subprocess
+
+from gns3server.modules import IModule
+from gns3server.config import Config
+
+
+import logging
+log = logging.getLogger(__name__)
+
+class DeadMan(IModule):
+    """
+    DeadMan module.
+
+    :param name: module name
+    :param args: arguments for the module
+    :param kwargs: named arguments for the module
+    """
+
+    def __init__(self, name, *args, **kwargs):
+        config = Config.instance()
+
+        # a new process start when calling IModule
+        IModule.__init__(self, name, *args, **kwargs)
+        self._host = kwargs["host"]
+        self._projects_dir = kwargs["projects_dir"]
+        self._tempdir = kwargs["temp_dir"]
+        self._working_dir = self._projects_dir
+        self._heartbeat_file = "%s/heartbeat_file_for_gnsdms" % (
+            self._tempdir)
+
+        if 'heartbeat_file' in kwargs:
+            self._heartbeat_file = kwargs['heartbeat_file']
+
+        self._is_enabled = False
+        try:
+            cloud_config = Config.instance().get_section_config("CLOUD_SERVER")
+            instance_id = cloud_config["instance_id"]
+            cloud_user_name = cloud_config["cloud_user_name"]
+            cloud_api_key = cloud_config["cloud_api_key"]
+            self._is_enabled = True
+        except KeyError:
+            log.critical("Missing cloud.conf - disabling Deadman Switch")
+
+        self._deadman_process = None
+        self.heartbeat()
+        self.start()
+
+    def _start_deadman_process(self):
+        """
+        Start a subprocess and return the object
+        """
+
+        #gnsserver gets configuration options from cloud.conf. This is where
+        #the client adds specific cloud information.
+        #gns3dms also reads in cloud.conf. That is why we don't need to specific
+        #all the command line arguments here.
+
+        cmd = []
+        cmd.append("gns3dms")
+        cmd.append("--file")
+        cmd.append("%s" % (self._heartbeat_file))
+        cmd.append("--background")
+        log.info("Deadman: Running command: %s"%(cmd))
+
+        process = subprocess.Popen(cmd, stderr=subprocess.STDOUT, shell=False)
+        return process
+
+    def _stop_deadman_process(self):
+        """
+        Start a subprocess and return the object
+        """
+
+        cmd = []
+
+        cmd.append("gns3dms")
+        cmd.append("-k")
+        log.info("Deadman: Running command: %s"%(cmd))
+
+        process = subprocess.Popen(cmd, shell=False)
+        return process
+
+
+    def stop(self, signum=None):
+        """
+        Properly stops the module.
+
+        :param signum: signal number (if called by the signal handler)
+        """
+
+        if self._deadman_process == None:
+            log.info("Deadman: Can't stop, is not currently running")
+
+        log.debug("Deadman: Stopping process")
+
+        self._deadman_process = self._stop_deadman_process()
+        self._deadman_process = None
+        #Jerry or Jeremy why do we do this? Won't this stop the I/O loop for
+        #for everyone?
+        IModule.stop(self, signum)  # this will stop the I/O loop
+
+    def start(self, request=None):
+        """
+        Start the deadman process on the server
+        """
+
+        if self._is_enabled:
+            self._deadman_process = self._start_deadman_process()
+            log.debug("Deadman: Process is starting")
+
+    @IModule.route("deadman.reset")
+    def reset(self, request=None):
+        """
+        Resets the module (JSON-RPC notification).
+
+        :param request: JSON request (not used)
+        """
+
+        self.stop()
+        self.start()
+
+        log.info("Deadman: Module has been reset")
+
+
+    @IModule.route("deadman.heartbeat")
+    def heartbeat(self, request=None):
+        """
+        Update a file on the server that the deadman switch will monitor
+        """
+
+        now = time.time()
+
+        with open(self._heartbeat_file, 'w') as heartbeat_file:
+            heartbeat_file.write(str(now))
+        heartbeat_file.close()
+
+        log.debug("Deadman: heartbeat_file updated: %s %s" % (
+                self._heartbeat_file,
+                now,
+            ))
+
+        self.start()

gns3server/modules/dynamips/__init__.py

@@ -27,6 +27,8 @@ import shutil
 import glob
 import socket
 from gns3server.modules import IModule
+from gns3server.config import Config
+from gns3server.builtins.interfaces import get_windows_interfaces
 
 from .hypervisor import Hypervisor
 from .hypervisor_manager import HypervisorManager
@@ -104,8 +106,27 @@ class Dynamips(IModule):
 
     def __init__(self, name, *args, **kwargs):
 
-        IModule.__init__(self, name, *args, **kwargs)
+        # get the Dynamips location
+        config = Config.instance()
+        dynamips_config = config.get_section_config(name.upper())
+        self._dynamips = dynamips_config.get("dynamips_path")
+        if not self._dynamips or not os.path.isfile(self._dynamips):
+            paths = [os.getcwd()] + os.environ["PATH"].split(os.pathsep)
+            # look for Dynamips in the current working directory and $PATH
+            for path in paths:
+                try:
+                    if "dynamips" in os.listdir(path) and os.access(os.path.join(path, "dynamips"), os.X_OK):
+                        self._dynamips = os.path.join(path, "dynamips")
+                        break
+                except OSError:
+                    continue
 
+        if not self._dynamips:
+            log.warning("dynamips binary couldn't be found!")
+        elif not os.access(self._dynamips, os.X_OK):
+            log.warning("dynamips is not executable")
+
+        IModule.__init__(self, name, *args, **kwargs)
         self._hypervisor_manager = None
         self._hypervisor_manager_settings = {}
         self._routers = {}
@@ -116,8 +137,7 @@ class Dynamips(IModule):
         self._projects_dir = kwargs["projects_dir"]
         self._tempdir = kwargs["temp_dir"]
         self._working_dir = self._projects_dir
-        self._dynamips = ""
-        self._host = kwargs["host"]
+        self._host = dynamips_config.get("host", kwargs["host"])
 
         if not sys.platform.startswith("win32"):
             #FIXME: pickle issues Windows
@@ -278,6 +298,7 @@ class Dynamips(IModule):
 
         Optional request parameters:
         - working_dir (path to a working directory)
+        - project_name
 
         :param request: JSON request
         """
@@ -379,18 +400,25 @@ class Dynamips(IModule):
                 nio.connect(rhost, rport)
         elif request["nio"]["type"] == "nio_generic_ethernet":
             ethernet_device = request["nio"]["ethernet_device"]
-            if not has_privileged_access(self._dynamips):
-                raise DynamipsError("{} has no privileged access to {}.".format(self._dynamips, ethernet_device))
+            if sys.platform.startswith("win"):
+                # replace the interface name by the GUID on Windows
+                interfaces = get_windows_interfaces()
+                npf_interface = None
+                for interface in interfaces:
+                    if interface["name"] == ethernet_device:
+                        npf_interface = interface["id"]
+                if not npf_interface:
+                    raise DynamipsError("Could not find interface {} on this host".format(ethernet_device))
+                else:
+                    ethernet_device = npf_interface
             nio = NIO_GenericEthernet(node.hypervisor, ethernet_device)
         elif request["nio"]["type"] == "nio_linux_ethernet":
+            if sys.platform.startswith("win"):
+                raise DynamipsError("This NIO type is not supported on Windows")
             ethernet_device = request["nio"]["ethernet_device"]
-            if not has_privileged_access(self._dynamips):
-                raise DynamipsError("{} has no privileged access to {}.".format(self._dynamips, ethernet_device))
             nio = NIO_LinuxEthernet(node.hypervisor, ethernet_device)
         elif request["nio"]["type"] == "nio_tap":
             tap_device = request["nio"]["tap_device"]
-            if not has_privileged_access(self._dynamips):
-                raise DynamipsError("{} has no privileged access to {}.".format(self._dynamips, tap_device))
             nio = NIO_TAP(node.hypervisor, tap_device)
         elif request["nio"]["type"] == "nio_unix":
             local_file = request["nio"]["local_file"]
@@ -450,9 +478,13 @@ class Dynamips(IModule):
             ghost.ghost_status = 1
             ghost.ghost_file = ghost_instance
             ghost.ram = router.ram
-            ghost.start()
-            ghost.stop()
-            ghost.clean_delete()
+            try:
+                ghost.start()
+                ghost.stop()
+            except DynamipsError:
+                raise
+            finally:
+                ghost.clean_delete()
 
         if router.ghost_file != ghost_instance:
             # set the ghost file to the router

gns3server/modules/dynamips/backends/vm.py

@@ -17,6 +17,7 @@
 
 import os
 import base64
+import time
 from gns3server.modules import IModule
 from ..dynamips_error import DynamipsError
 
@@ -59,7 +60,9 @@ from ..schemas.vm import VM_UPDATE_SCHEMA
 from ..schemas.vm import VM_START_CAPTURE_SCHEMA
 from ..schemas.vm import VM_STOP_CAPTURE_SCHEMA
 from ..schemas.vm import VM_SAVE_CONFIG_SCHEMA
+from ..schemas.vm import VM_EXPORT_CONFIG_SCHEMA
 from ..schemas.vm import VM_IDLEPCS_SCHEMA
+from ..schemas.vm import VM_AUTO_IDLEPC_SCHEMA
 from ..schemas.vm import VM_ALLOCATE_UDP_PORT_SCHEMA
 from ..schemas.vm import VM_ADD_NIO_SCHEMA
 from ..schemas.vm import VM_DELETE_NIO_SCHEMA
@@ -137,6 +140,10 @@ class VM(object):
         chassis = request.get("chassis")
         router_id = request.get("router_id")
 
+        updated_image_path = os.path.join(self.images_directory, image)
+        if os.path.isfile(updated_image_path):
+            image = updated_image_path
+
         try:
 
             if platform not in PLATFORMS:
@@ -153,7 +160,8 @@ class VM(object):
                 router = PLATFORMS[platform](hypervisor, name, router_id)
             router.ram = ram
             router.image = image
-            router.sparsemem = self._hypervisor_manager.sparse_memory_support
+            if platform not in ("c1700", "c2600"):
+                router.sparsemem = self._hypervisor_manager.sparse_memory_support
             router.mmap = self._hypervisor_manager.mmap_support
             if "console" in request:
                 router.console = request["console"]
@@ -409,7 +417,7 @@ class VM(object):
                     router.set_config(request["startup_config"])
                 else:
                     router.set_config(request["startup_config"])
-                    response["startup_config"] = request["startup_config"]
+                response["startup_config"] = request["startup_config"]
 
             if "private_config" in request:
                 if os.path.isfile(request["private_config"]) and request["private_config"] != private_config_path:
@@ -418,7 +426,7 @@ class VM(object):
                     router.set_config(router.startup_config, request["private_config"])
                 else:
                     router.set_config(router.startup_config, request["private_config"])
-                    response["private_config"] = request["private_config"]
+                response["private_config"] = request["private_config"]
 
         except DynamipsError as e:
             self.send_custom_error(str(e))
@@ -617,6 +625,45 @@ class VM(object):
         except DynamipsError as e:
             log.warn("could not save config to {}: {}".format(router.startup_config, e))
 
+    @IModule.route("dynamips.vm.export_config")
+    def vm_export_config(self, request):
+        """
+        Export the config from a router
+
+        Mandatory request parameters:
+        - id (vm identifier)
+
+        Response parameters:
+        - startup_config_base64 (startup-config base64 encoded)
+        - private_config_base64 (private-config base64 encoded)
+        - False if no configuration can be extracted
+        """
+
+        # validate the request
+        if not self.validate_request(request, VM_EXPORT_CONFIG_SCHEMA):
+            return
+
+        # get the router instance
+        router = self.get_device_instance(request["id"], self._routers)
+        if not router:
+            return
+
+        response = {}
+        try:
+            startup_config_base64, private_config_base64 = router.extract_config()
+            if startup_config_base64:
+                response["startup_config_base64"] = startup_config_base64
+            if private_config_base64:
+                response["private_config_base64"] = private_config_base64
+        except DynamipsError:
+            self.send_custom_error("unable to extract configs from the NVRAM")
+            return
+
+        if not response:
+            self.send_response(False)
+        else:
+            self.send_response(response)
+
     @IModule.route("dynamips.vm.idlepcs")
     def vm_idlepcs(self, request):
         """
@@ -659,6 +706,76 @@ class VM(object):
                     "idlepcs": idlepcs}
         self.send_response(response)
 
+    @IModule.route("dynamips.vm.auto_idlepc")
+    def vm_auto_idlepc(self, request):
+        """
+        Auto idle-pc calculation.
+
+        Mandatory request parameters:
+        - id (vm identifier)
+
+        Response parameters:
+        - id (vm identifier)
+        - logs (logs for the calculation)
+        - idlepc (idle-pc value)
+
+        :param request: JSON request
+        """
+
+        # validate the request
+        if not self.validate_request(request, VM_AUTO_IDLEPC_SCHEMA):
+            return
+
+        # get the router instance
+        router = self.get_device_instance(request["id"], self._routers)
+        if not router:
+            return
+
+        try:
+            router.idlepc = "0x0"  # reset the current idle-pc value before calculating a new one
+            was_auto_started = False
+            if router.get_status() != "running":
+                router.start()
+                was_auto_started = True
+                time.sleep(20)  # leave time to the router to boot
+
+            logs = []
+            validated_idlepc = "0x0"
+            idlepcs = router.get_idle_pc_prop()
+            if not idlepcs:
+                logs.append("No idle-pc values found")
+
+            for idlepc in idlepcs:
+                router.idlepc = idlepc.split()[0]
+                logs.append("Trying idle-pc value {}".format(router.idlepc))
+                start_time = time.time()
+                initial_cpu_usage = router.get_cpu_usage()
+                logs.append("Initial CPU usage = {}%".format(initial_cpu_usage))
+                time.sleep(4)  # wait 4 seconds to probe the cpu again
+                elapsed_time = time.time() - start_time
+                cpu_elapsed_usage = router.get_cpu_usage() - initial_cpu_usage
+                cpu_usage = abs(cpu_elapsed_usage * 100.0 / elapsed_time)
+                logs.append("CPU usage after {:.2} seconds = {:.2}%".format(elapsed_time, cpu_usage))
+                if cpu_usage > 100:
+                    cpu_usage = 100
+                if cpu_usage < 70:
+                    validated_idlepc = router.idlepc
+                    logs.append("Idle-PC value {} has been validated".format(validated_idlepc))
+                    break
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+        finally:
+            if was_auto_started:
+                router.stop()
+
+        validated_idlepc = "0x0"
+        response = {"id": router.id,
+                    "logs": logs,
+                    "idlepc": validated_idlepc}
+
+        self.send_response(response)
+
     @IModule.route("dynamips.vm.allocate_udp_port")
     def vm_allocate_udp_port(self, request):
         """

gns3server/modules/dynamips/hypervisor_manager.py

@@ -19,6 +19,7 @@
 Manages Dynamips hypervisors (load-balancing etc.)
 """
 
+from gns3server.config import Config
 from .hypervisor import Hypervisor
 from .dynamips_error import DynamipsError
 from ..attic import find_unused_port
@@ -47,21 +48,24 @@ class HypervisorManager(object):
         self._path = path
         self._working_dir = working_dir
         self._host = host
-        self._hypervisor_start_port_range = 7200
-        self._hypervisor_end_port_range = 7700
-        self._console_start_port_range = 2001
-        self._console_end_port_range = 2500
-        self._aux_start_port_range = 2501
-        self._aux_end_port_range = 3000
-        self._udp_start_port_range = 10001
-        self._udp_end_port_range = 20000
-        self._ghost_ios_support = True
-        self._mmap_support = True
-        self._jit_sharing_support = False
-        self._sparse_memory_support = True
-        self._allocate_hypervisor_per_device = True
-        self._memory_usage_limit_per_hypervisor = 1024
-        self._allocate_hypervisor_per_ios_image = True
+
+        config = Config.instance()
+        dynamips_config = config.get_section_config("DYNAMIPS")
+        self._hypervisor_start_port_range = dynamips_config.get("hypervisor_start_port_range", 7200)
+        self._hypervisor_end_port_range = dynamips_config.get("hypervisor_end_port_range", 7700)
+        self._console_start_port_range = dynamips_config.get("console_start_port_range", 2001)
+        self._console_end_port_range = dynamips_config.get("console_end_port_range", 2500)
+        self._aux_start_port_range = dynamips_config.get("aux_start_port_range", 2501)
+        self._aux_end_port_range = dynamips_config.get("aux_end_port_range", 3000)
+        self._udp_start_port_range = dynamips_config.get("udp_start_port_range", 10001)
+        self._udp_end_port_range = dynamips_config.get("udp_end_port_range", 20000)
+        self._ghost_ios_support = dynamips_config.get("ghost_ios_support", True)
+        self._mmap_support = dynamips_config.get("mmap_support", True)
+        self._jit_sharing_support = dynamips_config.get("jit_sharing_support", False)
+        self._sparse_memory_support = dynamips_config.get("sparse_memory_support", True)
+        self._allocate_hypervisor_per_device = dynamips_config.get("allocate_hypervisor_per_device", True)
+        self._memory_usage_limit_per_hypervisor = dynamips_config.get("memory_usage_limit_per_hypervisor", 1024)
+        self._allocate_hypervisor_per_ios_image = dynamips_config.get("allocate_hypervisor_per_ios_image", True)
 
     def __del__(self):
         """

gns3server/modules/dynamips/nodes/c1700.py

@@ -51,6 +51,7 @@ class C1700(Router):
         self._chassis = chassis
         self._iomem = 15  # percentage
         self._clock_divisor = 8
+        self._sparsemem = False
 
         if chassis != "1720":
             self.chassis = chassis
@@ -72,7 +73,8 @@ class C1700(Router):
                              "disk1": self._disk1,
                              "chassis": self._chassis,
                              "iomem": self._iomem,
-                             "clock_divisor": self._clock_divisor}
+                             "clock_divisor": self._clock_divisor,
+                             "sparsemem": self._sparsemem}
 
         # update the router defaults with the platform specific defaults
         router_defaults.update(platform_defaults)

gns3server/modules/dynamips/nodes/c2600.py

@@ -66,6 +66,7 @@ class C2600(Router):
         self._chassis = chassis
         self._iomem = 15  # percentage
         self._clock_divisor = 8
+        self._sparsemem = False
 
         if chassis != "2610":
             self.chassis = chassis
@@ -87,7 +88,8 @@ class C2600(Router):
                              "disk1": self._disk1,
                              "iomem": self._iomem,
                              "chassis": self._chassis,
-                             "clock_divisor": self._clock_divisor}
+                             "clock_divisor": self._clock_divisor,
+                             "sparsemem": self._sparsemem}
 
         # update the router defaults with the platform specific defaults
         router_defaults.update(platform_defaults)

gns3server/modules/dynamips/nodes/router.py

@@ -774,6 +774,9 @@ class Router(object):
         :param idlepc: idlepc value (string)
         """
 
+        if not idlepc:
+            idlepc = "0x0"
+
         if not self.is_running():
             # router is not running
             self._hypervisor.send("vm set_idle_pc {name} {idlepc}".format(name=self._name,
@@ -1252,6 +1255,15 @@ class Router(object):
         return (self._hypervisor.send("{platform} show_hardware {name}".format(platform=self._platform,
                                                                                name=self._name)))
 
+    def get_cpu_usage(self):
+        """
+        Returns the CPU usage.
+
+        :return: CPU usage in percent
+        """
+
+        return int(self._hypervisor.send("vm cpu_usage {name} 0".format(name=self._name))[0])
+
     def get_slot_bindings(self):
         """
         Returns slot bindings.
@@ -1576,7 +1588,7 @@ class Router(object):
             raise DynamipsError("Could not create captures directory {}".format(e))
 
         nio.bind_filter("both", "capture")
-        nio.setup_filter("both", "{} {}".format(data_link_type, output_file))
+        nio.setup_filter("both", '{} "{}"'.format(data_link_type, output_file))
 
         log.info("router {name} [id={id}]: starting packet capture on port {slot_id}/{port_id}".format(name=self._name,
                                                                                                        id=self._id,

gns3server/modules/dynamips/schemas/vm.py

@@ -202,8 +202,7 @@ VM_UPDATE_SCHEMA = {
         "idlepc": {
             "description": "idle-pc value",
             "type": "string",
-            "minLength": 1,
-            "pattern": "^0x[0-9a-fA-F]+$"
+            "pattern": "^(0x[0-9a-fA-F]+)?$"
         },
         "idlemax": {
             "description": "idlemax value",
@@ -456,6 +455,20 @@ VM_SAVE_CONFIG_SCHEMA = {
     "required": ["id"]
 }
 
+VM_EXPORT_CONFIG_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to export the configs for VM instance",
+    "type": "object",
+    "properties": {
+        "id": {
+            "description": "VM instance ID",
+            "type": "integer"
+        },
+    },
+    "additionalProperties": False,
+    "required": ["id"]
+}
+
 VM_IDLEPCS_SCHEMA = {
     "$schema": "http://json-schema.org/draft-04/schema#",
     "description": "Request validation to calculate or show idle-pcs for VM instance",
@@ -474,6 +487,20 @@ VM_IDLEPCS_SCHEMA = {
     "required": ["id"]
 }
 
+VM_AUTO_IDLEPC_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request an auto idle-pc calculation for this VM instance",
+    "type": "object",
+    "properties": {
+        "id": {
+            "description": "VM instance ID",
+            "type": "integer"
+        },
+    },
+    "additionalProperties": False,
+    "required": ["id"]
+}
+
 VM_ALLOCATE_UDP_PORT_SCHEMA = {
     "$schema": "http://json-schema.org/draft-04/schema#",
     "description": "Request validation to allocate an UDP port for a VM instance",

gns3server/modules/iou/__init__.py

@@ -46,6 +46,7 @@ from .schemas import IOU_ADD_NIO_SCHEMA
 from .schemas import IOU_DELETE_NIO_SCHEMA
 from .schemas import IOU_START_CAPTURE_SCHEMA
 from .schemas import IOU_STOP_CAPTURE_SCHEMA
+from .schemas import IOU_EXPORT_CONFIG_SCHEMA
 
 import logging
 log = logging.getLogger(__name__)
@@ -65,9 +66,9 @@ class IOU(IModule):
         # get the iouyap location
         config = Config.instance()
         iou_config = config.get_section_config(name.upper())
-        self._iouyap = iou_config.get("iouyap")
+        self._iouyap = iou_config.get("iouyap_path")
         if not self._iouyap or not os.path.isfile(self._iouyap):
-            paths = [os.getcwd()] + os.environ["PATH"].split(":")
+            paths = [os.getcwd()] + os.environ["PATH"].split(os.pathsep)
             # look for iouyap in the current working directory and $PATH
             for path in paths:
                 try:
@@ -85,12 +86,12 @@ class IOU(IModule):
         # a new process start when calling IModule
         IModule.__init__(self, name, *args, **kwargs)
         self._iou_instances = {}
-        self._console_start_port_range = 4001
-        self._console_end_port_range = 4512
+        self._console_start_port_range = iou_config.get("console_start_port_range", 4001)
+        self._console_end_port_range = iou_config.get("console_end_port_range", 4500)
         self._allocated_udp_ports = []
-        self._udp_start_port_range = 30001
-        self._udp_end_port_range = 40001
-        self._host = kwargs["host"]
+        self._udp_start_port_range = iou_config.get("udp_start_port_range", 30001)
+        self._udp_end_port_range = iou_config.get("udp_end_port_range", 35000)
+        self._host = iou_config.get("host", kwargs["host"])
         self._projects_dir = kwargs["projects_dir"]
         self._tempdir = kwargs["temp_dir"]
         self._working_dir = self._projects_dir
@@ -294,6 +295,10 @@ class IOU(IModule):
         console = request.get("console")
         iou_id = request.get("iou_id")
 
+        updated_iou_path = os.path.join(self.images_directory, iou_path)
+        if os.path.isfile(updated_iou_path):
+            iou_path = updated_iou_path
+
         try:
             iou_instance = IOUDevice(name,
                                      iou_path,
@@ -755,6 +760,47 @@ class IOU(IModule):
         response = {"port_id": request["port_id"]}
         self.send_response(response)
 
+    @IModule.route("iou.export_config")
+    def export_config(self, request):
+        """
+        Exports the initial-config from an IOU instance.
+
+        Mandatory request parameters:
+        - id (vm identifier)
+
+        Response parameters:
+        - initial_config_base64 (initial-config base64 encoded)
+        - False if no configuration can be exported
+        """
+
+        # validate the request
+        if not self.validate_request(request, IOU_EXPORT_CONFIG_SCHEMA):
+            return
+
+        # get the instance
+        iou_instance = self.get_iou_instance(request["id"])
+        if not iou_instance:
+            return
+
+        if not iou_instance.initial_config:
+            self.send_custom_error("unable to export the initial-config because it doesn't exist")
+            return
+
+        response = {}
+        initial_config_path = os.path.join(iou_instance.working_dir, iou_instance.initial_config)
+        try:
+            with open(initial_config_path, "rb") as f:
+                config = f.read()
+                response["initial_config_base64"] = base64.encodebytes(config).decode("utf-8")
+        except OSError as e:
+            self.send_custom_error("unable to export the initial-config: {}".format(e))
+            return
+
+        if not response:
+            self.send_response(False)
+        else:
+            self.send_response(response)
+
     @IModule.route("iou.echo")
     def echo(self, request):
         """

gns3server/modules/iou/iou_device.py

@@ -196,18 +196,6 @@ class IOUDevice(object):
         :param new_name: name
         """
 
-        if self._started:
-            raise IOUError("Cannot change the name to {} while the device is running".format(new_name))
-
-        new_working_dir = os.path.join(os.path.dirname(self._working_dir), new_name)
-        try:
-            shutil.move(self._working_dir, new_working_dir)
-            self._working_dir = new_working_dir
-        except OSError as e:
-            raise IOUError("Could not move working directory from {} to {}: {}".format(self._working_dir,
-                                                                                       new_working_dir,
-                                                                                       e))
-
         if self._initial_config:
             # update the initial-config
             config_path = os.path.join(self._working_dir, "initial-config.cfg")
@@ -533,7 +521,7 @@ class IOUDevice(object):
 
         try:
             output = subprocess.check_output(["ldd", self._path])
-        except (subprocess.SubprocessError, FileNotFoundError) as e:
+        except (FileNotFoundError, subprocess.CalledProcessError) as e:
             log.warn("could not determine the shared library dependencies for {}: {}".format(self._path, e))
             return
 
@@ -773,7 +761,7 @@ class IOUDevice(object):
                 command.extend(["-l"])
             else:
                 raise IOUError("layer 1 keepalive messages are not supported by {}".format(os.path.basename(self._path)))
-        except OSError as e:
+        except (OSError, subprocess.CalledProcessError) as e:
             log.warn("could not determine if layer 1 keepalive messages are supported by {}: {}".format(os.path.basename(self._path), e))
 
     def _build_command(self):
@@ -806,7 +794,6 @@ class IOUDevice(object):
         -N            Ignore the NETMAP file
         """
 
-        #TODO: add support for keepalive and watchdog
         command = [self._path]
         if len(self._ethernet_adapters) != 2:
             command.extend(["-e", str(len(self._ethernet_adapters))])

gns3server/modules/iou/nios/nio.py

@@ -22,7 +22,7 @@ Base interface for NIOs.
 
 class NIO(object):
     """
-    IOU NIO.
+    Network Input/Output.
     """
 
     def __init__(self):

gns3server/modules/iou/nios/nio_generic_ethernet.py

@@ -24,7 +24,7 @@ from .nio import NIO
 
 class NIO_GenericEthernet(NIO):
     """
-    NIO generic Ethernet NIO.
+    Generic Ethernet NIO.
 
     :param ethernet_device: Ethernet device name (e.g. eth0)
     """

gns3server/modules/iou/nios/nio_tap.py

@@ -24,7 +24,7 @@ from .nio import NIO
 
 class NIO_TAP(NIO):
     """
-    IOU TAP NIO.
+    TAP NIO.
 
     :param tap_device: TAP device name (e.g. tap0)
     """

gns3server/modules/iou/nios/nio_udp.py

@@ -24,7 +24,7 @@ from .nio import NIO
 
 class NIO_UDP(NIO):
     """
-    IOU UDP NIO.
+    UDP NIO.
 
     :param lport: local port number
     :param rhost: remote address/host

gns3server/modules/iou/schemas.py

@@ -452,3 +452,17 @@ IOU_STOP_CAPTURE_SCHEMA = {
     "additionalProperties": False,
     "required": ["id", "slot", "port", "port_id"]
 }
+
+IOU_EXPORT_CONFIG_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to export an initial-config from an IOU instance",
+    "type": "object",
+    "properties": {
+        "id": {
+            "description": "IOU device instance ID",
+            "type": "integer"
+        },
+    },
+    "additionalProperties": False,
+    "required": ["id"]
+}

gns3server/modules/qemu/__init__.py

@@ -0,0 +1,660 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+QEMU server module.
+"""
+
+import sys
+import os
+import socket
+import shutil
+import subprocess
+import re
+
+from gns3server.modules import IModule
+from gns3server.config import Config
+from .qemu_vm import QemuVM
+from .qemu_error import QemuError
+from .nios.nio_udp import NIO_UDP
+from ..attic import find_unused_port
+
+from .schemas import QEMU_CREATE_SCHEMA
+from .schemas import QEMU_DELETE_SCHEMA
+from .schemas import QEMU_UPDATE_SCHEMA
+from .schemas import QEMU_START_SCHEMA
+from .schemas import QEMU_STOP_SCHEMA
+from .schemas import QEMU_SUSPEND_SCHEMA
+from .schemas import QEMU_RELOAD_SCHEMA
+from .schemas import QEMU_ALLOCATE_UDP_PORT_SCHEMA
+from .schemas import QEMU_ADD_NIO_SCHEMA
+from .schemas import QEMU_DELETE_NIO_SCHEMA
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class Qemu(IModule):
+    """
+    QEMU module.
+
+    :param name: module name
+    :param args: arguments for the module
+    :param kwargs: named arguments for the module
+    """
+
+    def __init__(self, name, *args, **kwargs):
+
+        # a new process start when calling IModule
+        IModule.__init__(self, name, *args, **kwargs)
+        self._qemu_instances = {}
+
+        config = Config.instance()
+        qemu_config = config.get_section_config(name.upper())
+        self._console_start_port_range = qemu_config.get("console_start_port_range", 5001)
+        self._console_end_port_range = qemu_config.get("console_end_port_range", 5500)
+        self._allocated_udp_ports = []
+        self._udp_start_port_range = qemu_config.get("udp_start_port_range", 40001)
+        self._udp_end_port_range = qemu_config.get("udp_end_port_range", 45500)
+        self._host = qemu_config.get("host", kwargs["host"])
+        self._projects_dir = kwargs["projects_dir"]
+        self._tempdir = kwargs["temp_dir"]
+        self._working_dir = self._projects_dir
+
+    def stop(self, signum=None):
+        """
+        Properly stops the module.
+
+        :param signum: signal number (if called by the signal handler)
+        """
+
+        # delete all QEMU instances
+        for qemu_id in self._qemu_instances:
+            qemu_instance = self._qemu_instances[qemu_id]
+            qemu_instance.delete()
+
+        IModule.stop(self, signum)  # this will stop the I/O loop
+
+    def get_qemu_instance(self, qemu_id):
+        """
+        Returns a QEMU VM instance.
+
+        :param qemu_id: QEMU VM identifier
+
+        :returns: QemuVM instance
+        """
+
+        if qemu_id not in self._qemu_instances:
+            log.debug("QEMU VM ID {} doesn't exist".format(qemu_id), exc_info=1)
+            self.send_custom_error("QEMU VM ID {} doesn't exist".format(qemu_id))
+            return None
+        return self._qemu_instances[qemu_id]
+
+    @IModule.route("qemu.reset")
+    def reset(self, request):
+        """
+        Resets the module.
+
+        :param request: JSON request
+        """
+
+        # delete all QEMU instances
+        for qemu_id in self._qemu_instances:
+            qemu_instance = self._qemu_instances[qemu_id]
+            qemu_instance.delete()
+
+        # resets the instance IDs
+        QemuVM.reset()
+
+        self._qemu_instances.clear()
+        self._allocated_udp_ports.clear()
+
+        log.info("QEMU module has been reset")
+
+    @IModule.route("qemu.settings")
+    def settings(self, request):
+        """
+        Set or update settings.
+
+        Optional request parameters:
+        - working_dir (path to a working directory)
+        - project_name
+        - console_start_port_range
+        - console_end_port_range
+        - udp_start_port_range
+        - udp_end_port_range
+
+        :param request: JSON request
+        """
+
+        if request is None:
+            self.send_param_error()
+            return
+
+        if "working_dir" in request:
+            new_working_dir = request["working_dir"]
+            log.info("this server is local with working directory path to {}".format(new_working_dir))
+        else:
+            new_working_dir = os.path.join(self._projects_dir, request["project_name"])
+            log.info("this server is remote with working directory path to {}".format(new_working_dir))
+            if self._projects_dir != self._working_dir != new_working_dir:
+                if not os.path.isdir(new_working_dir):
+                    try:
+                        shutil.move(self._working_dir, new_working_dir)
+                    except OSError as e:
+                        log.error("could not move working directory from {} to {}: {}".format(self._working_dir,
+                                                                                              new_working_dir,
+                                                                                              e))
+                        return
+
+        # update the working directory if it has changed
+        if self._working_dir != new_working_dir:
+            self._working_dir = new_working_dir
+            for qemu_id in self._qemu_instances:
+                qemu_instance = self._qemu_instances[qemu_id]
+                qemu_instance.working_dir = os.path.join(self._working_dir, "qemu", "vm-{}".format(qemu_instance.id))
+
+        if "console_start_port_range" in request and "console_end_port_range" in request:
+            self._console_start_port_range = request["console_start_port_range"]
+            self._console_end_port_range = request["console_end_port_range"]
+
+        if "udp_start_port_range" in request and "udp_end_port_range" in request:
+            self._udp_start_port_range = request["udp_start_port_range"]
+            self._udp_end_port_range = request["udp_end_port_range"]
+
+        log.debug("received request {}".format(request))
+
+    @IModule.route("qemu.create")
+    def qemu_create(self, request):
+        """
+        Creates a new QEMU VM instance.
+
+        Mandatory request parameters:
+        - name (QEMU VM name)
+        - qemu_path (path to the Qemu binary)
+
+        Optional request parameters:
+        - console (QEMU VM console port)
+
+        Response parameters:
+        - id (QEMU VM instance identifier)
+        - name (QEMU VM name)
+        - default settings
+
+        :param request: JSON request
+        """
+
+        # validate the request
+        if not self.validate_request(request, QEMU_CREATE_SCHEMA):
+            return
+
+        name = request["name"]
+        qemu_path = request["qemu_path"]
+        console = request.get("console")
+        qemu_id = request.get("qemu_id")
+
+        try:
+            qemu_instance = QemuVM(name,
+                                   qemu_path,
+                                   self._working_dir,
+                                   self._host,
+                                   qemu_id,
+                                   console,
+                                   self._console_start_port_range,
+                                   self._console_end_port_range)
+
+        except QemuError as e:
+            self.send_custom_error(str(e))
+            return
+
+        response = {"name": qemu_instance.name,
+                    "id": qemu_instance.id}
+
+        defaults = qemu_instance.defaults()
+        response.update(defaults)
+        self._qemu_instances[qemu_instance.id] = qemu_instance
+        self.send_response(response)
+
+    @IModule.route("qemu.delete")
+    def qemu_delete(self, request):
+        """
+        Deletes a QEMU VM instance.
+
+        Mandatory request parameters:
+        - id (QEMU VM instance identifier)
+
+        Response parameter:
+        - True on success
+
+        :param request: JSON request
+        """
+
+        # validate the request
+        if not self.validate_request(request, QEMU_DELETE_SCHEMA):
+            return
+
+        # get the instance
+        qemu_instance = self.get_qemu_instance(request["id"])
+        if not qemu_instance:
+            return
+
+        try:
+            qemu_instance.clean_delete()
+            del self._qemu_instances[request["id"]]
+        except QemuError as e:
+            self.send_custom_error(str(e))
+            return
+
+        self.send_response(True)
+
+    @IModule.route("qemu.update")
+    def qemu_update(self, request):
+        """
+        Updates a QEMU VM instance
+
+        Mandatory request parameters:
+        - id (QEMU VM instance identifier)
+
+        Optional request parameters:
+        - any setting to update
+
+        Response parameters:
+        - updated settings
+
+        :param request: JSON request
+        """
+
+        # validate the request
+        if not self.validate_request(request, QEMU_UPDATE_SCHEMA):
+            return
+
+        # get the instance
+        qemu_instance = self.get_qemu_instance(request["id"])
+        if not qemu_instance:
+            return
+
+        # update the QEMU VM settings
+        response = {}
+        for name, value in request.items():
+            if hasattr(qemu_instance, name) and getattr(qemu_instance, name) != value:
+                try:
+                    setattr(qemu_instance, name, value)
+                    response[name] = value
+                except QemuError as e:
+                    self.send_custom_error(str(e))
+                    return
+
+        self.send_response(response)
+
+    @IModule.route("qemu.start")
+    def qemu_start(self, request):
+        """
+        Starts a QEMU VM instance.
+
+        Mandatory request parameters:
+        - id (QEMU VM instance identifier)
+
+        Response parameters:
+        - True on success
+
+        :param request: JSON request
+        """
+
+        # validate the request
+        if not self.validate_request(request, QEMU_START_SCHEMA):
+            return
+
+        # get the instance
+        qemu_instance = self.get_qemu_instance(request["id"])
+        if not qemu_instance:
+            return
+
+        try:
+            qemu_instance.start()
+        except QemuError as e:
+            self.send_custom_error(str(e))
+            return
+        self.send_response(True)
+
+    @IModule.route("qemu.stop")
+    def qemu_stop(self, request):
+        """
+        Stops a QEMU VM instance.
+
+        Mandatory request parameters:
+        - id (QEMU VM instance identifier)
+
+        Response parameters:
+        - True on success
+
+        :param request: JSON request
+        """
+
+        # validate the request
+        if not self.validate_request(request, QEMU_STOP_SCHEMA):
+            return
+
+        # get the instance
+        qemu_instance = self.get_qemu_instance(request["id"])
+        if not qemu_instance:
+            return
+
+        try:
+            qemu_instance.stop()
+        except QemuError as e:
+            self.send_custom_error(str(e))
+            return
+        self.send_response(True)
+
+    @IModule.route("qemu.reload")
+    def qemu_reload(self, request):
+        """
+        Reloads a QEMU VM instance.
+
+        Mandatory request parameters:
+        - id (QEMU VM identifier)
+
+        Response parameters:
+        - True on success
+
+        :param request: JSON request
+        """
+
+        # validate the request
+        if not self.validate_request(request, QEMU_RELOAD_SCHEMA):
+            return
+
+        # get the instance
+        qemu_instance = self.get_qemu_instance(request["id"])
+        if not qemu_instance:
+            return
+
+        try:
+            qemu_instance.reload()
+        except QemuError as e:
+            self.send_custom_error(str(e))
+            return
+        self.send_response(True)
+
+    @IModule.route("qemu.stop")
+    def qemu_stop(self, request):
+        """
+        Stops a QEMU VM instance.
+
+        Mandatory request parameters:
+        - id (QEMU VM instance identifier)
+
+        Response parameters:
+        - True on success
+
+        :param request: JSON request
+        """
+
+        # validate the request
+        if not self.validate_request(request, QEMU_STOP_SCHEMA):
+            return
+
+        # get the instance
+        qemu_instance = self.get_qemu_instance(request["id"])
+        if not qemu_instance:
+            return
+
+        try:
+            qemu_instance.stop()
+        except QemuError as e:
+            self.send_custom_error(str(e))
+            return
+        self.send_response(True)
+
+    @IModule.route("qemu.suspend")
+    def qemu_suspend(self, request):
+        """
+        Suspends a QEMU VM instance.
+
+        Mandatory request parameters:
+        - id (QEMU VM instance identifier)
+
+        Response parameters:
+        - True on success
+
+        :param request: JSON request
+        """
+
+        # validate the request
+        if not self.validate_request(request, QEMU_SUSPEND_SCHEMA):
+            return
+
+        # get the instance
+        qemu_instance = self.get_qemu_instance(request["id"])
+        if not qemu_instance:
+            return
+
+        try:
+            qemu_instance.suspend()
+        except QemuError as e:
+            self.send_custom_error(str(e))
+            return
+        self.send_response(True)
+
+    @IModule.route("qemu.allocate_udp_port")
+    def allocate_udp_port(self, request):
+        """
+        Allocates a UDP port in order to create an UDP NIO.
+
+        Mandatory request parameters:
+        - id (QEMU VM identifier)
+        - port_id (unique port identifier)
+
+        Response parameters:
+        - port_id (unique port identifier)
+        - lport (allocated local port)
+
+        :param request: JSON request
+        """
+
+        # validate the request
+        if not self.validate_request(request, QEMU_ALLOCATE_UDP_PORT_SCHEMA):
+            return
+
+        # get the instance
+        qemu_instance = self.get_qemu_instance(request["id"])
+        if not qemu_instance:
+            return
+
+        try:
+            port = find_unused_port(self._udp_start_port_range,
+                                    self._udp_end_port_range,
+                                    host=self._host,
+                                    socket_type="UDP",
+                                    ignore_ports=self._allocated_udp_ports)
+        except Exception as e:
+            self.send_custom_error(str(e))
+            return
+
+        self._allocated_udp_ports.append(port)
+        log.info("{} [id={}] has allocated UDP port {} with host {}".format(qemu_instance.name,
+                                                                            qemu_instance.id,
+                                                                            port,
+                                                                            self._host))
+
+        response = {"lport": port,
+                    "port_id": request["port_id"]}
+        self.send_response(response)
+
+    @IModule.route("qemu.add_nio")
+    def add_nio(self, request):
+        """
+        Adds an NIO (Network Input/Output) for a QEMU VM instance.
+
+        Mandatory request parameters:
+        - id (QEMU VM instance identifier)
+        - port (port number)
+        - port_id (unique port identifier)
+        - nio (one of the following)
+            - type "nio_udp"
+                - lport (local port)
+                - rhost (remote host)
+                - rport (remote port)
+
+        Response parameters:
+        - port_id (unique port identifier)
+
+        :param request: JSON request
+        """
+
+        # validate the request
+        if not self.validate_request(request, QEMU_ADD_NIO_SCHEMA):
+            return
+
+        # get the instance
+        qemu_instance = self.get_qemu_instance(request["id"])
+        if not qemu_instance:
+            return
+
+        port = request["port"]
+        try:
+            nio = None
+            if request["nio"]["type"] == "nio_udp":
+                lport = request["nio"]["lport"]
+                rhost = request["nio"]["rhost"]
+                rport = request["nio"]["rport"]
+                try:
+                    #TODO: handle IPv6
+                    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
+                        sock.connect((rhost, rport))
+                except OSError as e:
+                    raise QemuError("Could not create an UDP connection to {}:{}: {}".format(rhost, rport, e))
+                nio = NIO_UDP(lport, rhost, rport)
+            if not nio:
+                raise QemuError("Requested NIO does not exist or is not supported: {}".format(request["nio"]["type"]))
+        except QemuError as e:
+            self.send_custom_error(str(e))
+            return
+
+        try:
+            qemu_instance.port_add_nio_binding(port, nio)
+        except QemuError as e:
+            self.send_custom_error(str(e))
+            return
+
+        self.send_response({"port_id": request["port_id"]})
+
+    @IModule.route("qemu.delete_nio")
+    def delete_nio(self, request):
+        """
+        Deletes an NIO (Network Input/Output).
+
+        Mandatory request parameters:
+        - id (QEMU VM instance identifier)
+        - port (port identifier)
+
+        Response parameters:
+        - True on success
+
+        :param request: JSON request
+        """
+
+        # validate the request
+        if not self.validate_request(request, QEMU_DELETE_NIO_SCHEMA):
+            return
+
+        # get the instance
+        qemu_instance = self.get_qemu_instance(request["id"])
+        if not qemu_instance:
+            return
+
+        port = request["port"]
+        try:
+            nio = qemu_instance.port_remove_nio_binding(port)
+            if isinstance(nio, NIO_UDP) and nio.lport in self._allocated_udp_ports:
+                self._allocated_udp_ports.remove(nio.lport)
+        except QemuError as e:
+            self.send_custom_error(str(e))
+            return
+
+        self.send_response(True)
+
+    def _get_qemu_version(self, qemu_path):
+        """
+        Gets the Qemu version.
+
+        :param qemu_path: path to Qemu
+        """
+
+        if sys.platform.startswith("win"):
+            return ""
+        try:
+            output = subprocess.check_output([qemu_path, "--version"])
+            match = re.search("QEMU emulator version ([0-9a-z\-\.]+)", output.decode("utf-8"))
+            if match:
+                version = match.group(1)
+                return version
+            else:
+                raise QemuError("Could not determine the Qemu version for {}".format(qemu_path))
+        except (OSError, subprocess.CalledProcessError) as e:
+            raise QemuError("Error while looking for the Qemu version: {}".format(e))
+
+    @IModule.route("qemu.qemu_list")
+    def qemu_list(self, request):
+        """
+        Gets QEMU binaries list.
+
+        Response parameters:
+        - Server address/host
+        - List of Qemu binaries
+        """
+
+        qemus = []
+        paths = [os.getcwd()] + os.environ["PATH"].split(os.pathsep)
+        # look for Qemu binaries in the current working directory and $PATH
+        if sys.platform.startswith("win"):
+            # add specific Windows paths
+            paths.append(os.path.join(os.getcwd(), "qemu"))
+            if "PROGRAMFILES(X86)" in os.environ and os.path.exists(os.environ["PROGRAMFILES(X86)"]):
+                paths.append(os.path.join(os.environ["PROGRAMFILES(X86)"], "qemu"))
+            if "PROGRAMFILES" in os.environ and os.path.exists(os.environ["PROGRAMFILES"]):
+                paths.append(os.path.join(os.environ["PROGRAMFILES"], "qemu"))
+        elif sys.platform.startswith("darwin"):
+            # add a specific location on Mac OS X regardless of what's in $PATH
+            paths.append("/usr/local/bin")
+        for path in paths:
+            try:
+                for f in os.listdir(path):
+                    if f.startswith("qemu-system") and os.access(os.path.join(path, f), os.X_OK):
+                        qemu_path = os.path.join(path, f)
+                        version = self._get_qemu_version(qemu_path)
+                        qemus.append({"path": qemu_path, "version": version})
+            except OSError:
+                continue
+
+        response = {"server": self._host,
+                    "qemus": qemus}
+        self.send_response(response)
+
+    @IModule.route("qemu.echo")
+    def echo(self, request):
+        """
+        Echo end point for testing purposes.
+
+        :param request: JSON request
+        """
+
+        if request is None:
+            self.send_param_error()
+        else:
+            log.debug("received request {}".format(request))
+            self.send_response(request)

gns3server/modules/qemu/adapters/adapter.py

@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+class Adapter(object):
+    """
+    Base class for adapters.
+
+    :param interfaces: number of interfaces supported by this adapter.
+    """
+
+    def __init__(self, interfaces=1):
+
+        self._interfaces = interfaces
+
+        self._ports = {}
+        for port_id in range(0, interfaces):
+            self._ports[port_id] = None
+
+    def removable(self):
+        """
+        Returns True if the adapter can be removed from a slot
+        and False if not.
+
+        :returns: boolean
+        """
+
+        return True
+
+    def port_exists(self, port_id):
+        """
+        Checks if a port exists on this adapter.
+
+        :returns: True is the port exists,
+        False otherwise.
+        """
+
+        if port_id in self._ports:
+            return True
+        return False
+
+    def add_nio(self, port_id, nio):
+        """
+        Adds a NIO to a port on this adapter.
+
+        :param port_id: port ID (integer)
+        :param nio: NIO instance
+        """
+
+        self._ports[port_id] = nio
+
+    def remove_nio(self, port_id):
+        """
+        Removes a NIO from a port on this adapter.
+
+        :param port_id: port ID (integer)
+        """
+
+        self._ports[port_id] = None
+
+    def get_nio(self, port_id):
+        """
+        Returns the NIO assigned to a port.
+
+        :params port_id: port ID (integer)
+
+        :returns: NIO instance
+        """
+
+        return self._ports[port_id]
+
+    @property
+    def ports(self):
+        """
+        Returns port to NIO mapping
+
+        :returns: dictionary port -> NIO
+        """
+
+        return self._ports
+
+    @property
+    def interfaces(self):
+        """
+        Returns the number of interfaces supported by this adapter.
+
+        :returns: number of interfaces
+        """
+
+        return self._interfaces

gns3server/modules/qemu/adapters/ethernet_adapter.py

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from .adapter import Adapter
+
+
+class EthernetAdapter(Adapter):
+    """
+    QEMU Ethernet adapter.
+    """
+
+    def __init__(self):
+        Adapter.__init__(self, interfaces=1)
+
+    def __str__(self):
+
+        return "QEMU Ethernet adapter"

gns3server/modules/qemu/nios/nio.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+Base interface for NIOs.
+"""
+
+
+class NIO(object):
+    """
+    Network Input/Output.
+    """
+
+    def __init__(self):
+
+        self._capturing = False
+        self._pcap_output_file = ""
+
+    def startPacketCapture(self, pcap_output_file):
+        """
+
+        :param pcap_output_file: PCAP destination file for the capture
+        """
+
+        self._capturing = True
+        self._pcap_output_file = pcap_output_file
+
+    def stopPacketCapture(self):
+
+        self._capturing = False
+        self._pcap_output_file = ""
+
+    @property
+    def capturing(self):
+        """
+        Returns either a capture is configured on this NIO.
+
+        :returns: boolean
+        """
+
+        return self._capturing
+
+    @property
+    def pcap_output_file(self):
+        """
+        Returns the path to the PCAP output file.
+
+        :returns: path to the PCAP output file
+        """
+
+        return self._pcap_output_file

gns3server/modules/qemu/nios/nio_udp.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+Interface for UDP NIOs.
+"""
+
+from .nio import NIO
+
+
+class NIO_UDP(NIO):
+    """
+    UDP NIO.
+
+    :param lport: local port number
+    :param rhost: remote address/host
+    :param rport: remote port number
+    """
+
+    _instance_count = 0
+
+    def __init__(self, lport, rhost, rport):
+
+        NIO.__init__(self)
+        self._lport = lport
+        self._rhost = rhost
+        self._rport = rport
+
+    @property
+    def lport(self):
+        """
+        Returns the local port
+
+        :returns: local port number
+        """
+
+        return self._lport
+
+    @property
+    def rhost(self):
+        """
+        Returns the remote host
+
+        :returns: remote address/host
+        """
+
+        return self._rhost
+
+    @property
+    def rport(self):
+        """
+        Returns the remote port
+
+        :returns: remote port number
+        """
+
+        return self._rport
+
+    def __str__(self):
+
+        return "NIO UDP"

gns3server/modules/qemu/qemu_error.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+Custom exceptions for QEMU module.
+"""
+
+
+class QemuError(Exception):
+
+    def __init__(self, message, original_exception=None):
+
+        Exception.__init__(self, message)
+        if isinstance(message, Exception):
+            message = str(message)
+        self._message = message
+        self._original_exception = original_exception
+
+    def __repr__(self):
+
+        return self._message
+
+    def __str__(self):
+
+        return self._message

gns3server/modules/qemu/qemu_vm.py

@@ -0,0 +1,785 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+QEMU VM instance.
+"""
+
+import os
+import shutil
+import random
+import subprocess
+import shlex
+
+from .qemu_error import QemuError
+from .adapters.ethernet_adapter import EthernetAdapter
+from .nios.nio_udp import NIO_UDP
+from ..attic import find_unused_port
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class QemuVM(object):
+    """
+    QEMU VM implementation.
+
+    :param name: name of this QEMU VM
+    :param qemu_path: path to the QEMU binary
+    :param working_dir: path to a working directory
+    :param host: host/address to bind for console and UDP connections
+    :param qemu_id: QEMU VM instance ID
+    :param console: TCP console port
+    :param console_start_port_range: TCP console port range start
+    :param console_end_port_range: TCP console port range end
+    """
+
+    _instances = []
+    _allocated_console_ports = []
+
+    def __init__(self,
+                 name,
+                 qemu_path,
+                 working_dir,
+                 host="127.0.0.1",
+                 qemu_id=None,
+                 console=None,
+                 console_start_port_range=5001,
+                 console_end_port_range=5500):
+
+        if not qemu_id:
+            self._id = 0
+            for identifier in range(1, 1024):
+                if identifier not in self._instances:
+                    self._id = identifier
+                    self._instances.append(self._id)
+                    break
+
+            if self._id == 0:
+                raise QemuError("Maximum number of QEMU VM instances reached")
+        else:
+            if qemu_id in self._instances:
+                raise QemuError("QEMU identifier {} is already used by another QEMU VM instance".format(qemu_id))
+            self._id = qemu_id
+            self._instances.append(self._id)
+
+        self._name = name
+        self._working_dir = None
+        self._host = host
+        self._command = []
+        self._started = False
+        self._process = None
+        self._stdout_file = ""
+        self._console_start_port_range = console_start_port_range
+        self._console_end_port_range = console_end_port_range
+
+        # QEMU settings
+        self._qemu_path = qemu_path
+        self._hda_disk_image = ""
+        self._hdb_disk_image = ""
+        self._options = ""
+        self._ram = 256
+        self._console = console
+        self._ethernet_adapters = []
+        self._adapter_type = "e1000"
+        self._initrd = ""
+        self._kernel_image = ""
+        self._kernel_command_line = ""
+
+        working_dir_path = os.path.join(working_dir, "qemu", "vm-{}".format(self._id))
+
+        if qemu_id and not os.path.isdir(working_dir_path):
+            raise QemuError("Working directory {} doesn't exist".format(working_dir_path))
+
+        # create the device own working directory
+        self.working_dir = working_dir_path
+
+        if not self._console:
+            # allocate a console port
+            try:
+                self._console = find_unused_port(self._console_start_port_range,
+                                                 self._console_end_port_range,
+                                                 self._host,
+                                                 ignore_ports=self._allocated_console_ports)
+            except Exception as e:
+                raise QemuError(e)
+
+        if self._console in self._allocated_console_ports:
+            raise QemuError("Console port {} is already used by another QEMU VM".format(console))
+        self._allocated_console_ports.append(self._console)
+
+        self.adapters = 1  # creates 1 adapter by default
+        log.info("QEMU VM {name} [id={id}] has been created".format(name=self._name,
+                                                                    id=self._id))
+
+    def defaults(self):
+        """
+        Returns all the default attribute values for this QEMU VM.
+
+        :returns: default values (dictionary)
+        """
+
+        qemu_defaults = {"name": self._name,
+                         "qemu_path": self._qemu_path,
+                         "ram": self._ram,
+                         "hda_disk_image": self._hda_disk_image,
+                         "hdb_disk_image": self._hdb_disk_image,
+                         "options": self._options,
+                         "adapters": self.adapters,
+                         "adapter_type": self._adapter_type,
+                         "console": self._console,
+                         "initrd": self._initrd,
+                         "kernel_image": self._kernel_image,
+                         "kernel_command_line": self._kernel_command_line}
+
+        return qemu_defaults
+
+    @property
+    def id(self):
+        """
+        Returns the unique ID for this QEMU VM.
+
+        :returns: id (integer)
+        """
+
+        return self._id
+
+    @classmethod
+    def reset(cls):
+        """
+        Resets allocated instance list.
+        """
+
+        cls._instances.clear()
+        cls._allocated_console_ports.clear()
+
+    @property
+    def name(self):
+        """
+        Returns the name of this QEMU VM.
+
+        :returns: name
+        """
+
+        return self._name
+
+    @name.setter
+    def name(self, new_name):
+        """
+        Sets the name of this QEMU VM.
+
+        :param new_name: name
+        """
+
+        log.info("QEMU VM {name} [id={id}]: renamed to {new_name}".format(name=self._name,
+                                                                          id=self._id,
+                                                                          new_name=new_name))
+
+        self._name = new_name
+
+    @property
+    def working_dir(self):
+        """
+        Returns current working directory
+
+        :returns: path to the working directory
+        """
+
+        return self._working_dir
+
+    @working_dir.setter
+    def working_dir(self, working_dir):
+        """
+        Sets the working directory this QEMU VM.
+
+        :param working_dir: path to the working directory
+        """
+
+        try:
+            os.makedirs(working_dir)
+        except FileExistsError:
+            pass
+        except OSError as e:
+            raise QemuError("Could not create working directory {}: {}".format(working_dir, e))
+
+        self._working_dir = working_dir
+        log.info("QEMU VM {name} [id={id}]: working directory changed to {wd}".format(name=self._name,
+                                                                                      id=self._id,
+                                                                                      wd=self._working_dir))
+
+    @property
+    def console(self):
+        """
+        Returns the TCP console port.
+
+        :returns: console port (integer)
+        """
+
+        return self._console
+
+    @console.setter
+    def console(self, console):
+        """
+        Sets the TCP console port.
+
+        :param console: console port (integer)
+        """
+
+        if console in self._allocated_console_ports:
+            raise QemuError("Console port {} is already used by another QEMU VM".format(console))
+
+        self._allocated_console_ports.remove(self._console)
+        self._console = console
+        self._allocated_console_ports.append(self._console)
+
+        log.info("QEMU VM {name} [id={id}]: console port set to {port}".format(name=self._name,
+                                                                               id=self._id,
+                                                                               port=console))
+
+    def delete(self):
+        """
+        Deletes this QEMU VM.
+        """
+
+        self.stop()
+        if self._id in self._instances:
+            self._instances.remove(self._id)
+
+        if self.console and self.console in self._allocated_console_ports:
+            self._allocated_console_ports.remove(self.console)
+
+        log.info("QEMU VM {name} [id={id}] has been deleted".format(name=self._name,
+                                                                    id=self._id))
+
+    def clean_delete(self):
+        """
+        Deletes this QEMU VM & all files.
+        """
+
+        self.stop()
+        if self._id in self._instances:
+            self._instances.remove(self._id)
+
+        if self.console:
+            self._allocated_console_ports.remove(self.console)
+
+        try:
+            shutil.rmtree(self._working_dir)
+        except OSError as e:
+            log.error("could not delete QEMU VM {name} [id={id}]: {error}".format(name=self._name,
+                                                                                  id=self._id,
+                                                                                  error=e))
+            return
+
+        log.info("QEMU VM {name} [id={id}] has been deleted (including associated files)".format(name=self._name,
+                                                                                                 id=self._id))
+
+    @property
+    def qemu_path(self):
+        """
+        Returns the QEMU binary path for this QEMU VM.
+
+        :returns: QEMU path
+        """
+
+        return self._qemu_path
+
+    @qemu_path.setter
+    def qemu_path(self, qemu_path):
+        """
+        Sets the QEMU binary path this QEMU VM.
+
+        :param qemu_path: QEMU path
+        """
+
+        log.info("QEMU VM {name} [id={id}] has set the QEMU path to {qemu_path}".format(name=self._name,
+                                                                                        id=self._id,
+                                                                                        qemu_path=qemu_path))
+        self._qemu_path = qemu_path
+
+    @property
+    def hda_disk_image(self):
+        """
+        Returns the hda disk image path for this QEMU VM.
+
+        :returns: QEMU hda disk image path
+        """
+
+        return self._hda_disk_image
+
+    @hda_disk_image.setter
+    def hda_disk_image(self, hda_disk_image):
+        """
+        Sets the hda disk image for this QEMU VM.
+
+        :param hda_disk_image: QEMU hda disk image path
+        """
+
+        log.info("QEMU VM {name} [id={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
+
+    @property
+    def hdb_disk_image(self):
+        """
+        Returns the hdb disk image path for this QEMU VM.
+
+        :returns: QEMU hdb disk image path
+        """
+
+        return self._hdb_disk_image
+
+    @hdb_disk_image.setter
+    def hdb_disk_image(self, hdb_disk_image):
+        """
+        Sets the hdb disk image for this QEMU VM.
+
+        :param hdb_disk_image: QEMU hdb disk image path
+        """
+
+        log.info("QEMU VM {name} [id={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
+
+
+    @property
+    def adapters(self):
+        """
+        Returns the number of Ethernet adapters for this QEMU VM instance.
+
+        :returns: number of adapters
+        """
+
+        return len(self._ethernet_adapters)
+
+    @adapters.setter
+    def adapters(self, adapters):
+        """
+        Sets the number of Ethernet adapters for this QEMU VM instance.
+
+        :param adapters: number of adapters
+        """
+
+        self._ethernet_adapters.clear()
+        for adapter_id in range(0, adapters):
+            self._ethernet_adapters.append(EthernetAdapter())
+
+        log.info("QEMU VM {name} [id={id}]: number of Ethernet adapters changed to {adapters}".format(name=self._name,
+                                                                                                      id=self._id,
+                                                                                                      adapters=adapters))
+
+    @property
+    def adapter_type(self):
+        """
+        Returns the adapter type for this QEMU VM instance.
+
+        :returns: adapter type (string)
+        """
+
+        return self._adapter_type
+
+    @adapter_type.setter
+    def adapter_type(self, adapter_type):
+        """
+        Sets the adapter type for this QEMU VM instance.
+
+        :param adapter_type: adapter type (string)
+        """
+
+        self._adapter_type = adapter_type
+
+        log.info("QEMU VM {name} [id={id}]: adapter type changed to {adapter_type}".format(name=self._name,
+                                                                                           id=self._id,
+                                                                                           adapter_type=adapter_type))
+
+    @property
+    def ram(self):
+        """
+        Returns the RAM amount for this QEMU VM.
+
+        :returns: RAM amount in MB
+        """
+
+        return self._ram
+
+    @ram.setter
+    def ram(self, ram):
+        """
+        Sets the amount of RAM for this QEMU VM.
+
+        :param ram: RAM amount in MB
+        """
+
+        log.info("QEMU VM {name} [id={id}] has set the RAM to {ram}".format(name=self._name,
+                                                                            id=self._id,
+                                                                            ram=ram))
+        self._ram = ram
+
+    @property
+    def options(self):
+        """
+        Returns the options for this QEMU VM.
+
+        :returns: QEMU options
+        """
+
+        return self._options
+
+    @options.setter
+    def options(self, options):
+        """
+        Sets the options for this QEMU VM.
+
+        :param options: QEMU options
+        """
+
+        log.info("QEMU VM {name} [id={id}] has set the QEMU options to {options}".format(name=self._name,
+                                                                                         id=self._id,
+                                                                                         options=options))
+        self._options = options
+
+    @property
+    def initrd(self):
+        """
+        Returns the initrd path for this QEMU VM.
+
+        :returns: QEMU initrd path
+        """
+
+        return self._initrd
+
+    @initrd.setter
+    def initrd(self, initrd):
+        """
+        Sets the initrd path for this QEMU VM.
+
+        :param initrd: QEMU initrd path
+        """
+
+        log.info("QEMU VM {name} [id={id}] has set the QEMU initrd path to {initrd}".format(name=self._name,
+                                                                                            id=self._id,
+                                                                                            initrd=initrd))
+        self._initrd = initrd
+
+    @property
+    def kernel_image(self):
+        """
+        Returns the kernel image path for this QEMU VM.
+
+        :returns: QEMU kernel image path
+        """
+
+        return self._kernel_image
+
+    @kernel_image.setter
+    def kernel_image(self, kernel_image):
+        """
+        Sets the kernel image path for this QEMU VM.
+
+        :param kernel_image: QEMU kernel image path
+        """
+
+        log.info("QEMU VM {name} [id={id}] has set the QEMU kernel image path to {kernel_image}".format(name=self._name,
+                                                                                                        id=self._id,
+                                                                                                        kernel_image=kernel_image))
+        self._kernel_image = kernel_image
+
+    @property
+    def kernel_command_line(self):
+        """
+        Returns the kernel command line for this QEMU VM.
+
+        :returns: QEMU kernel command line
+        """
+
+        return self._kernel_command_line
+
+    @kernel_command_line.setter
+    def kernel_command_line(self, kernel_command_line):
+        """
+        Sets the kernel command line for this QEMU VM.
+
+        :param kernel_command_line: QEMU kernel command line
+        """
+
+        log.info("QEMU VM {name} [id={id}] has set the QEMU kernel command line to {kernel_command_line}".format(name=self._name,
+                                                                                                                 id=self._id,
+                                                                                                                 kernel_command_line=kernel_command_line))
+        self._kernel_command_line = kernel_command_line
+
+    def start(self):
+        """
+        Starts this QEMU VM.
+        """
+
+        if not self.is_running():
+
+            if not os.path.isfile(self._qemu_path) or not os.path.exists(self._qemu_path):
+                raise QemuError("QEMU binary '{}' is not accessible".format(self._qemu_path))
+
+            self._command = self._build_command()
+            try:
+                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:
+                    self._process = subprocess.Popen(self._command,
+                                                     stdout=fd,
+                                                     stderr=subprocess.STDOUT,
+                                                     cwd=self._working_dir)
+                log.info("QEMU VM instance {} started PID={}".format(self._id, self._process.pid))
+                self._started = True
+            except OSError as e:
+                stdout = self.read_stdout()
+                log.error("could not start QEMU {}: {}\n{}".format(self._qemu_path, e, stdout))
+                raise QemuError("could not start QEMU {}: {}\n{}".format(self._qemu_path, e, stdout))
+
+    def stop(self):
+        """
+        Stops this QEMU VM.
+        """
+
+        # stop the QEMU process
+        if self.is_running():
+            log.info("stopping QEMU VM instance {} PID={}".format(self._id, self._process.pid))
+            try:
+                self._process.terminate()
+                self._process.wait(1)
+            except subprocess.TimeoutExpired:
+                self._process.kill()
+                if self._process.poll() is None:
+                    log.warn("QEMU VM instance {} PID={} is still running".format(self._id,
+                                                                                  self._process.pid))
+        self._process = None
+        self._started = False
+
+    def suspend(self):
+        """
+        Suspends this QEMU VM.
+        """
+
+        pass
+
+    def reload(self):
+        """
+        Reloads this QEMU VM.
+        """
+
+        pass
+
+    def resume(self):
+        """
+        Resumes this QEMU VM.
+        """
+
+        pass
+
+    def port_add_nio_binding(self, adapter_id, nio):
+        """
+        Adds a port NIO binding.
+
+        :param adapter_id: adapter ID
+        :param nio: NIO instance to add to the slot/port
+        """
+
+        try:
+            adapter = self._ethernet_adapters[adapter_id]
+        except IndexError:
+            raise QemuError("Adapter {adapter_id} doesn't exist on QEMU VM {name}".format(name=self._name,
+                                                                                          adapter_id=adapter_id))
+
+        adapter.add_nio(0, nio)
+        log.info("QEMU VM {name} [id={id}]: {nio} added to adapter {adapter_id}".format(name=self._name,
+                                                                                        id=self._id,
+                                                                                        nio=nio,
+                                                                                        adapter_id=adapter_id))
+
+    def port_remove_nio_binding(self, adapter_id):
+        """
+        Removes a port NIO binding.
+
+        :param adapter_id: adapter ID
+
+        :returns: NIO instance
+        """
+
+        try:
+            adapter = self._ethernet_adapters[adapter_id]
+        except IndexError:
+            raise QemuError("Adapter {adapter_id} doesn't exist on QEMU VM {name}".format(name=self._name,
+                                                                                          adapter_id=adapter_id))
+
+        nio = adapter.get_nio(0)
+        adapter.remove_nio(0)
+        log.info("QEMU VM {name} [id={id}]: {nio} removed from adapter {adapter_id}".format(name=self._name,
+                                                                                            id=self._id,
+                                                                                            nio=nio,
+                                                                                            adapter_id=adapter_id))
+        return nio
+
+    @property
+    def started(self):
+        """
+        Returns either this QEMU VM has been started or not.
+
+        :returns: boolean
+        """
+
+        return self._started
+
+    def read_stdout(self):
+        """
+        Reads the standard output of the QEMU process.
+        Only use when the process has been stopped or has crashed.
+        """
+
+        output = ""
+        if self._stdout_file:
+            try:
+                with open(self._stdout_file, errors="replace") as file:
+                    output = file.read()
+            except OSError as e:
+                log.warn("could not read {}: {}".format(self._stdout_file, e))
+        return output
+
+    def is_running(self):
+        """
+        Checks if the QEMU process is running
+
+        :returns: True or False
+        """
+
+        if self._process and self._process.poll() is None:
+            return True
+        return False
+
+    def command(self):
+        """
+        Returns the QEMU command line.
+
+        :returns: QEMU command line (string)
+        """
+
+        return " ".join(self._build_command())
+
+    def _serial_options(self):
+
+        if self._console:
+            return ["-serial", "telnet:{}:{},server,nowait".format(self._host, self._console)]
+        else:
+            return []
+
+    def _disk_options(self):
+
+        options = []
+        qemu_img_path = ""
+        qemu_path_dir = os.path.dirname(self._qemu_path)
+        try:
+            for f in os.listdir(qemu_path_dir):
+                if f.startswith("qemu-img"):
+                    qemu_img_path = os.path.join(qemu_path_dir, f)
+        except OSError as e:
+            raise QemuError("Error while looking for qemu-img in {}: {}".format(qemu_path_dir, e))
+
+        if not qemu_img_path:
+            raise QemuError("Could not find qemu-img in {}".format(qemu_path_dir))
+
+        try:
+            if self._hda_disk_image:
+                hda_disk = os.path.join(self._working_dir, "hda_disk.qcow2")
+                if not os.path.exists(hda_disk):
+                    retcode = subprocess.call([qemu_img_path, "create", "-o",
+                                               "backing_file={}".format(self._hda_disk_image),
+                                               "-f", "qcow2", hda_disk])
+                    log.info("{} returned with {}".format(qemu_img_path, retcode))
+            else:
+                # create a "FLASH" with 256MB if no disk image has been specified
+                hda_disk = os.path.join(self._working_dir, "flash.qcow2")
+                if not os.path.exists(hda_disk):
+                    retcode = subprocess.call([qemu_img_path, "create", "-f", "qcow2", hda_disk, "256M"])
+                    log.info("{} returned with {}".format(qemu_img_path, retcode))
+
+        except OSError as e:
+            raise QemuError("Could not create disk image {}".format(e))
+
+        options.extend(["-hda", hda_disk])
+        if self._hdb_disk_image:
+            hdb_disk = os.path.join(self._working_dir, "hdb_disk.qcow2")
+            if not os.path.exists(hdb_disk):
+                try:
+                    retcode = subprocess.call([qemu_img_path, "create", "-o",
+                                              "backing_file={}".format(self._hdb_disk_image),
+                                              "-f", "qcow2", hdb_disk])
+                    log.info("{} returned with {}".format(qemu_img_path, retcode))
+                except OSError as e:
+                    raise QemuError("Could not create disk image {}".format(e))
+            options.extend(["-hdb", hdb_disk])
+
+        return options
+
+    def _linux_boot_options(self):
+
+        options = []
+        if self._initrd:
+            options.extend(["-initrd", self._initrd])
+        if self._kernel_image:
+            options.extend(["-kernel", self._kernel_image])
+        if self._kernel_command_line:
+            options.extend(["-append", self._kernel_command_line])
+
+        return options
+
+    def _network_options(self):
+
+        network_options = []
+        adapter_id = 0
+        for adapter in self._ethernet_adapters:
+            #TODO: let users specify a base mac address
+            mac = "00:00:ab:%02x:%02x:%02d" % (random.randint(0x00, 0xff), random.randint(0x00, 0xff), adapter_id)
+            network_options.extend(["-device", "{},mac={},netdev=gns3-{}".format(self._adapter_type, mac, adapter_id)])
+            nio = adapter.get_nio(0)
+            if nio and isinstance(nio, NIO_UDP):
+                network_options.extend(["-netdev", "socket,id=gns3-{},udp={}:{},localaddr={}:{}".format(adapter_id,
+                                                                                                        nio.rhost,
+                                                                                                        nio.rport,
+                                                                                                        self._host,
+                                                                                                        nio.lport)])
+            else:
+                network_options.extend(["-netdev", "user,id=gns3-{}".format(adapter_id)])
+            adapter_id += 1
+
+        return network_options
+
+    def _build_command(self):
+        """
+        Command to start the QEMU process.
+        (to be passed to subprocess.Popen())
+        """
+
+        command = [self._qemu_path]
+        command.extend(["-name", self._name])
+        command.extend(["-m", str(self._ram)])
+        command.extend(self._disk_options())
+        command.extend(self._linux_boot_options())
+        command.extend(self._serial_options())
+        additional_options = self._options.strip()
+        if additional_options:
+            command.extend(shlex.split(additional_options))
+        command.extend(self._network_options())
+        return command

gns3server/modules/qemu/schemas.py

@@ -0,0 +1,388 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+QEMU_CREATE_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to create a new QEMU VM instance",
+    "type": "object",
+    "properties": {
+        "name": {
+            "description": "QEMU VM instance name",
+            "type": "string",
+            "minLength": 1,
+        },
+        "qemu_path": {
+            "description": "Path to QEMU",
+            "type": "string",
+            "minLength": 1,
+        },
+        "qemu_id": {
+            "description": "QEMU VM instance ID",
+            "type": "integer"
+        },
+        "console": {
+            "description": "console TCP port",
+            "minimum": 1,
+            "maximum": 65535,
+            "type": "integer"
+        },
+    },
+    "additionalProperties": False,
+    "required": ["name", "qemu_path"],
+}
+
+QEMU_DELETE_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to delete a QEMU VM instance",
+    "type": "object",
+    "properties": {
+        "id": {
+            "description": "QEMU VM instance ID",
+            "type": "integer"
+        },
+    },
+    "additionalProperties": False,
+    "required": ["id"]
+}
+
+QEMU_UPDATE_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to update a QEMU VM instance",
+    "type": "object",
+    "properties": {
+        "id": {
+            "description": "QEMU VM instance ID",
+            "type": "integer"
+        },
+        "name": {
+            "description": "QEMU VM instance name",
+            "type": "string",
+            "minLength": 1,
+        },
+        "qemu_path": {
+            "description": "path to QEMU",
+            "type": "string",
+            "minLength": 1,
+        },
+        "hda_disk_image": {
+            "description": "QEMU hda disk image path",
+            "type": "string",
+        },
+        "hdb_disk_image": {
+            "description": "QEMU hdb disk image path",
+            "type": "string",
+        },
+        "ram": {
+            "description": "amount of RAM in MB",
+            "type": "integer"
+        },
+        "adapters": {
+            "description": "number of adapters",
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 8,
+        },
+        "adapter_type": {
+            "description": "QEMU adapter type",
+            "type": "string",
+            "minLength": 1,
+        },
+        "console": {
+            "description": "console TCP port",
+            "minimum": 1,
+            "maximum": 65535,
+            "type": "integer"
+        },
+        "initrd": {
+            "description": "QEMU initrd path",
+            "type": "string",
+        },
+        "kernel_image": {
+            "description": "QEMU kernel image path",
+            "type": "string",
+        },
+        "kernel_command_line": {
+            "description": "QEMU kernel command line",
+            "type": "string",
+        },
+        "options": {
+            "description": "additional QEMU options",
+            "type": "string",
+        },
+    },
+    "additionalProperties": False,
+    "required": ["id"]
+}
+
+QEMU_START_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to start a QEMU VM instance",
+    "type": "object",
+    "properties": {
+        "id": {
+            "description": "QEMU VM instance ID",
+            "type": "integer"
+        },
+    },
+    "additionalProperties": False,
+    "required": ["id"]
+}
+
+QEMU_STOP_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to stop a QEMU VM instance",
+    "type": "object",
+    "properties": {
+        "id": {
+            "description": "QEMU VM instance ID",
+            "type": "integer"
+        },
+    },
+    "additionalProperties": False,
+    "required": ["id"]
+}
+
+QEMU_SUSPEND_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to suspend a QEMU VM instance",
+    "type": "object",
+    "properties": {
+        "id": {
+            "description": "QEMU VM instance ID",
+            "type": "integer"
+        },
+    },
+    "additionalProperties": False,
+    "required": ["id"]
+}
+
+QEMU_RELOAD_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to reload a QEMU VM instance",
+    "type": "object",
+    "properties": {
+        "id": {
+            "description": "QEMU VM instance ID",
+            "type": "integer"
+        },
+    },
+    "additionalProperties": False,
+    "required": ["id"]
+}
+
+QEMU_ALLOCATE_UDP_PORT_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to allocate an UDP port for a QEMU VM instance",
+    "type": "object",
+    "properties": {
+        "id": {
+            "description": "QEMU VM instance ID",
+            "type": "integer"
+        },
+        "port_id": {
+            "description": "Unique port identifier for the QEMU VM instance",
+            "type": "integer"
+        },
+    },
+    "additionalProperties": False,
+    "required": ["id", "port_id"]
+}
+
+QEMU_ADD_NIO_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to add a NIO for a QEMU VM instance",
+    "type": "object",
+
+    "definitions": {
+        "UDP": {
+            "description": "UDP Network Input/Output",
+            "properties": {
+                "type": {
+                    "enum": ["nio_udp"]
+                },
+                "lport": {
+                    "description": "Local port",
+                    "type": "integer",
+                    "minimum": 1,
+                    "maximum": 65535
+                },
+                "rhost": {
+                    "description": "Remote host",
+                    "type": "string",
+                    "minLength": 1
+                },
+                "rport": {
+                    "description": "Remote port",
+                    "type": "integer",
+                    "minimum": 1,
+                    "maximum": 65535
+                }
+            },
+            "required": ["type", "lport", "rhost", "rport"],
+            "additionalProperties": False
+        },
+        "Ethernet": {
+            "description": "Generic Ethernet Network Input/Output",
+            "properties": {
+                "type": {
+                    "enum": ["nio_generic_ethernet"]
+                },
+                "ethernet_device": {
+                    "description": "Ethernet device name e.g. eth0",
+                    "type": "string",
+                    "minLength": 1
+                },
+            },
+            "required": ["type", "ethernet_device"],
+            "additionalProperties": False
+        },
+        "LinuxEthernet": {
+            "description": "Linux Ethernet Network Input/Output",
+            "properties": {
+                "type": {
+                    "enum": ["nio_linux_ethernet"]
+                },
+                "ethernet_device": {
+                    "description": "Ethernet device name e.g. eth0",
+                    "type": "string",
+                    "minLength": 1
+                },
+            },
+            "required": ["type", "ethernet_device"],
+            "additionalProperties": False
+        },
+        "TAP": {
+            "description": "TAP Network Input/Output",
+            "properties": {
+                "type": {
+                    "enum": ["nio_tap"]
+                },
+                "tap_device": {
+                    "description": "TAP device name e.g. tap0",
+                    "type": "string",
+                    "minLength": 1
+                },
+            },
+            "required": ["type", "tap_device"],
+            "additionalProperties": False
+        },
+        "UNIX": {
+            "description": "UNIX Network Input/Output",
+            "properties": {
+                "type": {
+                    "enum": ["nio_unix"]
+                },
+                "local_file": {
+                    "description": "path to the UNIX socket file (local)",
+                    "type": "string",
+                    "minLength": 1
+                },
+                "remote_file": {
+                    "description": "path to the UNIX socket file (remote)",
+                    "type": "string",
+                    "minLength": 1
+                },
+            },
+            "required": ["type", "local_file", "remote_file"],
+            "additionalProperties": False
+        },
+        "VDE": {
+            "description": "VDE Network Input/Output",
+            "properties": {
+                "type": {
+                    "enum": ["nio_vde"]
+                },
+                "control_file": {
+                    "description": "path to the VDE control file",
+                    "type": "string",
+                    "minLength": 1
+                },
+                "local_file": {
+                    "description": "path to the VDE control file",
+                    "type": "string",
+                    "minLength": 1
+                },
+            },
+            "required": ["type", "control_file", "local_file"],
+            "additionalProperties": False
+        },
+        "NULL": {
+            "description": "NULL Network Input/Output",
+            "properties": {
+                "type": {
+                    "enum": ["nio_null"]
+                },
+            },
+            "required": ["type"],
+            "additionalProperties": False
+        },
+    },
+
+    "properties": {
+        "id": {
+            "description": "QEMU VM instance ID",
+            "type": "integer"
+        },
+        "port_id": {
+            "description": "Unique port identifier for the QEMU VM instance",
+            "type": "integer"
+        },
+        "port": {
+            "description": "Port number",
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 8
+        },
+        "nio": {
+            "type": "object",
+            "description": "Network Input/Output",
+            "oneOf": [
+                {"$ref": "#/definitions/UDP"},
+                {"$ref": "#/definitions/Ethernet"},
+                {"$ref": "#/definitions/LinuxEthernet"},
+                {"$ref": "#/definitions/TAP"},
+                {"$ref": "#/definitions/UNIX"},
+                {"$ref": "#/definitions/VDE"},
+                {"$ref": "#/definitions/NULL"},
+            ]
+        },
+    },
+    "additionalProperties": False,
+    "required": ["id", "port_id", "port", "nio"]
+}
+
+
+QEMU_DELETE_NIO_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to delete a NIO for a QEMU VM instance",
+    "type": "object",
+    "properties": {
+        "id": {
+            "description": "QEMU VM instance ID",
+            "type": "integer"
+        },
+        "port": {
+            "description": "Port number",
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 8
+        },
+    },
+    "additionalProperties": False,
+    "required": ["id", "port"]
+}

gns3server/modules/virtualbox/__init__.py

@@ -0,0 +1,806 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+VirtualBox server module.
+"""
+
+import sys
+import os
+import socket
+import shutil
+
+from pkg_resources import parse_version
+from gns3server.modules import IModule
+from gns3server.config import Config
+from .virtualbox_vm import VirtualBoxVM
+from .virtualbox_error import VirtualBoxError
+from .vboxwrapper_client import VboxWrapperClient
+from .nios.nio_udp import NIO_UDP
+from ..attic import find_unused_port
+
+from .schemas import VBOX_CREATE_SCHEMA
+from .schemas import VBOX_DELETE_SCHEMA
+from .schemas import VBOX_UPDATE_SCHEMA
+from .schemas import VBOX_START_SCHEMA
+from .schemas import VBOX_STOP_SCHEMA
+from .schemas import VBOX_SUSPEND_SCHEMA
+from .schemas import VBOX_RELOAD_SCHEMA
+from .schemas import VBOX_ALLOCATE_UDP_PORT_SCHEMA
+from .schemas import VBOX_ADD_NIO_SCHEMA
+from .schemas import VBOX_DELETE_NIO_SCHEMA
+from .schemas import VBOX_START_CAPTURE_SCHEMA
+from .schemas import VBOX_STOP_CAPTURE_SCHEMA
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class VirtualBox(IModule):
+    """
+    VirtualBox module.
+
+    :param name: module name
+    :param args: arguments for the module
+    :param kwargs: named arguments for the module
+    """
+
+    def __init__(self, name, *args, **kwargs):
+
+        # get the vboxwrapper location (only non-Windows platforms)
+        if not sys.platform.startswith("win"):
+            config = Config.instance()
+            vbox_config = config.get_section_config(name.upper())
+            self._vboxwrapper_path = vbox_config.get("vboxwrapper_path")
+            if not self._vboxwrapper_path or not os.path.isfile(self._vboxwrapper_path):
+                paths = [os.getcwd()] + os.environ["PATH"].split(os.pathsep)
+                # look for vboxwrapper in the current working directory and $PATH
+                for path in paths:
+                    try:
+                        if "vboxwrapper" in os.listdir(path) and os.access(os.path.join(path, "vboxwrapper"), os.X_OK):
+                            self._vboxwrapper_path = os.path.join(path, "vboxwrapper")
+                            break
+                    except OSError:
+                        continue
+
+            if not self._vboxwrapper_path:
+                log.warning("vboxwrapper couldn't be found!")
+            elif not os.access(self._vboxwrapper_path, os.X_OK):
+                log.warning("vboxwrapper is not executable")
+
+        # a new process start when calling IModule
+        IModule.__init__(self, name, *args, **kwargs)
+        self._vbox_instances = {}
+
+        config = Config.instance()
+        vbox_config = config.get_section_config(name.upper())
+        self._console_start_port_range = vbox_config.get("console_start_port_range", 3501)
+        self._console_end_port_range = vbox_config.get("console_end_port_range", 4000)
+        self._allocated_udp_ports = []
+        self._udp_start_port_range = vbox_config.get("udp_start_port_range", 35001)
+        self._udp_end_port_range = vbox_config.get("udp_end_port_range", 35500)
+        self._host = vbox_config.get("host", kwargs["host"])
+        self._projects_dir = kwargs["projects_dir"]
+        self._tempdir = kwargs["temp_dir"]
+        self._working_dir = self._projects_dir
+        self._vboxmanager = None
+        self._vboxwrapper = None
+
+    def _start_vbox_service(self):
+        """
+        Starts the VirtualBox backend.
+        vboxapi on Windows or vboxwrapper on other platforms.
+        """
+
+        if sys.platform.startswith("win"):
+            import pywintypes
+            import win32com.client
+
+            try:
+                if win32com.client.gencache.is_readonly is True:
+                    # dynamically generate the cache
+                    # http://www.py2exe.org/index.cgi/IncludingTypelibs
+                    # http://www.py2exe.org/index.cgi/UsingEnsureDispatch
+                    win32com.client.gencache.is_readonly = False
+                    #win32com.client.gencache.Rebuild()
+                    win32com.client.gencache.GetGeneratePath()
+
+                win32com.client.gencache.EnsureDispatch("VirtualBox.VirtualBox")
+            except pywintypes.com_error:
+                raise VirtualBoxError("VirtualBox is not installed.")
+
+            try:
+                from .vboxapi_py3 import VirtualBoxManager
+                self._vboxmanager = VirtualBoxManager(None, None)
+                vbox_major_version, vbox_minor_version, _ = self._vboxmanager.vbox.version.split('.')
+                if parse_version("{}.{}".format(vbox_major_version, vbox_minor_version)) <= parse_version("4.1"):
+                    raise VirtualBoxError("VirtualBox version must be >= 4.2")
+            except Exception as e:
+                self._vboxmanager = None
+                raise VirtualBoxError("Could not initialize the VirtualBox Manager: {}".format(e))
+
+            log.info("VirtualBox Manager has successful started: version is {} r{}".format(self._vboxmanager.vbox.version,
+                                                                                           self._vboxmanager.vbox.revision))
+        else:
+
+            if not self._vboxwrapper_path:
+                raise VirtualBoxError("No vboxwrapper path has been configured")
+
+            if not os.path.isfile(self._vboxwrapper_path):
+                raise VirtualBoxError("vboxwrapper path doesn't exist {}".format(self._vboxwrapper_path))
+
+            self._vboxwrapper = VboxWrapperClient(self._vboxwrapper_path, self._tempdir, "127.0.0.1")
+            #self._vboxwrapper.connect()
+            try:
+                self._vboxwrapper.start()
+            except VirtualBoxError:
+                self._vboxwrapper = None
+                raise
+
+    def stop(self, signum=None):
+        """
+        Properly stops the module.
+
+        :param signum: signal number (if called by the signal handler)
+        """
+
+        # delete all VirtualBox instances
+        for vbox_id in self._vbox_instances:
+            vbox_instance = self._vbox_instances[vbox_id]
+            vbox_instance.delete()
+
+        if self._vboxwrapper and self._vboxwrapper.started:
+            self._vboxwrapper.stop()
+
+        IModule.stop(self, signum)  # this will stop the I/O loop
+
+    def get_vbox_instance(self, vbox_id):
+        """
+        Returns a VirtualBox VM instance.
+
+        :param vbox_id: VirtualBox VM identifier
+
+        :returns: VirtualBoxVM instance
+        """
+
+        if vbox_id not in self._vbox_instances:
+            log.debug("VirtualBox VM ID {} doesn't exist".format(vbox_id), exc_info=1)
+            self.send_custom_error("VirtualBox VM ID {} doesn't exist".format(vbox_id))
+            return None
+        return self._vbox_instances[vbox_id]
+
+    @IModule.route("virtualbox.reset")
+    def reset(self, request):
+        """
+        Resets the module.
+
+        :param request: JSON request
+        """
+
+        # delete all VirtualBox instances
+        for vbox_id in self._vbox_instances:
+            vbox_instance = self._vbox_instances[vbox_id]
+            vbox_instance.delete()
+
+        # resets the instance IDs
+        VirtualBoxVM.reset()
+
+        self._vbox_instances.clear()
+        self._allocated_udp_ports.clear()
+
+        if self._vboxwrapper and self._vboxwrapper.connected():
+            self._vboxwrapper.send("vboxwrapper reset")
+
+        log.info("VirtualBox module has been reset")
+
+    @IModule.route("virtualbox.settings")
+    def settings(self, request):
+        """
+        Set or update settings.
+
+        Optional request parameters:
+        - working_dir (path to a working directory)
+        - vboxwrapper_path (path to vboxwrapper)
+        - project_name
+        - console_start_port_range
+        - console_end_port_range
+        - udp_start_port_range
+        - udp_end_port_range
+
+        :param request: JSON request
+        """
+
+        if request is None:
+            self.send_param_error()
+            return
+
+        if "working_dir" in request:
+            new_working_dir = request["working_dir"]
+            log.info("this server is local with working directory path to {}".format(new_working_dir))
+        else:
+            new_working_dir = os.path.join(self._projects_dir, request["project_name"])
+            log.info("this server is remote with working directory path to {}".format(new_working_dir))
+            if self._projects_dir != self._working_dir != new_working_dir:
+                if not os.path.isdir(new_working_dir):
+                    try:
+                        shutil.move(self._working_dir, new_working_dir)
+                    except OSError as e:
+                        log.error("could not move working directory from {} to {}: {}".format(self._working_dir,
+                                                                                              new_working_dir,
+                                                                                              e))
+                        return
+
+        # update the working directory if it has changed
+        if self._working_dir != new_working_dir:
+            self._working_dir = new_working_dir
+            for vbox_id in self._vbox_instances:
+                vbox_instance = self._vbox_instances[vbox_id]
+                vbox_instance.working_dir = os.path.join(self._working_dir, "vbox", "vm-{}".format(vbox_instance.id))
+
+        if "vboxwrapper_path" in request:
+            self._vboxwrapper_path = request["vboxwrapper_path"]
+
+        if "console_start_port_range" in request and "console_end_port_range" in request:
+            self._console_start_port_range = request["console_start_port_range"]
+            self._console_end_port_range = request["console_end_port_range"]
+
+        if "udp_start_port_range" in request and "udp_end_port_range" in request:
+            self._udp_start_port_range = request["udp_start_port_range"]
+            self._udp_end_port_range = request["udp_end_port_range"]
+
+        log.debug("received request {}".format(request))
+
+    @IModule.route("virtualbox.create")
+    def vbox_create(self, request):
+        """
+        Creates a new VirtualBox VM instance.
+
+        Mandatory request parameters:
+        - name (VirtualBox VM name)
+        - vmname (VirtualBox VM name in VirtualBox)
+
+        Optional request parameters:
+        - console (VirtualBox VM console port)
+
+        Response parameters:
+        - id (VirtualBox VM instance identifier)
+        - name (VirtualBox VM name)
+        - default settings
+
+        :param request: JSON request
+        """
+
+        # validate the request
+        if not self.validate_request(request, VBOX_CREATE_SCHEMA):
+            return
+
+        name = request["name"]
+        vmname = request["vmname"]
+        console = request.get("console")
+        vbox_id = request.get("vbox_id")
+
+        try:
+
+            if not self._vboxwrapper and not self._vboxmanager:
+                self._start_vbox_service()
+
+            vbox_instance = VirtualBoxVM(self._vboxwrapper,
+                                         self._vboxmanager,
+                                         name,
+                                         vmname,
+                                         self._working_dir,
+                                         self._host,
+                                         vbox_id,
+                                         console,
+                                         self._console_start_port_range,
+                                         self._console_end_port_range)
+
+        except VirtualBoxError as e:
+            self.send_custom_error(str(e))
+            return
+
+        response = {"name": vbox_instance.name,
+                    "id": vbox_instance.id}
+
+        defaults = vbox_instance.defaults()
+        response.update(defaults)
+        self._vbox_instances[vbox_instance.id] = vbox_instance
+        self.send_response(response)
+
+    @IModule.route("virtualbox.delete")
+    def vbox_delete(self, request):
+        """
+        Deletes a VirtualBox VM instance.
+
+        Mandatory request parameters:
+        - id (VirtualBox VM instance identifier)
+
+        Response parameter:
+        - True on success
+
+        :param request: JSON request
+        """
+
+        # validate the request
+        if not self.validate_request(request, VBOX_DELETE_SCHEMA):
+            return
+
+        # get the instance
+        vbox_instance = self.get_vbox_instance(request["id"])
+        if not vbox_instance:
+            return
+
+        try:
+            vbox_instance.clean_delete()
+            del self._vbox_instances[request["id"]]
+        except VirtualBoxError as e:
+            self.send_custom_error(str(e))
+            return
+
+        self.send_response(True)
+
+    @IModule.route("virtualbox.update")
+    def vbox_update(self, request):
+        """
+        Updates a VirtualBox VM instance
+
+        Mandatory request parameters:
+        - id (VirtualBox VM instance identifier)
+
+        Optional request parameters:
+        - any setting to update
+
+        Response parameters:
+        - updated settings
+
+        :param request: JSON request
+        """
+
+        # validate the request
+        if not self.validate_request(request, VBOX_UPDATE_SCHEMA):
+            return
+
+        # get the instance
+        vbox_instance = self.get_vbox_instance(request["id"])
+        if not vbox_instance:
+            return
+
+        # update the VirtualBox VM settings
+        response = {}
+        for name, value in request.items():
+            if hasattr(vbox_instance, name) and getattr(vbox_instance, name) != value:
+                try:
+                    setattr(vbox_instance, name, value)
+                    response[name] = value
+                except VirtualBoxError as e:
+                    self.send_custom_error(str(e))
+                    return
+
+        self.send_response(response)
+
+    @IModule.route("virtualbox.start")
+    def vbox_start(self, request):
+        """
+        Starts a VirtualBox VM instance.
+
+        Mandatory request parameters:
+        - id (VirtualBox VM instance identifier)
+
+        Response parameters:
+        - True on success
+
+        :param request: JSON request
+        """
+
+        # validate the request
+        if not self.validate_request(request, VBOX_START_SCHEMA):
+            return
+
+        # get the instance
+        vbox_instance = self.get_vbox_instance(request["id"])
+        if not vbox_instance:
+            return
+
+        try:
+            vbox_instance.start()
+        except VirtualBoxError as e:
+            if self._vboxwrapper:
+                self.send_custom_error("{}: {}".format(e, self._vboxwrapper.read_stderr()))
+            else:
+                self.send_custom_error(str(e))
+            return
+        self.send_response(True)
+
+    @IModule.route("virtualbox.stop")
+    def vbox_stop(self, request):
+        """
+        Stops a VirtualBox VM instance.
+
+        Mandatory request parameters:
+        - id (VirtualBox VM instance identifier)
+
+        Response parameters:
+        - True on success
+
+        :param request: JSON request
+        """
+
+        # validate the request
+        if not self.validate_request(request, VBOX_STOP_SCHEMA):
+            return
+
+        # get the instance
+        vbox_instance = self.get_vbox_instance(request["id"])
+        if not vbox_instance:
+            return
+
+        try:
+            vbox_instance.stop()
+        except VirtualBoxError as e:
+            self.send_custom_error(str(e))
+            return
+        self.send_response(True)
+
+    @IModule.route("virtualbox.reload")
+    def vbox_reload(self, request):
+        """
+        Reloads a VirtualBox VM instance.
+
+        Mandatory request parameters:
+        - id (VirtualBox VM identifier)
+
+        Response parameters:
+        - True on success
+
+        :param request: JSON request
+        """
+
+        # validate the request
+        if not self.validate_request(request, VBOX_RELOAD_SCHEMA):
+            return
+
+        # get the instance
+        vbox_instance = self.get_vbox_instance(request["id"])
+        if not vbox_instance:
+            return
+
+        try:
+            vbox_instance.reload()
+        except VirtualBoxError as e:
+            self.send_custom_error(str(e))
+            return
+        self.send_response(True)
+
+    @IModule.route("virtualbox.stop")
+    def vbox_stop(self, request):
+        """
+        Stops a VirtualBox VM instance.
+
+        Mandatory request parameters:
+        - id (VirtualBox VM instance identifier)
+
+        Response parameters:
+        - True on success
+
+        :param request: JSON request
+        """
+
+        # validate the request
+        if not self.validate_request(request, VBOX_STOP_SCHEMA):
+            return
+
+        # get the instance
+        vbox_instance = self.get_vbox_instance(request["id"])
+        if not vbox_instance:
+            return
+
+        try:
+            vbox_instance.stop()
+        except VirtualBoxError as e:
+            self.send_custom_error(str(e))
+            return
+        self.send_response(True)
+
+    @IModule.route("virtualbox.suspend")
+    def vbox_suspend(self, request):
+        """
+        Suspends a VirtualBox VM instance.
+
+        Mandatory request parameters:
+        - id (VirtualBox VM instance identifier)
+
+        Response parameters:
+        - True on success
+
+        :param request: JSON request
+        """
+
+        # validate the request
+        if not self.validate_request(request, VBOX_SUSPEND_SCHEMA):
+            return
+
+        # get the instance
+        vbox_instance = self.get_vbox_instance(request["id"])
+        if not vbox_instance:
+            return
+
+        try:
+            vbox_instance.suspend()
+        except VirtualBoxError as e:
+            self.send_custom_error(str(e))
+            return
+        self.send_response(True)
+
+    @IModule.route("virtualbox.allocate_udp_port")
+    def allocate_udp_port(self, request):
+        """
+        Allocates a UDP port in order to create an UDP NIO.
+
+        Mandatory request parameters:
+        - id (VirtualBox VM identifier)
+        - port_id (unique port identifier)
+
+        Response parameters:
+        - port_id (unique port identifier)
+        - lport (allocated local port)
+
+        :param request: JSON request
+        """
+
+        # validate the request
+        if not self.validate_request(request, VBOX_ALLOCATE_UDP_PORT_SCHEMA):
+            return
+
+        # get the instance
+        vbox_instance = self.get_vbox_instance(request["id"])
+        if not vbox_instance:
+            return
+
+        try:
+            port = find_unused_port(self._udp_start_port_range,
+                                    self._udp_end_port_range,
+                                    host=self._host,
+                                    socket_type="UDP",
+                                    ignore_ports=self._allocated_udp_ports)
+        except Exception as e:
+            self.send_custom_error(str(e))
+            return
+
+        self._allocated_udp_ports.append(port)
+        log.info("{} [id={}] has allocated UDP port {} with host {}".format(vbox_instance.name,
+                                                                            vbox_instance.id,
+                                                                            port,
+                                                                            self._host))
+
+        response = {"lport": port,
+                    "port_id": request["port_id"]}
+        self.send_response(response)
+
+    @IModule.route("virtualbox.add_nio")
+    def add_nio(self, request):
+        """
+        Adds an NIO (Network Input/Output) for a VirtualBox VM instance.
+
+        Mandatory request parameters:
+        - id (VirtualBox VM instance identifier)
+        - port (port number)
+        - port_id (unique port identifier)
+        - nio (one of the following)
+            - type "nio_udp"
+                - lport (local port)
+                - rhost (remote host)
+                - rport (remote port)
+
+        Response parameters:
+        - port_id (unique port identifier)
+
+        :param request: JSON request
+        """
+
+        # validate the request
+        if not self.validate_request(request, VBOX_ADD_NIO_SCHEMA):
+            return
+
+        # get the instance
+        vbox_instance = self.get_vbox_instance(request["id"])
+        if not vbox_instance:
+            return
+
+        port = request["port"]
+        try:
+            nio = None
+            if request["nio"]["type"] == "nio_udp":
+                lport = request["nio"]["lport"]
+                rhost = request["nio"]["rhost"]
+                rport = request["nio"]["rport"]
+                try:
+                    #TODO: handle IPv6
+                    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
+                        sock.connect((rhost, rport))
+                except OSError as e:
+                    raise VirtualBoxError("Could not create an UDP connection to {}:{}: {}".format(rhost, rport, e))
+                nio = NIO_UDP(lport, rhost, rport)
+            if not nio:
+                raise VirtualBoxError("Requested NIO does not exist or is not supported: {}".format(request["nio"]["type"]))
+        except VirtualBoxError as e:
+            self.send_custom_error(str(e))
+            return
+
+        try:
+            vbox_instance.port_add_nio_binding(port, nio)
+        except VirtualBoxError as e:
+            self.send_custom_error(str(e))
+            return
+
+        self.send_response({"port_id": request["port_id"]})
+
+    @IModule.route("virtualbox.delete_nio")
+    def delete_nio(self, request):
+        """
+        Deletes an NIO (Network Input/Output).
+
+        Mandatory request parameters:
+        - id (VirtualBox instance identifier)
+        - port (port identifier)
+
+        Response parameters:
+        - True on success
+
+        :param request: JSON request
+        """
+
+        # validate the request
+        if not self.validate_request(request, VBOX_DELETE_NIO_SCHEMA):
+            return
+
+        # get the instance
+        vbox_instance = self.get_vbox_instance(request["id"])
+        if not vbox_instance:
+            return
+
+        port = request["port"]
+        try:
+            nio = vbox_instance.port_remove_nio_binding(port)
+            if isinstance(nio, NIO_UDP) and nio.lport in self._allocated_udp_ports:
+                self._allocated_udp_ports.remove(nio.lport)
+        except VirtualBoxError as e:
+            self.send_custom_error(str(e))
+            return
+
+        self.send_response(True)
+
+    @IModule.route("virtualbox.start_capture")
+    def vbox_start_capture(self, request):
+        """
+        Starts a packet capture.
+
+        Mandatory request parameters:
+        - id (VirtualBox VM identifier)
+        - port (port number)
+        - port_id (port identifier)
+        - capture_file_name
+
+        Response parameters:
+        - port_id (port identifier)
+        - capture_file_path (path to the capture file)
+
+        :param request: JSON request
+        """
+
+        # validate the request
+        if not self.validate_request(request, VBOX_START_CAPTURE_SCHEMA):
+            return
+
+        # get the instance
+        vbox_instance = self.get_vbox_instance(request["id"])
+        if not vbox_instance:
+            return
+
+        port = request["port"]
+        capture_file_name = request["capture_file_name"]
+
+        try:
+            capture_file_path = os.path.join(self._working_dir, "captures", capture_file_name)
+            vbox_instance.start_capture(port, capture_file_path)
+        except VirtualBoxError as e:
+            self.send_custom_error(str(e))
+            return
+
+        response = {"port_id": request["port_id"],
+                    "capture_file_path": capture_file_path}
+        self.send_response(response)
+
+    @IModule.route("virtualbox.stop_capture")
+    def vbox_stop_capture(self, request):
+        """
+        Stops a packet capture.
+
+        Mandatory request parameters:
+        - id (VirtualBox VM identifier)
+        - port (port number)
+        - port_id (port identifier)
+
+        Response parameters:
+        - port_id (port identifier)
+
+        :param request: JSON request
+        """
+
+        # validate the request
+        if not self.validate_request(request, VBOX_STOP_CAPTURE_SCHEMA):
+            return
+
+        # get the instance
+        vbox_instance = self.get_vbox_instance(request["id"])
+        if not vbox_instance:
+            return
+
+        port = request["port"]
+        try:
+            vbox_instance.stop_capture(port)
+        except VirtualBoxError as e:
+            self.send_custom_error(str(e))
+            return
+
+        response = {"port_id": request["port_id"]}
+        self.send_response(response)
+
+    @IModule.route("virtualbox.vm_list")
+    def vm_list(self, request):
+        """
+        Gets VirtualBox VM list.
+
+        Response parameters:
+        - Server address/host
+        - List of VM names
+        """
+
+        if not self._vboxwrapper and not self._vboxmanager:
+            try:
+                self._start_vbox_service()
+            except VirtualBoxError as e:
+                self.send_custom_error(str(e))
+                return
+
+        if self._vboxwrapper:
+            vms = self._vboxwrapper.get_vm_list()
+        elif self._vboxmanager:
+            vms = []
+            machines = self._vboxmanager.getArray(self._vboxmanager.vbox, "machines")
+            for machine in range(len(machines)):
+                vms.append(machines[machine].name)
+        else:
+            self.send_custom_error("Vboxmanager hasn't been initialized!")
+            return
+
+        response = {"server": self._host,
+                    "vms": vms}
+        self.send_response(response)
+
+    @IModule.route("virtualbox.echo")
+    def echo(self, request):
+        """
+        Echo end point for testing purposes.
+
+        :param request: JSON request
+        """
+
+        if request is None:
+            self.send_param_error()
+        else:
+            log.debug("received request {}".format(request))
+            self.send_response(request)

gns3server/modules/virtualbox/adapters/adapter.py

@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+class Adapter(object):
+    """
+    Base class for adapters.
+
+    :param interfaces: number of interfaces supported by this adapter.
+    """
+
+    def __init__(self, interfaces=1):
+
+        self._interfaces = interfaces
+
+        self._ports = {}
+        for port_id in range(0, interfaces):
+            self._ports[port_id] = None
+
+    def removable(self):
+        """
+        Returns True if the adapter can be removed from a slot
+        and False if not.
+
+        :returns: boolean
+        """
+
+        return True
+
+    def port_exists(self, port_id):
+        """
+        Checks if a port exists on this adapter.
+
+        :returns: True is the port exists,
+        False otherwise.
+        """
+
+        if port_id in self._ports:
+            return True
+        return False
+
+    def add_nio(self, port_id, nio):
+        """
+        Adds a NIO to a port on this adapter.
+
+        :param port_id: port ID (integer)
+        :param nio: NIO instance
+        """
+
+        self._ports[port_id] = nio
+
+    def remove_nio(self, port_id):
+        """
+        Removes a NIO from a port on this adapter.
+
+        :param port_id: port ID (integer)
+        """
+
+        self._ports[port_id] = None
+
+    def get_nio(self, port_id):
+        """
+        Returns the NIO assigned to a port.
+
+        :params port_id: port ID (integer)
+
+        :returns: NIO instance
+        """
+
+        return self._ports[port_id]
+
+    @property
+    def ports(self):
+        """
+        Returns port to NIO mapping
+
+        :returns: dictionary port -> NIO
+        """
+
+        return self._ports
+
+    @property
+    def interfaces(self):
+        """
+        Returns the number of interfaces supported by this adapter.
+
+        :returns: number of interfaces
+        """
+
+        return self._interfaces

gns3server/modules/virtualbox/adapters/ethernet_adapter.py

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from .adapter import Adapter
+
+
+class EthernetAdapter(Adapter):
+    """
+    VirtualBox Ethernet adapter.
+    """
+
+    def __init__(self):
+        Adapter.__init__(self, interfaces=1)
+
+    def __str__(self):
+
+        return "VirtualBox Ethernet adapter"

gns3server/modules/virtualbox/nios/nio.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+Base interface for NIOs.
+"""
+
+
+class NIO(object):
+    """
+    Network Input/Output.
+    """
+
+    def __init__(self):
+
+        self._capturing = False
+        self._pcap_output_file = ""
+
+    def startPacketCapture(self, pcap_output_file):
+        """
+
+        :param pcap_output_file: PCAP destination file for the capture
+        """
+
+        self._capturing = True
+        self._pcap_output_file = pcap_output_file
+
+    def stopPacketCapture(self):
+
+        self._capturing = False
+        self._pcap_output_file = ""
+
+    @property
+    def capturing(self):
+        """
+        Returns either a capture is configured on this NIO.
+
+        :returns: boolean
+        """
+
+        return self._capturing
+
+    @property
+    def pcap_output_file(self):
+        """
+        Returns the path to the PCAP output file.
+
+        :returns: path to the PCAP output file
+        """
+
+        return self._pcap_output_file

gns3server/modules/virtualbox/nios/nio_udp.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+Interface for UDP NIOs.
+"""
+
+from .nio import NIO
+
+
+class NIO_UDP(NIO):
+    """
+    UDP NIO.
+
+    :param lport: local port number
+    :param rhost: remote address/host
+    :param rport: remote port number
+    """
+
+    _instance_count = 0
+
+    def __init__(self, lport, rhost, rport):
+
+        NIO.__init__(self)
+        self._lport = lport
+        self._rhost = rhost
+        self._rport = rport
+
+    @property
+    def lport(self):
+        """
+        Returns the local port
+
+        :returns: local port number
+        """
+
+        return self._lport
+
+    @property
+    def rhost(self):
+        """
+        Returns the remote host
+
+        :returns: remote address/host
+        """
+
+        return self._rhost
+
+    @property
+    def rport(self):
+        """
+        Returns the remote port
+
+        :returns: remote port number
+        """
+
+        return self._rport
+
+    def __str__(self):
+
+        return "NIO UDP"

gns3server/modules/virtualbox/pipe_proxy.py

@@ -0,0 +1,476 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# Parts of this code have been taken from Pyserial project (http://pyserial.sourceforge.net/) under Python license
+
+import sys
+import time
+import threading
+import socket
+import select
+
+if sys.platform.startswith("win"):
+    import win32pipe
+    import win32file
+
+
+class PipeProxy(threading.Thread):
+
+    def __init__(self, name, pipe, host, port):
+        self.devname = name
+        self.pipe = pipe
+        self.host = host
+        self.port = port
+        self.server = None
+        self.reader_thread = None
+        self.use_thread = False
+        self._write_lock = threading.Lock()
+        self.clients = {}
+        self.timeout = 0.1
+        self.alive = True
+
+        if sys.platform.startswith("win"):
+            # we must a thread for reading the pipe on Windows because it is a Named Pipe and it cannot be monitored by select()
+            self.use_thread = True
+
+        try:
+            if self.host.__contains__(':'):
+                # IPv6 address support
+                self.server = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
+            else:
+                self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                self.server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+                self.server.bind((self.host, int(self.port)))
+                self.server.listen(5)
+        except socket.error as msg:
+            self.error("unable to create the socket server %s" % msg)
+            return
+
+        threading.Thread.__init__(self)
+        self.debug("initialized, waiting for clients on %s:%i..." % (self.host, self.port))
+
+    def error(self, msg):
+
+        sys.stderr.write("ERROR -> %s PIPE PROXY: %s\n" % (self.devname, msg))
+
+    def debug(self, msg):
+
+        sys.stdout.write("INFO -> %s PIPE PROXY: %s\n" % (self.devname, msg))
+
+    def run(self):
+
+        while True:
+
+            recv_list = [self.server.fileno()]
+
+            if not self.use_thread:
+                recv_list.append(self.pipe.fileno())
+
+            for client in self.clients.values():
+                if client.active:
+                    recv_list.append(client.fileno)
+                else:
+                    self.debug("lost client %s" % client.addrport())
+                    try:
+                        client.sock.close()
+                    except:
+                        pass
+                    del self.clients[client.fileno]
+
+            try:
+                rlist, slist, elist = select.select(recv_list, [], [], self.timeout)
+            except select.error as err:
+                self.error("fatal select error %d:%s" % (err[0], err[1]))
+                return False
+
+            if not self.alive:
+                self.debug('Exiting ...')
+                return True
+
+            for sock_fileno in rlist:
+                if sock_fileno == self.server.fileno():
+
+                    try:
+                        sock, addr = self.server.accept()
+                        sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
+                        sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+                        self.debug("new client %s:%s" % (addr[0], addr[1]))
+                    except socket.error as err:
+                        self.error("accept error %d:%s" % (err[0], err[1]))
+                        continue
+
+                    new_client = TelnetClient(sock, addr)
+                    self.clients[new_client.fileno] = new_client
+                    welcome_msg = "%s console is now available ... Press RETURN to get started.\r\n" % self.devname
+                    sock.send(welcome_msg.encode('utf-8'))
+
+                    if self.use_thread and not self.reader_thread:
+                        self.reader_thread = threading.Thread(target=self.reader)
+                        self.reader_thread.setDaemon(True)
+                        self.reader_thread.setName('pipe->socket')
+                        self.reader_thread.start()
+
+                elif not self.use_thread and sock_fileno == self.pipe.fileno():
+
+                    data = self.read_from_pipe()
+                    if not data:
+                        self.debug("pipe has been closed!")
+                        return False
+                    for client in self.clients.values():
+                        try:
+                            client.send(data)
+                        except:
+                            self.debug(msg)
+                            client.deactivate()
+                elif sock_fileno in self.clients:
+                    try:
+                        data = self.clients[sock_fileno].socket_recv()
+
+                        # For some reason, windows likes to send "cr/lf" when you send a "cr".
+                        # Strip that so we don't get a double prompt.
+                        data = data.replace(b"\r\n", b"\n")
+
+                        self.write_to_pipe(data)
+                    except Exception as msg:
+                        self.debug(msg)
+                        self.clients[sock_fileno].deactivate()
+
+    def write_to_pipe(self, data):
+
+        if sys.platform.startswith('win'):
+            win32file.WriteFile(self.pipe, data)
+        else:
+            self.pipe.sendall(data)
+
+    def read_from_pipe(self):
+
+        if sys.platform.startswith('win'):
+            (read, num_avail, num_message) = win32pipe.PeekNamedPipe(self.pipe, 0)
+            if num_avail > 0:
+                (error_code, output) = win32file.ReadFile(self.pipe, num_avail, None)
+                return output
+            return ""
+        else:
+            return self.pipe.recv(1024)
+
+    def reader(self):
+        """loop forever and copy pipe->socket"""
+
+        self.debug("reader thread started")
+        while self.alive:
+            try:
+                data = self.read_from_pipe()
+                if not data and not sys.platform.startswith('win'):
+                    self.debug("pipe has been closed!")
+                    break
+                self._write_lock.acquire()
+                try:
+                    for client in self.clients.values():
+                        client.send(data)
+                finally:
+                    self._write_lock.release()
+                if sys.platform.startswith('win'):
+                    # sleep every 10 ms
+                    time.sleep(0.01)
+            except:
+                self.debug("pipe has been closed!")
+                break
+        self.debug("reader thread exited")
+        self.stop()
+
+    def stop(self):
+        """Stop copying"""
+
+        if self.alive:
+            self.alive = False
+        for client in self.clients.values():
+            client.sock.close()
+            client.deactivate()
+
+# telnet protocol characters
+IAC  = 255 # Interpret As Command
+DONT = 254
+DO   = 253
+WONT = 252
+WILL = 251
+IAC_DOUBLED = [IAC, IAC]
+
+SE  = 240  # Subnegotiation End
+NOP = 241  # No Operation
+DM  = 242  # Data Mark
+BRK = 243  # Break
+IP  = 244  # Interrupt process
+AO  = 245  # Abort output
+AYT = 246  # Are You There
+EC  = 247  # Erase Character
+EL  = 248  # Erase Line
+GA  = 249  # Go Ahead
+SB =  250  # Subnegotiation Begin
+
+# selected telnet options
+ECHO = 1   # echo
+SGA = 3    # suppress go ahead
+LINEMODE = 34 # line mode
+TERMTYPE = 24 # terminal type
+
+# Telnet filter states
+M_NORMAL = 0
+M_IAC_SEEN = 1
+M_NEGOTIATE = 2
+
+# TelnetOption and TelnetSubnegotiation states
+REQUESTED = 'REQUESTED'
+ACTIVE = 'ACTIVE'
+INACTIVE = 'INACTIVE'
+REALLY_INACTIVE = 'REALLY_INACTIVE'
+
+class TelnetOption(object):
+    """Manage a single telnet option, keeps track of DO/DONT WILL/WONT."""
+
+    def __init__(self, connection, name, option, send_yes, send_no, ack_yes, ack_no, initial_state, activation_callback=None):
+        """Init option.
+        :param connection: connection used to transmit answers
+        :param name: a readable name for debug outputs
+        :param send_yes: what to send when option is to be enabled.
+        :param send_no: what to send when option is to be disabled.
+        :param ack_yes: what to expect when remote agrees on option.
+        :param ack_no: what to expect when remote disagrees on option.
+        :param initial_state: options initialized with REQUESTED are tried to
+            be enabled on startup. use INACTIVE for all others.
+        """
+        self.connection = connection
+        self.name = name
+        self.option = option
+        self.send_yes = send_yes
+        self.send_no = send_no
+        self.ack_yes = ack_yes
+        self.ack_no = ack_no
+        self.state = initial_state
+        self.active = False
+        self.activation_callback = activation_callback
+
+    def __repr__(self):
+        """String for debug outputs"""
+        return "%s:%s(%s)" % (self.name, self.active, self.state)
+
+    def process_incoming(self, command):
+        """A DO/DONT/WILL/WONT was received for this option, update state and
+        answer when needed."""
+        if command == self.ack_yes:
+            if self.state is REQUESTED:
+                self.state = ACTIVE
+                self.active = True
+                if self.activation_callback is not None:
+                    self.activation_callback()
+            elif self.state is ACTIVE:
+                pass
+            elif self.state is INACTIVE:
+                self.state = ACTIVE
+                self.connection.telnetSendOption(self.send_yes, self.option)
+                self.active = True
+                if self.activation_callback is not None:
+                    self.activation_callback()
+            elif self.state is REALLY_INACTIVE:
+                self.connection.telnetSendOption(self.send_no, self.option)
+            else:
+                raise ValueError('option in illegal state %r' % self)
+        elif command == self.ack_no:
+            if self.state is REQUESTED:
+                self.state = INACTIVE
+                self.active = False
+            elif self.state is ACTIVE:
+                self.state = INACTIVE
+                self.connection.telnetSendOption(self.send_no, self.option)
+                self.active = False
+            elif self.state is INACTIVE:
+                pass
+            elif self.state is REALLY_INACTIVE:
+                pass
+            else:
+                raise ValueError('option in illegal state %r' % self)
+
+class TelnetClient(object):
+
+    """
+    Represents a client connection via Telnet.
+
+    First argument is the socket discovered by the Telnet Server.
+    Second argument is the tuple (ip address, port number).
+    """
+
+    def __init__(self, sock, addr_tup):
+        self.active = True          # Turns False when the connection is lost
+        self.sock = sock            # The connection's socket
+        self.fileno = sock.fileno() # The socket's file descriptor
+        self.address = addr_tup[0]  # The client's remote TCP/IP address
+        self.port = addr_tup[1]     # The client's remote port
+
+        # filter state machine
+        self.mode = M_NORMAL
+        self.suboption = None
+        self.telnet_command = None
+
+        # all supported telnet options
+        self._telnet_options = [
+            TelnetOption(self, 'ECHO', ECHO, WILL, WONT, DO, DONT, REQUESTED),
+            TelnetOption(self, 'we-SGA', SGA, WILL, WONT, DO, DONT, REQUESTED),
+            TelnetOption(self, 'they-SGA', SGA, DO, DONT, WILL, WONT, INACTIVE),
+            TelnetOption(self, 'LINEMODE', LINEMODE, DONT, DONT, WILL, WONT, REQUESTED),
+            TelnetOption(self, 'TERMTYPE', TERMTYPE, DO, DONT, WILL, WONT, REQUESTED),
+            ]
+
+        for option in self._telnet_options:
+            if option.state is REQUESTED:
+                self.telnetSendOption(option.send_yes, option.option)
+
+    def telnetSendOption(self, action, option):
+        """Send DO, DONT, WILL, WONT."""
+        self.sock.sendall(bytes([IAC, action, option]))
+
+    def escape(self, data):
+        """ All outgoing data has to be properly escaped, so that no IAC character 
+        in the data stream messes up the Telnet state machine in the server.
+        """
+        for byte in data:
+            if byte == IAC:
+                yield IAC
+                yield IAC
+            else:
+                yield byte
+
+    def filter(self, data):
+        """ handle a bunch of incoming bytes. this is a generator. it will yield
+        all characters not of interest for Telnet
+        """
+        for byte in data:
+            if self.mode == M_NORMAL:
+                # interpret as command or as data
+                if byte == IAC:
+                    self.mode = M_IAC_SEEN
+                else:
+                    # store data in sub option buffer or pass it to our
+                    # consumer depending on state
+                    if self.suboption is not None:
+                        self.suboption.append(byte)
+                    else:
+                        yield byte
+            elif self.mode == M_IAC_SEEN:
+                if byte == IAC:
+                    # interpret as command doubled -> insert character
+                    # itself
+                    if self.suboption is not None:
+                        self.suboption.append(byte)
+                    else:
+                        yield byte
+                    self.mode = M_NORMAL
+                elif byte == SB:
+                    # sub option start
+                    self.suboption = bytearray()
+                    self.mode = M_NORMAL
+                elif byte == SE:
+                    # sub option end -> process it now
+                    #self._telnetProcessSubnegotiation(bytes(self.suboption))
+                    self.suboption = None
+                    self.mode = M_NORMAL
+                elif byte in (DO, DONT, WILL, WONT):
+                    # negotiation
+                    self.telnet_command = byte
+                    self.mode = M_NEGOTIATE
+                else:
+                    # other telnet commands are ignored!
+                    self.mode = M_NORMAL
+            elif self.mode == M_NEGOTIATE: # DO, DONT, WILL, WONT was received, option now following
+                self._telnetNegotiateOption(self.telnet_command, byte)
+                self.mode = M_NORMAL
+
+    def _telnetNegotiateOption(self, command, option):
+        """Process incoming DO, DONT, WILL, WONT."""
+        # check our registered telnet options and forward command to them
+        # they know themselves if they have to answer or not
+        known = False
+        for item in self._telnet_options:
+            # can have more than one match! as some options are duplicated for
+            # 'us' and 'them'
+            if item.option == option:
+                item.process_incoming(command)
+                known = True
+        if not known:
+            # handle unknown options
+            # only answer to positive requests and deny them
+            if command == WILL or command == DO:
+                self.telnetSendOption((command == WILL and DONT or WONT), option)
+
+    def send(self, data):
+        """
+        Send data to the distant end.
+        """
+
+        try:
+            self.sock.sendall(bytes(self.escape(data)))
+        except socket.error as ex:
+            self.active = False
+            raise Exception("socket.sendall() error '%d:%s' from %s" % (ex[0], ex[1], self.addrport()))
+
+    def deactivate(self):
+        """
+        Set the client to disconnect on the next server poll.
+        """
+        self.active = False
+
+    def addrport(self):
+        """
+        Return the DE's IP address and port number as a string.
+        """
+        return "%s:%s" % (self.address, self.port)
+
+    def socket_recv(self):
+        """
+        Called by TelnetServer when recv data is ready.
+        """
+        try:
+            data = self.sock.recv(4096)
+        except socket.error as ex:
+            raise Exception("socket.recv() error '%d:%s' from %s" % (ex[0], ex[1], self.addrport()))
+
+        ## Did they close the connection?
+        size = len(data)
+        if size == 0:
+            raise Exception("connection closed by %s" % self.addrport())
+
+        return bytes(self.filter(data))
+
+if __name__ == '__main__':
+
+    if sys.platform.startswith('win'):
+        import msvcrt
+        pipe_name = r'\\.\pipe\VBOX\Linux_Microcore_3.8.2'
+        pipe = open(pipe_name, 'a+b')
+        pipe_proxy = PipeProxy("VBOX", msvcrt.get_osfhandle(pipe.fileno()), '127.0.0.1', 3900)
+    else:
+        try:
+            unix_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+            #unix_socket.settimeout(0.1)
+            unix_socket.connect("/tmp/pipe_test")
+        except socket.error as err:
+            print("Socket error -> %d:%s" % (err[0], err[1]))
+            sys.exit(False)
+        pipe_proxy = PipeProxy('VBOX', unix_socket, '127.0.0.1', 3900)
+
+    pipe_proxy.setDaemon(True)
+    pipe_proxy.start()
+    pipe.proxy.stop()
+    pipe_proxy.join()

gns3server/modules/virtualbox/schemas.py

@@ -0,0 +1,428 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+VBOX_CREATE_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to create a new VirtualBox VM instance",
+    "type": "object",
+    "properties": {
+        "name": {
+            "description": "VirtualBox VM instance name",
+            "type": "string",
+            "minLength": 1,
+        },
+        "vmname": {
+            "description": "VirtualBox VM name (in VirtualBox itself)",
+            "type": "string",
+            "minLength": 1,
+        },
+        "vbox_id": {
+            "description": "VirtualBox VM instance ID",
+            "type": "integer"
+        },
+        "console": {
+            "description": "console TCP port",
+            "minimum": 1,
+            "maximum": 65535,
+            "type": "integer"
+        },
+    },
+    "additionalProperties": False,
+    "required": ["name", "vmname"],
+}
+
+VBOX_DELETE_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to delete a VirtualBox VM instance",
+    "type": "object",
+    "properties": {
+        "id": {
+            "description": "VirtualBox VM instance ID",
+            "type": "integer"
+        },
+    },
+    "additionalProperties": False,
+    "required": ["id"]
+}
+
+VBOX_UPDATE_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to update a VirtualBox VM instance",
+    "type": "object",
+    "properties": {
+        "id": {
+            "description": "VirtualBox VM instance ID",
+            "type": "integer"
+        },
+        "name": {
+            "description": "VirtualBox VM instance name",
+            "type": "string",
+            "minLength": 1,
+        },
+        "vmname": {
+            "description": "VirtualBox VM name (in VirtualBox itself)",
+            "type": "string",
+            "minLength": 1,
+        },
+        "adapters": {
+            "description": "number of adapters",
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 36,  # maximum given by the ICH9 chipset in VirtualBox
+        },
+        "adapter_start_index": {
+            "description": "adapter index from which to start using adapters",
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 35,  # maximum given by the ICH9 chipset in VirtualBox
+        },
+        "adapter_type": {
+            "description": "VirtualBox adapter type",
+            "type": "string",
+            "minLength": 1,
+        },
+        "console": {
+            "description": "console TCP port",
+            "minimum": 1,
+            "maximum": 65535,
+            "type": "integer"
+        },
+        "enable_console": {
+            "description": "enable the console",
+            "type": "boolean"
+        },
+        "headless": {
+            "description": "headless mode",
+            "type": "boolean"
+        },
+    },
+    "additionalProperties": False,
+    "required": ["id"]
+}
+
+VBOX_START_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to start a VirtualBox VM instance",
+    "type": "object",
+    "properties": {
+        "id": {
+            "description": "VirtualBox VM instance ID",
+            "type": "integer"
+        },
+    },
+    "additionalProperties": False,
+    "required": ["id"]
+}
+
+VBOX_STOP_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to stop a VirtualBox VM instance",
+    "type": "object",
+    "properties": {
+        "id": {
+            "description": "VirtualBox VM instance ID",
+            "type": "integer"
+        },
+    },
+    "additionalProperties": False,
+    "required": ["id"]
+}
+
+VBOX_SUSPEND_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to suspend a VirtualBox VM instance",
+    "type": "object",
+    "properties": {
+        "id": {
+            "description": "VirtualBox VM instance ID",
+            "type": "integer"
+        },
+    },
+    "additionalProperties": False,
+    "required": ["id"]
+}
+
+VBOX_RELOAD_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to reload a VirtualBox VM instance",
+    "type": "object",
+    "properties": {
+        "id": {
+            "description": "VirtualBox VM instance ID",
+            "type": "integer"
+        },
+    },
+    "additionalProperties": False,
+    "required": ["id"]
+}
+
+VBOX_ALLOCATE_UDP_PORT_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to allocate an UDP port for a VirtualBox VM instance",
+    "type": "object",
+    "properties": {
+        "id": {
+            "description": "VirtualBox VM instance ID",
+            "type": "integer"
+        },
+        "port_id": {
+            "description": "Unique port identifier for the VirtualBox VM instance",
+            "type": "integer"
+        },
+    },
+    "additionalProperties": False,
+    "required": ["id", "port_id"]
+}
+
+VBOX_ADD_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
+        },
+        "Ethernet": {
+            "description": "Generic Ethernet Network Input/Output",
+            "properties": {
+                "type": {
+                    "enum": ["nio_generic_ethernet"]
+                },
+                "ethernet_device": {
+                    "description": "Ethernet device name e.g. eth0",
+                    "type": "string",
+                    "minLength": 1
+                },
+            },
+            "required": ["type", "ethernet_device"],
+            "additionalProperties": False
+        },
+        "LinuxEthernet": {
+            "description": "Linux Ethernet Network Input/Output",
+            "properties": {
+                "type": {
+                    "enum": ["nio_linux_ethernet"]
+                },
+                "ethernet_device": {
+                    "description": "Ethernet device name e.g. eth0",
+                    "type": "string",
+                    "minLength": 1
+                },
+            },
+            "required": ["type", "ethernet_device"],
+            "additionalProperties": False
+        },
+        "TAP": {
+            "description": "TAP Network Input/Output",
+            "properties": {
+                "type": {
+                    "enum": ["nio_tap"]
+                },
+                "tap_device": {
+                    "description": "TAP device name e.g. tap0",
+                    "type": "string",
+                    "minLength": 1
+                },
+            },
+            "required": ["type", "tap_device"],
+            "additionalProperties": False
+        },
+        "UNIX": {
+            "description": "UNIX Network Input/Output",
+            "properties": {
+                "type": {
+                    "enum": ["nio_unix"]
+                },
+                "local_file": {
+                    "description": "path to the UNIX socket file (local)",
+                    "type": "string",
+                    "minLength": 1
+                },
+                "remote_file": {
+                    "description": "path to the UNIX socket file (remote)",
+                    "type": "string",
+                    "minLength": 1
+                },
+            },
+            "required": ["type", "local_file", "remote_file"],
+            "additionalProperties": False
+        },
+        "VDE": {
+            "description": "VDE Network Input/Output",
+            "properties": {
+                "type": {
+                    "enum": ["nio_vde"]
+                },
+                "control_file": {
+                    "description": "path to the VDE control file",
+                    "type": "string",
+                    "minLength": 1
+                },
+                "local_file": {
+                    "description": "path to the VDE control file",
+                    "type": "string",
+                    "minLength": 1
+                },
+            },
+            "required": ["type", "control_file", "local_file"],
+            "additionalProperties": False
+        },
+        "NULL": {
+            "description": "NULL Network Input/Output",
+            "properties": {
+                "type": {
+                    "enum": ["nio_null"]
+                },
+            },
+            "required": ["type"],
+            "additionalProperties": False
+        },
+    },
+
+    "properties": {
+        "id": {
+            "description": "VirtualBox VM instance ID",
+            "type": "integer"
+        },
+        "port_id": {
+            "description": "Unique port identifier for the VirtualBox VM instance",
+            "type": "integer"
+        },
+        "port": {
+            "description": "Port number",
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 36  # maximum given by the ICH9 chipset in VirtualBox
+        },
+        "nio": {
+            "type": "object",
+            "description": "Network Input/Output",
+            "oneOf": [
+                {"$ref": "#/definitions/UDP"},
+                {"$ref": "#/definitions/Ethernet"},
+                {"$ref": "#/definitions/LinuxEthernet"},
+                {"$ref": "#/definitions/TAP"},
+                {"$ref": "#/definitions/UNIX"},
+                {"$ref": "#/definitions/VDE"},
+                {"$ref": "#/definitions/NULL"},
+            ]
+        },
+    },
+    "additionalProperties": False,
+    "required": ["id", "port_id", "port", "nio"]
+}
+
+
+VBOX_DELETE_NIO_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to delete a NIO for a VirtualBox VM instance",
+    "type": "object",
+    "properties": {
+        "id": {
+            "description": "VirtualBox VM instance ID",
+            "type": "integer"
+        },
+        "port": {
+            "description": "Port number",
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 36  # maximum given by the ICH9 chipset in VirtualBox
+        },
+    },
+    "additionalProperties": False,
+    "required": ["id", "port"]
+}
+
+VBOX_START_CAPTURE_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to start a packet capture on a VirtualBox VM instance port",
+    "type": "object",
+    "properties": {
+        "id": {
+            "description": "VirtualBox VM instance ID",
+            "type": "integer"
+        },
+        "port": {
+            "description": "Port number",
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 36  # maximum given by the ICH9 chipset in VirtualBox
+        },
+        "port_id": {
+            "description": "Unique port identifier for the VirtualBox VM instance",
+            "type": "integer"
+        },
+        "capture_file_name": {
+            "description": "Capture file name",
+            "type": "string",
+            "minLength": 1,
+        },
+    },
+    "additionalProperties": False,
+    "required": ["id", "port", "port_id", "capture_file_name"]
+}
+
+VBOX_STOP_CAPTURE_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to stop a packet capture on a VirtualBox VM instance port",
+    "type": "object",
+    "properties": {
+        "id": {
+            "description": "VirtualBox VM instance ID",
+            "type": "integer"
+        },
+        "port": {
+            "description": "Port number",
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 36  # maximum given by the ICH9 chipset in VirtualBox
+        },
+        "port_id": {
+            "description": "Unique port identifier for the VirtualBox VM instance",
+            "type": "integer"
+        },
+    },
+    "additionalProperties": False,
+    "required": ["id", "port", "port_id"]
+}
+

gns3server/modules/virtualbox/vboxapi_py3/__init__.py

@@ -0,0 +1,612 @@
+"""
+Copyright (C) 2009-2012 Oracle Corporation
+
+This file is part of VirtualBox Open Source Edition (OSE), as
+available from http://www.virtualbox.org. This file is free software;
+you can redistribute it and/or modify it under the terms of the GNU
+General Public License (GPL) as published by the Free Software
+Foundation, in version 2 as it comes in the "COPYING" file of the
+VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+"""
+
+import sys,os
+import traceback
+
+# To set Python bitness on OSX use 'export VERSIONER_PYTHON_PREFER_32_BIT=yes'
+
+VboxBinDir = os.environ.get("VBOX_PROGRAM_PATH", None)
+VboxSdkDir = os.environ.get("VBOX_SDK_PATH", None)
+
+if VboxBinDir is None:
+    # Will be set by the installer
+    VboxBinDir = "C:\\Program Files\\Oracle\\VirtualBox\\"
+
+if VboxSdkDir is None:
+    # Will be set by the installer
+    VboxSdkDir = "C:\\Program Files\\Oracle\\VirtualBox\\sdk\\"
+
+os.environ["VBOX_PROGRAM_PATH"] = VboxBinDir
+os.environ["VBOX_SDK_PATH"] = VboxSdkDir
+sys.path.append(VboxBinDir)
+
+from .VirtualBox_constants import VirtualBoxReflectionInfo
+
+class PerfCollector:
+    """ This class provides a wrapper over IPerformanceCollector in order to
+    get more 'pythonic' interface.
+
+    To begin collection of metrics use setup() method.
+
+    To get collected data use query() method.
+
+    It is possible to disable metric collection without changing collection
+    parameters with disable() method. The enable() method resumes metric
+    collection.
+    """
+
+    def __init__(self, mgr, vbox):
+        """ Initializes the instance.
+
+        """
+        self.mgr = mgr
+        self.isMscom = (mgr.type == 'MSCOM')
+        self.collector = vbox.performanceCollector
+
+    def setup(self, names, objects, period, nsamples):
+        """ Discards all previously collected values for the specified
+        metrics, sets the period of collection and the number of retained
+        samples, enables collection.
+        """
+        self.collector.setupMetrics(names, objects, period, nsamples)
+
+    def enable(self, names, objects):
+        """ Resumes metric collection for the specified metrics.
+        """
+        self.collector.enableMetrics(names, objects)
+
+    def disable(self, names, objects):
+        """ Suspends metric collection for the specified metrics.
+        """
+        self.collector.disableMetrics(names, objects)
+
+    def query(self, names, objects):
+        """ Retrieves collected metric values as well as some auxiliary
+        information. Returns an array of dictionaries, one dictionary per
+        metric. Each dictionary contains the following entries:
+        'name': metric name
+        'object': managed object this metric associated with
+        'unit': unit of measurement
+        'scale': divide 'values' by this number to get float numbers
+        'values': collected data
+        'values_as_string': pre-processed values ready for 'print' statement
+        """
+        # Get around the problem with input arrays returned in output
+        # parameters (see #3953) for MSCOM.
+        if self.isMscom:
+            (values, names, objects, names_out, objects_out, units, scales, sequence_numbers,
+                indices, lengths) = self.collector.queryMetricsData(names, objects)
+        else:
+            (values, names_out, objects_out, units, scales, sequence_numbers,
+                indices, lengths) = self.collector.queryMetricsData(names, objects)
+        out = []
+        for i in xrange(0, len(names_out)):
+            scale = int(scales[i])
+            if scale != 1:
+                fmt = '%.2f%s'
+            else:
+                fmt = '%d %s'
+            out.append({
+                'name':str(names_out[i]),
+                'object':str(objects_out[i]),
+                'unit':str(units[i]),
+                'scale':scale,
+                'values':[int(values[j]) for j in xrange(int(indices[i]), int(indices[i])+int(lengths[i]))],
+                'values_as_string':'['+', '.join([fmt % (int(values[j])/scale, units[i]) for j in xrange(int(indices[i]), int(indices[i])+int(lengths[i]))])+']'
+            })
+        return out
+
+def ComifyName(name):
+    return name[0].capitalize()+name[1:]
+
+_COMForward = { 'getattr' : None,
+                'setattr' : None}
+
+def CustomGetAttr(self, attr):
+    # fastpath
+    if self.__class__.__dict__.get(attr) != None:
+        return self.__class__.__dict__.get(attr)
+
+    # try case-insensitivity workaround for class attributes (COM methods)
+    for k in self.__class__.__dict__.keys():
+        if k.lower() == attr.lower():
+            setattr(self.__class__, attr, self.__class__.__dict__[k])
+            return getattr(self, k)
+    try:
+        return _COMForward['getattr'](self,ComifyName(attr))
+    except AttributeError:
+        return _COMForward['getattr'](self,attr)
+
+def CustomSetAttr(self, attr, value):
+    try:
+        return _COMForward['setattr'](self, ComifyName(attr), value)
+    except AttributeError:
+        return _COMForward['setattr'](self, attr, value)
+
+class PlatformMSCOM:
+    # Class to fake access to constants in style of foo.bar.boo
+    class ConstantFake:
+        def __init__(self, parent, name):
+            self.__dict__['_parent'] = parent
+            self.__dict__['_name'] = name
+            self.__dict__['_consts'] = {}
+            try:
+                self.__dict__['_depth']=parent.__dict__['_depth']+1
+            except:
+                self.__dict__['_depth']=0
+                if self.__dict__['_depth'] > 4:
+                    raise AttributeError
+
+        def __getattr__(self, attr):
+            import win32com
+            from win32com.client import constants
+
+            if attr.startswith("__"):
+                raise AttributeError
+
+            consts = self.__dict__['_consts']
+
+            fake = consts.get(attr, None)
+            if fake != None:
+               return fake
+            try:
+               name = self.__dict__['_name']
+               parent = self.__dict__['_parent']
+               while parent != None:
+                  if parent._name is not None:
+                    name = parent._name+'_'+name
+                  parent = parent._parent
+
+               if name is not None:
+                  name += "_" + attr
+               else:
+                  name = attr
+               return win32com.client.constants.__getattr__(name)
+            except AttributeError as e:
+               fake = PlatformMSCOM.ConstantFake(self, attr)
+               consts[attr] = fake
+               return fake
+
+
+    class InterfacesWrapper:
+            def __init__(self):
+                self.__dict__['_rootFake'] = PlatformMSCOM.ConstantFake(None, None)
+
+            def __getattr__(self, a):
+                import win32com
+                from win32com.client import constants
+                if a.startswith("__"):
+                    raise AttributeError
+                try:
+                    return win32com.client.constants.__getattr__(a)
+                except AttributeError as e:
+                    return self.__dict__['_rootFake'].__getattr__(a)
+
+    VBOX_TLB_GUID  = '{46137EEC-703B-4FE5-AFD4-7C9BBBBA0259}'
+    VBOX_TLB_LCID  = 0
+    VBOX_TLB_MAJOR = 1
+    VBOX_TLB_MINOR = 0
+
+    def __init__(self, params):
+            from win32com import universal
+            from win32com.client import gencache, DispatchBaseClass
+            from win32com.client import constants, getevents
+            import win32com
+            import pythoncom
+            import win32api
+            from win32con import DUPLICATE_SAME_ACCESS
+            from win32api import GetCurrentThread,GetCurrentThreadId,DuplicateHandle,GetCurrentProcess
+            import threading
+            pid = GetCurrentProcess()
+            self.tid = GetCurrentThreadId()
+            handle = DuplicateHandle(pid, GetCurrentThread(), pid, 0, 0, DUPLICATE_SAME_ACCESS)
+            self.handles = []
+            self.handles.append(handle)
+            _COMForward['getattr'] = DispatchBaseClass.__dict__['__getattr__']
+            DispatchBaseClass.__getattr__ = CustomGetAttr
+            _COMForward['setattr'] = DispatchBaseClass.__dict__['__setattr__']
+            DispatchBaseClass.__setattr__ = CustomSetAttr
+            win32com.client.gencache.EnsureDispatch('VirtualBox.Session')
+            win32com.client.gencache.EnsureDispatch('VirtualBox.VirtualBox')
+            self.oIntCv = threading.Condition()
+            self.fInterrupted = False;
+
+    def getSessionObject(self, vbox):
+        import win32com
+        from win32com.client import Dispatch
+        return win32com.client.Dispatch("VirtualBox.Session")
+
+    def getVirtualBox(self):
+        import win32com
+        from win32com.client import Dispatch
+        return win32com.client.Dispatch("VirtualBox.VirtualBox")
+
+    def getType(self):
+        return 'MSCOM'
+
+    def getRemote(self):
+        return False
+
+    def getArray(self, obj, field):
+        return obj.__getattr__(field)
+
+    def initPerThread(self):
+        import pythoncom
+        pythoncom.CoInitializeEx(0)
+
+    def deinitPerThread(self):
+        import pythoncom
+        pythoncom.CoUninitialize()
+
+    def createListener(self, impl, arg):
+        d = {}
+        d['BaseClass'] = impl
+        d['arg'] = arg
+        d['tlb_guid'] = PlatformMSCOM.VBOX_TLB_GUID
+        str = ""
+        str += "import win32com.server.util\n"
+        str += "import pythoncom\n"
+
+        str += "class ListenerImpl(BaseClass):\n"
+        str += "   _com_interfaces_ = ['IEventListener']\n"
+        str += "   _typelib_guid_ = tlb_guid\n"
+        str += "   _typelib_version_ = 1, 0\n"
+        str += "   _reg_clsctx_ = pythoncom.CLSCTX_INPROC_SERVER\n"
+        # Maybe we'd better implement Dynamic invoke policy, to be more flexible here
+        str += "   _reg_policy_spec_ = 'win32com.server.policy.EventHandlerPolicy'\n"
+
+        # capitalized version of listener method
+        str += "   HandleEvent=BaseClass.handleEvent\n"
+        str += "   def __init__(self): BaseClass.__init__(self, arg)\n"
+        str += "result = win32com.server.util.wrap(ListenerImpl())\n"
+        exec(str,d,d)
+        return d['result']
+
+    def waitForEvents(self, timeout):
+        from win32api import GetCurrentThreadId
+        from win32event import INFINITE
+        from win32event import MsgWaitForMultipleObjects, \
+                               QS_ALLINPUT, WAIT_TIMEOUT, WAIT_OBJECT_0
+        from pythoncom import PumpWaitingMessages
+        import types
+
+        if not isinstance(timeout, types.IntType):
+            raise TypeError("The timeout argument is not an integer")
+        if (self.tid != GetCurrentThreadId()):
+            raise Exception("wait for events from the same thread you inited!")
+
+        if timeout < 0:     cMsTimeout = INFINITE
+        else:               cMsTimeout = timeout
+        rc = MsgWaitForMultipleObjects(self.handles, 0, cMsTimeout, QS_ALLINPUT)
+        if rc >= WAIT_OBJECT_0 and rc < WAIT_OBJECT_0+len(self.handles):
+            # is it possible?
+            rc = 2;
+        elif rc==WAIT_OBJECT_0 + len(self.handles):
+            # Waiting messages
+            PumpWaitingMessages()
+            rc = 0;
+        else:
+            # Timeout
+            rc = 1;
+
+        # check for interruption
+        self.oIntCv.acquire()
+        if self.fInterrupted:
+            self.fInterrupted = False
+            rc = 1;
+        self.oIntCv.release()
+
+        return rc;
+
+    def interruptWaitEvents(self):
+        """
+        Basically a python implementation of EventQueue::postEvent().
+
+        The magic value must be in sync with the C++ implementation or this
+        won't work.
+
+        Note that because of this method we cannot easily make use of a
+        non-visible Window to handle the message like we would like to do.
+        """
+        from win32api import PostThreadMessage
+        from win32con import WM_USER
+        self.oIntCv.acquire()
+        self.fInterrupted = True
+        self.oIntCv.release()
+        try:
+            PostThreadMessage(self.tid, WM_USER, None, 0xf241b819)
+        except:
+            return False;
+        return True;
+
+    def deinit(self):
+        import pythoncom
+        from win32file import CloseHandle
+
+        for h in self.handles:
+           if h is not None:
+              CloseHandle(h)
+        self.handles = None
+        pythoncom.CoUninitialize()
+        pass
+
+    def queryInterface(self, obj, klazzName):
+        from win32com.client import CastTo
+        return CastTo(obj, klazzName)
+
+class PlatformXPCOM:
+    def __init__(self, params):
+        sys.path.append(VboxSdkDir+'/bindings/xpcom/python/')
+        import xpcom.vboxxpcom
+        import xpcom
+        import xpcom.components
+
+    def getSessionObject(self, vbox):
+        import xpcom.components
+        return xpcom.components.classes["@virtualbox.org/Session;1"].createInstance()
+
+    def getVirtualBox(self):
+        import xpcom.components
+        return xpcom.components.classes["@virtualbox.org/VirtualBox;1"].createInstance()
+
+    def getType(self):
+        return 'XPCOM'
+
+    def getRemote(self):
+        return False
+
+    def getArray(self, obj, field):
+        return obj.__getattr__('get'+ComifyName(field))()
+
+    def initPerThread(self):
+        import xpcom
+        xpcom._xpcom.AttachThread()
+
+    def deinitPerThread(self):
+        import xpcom
+        xpcom._xpcom.DetachThread()
+
+    def createListener(self, impl, arg):
+        d = {}
+        d['BaseClass'] = impl
+        d['arg'] = arg
+        str = ""
+        str += "import xpcom.components\n"
+        str += "class ListenerImpl(BaseClass):\n"
+        str += "   _com_interfaces_ = xpcom.components.interfaces.IEventListener\n"
+        str += "   def __init__(self): BaseClass.__init__(self, arg)\n"
+        str += "result = ListenerImpl()\n"
+        exec(str,d,d)
+        return d['result']
+
+    def waitForEvents(self, timeout):
+        import xpcom
+        return xpcom._xpcom.WaitForEvents(timeout)
+
+    def interruptWaitEvents(self):
+        import xpcom
+        return xpcom._xpcom.InterruptWait()
+
+    def deinit(self):
+        import xpcom
+        xpcom._xpcom.DeinitCOM()
+
+    def queryInterface(self, obj, klazzName):
+        import xpcom.components
+        return obj.queryInterface(getattr(xpcom.components.interfaces, klazzName))
+
+class PlatformWEBSERVICE:
+    def __init__(self, params):
+        sys.path.append(os.path.join(VboxSdkDir,'bindings', 'webservice', 'python', 'lib'))
+        #import VirtualBox_services
+        import VirtualBox_wrappers
+        from VirtualBox_wrappers import IWebsessionManager2
+
+        if params is not None:
+            self.user = params.get("user", "")
+            self.password = params.get("password", "")
+            self.url = params.get("url", "")
+        else:
+            self.user = ""
+            self.password = ""
+            self.url = None
+        self.vbox = None
+
+    def getSessionObject(self, vbox):
+        return self.wsmgr.getSessionObject(vbox)
+
+    def getVirtualBox(self):
+        return self.connect(self.url, self.user, self.password)
+
+    def connect(self, url, user, passwd):
+        if self.vbox is not None:
+             self.disconnect()
+        from VirtualBox_wrappers import IWebsessionManager2
+        if url is None:
+            url = ""
+        self.url = url
+        if user is None:
+            user = ""
+        self.user = user
+        if passwd is None:
+            passwd = ""
+        self.password = passwd
+        self.wsmgr = IWebsessionManager2(self.url)
+        self.vbox = self.wsmgr.logon(self.user, self.password)
+        if not self.vbox.handle:
+            raise Exception("cannot connect to '"+self.url+"' as '"+self.user+"'")
+        return self.vbox
+
+    def disconnect(self):
+        if self.vbox is not None and self.wsmgr is not None:
+                self.wsmgr.logoff(self.vbox)
+                self.vbox = None
+                self.wsmgr = None
+
+    def getType(self):
+        return 'WEBSERVICE'
+
+    def getRemote(self):
+        return True
+
+    def getArray(self, obj, field):
+        return obj.__getattr__(field)
+
+    def initPerThread(self):
+        pass
+
+    def deinitPerThread(self):
+        pass
+
+    def createListener(self, impl, arg):
+        raise Exception("no active listeners for webservices")
+
+    def waitForEvents(self, timeout):
+        # Webservices cannot do that yet
+        return 2;
+
+    def interruptWaitEvents(self, timeout):
+        # Webservices cannot do that yet
+        return False;
+
+    def deinit(self):
+        try:
+           disconnect()
+        except:
+           pass
+
+    def queryInterface(self, obj, klazzName):
+        d = {}
+        d['obj'] = obj
+        str = ""
+        str += "from VirtualBox_wrappers import "+klazzName+"\n"
+        str += "result = "+klazzName+"(obj.mgr,obj.handle)\n"
+        # wrong, need to test if class indeed implements this interface
+        exec(str,d,d)
+        return d['result']
+
+class SessionManager:
+    def __init__(self, mgr):
+        self.mgr = mgr
+
+    def getSessionObject(self, vbox):
+        return self.mgr.platform.getSessionObject(vbox)
+
+class VirtualBoxManager:
+    def __init__(self, style, platparams):
+        if style is None:
+            if sys.platform == 'win32':
+                style = "MSCOM"
+            else:
+                style = "XPCOM"
+
+
+        exec("self.platform = Platform"+style+"(platparams)")
+        # for webservices, enums are symbolic
+        self.constants = VirtualBoxReflectionInfo(style == "WEBSERVICE")
+        self.type = self.platform.getType()
+        self.remote = self.platform.getRemote()
+        self.style = style
+        self.mgr = SessionManager(self)
+
+        try:
+            self.vbox = self.platform.getVirtualBox()
+        except NameError as ne:
+            print("Installation problem: check that appropriate libs in place")
+            traceback.print_exc()
+            raise ne
+        except Exception as e:
+            print("init exception: ",e)
+            traceback.print_exc()
+            if self.remote:
+                self.vbox = None
+            else:
+                raise e
+
+    def getArray(self, obj, field):
+        return self.platform.getArray(obj, field)
+
+    def getVirtualBox(self):
+        return  self.platform.getVirtualBox()
+
+    def __del__(self):
+        self.deinit()
+
+    def deinit(self):
+        if hasattr(self, "vbox"):
+            del self.vbox
+            self.vbox = None
+        if hasattr(self, "platform"):
+            self.platform.deinit()
+            self.platform = None
+
+    def initPerThread(self):
+        self.platform.initPerThread()
+
+    def openMachineSession(self, mach, permitSharing = True):
+         session = self.mgr.getSessionObject(self.vbox)
+         if permitSharing:
+             type = self.constants.LockType_Shared
+         else:
+             type = self.constants.LockType_Write
+         mach.lockMachine(session, type)
+         return session
+
+    def closeMachineSession(self, session):
+        if session is not None:
+            session.unlockMachine()
+
+    def deinitPerThread(self):
+        self.platform.deinitPerThread()
+
+    def createListener(self, impl, arg = None):
+        return self.platform.createListener(impl, arg)
+
+    def waitForEvents(self, timeout):
+        """
+        Wait for events to arrive and process them.
+
+        The timeout is in milliseconds.  A negative value means waiting for
+        ever, while 0 does not wait at all.
+
+        Returns 0 if events was processed.
+        Returns 1 if timed out or interrupted in some way.
+        Returns 2 on error (like not supported for web services).
+
+        Raises an exception if the calling thread is not the main thread (the one
+        that initialized VirtualBoxManager) or if the time isn't an integer.
+        """
+        return self.platform.waitForEvents(timeout)
+
+    def interruptWaitEvents(self):
+        """
+        Interrupt a waitForEvents call.
+        This is normally called from a worker thread.
+
+        Returns True on success, False on failure.
+        """
+        return self.platform.interruptWaitEvents()
+
+    def getPerfCollector(self, vbox):
+        return PerfCollector(self, vbox)
+
+    def getBinDir(self):
+        global VboxBinDir
+        return VboxBinDir
+
+    def getSdkDir(self):
+        global VboxSdkDir
+        return VboxSdkDir
+
+    def queryInterface(self, obj, klazzName):
+        return self.platform.queryInterface(obj, klazzName)

gns3server/modules/virtualbox/vboxwrapper_client.py

@@ -0,0 +1,422 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+Client to VirtualBox wrapper.
+"""
+
+import os
+import time
+import subprocess
+import tempfile
+import socket
+import re
+
+from pkg_resources import parse_version
+from ..attic import wait_socket_is_ready
+from .virtualbox_error import VirtualBoxError
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class VboxWrapperClient(object):
+    """
+    VirtualBox Wrapper client.
+
+    :param path: path to VirtualBox wrapper executable
+    :param working_dir: working directory
+    :param port: port
+    :param host: host/address
+    """
+
+    # Used to parse the VirtualBox wrapper response codes
+    error_re = re.compile(r"""^2[0-9]{2}-""")
+    success_re = re.compile(r"""^1[0-9]{2}\s{1}""")
+
+    def __init__(self, path, working_dir, host, port=11525, timeout=30.0):
+
+        self._path = path
+        self._command = []
+        self._process = None
+        self._working_dir = working_dir
+        self._stderr_file = ""
+        self._started = False
+        self._host = host
+        self._port = port
+        self._timeout = timeout
+        self._socket = None
+
+    @property
+    def started(self):
+        """
+        Returns either VirtualBox wrapper has been started or not.
+
+        :returns: boolean
+        """
+
+        return self._started
+
+    @property
+    def path(self):
+        """
+        Returns the path to the VirtualBox wrapper executable.
+
+        :returns: path to VirtualBox wrapper
+        """
+
+        return self._path
+
+    @path.setter
+    def path(self, path):
+        """
+        Sets the path to the VirtualBox wrapper executable.
+
+        :param path: path to VirtualBox wrapper
+        """
+
+        self._path = path
+
+    @property
+    def port(self):
+        """
+        Returns the port used to start the VirtualBox wrapper.
+
+        :returns: port number (integer)
+        """
+
+        return self._port
+
+    @port.setter
+    def port(self, port):
+        """
+        Sets the port used to start the VirtualBox wrapper.
+
+        :param port: port number (integer)
+        """
+
+        self._port = port
+
+    @property
+    def host(self):
+        """
+        Returns the host (binding) used to start the VirtualBox wrapper.
+
+        :returns: host/address (string)
+        """
+
+        return self._host
+
+    @host.setter
+    def host(self, host):
+        """
+        Sets the host (binding) used to start the VirtualBox wrapper.
+
+        :param host: host/address (string)
+        """
+
+        self._host = host
+
+    def start(self):
+        """
+        Starts the VirtualBox wrapper process.
+        """
+
+        self._command = self._build_command()
+        try:
+            log.info("starting VirtualBox wrapper: {}".format(self._command))
+            with tempfile.NamedTemporaryFile(delete=False) as fd:
+                with open(os.devnull, "w") as null:
+                    self._stderr_file = fd.name
+                    log.info("VirtualBox wrapper process logging to {}".format(fd.name))
+                    self._process = subprocess.Popen(self._command,
+                                                     stdout=null,
+                                                     stderr=fd,
+                                                     cwd=self._working_dir)
+            log.info("VirtualBox wrapper started PID={}".format(self._process.pid))
+
+            time.sleep(0.1) # give some time for vboxwrapper to start
+            if self._process.poll() is not None:
+                raise VirtualBoxError("Could not start VirtualBox wrapper: {}".format(self.read_stderr()))
+
+            self.wait_for_vboxwrapper(self._host, self._port)
+            self.connect()
+            self._started = True
+
+            version = self.send('vboxwrapper version')[0]
+            if parse_version(version) < parse_version("0.9.1"):
+                self.stop()
+                raise VirtualBoxError("VirtualBox wrapper version must be >= 0.9.1")
+
+        except OSError as e:
+            log.error("could not start VirtualBox wrapper: {}".format(e))
+            raise VirtualBoxError("Could not start VirtualBox wrapper: {}".format(e))
+
+    def wait_for_vboxwrapper(self, host, port):
+        """
+        Waits for vboxwrapper to be started (accepting a socket connection)
+
+        :param host: host/address to connect to the vboxwrapper
+        :param port: port to connect to the vboxwrapper
+        """
+
+        begin = time.time()
+        # wait for the socket for a maximum of 10 seconds.
+        connection_success, last_exception = wait_socket_is_ready(host, port, wait=10.0)
+
+        if not connection_success:
+            raise VirtualBoxError("Couldn't connect to vboxwrapper on {}:{} :{}".format(host, port,
+                                                                                 last_exception))
+        else:
+            log.info("vboxwrapper server ready after {:.4f} seconds".format(time.time() - begin))
+
+    def stop(self):
+        """
+        Stops the VirtualBox wrapper process.
+        """
+
+        if self.connected():
+            try:
+                self.send("vboxwrapper stop")
+            except VirtualBoxError:
+                pass
+            if self._socket:
+                self._socket.shutdown(socket.SHUT_RDWR)
+                self._socket.close()
+                self._socket = None
+
+        if self.is_running():
+            log.info("stopping VirtualBox wrapper PID={}".format(self._process.pid))
+            try:
+                # give some time for the VirtualBox wrapper to properly stop.
+                time.sleep(0.01)
+                self._process.terminate()
+                self._process.wait(1)
+            except subprocess.TimeoutExpired:
+                self._process.kill()
+                if self._process.poll() is None:
+                    log.warn("VirtualBox wrapper process {} is still running".format(self._process.pid))
+
+        if self._stderr_file and os.access(self._stderr_file, os.W_OK):
+            try:
+                os.remove(self._stderr_file)
+            except OSError as e:
+                log.warning("could not delete temporary VirtualBox wrapper log file: {}".format(e))
+        self._started = False
+
+    def read_stderr(self):
+        """
+        Reads the standard error output of the VirtualBox wrapper process.
+        Only use when the process has been stopped or has crashed.
+        """
+
+        output = ""
+        if self._stderr_file and os.access(self._stderr_file, os.R_OK):
+            try:
+                with open(self._stderr_file, errors="replace") as file:
+                    output = file.read()
+            except OSError as e:
+                log.warn("could not read {}: {}".format(self._stderr_file, e))
+        return output
+
+    def is_running(self):
+        """
+        Checks if the process is running
+
+        :returns: True or False
+        """
+
+        if self._process and self._process.poll() is None:
+            return True
+        return False
+
+    def _build_command(self):
+        """
+        Command to start the VirtualBox wrapper process.
+        (to be passed to subprocess.Popen())
+        """
+
+        command = [self._path]
+        if self._host != "0.0.0.0" and self._host != "::":
+            command.extend(["-l", self._host, "-p", str(self._port)])
+        else:
+            command.extend(["-p", str(self._port)])
+        return command
+
+    def connect(self):
+        """
+        Connects to the VirtualBox wrapper.
+        """
+
+        # connect to a local address by default
+        # if listening to all addresses (IPv4 or IPv6)
+        if self._host == "0.0.0.0":
+            host = "127.0.0.1"
+        elif self._host == "::":
+            host = "::1"
+        else:
+            host = self._host
+
+        try:
+            self._socket = socket.create_connection((host, self._port), self._timeout)
+        except OSError as e:
+            raise VirtualBoxError("Could not connect to the VirtualBox wrapper: {}".format(e))
+
+    def connected(self):
+        """
+        Returns either the client is connected to vboxwrapper or not.
+
+        :return: boolean
+        """
+
+        if self._socket:
+            return True
+        return False
+
+    def reset(self):
+        """
+        Resets the VirtualBox wrapper (used to get an empty configuration).
+        """
+
+        pass
+
+    @property
+    def working_dir(self):
+        """
+        Returns current working directory
+
+        :returns: path to the working directory
+        """
+
+        return self._working_dir
+
+    @working_dir.setter
+    def working_dir(self, working_dir):
+        """
+        Sets the working directory for the VirtualBox wrapper.
+
+        :param working_dir: path to the working directory
+        """
+
+        # encase working_dir in quotes to protect spaces in the path
+        #self.send("hypervisor working_dir {}".format('"' + working_dir + '"'))
+        self._working_dir = working_dir
+        log.debug("working directory set to {}".format(self._working_dir))
+
+    @property
+    def socket(self):
+        """
+        Returns the current socket used to communicate with the VirtualBox wrapper.
+
+        :returns: socket instance
+        """
+
+        assert self._socket
+        return self._socket
+
+    def get_vm_list(self):
+        """
+        Returns the list of all VirtualBox VMs.
+
+        :returns: list of VM names
+        """
+
+        return self.send('vbox vm_list')
+
+    def send(self, command):
+        """
+        Sends commands to the VirtualBox wrapper.
+
+        :param command: a VirtualBox wrapper command
+
+        :returns: results as a list
+        """
+
+        # VirtualBox wrapper responses are of the form:
+        #   1xx yyyyyy\r\n
+        #   1xx yyyyyy\r\n
+        #   ...
+        #   100-yyyy\r\n
+        # or
+        #   2xx-yyyy\r\n
+        #
+        # Where 1xx is a code from 100-199 for a success or 200-299 for an error
+        # The result might be multiple lines and might be less than the buffer size
+        # but still have more data. The only thing we know for sure is the last line
+        # will begin with '100-' or a '2xx-' and end with '\r\n'
+
+        if not self._socket:
+            raise VirtualBoxError("Not connected")
+
+        try:
+            command = command.strip() + '\n'
+            log.debug("sending {}".format(command))
+            self.socket.sendall(command.encode('utf-8'))
+        except OSError as e:
+            self._socket = None
+            raise VirtualBoxError("Lost communication with {host}:{port} :{error}"
+                                .format(host=self._host, port=self._port, error=e))
+
+        # Now retrieve the result
+        data = []
+        buf = ''
+        while True:
+            try:
+                chunk = self.socket.recv(1024)
+                buf += chunk.decode("utf-8")
+            except OSError as e:
+                self._socket = None
+                raise VirtualBoxError("Communication timed out with {host}:{port} :{error}"
+                                      .format(host=self._host, port=self._port, error=e))
+
+
+            # If the buffer doesn't end in '\n' then we can't be done
+            try:
+                if buf[-1] != '\n':
+                    continue
+            except IndexError:
+                self._socket = None
+                raise VirtualBoxError("Could not communicate with {host}:{port}"
+                                      .format(host=self._host, port=self._port))
+
+            data += buf.split('\r\n')
+            if data[-1] == '':
+                data.pop()
+            buf = ''
+
+            if len(data) == 0:
+                raise VirtualBoxError("no data returned from {host}:{port}"
+                                      .format(host=self._host, port=self._port))
+
+            # Does it contain an error code?
+            if self.error_re.search(data[-1]):
+                raise VirtualBoxError(data[-1][4:])
+
+            # Or does the last line begin with '100-'? Then we are done!
+            if data[-1][:4] == '100-':
+                data[-1] = data[-1][4:]
+                if data[-1] == 'OK':
+                    data.pop()
+                break
+
+        # Remove success responses codes
+        for index in range(len(data)):
+            if self.success_re.search(data[index]):
+                data[index] = data[index][4:]
+
+        log.debug("returned result {}".format(data))
+        return data

gns3server/modules/virtualbox/virtualbox_controller.py

@@ -0,0 +1,557 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+Controls VirtualBox using the VBox API.
+"""
+
+import sys
+import os
+import tempfile
+import re
+import time
+import socket
+import subprocess
+
+if sys.platform.startswith('win'):
+    import msvcrt
+    import win32file
+
+from .virtualbox_error import VirtualBoxError
+from .pipe_proxy import PipeProxy
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class VirtualBoxController(object):
+
+    def __init__(self, vmname, vboxmanager, host):
+
+        self._host = host
+        self._machine = None
+        self._session = None
+        self._vboxmanager = vboxmanager
+        self._maximum_adapters = 0
+        self._serial_pipe_thread = None
+        self._serial_pipe = None
+
+        self._vmname = vmname
+        self._console = 0
+        self._adapters = []
+        self._headless = False
+        self._enable_console = True
+        self._adapter_type = "Automatic"
+
+        try:
+            self._machine = self._vboxmanager.vbox.findMachine(self._vmname)
+        except Exception as e:
+            raise VirtualBoxError("VirtualBox error: {}".format(e))
+
+        # The maximum support network cards depends on the Chipset (PIIX3 or ICH9)
+        self._maximum_adapters = self._vboxmanager.vbox.systemProperties.getMaxNetworkAdapters(self._machine.chipsetType)
+
+    @property
+    def vmname(self):
+
+        return self._vmname
+
+    @vmname.setter
+    def vmname(self, new_vmname):
+
+        self._vmname = new_vmname
+        try:
+            self._machine = self._vboxmanager.vbox.findMachine(new_vmname)
+        except Exception as e:
+            raise VirtualBoxError("VirtualBox error: {}".format(e))
+
+        # The maximum support network cards depends on the Chipset (PIIX3 or ICH9)
+        self._maximum_adapters = self._vboxmanager.vbox.systemProperties.getMaxNetworkAdapters(self._machine.chipsetType)
+
+    @property
+    def console(self):
+
+        return self._console
+
+    @console.setter
+    def console(self, console):
+
+        self._console = console
+
+    @property
+    def headless(self):
+
+        return self._headless
+
+    @headless.setter
+    def headless(self, headless):
+
+        self._headless = headless
+
+    @property
+    def enable_console(self):
+
+        return self._enable_console
+
+    @enable_console.setter
+    def enable_console(self, enable_console):
+
+        self._enable_console = enable_console
+
+    @property
+    def adapters(self):
+
+        return self._adapters
+
+    @adapters.setter
+    def adapters(self, adapters):
+
+        self._adapters = adapters
+
+    @property
+    def adapter_type(self):
+
+        return self._adapter_type
+
+    @adapter_type.setter
+    def adapter_type(self, adapter_type):
+
+        self._adapter_type = adapter_type
+
+    def start(self):
+
+        if len(self._adapters) > self._maximum_adapters:
+            raise VirtualBoxError("Number of adapters above the maximum supported of {}".format(self._maximum_adapters))
+
+        if self._machine.state == self._vboxmanager.constants.MachineState_Paused:
+            self.resume()
+            return
+
+        self._get_session()
+        self._set_network_options()
+        if self._enable_console:
+            self._set_console_options()
+
+        progress = self._launch_vm_process()
+        log.info("VM is starting with {}% completed".format(progress.percent))
+        if progress.percent != 100:
+            # This will happen if you attempt to start VirtualBox with unloaded "vboxdrv" module.
+            # or have too little RAM or damaged vHDD, or connected to non-existent network.
+            # We must unlock machine, otherwise it locks the VirtualBox Manager GUI. (on Linux hosts)
+            self._unlock_machine()
+            raise VirtualBoxError("Unable to start the VM (failed at {}%)".format(progress.percent))
+
+        try:
+            self._machine.setGuestPropertyValue("NameInGNS3", self._name)
+        except Exception:
+            pass
+
+        if self._enable_console:
+            # starts the Telnet to pipe thread
+            pipe_name = self._get_pipe_name()
+            if sys.platform.startswith('win'):
+                try:
+                    self._serial_pipe = open(pipe_name, "a+b")
+                except OSError as e:
+                    raise VirtualBoxError("Could not open the pipe {}: {}".format(pipe_name, e))
+                self._serial_pipe_thread = PipeProxy(self._vmname, msvcrt.get_osfhandle(self._serial_pipe.fileno()), self._host, self._console)
+                #self._serial_pipe_thread.setDaemon(True)
+                self._serial_pipe_thread.start()
+            else:
+                try:
+                    self._serial_pipe = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+                    self._serial_pipe.connect(pipe_name)
+                except OSError as e:
+                    raise VirtualBoxError("Could not connect to the pipe {}: {}".format(pipe_name, e))
+                self._serial_pipe_thread = PipeProxy(self._vmname, self._serial_pipe, self._host, self._console)
+                #self._serial_pipe_thread.setDaemon(True)
+                self._serial_pipe_thread.start()
+
+    def stop(self):
+
+        if self._serial_pipe_thread:
+            self._serial_pipe_thread.stop()
+            self._serial_pipe_thread.join(1)
+            if self._serial_pipe_thread.isAlive():
+                log.warn("Serial pire thread is still alive!")
+            self._serial_pipe_thread = None
+
+        if self._serial_pipe:
+            if sys.platform.startswith('win'):
+                win32file.CloseHandle(msvcrt.get_osfhandle(self._serial_pipe.fileno()))
+            else:
+                self._serial_pipe.close()
+            self._serial_pipe = None
+
+        if self._machine.state >= self._vboxmanager.constants.MachineState_FirstOnline and \
+                self._machine.state <= self._vboxmanager.constants.MachineState_LastOnline:
+            try:
+                if sys.platform.startswith('win') and "VBOX_INSTALL_PATH" in os.environ:
+                    # work around VirtualBox bug #9239
+                    vboxmanage_path = os.path.join(os.environ["VBOX_INSTALL_PATH"], "VBoxManage.exe")
+                    command = '"{}" controlvm "{}" poweroff'.format(vboxmanage_path, self._vmname)
+                    subprocess.call(command, timeout=3)
+                else:
+                    progress = self._session.console.powerDown()
+                    # wait for VM to actually go down
+                    progress.waitForCompletion(3000)
+                    log.info("VM is stopping with {}% completed".format(self.vmname, progress.percent))
+
+                self._lock_machine()
+
+                for adapter_id in range(0, len(self._adapters)):
+                    if self._adapters[adapter_id] is None:
+                        continue
+                    self._disable_adapter(adapter_id, disable=True)
+                if self._enable_console:
+                    serial_port = self._session.machine.getSerialPort(0)
+                    serial_port.enabled = False
+                self._session.machine.saveSettings()
+                self._unlock_machine()
+            except Exception as e:
+                # Do not crash "vboxwrapper", if stopping VM fails.
+                # But return True anyway, so VM state in GNS3 can become "stopped"
+                # This can happen, if user manually kills VBox VM.
+                log.warn("could not stop VM for {}: {}".format(self._vmname, e))
+                return
+
+    def suspend(self):
+
+        try:
+            self._session.console.pause()
+        except Exception as e:
+            raise VirtualBoxError("VirtualBox error: {}".format(e))
+
+    def reload(self):
+
+        try:
+            self._session.console.reset()
+        except Exception as e:
+            raise VirtualBoxError("VirtualBox error: {}".format(e))
+
+    def resume(self):
+
+        try:
+            self._session.console.resume()
+        except Exception as e:
+            raise VirtualBoxError("VirtualBox error: {}".format(e))
+
+    def _get_session(self):
+
+        log.debug("getting session for {}".format(self._vmname))
+        try:
+            self._session = self._vboxmanager.mgr.getSessionObject(self._vboxmanager.vbox)
+        except Exception as e:
+            # fails on heavily loaded hosts...
+            raise VirtualBoxError("VirtualBox error: {}".format(e))
+
+    def _set_network_options(self):
+
+        log.debug("setting network options for {}".format(self._vmname))
+
+        self._lock_machine()
+
+        first_adapter_type = self._vboxmanager.constants.NetworkAdapterType_I82540EM
+        try:
+            first_adapter = self._session.machine.getNetworkAdapter(0)
+            first_adapter_type = first_adapter.adapterType
+        except Exception as e:
+            pass
+            #raise VirtualBoxError("VirtualBox error: {}".format(e))
+
+        for adapter_id in range(0, len(self._adapters)):
+
+            try:
+                # VirtualBox starts counting from 0
+                adapter = self._session.machine.getNetworkAdapter(adapter_id)
+                if self._adapters[adapter_id] is None:
+                    # force enable to avoid any discrepancy in the interface numbering inside the VM
+                    # e.g. Ethernet2 in GNS3 becoming eth0 inside the VM when using a start index of 2.
+                    adapter.enabled = True
+                    continue
+
+                vbox_adapter_type = adapter.adapterType
+                if self._adapter_type == "PCnet-PCI II (Am79C970A)":
+                    vbox_adapter_type = self._vboxmanager.constants.NetworkAdapterType_Am79C970A
+                if self._adapter_type == "PCNet-FAST III (Am79C973)":
+                    vbox_adapter_type = self._vboxmanager.constants.NetworkAdapterType_Am79C973
+                if self._adapter_type == "Intel PRO/1000 MT Desktop (82540EM)":
+                    vbox_adapter_type = self._vboxmanager.constants.NetworkAdapterType_I82540EM
+                if self._adapter_type == "Intel PRO/1000 T Server (82543GC)":
+                    vbox_adapter_type = self._vboxmanager.constants.NetworkAdapterType_I82543GC
+                if self._adapter_type == "Intel PRO/1000 MT Server (82545EM)":
+                    vbox_adapter_type = self._vboxmanager.constants.NetworkAdapterType_I82545EM
+                if self._adapter_type == "Paravirtualized Network (virtio-net)":
+                    vbox_adapter_type = self._vboxmanager.constants.NetworkAdapterType_Virtio
+                if self._adapter_type == "Automatic":  # "Auto-guess, based on first NIC"
+                    vbox_adapter_type = first_adapter_type
+
+                adapter.adapterType = vbox_adapter_type
+
+            except Exception as e:
+                raise VirtualBoxError("VirtualBox error: {}".format(e))
+
+            nio = self._adapters[adapter_id].get_nio(0)
+            if nio:
+                log.debug("setting UDP params on adapter {}".format(adapter_id))
+                try:
+                    adapter.enabled = True
+                    adapter.cableConnected = True
+                    adapter.traceEnabled = False
+                    # Temporary hack around VBox-UDP patch limitation: inability to use DNS
+                    if nio.rhost == 'localhost':
+                        rhost = '127.0.0.1'
+                    else:
+                        rhost = nio.rhost
+                    adapter.attachmentType = self._vboxmanager.constants.NetworkAttachmentType_Generic
+                    adapter.genericDriver = "UDPTunnel"
+                    adapter.setProperty("sport", str(nio.lport))
+                    adapter.setProperty("dest", rhost)
+                    adapter.setProperty("dport", str(nio.rport))
+                except Exception as e:
+                    # usually due to COM Error: "The object is not ready"
+                    raise VirtualBoxError("VirtualBox error: {}".format(e))
+
+                if nio.capturing:
+                    self._enable_capture(adapter, nio.pcap_output_file)
+
+            else:
+                # shutting down unused adapters...
+                try:
+                    adapter.enabled = True
+                    adapter.attachmentType = self._vboxmanager.constants.NetworkAttachmentType_Null
+                    adapter.cableConnected = False
+                except Exception as e:
+                    raise VirtualBoxError("VirtualBox error: {}".format(e))
+
+        for adapter_id in range(len(self._adapters), self._maximum_adapters):
+            log.debug("disabling remaining adapter {}".format(adapter_id))
+            self._disable_adapter(adapter_id)
+
+        try:
+            self._session.machine.saveSettings()
+        except Exception as e:
+            raise VirtualBoxError("VirtualBox error: {}".format(e))
+
+        self._unlock_machine()
+
+    def _disable_adapter(self, adapter_id, disable=True):
+
+        log.debug("disabling network adapter for {}".format(self._vmname))
+        # this command is retried several times, because it fails more often...
+        retries = 6
+        last_exception = None
+        for retry in range(retries):
+            if retry == (retries - 1):
+                raise VirtualBoxError("Could not disable network adapter after 4 retries: {}".format(last_exception))
+            try:
+                adapter = self._session.machine.getNetworkAdapter(adapter_id)
+                adapter.traceEnabled = False
+                adapter.attachmentType = self._vboxmanager.constants.NetworkAttachmentType_Null
+                if disable:
+                    adapter.enabled = False
+                break
+            except Exception as e:
+                # usually due to COM Error: "The object is not ready"
+                log.warn("cannot disable network adapter for {}, retrying {}: {}".format(self._vmname, retry + 1, e))
+                last_exception = e
+                time.sleep(1)
+                continue
+
+    def _enable_capture(self, adapter, output_file):
+
+        log.debug("enabling capture for {}".format(self._vmname))
+        # this command is retried several times, because it fails more often...
+        retries = 4
+        last_exception = None
+        for retry in range(retries):
+            if retry == (retries - 1):
+                raise VirtualBoxError("Could not enable packet capture after 4 retries: {}".format(last_exception))
+            try:
+                adapter.traceEnabled = True
+                adapter.traceFile = output_file
+                break
+            except Exception as e:
+                log.warn("cannot enable packet capture for {}, retrying {}: {}".format(self._vmname, retry + 1, e))
+                last_exception = e
+                time.sleep(0.75)
+                continue
+
+    def create_udp(self, adapter_id, sport, daddr, dport):
+
+        if self._machine.state >= self._vboxmanager.constants.MachineState_FirstOnline and \
+                self._machine.state <= self._vboxmanager.constants.MachineState_LastOnline:
+            # the machine is being executed
+            retries = 4
+            last_exception = None
+            for retry in range(retries):
+                if retry == (retries - 1):
+                    raise VirtualBoxError("Could not create an UDP tunnel after 4 retries :{}".format(last_exception))
+                try:
+                    adapter = self._session.machine.getNetworkAdapter(adapter_id)
+                    adapter.cableConnected = True
+                    adapter.attachmentType = self._vboxmanager.constants.NetworkAttachmentType_Null
+                    self._session.machine.saveSettings()
+                    adapter.attachmentType = self._vboxmanager.constants.NetworkAttachmentType_Generic
+                    adapter.genericDriver = "UDPTunnel"
+                    adapter.setProperty("sport", str(sport))
+                    adapter.setProperty("dest", daddr)
+                    adapter.setProperty("dport", str(dport))
+                    self._session.machine.saveSettings()
+                    break
+                except Exception as e:
+                    # usually due to COM Error: "The object is not ready"
+                    log.warn("cannot create UDP tunnel for {}: {}".format(self._vmname, e))
+                    last_exception = e
+                    time.sleep(0.75)
+                    continue
+
+    def delete_udp(self, adapter_id):
+
+        if self._machine.state >= self._vboxmanager.constants.MachineState_FirstOnline and \
+                self._machine.state <= self._vboxmanager.constants.MachineState_LastOnline:
+            # the machine is being executed
+            retries = 4
+            last_exception = None
+            for retry in range(retries):
+                if retry == (retries - 1):
+                    raise VirtualBoxError("Could not delete an UDP tunnel after 4 retries :{}".format(last_exception))
+                try:
+                    adapter = self._session.machine.getNetworkAdapter(adapter_id)
+                    adapter.attachmentType = self._vboxmanager.constants.NetworkAttachmentType_Null
+                    adapter.cableConnected = False
+                    self._session.machine.saveSettings()
+                    break
+                except Exception as e:
+                    # usually due to COM Error: "The object is not ready"
+                    log.debug("cannot delete UDP tunnel for {}: {}".format(self._vmname, e))
+                    last_exception = e
+                    time.sleep(0.75)
+                    continue
+
+    def _get_pipe_name(self):
+
+        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)
+        else:
+            pipe_name = os.path.join(tempfile.gettempdir(), "pipe_{}".format(pipe_name))
+        return pipe_name
+
+    def _set_console_options(self):
+        """
+        # Example to manually set serial parameters using Python
+
+        from vboxapi import VirtualBoxManager
+        mgr = VirtualBoxManager(None, None)
+        mach = mgr.vbox.findMachine("My VM")
+        session = mgr.mgr.getSessionObject(mgr.vbox)
+        mach.lockMachine(session, 1)
+        mach2=session.machine
+        serial_port = mach2.getSerialPort(0)
+        serial_port.enabled = True
+        serial_port.path = "/tmp/test_pipe"
+        serial_port.hostMode = 1
+        serial_port.server = True
+        session.unlockMachine()
+        """
+
+        log.info("setting console options for {}".format(self._vmname))
+
+        self._lock_machine()
+        pipe_name = self._get_pipe_name()
+
+        try:
+            serial_port = self._session.machine.getSerialPort(0)
+            serial_port.enabled = True
+            serial_port.path = pipe_name
+            serial_port.hostMode = 1
+            serial_port.server = True
+            self._session.machine.saveSettings()
+        except Exception as e:
+            raise VirtualBoxError("VirtualBox error: {}".format(e))
+
+        self._unlock_machine()
+
+    def _launch_vm_process(self):
+
+        log.debug("launching VM {}".format(self._vmname))
+        # this command is retried several times, because it fails more often...
+        retries = 4
+        last_exception = None
+        for retry in range(retries):
+            if retry == (retries - 1):
+                raise VirtualBoxError("Could not launch the VM after 4 retries: {}".format(last_exception))
+            try:
+                if self._headless:
+                    mode = "headless"
+                else:
+                    mode = "gui"
+                log.info("starting {} in {} mode".format(self._vmname, mode))
+                progress = self._machine.launchVMProcess(self._session, mode, "")
+                break
+            except Exception as e:
+                # This will usually happen if you try to start the same VM twice,
+                # but may happen on loaded hosts too...
+                log.warn("cannot launch VM {}, retrying {}: {}".format(self._vmname, retry + 1, e))
+                last_exception = e
+                time.sleep(0.6)
+                continue
+
+        try:
+            progress.waitForCompletion(-1)
+        except Exception as e:
+            raise VirtualBoxError("VirtualBox error: {}".format(e))
+
+        return progress
+
+    def _lock_machine(self):
+
+        log.debug("locking machine for {}".format(self._vmname))
+        # this command is retried several times, because it fails more often...
+        retries = 4
+        last_exception = None
+        for retry in range(retries):
+            if retry == (retries - 1):
+                raise VirtualBoxError("Could not lock the machine after 4 retries: {}".format(last_exception))
+            try:
+                self._machine.lockMachine(self._session, 1)
+                break
+            except Exception as e:
+                log.warn("cannot lock the machine for {}, retrying {}: {}".format(self._vmname, retry + 1, e))
+                last_exception = e
+                time.sleep(1)
+                continue
+
+    def _unlock_machine(self):
+
+        log.debug("unlocking machine for {}".format(self._vmname))
+        # this command is retried several times, because it fails more often...
+        retries = 4
+        last_exception = None
+        for retry in range(retries):
+            if retry == (retries - 1):
+                raise VirtualBoxError("Could not unlock the machine after 4 retries: {}".format(last_exception))
+            try:
+                self._session.unlockMachine()
+                break
+            except Exception as e:
+                log.warn("cannot unlock the machine for {}, retrying {}: {}".format(self._vmname, retry + 1, e))
+                time.sleep(1)
+                last_exception = e
+                continue

gns3server/modules/virtualbox/virtualbox_error.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+Custom exceptions for VirtualBox module.
+"""
+
+
+class VirtualBoxError(Exception):
+
+    def __init__(self, message, original_exception=None):
+
+        Exception.__init__(self, message)
+        if isinstance(message, Exception):
+            message = str(message)
+        self._message = message
+        self._original_exception = original_exception
+
+    def __repr__(self):
+
+        return self._message
+
+    def __str__(self):
+
+        return self._message

gns3server/modules/virtualbox/virtualbox_vm.py

@@ -0,0 +1,654 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2014 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+VirtualBox VM instance.
+"""
+
+import os
+import shutil
+
+from .virtualbox_error import VirtualBoxError
+from .virtualbox_controller import VirtualBoxController
+from .adapters.ethernet_adapter import EthernetAdapter
+from ..attic import find_unused_port
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class VirtualBoxVM(object):
+    """
+    VirtualBox VM implementation.
+
+    :param vboxwrapper client: VboxWrapperClient instance
+    :param vboxmanager: VirtualBox manager from the VirtualBox API
+    :param name: name of this VirtualBox VM
+    :param vmname: name of this VirtualBox VM in VirtualBox itself
+    :param working_dir: path to a working directory
+    :param host: host/address to bind for console and UDP connections
+    :param vbox_id: VirtalBox VM instance ID
+    :param console: TCP console port
+    :param console_start_port_range: TCP console port range start
+    :param console_end_port_range: TCP console port range end
+    """
+
+    _instances = []
+    _allocated_console_ports = []
+
+    def __init__(self,
+                 vboxwrapper,
+                 vboxmanager,
+                 name,
+                 vmname,
+                 working_dir,
+                 host="127.0.0.1",
+                 vbox_id=None,
+                 console=None,
+                 console_start_port_range=4512,
+                 console_end_port_range=5000):
+
+        if not vbox_id:
+            self._id = 0
+            for identifier in range(1, 1024):
+                if identifier not in self._instances:
+                    self._id = identifier
+                    self._instances.append(self._id)
+                    break
+
+            if self._id == 0:
+                raise VirtualBoxError("Maximum number of VirtualBox VM instances reached")
+        else:
+            if vbox_id in self._instances:
+                raise VirtualBoxError("VirtualBox identifier {} is already used by another VirtualBox VM instance".format(vbox_id))
+            self._id = vbox_id
+            self._instances.append(self._id)
+
+        self._name = name
+        self._working_dir = None
+        self._host = host
+        self._command = []
+        self._vboxwrapper = vboxwrapper
+        self._started = False
+        self._console_start_port_range = console_start_port_range
+        self._console_end_port_range = console_end_port_range
+
+        # VirtualBox settings
+        self._console = console
+        self._ethernet_adapters = []
+        self._headless = False
+        self._enable_console = True
+        self._vmname = vmname
+        self._adapter_start_index = 0
+        self._adapter_type = "Automatic"
+
+        working_dir_path = os.path.join(working_dir, "vbox", "vm-{}".format(self._id))
+
+        if vbox_id and not os.path.isdir(working_dir_path):
+            raise VirtualBoxError("Working directory {} doesn't exist".format(working_dir_path))
+
+        # create the device own working directory
+        self.working_dir = working_dir_path
+
+        if not self._console:
+            # allocate a console port
+            try:
+                self._console = find_unused_port(self._console_start_port_range,
+                                                 self._console_end_port_range,
+                                                 self._host,
+                                                 ignore_ports=self._allocated_console_ports)
+            except Exception as e:
+                raise VirtualBoxError(e)
+
+        if self._console in self._allocated_console_ports:
+            raise VirtualBoxError("Console port {} is already used by another VirtualBox VM".format(console))
+        self._allocated_console_ports.append(self._console)
+
+        if self._vboxwrapper:
+            self._vboxwrapper.send('vbox create vbox "{}"'.format(self._name))
+            self._vboxwrapper.send('vbox setattr "{}" image "{}"'.format(self._name, vmname))
+            self._vboxwrapper.send('vbox setattr "{}" console {}'.format(self._name, self._console))
+        else:
+            self._vboxcontroller = VirtualBoxController(self._vmname, vboxmanager, self._host)
+            self._vboxcontroller.console = self._console
+
+        self.adapters = 2  # creates 2 adapters by default
+        log.info("VirtualBox VM {name} [id={id}] has been created".format(name=self._name,
+                                                                          id=self._id))
+
+    def defaults(self):
+        """
+        Returns all the default attribute values for this VirtualBox VM.
+
+        :returns: default values (dictionary)
+        """
+
+        vbox_defaults = {"name": self._name,
+                         "vmname": self._vmname,
+                         "adapters": self.adapters,
+                         "adapter_start_index": self._adapter_start_index,
+                         "adapter_type": "Automatic",
+                         "console": self._console,
+                         "enable_console": self._enable_console,
+                         "headless": self._headless}
+
+        return vbox_defaults
+
+    @property
+    def id(self):
+        """
+        Returns the unique ID for this VirtualBox VM.
+
+        :returns: id (integer)
+        """
+
+        return self._id
+
+    @classmethod
+    def reset(cls):
+        """
+        Resets allocated instance list.
+        """
+
+        cls._instances.clear()
+        cls._allocated_console_ports.clear()
+
+    @property
+    def name(self):
+        """
+        Returns the name of this VirtualBox VM.
+
+        :returns: name
+        """
+
+        return self._name
+
+    @name.setter
+    def name(self, new_name):
+        """
+        Sets the name of this VirtualBox VM.
+
+        :param new_name: name
+        """
+
+        log.info("VirtualBox VM {name} [id={id}]: renamed to {new_name}".format(name=self._name,
+                                                                                id=self._id,
+                                                                                new_name=new_name))
+
+        if self._vboxwrapper:
+            self._vboxwrapper.send('vbox rename "{}" "{}"'.format(self._name, new_name))
+        self._name = new_name
+
+    @property
+    def working_dir(self):
+        """
+        Returns current working directory
+
+        :returns: path to the working directory
+        """
+
+        return self._working_dir
+
+    @working_dir.setter
+    def working_dir(self, working_dir):
+        """
+        Sets the working directory this VirtualBox VM.
+
+        :param working_dir: path to the working directory
+        """
+
+        try:
+            os.makedirs(working_dir)
+        except FileExistsError:
+            pass
+        except OSError as e:
+            raise VirtualBoxError("Could not create working directory {}: {}".format(working_dir, e))
+
+        self._working_dir = working_dir
+        log.info("VirtualBox VM {name} [id={id}]: working directory changed to {wd}".format(name=self._name,
+                                                                                            id=self._id,
+                                                                                            wd=self._working_dir))
+
+    @property
+    def console(self):
+        """
+        Returns the TCP console port.
+
+        :returns: console port (integer)
+        """
+
+        return self._console
+
+    @console.setter
+    def console(self, console):
+        """
+        Sets the TCP console port.
+
+        :param console: console port (integer)
+        """
+
+        if console in self._allocated_console_ports:
+            raise VirtualBoxError("Console port {} is already used by another VirtualBox VM".format(console))
+
+        self._allocated_console_ports.remove(self._console)
+        self._console = console
+        self._allocated_console_ports.append(self._console)
+
+        if self._vboxwrapper:
+            self._vboxwrapper.send('vbox setattr "{}" console {}'.format(self._name, self._console))
+        else:
+            self._vboxcontroller.console = console
+
+        log.info("VirtualBox VM {name} [id={id}]: console port set to {port}".format(name=self._name,
+                                                                                     id=self._id,
+                                                                                     port=console))
+
+    def delete(self):
+        """
+        Deletes this VirtualBox VM.
+        """
+
+        self.stop()
+        if self._id in self._instances:
+            self._instances.remove(self._id)
+
+        if self.console and self.console in self._allocated_console_ports:
+            self._allocated_console_ports.remove(self.console)
+
+        if self._vboxwrapper:
+            self._vboxwrapper.send('vbox delete "{}"'.format(self._name))
+
+        log.info("VirtualBox VM {name} [id={id}] has been deleted".format(name=self._name,
+                                                                          id=self._id))
+
+    def clean_delete(self):
+        """
+        Deletes this VirtualBox VM & all files.
+        """
+
+        self.stop()
+        if self._id in self._instances:
+            self._instances.remove(self._id)
+
+        if self.console:
+            self._allocated_console_ports.remove(self.console)
+
+        if self._vboxwrapper:
+            self._vboxwrapper.send('vbox delete "{}"'.format(self._name))
+
+        try:
+            shutil.rmtree(self._working_dir)
+        except OSError as e:
+            log.error("could not delete VirtualBox VM {name} [id={id}]: {error}".format(name=self._name,
+                                                                                        id=self._id,
+                                                                                        error=e))
+            return
+
+        log.info("VirtualBox VM {name} [id={id}] has been deleted (including associated files)".format(name=self._name,
+                                                                                                       id=self._id))
+
+    @property
+    def headless(self):
+        """
+        Returns either the VM will start in headless mode
+
+        :returns: boolean
+        """
+
+        return self._headless
+
+    @headless.setter
+    def headless(self, headless):
+        """
+        Sets either the VM will start in headless mode
+
+        :param headless: boolean
+        """
+
+        if headless:
+            if self._vboxwrapper:
+                self._vboxwrapper.send('vbox setattr "{}" headless_mode True'.format(self._name))
+            else:
+                self._vboxcontroller.headless = True
+            log.info("VirtualBox VM {name} [id={id}] has enabled the headless mode".format(name=self._name, id=self._id))
+        else:
+            if self._vboxwrapper:
+                self._vboxwrapper.send('vbox setattr "{}" headless_mode False'.format(self._name))
+            else:
+                self._vboxcontroller.headless = False
+            log.info("VirtualBox VM {name} [id={id}] has disabled the headless mode".format(name=self._name, id=self._id))
+        self._headless = headless
+
+    @property
+    def enable_console(self):
+        """
+        Returns either the console is enabled or not
+
+        :returns: boolean
+        """
+
+        return self._enable_console
+
+    @enable_console.setter
+    def enable_console(self, enable_console):
+        """
+        Sets either the console is enabled or not
+
+        :param enable_console: boolean
+        """
+
+        if enable_console:
+            if self._vboxwrapper:
+                self._vboxwrapper.send('vbox setattr "{}" enable_console True'.format(self._name))
+            else:
+                self._vboxcontroller.enable_console = True
+            log.info("VirtualBox VM {name} [id={id}] has enabled the console".format(name=self._name, id=self._id))
+        else:
+            if self._vboxwrapper:
+                self._vboxwrapper.send('vbox setattr "{}" enable_console False'.format(self._name))
+            else:
+                self._vboxcontroller.enable_console = False
+            log.info("VirtualBox VM {name} [id={id}] has disabled the console".format(name=self._name, id=self._id))
+        self._enable_console = enable_console
+
+    @property
+    def vmname(self):
+        """
+        Returns the VM name associated with this VirtualBox VM.
+
+        :returns: VirtualBox VM name
+        """
+
+        return self._vmname
+
+    @vmname.setter
+    def vmname(self, vmname):
+        """
+        Sets the VM name associated with this VirtualBox VM.
+
+        :param vmname: VirtualBox VM name
+        """
+
+        if self._vboxwrapper:
+            self._vboxwrapper.send('vbox setattr "{}" image "{}"'.format(self._name, vmname))
+        else:
+            self._vboxcontroller.vmname = vmname
+
+        log.info("VirtualBox VM {name} [id={id}] has set the VM name to {vmname}".format(name=self._name, id=self._id, vmname=vmname))
+        self._vmname = vmname
+
+    @property
+    def adapters(self):
+        """
+        Returns the number of Ethernet adapters for this VirtualBox VM instance.
+
+        :returns: number of adapters
+        """
+
+        return len(self._ethernet_adapters)
+
+    @adapters.setter
+    def adapters(self, adapters):
+        """
+        Sets the number of Ethernet adapters for this VirtualBox VM instance.
+
+        :param adapters: number of adapters
+        """
+
+        self._ethernet_adapters.clear()
+        for adapter_id in range(0, self._adapter_start_index + adapters):
+            if adapter_id < self._adapter_start_index:
+                self._ethernet_adapters.append(None)
+                continue
+            self._ethernet_adapters.append(EthernetAdapter())
+
+        if self._vboxwrapper:
+            self._vboxwrapper.send('vbox setattr "{}" nics {}'.format(self._name, adapters))
+        else:
+            self._vboxcontroller.adapters = self._ethernet_adapters
+
+        log.info("VirtualBox VM {name} [id={id}]: number of Ethernet adapters changed to {adapters}".format(name=self._name,
+                                                                                                            id=self._id,
+                                                                                                            adapters=adapters))
+
+    @property
+    def adapter_start_index(self):
+        """
+        Returns the adapter start index for this VirtualBox VM instance.
+
+        :returns: index
+        """
+
+        return self._adapter_start_index
+
+    @adapter_start_index.setter
+    def adapter_start_index(self, adapter_start_index):
+        """
+        Sets the adapter start index for this VirtualBox VM instance.
+
+        :param adapter_start_index: index
+        """
+
+        if self._vboxwrapper:
+            self._vboxwrapper.send('vbox setattr "{}" nic_start_index {}'.format(self._name, adapter_start_index))
+
+        self._adapter_start_index = adapter_start_index
+        self.adapters = self.adapters  # this forces to recreate the adapter list with the correct index
+        log.info("VirtualBox VM {name} [id={id}]: adapter start index changed to {index}".format(name=self._name,
+                                                                                                 id=self._id,
+                                                                                                 index=adapter_start_index))
+
+    @property
+    def adapter_type(self):
+        """
+        Returns the adapter type for this VirtualBox VM instance.
+
+        :returns: adapter type (string)
+        """
+
+        return self._adapter_type
+
+    @adapter_type.setter
+    def adapter_type(self, adapter_type):
+        """
+        Sets the adapter type for this VirtualBox VM instance.
+
+        :param adapter_type: adapter type (string)
+        """
+
+        self._adapter_type = adapter_type
+
+        if self._vboxwrapper:
+            self._vboxwrapper.send('vbox setattr "{}" netcard "{}"'.format(self._name, adapter_type))
+        else:
+            self._vboxcontroller.adapter_type = adapter_type
+
+        log.info("VirtualBox VM {name} [id={id}]: adapter type changed to {adapter_type}".format(name=self._name,
+                                                                                                 id=self._id,
+                                                                                                 adapter_type=adapter_type))
+
+    def start(self):
+        """
+        Starts this VirtualBox VM.
+        """
+
+        if self._vboxwrapper:
+            self._vboxwrapper.send('vbox start "{}"'.format(self._name))
+        else:
+            self._vboxcontroller.start()
+
+    def stop(self):
+        """
+        Stops this VirtualBox VM.
+        """
+
+        if self._vboxwrapper:
+            try:
+                self._vboxwrapper.send('vbox stop "{}"'.format(self._name))
+            except VirtualBoxError:
+                # probably lost the connection
+                return
+        else:
+            self._vboxcontroller.stop()
+
+    def suspend(self):
+        """
+        Suspends this VirtualBox VM.
+        """
+
+        if self._vboxwrapper:
+            self._vboxwrapper.send('vbox suspend "{}"'.format(self._name))
+        else:
+            self._vboxcontroller.suspend()
+
+    def reload(self):
+        """
+        Reloads this VirtualBox VM.
+        """
+
+        if self._vboxwrapper:
+            self._vboxwrapper.send('vbox reset "{}"'.format(self._name))
+        else:
+            self._vboxcontroller.reload()
+
+    def resume(self):
+        """
+        Resumes this VirtualBox VM.
+        """
+
+        if self._vboxwrapper:
+            self._vboxwrapper.send('vbox resume "{}"'.format(self._name))
+        else:
+            self._vboxcontroller.resume()
+
+    def port_add_nio_binding(self, adapter_id, nio):
+        """
+        Adds a port NIO binding.
+
+        :param adapter_id: adapter ID
+        :param nio: NIO instance to add to the slot/port
+        """
+
+        try:
+            adapter = self._ethernet_adapters[adapter_id]
+        except IndexError:
+            raise VirtualBoxError("Adapter {adapter_id} doesn't exist on VirtualBox VM {name}".format(name=self._name,
+                                                                                                      adapter_id=adapter_id))
+
+        if self._vboxwrapper:
+            self._vboxwrapper.send('vbox create_udp "{}" {} {} {} {}'.format(self._name,
+                                                                             adapter_id,
+                                                                             nio.lport,
+                                                                             nio.rhost,
+                                                                             nio.rport))
+        else:
+            self._vboxcontroller.create_udp(adapter_id, nio.lport, nio.rhost, nio.rport)
+
+        adapter.add_nio(0, nio)
+        log.info("VirtualBox VM {name} [id={id}]: {nio} added to adapter {adapter_id}".format(name=self._name,
+                                                                                              id=self._id,
+                                                                                              nio=nio,
+                                                                                              adapter_id=adapter_id))
+
+    def port_remove_nio_binding(self, adapter_id):
+        """
+        Removes a port NIO binding.
+
+        :param adapter_id: adapter ID
+
+        :returns: NIO instance
+        """
+
+        try:
+            adapter = self._ethernet_adapters[adapter_id]
+        except IndexError:
+            raise VirtualBoxError("Adapter {adapter_id} doesn't exist on VirtualBox VM {name}".format(name=self._name,
+                                                                                                      adapter_id=adapter_id))
+
+        if self._vboxwrapper:
+            self._vboxwrapper.send('vbox delete_udp "{}" {}'.format(self._name,
+                                                                    adapter_id))
+        else:
+            self._vboxcontroller.delete_udp(adapter_id)
+
+        nio = adapter.get_nio(0)
+        adapter.remove_nio(0)
+        log.info("VirtualBox VM {name} [id={id}]: {nio} removed from adapter {adapter_id}".format(name=self._name,
+                                                                                                  id=self._id,
+                                                                                                  nio=nio,
+                                                                                                  adapter_id=adapter_id))
+        return nio
+
+    def start_capture(self, adapter_id, output_file):
+        """
+        Starts a packet capture.
+
+        :param adapter_id: adapter ID
+        :param output_file: PCAP destination file for the capture
+        """
+
+        try:
+            adapter = self._ethernet_adapters[adapter_id]
+        except IndexError:
+            raise VirtualBoxError("Adapter {adapter_id} doesn't exist on VirtualBox VM {name}".format(name=self._name,
+                                                                                                      adapter_id=adapter_id))
+
+        nio = adapter.get_nio(0)
+        if nio.capturing:
+            raise VirtualBoxError("Packet capture is already activated on adapter {adapter_id}".format(adapter_id=adapter_id))
+
+        try:
+            os.makedirs(os.path.dirname(output_file))
+        except FileExistsError:
+            pass
+        except OSError as e:
+            raise VirtualBoxError("Could not create captures directory {}".format(e))
+
+        nio.startPacketCapture(output_file)
+
+        if self._vboxwrapper:
+            self._vboxwrapper.send('vbox create_capture "{}" {} "{}"'.format(self._name,
+                                                                            adapter_id,
+                                                                            output_file))
+
+        log.info("VirtualBox VM {name} [id={id}]: starting packet capture on adapter {adapter_id}".format(name=self._name,
+                                                                                                          id=self._id,
+                                                                                                          adapter_id=adapter_id))
+
+    def stop_capture(self, adapter_id):
+        """
+        Stops a packet capture.
+
+        :param adapter_id: adapter ID
+        """
+
+        try:
+            adapter = self._ethernet_adapters[adapter_id]
+        except IndexError:
+            raise VirtualBoxError("Adapter {adapter_id} doesn't exist on VirtualBox VM {name}".format(name=self._name,
+                                                                                                      adapter_id=adapter_id))
+
+        nio = adapter.get_nio(0)
+        nio.stopPacketCapture()
+
+        if self._vboxwrapper:
+            self._vboxwrapper.send('vbox delete_capture "{}" {}'.format(self._name,
+                                                                        adapter_id))
+
+        log.info("VirtualBox VM {name} [id={id}]: stopping packet capture on adapter {adapter_id}".format(name=self._name,
+                                                                                                          id=self._id,
+                                                                                                          adapter_id=adapter_id))

gns3server/modules/vpcs/__init__.py

@@ -41,6 +41,7 @@ from .schemas import VPCS_RELOAD_SCHEMA
 from .schemas import VPCS_ALLOCATE_UDP_PORT_SCHEMA
 from .schemas import VPCS_ADD_NIO_SCHEMA
 from .schemas import VPCS_DELETE_NIO_SCHEMA
+from .schemas import VPCS_EXPORT_CONFIG_SCHEMA
 
 import logging
 log = logging.getLogger(__name__)
@@ -60,9 +61,9 @@ class VPCS(IModule):
         # get the VPCS location
         config = Config.instance()
         vpcs_config = config.get_section_config(name.upper())
-        self._vpcs = vpcs_config.get("vpcs")
+        self._vpcs = vpcs_config.get("vpcs_path")
         if not self._vpcs or not os.path.isfile(self._vpcs):
-            paths = [os.getcwd()] + os.environ["PATH"].split(":")
+            paths = [os.getcwd()] + os.environ["PATH"].split(os.pathsep)
             # look for VPCS in the current working directory and $PATH
             for path in paths:
                 try:
@@ -80,12 +81,12 @@ class VPCS(IModule):
         # a new process start when calling IModule
         IModule.__init__(self, name, *args, **kwargs)
         self._vpcs_instances = {}
-        self._console_start_port_range = 4512
-        self._console_end_port_range = 5000
+        self._console_start_port_range = vpcs_config.get("console_start_port_range", 4501)
+        self._console_end_port_range = vpcs_config.get("console_end_port_range", 5000)
         self._allocated_udp_ports = []
-        self._udp_start_port_range = 40001
-        self._udp_end_port_range = 40512
-        self._host = kwargs["host"]
+        self._udp_start_port_range = vpcs_config.get("udp_start_port_range", 20501)
+        self._udp_end_port_range = vpcs_config.get("udp_end_port_range", 21000)
+        self._host = vpcs_config.get("host", kwargs["host"])
         self._projects_dir = kwargs["projects_dir"]
         self._tempdir = kwargs["temp_dir"]
         self._working_dir = self._projects_dir
@@ -361,7 +362,7 @@ class VPCS(IModule):
         self.send_response(response)
 
     @IModule.route("vpcs.start")
-    def vm_start(self, request):
+    def vpcs_start(self, request):
         """
         Starts a VPCS instance.
 
@@ -391,7 +392,7 @@ class VPCS(IModule):
         self.send_response(True)
 
     @IModule.route("vpcs.stop")
-    def vm_stop(self, request):
+    def vpcs_stop(self, request):
         """
         Stops a VPCS instance.
 
@@ -421,7 +422,7 @@ class VPCS(IModule):
         self.send_response(True)
 
     @IModule.route("vpcs.reload")
-    def vm_reload(self, request):
+    def vpcs_reload(self, request):
         """
         Reloads a VPCS instance.
 
@@ -597,6 +598,43 @@ class VPCS(IModule):
 
         self.send_response(True)
 
+    @IModule.route("vpcs.export_config")
+    def export_config(self, request):
+        """
+        Exports the script file from a VPCS instance.
+
+        Mandatory request parameters:
+        - id (vm identifier)
+
+        Response parameters:
+        - script_file_base64 (script file base64 encoded)
+        - False if no configuration can be exported
+        """
+
+        # validate the request
+        if not self.validate_request(request, VPCS_EXPORT_CONFIG_SCHEMA):
+            return
+
+        # get the instance
+        vpcs_instance = self.get_vpcs_instance(request["id"])
+        if not vpcs_instance:
+            return
+
+        response = {}
+        script_file_path = os.path.join(vpcs_instance.working_dir, vpcs_instance.script_file)
+        try:
+            with open(script_file_path, "rb") as f:
+                config = f.read()
+                response["script_file_base64"] = base64.encodebytes(config).decode("utf-8")
+        except OSError as e:
+            self.send_custom_error("unable to export the script file: {}".format(e))
+            return
+
+        if not response:
+            self.send_response(False)
+        else:
+            self.send_response(response)
+
     @IModule.route("vpcs.echo")
     def echo(self, request):
         """

gns3server/modules/vpcs/nios/nio_tap.py

@@ -22,7 +22,7 @@ Interface for TAP NIOs (UNIX based OSes only).
 
 class NIO_TAP(object):
     """
-    IOU TAP NIO.
+    TAP NIO.
 
     :param tap_device: TAP device name (e.g. tap0)
     """

gns3server/modules/vpcs/nios/nio_udp.py

@@ -22,7 +22,7 @@ Interface for UDP NIOs.
 
 class NIO_UDP(object):
     """
-    IOU UDP NIO.
+    UDP NIO.
 
     :param lport: local port number
     :param rhost: remote address/host

gns3server/modules/vpcs/schemas.py

@@ -331,3 +331,17 @@ VPCS_DELETE_NIO_SCHEMA = {
     "additionalProperties": False,
     "required": ["id", "port"]
 }
+
+VPCS_EXPORT_CONFIG_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request validation to export the script file of a VPCS instance",
+    "type": "object",
+    "properties": {
+        "id": {
+            "description": "VPCS device instance ID",
+            "type": "integer"
+        },
+    },
+    "additionalProperties": False,
+    "required": ["id"]
+}

gns3server/modules/vpcs/vpcs_device.py

@@ -25,7 +25,9 @@ import sys
 import subprocess
 import signal
 import shutil
+import re
 
+from pkg_resources import parse_version
 from .vpcs_error import VPCSError
 from .adapters.ethernet_adapter import EthernetAdapter
 from .nios.nio_udp import NIO_UDP
@@ -91,7 +93,6 @@ class VPCSDevice(object):
         self._command = []
         self._process = None
         self._vpcs_stdout_file = ""
-        self._host = "127.0.0.1"
         self._started = False
         self._console_start_port_range = console_start_port_range
         self._console_end_port_range = console_end_port_range
@@ -175,18 +176,6 @@ class VPCSDevice(object):
         :param new_name: name
         """
 
-        if self._started:
-            raise VPCSError("Cannot change the name to {} while the device is running".format(new_name))
-
-        new_working_dir = os.path.join(os.path.dirname(self._working_dir), new_name)
-        try:
-            shutil.move(self._working_dir, new_working_dir)
-            self._working_dir = new_working_dir
-        except OSError as e:
-            raise VPCSError("Could not move working directory from {} to {}: {}".format(self._working_dir,
-                                                                                        new_working_dir,
-                                                                                        e))
-
         if self._script_file:
             # update the startup.vpc
             config_path = os.path.join(self._working_dir, "startup.vpc")
@@ -343,6 +332,23 @@ class VPCSDevice(object):
 
         return self._started
 
+    def _check_vpcs_version(self):
+        """
+        Checks if the VPCS executable version is >= 0.5b1.
+        """
+
+        try:
+            output = subprocess.check_output([self._path, "-v"], cwd=self._working_dir)
+            match = re.search("Welcome to Virtual PC Simulator, version ([0-9a-z\.]+)", output.decode("utf-8"))
+            if match:
+                version = match.group(1)
+                if parse_version(version) < parse_version("0.5b1"):
+                    raise VPCSError("VPCS executable version must be >= 0.5b1")
+            else:
+                raise VPCSError("Could not determine the VPCS version for {}".format(self._path))
+        except (OSError, subprocess.CalledProcessError) as e:
+            raise VPCSError("Error while looking for the VPCS version: {}".format(e))
+
     def start(self):
         """
         Starts the VPCS process.
@@ -359,6 +365,8 @@ class VPCSDevice(object):
             if not os.access(self._path, os.X_OK):
                 raise VPCSError("VPCS program '{}' is not executable".format(self._path))
 
+            self._check_vpcs_version()
+
             if not self._ethernet_adapter.get_nio(0):
                 raise VPCSError("This VPCS instance must be connected in order to start")
 

gns3server/server.py

@@ -33,12 +33,16 @@ import tornado.ioloop
 import tornado.web
 import tornado.autoreload
 import pkg_resources
+from os.path import expanduser
+import base64
+import uuid
 
 from pkg_resources import parse_version
 from .config import Config
 from .handlers.jsonrpc_websocket import JSONRPCWebSocket
 from .handlers.version_handler import VersionHandler
 from .handlers.file_upload_handler import FileUploadHandler
+from .handlers.auth_handler import LoginHandler
 from .builtins.server_version import server_version
 from .builtins.interfaces import interfaces
 from .modules import MODULES
@@ -46,12 +50,12 @@ from .modules import MODULES
 import logging
 log = logging.getLogger(__name__)
 
-
 class Server(object):
 
     # built-in handlers
     handlers = [(r"/version", VersionHandler),
-                (r"/upload", FileUploadHandler)]
+                (r"/upload", FileUploadHandler),
+                (r"/login", LoginHandler)]
 
     def __init__(self, host, port, ipc=False):
 
@@ -136,11 +140,42 @@ class Server(object):
                 JSONRPCWebSocket.register_destination(destination, instance.name)
             instance.start()  # starts the new process
 
+
     def run(self):
         """
         Starts the Tornado web server and ZeroMQ server.
         """
 
+        settings = {
+            "debug":True,
+            "cookie_secret": base64.b64encode(uuid.uuid4().bytes + uuid.uuid4().bytes),
+            "login_url": "/login",
+        }
+
+        ssl_options = {}
+
+        try:
+            cloud_config = Config.instance().get_section_config("CLOUD_SERVER")
+
+            cloud_settings = {
+
+                "required_user" : cloud_config['WEB_USERNAME'],
+                "required_pass" : cloud_config['WEB_PASSWORD'],
+            }
+
+            settings.update(cloud_settings)
+
+            if cloud_config["SSL_ENABLED"] == "yes":
+                ssl_options = {
+                    "certfile" : cloud_config["SSL_CRT"],
+                    "keyfile" : cloud_config["SSL_KEY"],
+                }
+
+                log.info("Certs found - starting in SSL mode")
+        except KeyError:
+           log.info("Missing cloud.conf - disabling HTTP auth and SSL")
+
+
         router = self._create_zmq_router()
         # Add our JSON-RPC Websocket handler to Tornado
         self.handlers.extend([(r"/", JSONRPCWebSocket, dict(zmq_router=router))])
@@ -150,7 +185,7 @@ class Server(object):
             templates_dir = pkg_resources.resource_filename("gns3server", "templates")
         tornado_app = tornado.web.Application(self.handlers,
                                               template_path=templates_dir,
-                                              debug=True)  # FIXME: debug mode!
+                                              **settings)  # FIXME: debug mode!
 
         try:
             print("Starting server on {}:{} (Tornado v{}, PyZMQ v{}, ZMQ v{})".format(self._host,
@@ -159,6 +194,10 @@ class Server(object):
                                                                                       zmq.__version__,
                                                                                       zmq.zmq_version()))
             kwargs = {"address": self._host}
+
+            if ssl_options:
+                kwargs["ssl_options"] = ssl_options
+
             if parse_version(tornado.version) >= parse_version("3.1"):
                 kwargs["max_buffer_size"] = 524288000  # 500 MB file upload limit
             tornado_app.listen(self._port, **kwargs)
@@ -173,8 +212,12 @@ class Server(object):
         tornado.autoreload.add_reload_hook(self._reload_callback)
 
         def signal_handler(signum=None, frame=None):
-            log.warning("Server got signal {}, exiting...".format(signum))
-            self._cleanup(signum)
+            try:
+                log.warning("Server got signal {}, exiting...".format(signum))
+                self._cleanup(signum)
+            except RuntimeError:
+                # to ignore logging exception: RuntimeError: reentrant call inside <_io.BufferedWriter name='<stderr>'>
+                pass
 
         signals = [signal.SIGTERM, signal.SIGINT]
         if not sys.platform.startswith("win"):

gns3server/start_server.py

@@ -0,0 +1,242 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013 GNS3 Technologies Inc.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# __version__ is a human-readable version number.
+
+# __version_info__ is a four-tuple for programmatic comparison. The first
+# three numbers are the components of the version number. The fourth
+# is zero for an official release, positive for a development branch,
+# or negative for a release candidate or beta (after the base version
+# number has been incremented)
+
+"""
+Startup script for GNS3 Server Cloud Instance
+"""
+
+import os
+import sys
+import configparser
+import getopt
+import datetime
+import signal
+from logging.handlers import *
+from os.path import expanduser
+from gns3server.config import Config
+import ast
+import subprocess
+import uuid
+
+SCRIPT_NAME = os.path.basename(__file__)
+
+#Is the full path when used as an import
+SCRIPT_PATH = os.path.dirname(__file__)
+
+if not SCRIPT_PATH:
+    SCRIPT_PATH = os.path.join(os.path.dirname(os.path.abspath(
+        sys.argv[0])))
+
+
+LOG_NAME = "gns3-startup"
+log = None
+
+usage = """
+USAGE: %s
+
+Options:
+
+  -d, --debug         Enable debugging
+  -v, --verbose       Enable verbose logging
+  -h, --help          Display this menu :)
+
+  --data              Python dict of data to be written to the config file:
+                      " { 'gns3' : 'Is AWESOME' } "
+
+""" % (SCRIPT_NAME)
+
+# Parse cmd line options
+def parse_cmd_line(argv):
+    """
+    Parse command line arguments
+
+    argv: Pass in cmd line arguments
+    """
+
+    short_args = "dvh"
+    long_args = ("debug",
+                    "verbose",
+                    "help",
+                    "data=",
+                    )
+    try:
+        opts, extra_opts = getopt.getopt(argv[1:], short_args, long_args)
+    except getopt.GetoptError as e:
+        print("Unrecognized command line option or missing required argument: %s" %(e))
+        print(usage)
+        sys.exit(2)
+
+    cmd_line_option_list = {}
+    cmd_line_option_list["debug"] = False
+    cmd_line_option_list["verbose"] = True
+    cmd_line_option_list["data"] = None
+
+    if sys.platform == "linux":
+        cmd_line_option_list['syslog'] = "/dev/log"
+    elif sys.platform == "osx":
+        cmd_line_option_list['syslog'] = "/var/run/syslog"
+    else:
+        cmd_line_option_list['syslog'] = ('localhost',514)
+
+    for opt, val in opts:
+        if (opt in ("-h", "--help")):
+            print(usage)
+            sys.exit(0)
+        elif (opt in ("-d", "--debug")):
+            cmd_line_option_list["debug"] = True
+        elif (opt in ("-v", "--verbose")):
+            cmd_line_option_list["verbose"] = True
+        elif (opt in ("--data")):
+            cmd_line_option_list["data"] = ast.literal_eval(val)
+
+    return cmd_line_option_list
+
+
+def set_logging(cmd_options):
+    """
+    Setup logging and format output for console and syslog
+
+    Syslog is using the KERN facility
+    """
+    log = logging.getLogger("%s" % (LOG_NAME))
+    log_level = logging.INFO
+    log_level_console = logging.WARNING
+
+    if cmd_options['verbose'] == True:
+        log_level_console = logging.INFO
+
+    if cmd_options['debug'] == True:
+        log_level_console = logging.DEBUG
+        log_level = logging.DEBUG
+
+    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    sys_formatter = logging.Formatter('%(name)s - %(levelname)s - %(message)s')
+
+    console_log = logging.StreamHandler()
+    console_log.setLevel(log_level_console)
+    console_log.setFormatter(formatter)
+
+    syslog_hndlr = SysLogHandler(
+        address=cmd_options['syslog'],
+        facility=SysLogHandler.LOG_KERN
+    )
+
+    syslog_hndlr.setFormatter(sys_formatter)
+
+    log.setLevel(log_level)
+    log.addHandler(console_log)
+    log.addHandler(syslog_hndlr)
+
+    return log
+
+def _generate_certs():
+    cmd = []
+    cmd.append("%s/cert_utils/create_cert.sh" % (SCRIPT_PATH))
+
+    log.debug("Generating certs ...")
+    output_raw = subprocess.check_output(cmd, shell=False,
+        stderr=subprocess.STDOUT)
+
+    output_str = output_raw.decode("utf-8")
+    output = output_str.strip().split("\n")
+    log.debug(output)
+    return (output[-2], output[-1])
+
+def _start_gns3server():
+    cmd = []
+    cmd.append("gns3server")
+
+    log.info("Starting gns3server ...")
+    subprocess.Popen(cmd, shell=False)
+
+
+def main():
+
+    global log
+    options = parse_cmd_line(sys.argv)
+    log = set_logging(options)
+
+    def _shutdown(signalnum=None, frame=None):
+        """
+        Handles the SIGINT and SIGTERM event, inside of main so it has access to
+        the log vars.
+        """
+
+        log.info("Received shutdown signal")
+        sys.exit(0)
+
+
+    # Setup signal to catch Control-C / SIGINT and SIGTERM
+    signal.signal(signal.SIGINT, _shutdown)
+    signal.signal(signal.SIGTERM, _shutdown)
+
+    client_data = {}
+
+    config = Config.instance()
+    cfg = config.list_cloud_config_file()
+    cfg_path = os.path.dirname(cfg)
+
+    try:
+        os.makedirs(cfg_path)
+    except FileExistsError:
+        pass
+
+    (server_key, server_crt) = _generate_certs()
+
+    cloud_config = configparser.ConfigParser()
+    cloud_config['CLOUD_SERVER'] = {}
+
+    if options['data']:
+        cloud_config['CLOUD_SERVER'] = options['data']
+
+    cloud_config['CLOUD_SERVER']['SSL_KEY'] = server_key
+    cloud_config['CLOUD_SERVER']['SSL_CRT'] = server_crt
+    cloud_config['CLOUD_SERVER']['SSL_ENABLED'] = 'yes'
+    cloud_config['CLOUD_SERVER']['WEB_USERNAME'] = str(uuid.uuid4()).upper()[0:8]
+    cloud_config['CLOUD_SERVER']['WEB_PASSWORD'] = str(uuid.uuid4()).upper()[0:8]
+
+    with open(cfg, 'w') as cloud_config_file:
+        cloud_config.write(cloud_config_file)
+
+    cloud_config_file.close()
+
+    _start_gns3server()
+
+    with open(server_crt, 'r') as cert_file:
+        cert_data = cert_file.readlines()
+
+    cert_file.close()
+
+    client_data['SSL_CRT_FILE'] = server_crt
+    client_data['SSL_CRT'] = cert_data
+    client_data['WEB_USERNAME'] = cloud_config['CLOUD_SERVER']['WEB_USERNAME']
+    client_data['WEB_PASSWORD'] = cloud_config['CLOUD_SERVER']['WEB_PASSWORD']
+
+    print(client_data)
+
+
+if __name__ == "__main__":
+    result = main()
+    sys.exit(result)

gns3server/templates/upload.html

@@ -13,10 +13,8 @@ File: <input type="file" name="file" />
 </form>
 {%if items%}
 <h3>Files on {{host}}</h3>
-<ul>
 {%for item in items%}
-<li>{{path}}/{{item}}</a></li>
+<p>{{path}}/{{item}}</a></p>
 {%end%}
 {%end%}
-</ul>
 </body>

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.0a7"
-__version_info__ = (1, 0, 0, -99)
+__version__ = "1.0"
+__version_info__ = (1, 0, 0, 0)

requirements.txt

@@ -1,5 +1,9 @@
 netifaces
-tornado
+tornado==3.2.2
 pyzmq
-netifaces-py3
 jsonschema
+pycurl
+python-dateutil
+apache-libcloud
+requests
+

setup.py

@@ -20,7 +20,7 @@ from setuptools import setup, find_packages
 from setuptools.command.test import test as TestCommand
 
 
-class Tox(TestCommand):
+class PyTest(TestCommand):
 
     def finalize_options(self):
         TestCommand.finalize_options(self)
@@ -29,8 +29,8 @@ class Tox(TestCommand):
 
     def run_tests(self):
         #import here, cause outside the eggs aren't loaded
-        import tox
-        errcode = tox.cmdline(self.test_args)
+        import pytest
+        errcode = pytest.main(self.test_args)
         sys.exit(errcode)
 
 setup(
@@ -38,8 +38,8 @@ setup(
     version=__import__("gns3server").__version__,
     url="http://github.com/GNS3/gns3-server",
     license="GNU General Public License v3 (GPLv3)",
-    tests_require=["tox"],
-    cmdclass={"test": Tox},
+    tests_require=["pytest"],
+    cmdclass={"test": PyTest},
     author="Jeremy Grossmann",
     author_email="package-maintainer@gns3.net",
     description="GNS3 server to asynchronously manage emulators",
@@ -47,11 +47,12 @@ setup(
     install_requires=[
         "tornado>=3.1",
         "pyzmq>=14.0.0",
-        "jsonschema==2.3.0"
+        "jsonschema>=2.3.0"
     ],
     entry_points={
         "console_scripts": [
             "gns3server = gns3server.main:main",
+            "gns3dms = gns3dms.main:main",
         ]
     },
     packages=find_packages(),
@@ -59,7 +60,7 @@ setup(
     include_package_data=True,
     platforms="any",
     classifiers=[
-        "Development Status :: 3 - Alpha",
+        "Development Status :: 4 - Beta",
         "Environment :: Console",
         "Intended Audience :: Information Technology",
         "Topic :: System :: Networking",

tests/dynamips/conftest.py

@@ -6,10 +6,9 @@ import os
 @pytest.fixture(scope="module")
 def hypervisor(request):
 
-    cwd = os.path.dirname(os.path.abspath(__file__))
-    dynamips_path = os.path.join(cwd, "dynamips.stable")
+    dynamips_path = '/usr/bin/dynamips'
     print("\nStarting Dynamips Hypervisor: {}".format(dynamips_path))
-    manager = HypervisorManager(dynamips_path, "/tmp", "127.0.0.1", 9000)
+    manager = HypervisorManager(dynamips_path, "/tmp", "127.0.0.1")
     hypervisor = manager.start_new_hypervisor()
 
     def stop():

tests/dynamips/test_hypervisor.py

@@ -1,6 +1,5 @@
 from gns3server.modules.dynamips import Hypervisor
 import time
-import os
 
 
 def test_is_started(hypervisor):
@@ -10,7 +9,7 @@ def test_is_started(hypervisor):
 
 def test_port(hypervisor):
 
-    assert hypervisor.port == 9000
+    assert hypervisor.port == 7200
 
 
 def test_host(hypervisor):
@@ -25,8 +24,7 @@ def test_working_dir(hypervisor):
 
 def test_path(hypervisor):
 
-    cwd = os.path.dirname(os.path.abspath(__file__))
-    dynamips_path = os.path.join(cwd, "dynamips.stable")
+    dynamips_path = '/usr/bin/dynamips'
     assert hypervisor.path == dynamips_path
 
 
@@ -34,11 +32,10 @@ def test_stdout():
 
     # try to launch Dynamips on the same port
     # this will fail so that we can read its stdout/stderr
-    cwd = os.path.dirname(os.path.abspath(__file__))
-    dynamips_path = os.path.join(cwd, "dynamips.stable")
-    hypervisor = Hypervisor(dynamips_path, "/tmp", "172.0.0.1", 7200)
+    dynamips_path = '/usr/bin/dynamips'
+    hypervisor = Hypervisor(dynamips_path, "/tmp", "127.0.0.1", 7200)
     hypervisor.start()
     # give some time for Dynamips to start
-    time.sleep(0.01)
+    time.sleep(0.1)
     output = hypervisor.read_stdout()
     assert output

tests/dynamips/test_hypervisor_manager.py

@@ -7,10 +7,9 @@ import os
 @pytest.fixture(scope="module")
 def hypervisor_manager(request):
 
-    cwd = os.path.dirname(os.path.abspath(__file__))
-    dynamips_path = os.path.join(cwd, "dynamips.stable")
+    dynamips_path = '/usr/bin/dynamips'
     print("\nStarting Dynamips Hypervisor: {}".format(dynamips_path))
-    manager = HypervisorManager(dynamips_path, "/tmp", "127.0.0.1", 9000)
+    manager = HypervisorManager(dynamips_path, "/tmp", "127.0.0.1")
 
     #manager.start_new_hypervisor()
 

tests/dynamips/test_router.py

@@ -9,7 +9,7 @@ import base64
 @pytest.fixture
 def router(request, hypervisor):
 
-    router = Router(hypervisor, "router", "c3725")
+    router = Router(hypervisor, "router", platform="c3725")
     request.addfinalizer(router.delete)
     return router
 
@@ -127,9 +127,9 @@ def test_idlepc(router):
 
 def test_idlemax(router):
 
-    assert router.idlemax == 1500  # default value
-    router.idlemax = 500
-    assert router.idlemax == 500
+    assert router.idlemax == 500  # default value
+    router.idlemax = 1500
+    assert router.idlemax == 1500
 
 
 def test_idlesleep(router):
@@ -172,7 +172,7 @@ def test_confreg(router):
 
 def test_console(router):
 
-    assert router.console == router.hypervisor.baseconsole + router.id
+    assert router.console == 2001
     new_console_port = router.console + 100
     router.console = new_console_port
     assert router.console == new_console_port
@@ -180,7 +180,7 @@ def test_console(router):
 
 def test_aux(router):
 
-    assert router.aux == router.hypervisor.baseaux + router.id
+    assert router.aux == 2501
     new_aux_port = router.aux + 100
     router.aux = new_aux_port
     assert router.aux == new_aux_port

tests/iou/test_iou_device.py

@@ -3,17 +3,28 @@ import os
 import pytest
 
 
+def no_iou():
+    cwd = os.path.dirname(os.path.abspath(__file__))
+    iou_path = os.path.join(cwd, "i86bi_linux-ipbase-ms-12.4.bin")
+
+    if os.path.isfile(iou_path):
+        return False
+    else:
+        return True
+
+
 @pytest.fixture(scope="session")
 def iou(request):
 
     cwd = os.path.dirname(os.path.abspath(__file__))
     iou_path = os.path.join(cwd, "i86bi_linux-ipbase-ms-12.4.bin")
-    iou_device = IOUDevice(iou_path, "/tmp")
+    iou_device = IOUDevice("IOU1", iou_path, "/tmp")
     iou_device.start()
     request.addfinalizer(iou_device.delete)
     return iou_device
 
 
+@pytest.mark.skipif(no_iou(), reason="IOU Image not available")
 def test_iou_is_started(iou):
 
     print(iou.command())
@@ -21,6 +32,7 @@ def test_iou_is_started(iou):
     assert iou.is_running()
 
 
+@pytest.mark.skipif(no_iou(), reason="IOU Image not available")
 def test_iou_restart(iou):
 
     iou.stop()

tests/vpcs/test_vpcs_device.py

@@ -6,9 +6,13 @@ import pytest
 @pytest.fixture(scope="session")
 def vpcs(request):
 
-    cwd = os.path.dirname(os.path.abspath(__file__))
-    vpcs_path = os.path.join(cwd, "vpcs")
-    vpcs_device = VPCSDevice(vpcs_path, "/tmp")
+    if os.path.isfile("/usr/bin/vpcs"):
+        vpcs_path = "/usr/bin/vpcs"
+    else:
+        cwd = os.path.dirname(os.path.abspath(__file__))
+        vpcs_path = os.path.join(cwd, "vpcs")
+    vpcs_device = VPCSDevice("VPCS1", vpcs_path, "/tmp")
+    vpcs_device.port_add_nio_binding(0, 'nio_tap:tap0')
     vpcs_device.start()
     request.addfinalizer(vpcs_device.delete)
     return vpcs_device

tox.ini

@@ -2,6 +2,6 @@
 envlist = py33, py34
 
 [testenv]
-commands = py.test [] -s tests
+commands = python setup.py test
 deps = -rdev-requirements.txt