Upload 20 files

Dockerfile

@@ -1,9 +1,11 @@
 FROM python:3.11-slim
 
-# Cài system dependencies
+# Cài system dependencies + thêm DNS fallback
 RUN apt-get update && apt-get install -y --no-install-recommends \
-    curl wget git build-essential procps htop nano vim \
-    && rm -rf /var/lib/apt/lists/*
+    curl wget git build-essential procps htop nano vim dnsutils \
+    && rm -rf /var/lib/apt/lists/* \
+    && echo "nameserver 1.1.1.1" >> /etc/resolv.conf \
+    && echo "nameserver 8.8.8.8" >> /etc/resolv.conf
 
 # Cài Node.js 20
 RUN curl -fsSL https://deb.nodesource.com/setup_20.x | bash - \

routers/backup.py

@@ -10,10 +10,12 @@ Requires env var:
 """
 
 import os
+import socket
 import shutil
 import tarfile
 from datetime import datetime
 from pathlib import Path
+from urllib.parse import urlparse
 
 import httpx
 from fastapi import APIRouter, HTTPException, BackgroundTasks, Request
@@ -23,6 +25,77 @@ from storage import load_meta, save_meta, validate_zone_name
 
 router = APIRouter(prefix="/api/backup", tags=["backup"])
 
+# ── Resolve Worker IP at startup to avoid DNS issues in HF Spaces ──
+_worker_ip: str | None = None
+
+def _resolve_worker_ip() -> str | None:
+    """Resolve the Worker hostname to an IP address using system + fallback DNS."""
+    global _worker_ip
+    if _worker_ip:
+        return _worker_ip
+    if not ADMIN_API_URL:
+        return None
+    hostname = urlparse(ADMIN_API_URL).hostname
+    if not hostname:
+        return None
+    # Try system DNS first
+    try:
+        _worker_ip = socket.getaddrinfo(hostname, 443, socket.AF_INET)[0][4][0]
+        return _worker_ip
+    except socket.gaierror:
+        pass
+    # Fallback: query Cloudflare DNS over HTTPS
+    try:
+        import json
+        from urllib.request import urlopen, Request as UrlRequest
+        req = UrlRequest(
+            f"https://1.1.1.1/dns-query?name={hostname}&type=A",
+            headers={"Accept": "application/dns-json"},
+        )
+        with urlopen(req, timeout=5) as resp:
+            data = json.loads(resp.read())
+            for ans in data.get("Answer", []):
+                if ans.get("type") == 1:  # A record
+                    _worker_ip = ans["data"]
+                    return _worker_ip
+    except Exception:
+        pass
+    return None
+
+
+def _make_client(timeout: int = 30) -> httpx.AsyncClient:
+    """Create an httpx AsyncClient."""
+    return httpx.AsyncClient(timeout=timeout)
+
+
+def _make_sync_client(timeout: int = 300) -> httpx.Client:
+    """Create a sync httpx Client."""
+    return httpx.Client(timeout=timeout)
+
+
+def _url(path: str) -> str:
+    """Build the full Worker URL for a given path, using resolved IP if needed."""
+    full = f"{ADMIN_API_URL}{path}"
+    ip = _resolve_worker_ip()
+    if ip:
+        hostname = urlparse(ADMIN_API_URL).hostname or ""
+        return full.replace(hostname, ip)
+    return full
+
+
+def _host_header() -> dict:
+    """Return Host header if using IP-resolved URL."""
+    ip = _resolve_worker_ip()
+    if ip:
+        hostname = urlparse(ADMIN_API_URL).hostname or ""
+        return {"Host": hostname}
+    return {}
+
+
+def _worker_headers(token: str) -> dict:
+    """Build headers for Worker API calls."""
+    return {"Authorization": f"Bearer {token}", **_host_header()}
+
 
 def _get_token(request: Request) -> str:
     """Extract JWT token from request Authorization header."""
@@ -32,11 +105,6 @@ def _get_token(request: Request) -> str:
     return ""
 
 
-def _worker_headers(token: str) -> dict:
-    """Build headers for Worker API calls."""
-    return {"Authorization": f"Bearer {token}"}
-
-
 def _create_zone_archive(zone_name: str) -> Path:
     """Create a tar.gz archive of a zone directory."""
     zone_path = DATA_DIR / zone_name
@@ -72,8 +140,8 @@ async def list_backups(request: Request):
     if not token:
         raise HTTPException(401, "Chua dang nhap")
     try:
-        async with httpx.AsyncClient(timeout=30) as client:
-            resp = await client.get(f"{ADMIN_API_URL}/backup/list", headers=_worker_headers(token))
+        async with _make_client(timeout=30) as client:
+            resp = await client.get(_url("/backup/list"), headers=_worker_headers(token))
             if resp.status_code != 200:
                 data = resp.json() if resp.headers.get("content-type", "").startswith("application/json") else {"error": resp.text}
                 raise HTTPException(resp.status_code, data.get("error", "Worker error"))
@@ -105,10 +173,10 @@ async def backup_zone(zone_name: str, request: Request, background_tasks: Backgr
         try:
             archive_path = _create_zone_archive(zone_name)
             try:
-                with httpx.Client(timeout=300) as client:
+                with _make_sync_client(timeout=300) as client:
                     with open(archive_path, "rb") as f:
                         resp = client.post(
-                            f"{ADMIN_API_URL}/backup/upload/{zone_name}",
+                            _url(f"/backup/upload/{zone_name}"),
                             headers={**_worker_headers(token), "Content-Type": "application/octet-stream"},
                             content=f.read(),
                         )
@@ -153,10 +221,10 @@ async def backup_all(request: Request, background_tasks: BackgroundTasks):
                 _backup_status["progress"] = f"Dang backup zone {zone_name} ({done + 1}/{total})..."
                 archive_path = _create_zone_archive(zone_name)
                 try:
-                    with httpx.Client(timeout=300) as client:
+                    with _make_sync_client(timeout=300) as client:
                         with open(archive_path, "rb") as f:
                             resp = client.post(
-                                f"{ADMIN_API_URL}/backup/upload/{zone_name}",
+                                _url(f"/backup/upload/{zone_name}"),
                                 headers={**_worker_headers(token), "Content-Type": "application/octet-stream"},
                                 content=f.read(),
                             )
@@ -196,8 +264,8 @@ async def restore_zone(zone_name: str, request: Request, background_tasks: Backg
         _backup_status["error"] = None
         _backup_status["progress"] = f"Dang restore zone: {zone_name}..."
         try:
-            with httpx.Client(timeout=300) as client:
-                resp = client.get(f"{ADMIN_API_URL}/backup/download/{zone_name}", headers=_worker_headers(token))
+            with _make_sync_client(timeout=300) as client:
+                resp = client.get(_url(f"/backup/download/{zone_name}"), headers=_worker_headers(token))
                 if resp.status_code == 404:
                     raise ValueError(f"Backup zone '{zone_name}' khong ton tai")
                 if resp.status_code != 200:
@@ -251,8 +319,8 @@ async def restore_all(request: Request, background_tasks: BackgroundTasks):
         _backup_status["error"] = None
         _backup_status["progress"] = "Dang restore tat ca zones..."
         try:
-            with httpx.Client(timeout=30) as client:
-                resp = client.get(f"{ADMIN_API_URL}/backup/list", headers=_worker_headers(token))
+            with _make_sync_client(timeout=30) as client:
+                resp = client.get(_url("/backup/list"), headers=_worker_headers(token))
                 if resp.status_code != 200:
                     raise ValueError(f"Khong the lay danh sach backup: {resp.text}")
                 backup_list = resp.json()
@@ -262,8 +330,8 @@ async def restore_all(request: Request, background_tasks: BackgroundTasks):
             for b in backup_list:
                 zone_name = b["zone_name"]
                 _backup_status["progress"] = f"Dang restore zone {zone_name} ({done + 1}/{total})..."
-                with httpx.Client(timeout=300) as client:
-                    resp = client.get(f"{ADMIN_API_URL}/backup/download/{zone_name}", headers=_worker_headers(token))
+                with _make_sync_client(timeout=300) as client:
+                    resp = client.get(_url(f"/backup/download/{zone_name}"), headers=_worker_headers(token))
                     if resp.status_code != 200:
                         continue
                     archive_path = BACKUP_DIR / f"{zone_name}.tar.gz"
@@ -298,4 +366,4 @@ async def restore_all(request: Request, background_tasks: BackgroundTasks):
             _backup_status["running"] = False
 
     background_tasks.add_task(_run)
-    return {"ok": True, "message": "Dang restore tat ca zones trong nen..."}
+    return {"ok": True, "message": "Dang restore tat ca zones trong nen..."}