gns3-server/gns3server/controller/__init__.py

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

import os
import sys
import json
import asyncio
import aiohttp

from ..config import Config
from .project import Project
from .compute import Compute
from .notification import Notification
from ..version import __version__
from .topology import load_topology

import logging
log = logging.getLogger(__name__)


class Controller:
    """The controller is responsible to manage one or more compute servers"""

    def __init__(self):
        self._computes = {}
        self._projects = {}
        self._notification = Notification(self)

        if sys.platform.startswith("win"):
            config_path = os.path.join(os.path.expandvars("%APPDATA%"), "GNS3")
        else:
            config_path = os.path.join(os.path.expanduser("~"), ".config", "GNS3")
        self._config_file = os.path.join(config_path, "gns3_controller.conf")

        server_config = Config.instance().get_section_config("Server")
        if server_config.getboolean("local", False) is True:
            self._computes["local"] = Compute(compute_id="local",
                                              controller=self,
                                              protocol=server_config.get("protocol", "http"),
                                              host=server_config.get("host", "localhost"),
                                              port=server_config.getint("port", 3080),
                                              user=server_config.get("user", ""),
                                              password=server_config.get("password", ""))

    def save(self):
        """
        Save the controller configuration on disk
        """
        data = {"computes": [{"host": c.host,
                              "name": c.name,
                              "port": c.port,
                              "protocol": c.protocol,
                              "user": c.user,
                              "password": c.password,
                              "compute_id": c.id
                              } for c in self._computes.values()],
                "version": __version__}
        os.makedirs(os.path.dirname(self._config_file), exist_ok=True)
        with open(self._config_file, 'w+') as f:
            json.dump(data, f, indent=4)

    @asyncio.coroutine
    def load(self):
        """
        Reload the controller configuration from disk
        """
        if not os.path.exists(self._config_file):
            return
        try:
            with open(self._config_file) as f:
                data = json.load(f)
        except OSError as e:
            log.critical("Cannot load %s: %s", self._config_file, str(e))
            return
        for c in data["computes"]:
            yield from self.add_compute(**c)

        # Preload the list of projects from disk
        server_config = Config.instance().get_section_config("Server")
        projects_path = os.path.expanduser(server_config.get("projects_path", "~/GNS3/projects"))
        os.makedirs(projects_path, exist_ok=True)
        try:
            for project_path in os.listdir(projects_path):
                project_dir = os.path.join(projects_path, project_path)
                if os.path.isdir(project_dir):
                    for file in os.listdir(project_dir):
                        if file.endswith(".gns3"):
                            try:
                                yield from self.load_project(os.path.join(project_dir, file), load=False)
                            except aiohttp.web_exceptions.HTTPConflict:
                                pass  # Skip not compatible projects
        except OSError as e:
            log.error(str(e))

    def is_enabled(self):
        """
        :returns: whether the current instance is the controller
        of our GNS3 infrastructure.
        """
        return Config.instance().get_section_config("Server").getboolean("controller")

    @asyncio.coroutine
    def add_compute(self, **kwargs):
        """
        Add a server to the dictionary of compute servers controlled by this controller

        :param compute_id: Compute server identifier
        :param kwargs: See the documentation of Compute
        """
        compute_id = kwargs.pop("compute_id", None)
        if compute_id not in self._computes:

            # We disallow to create from the outside the
            if compute_id == 'local':
                return None

            compute = Compute(compute_id=compute_id, controller=self, **kwargs)
            self._computes[compute.id] = compute
            self.save()
            self.notification.emit("compute.created", compute.__json__())
            return compute
        else:
            self.notification.emit("compute.updated", self._computes[compute_id].__json__())
            return self._computes[compute_id]

    @asyncio.coroutine
    def delete_compute(self, compute_id):
        """
        Delete a compute node
        :param compute_id: Compute server identifier
        """
        compute = self.get_compute(compute_id)
        yield from compute.close()
        del self._computes[compute_id]
        self.save()
        self.notification.emit("compute.deleted", compute.__json__())

    @asyncio.coroutine
    def close(self):
        log.info("Close controller")
        for compute in self._computes.values():
            yield from compute.close()

    @property
    def notification(self):
        """
        The notification system
        """
        return self._notification

    @property
    def computes(self):
        """
        :returns: The dictionary of compute server managed by this controller
        """
        return self._computes

    def get_compute(self, compute_id):
        """
        Returns a compute server or raise a 404 error.
        """
        try:
            return self._computes[compute_id]
        except KeyError:
            raise aiohttp.web.HTTPNotFound(text="Compute ID {} doesn't exist".format(compute_id))

    @asyncio.coroutine
    def add_project(self, project_id=None, **kwargs):
        """
        Creates a project or returns an existing project

        :param kwargs: See the documentation of Project
        """
        if project_id not in self._projects:
            project = Project(project_id=project_id, controller=self, **kwargs)
            self._projects[project.id] = project
            return self._projects[project.id]
        return self._projects[project_id]

    def get_project(self, project_id):
        """
        Returns a compute server or raise a 404 error.
        """
        try:
            return self._projects[project_id]
        except KeyError:
            raise aiohttp.web.HTTPNotFound(text="Project ID {} doesn't exist".format(project_id))

    def remove_project(self, project):
        del self._projects[project.id]

    @asyncio.coroutine
    def load_project(self, path, load=True):
        """
        Load a project from a .gns3

        :param path: Path of the .gns3
        :param load: Load the topology
        """
        topo_data = load_topology(path)
        topology = topo_data.pop("topology")
        topo_data.pop("version")
        topo_data.pop("revision")
        topo_data.pop("type")

        project = yield from self.add_project(path=os.path.dirname(path), status="closed", filename=os.path.basename(path), **topo_data)
        if load:
            yield from project.open()
        return project

    @property
    def projects(self):
        """
        :returns: The dictionary of computes managed by GNS3
        """
        return self._projects

    @staticmethod
    def instance():
        """
        Singleton to return only on instance of Controller.

        :returns: instance of Controller
        """

        if not hasattr(Controller, '_instance') or Controller._instance is None:
            Controller._instance = Controller()
        return Controller._instance