Save computes to database

gns3server/db/models/__init__.py

@@ -17,6 +17,7 @@
 
 from .base import Base
 from .users import User
+from .computes import Compute
 from .templates import (
     Template,
     CloudTemplate,

gns3server/db/models/computes.py

@@ -0,0 +1,33 @@
+#!/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/>.
+
+from sqlalchemy import Column, String
+
+from .base import BaseTable, GUID
+
+
+class Compute(BaseTable):
+
+    __tablename__ = "computes"
+
+    compute_id = Column(GUID, primary_key=True)
+    name = Column(String, index=True)
+    protocol = Column(String)
+    host = Column(String)
+    port = Column(String)
+    user = Column(String)
+    password = Column(String)

gns3server/db/repositories/computes.py

@@ -0,0 +1,88 @@
+#!/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/>.
+
+from uuid import UUID
+from typing import Optional, List
+from sqlalchemy import select, update, delete
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from .base import BaseRepository
+
+import gns3server.db.models as models
+from gns3server.services import auth_service
+from gns3server import schemas
+
+
+class ComputesRepository(BaseRepository):
+
+    def __init__(self, db_session: AsyncSession) -> None:
+
+        super().__init__(db_session)
+        self._auth_service = auth_service
+
+    async def get_compute(self, compute_id: UUID) -> Optional[models.Compute]:
+
+        query = select(models.Compute).where(models.Compute.compute_id == compute_id)
+        result = await self._db_session.execute(query)
+        return result.scalars().first()
+
+    async def get_compute_by_name(self, name: str) -> Optional[models.Compute]:
+
+        query = select(models.Compute).where(models.Compute.name == name)
+        result = await self._db_session.execute(query)
+        return result.scalars().first()
+
+    async def get_computes(self) -> List[models.Compute]:
+
+        query = select(models.Compute)
+        result = await self._db_session.execute(query)
+        return result.scalars().all()
+
+    async def create_compute(self, compute_create: schemas.ComputeCreate) -> models.Compute:
+
+        db_compute = models.Compute(
+            compute_id=compute_create.compute_id,
+            name=compute_create.name,
+            protocol=compute_create.protocol.value,
+            host=compute_create.host,
+            port=compute_create.port,
+            user=compute_create.user,
+            password=compute_create.password
+        )
+        self._db_session.add(db_compute)
+        await self._db_session.commit()
+        await self._db_session.refresh(db_compute)
+        return db_compute
+
+    async def update_compute(self, compute_id: UUID, compute_update: schemas.ComputeUpdate) -> Optional[models.Compute]:
+
+        update_values = compute_update.dict(exclude_unset=True)
+
+        query = update(models.Compute) \
+            .where(models.Compute.compute_id == compute_id) \
+            .values(update_values)
+
+        await self._db_session.execute(query)
+        await self._db_session.commit()
+        return await self.get_compute(compute_id)
+
+    async def delete_compute(self, compute_id: UUID) -> bool:
+
+        query = delete(models.Compute).where(models.Compute.compute_id == compute_id)
+        result = await self._db_session.execute(query)
+        await self._db_session.commit()
+        return result.rowcount > 0

gns3server/db/tasks.py

@@ -18,8 +18,14 @@
 import os
 
 from fastapi import FastAPI
+from fastapi.encoders import jsonable_encoder
+from pydantic import ValidationError
+
+from typing import List
 from sqlalchemy.exc import SQLAlchemyError
-from sqlalchemy.ext.asyncio import create_async_engine
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from gns3server.db.repositories.computes import ComputesRepository
+from gns3server import schemas
 
 from .models import Base
 from gns3server.config import Config
@@ -40,3 +46,21 @@ async def connect_to_db(app: FastAPI) -> None:
         app.state._db_engine = engine
     except SQLAlchemyError as e:
         log.error(f"Error while connecting to database '{db_url}: {e}")
+
+
+async def get_computes(app: FastAPI) -> List[dict]:
+
+    computes = []
+    async with AsyncSession(app.state._db_engine) as db_session:
+        db_computes = await ComputesRepository(db_session).get_computes()
+        for db_compute in db_computes:
+            try:
+                compute = jsonable_encoder(
+                    schemas.Compute.from_orm(db_compute),
+                    exclude_unset=True,
+                    exclude={"created_at", "updated_at"})
+            except ValidationError as e:
+                log.error(f"Could not load compute '{db_compute.compute_id}' from database: {e}")
+                continue
+            computes.append(compute)
+    return computes