| |
| """Multi-connection HTTP Range download with resume (sidecar progress file).""" |
| from __future__ import annotations |
|
|
| import json |
| import os |
| import sys |
| import threading |
| import time |
| import urllib.error |
| import urllib.request |
| from concurrent.futures import ThreadPoolExecutor, as_completed |
|
|
| URL = os.environ.get( |
| "DL_URL", |
| "https://data.bris.ac.uk/datasets/tar/2v6cgv1x04ol22qp9rm9x2j6a7.zip", |
| ) |
| DEST = os.environ.get( |
| "DL_DEST", |
| os.path.join(os.path.dirname(os.path.abspath(__file__)), "2v6cgv1x04ol22qp9rm9x2j6a7.zip"), |
| ) |
| WORKERS = int(os.environ.get("DL_WORKERS", "16")) |
| CHUNK = int(os.environ.get("DL_CHUNK", str(32 * 1024 * 1024))) |
| PROGRESS_PATH = DEST + ".progress.json" |
| LOCK_PATH = DEST + ".lock" |
|
|
| print_lock = threading.Lock() |
| progress_lock = threading.Lock() |
| bytes_lock = threading.Lock() |
| session_bytes = 0 |
|
|
|
|
| def log(msg: str) -> None: |
| with print_lock: |
| print(msg, flush=True) |
|
|
|
|
| def head_length(url: str) -> int: |
| req = urllib.request.Request(url, method="HEAD") |
| with urllib.request.urlopen(req, timeout=60) as resp: |
| length = resp.headers.get("Content-Length") |
| accept = resp.headers.get("Accept-Ranges", "") |
| if "bytes" not in accept.lower(): |
| log(f"WARN Accept-Ranges={accept!r}") |
| if not length: |
| raise SystemExit("no Content-Length") |
| return int(length) |
|
|
|
|
| def load_progress(total: int, dest_size: int) -> list[list[int]]: |
| if os.path.exists(PROGRESS_PATH): |
| with open(PROGRESS_PATH) as f: |
| data = json.load(f) |
| if data.get("url") == URL and data.get("total") == total: |
| return merge_intervals(data.get("completed") or []) |
| if 0 < dest_size < total: |
| return [[0, dest_size]] |
| return [] |
|
|
|
|
| def save_progress(total: int, completed: list[list[int]]) -> None: |
| tmp = PROGRESS_PATH + ".tmp" |
| payload = {"url": URL, "total": total, "completed": merge_intervals(completed)} |
| with open(tmp, "w") as f: |
| json.dump(payload, f) |
| os.replace(tmp, PROGRESS_PATH) |
|
|
|
|
| def merge_intervals(intervals: list[list[int]]) -> list[list[int]]: |
| if not intervals: |
| return [] |
| items = sorted((int(a), int(b)) for a, b in intervals if b > a) |
| out = [list(items[0])] |
| for a, b in items[1:]: |
| if a <= out[-1][1]: |
| out[-1][1] = max(out[-1][1], b) |
| else: |
| out.append([a, b]) |
| return out |
|
|
|
|
| def gaps(total: int, completed: list[list[int]]) -> list[tuple[int, int]]: |
| done = merge_intervals(completed) |
| pos = 0 |
| missing: list[tuple[int, int]] = [] |
| for a, b in done: |
| if pos < a: |
| missing.append((pos, a)) |
| pos = max(pos, b) |
| if pos < total: |
| missing.append((pos, total)) |
| return missing |
|
|
|
|
| def split_gaps(missing: list[tuple[int, int]], chunk: int) -> list[tuple[int, int]]: |
| tasks = [] |
| for a, b in missing: |
| s = a |
| while s < b: |
| e = min(s + chunk, b) |
| tasks.append((s, e)) |
| s = e |
| return tasks |
|
|
|
|
| def fetch_range(url: str, start: int, end: int, fd: int, retries: int = 8) -> int: |
| """Download [start, end) into fd. Returns bytes written.""" |
| last_err: Exception | None = None |
| for attempt in range(retries): |
| written = 0 |
| offset = start |
| try: |
| req = urllib.request.Request( |
| url, |
| headers={ |
| "Range": f"bytes={start}-{end - 1}", |
| "User-Agent": "parallel-resume-get/1.0", |
| }, |
| ) |
| with urllib.request.urlopen(req, timeout=120) as resp: |
| if resp.status not in (200, 206): |
| raise RuntimeError(f"HTTP {resp.status}") |
| while offset < end: |
| want = min(1024 * 1024, end - offset) |
| buf = resp.read(want) |
| if not buf: |
| raise RuntimeError(f"short read at {offset}") |
| os.pwrite(fd, buf, offset) |
| n = len(buf) |
| offset += n |
| written += n |
| with bytes_lock: |
| global session_bytes |
| session_bytes += n |
| if offset != end: |
| raise RuntimeError(f"incomplete {offset} != {end}") |
| return written |
| except (urllib.error.URLError, TimeoutError, OSError, RuntimeError) as exc: |
| last_err = exc |
| time.sleep(min(2 ** attempt, 30)) |
| raise RuntimeError(f"range {start}-{end} failed: {last_err}") |
|
|
|
|
| def main() -> int: |
| if os.path.exists(LOCK_PATH): |
| try: |
| with open(LOCK_PATH) as f: |
| old = int(f.read().strip() or "0") |
| os.kill(old, 0) |
| log(f"another downloader is running (pid {old})") |
| return 1 |
| except (OSError, ValueError): |
| pass |
| with open(LOCK_PATH, "w") as f: |
| f.write(str(os.getpid())) |
|
|
| try: |
| total = head_length(URL) |
| dest_size = os.path.getsize(DEST) if os.path.exists(DEST) else 0 |
| completed = load_progress(total, dest_size) |
| log(f"url={URL}") |
| log(f"dest={DEST}") |
| log(f"total={total} ({total / 1024**3:.2f} GiB) workers={WORKERS} chunk={CHUNK}") |
| log(f"already={sum(b - a for a, b in completed)} bytes in {len(completed)} interval(s)") |
|
|
| flags = os.O_RDWR | os.O_CREAT |
| fd = os.open(DEST, flags, 0o644) |
| try: |
| if dest_size != total: |
| os.ftruncate(fd, total) |
| tasks = split_gaps(gaps(total, completed), CHUNK) |
| if not tasks: |
| log("nothing to download") |
| return 0 |
| log(f"tasks={len(tasks)} remaining={sum(e - s for s, e in tasks)}") |
| t0 = time.time() |
| done_tasks = 0 |
|
|
| def worker(se: tuple[int, int]) -> tuple[int, int]: |
| s, e = se |
| fetch_range(URL, s, e, fd) |
| with progress_lock: |
| completed.append([s, e]) |
| save_progress(total, completed) |
| return s, e |
|
|
| with ThreadPoolExecutor(max_workers=WORKERS) as pool: |
| futs = [pool.submit(worker, se) for se in tasks] |
| last_report = t0 |
| last_bytes = 0 |
| pending = set(futs) |
| while pending: |
| finished = [] |
| for fut in list(pending): |
| if fut.done(): |
| finished.append(fut) |
| pending.remove(fut) |
| for fut in finished: |
| fut.result() |
| done_tasks += 1 |
| now = time.time() |
| if now - last_report >= 5 or not pending: |
| with bytes_lock: |
| cur = session_bytes |
| dt = now - last_report |
| inst = (cur - last_bytes) / dt if dt > 0 else 0 |
| avg = cur / (now - t0) if now > t0 else 0 |
| remain = sum(e - s for s, e in tasks) - cur |
| eta = remain / inst if inst > 0 else float("inf") |
| log( |
| f"chunks {done_tasks}/{len(tasks)} " |
| f"+{cur / 1024**3:.2f} GiB this run " |
| f"{inst / 1024**2:.2f} MiB/s inst " |
| f"{avg / 1024**2:.2f} MiB/s avg " |
| f"eta {eta / 60:.1f} min" |
| ) |
| last_report = now |
| last_bytes = cur |
| if pending: |
| time.sleep(0.4) |
| finally: |
| os.close(fd) |
|
|
| final = merge_intervals(completed) |
| if gaps(total, final): |
| log(f"INCOMPLETE gaps={gaps(total, final)[:5]}") |
| return 1 |
| size = os.path.getsize(DEST) |
| if size != total: |
| log(f"size mismatch {size} != {total}") |
| return 1 |
| log(f"DONE {DEST} size={size}") |
| try: |
| os.remove(PROGRESS_PATH) |
| except OSError: |
| pass |
| return 0 |
| finally: |
| try: |
| os.remove(LOCK_PATH) |
| except OSError: |
| pass |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
