hyungi
347 lines
15 KiB
Python
347 lines
15 KiB
Python
"""크롤링 politeness 코어 (A-4, plan crawl-24x7-1)
|
||
|
||
개인 아카이빙 권장치를 그대로 박은 공용 fetch 계층:
|
||
- per-domain 동시성 1 (asyncio.Lock) + 같은 도메인 연속 요청 5–15초 지연 + jitter
|
||
- robots.txt 존중 (urllib.robotparser, 24h 캐시) — 비로그인 공개 크롤링 한정.
|
||
로그인 세션 fetch (B-3) 는 사용자 행위 성격이라 robots 대신 사람 속도가 기준.
|
||
- 정직 식별 UA + 연락처 (익명 크롤링 트랙. 로그인 세션은 브라우저 UA 유지 — B-3)
|
||
- 429 = Retry-After 존중 / 5xx = 재시도 가능 / 403 = 차단 신호 (호출측 circuit 연동)
|
||
|
||
도메인별 마지막 요청 시각 등 rate 상태는 in-process (영속 워터마크는 DB — news_sources).
|
||
SSRF 차단은 core.url_validator.validate_feed_url 재사용 (redirect target 재검증 포함).
|
||
"""
|
||
|
||
import asyncio
|
||
import base64
|
||
import random
|
||
import time
|
||
import urllib.robotparser
|
||
from urllib.parse import urljoin, urlparse
|
||
|
||
import httpx
|
||
|
||
from core.url_validator import validate_feed_url
|
||
from core.utils import setup_logger
|
||
|
||
# bare getLogger 는 root(WARNING) 상속이라 INFO 대기/차단 로그가 드랍됨 — 타 워커와 동일 설정
|
||
logger = setup_logger("crawl_politeness")
|
||
|
||
# 정직 식별 UA + 연락처 — 차단 전 연락 통로 (A-4)
|
||
CRAWL_UA = "HyungiPKM-Archiver/1.0 (personal archive; +mailto:hyun49196@gmail.com)"
|
||
|
||
# 같은 도메인 연속 요청 간격 (초) — 권장치 5–15s + jitter
|
||
_DOMAIN_DELAY_MIN = 5.0
|
||
_DOMAIN_DELAY_MAX = 15.0
|
||
|
||
# 구독 세션(브라우저) fetch 간격 — 사람 속도 (B-3 ④: 기사 간 수십 초)
|
||
_AUTH_DELAY_MIN = 30.0
|
||
_AUTH_DELAY_MAX = 60.0
|
||
|
||
# B-3 Playwright 격리 컨테이너 (internal-only, compose DNS)
|
||
_FETCHER_URL = "http://playwright-fetcher:3400"
|
||
_FETCHER_TIMEOUT = 120.0 # 브라우저 기동 + 네비게이션 + settle 포함
|
||
|
||
# 안티봇 챌린지 페이지 식별 마커 (DataDome/Cloudflare 등) — 좁게 유지(오탐 회피).
|
||
# 실측: 르몽드 기사 = DataDome "Client Challenge" + "Entrez les caractères" CAPTCHA.
|
||
_CHALLENGE_MARKERS = (
|
||
"Client Challenge",
|
||
"Entrez les caractères affichés",
|
||
"Checking your browser before",
|
||
"captcha-delivery.com",
|
||
"geo.captcha-delivery",
|
||
# CF JS 챌린지 인터스티셜의 스크립트 도메인 (aiche.org 실측 2026-06-11) —
|
||
# fetcher 의 챌린지 대기를 끝까지 통과 못 한 최종 HTML 만 여기 걸린다.
|
||
"challenges.cloudflare.com",
|
||
)
|
||
|
||
_ROBOTS_CACHE_TTL = 24 * 3600 # 24h
|
||
_MAX_PAGE_BYTES = 5 * 1024 * 1024 # 피드 fetch 와 동일 5MB cap
|
||
_PAGE_TIMEOUT = 20.0
|
||
_MAX_REDIRECTS = 3
|
||
|
||
_HTML_CONTENT_TYPES = ("text/html", "application/xhtml+xml")
|
||
|
||
|
||
class CrawlFetchError(Exception):
|
||
"""일시 오류 (5xx / timeout / 네트워크) — 큐 재시도 대상."""
|
||
|
||
|
||
class CrawlBlocked(Exception):
|
||
"""차단 신호 (403 / 429 / robots disallow) — 재시도보다 backoff/circuit 대상."""
|
||
|
||
|
||
class CrawlSkip(Exception):
|
||
"""영구 비대상 (비-HTML / 크기 초과 / SSRF 차단 / 4xx) — 격하 처리 대상."""
|
||
|
||
|
||
# 도메인별 직렬화 상태 (in-process)
|
||
_domain_locks: dict[str, asyncio.Lock] = {}
|
||
_domain_last_request: dict[str, float] = {}
|
||
# host → (cached_at, RobotFileParser | None). None = robots 없음/4xx (전부 허용)
|
||
_robots_cache: dict[str, tuple[float, urllib.robotparser.RobotFileParser | None]] = {}
|
||
|
||
|
||
def _domain_of(url: str) -> str:
|
||
return (urlparse(url).hostname or "").lower()
|
||
|
||
|
||
def _get_lock(domain: str) -> asyncio.Lock:
|
||
if domain not in _domain_locks:
|
||
_domain_locks[domain] = asyncio.Lock()
|
||
return _domain_locks[domain]
|
||
|
||
|
||
async def _respect_domain_rate(
|
||
domain: str,
|
||
delay_min: float = _DOMAIN_DELAY_MIN,
|
||
delay_max: float = _DOMAIN_DELAY_MAX,
|
||
) -> None:
|
||
"""같은 도메인 직전 요청에서 delay(jitter) 경과할 때까지 대기."""
|
||
last = _domain_last_request.get(domain)
|
||
if last is not None:
|
||
delay = random.uniform(delay_min, delay_max)
|
||
wait = last + delay - time.monotonic()
|
||
if wait > 0:
|
||
# silent sleep 금지 — politeness 동작 검증·운영 관찰 가시성
|
||
logger.info("[politeness] %s %.1fs 대기", domain, wait)
|
||
await asyncio.sleep(wait)
|
||
|
||
|
||
async def _fetch_robots(client: httpx.AsyncClient, scheme: str, host: str):
|
||
"""robots.txt 조회. 4xx/부재 = 전부 허용(None), 5xx/오류 = 보수적으로 이번 사이클 차단."""
|
||
robots_url = f"{scheme}://{host}/robots.txt"
|
||
try:
|
||
resp = await client.get(robots_url, headers={"User-Agent": CRAWL_UA})
|
||
except httpx.HTTPError as e:
|
||
raise CrawlFetchError(f"robots.txt 조회 실패: {host}: {e}") from e
|
||
if resp.status_code >= 500:
|
||
# 5xx 는 의도 불명 — 표준 관행대로 이번 사이클은 차단 취급
|
||
raise CrawlFetchError(f"robots.txt 5xx: {host}: {resp.status_code}")
|
||
if resp.status_code >= 400:
|
||
return None # robots 없음 = 전부 허용
|
||
rp = urllib.robotparser.RobotFileParser()
|
||
rp.parse(resp.text.splitlines())
|
||
return rp
|
||
|
||
|
||
async def _robots_allows(client: httpx.AsyncClient, url: str) -> bool:
|
||
parsed = urlparse(url)
|
||
host = (parsed.hostname or "").lower()
|
||
cached = _robots_cache.get(host)
|
||
if cached is None or time.monotonic() - cached[0] > _ROBOTS_CACHE_TTL:
|
||
rp = await _fetch_robots(client, parsed.scheme or "https", host)
|
||
_robots_cache[host] = (time.monotonic(), rp)
|
||
cached = _robots_cache[host]
|
||
rp = cached[1]
|
||
if rp is None:
|
||
return True
|
||
return rp.can_fetch(CRAWL_UA, url)
|
||
|
||
|
||
async def fetch_page(
|
||
url: str, *, check_robots: bool = True,
|
||
content_types: tuple[str, ...] = _HTML_CONTENT_TYPES,
|
||
) -> tuple[str, str]:
|
||
"""공개 페이지 1건 politeness fetch. (html_text, final_url) 반환.
|
||
|
||
- SSRF 검증 (redirect target 포함, news_collector 피드 fetch 와 동일 이중 검증)
|
||
- per-domain 동시성 1 + 5–15s jitter 지연
|
||
- 429: Retry-After 로그 후 CrawlBlocked / 403: CrawlBlocked / 그 외 4xx: CrawlSkip
|
||
- 5xx/timeout: CrawlFetchError (큐 재시도)
|
||
- 비-HTML content-type / 5MB 초과: CrawlSkip
|
||
"""
|
||
try:
|
||
validate_feed_url(url)
|
||
except ValueError as e:
|
||
raise CrawlSkip(f"URL 검증 실패: {e}") from e
|
||
|
||
domain = _domain_of(url)
|
||
async with _get_lock(domain):
|
||
await _respect_domain_rate(domain)
|
||
try:
|
||
async with httpx.AsyncClient(
|
||
timeout=_PAGE_TIMEOUT, follow_redirects=False,
|
||
headers={"User-Agent": CRAWL_UA},
|
||
) as client:
|
||
if check_robots and not await _robots_allows(client, url):
|
||
raise CrawlBlocked(f"robots.txt disallow: {url}")
|
||
|
||
resp = await client.get(url)
|
||
redirects = 0
|
||
# has_redirect_location = location 헤더 있는 진짜 redirect 만 (httpx 의
|
||
# is_redirect 는 3xx 전체라 304 등을 redirect 로 오인 — news_collector 동일 함정)
|
||
while resp.has_redirect_location and redirects < _MAX_REDIRECTS:
|
||
location = urljoin(str(resp.request.url), resp.headers["location"])
|
||
try:
|
||
validate_feed_url(location)
|
||
except ValueError as e:
|
||
raise CrawlSkip(f"redirect target 차단: {e}") from e
|
||
# redirect 도 같은 도메인 연속 요청 — 간격은 lock 보유로 충분 (즉시 1회)
|
||
resp = await client.get(location)
|
||
redirects += 1
|
||
if resp.has_redirect_location:
|
||
raise CrawlSkip(f"redirect {_MAX_REDIRECTS}회 초과: {url}")
|
||
except httpx.TimeoutException as e:
|
||
raise CrawlFetchError(f"timeout: {url}") from e
|
||
except httpx.HTTPError as e:
|
||
raise CrawlFetchError(f"네트워크 오류: {url}: {e}") from e
|
||
finally:
|
||
_domain_last_request[domain] = time.monotonic()
|
||
|
||
if resp.status_code == 429:
|
||
retry_after = resp.headers.get("retry-after", "")
|
||
logger.warning("[politeness] 429 %s (Retry-After=%s)", domain, retry_after or "-")
|
||
raise CrawlBlocked(f"429 rate limited: {url} (Retry-After={retry_after or '-'})")
|
||
if resp.status_code == 403:
|
||
raise CrawlBlocked(f"403 forbidden: {url}")
|
||
if resp.status_code >= 500:
|
||
raise CrawlFetchError(f"{resp.status_code}: {url}")
|
||
if resp.status_code >= 400:
|
||
raise CrawlSkip(f"{resp.status_code}: {url}")
|
||
|
||
ct = resp.headers.get("content-type", "").lower()
|
||
if ct and not any(t in ct for t in content_types):
|
||
raise CrawlSkip(f"비허용 content-type: {ct}: {url}")
|
||
if len(resp.content) > _MAX_PAGE_BYTES:
|
||
raise CrawlSkip(f"크기 초과: {len(resp.content)} bytes: {url}")
|
||
|
||
return resp.text, str(resp.request.url)
|
||
|
||
|
||
# ── B-3 구독 세션 fetch (Playwright 격리 컨테이너 경유) ──────────────────────
|
||
|
||
async def fetch_page_via_browser(url: str, profile: str | None) -> tuple[str, str]:
|
||
"""브라우저 페이지 1건 — playwright-fetcher 에 위임, politeness 는 사람 속도(30~60s).
|
||
|
||
profile=None = 익명 컨텍스트 (사이클 3 — 평문 httpx 를 UA 무관 403 하는 공개
|
||
사이트의 WAF 우회 전용, CCPS aiche.org 실측). 값 = B-3 구독 세션.
|
||
(html_text, final_url) 반환. robots 미적용 — 구독 fetch 는 사용자 행위 성격,
|
||
익명 WAF 우회는 월간 1~2회 저빈도 + 사람 속도가 보호 장치.
|
||
예외 어휘는 fetch_page 와 동일 (호출측 분기 재사용).
|
||
"""
|
||
try:
|
||
validate_feed_url(url)
|
||
except ValueError as e:
|
||
raise CrawlSkip(f"URL 검증 실패: {e}") from e
|
||
|
||
payload = {"url": url}
|
||
if profile:
|
||
payload["profile"] = profile
|
||
|
||
domain = _domain_of(url)
|
||
async with _get_lock(domain):
|
||
await _respect_domain_rate(domain, _AUTH_DELAY_MIN, _AUTH_DELAY_MAX)
|
||
try:
|
||
async with httpx.AsyncClient(timeout=_FETCHER_TIMEOUT) as client:
|
||
resp = await client.post(f"{_FETCHER_URL}/fetch", json=payload)
|
||
except httpx.TimeoutException as e:
|
||
raise CrawlFetchError(f"browser fetch timeout: {url}") from e
|
||
except httpx.HTTPError as e:
|
||
raise CrawlFetchError(f"playwright-fetcher 연결 오류: {e}") from e
|
||
finally:
|
||
_domain_last_request[domain] = time.monotonic()
|
||
|
||
if resp.status_code == 503:
|
||
# storage_state 부재 — 수동 세션 박제 대기 (호출측 degrade, 재시도 루프 금지)
|
||
raise CrawlBlocked(f"세션 프로필 부재: {profile}")
|
||
if resp.status_code != 200:
|
||
raise CrawlFetchError(f"playwright-fetcher {resp.status_code}: {url}")
|
||
data = resp.json()
|
||
html_text = data.get("html", "")
|
||
if len(html_text.encode("utf-8", errors="replace")) > _MAX_PAGE_BYTES:
|
||
raise CrawlSkip(f"크기 초과 (browser): {url}")
|
||
# 안티봇 챌린지 페이지(DataDome 등) 식별 — 본문 길이 게이트(200자)를 통과하는
|
||
# 짧은 챌린지 HTML 이 기사 본문으로 승격되는 silent corruption 차단. 헤드리스 탐지라
|
||
# 재시도 무의미 → CrawlBlocked(=degrade, RSS 요약 유지). 마커는 보수적으로 좁게.
|
||
if any(m in html_text for m in _CHALLENGE_MARKERS):
|
||
raise CrawlBlocked(f"안티봇 챌린지 페이지(headless 차단): {url}")
|
||
return html_text, data.get("final_url", url)
|
||
|
||
|
||
_MAX_DOWNLOAD_BYTES = 60 * 1024 * 1024 # fetcher MAX_DOWNLOAD_BYTES 와 동률
|
||
|
||
|
||
async def download_via_browser(
|
||
url: str, *, referer: str | None = None, profile: str | None = None
|
||
) -> tuple[bytes, str]:
|
||
"""바이너리(PDF) 1건 — fetcher /download 위임. (content, content_type) 반환.
|
||
|
||
referer = WAF 챌린지 쿠키를 먼저 획득할 목록 페이지 (CCPS Beacon 패턴).
|
||
내부 status 판정: 403/429 = CrawlBlocked, 그 외 4xx = CrawlSkip, 5xx = CrawlFetchError
|
||
(fetch_page 와 동일 어휘 — 호출측 분기 재사용).
|
||
"""
|
||
try:
|
||
validate_feed_url(url)
|
||
except ValueError as e:
|
||
raise CrawlSkip(f"URL 검증 실패: {e}") from e
|
||
|
||
payload: dict = {"url": url}
|
||
if referer:
|
||
payload["referer"] = referer
|
||
if profile:
|
||
payload["profile"] = profile
|
||
|
||
domain = _domain_of(url)
|
||
async with _get_lock(domain):
|
||
await _respect_domain_rate(domain, _AUTH_DELAY_MIN, _AUTH_DELAY_MAX)
|
||
try:
|
||
async with httpx.AsyncClient(timeout=_FETCHER_TIMEOUT) as client:
|
||
resp = await client.post(f"{_FETCHER_URL}/download", json=payload)
|
||
except httpx.TimeoutException as e:
|
||
raise CrawlFetchError(f"browser download timeout: {url}") from e
|
||
except httpx.HTTPError as e:
|
||
raise CrawlFetchError(f"playwright-fetcher 연결 오류: {e}") from e
|
||
finally:
|
||
_domain_last_request[domain] = time.monotonic()
|
||
|
||
if resp.status_code == 503:
|
||
raise CrawlBlocked(f"세션 프로필 부재: {profile}")
|
||
if resp.status_code != 200:
|
||
raise CrawlFetchError(f"playwright-fetcher {resp.status_code}: {url}")
|
||
data = resp.json()
|
||
inner = int(data.get("status", 0))
|
||
if inner in (403, 429):
|
||
raise CrawlBlocked(f"{inner} (browser download): {url}")
|
||
if 400 <= inner < 500:
|
||
raise CrawlSkip(f"{inner} (browser download): {url}")
|
||
if inner != 200:
|
||
raise CrawlFetchError(f"{inner} (browser download): {url}")
|
||
content = base64.b64decode(data.get("body_b64", ""))
|
||
if len(content) > _MAX_DOWNLOAD_BYTES:
|
||
raise CrawlSkip(f"크기 초과 (browser download): {url}")
|
||
return content, data.get("content_type", "")
|
||
|
||
|
||
async def probe_session(
|
||
profile: str, probe_url: str, min_body_chars: int, paywall_markers: list[str]
|
||
) -> dict:
|
||
"""내용 기반 세션 probe (B-3 ②) — {'ok': bool, 'reason': str|None, 'body_chars': int}.
|
||
|
||
실패를 예외가 아닌 값으로 반환 — 호출측이 source_health 에 기록하고 degrade 분기.
|
||
probe 도 실제 publisher fetch 라 동일 도메인 lock + 사람 속도 적용.
|
||
"""
|
||
domain = _domain_of(probe_url)
|
||
async with _get_lock(domain):
|
||
await _respect_domain_rate(domain, _AUTH_DELAY_MIN, _AUTH_DELAY_MAX)
|
||
try:
|
||
async with httpx.AsyncClient(timeout=_FETCHER_TIMEOUT) as client:
|
||
resp = await client.post(
|
||
f"{_FETCHER_URL}/probe",
|
||
json={
|
||
"profile": profile,
|
||
"probe_url": probe_url,
|
||
"min_body_chars": min_body_chars,
|
||
"paywall_markers": paywall_markers,
|
||
},
|
||
)
|
||
except httpx.HTTPError as e:
|
||
return {"ok": False, "reason": f"fetcher 연결 오류: {e}", "body_chars": 0}
|
||
finally:
|
||
_domain_last_request[domain] = time.monotonic()
|
||
|
||
if resp.status_code == 503:
|
||
return {"ok": False, "reason": f"세션 프로필 부재: {profile}", "body_chars": 0}
|
||
if resp.status_code != 200:
|
||
return {"ok": False, "reason": f"fetcher {resp.status_code}", "body_chars": 0}
|
||
return resp.json()
|