feat(api): sync dokku with database's service table

Author: JeanExtreme002

src/api/app.py

@@ -10,16 +10,17 @@
 
 from src.api.middlewares import SessionUserMiddleware
 from src.api.router import get_router
-from src.api.services import AppService
+from src.api.services import AppService, DatabaseService
 from src.config import Config
 
 APP_ROOT = Path(__file__).parent
 
 scheduler = AsyncIOScheduler()
 
 
-async def sync_database_with_dokku():
-    await AppService.sync_database()
+async def sync_dokku_with_api_database():
+    await DatabaseService.sync_dokku_with_api_database()
+    await AppService.sync_dokku_with_api_database()
 
 
 def get_app() -> FastAPI:
@@ -51,7 +52,7 @@ def get_app() -> FastAPI:
     async def startup():
         scheduler.start()
         scheduler.add_job(
-            sync_database_with_dokku,
+            sync_dokku_with_api_database,
             trigger=IntervalTrigger(hours=1),
             id="sync_db_w_dokku_task",
             replace_existing=True,

src/api/services/apps.py

@@ -575,13 +575,14 @@ async def download_file(
             return False, f"Failed to parse xxd output: {error}"
 
     @staticmethod
-    async def sync_database() -> None:
+    async def sync_dokku_with_api_database() -> None:
         success, message = await run_command("apps:list")
 
         if not success:
-            raise SystemError("Could not recover apps list to sync database")
+            logging.warning("Could not recover apps list to sync with database")
+            return
 
-        logging.warning("[sync_app_database]::Syncing database...")
+        logging.warning("[sync_dokku_w_app_database]::Syncing Dokku...")
 
         apps = parse_apps_list(message)
         apps = {name: True for name in apps if get_user_id_from_app(name) is not None}
@@ -593,8 +594,8 @@ async def sync_database() -> None:
 
         for app_name in apps:
             logging.warning(
-                f"[sync_app_database]:{app_name}::Destroying unused application..."
+                f"[sync_dokku_w_app_database]:{app_name}::Destroying unused application..."
             )
             await run_command(f"--force apps:destroy {app_name}")
 
-        logging.warning("[sync_app_database]::Sync complete.")
+        logging.warning("[sync_dokku_w_app_database]::Sync complete.")

src/api/services/databases.py

@@ -1,11 +1,12 @@
 import asyncio
+import logging
 import re
 from abc import ABC
-from typing import Any, Dict, Tuple
+from typing import Any, Dict, Optional, Tuple
 
 from fastapi import HTTPException
 
-from src.api.models import App, Service, create_resource, delete_resource
+from src.api.models import App, Service, create_resource, delete_resource, get_resources
 from src.api.schemas import UserSchema
 from src.api.tools.name import ResourceName
 from src.api.tools.ssh import run_command
@@ -29,6 +30,26 @@ def parse_service_info(plugin_name: str, info_str: str) -> Dict:
     return result
 
 
+def parse_service_list(text: str):
+    """
+    Extract the list of services from a formatted string.
+    """
+    lines = text.strip().split("\n")
+    apps = [
+        line.strip() for line in lines if line.strip() and not line.startswith("=====>")
+    ]
+    return apps
+
+
+def get_user_id_from_service(name) -> Optional[int]:
+    id = name.split("_", maxsplit=1)[0]
+
+    try:
+        return int(id)
+    except ValueError:
+        return None
+
+
 def extract_database_uri(text):
     pattern = re.compile(
         r"\b(?:[a-z]+)://(?:[^:@\s]+):(?:[^:@\s]+)@(?:[^:@\s]+):\d+/\S+\b",
@@ -358,3 +379,37 @@ async def restart_database(
             return False, None
 
         return True, message
+
+    @staticmethod
+    async def sync_dokku_with_api_database() -> None:
+        available_databases = (await DatabaseService.list_available_databases())[1]
+        services = {}
+
+        for plugin_name in available_databases:
+            success, message = await run_command(f"{plugin_name}:list")
+
+            if not success:
+                logging.warning(
+                    f"Could not recover {plugin_name} services list to sync with database"
+                )
+                continue
+
+            for name in parse_service_list(message):
+                if get_user_id_from_service(name):
+                    services[f"{plugin_name}:{name}"] = True
+
+        logging.warning("[sync_dokku_w_service_database]::Syncing Dokku...")
+
+        db_services = await get_resources(Service, offset=0, limit=None)
+
+        for service in db_services:
+            services.pop(service["name"], None)
+
+        for service_name in services:
+            plugin_name, service_name = service_name.split(":", maxsplit=1)
+            logging.warning(
+                f"[sync_dokku_w_service_database]:{plugin_name}:{service_name}::Destroying unused service..."
+            )
+            await run_command(f"--force {plugin_name}:destroy {service_name}")
+
+        logging.warning("[sync_dokku_w_service_database]::Sync complete.")