Refactor tests and start work on database integration.

gns3server/db/database.py

@@ -0,0 +1,26 @@
+#!/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/>.
+
+import os
+
+from sqlalchemy.ext.asyncio import create_async_engine
+from sqlalchemy.orm import declarative_base
+
+SQLALCHEMY_DATABASE_URL = os.environ.get("DATABASE_URI", "sqlite:///./sql_app.db")
+
+engine = create_async_engine(SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False})
+Base = declarative_base()

gns3server/db/models.py

@@ -0,0 +1,95 @@
+#!/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/>.
+
+import uuid
+
+from sqlalchemy import Boolean, Column, ForeignKey, Integer, String, DateTime, func
+from sqlalchemy.orm import relationship
+from sqlalchemy.types import TypeDecorator, CHAR
+from sqlalchemy.dialects.postgresql import UUID
+from .database import Base
+
+
+class GUID(TypeDecorator):
+    """Platform-independent GUID type.
+    Uses PostgreSQL's UUID type, otherwise uses
+    CHAR(32), storing as stringified hex values.
+    """
+    impl = CHAR
+
+    def load_dialect_impl(self, dialect):
+        if dialect.name == 'postgresql':
+            return dialect.type_descriptor(UUID())
+        else:
+            return dialect.type_descriptor(CHAR(32))
+
+    def process_bind_param(self, value, dialect):
+        if value is None:
+            return value
+        elif dialect.name == 'postgresql':
+            return str(value)
+        else:
+            if not isinstance(value, uuid.UUID):
+                return "%.32x" % uuid.UUID(value).int
+            else:
+                # hexstring
+                return "%.32x" % value.int
+
+    def process_result_value(self, value, dialect):
+        if value is None:
+            return value
+        else:
+            if not isinstance(value, uuid.UUID):
+                value = uuid.UUID(value)
+            return value
+
+
+class BaseTable(Base):
+
+    __abstract__ = True
+
+    created_at = Column(DateTime, default=func.current_timestamp())
+    updated_at = Column(DateTime,
+                        default=func.current_timestamp(),
+                        onupdate=func.current_timestamp())
+
+
+class User(BaseTable):
+
+    __tablename__ = "users"
+
+    user_id = Column(GUID, primary_key=True, default=str(uuid.uuid4()))
+    username = Column(String, unique=True, index=True)
+    email = Column(String, unique=True, index=True)
+    full_name = Column(String)
+    hashed_password = Column(String)
+    is_active = Column(Boolean, default=True)
+    is_superuser = Column(Boolean, default=False)
+
+
+#     items = relationship("Item", back_populates="owner")
+#
+#
+# class Item(Base):
+#     __tablename__ = "items"
+#
+#     id = Column(Integer, primary_key=True, index=True)
+#     title = Column(String, index=True)
+#     description = Column(String, index=True)
+#     owner_id = Column(Integer, ForeignKey("users.id"))
+#
+#     owner = relationship("User", back_populates="items")

gns3server/db/repositories/base.py

@@ -0,0 +1,29 @@
+#!/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/>.
+
+from sqlalchemy.ext.asyncio import AsyncSession
+from ..database import engine
+
+
+class BaseRepository:
+
+    async def db(self):
+        session = AsyncSession(engine)
+        try:
+            yield session
+        finally:
+            await session.close()

gns3server/db/repositories/users.py

@@ -0,0 +1,110 @@
+#!/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/>.
+
+from uuid import UUID
+from typing import Optional, List
+from sqlalchemy import select, update, delete
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from ..database import engine
+from .base import BaseRepository
+
+import gns3server.db.models as models
+from gns3server import schemas
+from gns3server.services import auth_service
+
+
+class UsersRepository(BaseRepository):
+
+    def __init__(self) -> None:
+
+        super().__init__()
+        self._auth_service = auth_service
+
+    async def get_user(self, user_id: UUID) -> Optional[models.User]:
+
+        async with AsyncSession(engine) as session:
+            result = await session.execute(select(models.User).where(models.User.user_id == user_id))
+            return result.scalars().first()
+
+    async def get_user_by_username(self, username: str) -> Optional[models.User]:
+
+        async with AsyncSession(engine) as session:
+            result = await session.execute(select(models.User).where(models.User.username == username))
+            return result.scalars().first()
+
+    async def get_user_by_email(self, email: str) -> Optional[models.User]:
+
+        async with AsyncSession(engine) as session:
+            result = await session.execute(select(models.User).where(models.User.email == email))
+            return result.scalars().first()
+
+    async def get_users(self) -> List[models.User]:
+
+        async with AsyncSession(engine) as session:
+            result = await session.execute(select(models.User))
+            return result.scalars().all()
+
+    async def create_user(self, user: schemas.UserCreate) -> models.User:
+
+        async with AsyncSession(engine) as session:
+            hashed_password = self._auth_service.hash_password(user.password)
+            db_user = models.User(username=user.username,
+                                  email=user.email,
+                                  full_name=user.full_name,
+                                  hashed_password=hashed_password)
+            session.add(db_user)
+            await session.commit()
+            await session.refresh(db_user)
+            return db_user
+
+    async def update_user(self, user_id: UUID, user_update: schemas.UserUpdate) -> Optional[models.User]:
+
+        async with AsyncSession(engine) as session:
+
+            update_values = user_update.dict(exclude_unset=True)
+            password = update_values.pop("password", None)
+            if password:
+                update_values["hashed_password"] = self._auth_service.hash_password(password=password)
+
+            print(update_values)
+            query = update(models.User) \
+                .where(models.User.user_id == user_id) \
+                .values(update_values)
+
+            await session.execute(query)
+            await session.commit()
+            return await self.get_user(user_id)
+
+    async def delete_user(self, user_id: UUID) -> bool:
+
+        async with AsyncSession(engine) as session:
+            query = delete(models.User).where(models.User.user_id == user_id)
+            result = await session.execute(query)
+            await session.commit()
+            return result.rowcount > 0
+            #except:
+            #    await session.rollback()
+
+    async def authenticate_user(self, username: str, password: str) -> Optional[models.User]:
+
+        user = await self.get_user_by_username(username)
+        if not user:
+            return None
+        if not self._auth_service.verify_password(password, user.hashed_password):
+            return None
+        return user

gns3server/db/tasks.py

@@ -0,0 +1,34 @@
+#!/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/>.
+
+from sqlalchemy.exc import SQLAlchemyError
+
+from .database import engine
+from .models import Base
+
+import logging
+log = logging.getLogger(__name__)
+
+
+async def connect_to_db() -> None:
+
+    try:
+        async with engine.begin() as conn:
+            await conn.run_sync(Base.metadata.create_all)
+            log.info("Successfully connected to the database")
+    except SQLAlchemyError as e:
+        log.error(f"Error while connecting to the database: {e}")