gns3-server 3.0.0rc2__py3-none-any.whl → 3.0.2__py3-none-any.whl

gns3server/controller/compute.py

@@ -18,14 +18,19 @@
 import ipaddress
 import aiohttp
 import asyncio
-import async_timeout
 import socket
 import json
 import sys
 import io
+
 from fastapi import HTTPException
 from aiohttp import web
 
+if sys.version_info >= (3, 11):
+    from asyncio import timeout as asynctimeout
+else:
+    from async_timeout import timeout as asynctimeout
+
 from ..utils import parse_version
 from ..utils.asyncio import locking
 from ..controller.controller_error import (
@@ -502,8 +507,8 @@ class Compute:
         """ Returns URL for specific path at Compute"""
         return self._getUrl(path)
 
-    async def _run_http_query(self, method, path, data=None, timeout=20, raw=False):
-        async with async_timeout.timeout(delay=timeout):
+    async def _run_http_query(self, method, path, data=None, timeout=120, raw=False):
+        async with asynctimeout(delay=timeout):
             url = self._getUrl(path)
             headers = {"content-type": "application/json"}
             chunked = None

gns3server/controller/node.py

@@ -572,15 +572,11 @@ class Node:
         Start a node
         """
         try:
-            # For IOU we need to send the licence everytime
+            # For IOU: we need to send the licence everytime we start a node
             if self.node_type == "iou":
                 license_check = self._project.controller.iou_license.get("license_check", True)
                 iourc_content = self._project.controller.iou_license.get("iourc_content", None)
-                # if license_check and not iourc_content:
-                #    raise aiohttp.web.HTTPConflict(text="IOU licence is not configured")
-                await self.post(
-                    "/start", timeout=240, data={"license_check": license_check, "iourc_content": iourc_content}
-                )
+                await self.post("/start", timeout=240, data={"license_check": license_check, "iourc_content": iourc_content})
             else:
                 await self.post("/start", data=data, timeout=240)
         except asyncio.TimeoutError:

gns3server/controller/project.py

@@ -595,7 +595,7 @@ class Project:
 
         if node_type == "iou":
             async with self._iou_id_lock:
-                # wait for a IOU node to be completely created before adding a new one
+                # wait for an IOU node to be completely created before adding a new one
                 # this is important otherwise we allocate the same application ID (used
                 # to generate MAC addresses) when creating multiple IOU node at the same time
                 if "properties" in kwargs.keys():
@@ -1339,7 +1339,6 @@ class Project:
         Copy the project files directly rather than in an import-export fashion.
 
         :param name: Name of the new project. A new one will be generated in case of conflicts
-        :param location: Parent directory of the new project
         :param reset_mac_addresses: Reset MAC addresses for the new project
         """
 

gns3server/crash_report.py

@@ -58,7 +58,7 @@ class CrashReport:
     Report crash to a third party service
     """
 
-    DSN = "https://29d15f2b7fde7fbd860843b7ee24dc7f@o19455.ingest.us.sentry.io/38482"
+    DSN = "https://9cf53e6b9adfe49b867f1847b7cc4d72@o19455.ingest.us.sentry.io/38482"
     _instance = None
 
     def __init__(self):

gns3server/db/repositories/images.py

@@ -18,7 +18,7 @@
 import os
 
 from typing import Optional, List
-from sqlalchemy import select, delete
+from sqlalchemy import select, delete, update
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from .base import BaseRepository
@@ -103,6 +103,22 @@ class ImagesRepository(BaseRepository):
         await self._db_session.refresh(db_image)
         return db_image
 
+    async def update_image(self, image_path: str, checksum: str, checksum_algorithm: str) -> models.Image:
+        """
+        Update an image.
+        """
+
+        query = update(models.Image).\
+            where(models.Image.path == image_path).\
+            values(checksum=checksum, checksum_algorithm=checksum_algorithm)
+
+        await self._db_session.execute(query)
+        await self._db_session.commit()
+        image_db = await self.get_image_by_checksum(checksum)
+        if image_db:
+            await self._db_session.refresh(image_db)  # force refresh of updated_at value
+        return image_db
+
     async def delete_image(self, image_path: str) -> bool:
         """
         Delete an image.
@@ -119,7 +135,7 @@ class ImagesRepository(BaseRepository):
         await self._db_session.commit()
         return result.rowcount > 0
 
-    async def prune_images(self) -> int:
+    async def prune_images(self, skip_images: list[str] = None) -> int:
         """
         Prune images not attached to any template.
         """
@@ -130,12 +146,15 @@ class ImagesRepository(BaseRepository):
         images = result.scalars().all()
         images_deleted = 0
         for image in images:
+            if skip_images and image.filename in skip_images:
+                log.debug(f"Skipping image '{image.path}' for pruning")
+                continue
             try:
                 log.debug(f"Deleting image '{image.path}'")
                 os.remove(image.path)
             except OSError:
                 log.warning(f"Could not delete image file {image.path}")
-            if await self.delete_image(image.filename):
+            if await self.delete_image(image.path):
                 images_deleted += 1
         log.info(f"{images_deleted} image(s) have been deleted")
         return images_deleted

gns3server/db/repositories/pools.py

@@ -80,7 +80,7 @@ class ResourcePoolsRepository(BaseRepository):
         await self._db_session.commit()
         return result.rowcount > 0
 
-    async def get_resource_memberships(self, resource_id: UUID) -> List[models.UserGroup]:
+    async def get_resource_memberships(self, resource_id: UUID) -> List[models.ResourcePool]:
         """
         Get all resource memberships in resource pools.
         """

gns3server/db/repositories/templates.py

@@ -170,3 +170,14 @@ class TemplatesRepository(BaseRepository):
             await self._db_session.commit()
             await self._db_session.refresh(template_in_db)
         return template_in_db
+
+    async def get_template_images(self, template_id: UUID) -> List[models.Image]:
+        """
+        Return all images attached to a template.
+        """
+
+        query = select(models.Image).\
+            join(models.Image.templates).\
+            filter(models.Template.template_id == template_id)
+        result = await self._db_session.execute(query)
+        return result.scalars().all()

gns3server/db/tasks.py

@@ -16,13 +16,11 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import asyncio
-import signal
+import time
 import os
 
 from fastapi import FastAPI
 from pydantic import ValidationError
-from watchfiles import awatch, Change
-
 from typing import List
 from sqlalchemy import event
 from sqlalchemy.engine import Engine
@@ -32,10 +30,13 @@ from alembic import command, config
 from alembic.script import ScriptDirectory
 from alembic.runtime.migration import MigrationContext
 from alembic.util.exc import CommandError
+from watchdog.observers import Observer
+from watchdog.events import FileSystemEvent, PatternMatchingEventHandler
 
 from gns3server.db.repositories.computes import ComputesRepository
 from gns3server.db.repositories.images import ImagesRepository
-from gns3server.utils.images import discover_images, check_valid_image_header, read_image_info, default_images_directory, InvalidImageError
+from gns3server.utils.images import md5sum, discover_images, read_image_info, InvalidImageError
+from gns3server.utils.asyncio import wait_run_in_executor
 from gns3server import schemas
 
 from .models import Base
@@ -130,81 +131,7 @@ async def get_computes(app: FastAPI) -> List[dict]:
     return computes
 
 
-def image_filter(change: Change, path: str) -> bool:
-
-    if change == Change.added and os.path.isfile(path):
-        if path.endswith(".tmp") or path.endswith(".md5sum") or path.startswith("."):
-            return False
-        if "/lib/" in path or "/lib64/" in path:
-            # ignore custom IOU libraries
-            return False
-        header_magic_len = 7
-        with open(path, "rb") as f:
-            image_header = f.read(header_magic_len)  # read the first 7 bytes of the file
-            if len(image_header) >= header_magic_len:
-                try:
-                    check_valid_image_header(image_header)
-                except InvalidImageError as e:
-                    log.debug(f"New image '{path}': {e}")
-                    return False
-            else:
-                log.debug(f"New image '{path}': size is too small to be valid")
-                return False
-        return True
-    # FIXME: should we support image deletion?
-    # elif change == Change.deleted:
-    #     return True
-    return False
-
-
-async def monitor_images_on_filesystem(app: FastAPI):
-
-    directories_to_monitor = []
-    for image_type in ("qemu", "ios", "iou"):
-        image_dir = default_images_directory(image_type)
-        if os.path.isdir(image_dir):
-            log.debug(f"Monitoring for new images in '{image_dir}'")
-            directories_to_monitor.append(image_dir)
-
-    try:
-        async for changes in awatch(
-                *directories_to_monitor,
-                watch_filter=image_filter,
-                raise_interrupt=True
-        ):
-            async with AsyncSession(app.state._db_engine) as db_session:
-                images_repository = ImagesRepository(db_session)
-                for change in changes:
-                    change_type, image_path = change
-                    if change_type == Change.added:
-                        try:
-                            image = await read_image_info(image_path)
-                        except InvalidImageError as e:
-                            log.warning(str(e))
-                            continue
-                        try:
-                            if await images_repository.get_image(image_path):
-                                continue
-                            await images_repository.add_image(**image)
-                            log.info(f"Discovered image '{image_path}' has been added to the database")
-                        except SQLAlchemyError as e:
-                            log.warning(f"Error while adding image '{image_path}' to the database: {e}")
-                    # if change_type == Change.deleted:
-                    #     try:
-                    #         if await images_repository.get_image(image_path):
-                    #             success = await images_repository.delete_image(image_path)
-                    #             if not success:
-                    #                 log.warning(f"Could not delete image '{image_path}' from the database")
-                    #             else:
-                    #                 log.info(f"Image '{image_path}' has been deleted from the database")
-                    #     except SQLAlchemyError as e:
-                    #         log.warning(f"Error while deleting image '{image_path}' from the database: {e}")
-    except KeyboardInterrupt:
-        # send SIGTERM to the server PID so uvicorn can shutdown the process
-        os.kill(os.getpid(), signal.SIGTERM)
-
-
-async def discover_images_on_filesystem(app: FastAPI):
+async def discover_images_on_filesystem(app: FastAPI) -> None:
 
     async with AsyncSession(app.state._db_engine) as db_session:
         images_repository = ImagesRepository(db_session)
@@ -228,3 +155,117 @@ async def discover_images_on_filesystem(app: FastAPI):
 
     # monitor if images have been manually added
     asyncio.create_task(monitor_images_on_filesystem(app))
+
+
+async def update_disk_checksums(updated_disks: List[str]) -> None:
+    """
+    Update the checksum of a list of disks in the database.
+
+    :param updated_disks: list of updated disks
+    """
+
+    from gns3server.api.server import app
+    async with AsyncSession(app.state._db_engine) as db_session:
+        images_repository = ImagesRepository(db_session)
+        for path in updated_disks:
+            image = await images_repository.get_image(path)
+            if image:
+                log.info(f"Updating image '{path}' in the database")
+                checksum = await wait_run_in_executor(md5sum, path, cache_to_md5file=False)
+                if image.checksum != checksum:
+                    await images_repository.update_image(path, checksum, "md5")
+
+class EventHandler(PatternMatchingEventHandler):
+    """
+    Watchdog event handler.
+    """
+
+    def __init__(self, queue: asyncio.Queue, loop: asyncio.BaseEventLoop, **kwargs):
+
+        self._loop = loop
+        self._queue = queue
+
+        # ignore temporary files, md5sum files, hidden files and directories
+        super().__init__(ignore_patterns=["*.tmp", "*.md5sum", ".*"], ignore_directories = True, **kwargs)
+
+    def on_closed(self, event: FileSystemEvent) -> None:
+        # monitor for closed files (e.g. when a file has finished to be copied)
+        if "/lib/" in event.src_path or "/lib64/" in event.src_path:
+            return  # ignore custom IOU libraries
+        self._loop.call_soon_threadsafe(self._queue.put_nowait, event)
+
+class EventIterator(object):
+    """
+    Watchdog Event iterator.
+    """
+
+    def __init__(self, queue: asyncio.Queue):
+        self.queue = queue
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self):
+
+        item = await self.queue.get()
+        if item is None:
+            raise StopAsyncIteration
+        return item
+
+async def monitor_images_on_filesystem(app: FastAPI):
+
+    def watchdog(
+            path: str,
+            queue: asyncio.Queue,
+            loop: asyncio.BaseEventLoop,
+            app: FastAPI, recursive: bool = False
+    ) -> None:
+        """
+        Thread to monitor a directory for new images.
+        """
+
+        handler = EventHandler(queue, loop)
+        observer = Observer()
+        observer.schedule(handler, str(path), recursive=recursive)
+        observer.start()
+        log.info(f"Monitoring for new images in '{path}'")
+        while True:
+            time.sleep(1)
+            # stop when the app is exiting
+            if app.state.exiting:
+                observer.stop()
+                observer.join(10)
+                log.info(f"Stopping monitoring for new images in '{path}'")
+                loop.call_soon_threadsafe(queue.put_nowait, None)
+                break
+
+    queue = asyncio.Queue()
+    loop = asyncio.get_event_loop()
+    server_config = Config.instance().settings.Server
+    image_dir = os.path.expanduser(server_config.images_path)
+    asyncio.get_event_loop().run_in_executor(None, watchdog,image_dir, queue, loop, app, True)
+
+    async for filesystem_event in EventIterator(queue):
+        # read the file system event from the queue
+        image_path = filesystem_event.src_path
+        expected_image_type = None
+        if "IOU" in image_path:
+            expected_image_type = "iou"
+        elif "QEMU" in image_path:
+            expected_image_type = "qemu"
+        elif "IOS" in image_path:
+            expected_image_type = "ios"
+        async with AsyncSession(app.state._db_engine) as db_session:
+            images_repository = ImagesRepository(db_session)
+            try:
+                image = await read_image_info(image_path, expected_image_type)
+            except InvalidImageError as e:
+                log.warning(str(e))
+                continue
+            try:
+                if await images_repository.get_image(image_path):
+                    continue
+                await images_repository.add_image(**image)
+                log.info(f"Discovered image '{image_path}' has been added to the database")
+            except SQLAlchemyError as e:
+                log.warning(f"Error while adding image '{image_path}' to the database: {e}")

gns3server/schemas/config.py

@@ -147,7 +147,7 @@ class ServerSettings(BaseModel):
     allow_remote_console: bool = False
     enable_builtin_templates: bool = True
     install_builtin_appliances: bool = True
-    model_config = ConfigDict(validate_assignment=True, str_strip_whitespace=True, use_enum_values=True)
+    model_config = ConfigDict(validate_assignment=True, str_strip_whitespace=True)
 
     @field_validator("additional_images_paths", mode="before")
     @classmethod

gns3server/server.py

@@ -267,9 +267,9 @@ class Server:
         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")
+        # we only support Python 3 version >= 3.9
+        if sys.version_info < (3, 9, 0):
+            raise SystemExit("Python 3.9 or higher is required")
 
         log.info(
             "Running with Python {major}.{minor}.{micro} and has PID {pid}".format(

gns3server/services/authentication.py

@@ -14,8 +14,9 @@
 # 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 jose import JWTError, jwt
+from joserfc import jwt
+from joserfc.jwk import OctKey
+from joserfc.errors import JoseError
 from datetime import datetime, timedelta, timezone
 import bcrypt
 
@@ -56,7 +57,8 @@ class AuthService:
             secret_key = DEFAULT_JWT_SECRET_KEY
             log.error("A JWT secret key must be configured to secure the server, using an unsecured default key!")
         algorithm = Config.instance().settings.Controller.jwt_algorithm
-        encoded_jwt = jwt.encode(to_encode, secret_key, algorithm=algorithm)
+        key = OctKey.import_key(secret_key)
+        encoded_jwt = jwt.encode({"alg": algorithm}, to_encode, key)
         return encoded_jwt
 
     def get_username_from_token(self, token: str, secret_key: str = None) -> Optional[str]:
@@ -73,11 +75,12 @@ class AuthService:
                 secret_key = DEFAULT_JWT_SECRET_KEY
                 log.error("A JWT secret key must be configured to secure the server, using an unsecured default key!")
             algorithm = Config.instance().settings.Controller.jwt_algorithm
-            payload = jwt.decode(token, secret_key, algorithms=[algorithm])
-            username: str = payload.get("sub")
+            key = OctKey.import_key(secret_key)
+            payload = jwt.decode(token, key, algorithms=[algorithm])
+            username: str = payload.claims.get("sub")
             if username is None:
                 raise credentials_exception
             token_data = TokenData(username=username)
-        except (JWTError, ValidationError):
+        except (JoseError, ValidationError, ValueError):
             raise credentials_exception
         return token_data.username