gns3-server 3.0.0__py3-none-any.whl

gns3server/schemas/controller/topology.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python
+#
+# 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/>.
+
+#
+# This file contains the validation for checking a .gns3 file
+#
+
+from .computes import Compute
+from .drawings import Drawing
+from .links import Link
+from .nodes import Node
+
+from .projects import Supplier, Variable
+
+from pydantic import BaseModel, Field
+from typing import Optional, List
+from enum import Enum
+from uuid import UUID
+
+
+class TopologyType(str, Enum):
+
+    topology = "topology"
+
+
+class TopologyContent(BaseModel):
+
+    computes: List[Compute] = Field(..., description="List of computes")
+    drawings: List[Drawing] = Field(..., description="List of drawings")
+    links: List[Link] = Field(..., description="List of links")
+    nodes: List[Node] = Field(..., description="List of nodes")
+
+
+class Topology(BaseModel):
+
+    project_id: UUID = Field(..., description="Project UUID")
+    type: TopologyType = Field(..., description="Type of file. It's always topology")
+    revision: int = Field(..., description="Version of the .gns3 specification")
+    version: str = Field(..., description="Version of the GNS3 software which have update the file for the last time")
+    name: str = Field(..., description="Name of the project")
+    topology: TopologyContent = Field(..., description="Topology content")
+    auto_start: Optional[bool] = Field(None, description="Start the topology when opened")
+    auto_close: Optional[bool] = Field(None, description="Close the topology when no client is connected")
+    scene_height: Optional[int] = Field(None, description="Height of the drawing area")
+    scene_width: Optional[int] = Field(None, description="Width of the drawing area")
+    zoom: Optional[int] = Field(None, description="Zoom of the drawing area")
+    show_layers: Optional[bool] = Field(None, description="Show layers on the drawing area")
+    snap_to_grid: Optional[bool] = Field(None, description="Snap to grid on the drawing area")
+    show_grid: Optional[bool] = Field(None, description="Show the grid on the drawing area")
+    grid_size: Optional[int] = Field(None, description="Grid size for the drawing area for nodes")
+    drawing_grid_size: Optional[int] = Field(None, description="Grid size for the drawing area for drawings")
+    show_interface_labels: Optional[bool] = Field(None, description="Show interface labels on the drawing area")
+    supplier: Optional[Supplier] = Field(None, description="Supplier of the project")
+    variables: Optional[List[Variable]] = Field(None, description="Variables required to run the project")
+
+
+def main():
+
+    import json
+    import sys
+
+    with open(sys.argv[1]) as f:
+        data = json.load(f)
+        Topology.model_validate(data)
+
+
+if __name__ == "__main__":
+    main()

gns3server/schemas/controller/users.py

@@ -0,0 +1,105 @@
+#
+# 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/>.
+
+from datetime import datetime
+from typing import Optional
+from pydantic import ConfigDict, EmailStr, BaseModel, Field, SecretStr
+from uuid import UUID
+
+from .base import DateTimeModelMixin
+
+
+class UserBase(BaseModel):
+    """
+    Common user properties.
+    """
+
+    username: Optional[str] = Field(None, min_length=3, pattern="[a-zA-Z0-9_-]+$")
+    is_active: bool = True
+    email: Optional[EmailStr] = None
+    full_name: Optional[str] = None
+
+
+class UserCreate(UserBase):
+    """
+    Properties to create a user.
+    """
+
+    username: str = Field(..., min_length=3, pattern="[a-zA-Z0-9_-]+$")
+    password: SecretStr = Field(..., min_length=6, max_length=100)
+
+
+class UserUpdate(UserBase):
+    """
+    Properties to update a user.
+    """
+
+    password: Optional[SecretStr] = Field(None, min_length=6, max_length=100)
+
+
+class LoggedInUserUpdate(BaseModel):
+    """
+    Properties to update a logged-in user.
+    """
+
+    password: Optional[SecretStr] = Field(None, min_length=6, max_length=100)
+    email: Optional[EmailStr] = None
+    full_name: Optional[str] = None
+
+
+class User(DateTimeModelMixin, UserBase):
+
+    user_id: UUID
+    last_login: Optional[datetime] = None
+    is_superadmin: bool = False
+    model_config = ConfigDict(from_attributes=True)
+
+
+class UserGroupBase(BaseModel):
+    """
+    Common user group properties.
+    """
+
+    name: Optional[str] = Field(None, min_length=3, pattern="[a-zA-Z0-9_-]+$")
+
+
+class UserGroupCreate(UserGroupBase):
+    """
+    Properties to create a user group.
+    """
+
+    name: Optional[str] = Field(..., min_length=3, pattern="[a-zA-Z0-9_-]+$")
+
+
+class UserGroupUpdate(UserGroupBase):
+    """
+    Properties to update a user group.
+    """
+
+    pass
+
+
+class UserGroup(DateTimeModelMixin, UserGroupBase):
+
+    user_group_id: UUID
+    is_builtin: bool
+    model_config = ConfigDict(from_attributes=True)
+
+
+class Credentials(BaseModel):
+
+    username: str
+    password: str

gns3server/schemas/qemu_disk_image.py

@@ -0,0 +1,103 @@
+#
+# Copyright (C) 2022 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/>.
+
+from pydantic import BaseModel, Field
+from typing import Optional
+from enum import Enum
+
+
+class QemuDiskImageFormat(str, Enum):
+    """
+    Supported Qemu disk image formats.
+    """
+
+    qcow2 = "qcow2"
+    qcow = "qcow"
+    vpc = "vpc"
+    vdi = "vdi"
+    vdmk = "vdmk"
+    raw = "raw"
+
+
+class QemuDiskImagePreallocation(str, Enum):
+    """
+    Supported Qemu disk image pre-allocation options.
+    """
+
+    off = "off"
+    metadata = "metadata"
+    falloc = "falloc"
+    full = "full"
+
+
+class QemuDiskImageOnOff(str, Enum):
+    """
+    Supported Qemu image on/off options.
+    """
+
+    on = "on"
+    off = "off"
+
+
+class QemuDiskImageSubformat(str, Enum):
+    """
+    Supported Qemu disk image sub-format options.
+    """
+
+    dynamic = "dynamic"
+    fixed = "fixed"
+    stream_optimized = "streamOptimized"
+    two_gb_max_extent_sparse = "twoGbMaxExtentSparse"
+    two_gb_max_extent_flat = "twoGbMaxExtentFlat"
+    monolithic_sparse = "monolithicSparse"
+    monolithic_flat = "monolithicFlat"
+
+
+class QemuDiskImageAdapterType(str, Enum):
+    """
+    Supported Qemu disk image on/off options.
+    """
+
+    ide = "ide"
+    lsilogic = "lsilogic"
+    buslogic = "buslogic"
+    legacy_esx = "legacyESX"
+
+
+class QemuDiskImageBase(BaseModel):
+
+    format: QemuDiskImageFormat = Field(..., description="Image format type")
+    size: int = Field(..., description="Image size in Megabytes")
+    preallocation: Optional[QemuDiskImagePreallocation] = None
+    cluster_size: Optional[int] = None
+    refcount_bits: Optional[int] = None
+    lazy_refcounts: Optional[QemuDiskImageOnOff] = None
+    subformat: Optional[QemuDiskImageSubformat] = None
+    static: Optional[QemuDiskImageOnOff] = None
+    zeroed_grain: Optional[QemuDiskImageOnOff] = None
+    adapter_type: Optional[QemuDiskImageAdapterType] = None
+
+
+class QemuDiskImageCreate(QemuDiskImageBase):
+
+    pass
+
+
+class QemuDiskImageUpdate(QemuDiskImageBase):
+
+    format: Optional[QemuDiskImageFormat] = Field(None, description="Image format type")
+    size: Optional[int] = Field(None, description="Image size in Megabytes")
+    extend: Optional[int] = Field(None, description="Number of Megabytes to extend the image")

gns3server/schemas/version.py

@@ -0,0 +1,25 @@
+#
+# 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/>.
+
+from pydantic import BaseModel, Field
+from typing import Optional
+
+
+class Version(BaseModel):
+
+    controller_host: Optional[str] = Field(None, description="Controller hostname or IP address")
+    version: str = Field(..., description="Version number")
+    local: Optional[bool] = Field(None, description="Whether this is a local server or not")

gns3server/server.py

@@ -0,0 +1,348 @@
+#!/usr/bin/env python
+#
+# Copyright (C) 2021 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/>.
+
+
+"""
+Start the program. Use main.py to load it.
+"""
+
+import os
+import datetime
+import locale
+import argparse
+import psutil
+import sys
+import asyncio
+import signal
+import functools
+import uvicorn
+import secrets
+import string
+
+from gns3server.controller import Controller
+from gns3server.compute.port_manager import PortManager
+from gns3server.logger import init_logger
+from gns3server.version import __version__
+from gns3server.config import Config
+from gns3server.crash_report import CrashReport
+from gns3server.api.server import app
+from pydantic import ValidationError, SecretStr
+
+import logging
+
+log = logging.getLogger(__name__)
+
+
+class Server:
+
+    _stream_handler = None
+
+    @staticmethod
+    def _locale_check():
+        """
+        Checks if this application runs with a correct locale (i.e. supports UTF-8 encoding) and attempt to fix
+        if this is not the case.
+
+        This is to prevent UnicodeEncodeError with unicode paths when using standard library I/O operation
+        methods (e.g. os.stat() or os.path.*) which rely on the system or user locale.
+
+        More information can be found there: http://seasonofcode.com/posts/unicode-i-o-and-locales-in-python.html
+        or there: http://robjwells.com/post/61198832297/get-your-us-ascii-out-of-my-face
+        """
+
+        # no need to check when this application is frozen
+        if hasattr(sys, "frozen"):
+            return
+
+        language = encoding = None
+        try:
+            language, encoding = locale.getlocale()
+        except ValueError as e:
+            log.error(f"Could not determine the current locale: {e}")
+        if not language and not encoding:
+            try:
+                log.warning("Could not find a default locale, switching to C.UTF-8...")
+                locale.setlocale(locale.LC_ALL, ("C", "UTF-8"))
+            except locale.Error as e:
+                log.error(f"Could not switch to the C.UTF-8 locale: {e}")
+                raise SystemExit
+        elif encoding != "UTF-8":
+            log.warning(f"Your locale {language}.{encoding} encoding is not UTF-8, switching to the UTF-8 version...")
+            try:
+                locale.setlocale(locale.LC_ALL, (language, "UTF-8"))
+            except locale.Error as e:
+                log.error(f"Could not set an UTF-8 encoding for the {language} locale: {e}")
+                raise SystemExit
+        else:
+            log.info(f"Current locale is {language}.{encoding}")
+
+    def _parse_arguments(self, argv):
+        """
+        Parse command line arguments and override local configuration
+
+        :params args: Array of command line arguments
+        """
+
+        parser = argparse.ArgumentParser(description=f"GNS3 server version {__version__}")
+        parser.add_argument("-v", "--version", help="show the version", action="version", version=__version__)
+        parser.add_argument("--host", help="run on the given host/IP address")
+        parser.add_argument("--port", help="run on the given port", type=int)
+        parser.add_argument("--ssl", action="store_true", help="run in SSL mode")
+        parser.add_argument("--config", help="Configuration file")
+        parser.add_argument("--certfile", help="SSL cert file")
+        parser.add_argument("--certkey", help="SSL key file")
+        parser.add_argument("-L", "--local", action="store_true", help="local mode (allows some insecure operations)")
+        parser.add_argument(
+            "-A", "--allow", action="store_true", help="allow remote connections to local console ports"
+        )
+        parser.add_argument("-q", "--quiet", default=False, action="store_true", help="do not show logs on stdout")
+        parser.add_argument("-d", "--debug", default=False, action="store_true", help="show debug logs")
+        parser.add_argument("--logfile", "--log", help="send output to logfile instead of console")
+        parser.add_argument("--logmaxsize", default=10000000, help="maximum logfile size in bytes (default is 10MB)")
+        parser.add_argument(
+            "--logbackupcount", default=10, help="number of historical log files to keep (default is 10)"
+        )
+        parser.add_argument(
+            "--logcompression", default=False, action="store_true", help="compress inactive (historical) logs"
+        )
+        parser.add_argument("--daemon", action="store_true", help="start as a daemon")
+        parser.add_argument("--pid", help="store process pid")
+        parser.add_argument("--profile", help="Settings profile (blank will use default settings files)")
+
+        args = parser.parse_args(argv)
+        level = logging.INFO
+        if args.debug:
+            level = logging.DEBUG
+
+        self._stream_handler = init_logger(
+            level,
+            logfile=args.logfile,
+            max_bytes=int(args.logmaxsize),
+            backup_count=int(args.logbackupcount),
+            compression=args.logcompression,
+            quiet=args.quiet,
+        )
+
+        try:
+            if args.config:
+                Config.instance(files=[args.config], profile=args.profile)
+            else:
+                Config.instance(profile=args.profile)
+            config = Config.instance().settings
+        except ValidationError:
+            sys.exit(1)
+
+        defaults = {
+            "host": config.Server.host,
+            "port": config.Server.port,
+            "ssl": config.Server.enable_ssl,
+            "certfile": config.Server.certfile,
+            "certkey": config.Server.certkey,
+            "local": config.Server.local,
+            "allow": config.Server.allow_remote_console,
+        }
+
+        parser.set_defaults(**defaults)
+        return parser.parse_args(argv)
+
+    @staticmethod
+    def _set_config_defaults_from_command_line(args):
+
+        config = Config.instance().settings
+        config.Server.local = args.local
+        config.Server.allow_remote_console = args.allow
+        config.Server.host = args.host
+        config.Server.port = args.port
+        if args.certfile:
+            config.Server.certfile = args.certfile
+        if args.certkey:
+            config.Server.certkey = args.certkey
+        config.Server.enable_ssl = args.ssl
+
+    def _signal_handling(self):
+        def signal_handler(signame, *args):
+
+            try:
+                if signame == "SIGHUP":
+                    log.info(f"Server has got signal {signame}, reloading...")
+                    asyncio.ensure_future(Controller.instance().reload())
+                else:
+                    log.info(f"Server has got signal {signame}, exiting...")
+                    # send SIGTERM to the server PID so uvicorn can shut down the process
+                    os.kill(os.getpid(), signal.SIGTERM)
+            except asyncio.CancelledError:
+                pass
+
+        signals = ["SIGHUP", "SIGQUIT"]  # SIGINT and SIGTERM are already registered by uvicorn
+        for signal_name in signals:
+            callback = functools.partial(signal_handler, signal_name)
+            loop = asyncio.get_event_loop()
+            loop.add_signal_handler(getattr(signal, signal_name), callback)
+
+    @staticmethod
+    def _kill_ghosts():
+        """
+        Kill processes from previous GNS3 session
+        """
+        detect_process = ["vpcs", "ubridge", "dynamips"]
+        for proc in psutil.process_iter():
+            try:
+                name = proc.name().lower().split(".")[0]
+                if name in detect_process:
+                    proc.kill()
+                    log.warning("Killed ghost process %s", name)
+            except (OSError, psutil.NoSuchProcess, psutil.AccessDenied):
+                pass
+
+    @staticmethod
+    def _pid_lock(path):
+        """
+        Write the file in a file on the system.
+        Check if the process is not already running.
+        """
+
+        if os.path.exists(path):
+            pid = None
+            try:
+                with open(path) as f:
+                    try:
+                        pid = int(f.read())
+                        os.kill(pid, 0)  # kill returns an error if the process is not running
+                    except (OSError, SystemError, ValueError):
+                        pid = None
+            except OSError as e:
+                log.critical("Can't open pid file %s: %s", pid, str(e))
+                sys.exit(1)
+
+            if pid:
+                log.critical("GNS3 is already running pid: %d", pid)
+                sys.exit(1)
+
+        try:
+            with open(path, "w+") as f:
+                f.write(str(os.getpid()))
+        except OSError as e:
+            log.critical("Can't write pid file %s: %s", path, str(e))
+            sys.exit(1)
+
+    async def run(self):
+
+        args = self._parse_arguments(sys.argv[1:])
+
+        if args.pid:
+            self._pid_lock(args.pid)
+            self._kill_ghosts()
+
+        log.info(f"GNS3 server version {__version__}")
+        current_year = datetime.date.today().year
+        log.info(f"Copyright (c) 2007-{current_year} GNS3 Technologies Inc.")
+
+        for config_file in Config.instance().get_config_files():
+            log.info(f"Config file '{config_file}' loaded")
+
+        self._set_config_defaults_from_command_line(args)
+        config = Config.instance().settings
+
+        if not config.Server.compute_password.get_secret_value():
+            alphabet = string.ascii_letters + string.digits + string.punctuation
+            generated_password = ''.join(secrets.choice(alphabet) for _ in range(16))
+            config.Server.compute_password = SecretStr(generated_password)
+            log.warning(f"Compute authentication is enabled with username '{config.Server.compute_username}' and "
+                        f"a randomly generated password. Please set a password in the config file if this compute "
+                        f"is to be used by an external controller")
+        else:
+            log.info(f"Compute authentication is enabled with username '{config.Server.compute_username}'")
+
+        # we only support Python 3 version >= 3.8
+        if sys.version_info < (3, 8, 0):
+            raise SystemExit("Python 3.8 or higher is required")
+
+        log.info(
+            "Running with Python {major}.{minor}.{micro} and has PID {pid}".format(
+                major=sys.version_info[0], minor=sys.version_info[1], micro=sys.version_info[2], pid=os.getpid()
+            )
+        )
+
+        # check for the correct locale (UNIX/Linux only)
+        self._locale_check()
+
+        try:
+            os.getcwd()
+        except FileNotFoundError:
+            log.critical("The current working directory doesn't exist")
+            return
+
+        try:
+            import truststore
+            truststore.inject_into_ssl()
+            log.info("Using system certificate store for SSL connections")
+        except ImportError:
+            pass
+
+        CrashReport.instance()
+        host = config.Server.host
+        port = config.Server.port
+
+        PortManager.instance().console_host = host
+        self._signal_handling()
+
+        try:
+            log.info(f"Starting server on {host}:{port}")
+
+            # only show uvicorn access logs in debug mode
+            access_log = False
+            if log.getEffectiveLevel() == logging.DEBUG:
+                access_log = True
+
+            if config.Server.enable_ssl:
+                log.info("SSL is enabled")
+
+            config = uvicorn.Config(
+                app,
+                host=host,
+                port=port,
+                access_log=access_log,
+                ssl_certfile=config.Server.certfile,
+                ssl_keyfile=config.Server.certkey,
+                lifespan="on"
+            )
+
+            # overwrite uvicorn loggers with our own logger
+            for uvicorn_logger_name in ("uvicorn", "uvicorn.error"):
+                uvicorn_logger = logging.getLogger(uvicorn_logger_name)
+                uvicorn_logger.handlers = [self._stream_handler]
+                uvicorn_logger.propagate = False
+
+            if access_log:
+                uvicorn_logger = logging.getLogger("uvicorn.access")
+                uvicorn_logger.handlers = [self._stream_handler]
+                uvicorn_logger.propagate = False
+
+            server = uvicorn.Server(config)
+            await server.serve()
+
+        except Exception as e:
+            log.critical(f"Critical error while running the server: {e}", exc_info=1)
+            CrashReport.instance().capture_exception()
+            return
+        finally:
+            if args.pid:
+                log.info("Remove PID file %s", args.pid)
+                try:
+                    os.remove(args.pid)
+                except OSError as e:
+                    log.critical("Can't remove pid file %s: %s", args.pid, str(e))

gns3server/services/__init__.py

@@ -0,0 +1,19 @@
+#
+# 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/>.
+
+from .authentication import AuthService
+
+auth_service = AuthService()