Upload 20 files

routers/backup.py

@@ -10,12 +10,10 @@ 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
@@ -25,76 +23,15 @@ 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 _worker_headers(token: str) -> dict:
+    """Build headers for Worker API calls."""
+    return {"Authorization": f"Bearer {token}"}
 
 
 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()}
+    """Build the full Worker URL for a given path."""
+    return f"{ADMIN_API_URL}{path}"
 
 
 def _get_token(request: Request) -> str:
@@ -140,7 +77,7 @@ async def list_backups(request: Request):
     if not token:
         raise HTTPException(401, "Chua dang nhap")
     try:
-        async with _make_client(timeout=30) as client:
+        async with httpx.AsyncClient(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}
@@ -173,7 +110,7 @@ async def backup_zone(zone_name: str, request: Request, background_tasks: Backgr
         try:
             archive_path = _create_zone_archive(zone_name)
             try:
-                with _make_sync_client(timeout=300) as client:
+                with httpx.Client(timeout=300) as client:
                     with open(archive_path, "rb") as f:
                         resp = client.post(
                             _url(f"/backup/upload/{zone_name}"),
@@ -221,7 +158,7 @@ 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 _make_sync_client(timeout=300) as client:
+                    with httpx.Client(timeout=300) as client:
                         with open(archive_path, "rb") as f:
                             resp = client.post(
                                 _url(f"/backup/upload/{zone_name}"),
@@ -264,7 +201,7 @@ 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 _make_sync_client(timeout=300) as client:
+            with httpx.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")
@@ -319,7 +256,7 @@ async def restore_all(request: Request, background_tasks: BackgroundTasks):
         _backup_status["error"] = None
         _backup_status["progress"] = "Dang restore tat ca zones..."
         try:
-            with _make_sync_client(timeout=30) as client:
+            with httpx.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}")
@@ -330,7 +267,7 @@ 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 _make_sync_client(timeout=300) as client:
+                with httpx.Client(timeout=300) as client:
                     resp = client.get(_url(f"/backup/download/{zone_name}"), headers=_worker_headers(token))
                     if resp.status_code != 200:
                         continue