497 lines
17 KiB
Python
Executable File
497 lines
17 KiB
Python
Executable File
"""
|
|
NAS Sharing API Module - FolderSharing API calls
|
|
|
|
EXTRACTED từ download_link.py DSMSeleniumLogin methods
|
|
"""
|
|
|
|
import os
|
|
import sys
|
|
import time
|
|
import requests
|
|
import urllib3
|
|
import logging
|
|
from typing import Dict, List, Any, Optional, Union, TYPE_CHECKING
|
|
from urllib.parse import urlencode
|
|
from selenium import webdriver
|
|
from selenium.webdriver.common.by import By
|
|
from selenium.webdriver.support.ui import WebDriverWait
|
|
from selenium.webdriver.support import expected_conditions as EC
|
|
from selenium.common.exceptions import TimeoutException
|
|
|
|
# Disable SSL warnings
|
|
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
|
|
|
|
# Setup logger
|
|
logger = logging.getLogger(__name__)
|
|
logger.setLevel(logging.INFO)
|
|
|
|
if TYPE_CHECKING:
|
|
from ..aria2.download_manager import Aria2DownloadManager
|
|
|
|
# aria2 integration
|
|
USE_ARIA2 = os.getenv('USE_ARIA2', 'true').lower() == 'true'
|
|
# None, False (unavailable), or Aria2DownloadManager
|
|
_aria2_manager: Optional[Union[bool, "Aria2DownloadManager"]] = None
|
|
|
|
|
|
def get_aria2_manager() -> "Aria2DownloadManager":
|
|
"""
|
|
Get or create aria2 manager instance for sharing downloads.
|
|
|
|
Raises:
|
|
RuntimeError: If aria2 is not available
|
|
"""
|
|
global _aria2_manager
|
|
if _aria2_manager is None and USE_ARIA2:
|
|
try:
|
|
from ..aria2.download_manager import get_aria2_manager as _get_manager
|
|
_aria2_manager = _get_manager()
|
|
if not _aria2_manager:
|
|
raise RuntimeError("aria2 manager returned None")
|
|
logger.debug("✅ aria2 manager initialized for Sharing downloads")
|
|
except Exception as e:
|
|
raise RuntimeError(f"aria2 is required but not available: {e}")
|
|
|
|
if _aria2_manager is False or _aria2_manager is None:
|
|
raise RuntimeError("aria2 is required but not initialized")
|
|
|
|
return _aria2_manager # type: ignore
|
|
|
|
|
|
def get_file_list(
|
|
driver: webdriver.Chrome,
|
|
sharing_id: str,
|
|
folder_path: str = "/"
|
|
) -> List[Dict[str, Any]]:
|
|
"""
|
|
Lấy danh sách file/folder từ sharing link qua FolderSharing.List API
|
|
|
|
Args:
|
|
driver: Selenium WebDriver có cookies hợp lệ
|
|
sharing_id: Sharing ID (trích xuất từ URL)
|
|
folder_path: Đường dẫn folder cần list (mặc định: "/")
|
|
|
|
Returns:
|
|
List of file/folder dicts với các key:
|
|
- name: Tên file/folder
|
|
- is_folder: True nếu là folder
|
|
- size: Chuỗi size đã format
|
|
- size_bytes: Size tính bằng bytes
|
|
- path: Đường dẫn đầy đủ
|
|
- additional: Metadata bổ sung từ API
|
|
|
|
Raises:
|
|
RuntimeError: Khi session hết hạn (error 101) hoặc lỗi API khác
|
|
"""
|
|
# Tạo session với cookies từ Selenium
|
|
session = requests.Session()
|
|
for cookie in driver.get_cookies():
|
|
session.cookies.set(
|
|
cookie['name'], cookie['value'], domain=cookie['domain'])
|
|
|
|
# Endpoint FolderSharing.List API
|
|
url = "https://disk.lezhin.com:5001/sharing/webapi/entry.cgi"
|
|
params = {
|
|
'api': 'SYNO.FolderSharing.List',
|
|
'method': 'list',
|
|
'version': '2',
|
|
'offset': '0',
|
|
'limit': '1000',
|
|
'sort_by': '"name"',
|
|
'sort_direction': '"ASC"',
|
|
'action': '"enum"',
|
|
'additional': '["size","owner","time","perm","type","mount_point_type"]',
|
|
'filetype': '"all"',
|
|
'folder_path': f'"{folder_path}"',
|
|
'_sharing_id': f'"{sharing_id}"'
|
|
}
|
|
|
|
# Log với context rõ ràng hơn
|
|
import inspect
|
|
caller = inspect.stack()[1].function if len(
|
|
inspect.stack()) > 1 else "unknown"
|
|
print(f"\n🔍 [{caller}] Lấy danh sách (FolderSharing API): {folder_path}")
|
|
|
|
# NO RETRY - Throw error ngay để phát hiện vấn đề sớm
|
|
try:
|
|
response = session.post(url, data=params, verify=False, timeout=30)
|
|
result = response.json()
|
|
|
|
# Kiểm tra response
|
|
if not result:
|
|
raise RuntimeError("API không trả về dữ liệu")
|
|
|
|
# Kiểm tra success
|
|
if not result.get("success"):
|
|
error_code = result.get('error', {}).get('code')
|
|
error_detail = result.get('error', {})
|
|
print(f"❌ API lỗi {error_code}: {error_detail}")
|
|
|
|
# Error 101: Session hết hạn
|
|
if error_code == 101:
|
|
raise RuntimeError("SESSION_EXPIRED")
|
|
|
|
# Error 407: Rate limit - KHÔNG RETRY, throw ngay
|
|
# (Frontend có debounce 300ms + Backend có rate limit 500ms)
|
|
if error_code == 407:
|
|
raise RuntimeError(f"API_ERROR_407_RATE_LIMIT: {error_detail}")
|
|
|
|
# Các lỗi API khác
|
|
raise RuntimeError(f"API_ERROR_{error_code}: {error_detail}")
|
|
|
|
# Parse file list
|
|
files = result['data']['files']
|
|
print(f"✅ Thành công! Tìm thấy {len(files)} item(s).")
|
|
|
|
# Format file list
|
|
formatted = []
|
|
for f in files:
|
|
is_folder = f.get('isdir', False)
|
|
|
|
# Lấy size (chỉ cho files, không có cho folders)
|
|
size_bytes = 0
|
|
if not is_folder and f.get('additional') and f['additional'].get('size'):
|
|
size_bytes = f['additional']['size']
|
|
|
|
# Format size string (rỗng cho folders)
|
|
size_str = "" if is_folder else _format_size(size_bytes)
|
|
|
|
formatted.append({
|
|
'name': f.get('name', ''),
|
|
'is_folder': is_folder,
|
|
'size': size_str,
|
|
'size_bytes': size_bytes,
|
|
'path': f.get('path', ''),
|
|
'additional': f.get('additional', {})
|
|
})
|
|
|
|
return formatted
|
|
|
|
except RuntimeError:
|
|
# RuntimeError (SESSION_EXPIRED, API_ERROR_xxx) → raise ngay
|
|
raise
|
|
|
|
except requests.exceptions.Timeout as e:
|
|
# Network timeout - KHÔNG RETRY, throw ngay
|
|
print(f"❌ Timeout khi gọi API: {e}")
|
|
raise RuntimeError(f"API_TIMEOUT: {e}") from e
|
|
|
|
except requests.exceptions.RequestException as e:
|
|
# Network/Request errors - KHÔNG RETRY, throw ngay
|
|
print(f"❌ Network error khi gọi API: {e}")
|
|
raise RuntimeError(f"API_NETWORK_ERROR: {e}") from e
|
|
|
|
|
|
def encode_path_to_dlink(path: str) -> str:
|
|
"""
|
|
Encode path to dlink token (hex encoding)
|
|
|
|
EXACT COPY từ download_link.py DSMSeleniumLogin.encode_path_to_dlink()
|
|
|
|
Args:
|
|
path: File path, e.g., "/수조(북극여우)/001화_PSD_JPG.zip"
|
|
|
|
Returns:
|
|
Hex-encoded path string for dlink parameter
|
|
"""
|
|
# Encode path to bytes (UTF-8) then convert to hex
|
|
path_bytes = path.encode('utf-8')
|
|
dlink_hex = path_bytes.hex()
|
|
return dlink_hex
|
|
|
|
|
|
def download_file_direct(
|
|
driver: webdriver.Chrome,
|
|
sharing_id: str,
|
|
remote_path: str,
|
|
is_dir: bool = False,
|
|
save_path: Optional[str] = None,
|
|
progress_callback=None
|
|
) -> bool:
|
|
"""
|
|
⚠️ DEPRECATED - DO NOT USE
|
|
|
|
This function uses requests library instead of aria2.
|
|
All downloads MUST use aria2 for parallel connections.
|
|
|
|
Use prepare_download_url() + aria2_manager.download_file() instead.
|
|
|
|
Kept for reference only - will be removed in future versions.
|
|
"""
|
|
raise NotImplementedError(
|
|
"download_file_direct() is deprecated. "
|
|
"Use prepare_download_url() + aria2_manager.download_file() instead. "
|
|
"All downloads MUST use aria2."
|
|
)
|
|
|
|
# Old implementation removed - see git history if needed
|
|
if not save_path:
|
|
raise ValueError("save_path is required")
|
|
|
|
|
|
def prepare_download_url(
|
|
driver: webdriver.Chrome,
|
|
sharing_id: str,
|
|
remote_path: str,
|
|
file_name: str
|
|
) -> tuple[str, str]:
|
|
"""
|
|
Extract cookies and build download URL from Selenium driver.
|
|
|
|
This function MUST be called with driver_lock held.
|
|
Returns URL and cookies that can be used for aria2 download WITHOUT driver.
|
|
|
|
Args:
|
|
driver: Selenium WebDriver with valid cookies
|
|
sharing_id: Sharing ID
|
|
remote_path: File/folder path in NAS
|
|
file_name: Filename for URL path
|
|
|
|
Returns:
|
|
(download_url, cookie_string) tuple
|
|
"""
|
|
# Extract cookies from Selenium
|
|
cookie_string = "; ".join([
|
|
f"{c['name']}={c['value']}"
|
|
for c in driver.get_cookies()
|
|
])
|
|
|
|
# Convert path to dlink (hex-encoded) for BOTH files and folders
|
|
dlink = encode_path_to_dlink(remote_path)
|
|
|
|
# Build GET request URL (same for files and folders)
|
|
url = f"https://disk.lezhin.com:5001/fsdownload/webapi/file_download.cgi/{file_name}"
|
|
params = {
|
|
'dlink': f'"{dlink}"',
|
|
'noCache': str(int(time.time() * 1000)),
|
|
'_sharing_id': f'"{sharing_id}"',
|
|
'api': 'SYNO.FolderSharing.Download',
|
|
'version': '2',
|
|
'method': 'download',
|
|
'mode': 'download',
|
|
'stdhtml': 'false'
|
|
}
|
|
|
|
download_url = f"{url}?{urlencode(params)}"
|
|
|
|
return download_url, cookie_string
|
|
|
|
|
|
def validate_download_link(
|
|
download_url: str,
|
|
cookie_string: str,
|
|
timeout: int = 10
|
|
) -> tuple[bool, Optional[str], Optional[int]]:
|
|
"""
|
|
Validate download link bằng HEAD request để phát hiện link chết TRƯỚC KHI tải.
|
|
|
|
Giải pháp cho vấn đề: Files pending lâu → Link expire → Download 38B HTML error page
|
|
|
|
Args:
|
|
download_url: URL download đã build từ prepare_download_url()
|
|
cookie_string: Cookie string từ prepare_download_url()
|
|
timeout: Timeout cho HEAD request (giây)
|
|
|
|
Returns:
|
|
(is_valid, error_message, content_length) tuple:
|
|
- is_valid: True nếu link OK, False nếu chết
|
|
- error_message: None nếu OK, error string nếu failed
|
|
- content_length: File size (bytes) nếu có, None nếu không xác định
|
|
|
|
Raises:
|
|
RuntimeError: Nếu có lỗi network/timeout
|
|
"""
|
|
import requests
|
|
|
|
try:
|
|
# Prepare headers
|
|
headers = {
|
|
'Cookie': cookie_string,
|
|
'Referer': 'https://disk.lezhin.com:5001/',
|
|
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
|
|
}
|
|
|
|
logger.debug(
|
|
f"[validate_link] Sending HEAD request to validate link...")
|
|
|
|
# Send HEAD request (lightweight, chỉ lấy headers)
|
|
response = requests.head(
|
|
download_url,
|
|
headers=headers,
|
|
timeout=timeout,
|
|
verify=False, # NAS self-signed cert
|
|
allow_redirects=True
|
|
)
|
|
|
|
# Check status code
|
|
if response.status_code == 200:
|
|
# Link OK!
|
|
content_length = response.headers.get('Content-Length')
|
|
size_bytes = int(content_length) if content_length else None
|
|
|
|
# Check Content-Type để phát hiện HTML error page
|
|
content_type = response.headers.get('Content-Type', '')
|
|
|
|
if 'text/html' in content_type.lower():
|
|
# NAS trả về HTML thay vì file → Link có vấn đề
|
|
error_msg = f"Link trả về HTML (possibly expired or error page). Content-Type: {content_type}"
|
|
logger.warning(f"[validate_link] ❌ {error_msg}")
|
|
return False, error_msg, None
|
|
|
|
# Link hợp lệ
|
|
size_str = f"{size_bytes:,} bytes" if size_bytes else "unknown size"
|
|
logger.debug(f"[validate_link] ✅ Link valid ({size_str})")
|
|
return True, None, size_bytes
|
|
|
|
elif response.status_code == 401:
|
|
# Unauthorized → Session expired
|
|
error_msg = "Session expired (401 Unauthorized)"
|
|
logger.warning(f"[validate_link] ❌ {error_msg}")
|
|
return False, error_msg, None
|
|
|
|
elif response.status_code == 403:
|
|
# Forbidden → Permission denied
|
|
error_msg = "Permission denied (403 Forbidden)"
|
|
logger.warning(f"[validate_link] ❌ {error_msg}")
|
|
return False, error_msg, None
|
|
|
|
elif response.status_code == 404:
|
|
# Not found → File không tồn tại
|
|
error_msg = "File not found (404)"
|
|
logger.warning(f"[validate_link] ❌ {error_msg}")
|
|
return False, error_msg, None
|
|
|
|
else:
|
|
# Unexpected status code
|
|
error_msg = f"Unexpected HTTP status: {response.status_code}"
|
|
logger.warning(f"[validate_link] ⚠️ {error_msg}")
|
|
return False, error_msg, None
|
|
|
|
except requests.exceptions.Timeout as e:
|
|
error_msg = f"Timeout after {timeout}s: {e}"
|
|
logger.error(f"[validate_link] ❌ {error_msg}")
|
|
raise RuntimeError(error_msg) from e
|
|
|
|
except requests.exceptions.RequestException as e:
|
|
error_msg = f"Network error: {e}"
|
|
logger.error(f"[validate_link] ❌ {error_msg}")
|
|
raise RuntimeError(error_msg) from e
|
|
|
|
except Exception as e:
|
|
error_msg = f"Unexpected error: {e}"
|
|
logger.error(f"[validate_link] ❌ {error_msg}")
|
|
raise RuntimeError(error_msg) from e
|
|
|
|
|
|
def get_initial_path(driver: webdriver.Chrome) -> str:
|
|
"""
|
|
Lấy folder path hiện tại từ thanh điều hướng (path bar) trên trang sharing.
|
|
|
|
Workflow:
|
|
1. Chờ path bar xuất hiện (tối đa 15s)
|
|
2. Nếu timeout → Check login dialog
|
|
3. Nếu có login dialog → raise NEEDS_LOGIN
|
|
4. Nếu không có cả 2 → raise error
|
|
|
|
Args:
|
|
driver: Selenium WebDriver đang ở trang sharing
|
|
|
|
Returns:
|
|
Path của folder hiện tại từ thanh điều hướng
|
|
|
|
Raises:
|
|
RuntimeError:
|
|
- "NEEDS_LOGIN" nếu phát hiện login dialog
|
|
- Error khác nếu không tìm thấy path bar
|
|
"""
|
|
if not driver:
|
|
raise RuntimeError("Driver không tồn tại")
|
|
|
|
# BƯỚC 1: Chờ folder path bar xuất hiện (tối đa 15s)
|
|
print("🔍 Đang chờ folder path bar xuất hiện (timeout 15s)...")
|
|
|
|
try:
|
|
path_btn = WebDriverWait(driver, 15).until(
|
|
EC.presence_of_element_located((By.CSS_SELECTOR,
|
|
"li table.x-btn button.x-btn-text[aria-label]"))
|
|
)
|
|
|
|
folder_name = path_btn.get_attribute('aria-label')
|
|
if folder_name:
|
|
path = f"/{folder_name}"
|
|
print(f"✅ Phát hiện folder path: {path}")
|
|
return path
|
|
|
|
# aria-label rỗng → fallback check login
|
|
print("⚠️ Path bar không có aria-label, kiểm tra login dialog...")
|
|
|
|
except TimeoutException:
|
|
# Timeout 15s - không tìm thấy path bar
|
|
print("⚠️ Timeout: Không tìm thấy folder path bar sau 15 giây")
|
|
|
|
# BƯỚC 2: Path bar không có → Check login dialog
|
|
print("🔍 Kiểm tra login dialog...")
|
|
try:
|
|
login_dialog = driver.find_element(
|
|
By.CSS_SELECTOR, "div#webfm-access-dialog")
|
|
if login_dialog and login_dialog.is_displayed():
|
|
print("⚠️ Phát hiện login dialog - cần đăng nhập File Station")
|
|
raise RuntimeError("NEEDS_LOGIN")
|
|
except Exception as e:
|
|
# Không tìm thấy login dialog hoặc lỗi khác
|
|
if "NEEDS_LOGIN" in str(e):
|
|
raise
|
|
print(f"⚠️ Không tìm thấy login dialog: {e}")
|
|
|
|
# BƯỚC 3: Không có path bar và không có login dialog → THROW ERROR
|
|
current_url = driver.current_url if driver else "unknown"
|
|
raise RuntimeError(
|
|
f"Không tìm thấy folder path bar trên trang sharing sau 15 giây. "
|
|
f"URL: {current_url}"
|
|
)
|
|
|
|
|
|
def extract_sharing_id(url: str) -> Optional[str]:
|
|
"""
|
|
Extract sharing ID from sharing link URL
|
|
|
|
Args:
|
|
url: Sharing link URL (e.g., "https://disk.lezhin.com:5001/sharing/ABC123/...")
|
|
|
|
Returns:
|
|
Sharing ID string, or None if invalid format
|
|
"""
|
|
try:
|
|
parts = url.split('/sharing/')
|
|
if len(parts) < 2:
|
|
return None
|
|
|
|
sharing_id = parts[1].split('/')[0].split('?')[0]
|
|
return sharing_id
|
|
|
|
except Exception as e:
|
|
print(f"❌ Lỗi extract_sharing_id: {e}")
|
|
return None
|
|
|
|
|
|
def _format_size(size_bytes: int) -> str:
|
|
"""
|
|
Helper: Format bytes to human-readable size
|
|
|
|
Args:
|
|
size_bytes: Size in bytes
|
|
|
|
Returns:
|
|
Formatted string (e.g., "1.5 MB")
|
|
"""
|
|
if size_bytes == 0:
|
|
return ""
|
|
elif size_bytes < 1024:
|
|
return f"{size_bytes} B"
|
|
elif size_bytes < 1024 * 1024:
|
|
return f"{size_bytes / 1024:.2f} KB"
|
|
elif size_bytes < 1024 * 1024 * 1024:
|
|
return f"{size_bytes / (1024 * 1024):.2f} MB"
|
|
else:
|
|
return f"{size_bytes / (1024 * 1024 * 1024):.2f} GB"
|