gns3-server/gns3server/modules/dynamips/hypervisor_manager.py

# -*- 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/>.

"""
Manages Dynamips hypervisors (load-balancing etc.)
"""

from .hypervisor import Hypervisor
from .dynamips_error import DynamipsError
from ..attic import find_unused_port
from pkg_resources import parse_version

import os
import socket
import time
import logging

log = logging.getLogger(__name__)


class HypervisorManager(object):
    """
    Manages Dynamips hypervisors.

    :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 base_port: base TCP port for hypervisors
    :param base_console: base TCP port for consoles
    :param base_aux: base TCP port for auxiliary consoles
    :param base_udp: base UDP port for UDP tunnels
    """

    def __init__(self, path, working_dir, host='127.0.0.1'):

        self._hypervisors = []
        self._path = path
        self._working_dir = working_dir
        self._host = host
        self._hypervisor_start_port_range = 7200
        self._hypervisor_end_port_range = 7700
        self._console_start_port_range = 2001
        self._console_end_port_range = 2500
        self._aux_start_port_range = 2501
        self._aux_end_port_range = 3000
        self._udp_start_port_range = 10001
        self._udp_end_port_range = 20000
        self._ghost_ios_support = True
        self._mmap_support = True
        self._jit_sharing_support = False
        self._sparse_memory_support = True
        self._allocate_hypervisor_per_device = True
        self._memory_usage_limit_per_hypervisor = 1024
        self._allocate_hypervisor_per_ios_image = True

    def __del__(self):
        """
        Shutdowns all started hypervisors
        """

        self.stop_all_hypervisors()

    @property
    def hypervisors(self):
        """
        Returns all hypervisor instances.

        :returns: list of hypervisor instances
        """

        return self._hypervisors

    @property
    def path(self):
        """
        Returns the Dynamips path.

        :returns: path to Dynamips
        """

        return self._path

    @path.setter
    def path(self, path):
        """
        Set a new Dynamips path.

        :param path: path to Dynamips
        """

        self._path = path
        log.info("Dynamips path set to {}".format(self._path))

    @property
    def working_dir(self):
        """
        Returns the Dynamips working directory path.

        :returns: path to Dynamips working directory
        """

        return self._working_dir

    @working_dir.setter
    def working_dir(self, working_dir):
        """
        Sets a new path to the Dynamips working directory.

        :param working_dir: path to Dynamips working directory
        """

        self._working_dir = os.path.join(working_dir, "dynamips")
        log.info("working directory set to {}".format(self._working_dir))

        # update all existing hypervisors with the new working directory
        for hypervisor in self._hypervisors:
            hypervisor.working_dir = self._working_dir

    @property
    def hypervisor_start_port_range(self):
        """
        Returns the hypervisor start port range value

        :returns: hypervisor start port range value (integer)
        """

        return self._hypervisor_start_port_range

    @hypervisor_start_port_range.setter
    def hypervisor_start_port_range(self, hypervisor_start_port_range):
        """
        Sets a new hypervisor start port range value

        :param hypervisor_start_port_range: hypervisor start port range value (integer)
        """

        if self._hypervisor_start_port_range != hypervisor_start_port_range:
            self._hypervisor_start_port_range = hypervisor_start_port_range
            log.info("hypervisor start port range value set to {}".format(self._hypervisor_start_port_range))

    @property
    def hypervisor_end_port_range(self):
        """
        Returns the hypervisor end port range value

        :returns: hypervisor end port range value (integer)
        """

        return self._hypervisor_end_port_range

    @hypervisor_end_port_range.setter
    def hypervisor_end_port_range(self, hypervisor_end_port_range):
        """
        Sets a new hypervisor end port range value

        :param hypervisor_end_port_range: hypervisor end port range value (integer)
        """

        if self._hypervisor_end_port_range != hypervisor_end_port_range:
            self._hypervisor_end_port_range = hypervisor_end_port_range
            log.info("hypervisor end port range value set to {}".format(self._hypervisor_end_port_range))

    @property
    def console_start_port_range(self):
        """
        Returns the console start port range value

        :returns: console start port range value (integer)
        """

        return self._console_start_port_range

    @console_start_port_range.setter
    def console_start_port_range(self, console_start_port_range):
        """
        Sets a new console start port range value

        :param console_start_port_range: console start port range value (integer)
        """

        if self._console_start_port_range != console_start_port_range:
            self._console_start_port_range = console_start_port_range
            log.info("console start port range value set to {}".format(self._console_start_port_range))

            # update all existing hypervisors with the new value
            for hypervisor in self._hypervisors:
                hypervisor.console_start_port_range = console_start_port_range

    @property
    def console_end_port_range(self):
        """
        Returns the console end port range value

        :returns: console end port range value (integer)
        """

        return self._console_end_port_range

    @console_end_port_range.setter
    def console_end_port_range(self, console_end_port_range):
        """
        Sets a new console end port range value

        :param console_end_port_range: console end port range value (integer)
        """

        if self._console_end_port_range != console_end_port_range:
            self._console_end_port_range = console_end_port_range
            log.info("console end port range value set to {}".format(self._console_end_port_range))

            # update all existing hypervisors with the new value
            for hypervisor in self._hypervisors:
                hypervisor.console_end_port_range = console_end_port_range

    @property
    def aux_start_port_range(self):
        """
        Returns the auxiliary console start port range value

        :returns: auxiliary console  start port range value (integer)
        """

        return self._aux_start_port_range

    @aux_start_port_range.setter
    def aux_start_port_range(self, aux_start_port_range):
        """
        Sets a new auxiliary console start port range value

        :param aux_start_port_range: auxiliary console start port range value (integer)
        """

        if self._aux_start_port_range != aux_start_port_range:
            self._aux_start_port_range = aux_start_port_range
            log.info("auxiliary console start port range value set to {}".format(self._aux_start_port_range))

            # update all existing hypervisors with the new value
            for hypervisor in self._hypervisors:
                hypervisor.aux_start_port_range = aux_start_port_range

    @property
    def aux_end_port_range(self):
        """
        Returns the auxiliary console end port range value

        :returns: auxiliary console end port range value (integer)
        """

        return self._aux_end_port_range

    @aux_end_port_range.setter
    def aux_end_port_range(self, aux_end_port_range):
        """
        Sets a new auxiliary console end port range value

        :param aux_end_port_range: auxiliary console end port range value (integer)
        """

        if self._aux_end_port_range != aux_end_port_range:
            self._aux_end_port_range = aux_end_port_range
            log.info("auxiliary console end port range value set to {}".format(self._aux_end_port_range))

            # update all existing hypervisors with the new value
            for hypervisor in self._hypervisors:
                hypervisor.aux_end_port_range = aux_end_port_range

    @property
    def udp_start_port_range(self):
        """
        Returns the UDP start port range value

        :returns: UDP start port range value (integer)
        """

        return self._udp_start_port_range

    @udp_start_port_range.setter
    def udp_start_port_range(self, udp_start_port_range):
        """
        Sets a new UDP start port range value

        :param udp_start_port_range: UDP start port range value (integer)
        """

        if self._udp_start_port_range != udp_start_port_range:
            self._udp_start_port_range = udp_start_port_range
            log.info("UDP start port range value set to {}".format(self._udp_start_port_range))

            # update all existing hypervisors with the new value
            for hypervisor in self._hypervisors:
                hypervisor.udp_start_port_range = udp_start_port_range

    @property
    def udp_end_port_range(self):
        """
        Returns the UDP end port range value

        :returns: UDP end port range value (integer)
        """

        return self._udp_end_port_range

    @udp_end_port_range.setter
    def udp_end_port_range(self, udp_end_port_range):
        """
        Sets a new UDP end port range value

        :param udp_end_port_range: UDP end port range value (integer)
        """

        if self._udp_end_port_range != udp_end_port_range:
            self._udp_end_port_range = udp_end_port_range
            log.info("UDP end port range value set to {}".format(self._udp_end_port_range))

            # update all existing hypervisors with the new value
            for hypervisor in self._hypervisors:
                hypervisor.udp_end_port_range = udp_end_port_range

    @property
    def ghost_ios_support(self):
        """
        Returns either ghost IOS is activated or not.

        :returns: boolean
        """

        return self._ghost_ios_support

    @ghost_ios_support.setter
    def ghost_ios_support(self, ghost_ios_support):
        """
        Sets ghost IOS support.

        :param ghost_ios_support: boolean
        """

        if self._ghost_ios_support != ghost_ios_support:
            self._ghost_ios_support = ghost_ios_support
            if ghost_ios_support:
                log.info("ghost IOS support enabled")
            else:
                log.info("ghost IOS support disabled")

    @property
    def mmap_support(self):
        """
        Returns either mmap is activated or not.

        :returns: boolean
        """

        return self._mmap_support

    @mmap_support.setter
    def mmap_support(self, mmap_support):
        """
        Sets mmap support.

        :param mmap_support: boolean
        """

        if self._mmap_support != mmap_support:
            self._mmap_support = mmap_support
            if mmap_support:
                log.info("mmap support enabled")
            else:
                log.info("mmap support disabled")

    @property
    def sparse_memory_support(self):
        """
        Returns either sparse memory is activated or not.

        :returns: boolean
        """

        return self._sparse_memory_support

    @sparse_memory_support.setter
    def sparse_memory_support(self, sparse_memory_support):
        """
        Sets sparse memory support.

        :param sparse_memory_support: boolean
        """

        if self._sparse_memory_support != sparse_memory_support:
            self._sparse_memory_support = sparse_memory_support
            if sparse_memory_support:
                log.info("sparse memory support enabled")
            else:
                log.info("sparse memory support disabled")

    @property
    def jit_sharing_support(self):
        """
        Returns either JIT sharing is activated or not.

        :returns: boolean
        """

        return self._jit_sharing_support

    @jit_sharing_support.setter
    def jit_sharing_support(self, jit_sharing_support):
        """
        Sets JIT sharing support.

        :param jit_sharing_support: boolean
        """

        if self._jit_sharing_support != jit_sharing_support:
            self._jit_sharing_support = jit_sharing_support
            if jit_sharing_support:
                log.info("JIT sharing support enabled")
            else:
                log.info("JIT sharing support disabled")

    @property
    def allocate_hypervisor_per_device(self):
        """
        Returns either an hypervisor is created for each device.

        :returns: True or False
        """

        return self._allocate_hypervisor_per_device

    @allocate_hypervisor_per_device.setter
    def allocate_hypervisor_per_device(self, value):
        """
        Sets if an hypervisor is created for each device.

        :param value: True or False
        """

        if self._allocate_hypervisor_per_device != value:
            self._allocate_hypervisor_per_device = value
            if value:
                log.info("allocating an hypervisor per device enabled")
            else:
                log.info("allocating an hypervisor per device disabled")

    @property
    def memory_usage_limit_per_hypervisor(self):
        """
        Returns the memory usage limit per hypervisor

        :returns: limit value (integer)
        """

        return self._memory_usage_limit_per_hypervisor

    @memory_usage_limit_per_hypervisor.setter
    def memory_usage_limit_per_hypervisor(self, memory_limit):
        """
        Sets the memory usage limit per hypervisor

        :param memory_limit: memory limit value (integer)
        """

        if self._memory_usage_limit_per_hypervisor != memory_limit:
            self._memory_usage_limit_per_hypervisor = memory_limit
            log.info("memory usage limit per hypervisor set to {}".format(memory_limit))

    @property
    def allocate_hypervisor_per_ios_image(self):
        """
        Returns if router are grouped per hypervisor
        based on their IOS image.

        :returns: True or False
        """

        return self._allocate_hypervisor_per_ios_image

    @allocate_hypervisor_per_ios_image.setter
    def allocate_hypervisor_per_ios_image(self, value):
        """
        Sets if routers are grouped per hypervisor
        based on their IOS image.

        :param value: True or False
        """

        if self._allocate_hypervisor_per_ios_image != value:
            self._allocate_hypervisor_per_ios_image = value
            if value:
                log.info("allocating an hypervisor per IOS image enabled")
            else:
                log.info("allocating an hypervisor per IOS image disabled")

    def wait_for_hypervisor(self, host, port, timeout=10):
        """
        Waits for an hypervisor to be started (accepting a socket connection)

        :param host: host/address to connect to the hypervisor
        :param port: port to connect to the hypervisor
        :param timeout: timeout value (default is 10 seconds)
        """

        # connect to a local address by default
        # if listening to all addresses (IPv4 or IPv6)
        if host == "0.0.0.0":
            host = "127.0.0.1"
        elif host == "::":
            host = "::1"

        connection_success = False
        begin = time.time()
        # try to connect for 10 seconds
        while(time.time() - begin < 10.0):
            time.sleep(0.01)
            try:
                with socket.create_connection((host, port), timeout):
                    pass
            except OSError as e:
                last_exception = e
                continue
            connection_success = True
            break

        if not connection_success:
            # FIXME: throw exception here
            log.critical("Couldn't connect to hypervisor on {}:{} :{}".format(host, port,
                                                                              last_exception))
        else:
            log.info("Dynamips server ready after {:.4f} seconds".format(time.time() - begin))

    def start_new_hypervisor(self):
        """
        Creates a new Dynamips process and start it.

        :returns: the new hypervisor instance
        """

        try:
            port = find_unused_port(self._hypervisor_start_port_range, self._hypervisor_end_port_range, self._host)
        except Exception as e:
            raise DynamipsError(e)

        hypervisor = Hypervisor(self._path,
                                self._working_dir,
                                self._host,
                                port)

        log.info("creating new hypervisor {}:{} with working directory {}".format(hypervisor.host, hypervisor.port, self._working_dir))
        hypervisor.start()

        self.wait_for_hypervisor(self._host, port)
        log.info("hypervisor {}:{} has successfully started".format(hypervisor.host, hypervisor.port))

        hypervisor.connect()
        if parse_version(hypervisor.version) < parse_version('0.2.11'):
            raise DynamipsError("Dynamips version must be >= 0.2.11, detected version is {}".format(hypervisor.version))

        hypervisor.console_start_port_range = self._console_start_port_range
        hypervisor.console_end_port_range = self._console_end_port_range
        hypervisor.aux_start_port_range = self._aux_start_port_range
        hypervisor.aux_end_port_range = self._aux_end_port_range
        hypervisor.udp_start_port_range = self._udp_start_port_range
        hypervisor.udp_end_port_range = self._udp_end_port_range
        self._hypervisors.append(hypervisor)
        return hypervisor

    def allocate_hypervisor_for_router(self, router_ios_image, router_ram):
        """
        Allocates a Dynamips hypervisor for a specific router
        (new or existing depending on the RAM amount and IOS image)

        :param router_ios_image: IOS image name
        :param router_ram: amount of RAM (integer)

        :returns: the allocated hypervisor instance
        """

        # allocate an hypervisor for each router by default
        if not self._allocate_hypervisor_per_device:
            for hypervisor in self._hypervisors:
                if self._allocate_hypervisor_per_ios_image:
                    if not hypervisor.image_ref:
                        hypervisor.image_ref = router_ios_image
                    elif hypervisor.image_ref != router_ios_image:
                        continue
                if (hypervisor.memory_load + router_ram) <= self._memory_usage_limit_per_hypervisor:
                    current_memory_load = hypervisor.memory_load
                    hypervisor.increase_memory_load(router_ram)
                    log.info("allocating existing hypervisor {}:{}, RAM={}+{}".format(hypervisor.host,
                                                                                      hypervisor.port,
                                                                                      current_memory_load,
                                                                                      router_ram))
                    return hypervisor

        hypervisor = self.start_new_hypervisor()
        hypervisor.image_ref = router_ios_image
        hypervisor.increase_memory_load(router_ram)
        return hypervisor

    def unallocate_hypervisor_for_router(self, router):
        """
        Unallocates a Dynamips hypervisor for a specific router.

        :param router: Router instance
        """

        hypervisor = router.hypervisor
        hypervisor.decrease_memory_load(router.ram)

        if hypervisor.memory_load < 0:
            log.warn("hypervisor {}:{} has a memory load below 0 ({})".format(hypervisor.host,
                                                                              hypervisor.port,
                                                                              hypervisor.memory_load))
            #hypervisor.memory_load = 0

        # memory load at 0MB and no devices managed anymore...
        # let's stop this hypervisor
        if hypervisor.memory_load == 0 and not hypervisor.devices:
            hypervisor.stop()
            self._hypervisors.remove(hypervisor)

    def allocate_hypervisor_for_simulated_device(self):
        """
        Allocates a Dynamips hypervisor for a specific Dynamips simulated device.

        :returns: the allocated hypervisor instance
        """

        # For now always allocate the first hypervisor available,
        # in the future we could randomly allocate.

        if self._hypervisors:
            return self._hypervisors[0]

        # no hypervisor, let's start one!
        return self.start_new_hypervisor()

    def unallocate_hypervisor_for_simulated_device(self, device):
        """
        Unallocates a Dynamips hypervisor for a specific Dynamips simulated device.

        :param device: device instance
        """

        hypervisor = device.hypervisor
        if not hypervisor.devices:
            hypervisor.stop()
            self._hypervisors.remove(hypervisor)

    def stop_all_hypervisors(self):
        """
        Stops all hypervisors.
        """

        for hypervisor in self._hypervisors:
            hypervisor.stop()
        self._hypervisors = []