gns3-server 3.0.0__py3-none-any.whl

gns3server/compute/builtin/nodes/ethernet_hub.py

@@ -0,0 +1,104 @@
+#
+# 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 asyncio
+
+from ...base_node import BaseNode
+
+import logging
+
+log = logging.getLogger(__name__)
+
+
+class EthernetHub(BaseNode):
+
+    """
+    Ethernet hub
+
+    :param name: name for this hub
+    :param node_id: Node identifier
+    :param project: Project instance
+    :param manager: Parent VM Manager
+    """
+
+    def __init__(self, name, node_id, project, manager):
+
+        super().__init__(name, node_id, project, manager)
+
+    def asdict(self):
+
+        return {
+            "name": self.name,
+            "usage": self.usage,
+            "node_id": self.id,
+            "project_id": self.project.id
+        }
+
+    async def create(self):
+        """
+        Creates this hub.
+        """
+
+        super().create()
+        log.info(f'Ethernet hub "{self._name}" [{self._id}] has been created')
+
+    async def delete(self):
+        """
+        Deletes this hub.
+        """
+
+        raise NotImplementedError()
+
+    async def add_nio(self, nio, port_number):
+        """
+        Adds a NIO as new port on this hub.
+
+        :param nio: NIO instance to add
+        :param port_number: port to allocate for the NIO
+        """
+
+        raise NotImplementedError()
+
+    async def remove_nio(self, port_number):
+        """
+        Removes the specified NIO as member of this hub.
+
+        :param port_number: allocated port number
+
+        :returns: the NIO that was bound to the allocated port
+        """
+
+        raise NotImplementedError()
+
+    async def start_capture(self, port_number, output_file, data_link_type="DLT_EN10MB"):
+        """
+        Starts a packet capture.
+
+        :param port_number: allocated port number
+        :param output_file: PCAP destination file for the capture
+        :param data_link_type: PCAP data link type (DLT_*), default is DLT_EN10MB
+        """
+
+        raise NotImplementedError()
+
+    async def stop_capture(self, port_number):
+        """
+        Stops a packet capture.
+
+        :param port_number: allocated port number
+        """
+
+        raise NotImplementedError()

gns3server/compute/builtin/nodes/ethernet_switch.py

@@ -0,0 +1,104 @@
+#
+# 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 asyncio
+
+from ...base_node import BaseNode
+
+import logging
+
+log = logging.getLogger(__name__)
+
+
+class EthernetSwitch(BaseNode):
+
+    """
+    Ethernet switch.
+
+    :param name: name for this switch
+    :param node_id: Node identifier
+    :param project: Project instance
+    :param manager: Parent VM Manager
+    """
+
+    def __init__(self, name, node_id, project, manager):
+
+        super().__init__(name, node_id, project, manager)
+
+    def asdict(self):
+
+        return {
+            "name": self.name,
+            "usage": self.usage,
+            "node_id": self.id,
+            "project_id": self.project.id
+        }
+
+    async def create(self):
+        """
+        Creates this switch.
+        """
+
+        super().create()
+        log.info(f'Ethernet switch "{self._name}" [{self._id}] has been created')
+
+    async def delete(self):
+        """
+        Deletes this switch.
+        """
+
+        raise NotImplementedError()
+
+    async def add_nio(self, nio, port_number):
+        """
+        Adds a NIO as new port on this switch.
+
+        :param nio: NIO instance to add
+        :param port_number: port to allocate for the NIO
+        """
+
+        raise NotImplementedError()
+
+    async def remove_nio(self, port_number):
+        """
+        Removes the specified NIO as member of this switch.
+
+        :param port_number: allocated port number
+
+        :returns: the NIO that was bound to the allocated port
+        """
+
+        raise NotImplementedError()
+
+    async def start_capture(self, port_number, output_file, data_link_type="DLT_EN10MB"):
+        """
+        Starts a packet capture.
+
+        :param port_number: allocated port number
+        :param output_file: PCAP destination file for the capture
+        :param data_link_type: PCAP data link type (DLT_*), default is DLT_EN10MB
+        """
+
+        raise NotImplementedError()
+
+    async def stop_capture(self, port_number):
+        """
+        Stops a packet capture.
+
+        :param port_number: allocated port number
+        """
+
+        raise NotImplementedError()

gns3server/compute/builtin/nodes/nat.py

@@ -0,0 +1,97 @@
+#!/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 sys
+
+from .cloud import Cloud
+from ...error import NodeError
+
+import gns3server.utils.interfaces
+from gns3server.config import Config
+
+import logging
+
+log = logging.getLogger(__name__)
+
+
+class Nat(Cloud):
+    """
+    A portable and pre-configured node allowing topologies to get a
+    NAT access.
+    """
+
+    def __init__(self, name, node_id, project, manager, ports=None):
+
+        allowed_interfaces = Config.instance().settings.Server.allowed_interfaces
+        if allowed_interfaces:
+            allowed_interfaces = allowed_interfaces.split(',')
+        if sys.platform.startswith("linux"):
+            nat_interface = Config.instance().settings.Server.default_nat_interface
+            if not nat_interface:
+                nat_interface = "virbr0"
+            if allowed_interfaces and nat_interface not in allowed_interfaces:
+                raise NodeError("NAT interface {} is not allowed be used on this server. "
+                                "Please check the server configuration file.".format(nat_interface))
+            if nat_interface not in [interface["name"] for interface in gns3server.utils.interfaces.interfaces()]:
+                raise NodeError(f"NAT interface {nat_interface} is missing, please install libvirt")
+            interface = nat_interface
+        else:
+            nat_interface = Config.instance().settings.Server.default_nat_interface
+            if not nat_interface:
+                nat_interface = "vmnet8"
+            if allowed_interfaces and nat_interface not in allowed_interfaces:
+                raise NodeError("NAT interface {} is not allowed be used on this server. "
+                                "Please check the server configuration file.".format(nat_interface))
+            interfaces = list(
+                filter(
+                    lambda x: nat_interface in x.lower(),
+                    [interface["name"] for interface in gns3server.utils.interfaces.interfaces()],
+                )
+            )
+            if not len(interfaces):
+                raise NodeError(
+                    f"NAT interface {nat_interface} is missing. "
+                    f"You need to install VMware or use the NAT node on GNS3 VM"
+                )
+            interface = interfaces[0]  # take the first available interface containing the vmnet8 name
+
+        log.info(f"NAT node '{name}' configured to use NAT interface '{interface}'")
+        ports = [{"name": "nat0", "type": "ethernet", "interface": interface, "port_number": 0}]
+        super().__init__(name, node_id, project, manager, ports=ports)
+
+    @property
+    def ports_mapping(self):
+        return self._ports_mapping
+
+    @ports_mapping.setter
+    def ports_mapping(self, ports):
+        # It's not allowed to change it
+        pass
+
+    @classmethod
+    def is_supported(self):
+        return True
+
+    def asdict(self):
+        return {
+            "name": self.name,
+            "usage": self.usage,
+            "node_id": self.id,
+            "project_id": self.project.id,
+            "status": "started",
+            "ports_mapping": self.ports_mapping,
+        }

gns3server/compute/compute_error.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+#
+# Copyright (C) 2020 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/>.
+
+
+class ComputeError(Exception):
+    def __init__(self, message: str):
+        super().__init__()
+        self._message = message
+
+    def __repr__(self):
+        return self._message
+
+    def __str__(self):
+        return self._message
+
+
+class ComputeNotFoundError(ComputeError):
+    def __init__(self, message: str):
+        super().__init__(message)
+
+
+class ComputeUnauthorizedError(ComputeError):
+    def __init__(self, message: str):
+        super().__init__(message)
+
+
+class ComputeForbiddenError(ComputeError):
+    def __init__(self, message: str):
+        super().__init__(message)
+
+
+class ComputeTimeoutError(ComputeError):
+    def __init__(self, message: str):
+        super().__init__(message)

gns3server/compute/docker/__init__.py

@@ -0,0 +1,320 @@
+#
+# 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/>.
+
+"""
+Docker server module.
+"""
+
+import os
+import sys
+import json
+import asyncio
+import logging
+import aiohttp
+import shutil
+import platformdirs
+
+from gns3server.utils import parse_version
+from gns3server.config import Config
+from gns3server.utils.asyncio import locking
+from gns3server.compute.base_manager import BaseManager
+from gns3server.compute.docker.docker_vm import DockerVM
+from gns3server.compute.docker.docker_error import DockerError, DockerHttp304Error, DockerHttp404Error
+
+log = logging.getLogger(__name__)
+
+
+# Be careful to keep it consistent
+DOCKER_MINIMUM_API_VERSION = "1.25"
+DOCKER_MINIMUM_VERSION = "1.13"
+DOCKER_PREFERRED_API_VERSION = "1.30"
+CHUNK_SIZE = 1024 * 8  # 8KB
+
+
+class Docker(BaseManager):
+
+    _NODE_CLASS = DockerVM
+
+    def __init__(self):
+
+        super().__init__()
+        self._server_url = "/var/run/docker.sock"
+        self._connected = False
+        # Allow locking during ubridge operations
+        self.ubridge_lock = asyncio.Lock()
+        self._connector = None
+        self._session = None
+        self._api_version = DOCKER_MINIMUM_API_VERSION
+
+    @staticmethod
+    async def install_busybox(dst_dir):
+
+        dst_busybox = os.path.join(dst_dir, "bin", "busybox")
+        if os.path.isfile(dst_busybox):
+            return
+        for busybox_exec in ("busybox-static", "busybox.static", "busybox"):
+            busybox_path = shutil.which(busybox_exec)
+            if busybox_path:
+                try:
+                    # check that busybox is statically linked
+                    # (dynamically linked busybox will fail to run in a container)
+                    proc = await asyncio.create_subprocess_exec(
+                        "ldd",
+                        busybox_path,
+                        stdout=asyncio.subprocess.PIPE,
+                        stderr=asyncio.subprocess.DEVNULL
+                    )
+                    stdout, _ = await proc.communicate()
+                    if proc.returncode == 1:
+                        # ldd returns 1 if the file is not a dynamic executable
+                        log.info(f"Installing busybox from '{busybox_path}' to '{dst_busybox}'")
+                        shutil.copy2(busybox_path, dst_busybox, follow_symlinks=True)
+                        return
+                    else:
+                        log.warning(f"Busybox '{busybox_path}' is dynamically linked\n"
+                                    f"{stdout.decode('utf-8', errors='ignore').strip()}")
+                except OSError as e:
+                    raise DockerError(f"Could not install busybox: {e}")
+        raise DockerError("No busybox executable could be found, please install busybox (apt install busybox-static on Debian/Ubuntu) and make sure it is in your PATH")
+
+    @staticmethod
+    def resources_path():
+        """
+        Get the Docker resources storage directory
+        """
+
+        resources_path = Config.instance().settings.Server.resources_path
+        if not resources_path:
+            appname = vendor = "GNS3"
+            resources_path = platformdirs.user_data_dir(appname, vendor, roaming=True)
+        else:
+            resources_path = os.path.expanduser(resources_path)
+        docker_resources_dir = os.path.join(resources_path, "docker")
+        os.makedirs(docker_resources_dir, exist_ok=True)
+        return docker_resources_dir
+
+    async def install_resources(self):
+        """
+        Copy the necessary resources to a writable location and install busybox
+        """
+
+        try:
+            dst_path = self.resources_path()
+            log.info(f"Installing Docker resources in '{dst_path}'")
+            from gns3server.controller import Controller
+            Controller.instance().install_resource_files(dst_path, "compute/docker/resources")
+            await self.install_busybox(dst_path)
+        except OSError as e:
+            raise DockerError(f"Could not install Docker resources to {dst_path}: {e}")
+
+    async def _check_connection(self):
+
+        if not self._connected:
+            try:
+                self._connected = True
+                version = await self.query("GET", "version")
+            except (aiohttp.ClientError, FileNotFoundError):
+                self._connected = False
+                raise DockerError("Can't connect to docker daemon")
+
+            docker_version = parse_version(version["ApiVersion"])
+
+            if docker_version < parse_version(DOCKER_MINIMUM_API_VERSION):
+                raise DockerError(
+                    f"Docker version is {version['Version']}. "
+                    f"GNS3 requires a minimum version of {DOCKER_MINIMUM_VERSION}"
+                )
+
+            preferred_api_version = parse_version(DOCKER_PREFERRED_API_VERSION)
+            if docker_version >= preferred_api_version:
+                self._api_version = DOCKER_PREFERRED_API_VERSION
+
+    def connector(self):
+
+        if self._connector is None or self._connector.closed:
+            if not sys.platform.startswith("linux"):
+                raise DockerError("Docker is supported only on Linux")
+            try:
+                self._connector = aiohttp.connector.UnixConnector(self._server_url, limit=None)
+            except (aiohttp.ClientError, FileNotFoundError):
+                raise DockerError("Can't connect to docker daemon")
+        return self._connector
+
+    async def unload(self):
+
+        await super().unload()
+        if self._connected:
+            if self._connector and not self._connector.closed:
+                await self._connector.close()
+        if self._session and not self._session.closed:
+            await self._session.close()
+
+    async def query(self, method, path, data={}, params={}):
+        """
+        Makes a query to the Docker daemon and decode the request
+
+        :param method: HTTP method
+        :param path: Endpoint in API
+        :param data: Dictionary with the body. Will be transformed to a JSON
+        :param params: Parameters added as a query arg
+        """
+
+        response = await self.http_query(method, path, data=data, params=params)
+        body = await response.read()
+        response.close()
+        if body and len(body):
+            if response.headers.get('CONTENT-TYPE') == 'application/json':
+                body = json.loads(body.decode("utf-8"))
+            else:
+                body = body.decode("utf-8")
+        log.debug("Query Docker %s %s params=%s data=%s Response: %s", method, path, params, data, body)
+        return body
+
+    async def http_query(self, method, path, data={}, params={}, timeout=300):
+        """
+        Makes a query to the docker daemon
+
+        :param method: HTTP method
+        :param path: Endpoint in API
+        :param data: Dictionnary with the body. Will be transformed to a JSON
+        :param params: Parameters added as a query arg
+        :param timeout: Timeout
+        :returns: HTTP response
+        """
+
+        data = json.dumps(data)
+        if timeout is None:
+            timeout = 60 * 60 * 24 * 31  # One month timeout
+
+        if path == 'version':
+            url = "http://docker/v1.24/" + path
+        else:
+            url = "http://docker/v" + DOCKER_MINIMUM_API_VERSION + "/" + path
+        try:
+            if path != "version":  # version is use by check connection
+                await self._check_connection()
+            if self._session is None or self._session.closed:
+                connector = self.connector()
+                self._session = aiohttp.ClientSession(connector=connector)
+            response = await self._session.request(
+                method,
+                url,
+                params=params,
+                data=data,
+                headers={
+                    "content-type": "application/json",
+                },
+                timeout=timeout,
+            )
+        except aiohttp.ClientError as e:
+            raise DockerError(f"Docker has returned an error: {e}")
+        except asyncio.TimeoutError:
+            raise DockerError("Docker timeout " + method + " " + path)
+        if response.status >= 300:
+            body = await response.read()
+            try:
+                body = json.loads(body.decode("utf-8"))["message"]
+            except ValueError:
+                pass
+            log.debug(f"Query Docker {method} {path} params={params} data={data} Response: {body}")
+            if response.status == 304:
+                raise DockerHttp304Error(f"Docker has returned an error: {response.status} {body}")
+            elif response.status == 404:
+                raise DockerHttp404Error(f"Docker has returned an error: {response.status} {body}")
+            else:
+                raise DockerError(f"Docker has returned an error: {response.status} {body}")
+        return response
+
+    async def websocket_query(self, path, params={}):
+        """
+        Opens a websocket connection
+
+        :param path: Endpoint in API
+        :param params: Parameters added as a query arg
+        :returns: Websocket
+        """
+
+        url = "http://docker/v" + self._api_version + "/" + path
+        connection = await self._session.ws_connect(url, origin="http://docker", autoping=True)
+        return connection
+
+    @locking
+    async def pull_image(self, image, progress_callback=None):
+        """
+        Pulls an image from the Docker repository
+
+        :params image: Image name
+        :params progress_callback: A function that receive a log message about image download progress
+        """
+
+        try:
+            await self.query("GET", f"images/{image}/json")
+            return  # We already have the image skip the download
+        except DockerHttp404Error:
+            pass
+
+        if progress_callback:
+            progress_callback(f"Pulling '{image}' from docker hub")
+        try:
+            response = await self.http_query("POST", "images/create", params={"fromImage": image}, timeout=None)
+        except DockerError as e:
+            raise DockerError(
+                f"Could not pull the '{image}' image from Docker Hub, "
+                f"please check your Internet connection (original error: {e})"
+            )
+        # The pull api will stream status via an HTTP JSON stream
+        content = ""
+        while True:
+            try:
+                chunk = await response.content.read(CHUNK_SIZE)
+            except aiohttp.ServerDisconnectedError:
+                log.error(f"Disconnected from server while pulling Docker image '{image}' from docker hub")
+                break
+            except asyncio.TimeoutError:
+                log.error(f"Timeout while pulling Docker image '{image}' from docker hub")
+                break
+            if not chunk:
+                break
+            content += chunk.decode("utf-8")
+
+            try:
+                while True:
+                    content = content.lstrip(" \r\n\t")
+                    answer, index = json.JSONDecoder().raw_decode(content)
+                    if "progress" in answer and progress_callback:
+                        progress_callback("Pulling image {}:{}: {}".format(image, answer["id"], answer["progress"]))
+                    content = content[index:]
+            except ValueError:  # Partial JSON
+                pass
+        response.close()
+        if progress_callback:
+            progress_callback(f"Success pulling image {image}")
+
+    async def list_images(self):
+        """
+        Gets Docker image list.
+
+        :returns: list of dicts
+        :rtype: list
+        """
+
+        images = []
+        for image in await self.query("GET", "images/json", params={"all": 0}):
+            if image["RepoTags"]:
+                for tag in image["RepoTags"]:
+                    if tag != "<none>:<none>":
+                        images.append({"image": tag})
+        return sorted(images, key=lambda i: i["image"])