refactor database clients to use a common base

Author: sampsapenna

.github/config/.wordlist.txt

@@ -19,6 +19,7 @@ configs
 containerport
 cp
 cryptfiles
+cryptupload
 csc
 cscfi
 decrypt
@@ -54,6 +55,7 @@ lt
 macos
 matchlabels
 maxdepth
+middleware
 middlewares
 namespace
 navbar
@@ -106,6 +108,7 @@ ui
 untrusted
 url
 usr
+util
 venv
 veryfast
 vm

.gitignore

@@ -70,6 +70,7 @@ docs/source/swift_browser_ui.ui
 docs/source/swift_browser_ui.sharing
 docs/source/swift_browser_ui.request
 docs/source/swift_browser_ui.upload
+docs/source/swift_browser_ui.common
 
 # PyBuilder
 target/

CHANGELOG.md

@@ -116,6 +116,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - (GL #1074) Updated `/api/{project}` endpoint to check for `last_modified` values before returning the container list
 - (GL #1105) Upload modal restricted to uploading to current container, or creating a new one in main container view
 - (GL #1028) Disallow uploading files with size 0
+- Use common base class for database connections
 
 ### Fixed
 

docs/source/code.rst

@@ -31,7 +31,6 @@ Python Modules
 
     swift_browser_ui.sharing.bindings.bind
     swift_browser_ui.sharing.api
-    swift_browser_ui.sharing.db
     swift_browser_ui.sharing.server
     swift_browser_ui.sharing.shared
 
@@ -44,7 +43,6 @@ Python Modules
 
     swift_browser_ui.request.bindings.bind
     swift_browser_ui.request.api
-    swift_browser_ui.request.db
     swift_browser_ui.request.server
 
 .. automodule:: swift_browser_ui.upload
@@ -61,6 +59,21 @@ Python Modules
     swift_browser_ui.upload.replicate
     swift_browser_ui.upload.server
     swift_browser_ui.upload.upload
+    swift_browser_ui.upload.cryptupload
 
+.. automodule:: swift_browser_ui.common
+    :synopsis: The ``swift_browser_ui.common`` package contains code shared
+               between the different services.
+
+.. autosummary::
+    :toctree: swift_browser_ui.common
+
+    swift_browser_ui.common.common_handlers
+    swift_browser_ui.common.common_middleware
+    swift_browser_ui.common.common_util
+    swift_browser_ui.common.db
+    swift_browser_ui.common.signature
+    swift_browser_ui.common.types
+    swift_browser_ui.common.vault_client
 
 :ref:`genindex` | :ref:`modindex`

swift_browser_ui/common/common_middleware.py

@@ -92,7 +92,7 @@ async def handle_validate_authentication(
             except KeyError:
                 project = None
     finally:
-        if project:
+        if project and "db_conn" in request.app:
             try:
                 project_tokens = [
                     rec["token"].encode("utf-8")
@@ -102,8 +102,10 @@ async def handle_validate_authentication(
                 pass
         else:
             if request.path != "/health":
-                LOGGER.debug(f"No project ID found in request {request}")
-                raise aiohttp.web.HTTPUnauthorized(reason="No project ID in request")
+                LOGGER.debug(
+                    f"No project ID found in request {request}, "
+                    "assuming scopeless authentication and skipping tokens."
+                )
 
     await swift_browser_ui.common.signature.test_signature(
         request.app["tokens"] + project_tokens, signature, validity + path, validity

swift_browser_ui/sharing/db.py swift_browser_ui/common/db.py

@@ -1,10 +1,11 @@
-"""Sharing backend database implementation."""
+"""Module for database interfaces using postgres."""
 
 
 import logging
 import os
 import typing
 
+import aiohttp.web
 import asyncpg
 
 from swift_browser_ui.common.common_util import sleep_random
@@ -13,8 +14,20 @@
 MODULE_LOGGER.setLevel(os.environ.get("LOG_LEVEL", "INFO"))
 
 
-class DBConn:
-    """Class for the account sharing database functionality."""
+async def db_graceful_start(app: aiohttp.web.Application) -> None:
+    """Gracefully start the database."""
+    app["db_conn"] = app["db_class"]()
+    await app["db_conn"].open()
+
+
+async def db_graceful_close(app: aiohttp.web.Application) -> None:
+    """Gracefully close the database."""
+    if app["db_conn"] is not None:
+        await app["db_conn"].close()
+
+
+class BaseDBConn:
+    """Class for base database connection."""
 
     def __init__(self) -> None:
         """Initialize connection variable."""
@@ -27,27 +40,16 @@ def erase(self) -> None:
             self.pool.terminate()
             self.pool = None
 
-    async def open(self) -> None:
+    async def close(self) -> None:
+        """Safely close the database connection."""
+        if self.pool is not None:
+            await self.pool.close()
+
+    async def _open(self, **kwargs) -> None:
         """Initialize the database connection."""
         while self.pool is None:
             try:
-                self.pool = await asyncpg.create_pool(
-                    password=os.environ.get("SHARING_DB_PASSWORD", None),
-                    user=os.environ.get("SHARING_DB_USER", "sharing"),
-                    host=os.environ.get("SHARING_DB_HOST", "localhost"),
-                    port=int(os.environ.get("SHARING_DB_PORT", 5432)),
-                    ssl=os.environ.get("SHARING_DB_SSL", "prefer"),
-                    database=os.environ.get("SHARING_DB_NAME", "swiftbrowserdb"),
-                    min_size=int(os.environ.get("SHARING_DB_MIN_CONNECTIONS", 0)),
-                    max_size=int(os.environ.get("SHARING_DB_MAX_CONNECTIONS", 2)),
-                    timeout=int(os.environ.get("SHARING_DB_TIMEOUT", 120)),
-                    command_timeout=int(
-                        os.environ.get("SHARING_DB_COMMAND_TIMEOUT", 180)
-                    ),
-                    max_inactive_connection_lifetime=int(
-                        os.environ.get("SHARING_DB_MAX_INACTIVE_CONN_LIFETIME", 10)
-                    ),
-                )
+                self.pool = await asyncpg.create_pool(**kwargs)
             except (ConnectionError, OSError):
                 self.log.error(
                     "Failed to establish connection. "
@@ -61,10 +63,47 @@ async def open(self) -> None:
                 self.log.error("Database is not ready yet.")
                 await sleep_random()
 
-    async def close(self) -> None:
-        """Safely close the database connection."""
+    async def get_tokens(
+        self, token_owner: str
+    ) -> typing.List[typing.Dict[str, typing.Any]]:
+        """Get tokens created for a project."""
         if self.pool is not None:
-            await self.pool.close()
+            query = await self.pool.fetch(
+                """SELECT *
+                FROM Tokens
+                WHERE token_owner = $1
+                ;
+                """,
+                token_owner,
+            )
+            return list(query)
+        return []
+
+
+class SharingDBConn(BaseDBConn):
+    """Class for the account sharing database functionality."""
+
+    def __init__(self) -> None:
+        """Initialize connection variable."""
+        super().__init__()
+
+    async def open(self) -> None:
+        """Initialize the database connection."""
+        await super()._open(
+            password=os.environ.get("SHARING_DB_PASSWORD", None),
+            user=os.environ.get("SHARING_DB_USER", "sharing"),
+            host=os.environ.get("SHARING_DB_HOST", "localhost"),
+            port=int(os.environ.get("SHARING_DB_PORT", 5432)),
+            ssl=os.environ.get("SHARING_DB_SSL", "prefer"),
+            database=os.environ.get("SHARING_DB_NAME", "swiftbrowserdb"),
+            min_size=int(os.environ.get("SHARING_DB_MIN_CONNECTIONS", 0)),
+            max_size=int(os.environ.get("SHARING_DB_MAX_CONNECTIONS", 2)),
+            timeout=int(os.environ.get("SHARING_DB_TIMEOUT", 120)),
+            command_timeout=int(os.environ.get("SHARING_DB_COMMAND_TIMEOUT", 180)),
+            max_inactive_connection_lifetime=int(
+                os.environ.get("SHARING_DB_MAX_INACTIVE_CONN_LIFETIME", 10)
+            ),
+        )
 
     async def add_share(
         self,
@@ -311,22 +350,6 @@ async def get_shared_container_details(
             return ret
         return []
 
-    async def get_tokens(
-        self, token_owner: str
-    ) -> typing.List[typing.Dict[str, typing.Any]]:
-        """Get tokens created for a project."""
-        if self.pool is not None:
-            query = await self.pool.fetch(
-                """SELECT *
-                FROM Tokens
-                WHERE token_owner = $1
-                ;
-                """,
-                token_owner,
-            )
-            return list(query)
-        return []
-
     async def revoke_token(self, token_owner: str, token_identifier: str) -> None:
         """Remove a token from the database."""
         if self.pool is not None:
@@ -415,3 +438,139 @@ async def match_name_id(self, name: str) -> list:
             return list(query)
 
         return []
+
+
+class RequestDBConn(BaseDBConn):
+    """Class for handling sharing request database connection."""
+
+    def __init__(self) -> None:
+        """."""
+        super().__init__()
+
+    async def open(self) -> None:
+        """Gracefully open the database."""
+        await super()._open(
+            password=os.environ.get("REQUEST_DB_PASSWORD", None),
+            user=os.environ.get("REQUEST_DB_USER", "request"),
+            host=os.environ.get("REQUEST_DB_HOST", "localhost"),
+            port=int(os.environ.get("REQUEST_DB_PORT", 5432)),
+            ssl=os.environ.get("REQUEST_DB_SSL", "prefer"),
+            database=os.environ.get("REQUEST_DB_NAME", "swiftbrowserdb"),
+            min_size=int(os.environ.get("REQUEST_DB_MIN_CONNECTIONS", 0)),
+            max_size=int(os.environ.get("REQUEST_DB_MAX_CONNECTIONS", 49)),
+            timeout=int(os.environ.get("REQUEST_DB_TIMEOUT", 120)),
+            command_timeout=int(os.environ.get("REQUEST_DB_COMMAND_TIMEOUT", 180)),
+            max_inactive_connection_lifetime=int(
+                os.environ.get("REQUEST_DB_MAX_INACTIVE_CONN_LIFETIME", 0)
+            ),
+        )
+
+    @staticmethod
+    async def parse_query(
+        query: typing.List[asyncpg.Record],
+    ) -> typing.List[typing.Dict[str, typing.Any]]:
+        """Parse a database query list to JSON serializable form."""
+        return [
+            {
+                "container": rec["container"],
+                "user": rec["recipient"],
+                "owner": rec["container_owner"],
+                "date": rec["created"].isoformat(),
+            }
+            for rec in query
+        ]
+
+    async def add_request(self, user: str, container: str, owner: str) -> bool:
+        """Add an access request to the database."""
+        if self.pool is not None:
+            async with self.pool.acquire() as conn:
+                async with conn.transaction():
+                    await conn.execute(
+                        """
+                        INSERT INTO Requests(
+                            container,
+                            container_owner,
+                            recipient,
+                            created
+                        ) VALUES (
+                            $1, $2, $3, NOW()
+                        );
+                        """,
+                        container,
+                        owner,
+                        user,
+                    )
+                    return True
+        return False
+
+    async def get_request_owned(
+        self, user: str
+    ) -> typing.List[typing.Dict[str, typing.Any]]:
+        """Get the requests owned by the getter."""
+        if self.pool is not None:
+            query = await self.pool.fetch(
+                """
+                SELECT *
+                FROM Requests
+                WHERE container_owner = $1
+                ;
+                """,
+                user,
+            )
+            return await self.parse_query(query)
+        return []
+
+    async def get_request_made(
+        self, user: str
+    ) -> typing.List[typing.Dict[str, typing.Any]]:
+        """Get the requests made by the getter."""
+        if self.pool is not None:
+            query = await self.pool.fetch(
+                """
+                SELECT *
+                FROM Requests
+                WHERE recipient = $1
+                ;
+                """,
+                user,
+            )
+            return await self.parse_query(query)
+        return []
+
+    async def get_request_container(
+        self, container: str
+    ) -> typing.List[typing.Dict[str, typing.Any]]:
+        """Get the requests made for a container."""
+        if self.pool is not None:
+            query = await self.pool.fetch(
+                """
+                SELECT *
+                FROM Requests
+                WHERE container = $1
+                ;
+                """,
+                container,
+            )
+            return await self.parse_query(query)
+        return []
+
+    async def delete_request(self, container: str, owner: str, recipient: str) -> bool:
+        """Delete an access request from the database."""
+        if self.pool is not None:
+            async with self.pool.acquire() as conn:
+                async with conn.transaction():
+                    await conn.execute(
+                        """
+                        DELETE FROM Requests
+                        WHERE
+                            container = $1 AND
+                            container_owner = $2 AND
+                            recipient = $3
+                        ;
+                        """,
+                        container,
+                        owner,
+                        recipient,
+                    )
+                return True
+        return False