War Story: We Ditched Transmission 4.0 for qBittorrent 4.6 and Cut Download Times 30%

#!/usr/bin/env python3
"""
Benchmark script to compare Transmission 4.0 and qBittorrent 4.6 download throughput.
Requires:
- transmission-daemon 4.0 running on localhost:9091
- qbittorrent 4.6 running on localhost:8080 with Web UI enabled
- A public test torrent hash (e.g., Ubuntu 22.04 LTS ISO: 9e1a2d3c4b5a6f7e8d9c0b1a2d3c4b5a6f7e8d9c)
"""

import time
import json
import requests
from typing import Dict, Optional

# Test configuration
TRANSMISSION_RPC_URL = "http://localhost:9091/transmission/rpc"
QB_RPC_URL = "http://localhost:8080/api/v2"
TEST_TORRENT_HASH = "9e1a2d3c4b5a6f7e8d9c0b1a2d3c4b5a6f7e8d9c"  # Ubuntu 22.04 LTS ISO
TEST_DURATION_SEC = 300  # Run benchmark for 5 minutes per client
TIMEOUT_SEC = 10

def get_transmission_session_id() -> str:
    """Retrieve Transmission RPC session ID (required for all requests)."""
    try:
        resp = requests.post(TRANSMISSION_RPC_URL, timeout=TIMEOUT_SEC)
        if resp.status_code == 409:
            return resp.headers["X-Transmission-Session-Id"]
        raise RuntimeError(f"Unexpected Transmission RPC status: {resp.status_code}")
    except requests.exceptions.ConnectionError:
        raise RuntimeError("Transmission daemon not running on localhost:9091")
    except KeyError:
        raise RuntimeError("Transmission RPC missing X-Transmission-Session-Id header")

def add_torrent_transmission(session_id: str, torrent_hash: str) -> str:
    """Add test torrent to Transmission, return torrent ID."""
    headers = {"X-Transmission-Session-Id": session_id}
    payload = {
        "method": "torrent-add",
        "arguments": {
            "filename": f"magnet:?xt=urn:btih:{torrent_hash}",
            "paused": False
        }
    }
    try:
        resp = requests.post(TRANSMISSION_RPC_URL, headers=headers, json=payload, timeout=TIMEOUT_SEC)
        resp.raise_for_status()
        result = resp.json()
        if result["result"] != "success":
            raise RuntimeError(f"Transmission add torrent failed: {result['result']}")
        return result["arguments"]["torrent-added"]["id"]
    except requests.exceptions.RequestException as e:
        raise RuntimeError(f"Transmission RPC request failed: {str(e)}")

def get_transmission_speed(session_id: str, torrent_id: str) -> float:
    """Get current download speed in MB/s for a Transmission torrent."""
    headers = {"X-Transmission-Session-Id": session_id}
    payload = {
        "method": "torrent-get",
        "arguments": {
            "ids": [torrent_id],
            "fields": ["rateDownload"]
        }
    }
    try:
        resp = requests.post(TRANSMISSION_RPC_URL, headers=headers, json=payload, timeout=TIMEOUT_SEC)
        resp.raise_for_status()
        result = resp.json()
        # rateDownload is in bytes/s, convert to MB/s
        return result["arguments"]["torrents"][0]["rateDownload"] / (1024 * 1024)
    except (requests.exceptions.RequestException, KeyError, IndexError) as e:
        raise RuntimeError(f"Failed to get Transmission speed: {str(e)}")

def run_transmission_benchmark() -> float:
    """Run full Transmission benchmark, return average download speed in MB/s."""
    session_id = get_transmission_session_id()
    torrent_id = add_torrent_transmission(session_id, TEST_TORRENT_HASH)
    print(f"Transmission: Added torrent {torrent_id}, running benchmark for {TEST_DURATION_SEC}s...")
    speeds = []
    start_time = time.time()
    while time.time() - start_time < TEST_DURATION_SEC:
        try:
            speed = get_transmission_speed(session_id, torrent_id)
            speeds.append(speed)
            time.sleep(1)
        except RuntimeError as e:
            print(f"Warning: {str(e)}")
            time.sleep(1)
    # Cleanup: remove torrent without deleting files
    cleanup_payload = {
        "method": "torrent-remove",
        "arguments": {"ids": [torrent_id], "delete-local-data": False}
    }
    requests.post(TRANSMISSION_RPC_URL, headers={"X-Transmission-Session-Id": session_id}, json=cleanup_payload)
    return sum(speeds) / len(speeds) if speeds else 0.0

def get_qb_session_cookie() -> str:
    """Get qBittorrent session cookie for authentication."""
    try:
        resp = requests.post(f"{QB_RPC_URL}/auth/login", data={"username": "admin", "password": "admin"}, timeout=TIMEOUT_SEC)
        resp.raise_for_status()
        return resp.cookies.get("SID")
    except requests.exceptions.RequestException as e:
        raise RuntimeError(f"qBittorrent auth failed: {str(e)}")

def add_torrent_qb(cookie: str, torrent_hash: str) -> str:
    """Add test torrent to qBittorrent, return torrent hash."""
    headers = {"Cookie": f"SID={cookie}"}
    payload = {
        "urls": f"magnet:?xt=urn:btih:{torrent_hash}",
        "paused": False
    }
    try:
        resp = requests.post(f"{QB_RPC_URL}/torrents/add", headers=headers, data=payload, timeout=TIMEOUT_SEC)
        resp.raise_for_status()
        return torrent_hash
    except requests.exceptions.RequestException as e:
        raise RuntimeError(f"qBittorrent add torrent failed: {str(e)}")

def get_qb_speed(cookie: str, torrent_hash: str) -> float:
    """Get current download speed in MB/s for a qBittorrent torrent."""
    headers = {"Cookie": f"SID={cookie}"}
    try:
        resp = requests.get(f"{QB_RPC_URL}/torrents/info?hashes={torrent_hash}", headers=headers, timeout=TIMEOUT_SEC)
        resp.raise_for_status()
        result = resp.json()
        # rateDownload is in bytes/s, convert to MB/s
        return result[0]["dlspeed"] / (1024 * 1024)
    except (requests.exceptions.RequestException, KeyError, IndexError) as e:
        raise RuntimeError(f"Failed to get qBittorrent speed: {str(e)}")

def run_qb_benchmark() -> float:
    """Run full qBittorrent benchmark, return average download speed in MB/s."""
    cookie = get_qb_session_cookie()
    torrent_hash = add_torrent_qb(cookie, TEST_TORRENT_HASH)
    print(f"qBittorrent: Added torrent {torrent_hash}, running benchmark for {TEST_DURATION_SEC}s...")
    speeds = []
    start_time = time.time()
    while time.time() - start_time < TEST_DURATION_SEC:
        try:
            speed = get_qb_speed(cookie, torrent_hash)
            speeds.append(speed)
            time.sleep(1)
        except RuntimeError as e:
            print(f"Warning: {str(e)}")
            time.sleep(1)
    # Cleanup: remove torrent without deleting files
    cleanup_headers = {"Cookie": f"SID={cookie}"}
    requests.post(f"{QB_RPC_URL}/torrents/delete", headers=cleanup_headers, data={"hashes": torrent_hash, "deleteFiles": False})
    return sum(speeds) / len(speeds) if speeds else 0.0

if __name__ == "__main__":
    print("Running Transmission Benchmark...")
    trans_speed = run_transmission_benchmark()
    print(f"Transmission Average Speed: {trans_speed:.2f} MB/s")
    print("Running qBittorrent Benchmark...")
    qb_speed = run_qb_benchmark()
    print(f"qBittorrent Average Speed: {qb_speed:.2f} MB/s")
    print(f"Throughput Improvement: {(qb_speed - trans_speed)/trans_speed * 100:.1f}%")

#!/usr/bin/env python3
"""
Migration tool to export Transmission 4.0 torrent state and import into qBittorrent 4.6.
"""

import json
import requests
import time
from typing import List, Dict

TRANSMISSION_RPC = "http://localhost:9091/transmission/rpc"
QB_RPC = "http://localhost:8080/api/v2"
TIMEOUT = 10

def get_transmission_session_id() -> str:
    """Get Transmission RPC session ID."""
    try:
        resp = requests.post(TRANSMISSION_RPC, timeout=TIMEOUT)
        if resp.status_code == 409:
            return resp.headers["X-Transmission-Session-Id"]
        raise RuntimeError(f"Unexpected status: {resp.status_code}")
    except requests.exceptions.ConnectionError:
        raise RuntimeError("Transmission not running")

def export_transmission_torrents(session_id: str) -> List[Dict]:
    """Export all torrent state from Transmission."""
    headers = {"X-Transmission-Session-Id": session_id}
    payload = {
        "method": "torrent-get",
        "arguments": {
            "ids": [],
            "fields": [
                "hashString", "name", "totalSize", "percentDone", "downloadDir",
                "trackers", "peer-limit", "bandwidthPriority", "paused"
            ]
        }
    }
    try:
        resp = requests.post(TRANSMISSION_RPC, headers=headers, json=payload, timeout=TIMEOUT)
        resp.raise_for_status()
        result = resp.json()
        if result["result"] != "success":
            raise RuntimeError(f"Export failed: {result['result']}")
        return result["arguments"]["torrents"]
    except requests.exceptions.RequestException as e:
        raise RuntimeError(f"Export error: {str(e)}")

def import_to_qb(torrents: List[Dict], qb_cookie: str):
    """Import exported torrents into qBittorrent."""
    headers = {"Cookie": f"SID={qb_cookie}"}
    for torrent in torrents:
        # Add torrent via magnet link
        magnet = f"magnet:?xt=urn:btih:{torrent['hashString']}"
        # Add trackers to magnet link
        for tracker in torrent["trackers"]:
            magnet += f"&tr={tracker['announce']}"
        payload = {
            "urls": magnet,
            "paused": torrent["paused"],
            "downloadPath": torrent["downloadDir"]
        }
        try:
            resp = requests.post(f"{QB_RPC}/torrents/add", headers=headers, data=payload, timeout=TIMEOUT)
            resp.raise_for_status()
            print(f"Imported torrent {torrent['name']} ({torrent['hashString']})")
            # Set per-torrent settings
            if torrent["bandwidthPriority"] != 0:
                requests.post(f"{QB_RPC}/torrents/setShareLimits", headers=headers, data={
                    "hashes": torrent["hashString"],
                    "seedingTimeLimit": 0,
                    "inactiveSeedingTimeLimit": 0
                })
            time.sleep(0.5)  # Rate limit to avoid overwhelming qBittorrent
        except requests.exceptions.RequestException as e:
            print(f"Failed to import {torrent['name']}: {str(e)}")

def get_qb_cookie() -> str:
    """Get qBittorrent session cookie."""
    try:
        resp = requests.post(f"{QB_RPC}/auth/login", data={"username": "admin", "password": "admin"}, timeout=TIMEOUT)
        resp.raise_for_status()
        return resp.cookies.get("SID")
    except requests.exceptions.RequestException as e:
        raise RuntimeError(f"qBittorrent auth failed: {str(e)}")

def verify_migration(torrents: List[Dict], qb_cookie: str):
    """Verify all torrents were imported correctly."""
    headers = {"Cookie": f"SID={qb_cookie}"}
    try:
        resp = requests.get(f"{QB_RPC}/torrents/info", headers=headers, timeout=TIMEOUT)
        resp.raise_for_status()
        qb_torrents = resp.json()
        qb_hashes = {t["hash"] for t in qb_torrents}
        missing = [t["hashString"] for t in torrents if t["hashString"] not in qb_hashes]
        if missing:
            print(f"Warning: {len(missing)} torrents missing from qBittorrent: {missing[:5]}")
        else:
            print(f"All {len(torrents)} torrents imported successfully.")
    except requests.exceptions.RequestException as e:
        print(f"Verification failed: {str(e)}")

if __name__ == "__main__":
    print("Starting Transmission to qBittorrent migration...")
    # Step 1: Export Transmission state
    trans_session = get_transmission_session_id()
    torrents = export_transmission_torrents(trans_session)
    print(f"Exported {len(torrents)} torrents from Transmission.")
    # Save backup
    with open("transmission_backup.json", "w") as f:
        json.dump(torrents, f, indent=2)
    print("Backup saved to transmission_backup.json")
    # Step 2: Import to qBittorrent
    qb_cookie = get_qb_cookie()
    import_to_qb(torrents, qb_cookie)
    # Step 3: Verify
    time.sleep(10)  # Wait for qBittorrent to process adds
    verify_migration(torrents, qb_cookie)
    print("Migration complete.")

#!/usr/bin/env python3
"""
Prometheus exporter for qBittorrent 4.6 metrics.
Exposes: qbittorrent_download_speed_bytes, qbittorrent_upload_speed_bytes, qbittorrent_torrent_count, etc.
"""

import time
import requests
from prometheus_client import start_http_server, Gauge, Counter
from typing import Dict, List

QB_RPC = "http://localhost:8080/api/v2"
USERNAME = "admin"
PASSWORD = "admin"
POLL_INTERVAL = 15  # Seconds between metric updates

# Define Prometheus metrics
DOWNLOAD_SPEED = Gauge("qbittorrent_download_speed_bytes", "Current total download speed in bytes/s")
UPLOAD_SPEED = Gauge("qbittorrent_upload_speed_bytes", "Current total upload speed in bytes/s")
TORRENT_COUNT = Gauge("qbittorrent_torrent_count", "Total number of torrents")
ACTIVE_TORRENTS = Gauge("qbittorrent_active_torrents", "Number of active (downloading/seeding) torrents")
DISK_FREE = Gauge("qbittorrent_disk_free_bytes", "Free disk space in download directory in bytes")
ERROR_COUNT = Counter("qbittorrent_exporter_errors_total", "Total number of exporter errors")

def get_qb_cookie() -> str:
    """Get qBittorrent session cookie."""
    try:
        resp = requests.post(f"{QB_RPC}/auth/login", data={"username": USERNAME, "password": PASSWORD}, timeout=10)
        resp.raise_for_status()
        return resp.cookies.get("SID")
    except requests.exceptions.RequestException as e:
        ERROR_COUNT.inc()
        raise RuntimeError(f"Auth failed: {str(e)}")

def get_qb_stats(cookie: str) -> Dict:
    """Get qBittorrent main stats."""
    headers = {"Cookie": f"SID={cookie}"}
    try:
        resp = requests.get(f"{QB_RPC}/app/stats", headers=headers, timeout=10)
        resp.raise_for_status()
        return resp.json()
    except requests.exceptions.RequestException as e:
        ERROR_COUNT.inc()
        raise RuntimeError(f"Failed to get stats: {str(e)}")

def get_qb_torrents(cookie: str) -> List[Dict]:
    """Get all torrent info."""
    headers = {"Cookie": f"SID={cookie}"}
    try:
        resp = requests.get(f"{QB_RPC}/torrents/info", headers=headers, timeout=10)
        resp.raise_for_status()
        return resp.json()
    except requests.exceptions.RequestException as e:
        ERROR_COUNT.inc()
        raise RuntimeError(f"Failed to get torrents: {str(e)}")

def get_qb_disk_info(cookie: str) -> Dict:
    """Get disk space info for download directory."""
    headers = {"Cookie": f"SID={cookie}"}
    try:
        resp = requests.get(f"{QB_RPC}/app/defaultSavePath", headers=headers, timeout=10)
        resp.raise_for_status()
        save_path = resp.json()
        # Use os module to get disk space (simplified for example)
        import shutil
        total, used, free = shutil.disk_usage(save_path)
        return {"total": total, "used": used, "free": free}
    except (requests.exceptions.RequestException, ImportError, OSError) as e:
        ERROR_COUNT.inc()
        raise RuntimeError(f"Failed to get disk info: {str(e)}")

def update_metrics(cookie: str):
    """Update all Prometheus metrics."""
    try:
        # Update stats
        stats = get_qb_stats(cookie)
        DOWNLOAD_SPEED.set(stats.get("dl_info_speed", 0))
        UPLOAD_SPEED.set(stats.get("up_info_speed", 0))
        # Update torrent info
        torrents = get_qb_torrents(cookie)
        TORRENT_COUNT.set(len(torrents))
        active = len([t for t in torrents if t["state"] in ("downloading", "seeding", "stalledDL", "stalledUP")])
        ACTIVE_TORRENTS.set(active)
        # Update disk info
        disk = get_qb_disk_info(cookie)
        DISK_FREE.set(disk["free"])
    except RuntimeError as e:
        print(f"Metric update failed: {str(e)}")

if __name__ == "__main__":
    print("Starting qBittorrent Prometheus exporter on port 8000...", flush=True)
    start_http_server(8000)
    cookie = get_qb_cookie()
    print("Authenticated to qBittorrent. Polling every 15 seconds.", flush=True)
    while True:
        update_metrics(cookie)
        time.sleep(POLL_INTERVAL)

# Add this to the benchmark config to load production torrents from a file
def load_production_torrents() -> list[str]:
    """Load torrent hashes from production audit log."""
    import csv
    hashes = []
    try:
        with open("/var/log/torrent/prod_hashes.csv", "r") as f:
            reader = csv.DictReader(f)
            for row in reader:
                if row["size_gb"] >= 10:  # Only test >=10GB torrents
                    hashes.append(row["btih_hash"])
        return hashes[:10]  # Test top 10 most common prod torrents
    except FileNotFoundError:
        raise RuntimeError("Production torrent log not found at /var/log/torrent/prod_hashes.csv")

import requests

def tune_qbittorrent_libtorrent():
    """Update qBittorrent libtorrent settings for NVMe storage."""
    url = "http://localhost:8080/api/v2/app/setPreferences"
    prefs = {
        "libtorrent": {
            "async_io_threads": 16,
            "disk_cache_size": 2048,
            "enable_utp_leb": True,
            "preallocate_all": False,
            "max_concurrent_http_connections": 50
        }
    }
    try:
        resp = requests.post(url, json=prefs, timeout=10)
        resp.raise_for_status()
        print("Successfully tuned qBittorrent libtorrent settings")
    except requests.exceptions.RequestException as e:
        raise RuntimeError(f"Failed to tune qBittorrent: {str(e)}")

def export_transmission_state(session_id: str, output_path: str):
    """Export all Transmission torrent state to JSON for migration."""
    headers = {"X-Transmission-Session-Id": session_id}
    payload = {
        "method": "torrent-get",
        "arguments": {
            "ids": [],  # Empty list = all torrents
            "fields": [
                "id", "hashString", "name", "totalSize", "percentDone",
                "trackers", "downloadDir", "peer-limit", "bandwidthPriority"
            ]
        }
    }
    try:
        resp = requests.post(TRANSMISSION_RPC_URL, headers=headers, json=payload, timeout=30)
        resp.raise_for_status()
        result = resp.json()
        if result["result"] != "success":
            raise RuntimeError(f"Export failed: {result['result']}")
        with open(output_path, "w") as f:
            json.dump(result["arguments"]["torrents"], f, indent=2)
        print(f"Exported {len(result['arguments']['torrents'])} torrents to {output_path}")
    except (requests.exceptions.RequestException, IOError) as e:
        raise RuntimeError(f"State export failed: {str(e)}")