feat(node): get user all ips with single request

Author: M03ED

app/models/node.py

@@ -173,3 +173,15 @@ class NodeNotification(BaseModel):
     message: str | None = None
 
     model_config = ConfigDict(from_attributes=True)
+
+
+class UserIPList(BaseModel):
+    """User IP list - mapping of IP addresses to connection counts"""
+
+    ips: dict[str, int]  # {ip_address: connection_count}
+
+
+class UserIPListAll(BaseModel):
+    """User IP lists for all nodes"""
+
+    nodes: dict[int, UserIPList | None]  # {node_id: UserIPList | None}

app/operation/node.py

@@ -23,7 +23,7 @@
 from app.db.crud.user import get_user
 from app.db.models import Node, NodeStatus
 from app.models.admin import AdminDetails
-from app.models.node import NodeCreate, NodeModify, NodeNotification, NodeResponse, UsageTable
+from app.models.node import NodeCreate, NodeModify, NodeNotification, NodeResponse, UsageTable, UserIPList, UserIPListAll
 from app.models.stats import NodeRealtimeStats, NodeStatsList, NodeUsageStatsList, Period
 from app.node import core_users, node_manager
 from app.operation import BaseOperation
@@ -416,25 +416,55 @@ async def get_user_online_stats_by_node(self, db: AsyncSession, node_id: Node, u
 
     async def get_user_ip_list_by_node(
         self, db: AsyncSession, node_id: Node, username: str
-    ) -> dict[int, dict[str, int]]:
+    ) -> UserIPList:
         db_user = await get_user(db, username=username)
         if db_user is None:
             await self.raise_error(message="User not found", code=404)
 
-        node = await node_manager.get_node(node_id)
+        email = f"{db_user.id}.{db_user.username}"
+        ips = await self._get_node_user_ip_list_safe(node_id, email)
 
-        if node is None:
-            await self.raise_error(message="Node not found", code=404)
+        if ips is None:
+            await self.raise_error(message="Node not found or unavailable", code=404)
+
+        return UserIPList(ips=ips)
+
+    async def get_user_ip_list_all_nodes(self, db: AsyncSession, username: str) -> UserIPListAll:
+        db_user = await get_user(db, username=username)
+        if db_user is None:
+            await self.raise_error(message="User not found", code=404)
+
+        nodes = await node_manager.get_healthy_nodes()
+        email = f"{db_user.id}.{db_user.username}"
+
+        ip_list_tasks = {id: asyncio.create_task(self._get_node_user_ip_list_safe(id, email)) for id, _ in nodes}
+
+        await asyncio.gather(*ip_list_tasks.values(), return_exceptions=True)
+
+        results = {}
+        for node_id, task in ip_list_tasks.items():
+            if task.exception() or task.result() is None:
+                results[node_id] = None
+            else:
+                results[node_id] = UserIPList(ips=task.result())
+
+        return UserIPListAll(nodes=results)
 
+    async def _get_node_user_ip_list_safe(self, node_id: int, email: str) -> dict[str, int] | None:
+        """Wrapper method that returns None instead of raising exceptions"""
         try:
-            stats = await node.get_user_online_ip_list(email=f"{db_user.id}.{db_user.username}")
-        except NodeAPIError as e:
-            await self.raise_error(message=e.detail, code=e.code)
+            node = await node_manager.get_node(node_id)
+            if node is None:
+                return None
 
-        if stats is None:
-            await self.raise_error(message="Stats not found", code=404)
+            stats = await node.get_user_online_ip_list(email=email)
+            if stats is None:
+                return None
 
-        return {node_id: stats.ips}
+            return stats.ips
+        except Exception as e:
+            logger.error(f"Error getting IP list for user {email} on node {node_id}: {e}")
+            return None
 
     async def sync_node_users(self, db: AsyncSession, node_id: int, flush_users: bool = False) -> NodeResponse:
         db_node = await self.get_validated_node(db, node_id=node_id)

app/routers/node.py

@@ -8,7 +8,7 @@
 
 from app.db import AsyncSession, get_db
 from app.models.admin import AdminDetails
-from app.models.node import NodeCreate, NodeModify, NodeResponse, NodeSettings, UsageTable
+from app.models.node import NodeCreate, NodeModify, NodeResponse, NodeSettings, UsageTable, UserIPList, UserIPListAll
 from app.models.stats import NodeRealtimeStats, NodeStatsList, NodeUsageStatsList, Period
 from app.operation import OperatorType
 from app.operation.node import NodeOperation
@@ -177,6 +177,14 @@ async def realtime_nodes_stats(_: AdminDetails = Depends(check_sudo_admin)):
     return await node_operator.get_nodes_system_stats()
 
 
+@router.get("/online_stats/{username}/ip", response_model=UserIPListAll)
+async def user_online_ip_list_all_nodes(
+    username: str, db: AsyncSession = Depends(get_db), _: AdminDetails = Depends(check_sudo_admin)
+):
+    """Retrieve user ips from all nodes."""
+    return await node_operator.get_user_ip_list_all_nodes(db=db, username=username)
+
+
 @router.get("/{node_id}/online_stats/{username}", response_model=dict[int, int])
 async def user_online_stats(
     node_id: int, username: str, db: AsyncSession = Depends(get_db), _: AdminDetails = Depends(check_sudo_admin)
@@ -185,7 +193,7 @@ async def user_online_stats(
     return await node_operator.get_user_online_stats_by_node(db=db, node_id=node_id, username=username)
 
 
-@router.get("/{node_id}/online_stats/{username}/ip", response_model=dict[int, dict[str, int]])
+@router.get("/{node_id}/online_stats/{username}/ip", response_model=UserIPList)
 async def user_online_ip_list(
     node_id: int, username: str, db: AsyncSession = Depends(get_db), _: AdminDetails = Depends(check_sudo_admin)
 ):