Polish and bump up to version 1.0!

Add secure communication between gui and server 2/2

README.rst

@@ -34,4 +34,19 @@ Please use our all-in-one installer.
 Mac OS X
 --------
 
-Please use our DMG package.
+Please use our DMG package for a simple installation.
+
+
+If you want to test the current git version or contribute to the project.
+
+You can follow this instructions with virtualenwrapper: http://virtualenvwrapper.readthedocs.org/
+and homebrew: http://brew.sh/.
+
+.. code:: bash
+
+   brew install python3
+   mkvirtualenv gns3-server --python=/usr/local/bin/python3.4
+   python3 setup.py install
+   gns3server
+
+

cloud-image/create_image.py

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

cloud-image/script_template

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

gns3dms/__init__.py

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

gns3dms/cloud/base_cloud_ctrl.py

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

gns3dms/cloud/exceptions.py

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

gns3dms/cloud/rackspace_ctrl.py

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

gns3dms/main.py

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

gns3dms/modules/__init__.py

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

gns3dms/modules/daemon.py

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

gns3dms/modules/rackspace_cloud.py

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

gns3dms/version.py

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

gns3server/cert_utils/create_cert.sh

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

gns3server/config.py

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

gns3server/handlers/auth_handler.py

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

gns3server/handlers/file_upload_handler.py

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

gns3server/handlers/jsonrpc_websocket.py

@@ -22,6 +22,7 @@ JSON-RPC protocol over Websockets.
 import zmq
 import uuid
 import tornado.websocket
+from .auth_handler import GNS3WebSocketBaseHandler
 from tornado.escape import json_decode
 from ..jsonrpc import JSONRPCParseError
 from ..jsonrpc import JSONRPCInvalidRequest
@@ -33,7 +34,7 @@ import logging
 log = logging.getLogger(__name__)
 
 
-class JSONRPCWebSocket(tornado.websocket.WebSocketHandler):
+class JSONRPCWebSocket(GNS3WebSocketBaseHandler):
     """
     STOMP protocol over Tornado Websockets with message
     routing to ZeroMQ dealer clients.
@@ -119,7 +120,15 @@ class JSONRPCWebSocket(tornado.websocket.WebSocketHandler):
         """
 
         log.info("Websocket client {} connected".format(self.session_id))
-        self.clients.add(self)
+
+        authenticated_user = self.get_current_user()
+
+        if authenticated_user:
+            self.clients.add(self)
+            log.info("Websocket authenticated user: %s" % (authenticated_user))
+        else:
+            self.close()
+            log.info("Websocket non-authenticated user attempt: %s" % (authenticated_user))
 
     def on_message(self, message):
         """

gns3server/handlers/version_handler.py

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

gns3server/modules/__init__.py

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

gns3server/modules/deadman/__init__.py

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

gns3server/modules/dynamips/__init__.py

@@ -111,7 +111,7 @@ class Dynamips(IModule):
         dynamips_config = config.get_section_config(name.upper())
         self._dynamips = dynamips_config.get("dynamips_path")
         if not self._dynamips or not os.path.isfile(self._dynamips):
-            paths = [os.getcwd()] + os.environ["PATH"].split(":")
+            paths = [os.getcwd()] + os.environ["PATH"].split(os.pathsep)
             # look for Dynamips in the current working directory and $PATH
             for path in paths:
                 try:

gns3server/modules/dynamips/backends/vm.py

@@ -17,6 +17,7 @@
 
 import os
 import base64
+import time
 from gns3server.modules import IModule
 from ..dynamips_error import DynamipsError
 
@@ -61,6 +62,7 @@ from ..schemas.vm import VM_STOP_CAPTURE_SCHEMA
 from ..schemas.vm import VM_SAVE_CONFIG_SCHEMA
 from ..schemas.vm import VM_EXPORT_CONFIG_SCHEMA
 from ..schemas.vm import VM_IDLEPCS_SCHEMA
+from ..schemas.vm import VM_AUTO_IDLEPC_SCHEMA
 from ..schemas.vm import VM_ALLOCATE_UDP_PORT_SCHEMA
 from ..schemas.vm import VM_ADD_NIO_SCHEMA
 from ..schemas.vm import VM_DELETE_NIO_SCHEMA
@@ -704,6 +706,76 @@ class VM(object):
                     "idlepcs": idlepcs}
         self.send_response(response)
 
+    @IModule.route("dynamips.vm.auto_idlepc")
+    def vm_auto_idlepc(self, request):
+        """
+        Auto idle-pc calculation.
+
+        Mandatory request parameters:
+        - id (vm identifier)
+
+        Response parameters:
+        - id (vm identifier)
+        - logs (logs for the calculation)
+        - idlepc (idle-pc value)
+
+        :param request: JSON request
+        """
+
+        # validate the request
+        if not self.validate_request(request, VM_AUTO_IDLEPC_SCHEMA):
+            return
+
+        # get the router instance
+        router = self.get_device_instance(request["id"], self._routers)
+        if not router:
+            return
+
+        try:
+            router.idlepc = "0x0"  # reset the current idle-pc value before calculating a new one
+            was_auto_started = False
+            if router.get_status() != "running":
+                router.start()
+                was_auto_started = True
+                time.sleep(20)  # leave time to the router to boot
+
+            logs = []
+            validated_idlepc = "0x0"
+            idlepcs = router.get_idle_pc_prop()
+            if not idlepcs:
+                logs.append("No idle-pc values found")
+
+            for idlepc in idlepcs:
+                router.idlepc = idlepc.split()[0]
+                logs.append("Trying idle-pc value {}".format(router.idlepc))
+                start_time = time.time()
+                initial_cpu_usage = router.get_cpu_usage()
+                logs.append("Initial CPU usage = {}%".format(initial_cpu_usage))
+                time.sleep(4)  # wait 4 seconds to probe the cpu again
+                elapsed_time = time.time() - start_time
+                cpu_elapsed_usage = router.get_cpu_usage() - initial_cpu_usage
+                cpu_usage = abs(cpu_elapsed_usage * 100.0 / elapsed_time)
+                logs.append("CPU usage after {:.2} seconds = {:.2}%".format(elapsed_time, cpu_usage))
+                if cpu_usage > 100:
+                    cpu_usage = 100
+                if cpu_usage < 70:
+                    validated_idlepc = router.idlepc
+                    logs.append("Idle-PC value {} has been validated".format(validated_idlepc))
+                    break
+        except DynamipsError as e:
+            self.send_custom_error(str(e))
+            return
+        finally:
+            if was_auto_started:
+                router.stop()
+
+        validated_idlepc = "0x0"
+        response = {"id": router.id,
+                    "logs": logs,
+                    "idlepc": validated_idlepc}
+
+        self.send_response(response)
+
     @IModule.route("dynamips.vm.allocate_udp_port")
     def vm_allocate_udp_port(self, request):
         """

gns3server/modules/dynamips/nodes/router.py

@@ -1255,6 +1255,15 @@ class Router(object):
         return (self._hypervisor.send("{platform} show_hardware {name}".format(platform=self._platform,
                                                                                name=self._name)))
 
+    def get_cpu_usage(self):
+        """
+        Returns the CPU usage.
+
+        :return: CPU usage in percent
+        """
+
+        return int(self._hypervisor.send("vm cpu_usage {name} 0".format(name=self._name))[0])
+
     def get_slot_bindings(self):
         """
         Returns slot bindings.

gns3server/modules/dynamips/schemas/vm.py

@@ -487,6 +487,20 @@ VM_IDLEPCS_SCHEMA = {
     "required": ["id"]
 }
 
+VM_AUTO_IDLEPC_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Request an auto idle-pc calculation for this VM instance",
+    "type": "object",
+    "properties": {
+        "id": {
+            "description": "VM instance ID",
+            "type": "integer"
+        },
+    },
+    "additionalProperties": False,
+    "required": ["id"]
+}
+
 VM_ALLOCATE_UDP_PORT_SCHEMA = {
     "$schema": "http://json-schema.org/draft-04/schema#",
     "description": "Request validation to allocate an UDP port for a VM instance",

gns3server/modules/iou/__init__.py

@@ -68,7 +68,7 @@ class IOU(IModule):
         iou_config = config.get_section_config(name.upper())
         self._iouyap = iou_config.get("iouyap_path")
         if not self._iouyap or not os.path.isfile(self._iouyap):
-            paths = [os.getcwd()] + os.environ["PATH"].split(":")
+            paths = [os.getcwd()] + os.environ["PATH"].split(os.pathsep)
             # look for iouyap in the current working directory and $PATH
             for path in paths:
                 try:

gns3server/modules/qemu/__init__.py

@@ -619,7 +619,7 @@ class Qemu(IModule):
         """
 
         qemus = []
-        paths = [os.getcwd()] + os.environ["PATH"].split(":")
+        paths = [os.getcwd()] + os.environ["PATH"].split(os.pathsep)
         # look for Qemu binaries in the current working directory and $PATH
         if sys.platform.startswith("win"):
             # add specific Windows paths
@@ -628,6 +628,9 @@ class Qemu(IModule):
                 paths.append(os.path.join(os.environ["PROGRAMFILES(X86)"], "qemu"))
             if "PROGRAMFILES" in os.environ and os.path.exists(os.environ["PROGRAMFILES"]):
                 paths.append(os.path.join(os.environ["PROGRAMFILES"], "qemu"))
+        elif sys.platform.startswith("darwin"):
+            # add a specific location on Mac OS X regardless of what's in $PATH
+            paths.append("/usr/local/bin")
         for path in paths:
             try:
                 for f in os.listdir(path):

gns3server/modules/qemu/schemas.py

@@ -82,12 +82,10 @@ QEMU_UPDATE_SCHEMA = {
         "hda_disk_image": {
             "description": "QEMU hda disk image path",
             "type": "string",
-            "minLength": 1,
         },
         "hdb_disk_image": {
             "description": "QEMU hdb disk image path",
             "type": "string",
-            "minLength": 1,
         },
         "ram": {
             "description": "amount of RAM in MB",
@@ -113,17 +111,14 @@ QEMU_UPDATE_SCHEMA = {
         "initrd": {
             "description": "QEMU initrd path",
             "type": "string",
-            "minLength": 1,
         },
         "kernel_image": {
             "description": "QEMU kernel image path",
             "type": "string",
-            "minLength": 1,
         },
         "kernel_command_line": {
             "description": "QEMU kernel command line",
             "type": "string",
-            "minLength": 1,
         },
         "options": {
             "description": "additional QEMU options",

gns3server/modules/virtualbox/__init__.py

@@ -67,7 +67,7 @@ class VirtualBox(IModule):
             vbox_config = config.get_section_config(name.upper())
             self._vboxwrapper_path = vbox_config.get("vboxwrapper_path")
             if not self._vboxwrapper_path or not os.path.isfile(self._vboxwrapper_path):
-                paths = [os.getcwd()] + os.environ["PATH"].split(":")
+                paths = [os.getcwd()] + os.environ["PATH"].split(os.pathsep)
                 # look for vboxwrapper in the current working directory and $PATH
                 for path in paths:
                     try:

gns3server/modules/vpcs/__init__.py

@@ -63,7 +63,7 @@ class VPCS(IModule):
         vpcs_config = config.get_section_config(name.upper())
         self._vpcs = vpcs_config.get("vpcs_path")
         if not self._vpcs or not os.path.isfile(self._vpcs):
-            paths = [os.getcwd()] + os.environ["PATH"].split(":")
+            paths = [os.getcwd()] + os.environ["PATH"].split(os.pathsep)
             # look for VPCS in the current working directory and $PATH
             for path in paths:
                 try:

gns3server/server.py

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

gns3server/start_server.py

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

gns3server/templates/upload.html

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

gns3server/version.py

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

requirements.txt

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

setup.py

@@ -52,6 +52,7 @@ setup(
     entry_points={
         "console_scripts": [
             "gns3server = gns3server.main:main",
+            "gns3dms = gns3dms.main:main",
         ]
     },
     packages=find_packages(),

tests/dynamips/test_c7200.py

@@ -29,9 +29,9 @@ def test_router_exists(router_c7200):
 
 def test_npe(router_c7200):
 
-    assert router_c7200.npe == "npe-200"  # default value
-    router_c7200.npe = "npe-400"
-    assert router_c7200.npe == "npe-400"
+    assert router_c7200.npe == "npe-400"  # default value
+    router_c7200.npe = "npe-200"
+    assert router_c7200.npe == "npe-200"
 
 
 def test_midplane(router_c7200):