Bump version to 1.2.1

Update setup.py

.gitignore

@@ -35,5 +35,8 @@ nosetests.xml
 .pydevproject
 .settings
 
+# Pycharm
+.idea
+
 # Gedit Backup Files
 *~

README.rst

@@ -1,24 +1,37 @@
 GNS3-server
 ===========
 
-New GNS3 server repository (beta stage).
+This is the GNS3 server repository.
 
 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.
 
-You will need the new GNS3 GUI (gns3-gui repository) to control the server.
+You will need the GNS3 GUI (gns3-gui repository) to control the server.
 
-Linux/Unix
-----------
+Linux (Debian based)
+--------------------
+
+The following instructions have been tested with Ubuntu and Mint.
+You must be connected to the Internet in order to install the dependencies.
 
 Dependencies:
 
-- Python version 3.3 or above
-- pip & setuptools must be installed, please see http://pip.readthedocs.org/en/latest/installing.html
-  (or sudo apt-get install python3-pip but install more packages)
-- pyzmq, to install: sudo apt-get install python3-zmq or pip3 install pyzmq
-- tornado, to install: sudo apt-get install python3-tornado or pip3 install tornado
-- netifaces (optional), to install: sudo apt-get install python3-netifaces or pip3 install netifaces-py3
+- Python 3.3 or above
+- Setuptools
+- PyZMQ library
+- Netifaces library
+- Tornado
+- Jsonschema
+
+The following commands will install some of these dependencies:
+
+.. code:: bash
+
+   sudo apt-get install python3-setuptools
+   sudo apt-get install python3-zmq
+   sudo apt-get install python3-netifaces
+
+Finally these commands will install the server as well as the rest of the dependencies:
 
 .. code:: bash
 
@@ -36,7 +49,6 @@ Mac OS X
 
 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/

gns3dms/cloud/base_cloud_ctrl.py

@@ -22,13 +22,24 @@ Base class for interacting with Cloud APIs to create and manage cloud
 instances.
 
 """
+from collections import namedtuple
+import hashlib
+import os
+import logging
+from io import StringIO, BytesIO
 
 from libcloud.compute.base import NodeAuthSSHKey
+from libcloud.storage.types import ContainerAlreadyExistsError, ContainerDoesNotExistError
+
 from .exceptions import ItemNotFound, KeyPairExists, MethodNotAllowed
 from .exceptions import OverLimit, BadRequest, ServiceUnavailable
 from .exceptions import Unauthorized, ApiError
 
 
+KeyPair = namedtuple("KeyPair", ['name'], verbose=False)
+log = logging.getLogger(__name__)
+
+
 def parse_exception(exception):
     """
     Parse the exception to separate the HTTP status code from the text.
@@ -67,6 +78,8 @@ class BaseCloudCtrl(object):
         503: ServiceUnavailable
     }
 
+    GNS3_CONTAINER_NAME = 'GNS3'
+
     def __init__(self, username, api_key):
         self.username = username
         self.api_key = api_key
@@ -89,23 +102,37 @@ class BaseCloudCtrl(object):
 
         return self.driver.list_sizes()
 
-    def create_instance(self, name, size, image, keypair):
+    def list_flavors(self):
+        """ Return an iterable of flavors """
+
+        raise NotImplementedError
+
+    def create_instance(self, name, size_id, image_id, 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
-            )
+            image = self.get_image(image_id)
+            if image is None:
+                raise ItemNotFound("Image not found")
+
+            size = self.driver.ex_get_size(size_id)
+
+            args = {
+                "name": name,
+                "size": size,
+                "image": image,
+            }
+
+            if keypair is not None:
+                auth_key = NodeAuthSSHKey(keypair.public_key)
+                args["auth"] = auth_key
+                args["ex_keyname"] = name
+
+            return self.driver.create_node(**args)
 
         except Exception as e:
             status, error_text = parse_exception(e)
@@ -113,7 +140,8 @@ class BaseCloudCtrl(object):
             if status:
                 self._handle_exception(status, error_text)
             else:
-                raise e
+                log.error("create_instance method raised an exception: {}".format(e))
+                log.error('image id {}'.format(image))
 
     def delete_instance(self, instance):
         """ Delete the specified instance.  Returns True or False. """
@@ -142,7 +170,11 @@ class BaseCloudCtrl(object):
     def list_instances(self):
         """ Return a list of instances in the current region. """
 
-        return self.driver.list_nodes()
+        try:
+            return self.driver.list_nodes()
+        except Exception as e:
+            log.error("list_instances returned an error: {}".format(e))
+
 
     def create_key_pair(self, name):
         """ Create and return a new Key Pair. """
@@ -173,7 +205,85 @@ class BaseCloudCtrl(object):
             else:
                 raise e
 
+    def delete_key_pair_by_name(self, keypair_name):
+        """ Utility method to incapsulate boilerplate code """
+
+        kp = KeyPair(name=keypair_name)
+        return self.delete_key_pair(kp)
+
     def list_key_pairs(self):
         """ Return a list of Key Pairs. """
 
         return self.driver.list_key_pairs()
+
+    def upload_file(self, file_path, folder):
+        """
+        Uploads file to cloud storage (if it is not identical to a file already in cloud storage).
+        :param file_path: path to file to upload
+        :param folder: folder in cloud storage to save file in
+        :return: True if file was uploaded, False if it was skipped because it already existed and was identical
+        """
+        try:
+            gns3_container = self.storage_driver.create_container(self.GNS3_CONTAINER_NAME)
+        except ContainerAlreadyExistsError:
+            gns3_container = self.storage_driver.get_container(self.GNS3_CONTAINER_NAME)
+
+        with open(file_path, 'rb') as file:
+            local_file_hash = hashlib.md5(file.read()).hexdigest()
+
+            cloud_object_name = folder + '/' + os.path.basename(file_path)
+            cloud_hash_name = cloud_object_name + '.md5'
+            cloud_objects = [obj.name for obj in gns3_container.list_objects()]
+
+            # if the file and its hash are in object storage, and the local and storage file hashes match
+            # do not upload the file, otherwise upload it
+            if cloud_object_name in cloud_objects and cloud_hash_name in cloud_objects:
+                hash_object = gns3_container.get_object(cloud_hash_name)
+                cloud_object_hash = ''
+                for chunk in hash_object.as_stream():
+                    cloud_object_hash += chunk.decode('utf8')
+
+                if cloud_object_hash == local_file_hash:
+                    return False
+
+            file.seek(0)
+            self.storage_driver.upload_object_via_stream(file, gns3_container, cloud_object_name)
+            self.storage_driver.upload_object_via_stream(StringIO(local_file_hash), gns3_container, cloud_hash_name)
+            return True
+
+    def list_projects(self):
+        """
+        Lists projects in cloud storage
+        :return: List of (project name, object name in storage)
+        """
+
+        try:
+            gns3_container = self.storage_driver.get_container(self.GNS3_CONTAINER_NAME)
+            projects = [
+                (obj.name.replace('projects/', '').replace('.zip', ''), obj.name)
+                for obj in gns3_container.list_objects()
+                if obj.name.startswith('projects/') and obj.name[-4:] == '.zip'
+            ]
+            return projects
+        except ContainerDoesNotExistError:
+            return []
+
+    def download_file(self, file_name, destination=None):
+        """
+        Downloads file from cloud storage
+        :param file_name: name of file in cloud storage to download
+        :param destination: local path to save file to (if None, returns file contents as a file-like object)
+        :return: A file-like object if file contents are returned, or None if file is saved to filesystem
+        """
+
+        gns3_container = self.storage_driver.get_container(self.GNS3_CONTAINER_NAME)
+        storage_object = gns3_container.get_object(file_name)
+        if destination is not None:
+            storage_object.download(destination)
+        else:
+            contents = b''
+
+            for chunk in storage_object.as_stream():
+                contents += chunk
+
+            return BytesIO(contents)

gns3dms/cloud/rackspace_ctrl.py

@@ -23,31 +23,37 @@ 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 libcloud.storage.providers import get_driver as get_storage_driver
+from libcloud.storage.types import Provider as StorageProvider
 
 from .exceptions import ItemNotFound, ApiError
 from ..version import __version__
 
+from collections import OrderedDict
+
 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):
+    def __init__(self, username, api_key, gns3_ias_url):
         super(RackspaceCtrl, self).__init__(username, api_key)
 
+        self.gns3_ias_url = gns3_ias_url
+
         # 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.storage_driver_cls = get_storage_driver(StorageProvider.CLOUDFILES)
 
         self.driver = None
+        self.storage_driver = None
         self.region = None
         self.instances = {}
 
@@ -57,6 +63,26 @@ class RackspaceCtrl(BaseCloudCtrl):
 
         self.regions = []
         self.token = None
+        self.tenant_id = None
+        self.flavor_ep = "https://dfw.servers.api.rackspacecloud.com/v2/{username}/flavors"
+        self._flavors = OrderedDict([
+            ('2', '512MB, 1 VCPU'),
+            ('3', '1GB, 1 VCPU'),
+            ('4', '2GB, 2 VCPUs'),
+            ('5', '4GB, 2 VCPUs'),
+            ('6', '8GB, 4 VCPUs'),
+            ('7', '15GB, 6 VCPUs'),
+            ('8', '30GB, 8 VCPUs'),
+            ('performance1-1', '1GB Performance, 1 VCPU'),
+            ('performance1-2', '2GB Performance, 2 VCPUs'),
+            ('performance1-4', '4GB Performance, 4 VCPUs'),
+            ('performance1-8', '8GB Performance, 8 VCPUs'),
+            ('performance2-15', '15GB Performance, 4 VCPUs'),
+            ('performance2-30', '30GB Performance, 8 VCPUs'),
+            ('performance2-60', '60GB Performance, 16 VCPUs'),
+            ('performance2-90', '90GB Performance, 24 VCPUs'),
+            ('performance2-120', '120GB Performance, 32 VCPUs',)
+        ])
 
     def authenticate(self):
         """
@@ -100,6 +126,7 @@ class RackspaceCtrl(BaseCloudCtrl):
                 self.authenticated = True
                 user_regions = self._parse_endpoints(api_data)
                 self.regions = self._make_region_list(user_regions)
+                self.tenant_id = self._parse_tenant_id(api_data)
 
         else:
             self.regions = []
@@ -114,6 +141,11 @@ class RackspaceCtrl(BaseCloudCtrl):
 
         return self.regions
 
+    def list_flavors(self):
+        """ Return the dictionary containing flavors id and names """
+
+        return self._flavors
+
     def _parse_endpoints(self, api_data):
         """
         Parse the JSON-encoded data returned by the Identity Service API.
@@ -144,6 +176,17 @@ class RackspaceCtrl(BaseCloudCtrl):
 
         return token
 
+    def _parse_tenant_id(self, api_data):
+        """  """
+        try:
+            roles = api_data['access']['user']['roles']
+            for role in roles:
+                if 'tenantId' in role and role['name'] == 'compute:default':
+                    return role['tenantId']
+            return None
+        except KeyError:
+            return None
+
     def _make_region_list(self, region_codes):
         """
         Make a list of regions for use in the GUI.
@@ -173,6 +216,8 @@ class RackspaceCtrl(BaseCloudCtrl):
         try:
             self.driver = self.driver_cls(self.username, self.api_key,
                                           region=region)
+            self.storage_driver = self.storage_driver_cls(self.username, self.api_key,
+                                                          region=region)
 
         except ValueError:
             return False
@@ -189,14 +234,19 @@ class RackspaceCtrl(BaseCloudCtrl):
             or, if access was already asked
             [{"image_id": "", "member_id": "", "status": "ALREADYREQUESTED"},]
         """
-        endpoint = GNS3IAS_URL+"/images/grant_access"
+        endpoint = self.gns3_ias_url+"/images/grant_access"
         params = {
             "user_id": username,
-            "user_region": region,
+            "user_region": region.upper(),
             "gns3_version": gns3_version,
         }
-        response = requests.get(endpoint, params=params)
+        try:
+            response = requests.get(endpoint, params=params)
+        except requests.ConnectionError:
+            raise ApiError("Unable to connect to IAS")
+
         status = response.status_code
+
         if status == 200:
             return response.json()
         elif status == 404:
@@ -209,17 +259,53 @@ class RackspaceCtrl(BaseCloudCtrl):
         Return a dictionary containing RackSpace server images
         retrieved from gns3-ias server
         """
-        if not (self.username and self.region):
-            return []
+        if not (self.tenant_id and self.region):
+            return {}
 
         try:
-            response = self._get_shared_images(self.username, self.region, __version__)
-            shared_images = json.loads(response)
+            shared_images = self._get_shared_images(self.tenant_id, self.region, __version__)
             images = {}
             for i in shared_images:
                 images[i['image_id']] = i['image_name']
             return images
         except ItemNotFound:
-            return []
+            return {}
         except ApiError as e:
             log.error('Error while retrieving image list: %s' % e)
+            return {}
+
+    def get_image(self, image_id):
+        return self.driver.get_image(image_id)
+
+
+def get_provider(cloud_settings):
+    """
+    Utility function to retrieve a cloud provider instance already authenticated and with the
+    region set
+
+    :param cloud_settings: cloud settings dictionary
+    :return: a provider instance or None on errors
+    """
+    try:
+        username = cloud_settings['cloud_user_name']
+        apikey = cloud_settings['cloud_api_key']
+        region = cloud_settings['cloud_region']
+        ias_url = cloud_settings.get('gns3_ias_url', '')
+    except KeyError as e:
+        log.error("Unable to create cloud provider: {}".format(e))
+        return
+
+    provider = RackspaceCtrl(username, apikey, ias_url)
+
+    if not provider.authenticate():
+        log.error("Authentication failed for cloud provider")
+        return
+
+    if not region:
+        region = provider.list_regions().values()[0]
+
+    if not provider.set_region(region):
+        log.error("Unable to set cloud provider region")
+        return
+
+    return provider

gns3dms/main.py

@@ -77,7 +77,7 @@ Options:
   --cloud_user_name
 
   --instance_id       ID of the Rackspace instance to terminate
-  --region            Region of instance
+  --cloud_region      Region of instance
 
   --deadtime          How long in seconds can the communication lose exist before we
                       shutdown this instance.
@@ -205,8 +205,8 @@ def parse_cmd_line(argv):
             print(usage)
             sys.exit(2)
 
-        if cmd_line_option_list["region"] is None:
-            print("You need to specify a region")
+        if cmd_line_option_list["cloud_region"] is None:
+            print("You need to specify a cloud_region")
             print(usage)
             sys.exit(2)
 

gns3server/config.py

@@ -26,6 +26,8 @@ import configparser
 import logging
 log = logging.getLogger(__name__)
 
+CLOUD_SERVER = 'CLOUD_SERVER'
+
 
 class Config(object):
     """
@@ -46,12 +48,14 @@ class Config(object):
 
             appdata = os.path.expandvars("%APPDATA%")
             common_appdata = os.path.expandvars("%COMMON_APPDATA%")
+            self._cloud_file = os.path.join(appdata, appname, "cloud.ini")
             filename = "server.ini"
             self._files = [os.path.join(appdata, appname, filename),
                            os.path.join(appdata, appname + ".ini"),
                            os.path.join(common_appdata, appname, filename),
                            os.path.join(common_appdata, appname + ".ini"),
-                           filename]
+                           filename,
+                           self._cloud_file]
         else:
 
             # On UNIX-like platforms, the configuration file location can be one of the following:
@@ -62,20 +66,30 @@ 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")
+            self._cloud_file = 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,
-                           self._cloud_config]
+                           self._cloud_file]
 
         self._config = configparser.ConfigParser()
         self.read_config()
+        self._cloud_config = configparser.ConfigParser()
+        self.read_cloud_config()
 
     def list_cloud_config_file(self):
-        return self._cloud_config
+        return self._cloud_file
+
+    def read_cloud_config(self):
+        parsed_file = self._cloud_config.read(self._cloud_file)
+        if not self._cloud_config.has_section(CLOUD_SERVER):
+            self._cloud_config.add_section(CLOUD_SERVER)
+
+    def cloud_settings(self):
+        return self._cloud_config[CLOUD_SERVER]
 
     def read_config(self):
         """

gns3server/handlers/auth_handler.py

@@ -78,11 +78,15 @@ class LoginHandler(tornado.web.RequestHandler):
           self.set_secure_cookie("user", "None")
           auth_status = "failure"
 
-        log.info("Authentication attempt %s: %s" %(auth_status, user))
+        log.info("Authentication attempt {}: {}, {}".format(auth_status, user, password))
 
         try:
           redirect_to = self.get_secure_cookie("login_success_redirect_to")
         except tornado.web.MissingArgumentError:
           redirect_to = "/"
 
-        self.redirect(redirect_to)
+        if redirect_to is None:
+            self.write({'result': auth_status})
+        else:
+            log.info('Redirecting to {}'.format(redirect_to))
+            self.redirect(redirect_to)

gns3server/main.py

@@ -34,6 +34,8 @@ define("host", default="0.0.0.0", help="run on the given host/IP address", type=
 define("port", default=8000, help="run on the given port", type=int)
 define("ipc", default=False, help="use IPC for module communication", type=bool)
 define("version", default=False, help="show the version", type=bool)
+define("quiet", default=False, help="do not show output on stdout", type=bool)
+define("console_bind_to_any", default=True, help="bind console ports to any local IP address", type=bool)
 
 
 def locale_check():
@@ -96,17 +98,25 @@ def main():
         raise SystemExit
 
     current_year = datetime.date.today().year
-    print("GNS3 server version {}".format(__version__))
-    print("Copyright (c) 2007-{} GNS3 Technologies Inc.".format(current_year))
+
+    user_log = logging.getLogger('user_facing')
+    if not options.quiet:
+        # Send user facing messages to stdout.
+        stream_handler = logging.StreamHandler(sys.stdout)
+        stream_handler.addFilter(logging.Filter(name='user_facing'))
+        user_log.addHandler(stream_handler)
+        user_log.propagate = False
+
+    user_log.info("GNS3 server version {}".format(__version__))
+    user_log.info("Copyright (c) 2007-{} GNS3 Technologies Inc.".format(current_year))
 
     # we only support Python 3 version >= 3.3
     if sys.version_info < (3, 3):
         raise RuntimeError("Python 3.3 or higher is required")
 
-    print("Running with Python {major}.{minor}.{micro} and has PID {pid}".format(major=sys.version_info[0],
-                                                                                 minor=sys.version_info[1],
-                                                                                 micro=sys.version_info[2],
-                                                                                 pid=os.getpid()))
+    user_log.info("Running with Python {major}.{minor}.{micro} and has PID {pid}".format(
+                  major=sys.version_info[0], minor=sys.version_info[1],
+                  micro=sys.version_info[2], pid=os.getpid()))
 
     # check for the correct locale
     # (UNIX/Linux only)
@@ -118,9 +128,7 @@ def main():
         log.critical("the current working directory doesn't exist")
         return
 
-    server = Server(options.host,
-                    options.port,
-                    ipc=options.ipc)
+    server = Server(options.host, options.port, options.ipc, options.console_bind_to_any)
     server.load_modules()
     server.run()
 

gns3server/modules/attic.py

@@ -50,6 +50,7 @@ def find_unused_port(start_port, end_port, host='127.0.0.1', socket_type="TCP",
     else:
         socket_type = socket.SOCK_STREAM
 
+    last_exception = None
     for port in range(start_port, end_port + 1):
         if port in ignore_ports:
             continue
@@ -57,21 +58,21 @@ def find_unused_port(start_port, end_port, host='127.0.0.1', socket_type="TCP",
             if ":" in host:
                 # IPv6 address support
                 with socket.socket(socket.AF_INET6, socket_type) as s:
+                    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
                     s.bind((host, port))  # the port is available if bind is a success
             else:
                 with socket.socket(socket.AF_INET, socket_type) as s:
+                    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
                     s.bind((host, port))  # the port is available if bind is a success
             return port
         except OSError as e:
-            if e.errno == errno.EADDRINUSE:  # socket already in use
-                if port + 1 == end_port:
-                    break
-                else:
-                    continue
+            last_exception = e
+            if port + 1 == end_port:
+                break
             else:
-                raise Exception("Could not find an unused port: {}".format(e))
+                continue
 
-    raise Exception("Could not find a free port between {0} and {1}".format(start_port, end_port))
+    raise Exception("Could not find a free port between {} and {} on host {}, last exception: {}".format(start_port, end_port, host, last_exception))
 
 
 def wait_socket_is_ready(host, port, wait=2.0, socket_timeout=10):

gns3server/modules/base.py

@@ -61,6 +61,7 @@ class IModule(multiprocessing.Process):
         self._current_destination = None
         self._current_call_id = None
         self._stopping = False
+        self._cloud_settings = config.cloud_settings()
 
     def _setup(self):
         """

gns3server/modules/dynamips/__init__.py

@@ -33,7 +33,6 @@ from gns3server.builtins.interfaces import get_windows_interfaces
 from .hypervisor import Hypervisor
 from .hypervisor_manager import HypervisorManager
 from .dynamips_error import DynamipsError
-from ..attic import has_privileged_access
 
 # Nodes
 from .nodes.router import Router
@@ -138,6 +137,7 @@ class Dynamips(IModule):
         self._tempdir = kwargs["temp_dir"]
         self._working_dir = self._projects_dir
         self._host = dynamips_config.get("host", kwargs["host"])
+        self._console_host = dynamips_config.get("console_host", kwargs["console_host"])
 
         if not sys.platform.startswith("win32"):
             #FIXME: pickle issues Windows
@@ -154,12 +154,19 @@ class Dynamips(IModule):
         if not sys.platform.startswith("win32"):
             self._callback.stop()
 
+        # automatically save configs for all router instances
+        for router_id in self._routers:
+            router = self._routers[router_id]
+            try:
+                router.save_configs()
+            except DynamipsError:
+                continue
+
         # stop all Dynamips hypervisors
         if self._hypervisor_manager:
             self._hypervisor_manager.stop_all_hypervisors()
 
         self.delete_dynamips_files()
-
         IModule.stop(self, signum)  # this will stop the I/O loop
 
     def _check_hypervisors(self):
@@ -225,6 +232,14 @@ class Dynamips(IModule):
         :param request: JSON request (not used)
         """
 
+        # automatically save configs for all router instances
+        for router_id in self._routers:
+            router = self._routers[router_id]
+            try:
+                router.save_configs()
+            except DynamipsError:
+                continue
+
         # stop all Dynamips hypervisors
         if self._hypervisor_manager:
             self._hypervisor_manager.stop_all_hypervisors()
@@ -254,6 +269,7 @@ class Dynamips(IModule):
         self.delete_dynamips_files()
 
         self._hypervisor_manager = None
+        self._working_dir = self._projects_dir
         log.info("dynamips module has been reset")
 
     def start_hypervisor_manager(self):
@@ -282,7 +298,7 @@ class Dynamips(IModule):
             raise DynamipsError("Cannot write to working directory {}".format(workdir))
 
         log.info("starting the hypervisor manager with Dynamips working directory set to '{}'".format(workdir))
-        self._hypervisor_manager = HypervisorManager(self._dynamips, workdir, self._host)
+        self._hypervisor_manager = HypervisorManager(self._dynamips, workdir, self._host, self._console_host)
 
         for name, value in self._hypervisor_manager_settings.items():
             if hasattr(self._hypervisor_manager, name) and getattr(self._hypervisor_manager, name) != value:
@@ -293,10 +309,8 @@ class Dynamips(IModule):
         """
         Set or update settings.
 
-        Mandatory request parameters:
-        - path (path to the Dynamips executable)
-
         Optional request parameters:
+        - path (path to the Dynamips executable)
         - working_dir (path to a working directory)
         - project_name
 
@@ -311,7 +325,9 @@ class Dynamips(IModule):
 
         #TODO: JSON schema validation
         if not self._hypervisor_manager:
-            self._dynamips = request.pop("path")
+
+            if "path" in request:
+                self._dynamips = request.pop("path")
 
             if "working_dir" in request:
                 self._working_dir = request.pop("working_dir")
@@ -347,8 +363,13 @@ class Dynamips(IModule):
                 # for local server
                 new_working_dir = request.pop("working_dir")
 
+            try:
+                self._hypervisor_manager.working_dir = new_working_dir
+            except DynamipsError as e:
+                log.error("could not change working directory: {}".format(e))
+                return
+
             self._working_dir = new_working_dir
-            self._hypervisor_manager.working_dir = new_working_dir
 
             # apply settings to the hypervisor manager
             for name, value in request.items():

gns3server/modules/dynamips/backends/vm.py

@@ -17,8 +17,10 @@
 
 import os
 import base64
+import ntpath
 import time
 from gns3server.modules import IModule
+from gns3dms.cloud.rackspace_ctrl import get_provider
 from ..dynamips_error import DynamipsError
 
 from ..nodes.c1700 import C1700
@@ -71,8 +73,8 @@ import logging
 log = logging.getLogger(__name__)
 
 
-ADAPTER_MATRIX = {"C7200_IO_2FE": C7200_IO_2FE,
-                  "C7200_IO_FE": C7200_IO_FE,
+ADAPTER_MATRIX = {"C7200-IO-2FE": C7200_IO_2FE,
+                  "C7200-IO-FE": C7200_IO_FE,
                   "C7200-IO-GE-E": C7200_IO_GE_E,
                   "NM-16ESW": NM_16ESW,
                   "NM-1E": NM_1E,
@@ -140,12 +142,25 @@ class VM(object):
         chassis = request.get("chassis")
         router_id = request.get("router_id")
 
+        # Locate the image
         updated_image_path = os.path.join(self.images_directory, image)
         if os.path.isfile(updated_image_path):
             image = updated_image_path
+        else:
+            if not os.path.exists(self.images_directory):
+                os.mkdir(self.images_directory)
+            cloud_path = request.get("cloud_path", None)
+            if cloud_path is not None:
+                # Download the image from cloud files
+                _, filename = ntpath.split(image)
+                src = '{}/{}'.format(cloud_path, filename)
+                provider = get_provider(self._cloud_settings)
+                log.debug("Downloading file from {} to {}...".format(src, updated_image_path))
+                provider.download_file(src, updated_image_path)
+                log.debug("Download of {} complete.".format(src))
+                image = updated_image_path
 
         try:
-
             if platform not in PLATFORMS:
                 raise DynamipsError("Unknown router platform: {}".format(platform))
 
@@ -453,7 +468,7 @@ class VM(object):
                 except DynamipsError as e:
                     self.send_custom_error(str(e))
                     return
-            elif name.startswith("slot") and value == None:
+            elif name.startswith("slot") and value is None:
                 slot_id = int(name[-1])
                 if router.slots[slot_id]:
                     try:
@@ -597,31 +612,7 @@ class VM(object):
             return
 
         try:
-            if router.startup_config or router.private_config:
-
-                startup_config_base64, private_config_base64 = router.extract_config()
-                if startup_config_base64:
-                    try:
-                        config = base64.decodestring(startup_config_base64.encode("utf-8")).decode("utf-8")
-                        config = "!\n" + config.replace("\r", "")
-                        config_path = os.path.join(router.hypervisor.working_dir, router.startup_config)
-                        with open(config_path, "w") as f:
-                            log.info("saving startup-config to {}".format(router.startup_config))
-                            f.write(config)
-                    except OSError as e:
-                        raise DynamipsError("Could not save the startup configuration {}: {}".format(config_path, e))
-
-                if private_config_base64:
-                    try:
-                        config = base64.decodestring(private_config_base64.encode("utf-8")).decode("utf-8")
-                        config = "!\n" + config.replace("\r", "")
-                        config_path = os.path.join(router.hypervisor.working_dir, router.private_config)
-                        with open(config_path, "w") as f:
-                            log.info("saving private-config to {}".format(router.private_config))
-                            f.write(config)
-                    except OSError as e:
-                        raise DynamipsError("Could not save the private configuration {}: {}".format(config_path, e))
-
+            router.save_configs()
         except DynamipsError as e:
             log.warn("could not save config to {}: {}".format(router.startup_config, e))
 

gns3server/modules/dynamips/hypervisor.py

@@ -212,7 +212,7 @@ class Hypervisor(DynamipsHypervisor):
                                                  cwd=self._working_dir)
             log.info("Dynamips started PID={}".format(self._process.pid))
             self._started = True
-        except OSError as e:
+        except subprocess.SubprocessError as e:
             log.error("could not start Dynamips: {}".format(e))
             raise DynamipsError("could not start Dynamips: {}".format(e))
 

gns3server/modules/dynamips/hypervisor_manager.py

@@ -40,14 +40,16 @@ class HypervisorManager(object):
     :param path: path to the Dynamips executable
     :param working_dir: path to a working directory
     :param host: host/address for hypervisors to listen to
+    :param console_host: IP address to bind for console connections
     """
 
-    def __init__(self, path, working_dir, host='127.0.0.1'):
+    def __init__(self, path, working_dir, host='127.0.0.1', console_host='0.0.0.0'):
 
         self._hypervisors = []
         self._path = path
         self._working_dir = working_dir
-        self._host = host
+        self._console_host = console_host
+        self._host = console_host  # FIXME: Dynamips must be patched to bind on a different address than the one used by the hypervisor.
 
         config = Config.instance()
         dynamips_config = config.get_section_config("DYNAMIPS")

gns3server/modules/dynamips/nodes/c7200.py

@@ -22,7 +22,7 @@ http://github.com/GNS3/dynamips/blob/master/README.hypervisor#L294
 
 from ..dynamips_error import DynamipsError
 from .router import Router
-from ..adapters.c7200_io_2fe import C7200_IO_2FE
+from ..adapters.c7200_io_fe import C7200_IO_FE
 from ..adapters.c7200_io_ge_e import C7200_IO_GE_E
 
 import logging
@@ -70,7 +70,7 @@ class C7200(Router):
         if npe == "npe-g2":
             self.slot_add_binding(0, C7200_IO_GE_E())
         else:
-            self.slot_add_binding(0, C7200_IO_2FE())
+            self.slot_add_binding(0, C7200_IO_FE())
 
     def defaults(self):
         """

gns3server/modules/dynamips/nodes/router.py

@@ -26,6 +26,7 @@ from ...attic import find_unused_port
 import time
 import sys
 import os
+import base64
 
 import logging
 log = logging.getLogger(__name__)
@@ -598,6 +599,35 @@ class Router(object):
             log.info("router {name} [id={id}]: new private-config pushed".format(name=self._name,
                                                                                  id=self._id))
 
+    def save_configs(self):
+        """
+        Saves the startup-config and private-config to files.
+        """
+
+        if self.startup_config or self.private_config:
+            startup_config_base64, private_config_base64 = self.extract_config()
+            if startup_config_base64:
+                try:
+                    config = base64.decodebytes(startup_config_base64.encode("utf-8")).decode("utf-8")
+                    config = "!\n" + config.replace("\r", "")
+                    config_path = os.path.join(self.hypervisor.working_dir, self.startup_config)
+                    with open(config_path, "w") as f:
+                        log.info("saving startup-config to {}".format(self.startup_config))
+                        f.write(config)
+                except OSError as e:
+                    raise DynamipsError("Could not save the startup configuration {}: {}".format(config_path, e))
+
+            if private_config_base64:
+                try:
+                    config = base64.decodebytes(private_config_base64.encode("utf-8")).decode("utf-8")
+                    config = "!\n" + config.replace("\r", "")
+                    config_path = os.path.join(self.hypervisor.working_dir, self.private_config)
+                    with open(config_path, "w") as f:
+                        log.info("saving private-config to {}".format(self.private_config))
+                        f.write(config)
+                except OSError as e:
+                    raise DynamipsError("Could not save the private configuration {}: {}".format(config_path, e))
+
     @property
     def ram(self):
         """
@@ -1294,7 +1324,7 @@ class Router(object):
                                                                                                                   adapter=current_adapter))
 
         # Only c7200, c3600 and c3745 (NM-4T only) support new adapter while running
-        if self.is_running() and not (self._platform == 'c7200'
+        if self.is_running() and not ((self._platform == 'c7200' and not str(adapter).startswith('C7200'))
                                       and not (self._platform == 'c3600' and self.chassis == '3660')
                                       and not (self._platform == 'c3745' and adapter == 'NM-4T')):
             raise DynamipsError("Adapter {adapter} cannot be added while router {name} is running".format(adapter=adapter,
@@ -1339,7 +1369,7 @@ class Router(object):
                                                                                        slot_id=slot_id))
 
         # Only c7200, c3600 and c3745 (NM-4T only) support to remove adapter while running
-        if self.is_running() and not (self._platform == 'c7200'
+        if self.is_running() and not ((self._platform == 'c7200' and not str(adapter).startswith('C7200'))
                                       and not (self._platform == 'c3600' and self.chassis == '3660')
                                       and not (self._platform == 'c3745' and adapter == 'NM-4T')):
             raise DynamipsError("Adapter {adapter} cannot be removed while router {name} is running".format(adapter=adapter,

gns3server/modules/dynamips/schemas/vm.py

@@ -67,6 +67,10 @@ VM_CREATE_SCHEMA = {
             "type": "string",
             "minLength": 1,
             "pattern": "^([0-9a-fA-F]{4}\\.){2}[0-9a-fA-F]{4}$"
+        },
+        "cloud_path": {
+            "description": "Path to the image in the cloud object store",
+            "type": "string",
         }
     },
     "additionalProperties": False,

gns3server/modules/iou/__init__.py

@@ -21,12 +21,15 @@ IOU server module.
 
 import os
 import base64
+import ntpath
+import stat
 import tempfile
 import socket
 import shutil
 
 from gns3server.modules import IModule
 from gns3server.config import Config
+from gns3dms.cloud.rackspace_ctrl import get_provider
 from .iou_device import IOUDevice
 from .iou_error import IOUError
 from .nios.nio_udp import NIO_UDP
@@ -92,6 +95,7 @@ class IOU(IModule):
         self._udp_start_port_range = iou_config.get("udp_start_port_range", 30001)
         self._udp_end_port_range = iou_config.get("udp_end_port_range", 35000)
         self._host = iou_config.get("host", kwargs["host"])
+        self._console_host = iou_config.get("console_host", kwargs["console_host"])
         self._projects_dir = kwargs["projects_dir"]
         self._tempdir = kwargs["temp_dir"]
         self._working_dir = self._projects_dir
@@ -192,6 +196,7 @@ class IOU(IModule):
         self._allocated_udp_ports.clear()
         self.delete_iourc_file()
 
+        self._working_dir = self._projects_dir
         log.info("IOU module has been reset")
 
     @IModule.route("iou.settings")
@@ -298,14 +303,30 @@ class IOU(IModule):
         updated_iou_path = os.path.join(self.images_directory, iou_path)
         if os.path.isfile(updated_iou_path):
             iou_path = updated_iou_path
+        else:
+            if not os.path.exists(self.images_directory):
+                os.mkdir(self.images_directory)
+            cloud_path = request.get("cloud_path", None)
+            if cloud_path is not None:
+                # Download the image from cloud files
+                _, filename = ntpath.split(iou_path)
+                src = '{}/{}'.format(cloud_path, filename)
+                provider = get_provider(self._cloud_settings)
+                log.debug("Downloading file from {} to {}...".format(src, updated_iou_path))
+                provider.download_file(src, updated_iou_path)
+                log.debug("Download of {} complete.".format(src))
+                # Make file executable
+                st = os.stat(updated_iou_path)
+                os.chmod(updated_iou_path, st.st_mode | stat.S_IEXEC)
+                iou_path = updated_iou_path
 
         try:
             iou_instance = IOUDevice(name,
                                      iou_path,
                                      self._working_dir,
-                                     self._host,
                                      iou_id,
                                      console,
+                                     self._console_host,
                                      self._console_start_port_range,
                                      self._console_end_port_range)
 

gns3server/modules/iou/iou_device.py

@@ -49,9 +49,9 @@ class IOUDevice(object):
     :param name: name of this IOU device
     :param path: path to IOU executable
     :param working_dir: path to a working directory
-    :param host: host/address to bind for console and UDP connections
     :param iou_id: IOU instance ID
     :param console: TCP console port
+    :param console_host: IP address to bind for console connections
     :param console_start_port_range: TCP console port range start
     :param console_end_port_range: TCP console port range end
     """
@@ -63,9 +63,9 @@ class IOUDevice(object):
                  name,
                  path,
                  working_dir,
-                 host="127.0.0.1",
-                 iou_id = None,
+                 iou_id=None,
                  console=None,
+                 console_host="0.0.0.0",
                  console_start_port_range=4001,
                  console_end_port_range=4512):
 
@@ -99,8 +99,8 @@ class IOUDevice(object):
         self._iouyap_stdout_file = ""
         self._ioucon_thead = None
         self._ioucon_thread_stop_event = None
-        self._host = host
         self._started = False
+        self._console_host = console_host
         self._console_start_port_range = console_start_port_range
         self._console_end_port_range = console_end_port_range
 
@@ -127,7 +127,7 @@ class IOUDevice(object):
             try:
                 self._console = find_unused_port(self._console_start_port_range,
                                                  self._console_end_port_range,
-                                                 self._host,
+                                                 self._console_host,
                                                  ignore_ports=self._allocated_console_ports)
             except Exception as e:
                 raise IOUError(e)
@@ -484,7 +484,7 @@ class IOUDevice(object):
         """
 
         if not self._ioucon_thead:
-            telnet_server = "{}:{}".format(self._host, self.console)
+            telnet_server = "{}:{}".format(self._console_host, self.console)
             log.info("starting ioucon for IOU instance {} to accept Telnet connections on {}".format(self._name, telnet_server))
             args = argparse.Namespace(appl_id=str(self._id), debug=False, escape='^^', telnet_limit=0, telnet_server=telnet_server)
             self._ioucon_thread_stop_event = threading.Event()
@@ -509,7 +509,7 @@ class IOUDevice(object):
                                                         cwd=self._working_dir)
 
             log.info("iouyap started PID={}".format(self._iouyap_process.pid))
-        except OSError as e:
+        except subprocess.SubprocessError as e:
             iouyap_stdout = self.read_iouyap_stdout()
             log.error("could not start iouyap: {}\n{}".format(e, iouyap_stdout))
             raise IOUError("Could not start iouyap: {}\n{}".format(e, iouyap_stdout))
@@ -521,7 +521,7 @@ class IOUDevice(object):
 
         try:
             output = subprocess.check_output(["ldd", self._path])
-        except (FileNotFoundError, subprocess.CalledProcessError) as e:
+        except (FileNotFoundError, subprocess.SubprocessError) as e:
             log.warn("could not determine the shared library dependencies for {}: {}".format(self._path, e))
             return
 
@@ -583,7 +583,7 @@ class IOUDevice(object):
                 self._started = True
             except FileNotFoundError as e:
                 raise IOUError("could not start IOU: {}: 32-bit binary support is probably not installed".format(e))
-            except OSError as e:
+            except subprocess.SubprocessError as e:
                 iou_stdout = self.read_iou_stdout()
                 log.error("could not start IOU {}: {}\n{}".format(self._path, e, iou_stdout))
                 raise IOUError("could not start IOU {}: {}\n{}".format(self._path, e, iou_stdout))
@@ -761,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, subprocess.CalledProcessError) as e:
+        except subprocess.SubprocessError 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):

gns3server/modules/iou/ioucon.py

@@ -224,6 +224,8 @@ class TelnetServer(Console):
             buf = self._read_cur(bufsize, socket.MSG_DONTWAIT)
         except BlockingIOError:
             return None
+        except ConnectionResetError:
+            buf = b''
         if not buf:
             self._disconnect(fileno)
 

gns3server/modules/iou/schemas.py

@@ -40,6 +40,10 @@ IOU_CREATE_SCHEMA = {
             "description": "path to the IOU executable",
             "type": "string",
             "minLength": 1,
+        },
+        "cloud_path": {
+            "description": "Path to the image in the cloud object store",
+            "type": "string",
         }
     },
     "additionalProperties": False,

gns3server/modules/qemu/__init__.py

@@ -71,6 +71,7 @@ class Qemu(IModule):
         self._udp_start_port_range = qemu_config.get("udp_start_port_range", 40001)
         self._udp_end_port_range = qemu_config.get("udp_end_port_range", 45500)
         self._host = qemu_config.get("host", kwargs["host"])
+        self._console_host = qemu_config.get("console_host", kwargs["console_host"])
         self._projects_dir = kwargs["projects_dir"]
         self._tempdir = kwargs["temp_dir"]
         self._working_dir = self._projects_dir
@@ -123,6 +124,7 @@ class Qemu(IModule):
         self._qemu_instances.clear()
         self._allocated_udp_ports.clear()
 
+        self._working_dir = self._projects_dir
         log.info("QEMU module has been reset")
 
     @IModule.route("qemu.settings")
@@ -214,6 +216,7 @@ class Qemu(IModule):
                                    self._host,
                                    qemu_id,
                                    console,
+                                   self._console_host,
                                    self._console_start_port_range,
                                    self._console_end_port_range)
 
@@ -598,14 +601,14 @@ class Qemu(IModule):
         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"))
+            output = subprocess.check_output([qemu_path, "-version"])
+            match = re.search("version\s+([0-9a-z\-\.]+)", output.decode("utf-8"))
             if match:
                 version = match.group(1)
                 return version
             else:
                 raise QemuError("Could not determine the Qemu version for {}".format(qemu_path))
-        except (OSError, subprocess.CalledProcessError) as e:
+        except subprocess.SubprocessError as e:
             raise QemuError("Error while looking for the Qemu version: {}".format(e))
 
     @IModule.route("qemu.qemu_list")
@@ -614,7 +617,6 @@ class Qemu(IModule):
         Gets QEMU binaries list.
 
         Response parameters:
-        - Server address/host
         - List of Qemu binaries
         """
 
@@ -623,26 +625,35 @@ class Qemu(IModule):
         # 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 hasattr(sys, "frozen"):
+                # add any qemu dir in the same location as gns3server.exe to the list of paths
+                exec_dir = os.path.dirname(os.path.abspath(sys.executable))
+                for f in os.listdir(exec_dir):
+                    if f.lower().startswith("qemu"):
+                        paths.append(os.path.join(exec_dir, f))
+
             if "PROGRAMFILES(X86)" in os.environ and os.path.exists(os.environ["PROGRAMFILES(X86)"]):
                 paths.append(os.path.join(os.environ["PROGRAMFILES(X86)"], "qemu"))
             if "PROGRAMFILES" in os.environ and os.path.exists(os.environ["PROGRAMFILES"]):
                 paths.append(os.path.join(os.environ["PROGRAMFILES"], "qemu"))
         elif sys.platform.startswith("darwin"):
-            # add a specific location on Mac OS X regardless of what's in $PATH
-            paths.append("/usr/local/bin")
+            # add specific locations on Mac OS X regardless of what's in $PATH
+            paths.extend(["/usr/local/bin", "/opt/local/bin"])
+            if hasattr(sys, "frozen"):
+                paths.append(os.path.abspath(os.path.join(os.getcwd(), "../../../qemu/bin/")))
         for path in paths:
             try:
                 for f in os.listdir(path):
-                    if f.startswith("qemu-system") and os.access(os.path.join(path, f), os.X_OK):
+                    if (f.startswith("qemu-system") or f == "qemu" or f == "qemu.exe") and \
+                            os.access(os.path.join(path, f), os.X_OK) and \
+                            os.path.isfile(os.path.join(path, f)):
                         qemu_path = os.path.join(path, f)
                         version = self._get_qemu_version(qemu_path)
                         qemus.append({"path": qemu_path, "version": version})
             except OSError:
                 continue
 
-        response = {"server": self._host,
-                    "qemus": qemus}
+        response = {"qemus": qemus}
         self.send_response(response)
 
     @IModule.route("qemu.echo")

gns3server/modules/qemu/qemu_vm.py

@@ -19,11 +19,16 @@
 QEMU VM instance.
 """
 
+import sys
 import os
 import shutil
 import random
 import subprocess
 import shlex
+import ntpath
+
+from gns3server.config import Config
+from gns3dms.cloud.rackspace_ctrl import get_provider
 
 from .qemu_error import QemuError
 from .adapters.ethernet_adapter import EthernetAdapter
@@ -44,6 +49,7 @@ class QemuVM(object):
     :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_host: IP address to bind for console connections
     :param console_start_port_range: TCP console port range start
     :param console_end_port_range: TCP console port range end
     """
@@ -58,6 +64,7 @@ class QemuVM(object):
                  host="127.0.0.1",
                  qemu_id=None,
                  console=None,
+                 console_host="0.0.0.0",
                  console_start_port_range=5001,
                  console_end_port_range=5500):
 
@@ -83,9 +90,12 @@ class QemuVM(object):
         self._command = []
         self._started = False
         self._process = None
+        self._cpulimit_process = None
         self._stdout_file = ""
+        self._console_host = console_host
         self._console_start_port_range = console_start_port_range
         self._console_end_port_range = console_end_port_range
+        self._cloud_path = None
 
         # QEMU settings
         self._qemu_path = qemu_path
@@ -99,6 +109,9 @@ class QemuVM(object):
         self._initrd = ""
         self._kernel_image = ""
         self._kernel_command_line = ""
+        self._legacy_networking = False
+        self._cpu_throttling = 0  # means no CPU throttling
+        self._process_priority = "low"
 
         working_dir_path = os.path.join(working_dir, "qemu", "vm-{}".format(self._id))
 
@@ -113,7 +126,7 @@ class QemuVM(object):
             try:
                 self._console = find_unused_port(self._console_start_port_range,
                                                  self._console_end_port_range,
-                                                 self._host,
+                                                 self._console_host,
                                                  ignore_ports=self._allocated_console_ports)
             except Exception as e:
                 raise QemuError(e)
@@ -144,7 +157,11 @@ class QemuVM(object):
                          "console": self._console,
                          "initrd": self._initrd,
                          "kernel_image": self._kernel_image,
-                         "kernel_command_line": self._kernel_command_line}
+                         "kernel_command_line": self._kernel_command_line,
+                         "legacy_networking": self._legacy_networking,
+                         "cpu_throttling": self._cpu_throttling,
+                         "process_priority": self._process_priority
+                         }
 
         return qemu_defaults
 
@@ -288,6 +305,27 @@ class QemuVM(object):
         log.info("QEMU VM {name} [id={id}] has been deleted (including associated files)".format(name=self._name,
                                                                                                  id=self._id))
 
+    @property
+    def cloud_path(self):
+        """
+        Returns the cloud path where images can be downloaded from.
+
+        :returns: cloud path
+        """
+
+        return self._cloud_path
+
+    @cloud_path.setter
+    def cloud_path(self, cloud_path):
+        """
+        Sets the cloud path where images can be downloaded from.
+
+        :param cloud_path:
+        :return:
+        """
+
+        self._cloud_path = cloud_path
+
     @property
     def qemu_path(self):
         """
@@ -408,6 +446,80 @@ class QemuVM(object):
                                                                                            id=self._id,
                                                                                            adapter_type=adapter_type))
 
+    @property
+    def legacy_networking(self):
+        """
+        Returns either QEMU legacy networking commands are used.
+
+        :returns: boolean
+        """
+
+        return self._legacy_networking
+
+    @legacy_networking.setter
+    def legacy_networking(self, legacy_networking):
+        """
+        Sets either QEMU legacy networking commands are used.
+
+        :param legacy_networking: boolean
+        """
+
+        if legacy_networking:
+            log.info("QEMU VM {name} [id={id}] has enabled legacy networking".format(name=self._name, id=self._id))
+        else:
+            log.info("QEMU VM {name} [id={id}] has disabled legacy networking".format(name=self._name, id=self._id))
+        self._legacy_networking = legacy_networking
+
+    @property
+    def cpu_throttling(self):
+        """
+        Returns the percentage of CPU allowed.
+
+        :returns: integer
+        """
+
+        return self._cpu_throttling
+
+    @cpu_throttling.setter
+    def cpu_throttling(self, cpu_throttling):
+        """
+        Sets the percentage of CPU allowed.
+
+        :param cpu_throttling: integer
+        """
+
+        log.info("QEMU VM {name} [id={id}] has set the percentage of CPU allowed to {cpu}".format(name=self._name,
+                                                                                                  id=self._id,
+                                                                                                  cpu=cpu_throttling))
+        self._cpu_throttling = cpu_throttling
+        self._stop_cpulimit()
+        if cpu_throttling:
+            self._set_cpu_throttling()
+
+    @property
+    def process_priority(self):
+        """
+        Returns the process priority.
+
+        :returns: string
+        """
+
+        return self._process_priority
+
+    @process_priority.setter
+    def process_priority(self, process_priority):
+        """
+        Sets the process priority.
+
+        :param process_priority: string
+        """
+
+        log.info("QEMU VM {name} [id={id}] has set the process priority to {priority}".format(name=self._name,
+                                                                                              id=self._id,
+                                                                                              priority=process_priority))
+        self._process_priority = process_priority
+
+
     @property
     def ram(self):
         """
@@ -523,6 +635,84 @@ class QemuVM(object):
                                                                                                                  kernel_command_line=kernel_command_line))
         self._kernel_command_line = kernel_command_line
 
+    def _set_process_priority(self):
+        """
+        Changes the process priority
+        """
+
+        if sys.platform.startswith("win"):
+            try:
+                import win32api
+                import win32con
+                import win32process
+            except ImportError:
+                log.error("pywin32 must be installed to change the priority class for QEMU VM {}".format(self._name))
+            else:
+                log.info("setting QEMU VM {} priority class to BELOW_NORMAL".format(self._name))
+                handle = win32api.OpenProcess(win32con.PROCESS_ALL_ACCESS, 0, self._process.pid)
+                if self._process_priority == "realtime":
+                    priority = win32process.REALTIME_PRIORITY_CLASS
+                elif self._process_priority == "very high":
+                    priority = win32process.HIGH_PRIORITY_CLASS
+                elif self._process_priority == "high":
+                    priority = win32process.ABOVE_NORMAL_PRIORITY_CLASS
+                elif self._process_priority == "low":
+                    priority = win32process.BELOW_NORMAL_PRIORITY_CLASS
+                elif self._process_priority == "very low":
+                    priority = win32process.IDLE_PRIORITY_CLASS
+                else:
+                    priority = win32process.NORMAL_PRIORITY_CLASS
+                win32process.SetPriorityClass(handle, priority)
+        else:
+            if self._process_priority == "realtime":
+                priority = -20
+            elif self._process_priority == "very high":
+                priority = -15
+            elif self._process_priority == "high":
+                priority = -5
+            elif self._process_priority == "low":
+                priority = 5
+            elif self._process_priority == "very low":
+                priority = 19
+            else:
+                priority = 0
+            try:
+                subprocess.call(['renice', '-n', str(priority), '-p', str(self._process.pid)])
+            except subprocess.SubprocessError as e:
+                log.error("could not change process priority for QEMU VM {}: {}".format(self._name, e))
+
+    def _stop_cpulimit(self):
+        """
+        Stops the cpulimit process.
+        """
+
+        if self._cpulimit_process and self._cpulimit_process.poll() is None:
+            self._cpulimit_process.kill()
+            try:
+                self._process.wait(3)
+            except subprocess.TimeoutExpired:
+                log.error("could not kill cpulimit process {}".format(self._cpulimit_process.pid))
+
+    def _set_cpu_throttling(self):
+        """
+        Limits the CPU usage for current QEMU process.
+        """
+
+        if not self.is_running():
+            return
+
+        try:
+            if sys.platform.startswith("win") and hasattr(sys, "frozen"):
+                cpulimit_exec = os.path.join(os.path.dirname(os.path.abspath(sys.executable)), "cpulimit", "cpulimit.exe")
+            else:
+                cpulimit_exec = "cpulimit"
+            subprocess.Popen([cpulimit_exec, "--lazy", "--pid={}".format(self._process.pid), "--limit={}".format(self._cpu_throttling)], cwd=self._working_dir)
+            log.info("CPU throttled to {}%".format(self._cpu_throttling))
+        except FileNotFoundError:
+            raise QemuError("cpulimit could not be found, please install it or deactivate CPU throttling")
+        except subprocess.SubprocessError as e:
+            raise QemuError("Could not throttle CPU: {}".format(e))
+
     def start(self):
         """
         Starts this QEMU VM.
@@ -531,7 +721,45 @@ class QemuVM(object):
         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))
+                found = False
+                paths = [os.getcwd()] + os.environ["PATH"].split(os.pathsep)
+                # look for the qemu binary in the current working directory and $PATH
+                for path in paths:
+                    try:
+                        if self._qemu_path in os.listdir(path) and os.access(os.path.join(path, self._qemu_path), os.X_OK):
+                            self._qemu_path = os.path.join(path, self._qemu_path)
+                            found = True
+                            break
+                    except OSError:
+                        continue
+
+                if not found:
+                    raise QemuError("QEMU binary '{}' is not accessible".format(self._qemu_path))
+
+            if self.cloud_path is not None:
+                # Download from Cloud Files
+                if self.hda_disk_image != "":
+                    _, filename = ntpath.split(self.hda_disk_image)
+                    src = '{}/{}'.format(self.cloud_path, filename)
+                    dst = os.path.join(self.working_dir, filename)
+                    if not os.path.isfile(dst):
+                        cloud_settings = Config.instance().cloud_settings()
+                        provider = get_provider(cloud_settings)
+                        log.debug("Downloading file from {} to {}...".format(src, dst))
+                        provider.download_file(src, dst)
+                        log.debug("Download of {} complete.".format(src))
+                    self.hda_disk_image = dst
+                if self.hdb_disk_image != "":
+                    _, filename = ntpath.split(self.hdb_disk_image)
+                    src = '{}/{}'.format(self.cloud_path, filename)
+                    dst = os.path.join(self.working_dir, filename)
+                    if not os.path.isfile(dst):
+                        cloud_settings = Config.instance().cloud_settings()
+                        provider = get_provider(cloud_settings)
+                        log.debug("Downloading file from {} to {}...".format(src, dst))
+                        provider.download_file(src, dst)
+                        log.debug("Download of {} complete.".format(src))
+                    self.hdb_disk_image = dst
 
             self._command = self._build_command()
             try:
@@ -545,11 +773,15 @@ class QemuVM(object):
                                                      cwd=self._working_dir)
                 log.info("QEMU VM instance {} started PID={}".format(self._id, self._process.pid))
                 self._started = True
-            except OSError as e:
+            except subprocess.SubprocessError 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))
 
+            self._set_process_priority()
+            if self._cpu_throttling:
+                self._set_cpu_throttling()
+
     def stop(self):
         """
         Stops this QEMU VM.
@@ -568,6 +800,7 @@ class QemuVM(object):
                                                                                   self._process.pid))
         self._process = None
         self._started = False
+        self._stop_cpulimit()
 
     def suspend(self):
         """
@@ -681,7 +914,7 @@ class QemuVM(object):
     def _serial_options(self):
 
         if self._console:
-            return ["-serial", "telnet:{}:{},server,nowait".format(self._host, self._console)]
+            return ["-serial", "telnet:{}:{},server,nowait".format(self._console_host, self._console)]
         else:
             return []
 
@@ -712,10 +945,10 @@ class QemuVM(object):
                 # 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"])
+                    retcode = subprocess.call([qemu_img_path, "create", "-f", "qcow2", hda_disk, "128M"])
                     log.info("{} returned with {}".format(qemu_img_path, retcode))
 
-        except OSError as e:
+        except subprocess.SubprocessError as e:
             raise QemuError("Could not create disk image {}".format(e))
 
         options.extend(["-hda", hda_disk])
@@ -727,7 +960,7 @@ class QemuVM(object):
                                               "backing_file={}".format(self._hdb_disk_image),
                                               "-f", "qcow2", hdb_disk])
                     log.info("{} returned with {}".format(qemu_img_path, retcode))
-                except OSError as e:
+                except subprocess.SubprocessError as e:
                     raise QemuError("Could not create disk image {}".format(e))
             options.extend(["-hdb", hdb_disk])
 
@@ -752,16 +985,29 @@ class QemuVM(object):
         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)])
+            if self._legacy_networking:
+                network_options.extend(["-net", "nic,vlan={},macaddr={},model={}".format(adapter_id, mac, self._adapter_type)])
+            else:
+                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)])
+                if self._legacy_networking:
+                    network_options.extend(["-net", "udp,vlan={},sport={},dport={},daddr={}".format(adapter_id,
+                                                                                                    nio.lport,
+                                                                                                    nio.rport,
+                                                                                                    nio.rhost)])
+
+                else:
+                    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)])
+                if self._legacy_networking:
+                    network_options.extend(["-net", "user,vlan={}".format(adapter_id)])
+                else:
+                    network_options.extend(["-netdev", "user,id=gns3-{}".format(adapter_id)])
             adapter_id += 1
 
         return network_options

gns3server/modules/qemu/schemas.py

@@ -94,7 +94,7 @@ QEMU_UPDATE_SCHEMA = {
         "adapters": {
             "description": "number of adapters",
             "type": "integer",
-            "minimum": 1,
+            "minimum": 0,
             "maximum": 8,
         },
         "adapter_type": {
@@ -120,8 +120,31 @@ QEMU_UPDATE_SCHEMA = {
             "description": "QEMU kernel command line",
             "type": "string",
         },
+        "cloud_path": {
+            "description": "Path to the image in the cloud object store",
+            "type": "string",
+        },
+        "legacy_networking": {
+            "description": "Use QEMU legagy networking commands (-net syntax)",
+            "type": "boolean",
+        },
+        "cpu_throttling": {
+            "description": "Percentage of CPU allowed for QEMU",
+            "minimum": 0,
+            "maximum": 800,
+            "type": "integer",
+        },
+        "process_priority": {
+            "description": "Process priority for QEMU",
+            "enum": ["realtime",
+                     "very high",
+                     "high",
+                     "normal",
+                     "low",
+                     "very low"]
+        },
         "options": {
-            "description": "additional QEMU options",
+            "description": "Additional QEMU options",
             "type": "string",
         },
     },

gns3server/modules/virtualbox/__init__.py

@@ -23,13 +23,12 @@ import sys
 import os
 import socket
 import shutil
+import subprocess
 
-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
 
@@ -61,26 +60,34 @@ class VirtualBox(IModule):
 
     def __init__(self, name, *args, **kwargs):
 
-        # get the vboxwrapper location (only non-Windows platforms)
-        if not sys.platform.startswith("win"):
+        # get the vboxmanage location
+        self._vboxmanage_path = None
+        if sys.platform.startswith("win"):
+            if "VBOX_INSTALL_PATH" in os.environ:
+                self._vboxmanage_path = os.path.join(os.environ["VBOX_INSTALL_PATH"], "VBoxManage.exe")
+            elif "VBOX_MSI_INSTALL_PATH" in os.environ:
+                self._vboxmanage_path = os.path.join(os.environ["VBOX_MSI_INSTALL_PATH"], "VBoxManage.exe")
+        elif sys.platform.startswith("darwin"):
+            self._vboxmanage_path = "/Applications/VirtualBox.app/Contents/MacOS/VBoxManage"
+        else:
             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):
+            self._vboxmanage_path = vbox_config.get("vboxmanage_path")
+            if not self._vboxmanage_path or not os.path.isfile(self._vboxmanage_path):
                 paths = [os.getcwd()] + os.environ["PATH"].split(os.pathsep)
-                # look for vboxwrapper in the current working directory and $PATH
+                # look for vboxmanage 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")
+                        if "vboxmanage" in [s.lower() for s in os.listdir(path)] and os.access(os.path.join(path, "vboxmanage"), os.X_OK):
+                            self._vboxmanage_path = os.path.join(path, "vboxmanage")
                             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")
+        if not self._vboxmanage_path:
+            log.warning("vboxmanage couldn't be found!")
+        elif not os.access(self._vboxmanage_path, os.X_OK):
+            log.warning("vboxmanage is not executable")
 
         # a new process start when calling IModule
         IModule.__init__(self, name, *args, **kwargs)
@@ -94,62 +101,10 @@ class VirtualBox(IModule):
         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._console_host = vbox_config.get("console_host", kwargs["console_host"])
         self._projects_dir = kwargs["projects_dir"]
         self._tempdir = kwargs["temp_dir"]
         self._working_dir = self._projects_dir
-        self._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):
         """
@@ -161,10 +116,10 @@ class VirtualBox(IModule):
         # 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()
+            try:
+                vbox_instance.delete()
+            except VirtualBoxError:
+                continue
 
         IModule.stop(self, signum)  # this will stop the I/O loop
 
@@ -202,9 +157,7 @@ class VirtualBox(IModule):
         self._vbox_instances.clear()
         self._allocated_udp_ports.clear()
 
-        if self._vboxwrapper and self._vboxwrapper.connected():
-            self._vboxwrapper.send("vboxwrapper reset")
-
+        self._working_dir = self._projects_dir
         log.info("VirtualBox module has been reset")
 
     @IModule.route("virtualbox.settings")
@@ -214,7 +167,7 @@ class VirtualBox(IModule):
 
         Optional request parameters:
         - working_dir (path to a working directory)
-        - vboxwrapper_path (path to vboxwrapper)
+        - vboxmanage_path (path to vboxmanage)
         - project_name
         - console_start_port_range
         - console_end_port_range
@@ -249,10 +202,10 @@ class VirtualBox(IModule):
             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))
+                vbox_instance.working_dir = os.path.join(self._working_dir, "vbox", "{}".format(vbox_instance.name))
 
-        if "vboxwrapper_path" in request:
-            self._vboxwrapper_path = request["vboxwrapper_path"]
+        if "vboxmanage_path" in request:
+            self._vboxmanage_path = request["vboxmanage_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"]
@@ -272,6 +225,7 @@ class VirtualBox(IModule):
         Mandatory request parameters:
         - name (VirtualBox VM name)
         - vmname (VirtualBox VM name in VirtualBox)
+        - linked_clone (Flag to create a linked clone)
 
         Optional request parameters:
         - console (VirtualBox VM console port)
@@ -290,22 +244,23 @@ class VirtualBox(IModule):
 
         name = request["name"]
         vmname = request["vmname"]
+        linked_clone = request["linked_clone"]
         console = request.get("console")
         vbox_id = request.get("vbox_id")
 
         try:
 
-            if not self._vboxwrapper and not self._vboxmanager:
-                self._start_vbox_service()
+            if not self._vboxmanage_path or not os.path.exists(self._vboxmanage_path):
+                raise VirtualBoxError("Could not find VBoxManage, is VirtualBox correctly installed?")
 
-            vbox_instance = VirtualBoxVM(self._vboxwrapper,
-                                         self._vboxmanager,
+            vbox_instance = VirtualBoxVM(self._vboxmanage_path,
                                          name,
                                          vmname,
+                                         linked_clone,
                                          self._working_dir,
-                                         self._host,
                                          vbox_id,
                                          console,
+                                         self._console_host,
                                          self._console_start_port_range,
                                          self._console_end_port_range)
 
@@ -418,10 +373,7 @@ class VirtualBox(IModule):
         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))
+            self.send_custom_error(str(e))
             return
         self.send_response(True)
 
@@ -759,6 +711,21 @@ class VirtualBox(IModule):
         response = {"port_id": request["port_id"]}
         self.send_response(response)
 
+    def _execute_vboxmanage(self, command):
+        """
+        Executes VBoxManage and return its result.
+
+        :param command: command to execute (list)
+
+        :returns: VBoxManage output
+        """
+
+        try:
+            result = subprocess.check_output(command, stderr=subprocess.STDOUT, timeout=30)
+        except subprocess.SubprocessError as e:
+            raise VirtualBoxError("Could not execute VBoxManage {}".format(e))
+        return result.decode("utf-8")
+
     @IModule.route("virtualbox.vm_list")
     def vm_list(self, request):
         """
@@ -769,26 +736,37 @@ class VirtualBox(IModule):
         - List of VM names
         """
 
-        if not self._vboxwrapper and not self._vboxmanager:
+        try:
+
+            if request and "vboxmanage_path" in request:
+                vboxmanage_path = request["vboxmanage_path"]
+            else:
+                vboxmanage_path = self._vboxmanage_path
+
+            if not vboxmanage_path or not os.path.exists(vboxmanage_path):
+                raise VirtualBoxError("Could not find VBoxManage, is VirtualBox correctly installed?")
+
+            command = [vboxmanage_path, "--nologo", "list", "vms"]
+            result = self._execute_vboxmanage(command)
+        except VirtualBoxError as e:
+            self.send_custom_error(str(e))
+            return
+
+        vms = []
+        for line in result.splitlines():
+            vmname, uuid = line.rsplit(' ', 1)
+            vmname = vmname.strip('"')
+            if vmname == "<inaccessible>":
+                continue  # ignore inaccessible VMs
             try:
-                self._start_vbox_service()
+                extra_data = self._execute_vboxmanage([vboxmanage_path, "getextradata", vmname, "GNS3/Clone"]).strip()
             except VirtualBoxError as e:
                 self.send_custom_error(str(e))
                 return
+            if not extra_data == "Value: yes":
+                vms.append(vmname)
 
-        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}
+        response = {"vms": vms}
         self.send_response(response)
 
     @IModule.route("virtualbox.echo")

gns3server/modules/virtualbox/pipe_proxy.py

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

@@ -31,6 +31,10 @@ VBOX_CREATE_SCHEMA = {
             "type": "string",
             "minLength": 1,
         },
+        "linked_clone": {
+            "description": "either the VM is a linked clone or not",
+            "type": "boolean"
+        },
         "vbox_id": {
             "description": "VirtualBox VM instance ID",
             "type": "integer"
@@ -102,8 +106,8 @@ VBOX_UPDATE_SCHEMA = {
             "maximum": 65535,
             "type": "integer"
         },
-        "enable_console": {
-            "description": "enable the console",
+        "enable_remote_console": {
+            "description": "enable the remote console",
             "type": "boolean"
         },
         "headless": {

gns3server/modules/virtualbox/telnet_server.py

@@ -0,0 +1,444 @@
+# -*- 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/>.
+
+
+import sys
+import time
+import threading
+import socket
+import select
+
+import logging
+log = logging.getLogger(__name__)
+
+if sys.platform.startswith("win"):
+    import win32pipe
+    import win32file
+
+
+class TelnetServer(threading.Thread):
+    """
+    Mini Telnet Server.
+
+    :param vm_name: Virtual machine name
+    :param pipe_path: path to VM pipe (UNIX socket on Linux/UNIX, Named Pipe on Windows)
+    :param host: server host
+    :param port: server port
+    """
+
+    def __init__(self, vm_name, pipe_path, host, port):
+
+        self._vm_name = vm_name
+        self._pipe = pipe_path
+        self._host = host
+        self._port = port
+        self._reader_thread = None
+        self._use_thread = False
+        self._write_lock = threading.Lock()
+        self._clients = {}
+        self._timeout = 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 ":" in self._host:
+                # IPv6 address support
+                self._server_socket = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
+            else:
+                self._server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                self._server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+                self._server_socket.bind((self._host, self._port))
+                self._server_socket.listen(socket.SOMAXCONN)
+        except OSError as e:
+            log.critical("unable to create a server socket: {}".format(e))
+            return
+
+        threading.Thread.__init__(self)
+        log.info("Telnet server initialized, waiting for clients on {}:{}".format(self._host, self._port))
+
+    def run(self):
+        """
+        Thread loop.
+        """
+
+        while True:
+
+            recv_list = [self._server_socket.fileno()]
+
+            if not self._use_thread:
+                recv_list.append(self._pipe.fileno())
+
+            for client in self._clients.values():
+                if client.is_active():
+                    recv_list.append(client.socket().fileno())
+                else:
+                    del self._clients[client.socket().fileno()]
+                    try:
+                        client.socket().shutdown(socket.SHUT_RDWR)
+                    except OSError as e:
+                        log.warn("shutdown: {}".format(e))
+                    client.socket().close()
+                    break
+
+            try:
+                rlist, slist, elist = select.select(recv_list, [], [], self._timeout)
+            except OSError as e:
+                log.critical("fatal select error: {}".format(e))
+                return False
+
+            if not self._alive:
+                log.info("Telnet server for {} is exiting".format(self._vm_name))
+                return True
+
+            for sock_fileno in rlist:
+                if sock_fileno == self._server_socket.fileno():
+
+                    try:
+                        sock, addr = self._server_socket.accept()
+                        host, port = addr
+                        sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
+                        sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+                        log.info("new client {}:{} has connected".format(host, port))
+                    except OSError as e:
+                        log.error("could not accept new client: {}".format(e))
+                        continue
+
+                    new_client = TelnetClient(self._vm_name, sock, host, port)
+                    self._clients[sock.fileno()] = new_client
+
+                    if self._use_thread and not self._reader_thread:
+                        self._reader_thread = threading.Thread(target=self._reader, daemon=True)
+                        self._reader_thread.start()
+
+                elif not self._use_thread and sock_fileno == self._pipe.fileno():
+
+                    data = self._read_from_pipe()
+                    if not data:
+                        log.warning("pipe has been closed!")
+                        return False
+                    for client in self._clients.values():
+                        try:
+                            client.send(data)
+                        except OSError as e:
+                            log.debug(e)
+                            client.deactivate()
+
+                elif sock_fileno in self._clients:
+                    try:
+                        data = self._clients[sock_fileno].socket_recv()
+
+                        if not data:
+                            continue
+
+                        # 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:
+                        log.info(msg)
+                        self._clients[sock_fileno].deactivate()
+
+    def _write_to_pipe(self, data):
+        """
+        Writes data to the pipe.
+
+        :param data: data to write
+        """
+
+        if sys.platform.startswith('win'):
+            win32file.WriteFile(self._pipe, data)
+        else:
+            self._pipe.sendall(data)
+
+    def _read_from_pipe(self):
+        """
+        Reads data from the pipe.
+
+        :returns: data
+        """
+
+        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 b""
+        else:
+            return self._pipe.recv(1024)
+
+    def _reader(self):
+        """
+        Loops forever and copy everything from the pipe to the socket.
+        """
+
+        log.debug("reader thread has started")
+        while self._alive:
+            try:
+                data = self._read_from_pipe()
+                if not data and not sys.platform.startswith('win'):
+                    log.debug("pipe has been closed! (no data)")
+                    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 Exception as e:
+                log.debug("pipe has been closed! {}".format(e))
+                break
+        log.debug("reader thread exited")
+        self.stop()
+
+    def stop(self):
+        """
+        Stops the server.
+        """
+
+        if self._alive:
+            self._alive = False
+
+        for client in self._clients.values():
+            client.socket().close()
+            client.deactivate()
+
+# Mostly from https://code.google.com/p/miniboa/source/browse/trunk/miniboa/telnet.py
+
+# Telnet Commands
+SE      = 240    # End of sub-negotiation parameters
+NOP     = 241    # No operation
+DATMK   = 242    # Data stream portion of a sync.
+BREAK   = 243    # NVT Character BRK
+IP      = 244    # Interrupt Process
+AO      = 245    # Abort Output
+AYT     = 246    # Are you there
+EC      = 247    # Erase Character
+EL      = 248    # Erase Line
+GA      = 249    # The Go Ahead Signal
+SB      = 250    # Sub-option to follow
+WILL    = 251    # Will; request or confirm option begin
+WONT    = 252    # Wont; deny option request
+DO      = 253    # Do = Request or confirm remote option
+DONT    = 254    # Don't = Demand or confirm option halt
+IAC     = 255    # Interpret as Command
+SEND    = 1      # Sub-process negotiation SEND command
+IS      = 0      # Sub-process negotiation IS command
+
+# Telnet Options
+BINARY  = 0      # Transmit Binary
+ECHO    = 1      # Echo characters back to sender
+RECON   = 2      # Reconnection
+SGA     = 3      # Suppress Go-Ahead
+TMARK   = 6      # Timing Mark
+TTYPE   = 24     # Terminal Type
+NAWS    = 31     # Negotiate About Window Size
+LINEMO  = 34     # Line Mode
+
+
+class TelnetClient(object):
+    """
+    Represents a Telnet client connection.
+
+    :param vm_name: VM name
+    :param sock: socket connection
+    :param host: IP of the Telnet client
+    :param port: port of the Telnet client
+    """
+
+    def __init__(self, vm_name, sock, host, port):
+
+        self._active = True
+        self._sock = sock
+        self._host = host
+        self._port = port
+
+        sock.send(bytes([IAC, WILL, ECHO,
+                         IAC, WILL, SGA,
+                         IAC, WILL, BINARY,
+                         IAC, DO, BINARY]))
+
+        welcome_msg = "{} console is now available... Press RETURN to get started.\r\n".format(vm_name)
+        sock.send(welcome_msg.encode('utf-8'))
+
+    def is_active(self):
+        """
+        Returns either the client is active or not.
+
+        :return: boolean
+        """
+
+        return self._active
+
+    def socket(self):
+        """
+        Returns the socket for this Telnet client.
+
+        :returns: socket instance.
+        """
+
+        return self._sock
+
+    def send(self, data):
+        """
+        Sends data to the remote end.
+
+        :param data: data to send
+        """
+
+        try:
+            self._sock.send(data)
+        except OSError as e:
+            self._active = False
+            raise Exception("Socket send: {}".format(e))
+
+    def deactivate(self):
+        """
+        Sets the client to disconnect on the next server poll.
+        """
+
+        self._active = False
+
+    def socket_recv(self):
+        """
+        Called by Telnet Server when data is ready.
+        """
+
+        try:
+            buf = self._sock.recv(1024)
+        except BlockingIOError:
+            return None
+        except ConnectionResetError:
+            buf = b''
+
+        # is the connection closed?
+        if not buf:
+            raise Exception("connection closed by {}:{}".format(self._host, self._port))
+
+        # Process and remove any telnet commands from the buffer
+        if IAC in buf:
+            buf = self._IAC_parser(buf)
+
+        return buf
+
+    def _read_block(self, bufsize):
+        """
+        Reads a block for data from the socket.
+
+        :param bufsize: size of the buffer
+        :returns: data read
+        """
+        buf = self._sock.recv(1024, socket.MSG_WAITALL)
+        # If we don't get everything we were looking for then the
+        # client probably disconnected.
+        if len(buf) < bufsize:
+            raise Exception("connection closed by {}:{}".format(self._host, self._port))
+        return buf
+
+    def _IAC_parser(self, buf):
+        """
+        Processes and removes any Telnet commands from the buffer.
+
+        :param buf: buffer
+        :returns: buffer minus Telnet commands
+        """
+
+        skip_to = 0
+        while self._active:
+            # Locate an IAC to process
+            iac_loc = buf.find(IAC, skip_to)
+            if iac_loc < 0:
+                break
+
+            # Get the TELNET command
+            iac_cmd = bytearray([IAC])
+            try:
+                iac_cmd.append(buf[iac_loc + 1])
+            except IndexError:
+                buf.extend(self._read_block(1))
+                iac_cmd.append(buf[iac_loc + 1])
+
+            # Is this just a 2-byte TELNET command?
+            if iac_cmd[1] not in [WILL, WONT, DO, DONT]:
+                if iac_cmd[1] == AYT:
+                    log.debug("Telnet server received Are-You-There (AYT)")
+                    self._sock.send(b'\r\nYour Are-You-There received. I am here.\r\n')
+                elif iac_cmd[1] == IAC:
+                    # It's data, not an IAC
+                    iac_cmd.pop()
+                    # This prevents the 0xff from being
+                    # interrupted as yet another IAC
+                    skip_to = iac_loc + 1
+                    log.debug("Received IAC IAC")
+                elif iac_cmd[1] == NOP:
+                    pass
+                else:
+                    log.debug("Unhandled telnet command: "
+                              "{0:#x} {1:#x}".format(*iac_cmd))
+
+            # This must be a 3-byte TELNET command
+            else:
+                try:
+                    iac_cmd.append(buf[iac_loc + 2])
+                except IndexError:
+                    buf.extend(self._read_block(1))
+                    iac_cmd.append(buf[iac_loc + 2])
+                # We do ECHO, SGA, and BINARY. Period.
+                if iac_cmd[1] == DO and iac_cmd[2] not in [ECHO, SGA, BINARY]:
+                    self._sock.send(bytes([IAC, WONT, iac_cmd[2]]))
+                    log.debug("Telnet WON'T {:#x}".format(iac_cmd[2]))
+                else:
+                    log.debug("Unhandled telnet command: "
+                              "{0:#x} {1:#x} {2:#x}".format(*iac_cmd))
+
+            # Remove the entire TELNET command from the buffer
+            buf = buf.replace(iac_cmd, b'', 1)
+
+        # Return the new copy of the buffer, minus telnet commands
+        return buf
+
+if __name__ == '__main__':
+
+    logging.basicConfig(level=logging.INFO)
+    if sys.platform.startswith('win'):
+        import msvcrt
+        pipe_name = r'\\.\pipe\VBOX\Linux_Microcore_4.7.1'
+        pipe = open(pipe_name, 'a+b')
+        telnet_server = TelnetServer("VBOX", msvcrt.get_osfhandle(pipe.fileno()), "127.0.0.1", 3900)
+    else:
+        pipe_name = "/tmp/pipe_test"
+        try:
+            unix_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+            unix_socket.connect(pipe_name)
+        except OSError as e:
+            print("Could not connect to UNIX socket {}: {}".format(pipe_name, e))
+            sys.exit(False)
+        telnet_server = TelnetServer("VBOX", unix_socket, "127.0.0.1", 3900)
+
+    telnet_server.setDaemon(True)
+    telnet_server.start()
+    try:
+        telnet_server.join()
+    except KeyboardInterrupt:
+        telnet_server.stop()
+        telnet_server.join(timeout=3)

gns3server/modules/virtualbox/vboxapi_py3/__init__.py

@@ -1,612 +0,0 @@
-"""
-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

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

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

@@ -19,13 +19,25 @@
 VirtualBox VM instance.
 """
 
+import sys
+import shlex
+import re
 import os
+import subprocess
+import tempfile
 import shutil
+import json
+import socket
+import time
 
 from .virtualbox_error import VirtualBoxError
-from .virtualbox_controller import VirtualBoxController
 from .adapters.ethernet_adapter import EthernetAdapter
 from ..attic import find_unused_port
+from .telnet_server import TelnetServer
+
+if sys.platform.startswith('win'):
+    import msvcrt
+    import win32file
 
 import logging
 log = logging.getLogger(__name__)
@@ -35,14 +47,14 @@ class VirtualBoxVM(object):
     """
     VirtualBox VM implementation.
 
-    :param vboxwrapper client: VboxWrapperClient instance
-    :param vboxmanager: VirtualBox manager from the VirtualBox API
+    :param vboxmanage_path: path to the VBoxManage tool
     :param name: name of this VirtualBox VM
     :param vmname: name of this VirtualBox VM in VirtualBox itself
+    :param linked_clone: flag if a linked clone must be created
     :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_host: IP address to bind for console connections
     :param console_start_port_range: TCP console port range start
     :param console_end_port_range: TCP console port range end
     """
@@ -51,14 +63,14 @@ class VirtualBoxVM(object):
     _allocated_console_ports = []
 
     def __init__(self,
-                 vboxwrapper,
-                 vboxmanager,
+                 vboxmanage_path,
                  name,
                  vmname,
+                 linked_clone,
                  working_dir,
-                 host="127.0.0.1",
                  vbox_id=None,
                  console=None,
+                 console_host="0.0.0.0",
                  console_start_port_range=4512,
                  console_end_port_range=5000):
 
@@ -79,24 +91,28 @@ class VirtualBoxVM(object):
             self._instances.append(self._id)
 
         self._name = name
+        self._linked_clone = linked_clone
         self._working_dir = None
-        self._host = host
         self._command = []
-        self._vboxwrapper = vboxwrapper
+        self._vboxmanage_path = vboxmanage_path
         self._started = False
+        self._console_host = console_host
         self._console_start_port_range = console_start_port_range
         self._console_end_port_range = console_end_port_range
 
+        self._telnet_server_thread = None
+        self._serial_pipe = None
+
         # VirtualBox settings
         self._console = console
         self._ethernet_adapters = []
         self._headless = False
-        self._enable_console = True
+        self._enable_remote_console = True
         self._vmname = vmname
         self._adapter_start_index = 0
-        self._adapter_type = "Automatic"
+        self._adapter_type = "Intel PRO/1000 MT Desktop (82540EM)"
 
-        working_dir_path = os.path.join(working_dir, "vbox", "vm-{}".format(self._id))
+        working_dir_path = os.path.join(working_dir, "vbox")
 
         if vbox_id and not os.path.isdir(working_dir_path):
             raise VirtualBoxError("Working directory {} doesn't exist".format(working_dir_path))
@@ -109,7 +125,7 @@ class VirtualBoxVM(object):
             try:
                 self._console = find_unused_port(self._console_start_port_range,
                                                  self._console_end_port_range,
-                                                 self._host,
+                                                 self._console_host,
                                                  ignore_ports=self._allocated_console_ports)
             except Exception as e:
                 raise VirtualBoxError(e)
@@ -118,15 +134,26 @@ class VirtualBoxVM(object):
             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._system_properties = {}
+        properties = self._execute("list", ["systemproperties"])
+        for prop in properties:
+            try:
+                name, value = prop.split(':', 1)
+            except ValueError:
+                continue
+            self._system_properties[name.strip()] = value.strip()
 
+        if linked_clone:
+            if vbox_id and os.path.isdir(os.path.join(self.working_dir, self._vmname)):
+                vbox_file = os.path.join(self.working_dir, self._vmname, self._vmname + ".vbox")
+                self._execute("registervm", [vbox_file])
+                self._reattach_hdds()
+            else:
+                self._create_linked_clone()
+
+        self._maximum_adapters = 8
         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))
 
@@ -141,9 +168,9 @@ class VirtualBoxVM(object):
                          "vmname": self._vmname,
                          "adapters": self.adapters,
                          "adapter_start_index": self._adapter_start_index,
-                         "adapter_type": "Automatic",
+                         "adapter_type": "Intel PRO/1000 MT Desktop (82540EM)",
                          "console": self._console,
-                         "enable_console": self._enable_console,
+                         "enable_remote_console": self._enable_remote_console,
                          "headless": self._headless}
 
         return vbox_defaults
@@ -189,8 +216,6 @@ class VirtualBoxVM(object):
                                                                                 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
@@ -248,15 +273,42 @@ class VirtualBoxVM(object):
         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 _get_all_hdd_files(self):
+
+        hdds = []
+        properties = self._execute("list", ["hdds"])
+        for prop in properties:
+            try:
+                name, value = prop.split(':', 1)
+            except ValueError:
+                continue
+            if name.strip() == "Location":
+                hdds.append(value.strip())
+        return hdds
+
+    def _reattach_hdds(self):
+
+        hdd_info_file = os.path.join(self._working_dir, self._vmname, "hdd_info.json")
+        try:
+            with open(hdd_info_file, "r") as f:
+                #log.info("loading project: {}".format(path))
+                hdd_table = json.load(f)
+        except OSError as e:
+            raise VirtualBoxError("Could not read HDD info file: {}".format(e))
+
+        for hdd_info in hdd_table:
+            hdd_file = os.path.join(self._working_dir, self._vmname, "Snapshots", hdd_info["hdd"])
+            if os.path.exists(hdd_file):
+                log.debug("reattaching hdd {}".format(hdd_file))
+                self._storage_attach('--storagectl {} --port {} --device {} --type hdd --medium "{}"'.format(hdd_info["controller"],
+                                                                                                             hdd_info["port"],
+                                                                                                             hdd_info["device"],
+                                                                                                             hdd_file))
+
     def delete(self):
         """
         Deletes this VirtualBox VM.
@@ -269,8 +321,39 @@ class VirtualBoxVM(object):
         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))
+        if self._linked_clone:
+            hdd_table = []
+            if os.path.exists(self._working_dir):
+                hdd_files = self._get_all_hdd_files()
+                vm_info = self._get_vm_info()
+                for entry, value in vm_info.items():
+                    match = re.search("^(\w+)\-(\d)\-(\d)$", entry)
+                    if match:
+                        controller = match.group(1)
+                        port = match.group(2)
+                        device = match.group(3)
+                        if value in hdd_files:
+                            self._storage_attach("--storagectl {} --port {} --device {} --type hdd --medium none".format(controller, port, device))
+                            hdd_table.append(
+                                {
+                                    "hdd": os.path.basename(value),
+                                    "controller": controller,
+                                    "port": port,
+                                    "device": device,
+                                }
+                            )
+
+            self._execute("unregistervm", [self._vmname])
+
+            if hdd_table:
+                try:
+                    hdd_info_file = os.path.join(self._working_dir, self._vmname, "hdd_info.json")
+                    with open(hdd_info_file, "w") as f:
+                        #log.info("saving project: {}".format(path))
+                        json.dump(hdd_table, f, indent=4)
+                except OSError as e:
+                    raise VirtualBoxError("Could not write HDD info file: {}".format(e))
+
 
         log.info("VirtualBox VM {name} [id={id}] has been deleted".format(name=self._name,
                                                                           id=self._id))
@@ -287,16 +370,16 @@ class VirtualBoxVM(object):
         if self.console:
             self._allocated_console_ports.remove(self.console)
 
-        if self._vboxwrapper:
-            self._vboxwrapper.send('vbox delete "{}"'.format(self._name))
+        if self._linked_clone:
+            self._execute("unregistervm", [self._vmname, "--delete"])
 
-        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
+        #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))
@@ -320,50 +403,34 @@ class VirtualBoxVM(object):
         """
 
         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):
+    def enable_remote_console(self):
         """
-        Returns either the console is enabled or not
+        Returns either the remote console is enabled or not
 
         :returns: boolean
         """
 
-        return self._enable_console
+        return self._enable_remote_console
 
-    @enable_console.setter
-    def enable_console(self, enable_console):
+    @enable_remote_console.setter
+    def enable_remote_console(self, enable_remote_console):
         """
         Sets either the console is enabled or not
 
-        :param enable_console: boolean
+        :param enable_remote_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
+        if enable_remote_console:
             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
+        self._enable_remote_console = enable_remote_console
 
     @property
     def vmname(self):
@@ -383,11 +450,6 @@ class VirtualBoxVM(object):
         :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
 
@@ -409,6 +471,11 @@ class VirtualBoxVM(object):
         :param adapters: number of adapters
         """
 
+        # check for the maximum adapters supported by the VM
+        self._maximum_adapters = self._get_maximum_supported_adapters()
+        if len(self._ethernet_adapters) > self._maximum_adapters:
+            raise VirtualBoxError("Number of adapters above the maximum supported of {}".format(self._maximum_adapters))
+
         self._ethernet_adapters.clear()
         for adapter_id in range(0, self._adapter_start_index + adapters):
             if adapter_id < self._adapter_start_index:
@@ -416,11 +483,6 @@ class VirtualBoxVM(object):
                 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))
@@ -443,9 +505,6 @@ class VirtualBoxVM(object):
         :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,
@@ -472,68 +531,364 @@ class VirtualBoxVM(object):
 
         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 _execute(self, subcommand, args, timeout=30):
+        """
+        Executes a command with VBoxManage.
+
+        :param subcommand: vboxmanage subcommand (e.g. modifyvm, controlvm etc.)
+        :param args: arguments for the subcommand.
+        :param timeout: how long to wait for vboxmanage
+
+        :returns: result (list)
+        """
+
+        command = [self._vboxmanage_path, "--nologo", subcommand]
+        command.extend(args)
+        log.debug("Execute vboxmanage command: {}".format(command))
+        try:
+            result = subprocess.check_output(command, stderr=subprocess.STDOUT, timeout=timeout)
+        except subprocess.CalledProcessError as e:
+            if e.output:
+                # only the first line of the output is useful
+                virtualbox_error = e.output.decode("utf-8").splitlines()[0]
+                raise VirtualBoxError("{}".format(virtualbox_error))
+            else:
+                raise VirtualBoxError("{}".format(e))
+        except subprocess.SubprocessError as e:
+            raise VirtualBoxError("Could not execute VBoxManage: {}".format(e))
+        return result.decode("utf-8").splitlines()
+
+    def _get_vm_info(self):
+        """
+        Returns this VM info.
+
+        :returns: dict of info
+        """
+
+        vm_info = {}
+        results = self._execute("showvminfo", [self._vmname, "--machinereadable"])
+        for info in results:
+            try:
+                name, value = info.split('=', 1)
+            except ValueError:
+                continue
+            vm_info[name.strip('"')] = value.strip('"')
+        return vm_info
+
+    def _get_vm_state(self):
+        """
+        Returns this VM state (e.g. running, paused etc.)
+
+        :returns: state (string)
+        """
+
+        results = self._execute("showvminfo", [self._vmname, "--machinereadable"])
+        for info in results:
+            name, value = info.split('=', 1)
+            if name == "VMState":
+                return value.strip('"')
+        raise VirtualBoxError("Could not get VM state for {}".format(self._vmname))
+
+    def _get_maximum_supported_adapters(self):
+        """
+        Returns the maximum adapters supported by this VM.
+
+        :returns: maximum number of supported adapters (int)
+        """
+
+        # check the maximum number of adapters supported by the VM
+        vm_info = self._get_vm_info()
+        chipset = vm_info["chipset"]
+        maximum_adapters = 8
+        if chipset == "ich9":
+            maximum_adapters = int(self._system_properties["Maximum ICH9 Network Adapter count"])
+        return maximum_adapters
+
+    def _get_pipe_name(self):
+        """
+        Returns the pipe name to create a serial connection.
+
+        :returns: pipe path (string)
+        """
+
+        p = re.compile('\s+', re.UNICODE)
+        pipe_name = p.sub("_", self._vmname)
+        if sys.platform.startswith('win'):
+            pipe_name = r"\\.\pipe\VBOX\{}".format(pipe_name)
+        else:
+            pipe_name = os.path.join(tempfile.gettempdir(), "pipe_{}".format(pipe_name))
+        return pipe_name
+
+    def _set_serial_console(self):
+        """
+        Configures the first serial port to allow a serial console connection.
+        """
+
+        # activate the first serial port
+        self._modify_vm("--uart1 0x3F8 4")
+
+        # set server mode with a pipe on the first serial port
+        pipe_name = self._get_pipe_name()
+        args = [self._vmname, "--uartmode1", "server", pipe_name]
+        self._execute("modifyvm", args)
+
+    def _modify_vm(self, params):
+        """
+        Change setting in this VM when not running.
+
+        :param params: params to use with sub-command modifyvm
+        """
+
+        args = shlex.split(params)
+        self._execute("modifyvm", [self._vmname] + args)
+
+    def _control_vm(self, params):
+        """
+        Change setting in this VM when running.
+
+        :param params: params to use with sub-command controlvm
+
+        :returns: result of the command.
+        """
+
+        args = shlex.split(params)
+        return self._execute("controlvm", [self._vmname] + args)
+
+    def _storage_attach(self, params):
+        """
+        Change storage medium in this VM.
+
+        :param params: params to use with sub-command storageattach
+        """
+
+        args = shlex.split(params)
+        self._execute("storageattach", [self._vmname] + args)
+
+    def _get_nic_attachements(self, maximum_adapters):
+        """
+        Returns NIC attachements.
+
+        :param maximum_adapters: maximum number of supported adapters
+        :returns: list of adapters with their Attachment setting (NAT, bridged etc.)
+        """
+
+        nics = []
+        vm_info = self._get_vm_info()
+        for adapter_id in range(0, maximum_adapters):
+            entry = "nic{}".format(adapter_id + 1)
+            if entry in vm_info:
+                value = vm_info[entry]
+                nics.append(value)
+            else:
+                nics.append(None)
+        return nics
+
+    def _set_network_options(self):
+        """
+        Configures network options.
+        """
+
+        nic_attachements = self._get_nic_attachements(self._maximum_adapters)
+        for adapter_id in range(0, len(self._ethernet_adapters)):
+            if self._ethernet_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.
+                attachement = nic_attachements[adapter_id]
+                if attachement:
+                    # attachement can be none, null, nat, bridged, intnet, hostonly or generic
+                    self._modify_vm("--nic{} {}".format(adapter_id + 1, attachement))
+                continue
+
+            vbox_adapter_type = "82540EM"
+            if self._adapter_type == "PCnet-PCI II (Am79C970A)":
+                vbox_adapter_type = "Am79C970A"
+            if self._adapter_type == "PCNet-FAST III (Am79C973)":
+                vbox_adapter_type = "Am79C973"
+            if self._adapter_type == "Intel PRO/1000 MT Desktop (82540EM)":
+                vbox_adapter_type = "82540EM"
+            if self._adapter_type == "Intel PRO/1000 T Server (82543GC)":
+                vbox_adapter_type = "82543GC"
+            if self._adapter_type == "Intel PRO/1000 MT Server (82545EM)":
+                vbox_adapter_type = "82545EM"
+            if self._adapter_type == "Paravirtualized Network (virtio-net)":
+                vbox_adapter_type = "virtio"
+
+            args = [self._vmname, "--nictype{}".format(adapter_id + 1), vbox_adapter_type]
+            self._execute("modifyvm", args)
+
+            self._modify_vm("--nictrace{} off".format(adapter_id + 1))
+            nio = self._ethernet_adapters[adapter_id].get_nio(0)
+            if nio:
+                log.debug("setting UDP params on adapter {}".format(adapter_id))
+                self._modify_vm("--nic{} generic".format(adapter_id + 1))
+                self._modify_vm("--nicgenericdrv{} UDPTunnel".format(adapter_id + 1))
+                self._modify_vm("--nicproperty{} sport={}".format(adapter_id + 1, nio.lport))
+                self._modify_vm("--nicproperty{} dest={}".format(adapter_id + 1, nio.rhost))
+                self._modify_vm("--nicproperty{} dport={}".format(adapter_id + 1, nio.rport))
+                self._modify_vm("--cableconnected{} on".format(adapter_id + 1))
+
+                if nio.capturing:
+                    self._modify_vm("--nictrace{} on".format(adapter_id + 1))
+                    self._modify_vm("--nictracefile{} {}".format(adapter_id + 1, nio.pcap_output_file))
+            else:
+                # shutting down unused adapters...
+                self._modify_vm("--cableconnected{} off".format(adapter_id + 1))
+                self._modify_vm("--nic{} null".format(adapter_id + 1))
+
+        for adapter_id in range(len(self._ethernet_adapters), self._maximum_adapters):
+            log.debug("disabling remaining adapter {}".format(adapter_id))
+            self._modify_vm("--nic{} none".format(adapter_id + 1))
+
+    def _create_linked_clone(self):
+        """
+        Creates a new linked clone.
+        """
+
+        gns3_snapshot_exists = False
+        vm_info = self._get_vm_info()
+        for entry, value in vm_info.items():
+            if entry.startswith("SnapshotName") and value == "GNS3 Linked Base for clones":
+                gns3_snapshot_exists = True
+
+        if not gns3_snapshot_exists:
+            result = self._execute("snapshot", [self._vmname, "take", "GNS3 Linked Base for clones"])
+            log.debug("GNS3 snapshot created: {}".format(result))
+
+        args = [self._vmname,
+                "--snapshot",
+                "GNS3 Linked Base for clones",
+                "--options",
+                "link",
+                "--name",
+                self._name,
+                "--basefolder",
+                self._working_dir,
+                "--register"]
+
+        result = self._execute("clonevm", args)
+        self._vmname = self._name
+        self._execute("setextradata", [self._vmname, "GNS3/Clone", "yes"])
+        log.debug("cloned VirtualBox VM: {}".format(result))
+
     def start(self):
         """
         Starts this VirtualBox VM.
         """
 
-        if self._vboxwrapper:
-            self._vboxwrapper.send('vbox start "{}"'.format(self._name))
-        else:
-            self._vboxcontroller.start()
+        # resume the VM if it is paused
+        vm_state = self._get_vm_state()
+        if vm_state == "paused":
+            self.resume()
+            return
+
+        # VM must be powered off and in saved state to start it
+        if vm_state != "poweroff" and vm_state != "saved":
+            raise VirtualBoxError("VirtualBox VM not powered off or saved")
+
+        self._set_network_options()
+        self._set_serial_console()
+
+        args = [self._vmname]
+        if self._headless:
+            args.extend(["--type", "headless"])
+        result = self._execute("startvm", args)
+        log.debug("started VirtualBox VM: {}".format(result))
+
+        # add a guest property to let the VM know about the GNS3 name
+        self._execute("guestproperty", ["set", self._vmname, "NameInGNS3", self._name])
+
+        # add a guest property to let the VM know about the GNS3 project directory
+        self._execute("guestproperty", ["set", self._vmname, "ProjectDirInGNS3", self._working_dir])
+
+        if self._enable_remote_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._telnet_server_thread = TelnetServer(self._vmname, msvcrt.get_osfhandle(self._serial_pipe.fileno()), self._console_host, self._console)
+                self._telnet_server_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._telnet_server_thread = TelnetServer(self._vmname, self._serial_pipe, self._console_host, self._console)
+                self._telnet_server_thread.start()
 
     def stop(self):
         """
         Stops this VirtualBox VM.
         """
 
-        if self._vboxwrapper:
+        if self._telnet_server_thread:
+            self._telnet_server_thread.stop()
+            self._telnet_server_thread.join(timeout=3)
+            if self._telnet_server_thread.isAlive():
+                log.warn("Serial pire thread is still alive!")
+            self._telnet_server_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
+
+        vm_state = self._get_vm_state()
+        if vm_state == "running" or vm_state == "paused" or vm_state == "stuck":
+            # power off the VM
+            result = self._control_vm("poweroff")
+            log.debug("VirtualBox VM has been stopped: {}".format(result))
+
+            time.sleep(0.5)  # give some time for VirtualBox to unlock the VM
+            # deactivate the first serial port
             try:
-                self._vboxwrapper.send('vbox stop "{}"'.format(self._name))
-            except VirtualBoxError:
-                # probably lost the connection
-                return
-        else:
-            self._vboxcontroller.stop()
+                self._modify_vm("--uart1 off")
+            except VirtualBoxError as e:
+                log.warn("Could not deactivate the first serial port: {}".format(e))
+
+            for adapter_id in range(0, len(self._ethernet_adapters)):
+                if self._ethernet_adapters[adapter_id] is None:
+                    continue
+                self._modify_vm("--nictrace{} off".format(adapter_id + 1))
+                self._modify_vm("--cableconnected{} off".format(adapter_id + 1))
+                self._modify_vm("--nic{} null".format(adapter_id + 1))
 
     def suspend(self):
         """
         Suspends this VirtualBox VM.
         """
 
-        if self._vboxwrapper:
-            self._vboxwrapper.send('vbox suspend "{}"'.format(self._name))
+        vm_state = self._get_vm_state()
+        if vm_state == "running":
+            result = self._control_vm("pause")
+            log.debug("VirtualBox VM has been suspended: {}".format(result))
         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()
+            log.info("VirtualBox VM is not running to be suspended, current state is {}".format(vm_state))
 
     def resume(self):
         """
         Resumes this VirtualBox VM.
         """
 
-        if self._vboxwrapper:
-            self._vboxwrapper.send('vbox resume "{}"'.format(self._name))
-        else:
-            self._vboxcontroller.resume()
+        result = self._control_vm("resume")
+        log.debug("VirtualBox VM has been resumed: {}".format(result))
+
+    def reload(self):
+        """
+        Reloads this VirtualBox VM.
+        """
+
+        result = self._control_vm("reset")
+        log.debug("VirtualBox VM has been reset: {}".format(result))
 
     def port_add_nio_binding(self, adapter_id, nio):
         """
@@ -549,14 +904,14 @@ class VirtualBoxVM(object):
             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)
+        vm_state = self._get_vm_state()
+        if vm_state == "running":
+            # dynamically configure an UDP tunnel on the VirtualBox adapter
+            self._control_vm("nic{} generic UDPTunnel".format(adapter_id + 1))
+            self._control_vm("nicproperty{} sport={}".format(adapter_id + 1, nio.lport))
+            self._control_vm("nicproperty{} dest={}".format(adapter_id + 1, nio.rhost))
+            self._control_vm("nicproperty{} dport={}".format(adapter_id + 1, nio.rport))
+            self._control_vm("setlinkstate{} on".format(adapter_id + 1))
 
         adapter.add_nio(0, nio)
         log.info("VirtualBox VM {name} [id={id}]: {nio} added to adapter {adapter_id}".format(name=self._name,
@@ -579,11 +934,11 @@ class VirtualBoxVM(object):
             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)
+        vm_state = self._get_vm_state()
+        if vm_state == "running":
+            # dynamically disable the VirtualBox adapter
+            self._control_vm("setlinkstate{} off".format(adapter_id + 1))
+            self._control_vm("nic{} null".format(adapter_id + 1))
 
         nio = adapter.get_nio(0)
         adapter.remove_nio(0)
@@ -620,11 +975,6 @@ class VirtualBoxVM(object):
 
         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))
@@ -645,10 +995,6 @@ class VirtualBoxVM(object):
         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

@@ -87,6 +87,7 @@ class VPCS(IModule):
         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._console_host = vpcs_config.get("console_host", kwargs["console_host"])
         self._projects_dir = kwargs["projects_dir"]
         self._tempdir = kwargs["temp_dir"]
         self._working_dir = self._projects_dir
@@ -139,6 +140,7 @@ class VPCS(IModule):
         self._vpcs_instances.clear()
         self._allocated_udp_ports.clear()
 
+        self._working_dir = self._projects_dir
         log.info("VPCS module has been reset")
 
     @IModule.route("vpcs.settings")
@@ -237,9 +239,9 @@ class VPCS(IModule):
             vpcs_instance = VPCSDevice(name,
                                        self._vpcs,
                                        self._working_dir,
-                                       self._host,
                                        vpcs_id,
                                        console,
+                                       self._console_host,
                                        self._console_start_port_range,
                                        self._console_end_port_range)
 

gns3server/modules/vpcs/vpcs_device.py

@@ -45,9 +45,9 @@ class VPCSDevice(object):
     :param name: name of this VPCS device
     :param path: path to VPCS executable
     :param working_dir: path to a working directory
-    :param host: host/address to bind for console and UDP connections
     :param vpcs_id: VPCS instance ID
     :param console: TCP console port
+    :param console_host: IP address to bind for console connections
     :param console_start_port_range: TCP console port range start
     :param console_end_port_range: TCP console port range end
     """
@@ -59,9 +59,9 @@ class VPCSDevice(object):
                  name,
                  path,
                  working_dir,
-                 host="127.0.0.1",
                  vpcs_id=None,
                  console=None,
+                 console_host="0.0.0.0",
                  console_start_port_range=4512,
                  console_end_port_range=5000):
 
@@ -89,7 +89,7 @@ class VPCSDevice(object):
         self._path = path
         self._console = console
         self._working_dir = None
-        self._host = host
+        self._console_host = console_host
         self._command = []
         self._process = None
         self._vpcs_stdout_file = ""
@@ -114,7 +114,7 @@ class VPCSDevice(object):
             try:
                 self._console = find_unused_port(self._console_start_port_range,
                                                  self._console_end_port_range,
-                                                 self._host,
+                                                 self._console_host,
                                                  ignore_ports=self._allocated_console_ports)
             except Exception as e:
                 raise VPCSError(e)
@@ -346,7 +346,7 @@ class VPCSDevice(object):
                     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:
+        except subprocess.SubprocessError as e:
             raise VPCSError("Error while looking for the VPCS version: {}".format(e))
 
     def start(self):
@@ -386,7 +386,7 @@ class VPCSDevice(object):
                                                      creationflags=flags)
                 log.info("VPCS instance {} started PID={}".format(self._id, self._process.pid))
                 self._started = True
-            except OSError as e:
+            except subprocess.SubprocessError as e:
                 vpcs_stdout = self.read_vpcs_stdout()
                 log.error("could not start VPCS {}: {}\n{}".format(self._path, e, vpcs_stdout))
                 raise VPCSError("could not start VPCS {}: {}\n{}".format(self._path, e, vpcs_stdout))

gns3server/server.py

@@ -33,7 +33,7 @@ import tornado.ioloop
 import tornado.web
 import tornado.autoreload
 import pkg_resources
-from os.path import expanduser
+import ipaddress
 import base64
 import uuid
 
@@ -50,6 +50,7 @@ from .modules import MODULES
 import logging
 log = logging.getLogger(__name__)
 
+
 class Server(object):
 
     # built-in handlers
@@ -57,13 +58,21 @@ class Server(object):
                 (r"/upload", FileUploadHandler),
                 (r"/login", LoginHandler)]
 
-    def __init__(self, host, port, ipc=False):
+    def __init__(self, host, port, ipc, console_bind_to_any):
 
         self._host = host
         self._port = port
         self._router = None
         self._stream = None
 
+        if console_bind_to_any:
+            if ipaddress.ip_address(self._host).version == 6:
+                self._console_host = "::"
+            else:
+                self._console_host = "0.0.0.0"
+        else:
+            self._console_host = self._host
+
         if ipc:
             self._zmq_port = 0  # this forces to use IPC for communications with the ZeroMQ server
         else:
@@ -131,6 +140,7 @@ class Server(object):
                               "127.0.0.1",  # ZeroMQ server address
                               self._zmq_port,  # ZeroMQ server port
                               host=self._host,  # server host address
+                              console_host=self._console_host,
                               projects_dir=self._projects_dir,
                               temp_dir=self._temp_dir)
 
@@ -140,7 +150,6 @@ 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.
@@ -175,7 +184,6 @@ class Server(object):
         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))])
@@ -188,11 +196,10 @@ class Server(object):
                                               **settings)  # FIXME: debug mode!
 
         try:
-            print("Starting server on {}:{} (Tornado v{}, PyZMQ v{}, ZMQ v{})".format(self._host,
-                                                                                      self._port,
-                                                                                      tornado.version,
-                                                                                      zmq.__version__,
-                                                                                      zmq.zmq_version()))
+            user_log = logging.getLogger('user_facing')
+            user_log.info("Starting server on {}:{} (Tornado v{}, PyZMQ v{}, ZMQ v{})".format(
+                          self._host, self._port, tornado.version, zmq.__version__, zmq.zmq_version()))
+
             kwargs = {"address": self._host}
 
             if ssl_options:
@@ -200,6 +207,7 @@ class Server(object):
 
             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)
         except OSError as e:
             if e.errno == errno.EADDRINUSE:  # socket already in use
@@ -230,7 +238,7 @@ class Server(object):
         try:
             ioloop.start()
         except (KeyboardInterrupt, SystemExit):
-            print("\nExiting...")
+            log.info("\nExiting...")
             self._cleanup()
 
     def _create_zmq_router(self):

gns3server/start_server.py

@@ -24,7 +24,9 @@
 # number has been incremented)
 
 """
-Startup script for GNS3 Server Cloud Instance
+Startup script for a GNS3 Server Cloud Instance.  It generates certificates,
+config files and usernames before finally starting the gns3server process
+on the instance.
 """
 
 import os
@@ -59,6 +61,7 @@ USAGE: %s
 Options:
 
   -d, --debug         Enable debugging
+  -i  --ip            The ip address of the server, for cert generation
   -v, --verbose       Enable verbose logging
   -h, --help          Display this menu :)
 
@@ -67,16 +70,17 @@ Options:
 
 """ % (SCRIPT_NAME)
 
-# Parse cmd line options
+
 def parse_cmd_line(argv):
     """
     Parse command line arguments
 
-    argv: Pass in cmd line arguments
+    argv: Passed in sys.argv
     """
 
     short_args = "dvh"
     long_args = ("debug",
+                    "ip=",
                     "verbose",
                     "help",
                     "data=",
@@ -88,10 +92,7 @@ def parse_cmd_line(argv):
         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
+    cmd_line_option_list = {'debug': False, 'verbose': True, 'data': None}
 
     if sys.platform == "linux":
         cmd_line_option_list['syslog'] = "/dev/log"
@@ -101,14 +102,16 @@ def parse_cmd_line(argv):
         cmd_line_option_list['syslog'] = ('localhost',514)
 
     for opt, val in opts:
-        if (opt in ("-h", "--help")):
+        if opt in ("-h", "--help"):
             print(usage)
             sys.exit(0)
-        elif (opt in ("-d", "--debug")):
+        elif opt in ("-d", "--debug"):
             cmd_line_option_list["debug"] = True
-        elif (opt in ("-v", "--verbose")):
+        elif opt in ("--ip",):
+            cmd_line_option_list["ip"] = val
+        elif opt in ("-v", "--verbose"):
             cmd_line_option_list["verbose"] = True
-        elif (opt in ("--data")):
+        elif opt in ("--data",):
             cmd_line_option_list["data"] = ast.literal_eval(val)
 
     return cmd_line_option_list
@@ -124,10 +127,10 @@ def set_logging(cmd_options):
     log_level = logging.INFO
     log_level_console = logging.WARNING
 
-    if cmd_options['verbose'] == True:
+    if cmd_options['verbose'] is True:
         log_level_console = logging.INFO
 
-    if cmd_options['debug'] == True:
+    if cmd_options['debug'] is True:
         log_level_console = logging.DEBUG
         log_level = logging.DEBUG
 
@@ -138,38 +141,48 @@ def set_logging(cmd_options):
     console_log.setLevel(log_level_console)
     console_log.setFormatter(formatter)
 
-    syslog_hndlr = SysLogHandler(
+    syslog_handler = SysLogHandler(
         address=cmd_options['syslog'],
         facility=SysLogHandler.LOG_KERN
     )
 
-    syslog_hndlr.setFormatter(sys_formatter)
+    syslog_handler.setFormatter(sys_formatter)
 
     log.setLevel(log_level)
     log.addHandler(console_log)
-    log.addHandler(syslog_hndlr)
+    log.addHandler(syslog_handler)
 
     return log
 
-def _generate_certs():
-    cmd = []
-    cmd.append("%s/cert_utils/create_cert.sh" % (SCRIPT_PATH))
 
-    log.debug("Generating certs ...")
+def _generate_certs(options):
+    """
+    Generate a self-signed certificate for SSL-enabling the WebSocket
+    connection.  The certificate is sent back to the client so it can
+    verify the authenticity of the server.
+
+    :return: A 2-tuple of strings containing (server_key, server_cert)
+    """
+    cmd = ["{}/cert_utils/create_cert.sh".format(SCRIPT_PATH), options['ip']]
+    log.debug("Generating certs with cmd: {}".format(' '.join(cmd)))
     output_raw = subprocess.check_output(cmd, shell=False,
-        stderr=subprocess.STDOUT)
+                                         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 _start_gns3server():
+    """
+    Start up the gns3 server.
+
+    :return: None
+    """
+    cmd = 'gns3server --quiet > /tmp/gns3.log 2>&1 &'
+    log.info("Starting gns3server with cmd {}".format(cmd))
+    os.system(cmd)
 
 
 def main():
@@ -187,7 +200,6 @@ def main():
         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)
@@ -203,7 +215,7 @@ def main():
     except FileExistsError:
         pass
 
-    (server_key, server_crt) = _generate_certs()
+    (server_key, server_crt) = _generate_certs(options)
 
     cloud_config = configparser.ConfigParser()
     cloud_config['CLOUD_SERVER'] = {}
@@ -213,15 +225,13 @@ def main():
 
     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']['SSL_ENABLED'] = 'no'
     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:
@@ -229,12 +239,14 @@ def main():
 
     cert_file.close()
 
+    # Return a stringified dictionary on stdout.  The gui captures this to get
+    # things like the server cert.
     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)
+    return 0
 
 
 if __name__ == "__main__":

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.1"
-__version_info__ = (1, 1, 0, 0)
+__version__ = "1.2.1"
+__version_info__ = (1, 2, 1, 0)

scripts/ws_client.py

@@ -0,0 +1,46 @@
+# -*- 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 ws4py.client.threadedclient import WebSocketClient
+
+
+class WSClient(WebSocketClient):
+
+    def opened(self):
+
+        print("Connection successful with {}:{}".format(self.host, self.port))
+
+        self.send('{"jsonrpc": 2.0, "method": "dynamips.settings", "params": {"path": "/usr/local/bin/dynamips", "allocate_hypervisor_per_device": true, "working_dir": "/tmp/gns3-1b4grwm3-files", "udp_end_port_range": 20000, "sparse_memory_support": true, "allocate_hypervisor_per_ios_image": true, "aux_start_port_range": 2501, "use_local_server": true, "hypervisor_end_port_range": 7700, "aux_end_port_range": 3000, "mmap_support": true, "console_start_port_range": 2001, "console_end_port_range": 2500, "hypervisor_start_port_range": 7200, "ghost_ios_support": true, "memory_usage_limit_per_hypervisor": 1024, "jit_sharing_support": false, "udp_start_port_range": 10001}}')
+        self.send('{"jsonrpc": 2.0, "method": "dynamips.vm.create", "id": "e8caf5be-de3d-40dd-80b9-ab6df8029570", "params": {"image": "/home/grossmj/GNS3/images/IOS/c3725-advipservicesk9-mz.124-15.T14.image", "name": "R1", "platform": "c3725", "ram": 256}}')
+
+    def closed(self, code, reason=None):
+
+        print("Closed down. Code: {} Reason: {}".format(code, reason))
+
+    def received_message(self, m):
+
+        print(m)
+        if len(m) == 175:
+            self.close(reason='Bye bye')
+
+if __name__ == '__main__':
+    try:
+        ws = WSClient('ws://localhost:8000/', protocols=['http-only', 'chat'])
+        ws.connect()
+        ws.run_forever()
+    except KeyboardInterrupt:
+        ws.close()

setup.py

@@ -47,7 +47,9 @@ setup(
     install_requires=[
         "tornado>=3.1",
         "pyzmq>=14.0.0",
-        "jsonschema>=2.3.0"
+        "jsonschema>=2.3.0",
+        "apache-libcloud>=0.14.1",
+        "requests",
     ],
     entry_points={
         "console_scripts": [