Belajar Aria2 - Scripting & Automation

#Pendahuluan

Di episode 17 kalian mengekstrak kecepatan maksimal dari aria2 — multi-connection dengan -x dan -s, max-concurrent-downloads, hingga tuning disk cache. Tapi kecepatan hanya berarti jika download bisa dijalankan tanpa pengawasan, diulang berkali-kali, dan diintegrasikan ke dalam alur kerja yang lebih besar. Episode 18 ini mengubah aria2 dari alat menjadi mesin otomasi.

Bedanya bukan pada opsi yang dipakai, melainkan pada cara kalian memperlakukannya: sebagai program yang mengembalikan exit code, bisa dipanggil dari skrip dan cron, dikendalikan dari aplikasi lewat RPC, dan yang memberi tahu kalian ketika sebuah download selesai. Mari kita bangun semuanya.

#Exit Code: Bahasa antara aria2 dan Skrip

Setiap kali aria2c selesai, ia keluar dengan sebuah exit code — angka yang menjadi satu-satunya bahasa yang bisa dibaca skrip secara andal. Berbeda dengan curl yang menangani satu request, aria2 menangani banyak download sekaligus, sehingga exit code-nya mencerminkan status terakhir seluruh sesi, bukan per file.

aria2c --dir=/srv/downloads https://cdn.example.com/update.iso
echo "aria2 keluar dengan kode: $?"

#Memanggil aria2 dari Skrip Shell

Prinsip pertama otomasi: jangan pernah mengabaikan exit code. Jika sebuah download adalah prasyarat langkah berikutnya — misalnya database yang harus ada sebelum aplikasi dipasang — skrip harus berhenti saat download gagal, bukan meneruskan dengan data yang tidak lengkap.

if aria2c --dir=/srv/downloads --max-tries=3 \
  https://cdn.example.com/update.iso; then
  echo "Download selesai, lanjut instalasi"
  ./install.sh
else
  echo "Download gagal, hentikan pipeline" >&2
  exit 1
fi

Pola if aria2c ...; then inilah yang mengubah aria2 menjadi blok logika: sukses atau gagal menentukan alur selanjutnya. Di cron, perilaku yang sama dipakai untuk memutuskan apakah sebuah job dianggap sukses atau memicu alert — cron membaca exit code skrip sebagai sinyal keberhasilan.

#Batch Download: Loop dan xargs

Otomasi jarang berurusan dengan satu URL — biasanya puluhan atau ratusan. Dua pola paling umum: loop untuk kontrol per URL (exit code diperiksa satu per satu), dan xargs untuk pemrosesan paralel. Flag -P 4 menjalankan hingga 4 proses aria2c sekaligus:

while read -r url; do
  [ -z "$url" ] && continue
  if aria2c --dir=/srv/downloads "$url"; then
    echo "OK: $url"
  else
    echo "GAGAL: $url" >&2
  fi
done < urls.txt

xargs -a urls.txt -n 1 -P 4 \
  aria2c --dir=/srv/downloads --max-tries=3

Hati-hati dengan kombinasi ini: setiap proses aria2c bisa membuka banyak koneksi per file (dari episode 4 dan 17). Empat proses dengan -x 16 berarti hingga 64 koneksi ke server yang sama — cukup untuk membuat server memblokir kalian. Untuk batch ke satu host, turunkan -x per proses, atau lebih baik serahkan antrean ke daemon RPC (di bawah) agar koneksi dikelola secara global.

#Integrasi RPC ke Aplikasi

Untuk membangun download manager pribadi, jalankan aria2 sebagai daemon RPC (dari episode 15) dan kirim request JSON-RPC ke port 6800. Keunggulannya: daemon tetap berjalan, antrean dan progress dikelola aria2, dan aplikasi cukup mengirim method seperti aria2.addUri. Payload JSON-RPC berbentuk:

{
  "jsonrpc": "2.0",
  "id": "1",
  "method": "aria2.addUri",
  "params": [
    "token:RAHASIA",
    ["https://cdn.example.com/dataset.zip"],
    { "dir": "/srv/downloads" }
  ]
}

Perhatikan bahwa sekret RPC dikirim sebagai elemen pertama params dengan awalan token:. Semua method mengikuti pola yang sama: awali params dengan token, lalu argumen method. Sekarang panggil endpoint http://localhost:6800/jsonrpc dari bahasa favorit kalian — ketiga contoh ini cukup memakai pustaka standar:

rpc_add.pyrpc_add.mjsrpc_add.go

import json
import urllib.request
 
payload = {
    "jsonrpc": "2.0",
    "id": "1",
    "method": "aria2.addUri",
    "params": [
        "token:RAHASIA",
        ["https://cdn.example.com/dataset.zip"],
        {"dir": "/srv/downloads"}
    ]
}
 
req = urllib.request.Request(
    "http://localhost:6800/jsonrpc",
    data=json.dumps(payload).encode(),
    headers={"Content-Type": "application/json"},
)
with urllib.request.urlopen(req) as resp:
    print(resp.read().decode())

const payload = {
  jsonrpc: "2.0",
  id: "1",
  method: "aria2.addUri",
  params: [
    "token:RAHASIA",
    ["https://cdn.example.com/dataset.zip"],
    { dir: "/srv/downloads" }
  ]
};
 
const res = await fetch("http://localhost:6800/jsonrpc", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify(payload)
});
console.log(await res.json());

package main
 
import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)
 
func main() {
    payload := map[string]interface{}{
        "jsonrpc": "2.0",
        "id":      "1",
        "method":  "aria2.addUri",
        "params": []interface{}{
            "token:RAHASIA",
            []string{"https://cdn.example.com/dataset.zip"},
            map[string]string{"dir": "/srv/downloads"},
        },
    }
    body, _ := json.Marshal(payload)
    resp, err := http.Post("http://localhost:6800/jsonrpc",
        "application/json", bytes.NewBuffer(body))
    if err != nil {
        fmt.Println("RPC gagal:", err)
        return
    }
    defer resp.Body.Close()
    fmt.Println("Status:", resp.Status)
}

Ketiga contoh melakukan hal yang persis sama: mengirim aria2.addUri dengan sekret dan opsi download. Responsnya berisi GID — pengenal unik download — yang bisa kalian simpan untuk memantau progress lewat aria2.tellStatus(gid) atau menghentikannya dengan aria2.remove(gid). Inilah inti download manager pribadi: antrean, pause, resume, dan notifikasi semuanya bisa dibangun di atas bahasa kalian sendiri.

#Event Notification: --on-download-complete

Otomasi yang baik tidak menunggu — ia mendengar. aria2 punya event hook: skrip yang dijalankan otomatis saat peristiwa tertentu terjadi. Yang paling berguna adalah --on-download-complete, dipanggil dengan tiga argumen: GID, jumlah file, dan path file pertama.

#!/usr/bin/env bash
GID="$1"
NUM_FILES="$2"
FILE_PATH="$3"
 
LOG_FILE="/var/log/aria2-hooks.log"
FINAL_DIR="/srv/downloads/selesai"
mkdir -p "$FINAL_DIR"
 
echo "[$(date +%F_%T)] Selesai: $GID - $FILE_PATH" >> "$LOG_FILE"
mv "$FILE_PATH" "$FINAL_DIR/"

Pasang hook itu ke download:

aria2c --dir=/srv/downloads \
  --on-download-complete /opt/hooks/on-complete.sh \
  https://cdn.example.com/file.zip

Hook inilah jembatan antara aria2 dan dunia luar: memindahkan file, memicu verifikasi checksum, memanggil API, atau mengirim notifikasi. Untuk download yang gagal ada --on-download-error, dan untuk apapun yang berhenti — sukses maupun gagal — ada --on-download-stop. Di episode 21 kita akan memakai hook ini untuk membangun alur download yang lengkap.

#Penutup

Episode 18 mengubah aria2 menjadi mesin otomasi: memahami exit code sebagai bahasa kegagalan sesi, memanggil aria2c dari skrip shell dengan pola if ...; then, menjalankan batch download dengan loop dan xargs -P, membangun download manager sendiri lewat JSON-RPC dari Python, Node, dan Go, serta mendengarkan peristiwa dengan --on-download-complete.

Inti yang harus dibawa pulang: skrip tidak membaca layar — ia membaca exit code dan event. Segala sesuatu yang tampak seperti tugas manual bisa diubah menjadi fungsi yang bisa dipanggil ulang tanpa pengawasan.

Di episode 19 berikutnya kita membalik sudut pandang: ketika otomasi itu gagal, bagaimana cara membaca buktinya? Troubleshooting dan debugging — dari --log dan --log-level hingga error jaringan, TLS, dan BitTorrent. Sampai jumpa!