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

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

"""
Dynamips server module.
"""

import sys
import os
import base64
import tempfile
import shutil
import glob
import socket
from gns3server.config import Config

# from .hypervisor import Hypervisor
# from .hypervisor_manager import HypervisorManager
# from .dynamips_error import DynamipsError
#
# # Nodes
# from .nodes.router import Router
# from .nodes.c1700 import C1700
# from .nodes.c2600 import C2600
# from .nodes.c2691 import C2691
# from .nodes.c3600 import C3600
# from .nodes.c3725 import C3725
# from .nodes.c3745 import C3745
# from .nodes.c7200 import C7200
# from .nodes.bridge import Bridge
# from .nodes.ethernet_switch import EthernetSwitch
# from .nodes.atm_switch import ATMSwitch
# from .nodes.atm_bridge import ATMBridge
# from .nodes.frame_relay_switch import FrameRelaySwitch
# from .nodes.hub import Hub
#
# # Adapters
# from .adapters.c7200_io_2fe import C7200_IO_2FE
# from .adapters.c7200_io_fe import C7200_IO_FE
# from .adapters.c7200_io_ge_e import C7200_IO_GE_E
# from .adapters.nm_16esw import NM_16ESW
# from .adapters.nm_1e import NM_1E
# from .adapters.nm_1fe_tx import NM_1FE_TX
# from .adapters.nm_4e import NM_4E
# from .adapters.nm_4t import NM_4T
# from .adapters.pa_2fe_tx import PA_2FE_TX
# from .adapters.pa_4e import PA_4E
# from .adapters.pa_4t import PA_4T
# from .adapters.pa_8e import PA_8E
# from .adapters.pa_8t import PA_8T
# from .adapters.pa_a1 import PA_A1
# from .adapters.pa_fe_tx import PA_FE_TX
# from .adapters.pa_ge import PA_GE
# from .adapters.pa_pos_oc3 import PA_POS_OC3
# from .adapters.wic_1t import WIC_1T
# from .adapters.wic_2t import WIC_2T
# from .adapters.wic_1enet import WIC_1ENET
#
# # NIOs
# from .nios.nio_udp import NIO_UDP
# from .nios.nio_udp_auto import NIO_UDP_auto
# from .nios.nio_unix import NIO_UNIX
# from .nios.nio_vde import NIO_VDE
# from .nios.nio_tap import NIO_TAP
# from .nios.nio_generic_ethernet import NIO_GenericEthernet
# from .nios.nio_linux_ethernet import NIO_LinuxEthernet
# from .nios.nio_fifo import NIO_FIFO
# from .nios.nio_mcast import NIO_Mcast
# from .nios.nio_null import NIO_Null
#
# from .backends import vm
# from .backends import ethsw
# from .backends import ethhub
# from .backends import frsw
# from .backends import atmsw

import time
import asyncio
import logging

log = logging.getLogger(__name__)

from pkg_resources import parse_version
from ..base_manager import BaseManager
from .dynamips_error import DynamipsError
from .hypervisor import Hypervisor
from .nodes.router import Router
from .dynamips_vm import DynamipsVM


class Dynamips(BaseManager):

    _VM_CLASS = DynamipsVM

    def __init__(self):

        super().__init__()
        self._dynamips_path = None

        # FIXME: temporary
        self._working_dir = "/tmp"
        self._dynamips_path = "/usr/bin/dynamips"

    def find_dynamips(self):

        # look for Dynamips
        dynamips_path = self.config.get_section_config("Dynamips").get("dynamips_path")
        if not dynamips_path:
            dynamips_path = shutil.which("dynamips")

        if not dynamips_path:
            raise DynamipsError("Could not find Dynamips")
        if not os.path.isfile(dynamips_path):
            raise DynamipsError("Dynamips {} is not accessible".format(dynamips_path))
        if not os.access(dynamips_path, os.X_OK):
            raise DynamipsError("Dynamips is not executable")

        self._dynamips_path = dynamips_path
        return dynamips_path

    @asyncio.coroutine
    def _wait_for_hypervisor(self, host, port, timeout=10.0):
        """
        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
        """

        begin = time.time()
        connection_success = False
        last_exception = None
        while time.time() - begin < timeout:
            yield from asyncio.sleep(0.01)
            try:
                _, writer = yield from asyncio.open_connection(host, port)
                writer.close()
            except OSError as e:
                last_exception = e
                continue
            connection_success = True
            break

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

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

        :returns: the new hypervisor instance
        """

        try:
            # let the OS find an unused port for the Dynamips hypervisor
            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
                sock.bind(("127.0.0.1", 0))
                port = sock.getsockname()[1]
        except OSError as e:
            raise DynamipsError("Could not find free port for the Dynamips hypervisor: {}".format(e))

        hypervisor = Hypervisor(self._dynamips_path, self._working_dir, "127.0.0.1", port)

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

        yield from self._wait_for_hypervisor("127.0.0.1", port)
        log.info("Hypervisor {}:{} has successfully started".format(hypervisor.host, hypervisor.port))

        yield from 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))

        return hypervisor


# class Dynamips(IModule):
#     """
#     Dynamips module.
#
#     :param name: module name
#     :param args: arguments for the module
#     :param kwargs: named arguments for the module
#     """
#
#     def stop(self, signum=None):
#         """
#         Properly stops the module.
#
#         :param signum: signal number (if called by the signal handler)
#         """
#
#         if not sys.platform.startswith("win32"):
#             self._callback.stop()
#
#         # automatically save configs for all router instances
#         for router_id in self._routers:
#             router = self._routers[router_id]
#             try:
#                 router.save_configs()
#             except DynamipsError:
#                 continue
#
#         # stop all Dynamips hypervisors
#         if self._hypervisor_manager:
#             self._hypervisor_manager.stop_all_hypervisors()
#
#         self.delete_dynamips_files()
#         IModule.stop(self, signum)  # this will stop the I/O loop
#
#     def get_device_instance(self, device_id, instance_dict):
#         """
#         Returns a device instance.
#
#         :param device_id: device identifier
#         :param instance_dict: dictionary containing the instances
#
#         :returns: device instance
#         """
#
#         if device_id not in instance_dict:
#             log.debug("device ID {} doesn't exist".format(device_id), exc_info=1)
#             self.send_custom_error("Device ID {} doesn't exist".format(device_id))
#             return None
#         return instance_dict[device_id]
#
#     def delete_dynamips_files(self):
#         """
#         Deletes useless Dynamips files from the working directory
#         """
#
#         files = glob.glob(os.path.join(self._working_dir, "dynamips", "*.ghost"))
#         files += glob.glob(os.path.join(self._working_dir, "dynamips", "*_lock"))
#         files += glob.glob(os.path.join(self._working_dir, "dynamips", "ilt_*"))
#         files += glob.glob(os.path.join(self._working_dir, "dynamips", "c[0-9][0-9][0-9][0-9]_*_rommon_vars"))
#         files += glob.glob(os.path.join(self._working_dir, "dynamips", "c[0-9][0-9][0-9][0-9]_*_ssa"))
#         for file in files:
#             try:
#                 log.debug("deleting file {}".format(file))
#                 os.remove(file)
#             except OSError as e:
#                 log.warn("could not delete file {}: {}".format(file, e))
#                 continue
#
#     @IModule.route("dynamips.reset")
#     def reset(self, request=None):
#         """
#         Resets the module (JSON-RPC notification).
#
#         :param request: JSON request (not used)
#         """
#
#         # automatically save configs for all router instances
#         for router_id in self._routers:
#             router = self._routers[router_id]
#             try:
#                 router.save_configs()
#             except DynamipsError:
#                 continue
#
#         # stop all Dynamips hypervisors
#         if self._hypervisor_manager:
#             self._hypervisor_manager.stop_all_hypervisors()
#
#         # resets the instance counters
#         Router.reset()
#         EthernetSwitch.reset()
#         Hub.reset()
#         FrameRelaySwitch.reset()
#         ATMSwitch.reset()
#         NIO_UDP.reset()
#         NIO_UDP_auto.reset()
#         NIO_UNIX.reset()
#         NIO_VDE.reset()
#         NIO_TAP.reset()
#         NIO_GenericEthernet.reset()
#         NIO_LinuxEthernet.reset()
#         NIO_FIFO.reset()
#         NIO_Mcast.reset()
#         NIO_Null.reset()
#
#         self._routers.clear()
#         self._ethernet_switches.clear()
#         self._frame_relay_switches.clear()
#         self._atm_switches.clear()
#
#         self.delete_dynamips_files()
#
#         self._hypervisor_manager = None
#         self._working_dir = self._projects_dir
#         log.info("dynamips module has been reset")
#
#     def start_hypervisor_manager(self):
#         """
#         Starts the hypervisor manager.
#         """
#
#         # check if Dynamips path exists
#         if not os.path.isfile(self._dynamips):
#             raise DynamipsError("Dynamips executable {} doesn't exist".format(self._dynamips))
#
#         # check if Dynamips is executable
#         if not os.access(self._dynamips, os.X_OK):
#             raise DynamipsError("Dynamips {} is not executable".format(self._dynamips))
#
#         workdir = os.path.join(self._working_dir, "dynamips")
#         try:
#             os.makedirs(workdir)
#         except FileExistsError:
#             pass
#         except OSError as e:
#             raise DynamipsError("Could not create working directory {}".format(e))
#
#         # check if the working directory is writable
#         if not os.access(workdir, os.W_OK):
#             raise DynamipsError("Cannot write to working directory {}".format(workdir))
#
#         log.info("starting the hypervisor manager with Dynamips working directory set to '{}'".format(workdir))
#         self._hypervisor_manager = HypervisorManager(self._dynamips, workdir, self._host, self._console_host)
#
#         for name, value in self._hypervisor_manager_settings.items():
#             if hasattr(self._hypervisor_manager, name) and getattr(self._hypervisor_manager, name) != value:
#                 setattr(self._hypervisor_manager, name, value)
#
#     @IModule.route("dynamips.settings")
#     def settings(self, request):
#         """
#         Set or update settings.
#
#         Optional request parameters:
#         - path (path to the Dynamips executable)
#         - working_dir (path to a working directory)
#         - project_name
#
#         :param request: JSON request
#         """
#
#         if request is None:
#             self.send_param_error()
#             return
#
#         log.debug("received request {}".format(request))
#
#         #TODO: JSON schema validation
#         if not self._hypervisor_manager:
#
#             if "path" in request:
#                 self._dynamips = request.pop("path")
#
#             if "working_dir" in request:
#                 self._working_dir = request.pop("working_dir")
#                 log.info("this server is local")
#             else:
#                 self._working_dir = os.path.join(self._projects_dir, request["project_name"])
#                 log.info("this server is remote with working directory path to {}".format(self._working_dir))
#
#             self._hypervisor_manager_settings = request
#
#         else:
#             if "project_name" in request:
#                 # for remote server
#                 new_working_dir = os.path.join(self._projects_dir, request["project_name"])
#
#                 if self._projects_dir != self._working_dir != new_working_dir:
#
#                     # trick to avoid file locks by Dynamips on Windows
#                     if sys.platform.startswith("win"):
#                         self._hypervisor_manager.working_dir = tempfile.gettempdir()
#
#                     if not os.path.isdir(new_working_dir):
#                         try:
#                             self.delete_dynamips_files()
#                             shutil.move(self._working_dir, new_working_dir)
#                         except OSError as e:
#                             log.error("could not move working directory from {} to {}: {}".format(self._working_dir,
#                                                                                                   new_working_dir,
#                                                                                                   e))
#                             return
#
#             elif "working_dir" in request:
#                 # for local server
#                 new_working_dir = request.pop("working_dir")
#
#             try:
#                 self._hypervisor_manager.working_dir = new_working_dir
#             except DynamipsError as e:
#                 log.error("could not change working directory: {}".format(e))
#                 return
#
#             self._working_dir = new_working_dir
#
#             # apply settings to the hypervisor manager
#             for name, value in request.items():
#                 if hasattr(self._hypervisor_manager, name) and getattr(self._hypervisor_manager, name) != value:
#                     setattr(self._hypervisor_manager, name, value)
#
#     @IModule.route("dynamips.echo")
#     def echo(self, request):
#         """
#         Echo end point for testing purposes.
#
#         :param request: JSON request
#         """
#
#         if request is None:
#             self.send_param_error()
#         else:
#             log.debug("received request {}".format(request))
#             self.send_response(request)
#
#     def create_nio(self, node, request):
#         """
#         Creates a new NIO.
#
#         :param node: node requesting the NIO
#         :param request: the original request with the
#         necessary information to create the NIO
#
#         :returns: a NIO object
#         """
#
#         nio = None
#         if request["nio"]["type"] == "nio_udp":
#             lport = request["nio"]["lport"]
#             rhost = request["nio"]["rhost"]
#             rport = request["nio"]["rport"]
#             try:
#                 #TODO: handle IPv6
#                 with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
#                     sock.connect((rhost, rport))
#             except OSError as e:
#                 raise DynamipsError("Could not create an UDP connection to {}:{}: {}".format(rhost, rport, e))
#             # check if we have an allocated NIO UDP auto
#             nio = node.hypervisor.get_nio_udp_auto(lport)
#             if not nio:
#                 # otherwise create an NIO UDP
#                 nio = NIO_UDP(node.hypervisor, lport, rhost, rport)
#             else:
#                 nio.connect(rhost, rport)
#         elif request["nio"]["type"] == "nio_generic_ethernet":
#             ethernet_device = request["nio"]["ethernet_device"]
#             if sys.platform.startswith("win"):
#                 # replace the interface name by the GUID on Windows
#                 interfaces = get_windows_interfaces()
#                 npf_interface = None
#                 for interface in interfaces:
#                     if interface["name"] == ethernet_device:
#                         npf_interface = interface["id"]
#                 if not npf_interface:
#                     raise DynamipsError("Could not find interface {} on this host".format(ethernet_device))
#                 else:
#                     ethernet_device = npf_interface
#             nio = NIO_GenericEthernet(node.hypervisor, ethernet_device)
#         elif request["nio"]["type"] == "nio_linux_ethernet":
#             if sys.platform.startswith("win"):
#                 raise DynamipsError("This NIO type is not supported on Windows")
#             ethernet_device = request["nio"]["ethernet_device"]
#             nio = NIO_LinuxEthernet(node.hypervisor, ethernet_device)
#         elif request["nio"]["type"] == "nio_tap":
#             tap_device = request["nio"]["tap_device"]
#             nio = NIO_TAP(node.hypervisor, tap_device)
#         elif request["nio"]["type"] == "nio_unix":
#             local_file = request["nio"]["local_file"]
#             remote_file = request["nio"]["remote_file"]
#             nio = NIO_UNIX(node.hypervisor, local_file, remote_file)
#         elif request["nio"]["type"] == "nio_vde":
#             control_file = request["nio"]["control_file"]
#             local_file = request["nio"]["local_file"]
#             nio = NIO_VDE(node.hypervisor, control_file, local_file)
#         elif request["nio"]["type"] == "nio_null":
#             nio = NIO_Null(node.hypervisor)
#         return nio
#
#     def allocate_udp_port(self, node):
#         """
#         Allocates a UDP port in order to create an UDP NIO.
#
#         :param node: the node that needs to allocate an UDP port
#
#         :returns: dictionary with the allocated host/port info
#         """
#
#         port = node.hypervisor.allocate_udp_port()
#         host = node.hypervisor.host
#
#         log.info("{} [id={}] has allocated UDP port {} with host {}".format(node.name,
#                                                                             node.id,
#                                                                             port,
#                                                                             host))
#         response = {"lport": port}
#         return response
#
#     def set_ghost_ios(self, router):
#         """
#         Manages Ghost IOS support.
#
#         :param router: Router instance
#         """
#
#         if not router.mmap:
#             raise DynamipsError("mmap support is required to enable ghost IOS support")
#
#         ghost_instance = router.formatted_ghost_file()
#         all_ghosts = []
#
#         # search of an existing ghost instance across all hypervisors
#         for hypervisor in self._hypervisor_manager.hypervisors:
#             all_ghosts.extend(hypervisor.ghosts)
#
#         if ghost_instance not in all_ghosts:
#             # create a new ghost IOS instance
#             ghost = Router(router.hypervisor, "ghost-" + ghost_instance, router.platform, ghost_flag=True)
#             ghost.image = router.image
#             # for 7200s, the NPE must be set when using an NPE-G2.
#             if router.platform == "c7200":
#                 ghost.npe = router.npe
#             ghost.ghost_status = 1
#             ghost.ghost_file = ghost_instance
#             ghost.ram = router.ram
#             try:
#                 ghost.start()
#                 ghost.stop()
#             except DynamipsError:
#                 raise
#             finally:
#                 ghost.clean_delete()
#
#         if router.ghost_file != ghost_instance:
#             # set the ghost file to the router
#             router.ghost_status = 2
#             router.ghost_file = ghost_instance
#
#     def create_config_from_file(self, local_base_config, router, destination_config_path):
#         """
#         Creates a config file from a local base config
#
#         :param local_base_config: path the a local base config
#         :param router: router instance
#         :param destination_config_path: path to the destination config file
#
#         :returns: relative path to the created config file
#         """
#
#         log.info("creating config file {} from {}".format(destination_config_path, local_base_config))
#         config_path = destination_config_path
#         config_dir = os.path.dirname(destination_config_path)
#         try:
#             os.makedirs(config_dir)
#         except FileExistsError:
#             pass
#         except OSError as e:
#             raise DynamipsError("Could not create configs directory: {}".format(e))
#
#         try:
#             with open(local_base_config, "r", errors="replace") as f:
#                 config = f.read()
#             with open(config_path, "w") as f:
#                 config = "!\n" + config.replace("\r", "")
#                 config = config.replace('%h', router.name)
#                 f.write(config)
#         except OSError as e:
#             raise DynamipsError("Could not save the configuration from {} to {}: {}".format(local_base_config, config_path, e))
#         return "configs" + os.sep + os.path.basename(config_path)
#
#     def create_config_from_base64(self, config_base64, router, destination_config_path):
#         """
#         Creates a config file from a base64 encoded config.
#
#         :param config_base64: base64 encoded config
#         :param router: router instance
#         :param destination_config_path: path to the destination config file
#
#         :returns: relative path to the created config file
#         """
#
#         log.info("creating config file {} from base64".format(destination_config_path))
#         config = base64.decodebytes(config_base64.encode("utf-8")).decode("utf-8")
#         config = "!\n" + config.replace("\r", "")
#         config = config.replace('%h', router.name)
#         config_dir = os.path.dirname(destination_config_path)
#         try:
#             os.makedirs(config_dir)
#         except FileExistsError:
#             pass
#         except OSError as e:
#             raise DynamipsError("Could not create configs directory: {}".format(e))
#
#         config_path = destination_config_path
#         try:
#             with open(config_path, "w") as f:
#                 log.info("saving startup-config to {}".format(config_path))
#                 f.write(config)
#         except OSError as e:
#             raise DynamipsError("Could not save the configuration {}: {}".format(config_path, e))
#         return "configs" + os.sep + os.path.basename(config_path)