513 lines
21 KiB
Python
513 lines
21 KiB
Python
"""
|
|
cdndania.com CDN 전용 다운로더 (curl_cffi 사용)
|
|
- 동일한 세션(TLS 핑거프린트)으로 m3u8 추출과 세그먼트 다운로드 수행
|
|
- CDN 보안 검증 우회
|
|
- subprocess로 분리 실행하여 Flask 블로킹 방지
|
|
"""
|
|
import os
|
|
import sys
|
|
import time
|
|
import json
|
|
import logging
|
|
import subprocess
|
|
import tempfile
|
|
import threading
|
|
from urllib.parse import urljoin, urlparse
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class CdndaniaDownloader:
|
|
"""cdndania.com 전용 다운로더 (세션 기반 보안 우회)"""
|
|
|
|
def __init__(self, iframe_src, output_path, referer_url=None, callback=None, proxy=None, threads=16):
|
|
self.iframe_src = iframe_src # cdndania.com 플레이어 iframe URL
|
|
self.output_path = output_path
|
|
self.referer_url = referer_url or "https://ani.ohli24.com/"
|
|
self.callback = callback
|
|
self.proxy = proxy
|
|
self.threads = threads
|
|
self.cancelled = False
|
|
|
|
# 진행 상황 추적
|
|
self.start_time = None
|
|
self.total_bytes = 0
|
|
self.current_speed = 0
|
|
self.process = None
|
|
|
|
def download(self):
|
|
"""subprocess로 다운로드 실행 (Flask 블로킹 방지)"""
|
|
try:
|
|
# 현재 파일 경로 (subprocess에서 실행할 스크립트)
|
|
script_path = os.path.abspath(__file__)
|
|
|
|
# 진행 상황 파일
|
|
progress_file = tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False)
|
|
progress_path = progress_file.name
|
|
progress_file.close()
|
|
|
|
# subprocess 실행
|
|
cmd = [
|
|
sys.executable, script_path,
|
|
self.iframe_src,
|
|
self.output_path,
|
|
self.referer_url or "",
|
|
self.proxy or "",
|
|
progress_path,
|
|
str(self.threads)
|
|
]
|
|
|
|
logger.info(f"Starting download subprocess: {self.iframe_src}")
|
|
logger.info(f"Output: {self.output_path}")
|
|
logger.info(f"Progress file: {progress_path}")
|
|
|
|
# subprocess 시작 (non-blocking)
|
|
self.process = subprocess.Popen(
|
|
cmd,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.PIPE,
|
|
text=True
|
|
)
|
|
|
|
self.start_time = time.time()
|
|
last_callback_time = 0
|
|
|
|
# 진행 상황 모니터링 (별도 스레드 불필요, 메인에서 폴링)
|
|
while self.process.poll() is None:
|
|
if self.cancelled:
|
|
self.process.terminate()
|
|
try:
|
|
os.unlink(progress_path)
|
|
except:
|
|
pass
|
|
return False, "Cancelled by user"
|
|
|
|
# 진행 상황 읽기 (0.5초마다)
|
|
current_time = time.time()
|
|
if current_time - last_callback_time >= 0.5:
|
|
last_callback_time = current_time
|
|
try:
|
|
if os.path.exists(progress_path):
|
|
with open(progress_path, 'r') as f:
|
|
content = f.read().strip()
|
|
if content:
|
|
progress = json.loads(content)
|
|
if self.callback and progress.get('percent', 0) > 0:
|
|
self.callback(
|
|
percent=progress.get('percent', 0),
|
|
current=progress.get('current', 0),
|
|
total=progress.get('total', 0),
|
|
speed=progress.get('speed', ''),
|
|
elapsed=progress.get('elapsed', '')
|
|
)
|
|
except (json.JSONDecodeError, IOError):
|
|
pass
|
|
|
|
time.sleep(0.1) # CPU 사용률 줄이기
|
|
|
|
# 프로세스 종료 후 결과 확인
|
|
stdout, stderr = self.process.communicate()
|
|
|
|
# 진행 상황 파일 삭제
|
|
try:
|
|
os.unlink(progress_path)
|
|
except:
|
|
pass
|
|
|
|
if self.process.returncode == 0:
|
|
# 출력 파일 확인
|
|
if os.path.exists(self.output_path):
|
|
file_size = os.path.getsize(self.output_path)
|
|
if file_size > 10000: # 10KB 이상
|
|
logger.info(f"Download completed: {self.output_path} ({file_size / 1024 / 1024:.1f}MB)")
|
|
return True, "Download completed"
|
|
else:
|
|
logger.error(f"Output file too small: {file_size}B")
|
|
return False, f"Output file too small: {file_size}B"
|
|
else:
|
|
logger.error(f"Output file not found: {self.output_path}")
|
|
return False, "Output file not created"
|
|
else:
|
|
# stderr에서 에러 메시지 추출
|
|
error_msg = stderr.strip() if stderr else f"Process exited with code {self.process.returncode}"
|
|
logger.error(f"Download failed: {error_msg}")
|
|
return False, error_msg
|
|
|
|
except Exception as e:
|
|
logger.error(f"CdndaniaDownloader error: {e}")
|
|
import traceback
|
|
logger.error(traceback.format_exc())
|
|
return False, str(e)
|
|
|
|
def cancel(self):
|
|
"""다운로드 취소"""
|
|
self.cancelled = True
|
|
if self.process:
|
|
self.process.terminate()
|
|
|
|
|
|
def _download_worker(iframe_src, output_path, referer_url, proxy, progress_path, threads=16):
|
|
"""실제 다운로드 작업 (subprocess에서 실행)"""
|
|
import sys
|
|
import os
|
|
import time
|
|
import json
|
|
import tempfile
|
|
from urllib.parse import urljoin
|
|
|
|
# 로깅 설정 (subprocess용)
|
|
import logging
|
|
logging.basicConfig(
|
|
level=logging.INFO,
|
|
format='[%(asctime)s|%(levelname)s|%(name)s] %(message)s',
|
|
handlers=[logging.StreamHandler(sys.stderr)]
|
|
)
|
|
log = logging.getLogger(__name__)
|
|
|
|
def update_progress(percent, current, total, speed, elapsed):
|
|
"""진행 상황을 파일에 저장"""
|
|
try:
|
|
with open(progress_path, 'w') as f:
|
|
json.dump({
|
|
'percent': percent,
|
|
'current': current,
|
|
'total': total,
|
|
'speed': speed,
|
|
'elapsed': elapsed
|
|
}, f)
|
|
except:
|
|
pass
|
|
|
|
def format_speed(bytes_per_sec):
|
|
if bytes_per_sec < 1024:
|
|
return f"{bytes_per_sec:.0f} B/s"
|
|
elif bytes_per_sec < 1024 * 1024:
|
|
return f"{bytes_per_sec / 1024:.1f} KB/s"
|
|
else:
|
|
return f"{bytes_per_sec / (1024 * 1024):.2f} MB/s"
|
|
|
|
def format_time(seconds):
|
|
seconds = int(seconds)
|
|
if seconds < 60:
|
|
return f"{seconds}초"
|
|
elif seconds < 3600:
|
|
return f"{seconds // 60}분 {seconds % 60}초"
|
|
else:
|
|
return f"{seconds // 3600}시간 {(seconds % 3600) // 60}분"
|
|
|
|
try:
|
|
# curl_cffi 임포트
|
|
try:
|
|
from curl_cffi import requests as cffi_requests
|
|
except ImportError:
|
|
subprocess.run([sys.executable, "-m", "pip", "install", "curl_cffi", "-q"],
|
|
timeout=120, check=True)
|
|
from curl_cffi import requests as cffi_requests
|
|
|
|
# 세션 생성 (Chrome 120 TLS 핑거프린트 사용)
|
|
session = cffi_requests.Session(impersonate="chrome120")
|
|
|
|
proxies = None
|
|
if proxy:
|
|
proxies = {"http": proxy, "https": proxy}
|
|
|
|
# 1. iframe URL에서 video_id 추출
|
|
video_id = None
|
|
if "/video/" in iframe_src:
|
|
video_id = iframe_src.split("/video/")[1].split("?")[0].split("&")[0]
|
|
elif "/v/" in iframe_src:
|
|
video_id = iframe_src.split("/v/")[1].split("?")[0].split("&")[0]
|
|
|
|
if not video_id:
|
|
print(f"Could not extract video ID from: {iframe_src}", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
log.info(f"Extracted video_id: {video_id}")
|
|
|
|
# 2. 플레이어 페이지 먼저 방문 (세션/쿠키 획득)
|
|
headers = {
|
|
"user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
|
|
"accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
|
|
"accept-language": "ko-KR,ko;q=0.9,en-US;q=0.8,en;q=0.7",
|
|
"referer": referer_url,
|
|
"sec-ch-ua": '"Not_A Brand";v="8", "Chromium";v="120", "Google Chrome";v="120"',
|
|
"sec-ch-ua-mobile": "?0",
|
|
"sec-ch-ua-platform": '"macOS"',
|
|
"sec-fetch-dest": "iframe",
|
|
"sec-fetch-mode": "navigate",
|
|
"sec-fetch-site": "cross-site",
|
|
}
|
|
|
|
log.info(f"Visiting iframe page: {iframe_src}")
|
|
resp = session.get(iframe_src, headers=headers, proxies=proxies, timeout=30)
|
|
log.info(f"Iframe page status: {resp.status_code}")
|
|
|
|
# 3. getVideo API 호출
|
|
api_url = f"https://cdndania.com/player/index.php?data={video_id}&do=getVideo"
|
|
api_headers = {
|
|
"user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
|
|
"x-requested-with": "XMLHttpRequest",
|
|
"content-type": "application/x-www-form-urlencoded; charset=UTF-8",
|
|
"referer": iframe_src,
|
|
"origin": "https://cdndania.com",
|
|
"accept": "application/json, text/javascript, */*; q=0.01",
|
|
}
|
|
post_data = {
|
|
"hash": video_id,
|
|
"r": referer_url
|
|
}
|
|
|
|
log.info(f"Calling video API: {api_url}")
|
|
api_resp = session.post(api_url, headers=api_headers, data=post_data,
|
|
proxies=proxies, timeout=30)
|
|
|
|
if api_resp.status_code != 200:
|
|
print(f"API request failed: HTTP {api_resp.status_code}", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
try:
|
|
data = api_resp.json()
|
|
except:
|
|
print(f"Failed to parse API response: {api_resp.text[:200]}", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
video_url = data.get("videoSource") or data.get("securedLink")
|
|
if not video_url:
|
|
print(f"No video URL in API response: {data}", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
log.info(f"Got video URL: {video_url}")
|
|
|
|
# 4. m3u8 다운로드 (동일 세션 유지!)
|
|
m3u8_headers = {
|
|
"user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
|
|
"referer": iframe_src,
|
|
"origin": "https://cdndania.com",
|
|
"accept": "*/*",
|
|
}
|
|
|
|
log.info(f"Fetching m3u8: {video_url}")
|
|
m3u8_resp = session.get(video_url, headers=m3u8_headers, proxies=proxies, timeout=30)
|
|
|
|
if m3u8_resp.status_code != 200:
|
|
print(f"m3u8 fetch failed: HTTP {m3u8_resp.status_code}", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
m3u8_content = m3u8_resp.text
|
|
|
|
# Master playlist 확인
|
|
if "#EXT-X-STREAM-INF" in m3u8_content:
|
|
# 가장 높은 품질의 미디어 플레이리스트 URL 추출
|
|
base = video_url.rsplit('/', 1)[0] + '/'
|
|
last_url = None
|
|
for line in m3u8_content.strip().split('\n'):
|
|
line = line.strip()
|
|
if line and not line.startswith('#'):
|
|
if line.startswith('http'):
|
|
last_url = line
|
|
else:
|
|
last_url = urljoin(base, line)
|
|
|
|
if last_url:
|
|
log.info(f"Following media playlist: {last_url}")
|
|
m3u8_resp = session.get(last_url, headers=m3u8_headers, proxies=proxies, timeout=30)
|
|
m3u8_content = m3u8_resp.text
|
|
video_url = last_url
|
|
|
|
# 5. 세그먼트 URL 파싱
|
|
base = video_url.rsplit('/', 1)[0] + '/'
|
|
segments = []
|
|
for line in m3u8_content.strip().split('\n'):
|
|
line = line.strip()
|
|
if line and not line.startswith('#'):
|
|
if line.startswith('http'):
|
|
segments.append(line)
|
|
else:
|
|
segments.append(urljoin(base, line))
|
|
|
|
if not segments:
|
|
print("No segments found in m3u8", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
log.info(f"Found {len(segments)} segments")
|
|
|
|
# 6. 세그먼트 다운로드 (병렬 처리)
|
|
start_time = time.time()
|
|
total_bytes = 0
|
|
current_speed = 0
|
|
|
|
# 진행 상황 공유 변수 (Thread-safe하게 관리 필요)
|
|
completed_segments = 0
|
|
lock = threading.Lock()
|
|
|
|
# 출력 디렉토리 미리 생성 (임시 폴더 생성을 위해)
|
|
output_dir = os.path.dirname(output_path)
|
|
if output_dir and not os.path.exists(output_dir):
|
|
os.makedirs(output_dir)
|
|
|
|
with tempfile.TemporaryDirectory(dir=output_dir) as temp_dir:
|
|
segment_files = [None] * len(segments) # 순서 보장을 위해 미리 할당
|
|
total_segments = len(segments)
|
|
|
|
log.info(f"Temp directory: {temp_dir}")
|
|
log.info(f"Starting parallel download with {threads} threads for {total_segments} segments...")
|
|
|
|
# 세그먼트 다운로드 함수
|
|
def download_segment(index, url):
|
|
nonlocal completed_segments, total_bytes
|
|
try:
|
|
# 재시도 로직
|
|
for retry in range(3):
|
|
try:
|
|
seg_resp = session.get(url, headers=m3u8_headers, proxies=proxies, timeout=30)
|
|
if seg_resp.status_code == 200:
|
|
content = seg_resp.content
|
|
if len(content) < 100:
|
|
if retry == 2:
|
|
raise Exception(f"Segment data too small ({len(content)}B)")
|
|
time.sleep(1)
|
|
continue
|
|
|
|
# 파일 저장
|
|
filename = f"segment_{index:05d}.ts"
|
|
filepath = os.path.join(temp_dir, filename)
|
|
with open(filepath, 'wb') as f:
|
|
f.write(content)
|
|
|
|
# 결과 기록
|
|
with lock:
|
|
segment_files[index] = filename
|
|
total_bytes += len(content)
|
|
completed_segments += 1
|
|
|
|
# 진행률 업데이트 (너무 자주는 말고 10개마다)
|
|
if completed_segments % 10 == 0 or completed_segments == total_segments:
|
|
pct = int((completed_segments / total_segments) * 100)
|
|
elapsed = time.time() - start_time
|
|
speed = total_bytes / elapsed if elapsed > 0 else 0
|
|
|
|
log.info(f"Progress: {pct}% ({completed_segments}/{total_segments}) Speed: {format_speed(speed)}")
|
|
update_progress(pct, completed_segments, total_segments, format_speed(speed), format_time(elapsed))
|
|
return True
|
|
except Exception as e:
|
|
if retry == 2:
|
|
log.error(f"Seg {index} failed after retries: {e}")
|
|
raise e
|
|
time.sleep(0.5)
|
|
except Exception as e:
|
|
return False
|
|
|
|
# 스레드 풀 실행
|
|
from concurrent.futures import ThreadPoolExecutor
|
|
|
|
# 설정된 스레드 수로 병렬 다운로드
|
|
with ThreadPoolExecutor(max_workers=threads) as executor:
|
|
futures = []
|
|
for i, seg_url in enumerate(segments):
|
|
futures.append(executor.submit(download_segment, i, seg_url))
|
|
|
|
# 모든 작업 완료 대기
|
|
for future in futures:
|
|
try:
|
|
future.result()
|
|
except Exception as e:
|
|
log.error(f"Thread error: {e}")
|
|
print(f"Download thread failed: {e}", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
# 다운로드 완료 확인
|
|
if completed_segments != total_segments:
|
|
print(f"Incomplete download: {completed_segments}/{total_segments}", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
log.info("All segments downloaded successfully.")
|
|
|
|
# 7. ffmpeg로 합치기
|
|
log.info("Concatenating segments with ffmpeg...")
|
|
concat_file = os.path.join(temp_dir, "concat.txt")
|
|
with open(concat_file, 'w') as f:
|
|
for seg_file in segment_files:
|
|
if seg_file:
|
|
f.write(f"file '{seg_file}'\n")
|
|
|
|
# 출력 디렉토리 생성
|
|
output_dir = os.path.dirname(output_path)
|
|
if output_dir and not os.path.exists(output_dir):
|
|
os.makedirs(output_dir)
|
|
|
|
cmd = [
|
|
'ffmpeg', '-y',
|
|
'-f', 'concat',
|
|
'-safe', '0',
|
|
'-i', 'concat.txt',
|
|
'-c', 'copy',
|
|
os.path.abspath(output_path)
|
|
]
|
|
|
|
result = subprocess.run(cmd, capture_output=True, text=True,
|
|
timeout=600, cwd=temp_dir)
|
|
|
|
if result.returncode != 0:
|
|
print(f"FFmpeg concat failed: {result.stderr[:200]}", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
# 출력 파일 확인
|
|
if not os.path.exists(output_path):
|
|
print("Output file not created", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
file_size = os.path.getsize(output_path)
|
|
if file_size < 10000:
|
|
print(f"Output file too small: {file_size}B", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
log.info(f"Download completed: {output_path} ({file_size / 1024 / 1024:.1f}MB)")
|
|
update_progress(100, total_segments, total_segments, "", format_time(time.time() - start_time))
|
|
sys.exit(0)
|
|
|
|
except Exception as e:
|
|
import traceback
|
|
print(f"Error: {e}", file=sys.stderr)
|
|
traceback.print_exc(file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
|
|
# CLI 및 subprocess 엔트리포인트
|
|
if __name__ == "__main__":
|
|
if len(sys.argv) >= 6:
|
|
# subprocess 모드
|
|
iframe_url = sys.argv[1]
|
|
output_path = sys.argv[2]
|
|
referer = sys.argv[3] if sys.argv[3] else None
|
|
proxy = sys.argv[4] if sys.argv[4] else None
|
|
progress_path = sys.argv[5]
|
|
threads = int(sys.argv[6]) if len(sys.argv) > 6 else 16
|
|
|
|
_download_worker(iframe_url, output_path, referer, proxy, progress_path, threads)
|
|
elif len(sys.argv) >= 3:
|
|
# CLI 테스트 모드
|
|
logging.basicConfig(level=logging.DEBUG)
|
|
|
|
iframe_url = sys.argv[1]
|
|
output_path = sys.argv[2]
|
|
referer = sys.argv[3] if len(sys.argv) > 3 else None
|
|
proxy = sys.argv[4] if len(sys.argv) > 4 else None
|
|
|
|
def progress_callback(percent, current, total, speed, elapsed):
|
|
print(f"\r[{percent:3d}%] {current}/{total} segments - {speed} - {elapsed}", end="", flush=True)
|
|
|
|
downloader = CdndaniaDownloader(
|
|
iframe_src=iframe_url,
|
|
output_path=output_path,
|
|
referer_url=referer,
|
|
callback=progress_callback,
|
|
proxy=proxy
|
|
)
|
|
|
|
success, message = downloader.download()
|
|
print()
|
|
print(f"Result: {'SUCCESS' if success else 'FAILED'} - {message}")
|
|
else:
|
|
print("Usage: python cdndania_downloader.py <iframe_url> <output_path> [referer_url] [proxy]")
|
|
sys.exit(1)
|