286 lines
7.0 KiB
Go
286 lines
7.0 KiB
Go
package download
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
type QBittorrentClient struct {
|
|
baseURL string
|
|
username string
|
|
password string
|
|
client *http.Client
|
|
mu sync.Mutex
|
|
sid *http.Cookie
|
|
}
|
|
|
|
func NewQBittorrentClient(baseURL, password string) *QBittorrentClient {
|
|
return &QBittorrentClient{
|
|
baseURL: strings.TrimRight(baseURL, "/"),
|
|
username: "admin",
|
|
password: password,
|
|
client: &http.Client{Timeout: 30 * time.Second},
|
|
}
|
|
}
|
|
|
|
func (q *QBittorrentClient) login(ctx context.Context) error {
|
|
q.mu.Lock()
|
|
defer q.mu.Unlock()
|
|
|
|
form := url.Values{}
|
|
form.Set("username", q.username)
|
|
form.Set("password", q.password)
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodPost,
|
|
q.baseURL+"/api/v2/auth/login", strings.NewReader(form.Encode()))
|
|
if err != nil {
|
|
return fmt.Errorf("qbittorrent login request: %w", err)
|
|
}
|
|
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
|
|
|
|
resp, err := q.client.Do(req)
|
|
if err != nil {
|
|
return fmt.Errorf("qbittorrent login: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
body, _ := io.ReadAll(resp.Body)
|
|
if !strings.Contains(string(body), "Ok.") {
|
|
return fmt.Errorf("qbittorrent login failed: %s", string(body))
|
|
}
|
|
|
|
for _, cookie := range resp.Cookies() {
|
|
if cookie.Name == "SID" {
|
|
q.sid = cookie
|
|
return nil
|
|
}
|
|
}
|
|
|
|
return fmt.Errorf("qbittorrent login: no SID cookie in response")
|
|
}
|
|
|
|
func (q *QBittorrentClient) doAuthenticated(ctx context.Context, method, path string, body url.Values) (*http.Response, error) {
|
|
var bodyReader io.Reader
|
|
if body != nil {
|
|
bodyReader = strings.NewReader(body.Encode())
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, method, q.baseURL+path, bodyReader)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if body != nil {
|
|
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
|
|
}
|
|
|
|
if q.sid != nil {
|
|
req.AddCookie(q.sid)
|
|
}
|
|
|
|
resp, err := q.client.Do(req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if resp.StatusCode == http.StatusForbidden {
|
|
resp.Body.Close()
|
|
if err := q.login(ctx); err != nil {
|
|
return nil, fmt.Errorf("qbittorrent re-auth: %w", err)
|
|
}
|
|
|
|
req2, err := http.NewRequestWithContext(ctx, method, q.baseURL+path, bodyReader)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if body != nil {
|
|
req2.Header.Set("Content-Type", "application/x-www-form-urlencoded")
|
|
}
|
|
req2.AddCookie(q.sid)
|
|
return q.client.Do(req2)
|
|
}
|
|
|
|
return resp, nil
|
|
}
|
|
|
|
func (q *QBittorrentClient) Add(ctx context.Context, torrentURL string, category string) (string, error) {
|
|
if category == "" {
|
|
category = "umm"
|
|
}
|
|
|
|
form := url.Values{}
|
|
form.Set("urls", torrentURL)
|
|
form.Set("category", category)
|
|
|
|
resp, err := q.doAuthenticated(ctx, http.MethodPost, "/api/v2/torrents/add", form)
|
|
if err != nil {
|
|
return "", fmt.Errorf("qbittorrent add: %w", err)
|
|
}
|
|
resp.Body.Close()
|
|
|
|
resp, err = q.doAuthenticated(ctx, http.MethodGet,
|
|
fmt.Sprintf("/api/v2/torrents/info?sort=added_on&reverse=true&category=%s", url.QueryEscape(category)), nil)
|
|
if err != nil {
|
|
return "", fmt.Errorf("qbittorrent add verify: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
var torrents []qbTorrentInfo
|
|
if err := json.NewDecoder(resp.Body).Decode(&torrents); err != nil {
|
|
return "", fmt.Errorf("qbittorrent add decode: %w", err)
|
|
}
|
|
|
|
for _, t := range torrents {
|
|
if t.MagnetURI == torrentURL || strings.Contains(t.Tracker, torrentURL) {
|
|
return t.Hash, nil
|
|
}
|
|
}
|
|
|
|
if len(torrents) > 0 {
|
|
return torrents[0].Hash, nil
|
|
}
|
|
|
|
return "", fmt.Errorf("qbittorrent add: torrent not found after adding")
|
|
}
|
|
|
|
func (q *QBittorrentClient) GetProgress(ctx context.Context, hash string) (*DownloadProgress, error) {
|
|
resp, err := q.doAuthenticated(ctx, http.MethodGet,
|
|
fmt.Sprintf("/api/v2/torrents/info?hashes=%s", url.QueryEscape(hash)), nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("qbittorrent progress: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
var torrents []qbTorrentInfo
|
|
if err := json.NewDecoder(resp.Body).Decode(&torrents); err != nil {
|
|
return nil, fmt.Errorf("qbittorrent progress decode: %w", err)
|
|
}
|
|
|
|
if len(torrents) == 0 {
|
|
return nil, fmt.Errorf("qbittorrent: torrent %s not found", hash)
|
|
}
|
|
|
|
t := torrents[0]
|
|
return &DownloadProgress{
|
|
ID: t.Hash,
|
|
Name: t.Name,
|
|
Status: qbStateToStatus(t.State),
|
|
Progress: t.Progress * 100,
|
|
Speed: t.DLSpeed,
|
|
ETA: t.ETA,
|
|
Size: t.Size,
|
|
}, nil
|
|
}
|
|
|
|
func (q *QBittorrentClient) GetCompleted(ctx context.Context) ([]CompletedDownload, error) {
|
|
resp, err := q.doAuthenticated(ctx, http.MethodGet,
|
|
"/api/v2/torrents/info?filter=completed", nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("qbittorrent completed: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
var torrents []qbTorrentInfo
|
|
if err := json.NewDecoder(resp.Body).Decode(&torrents); err != nil {
|
|
return nil, fmt.Errorf("qbittorrent completed decode: %w", err)
|
|
}
|
|
|
|
var completed []CompletedDownload
|
|
for _, t := range torrents {
|
|
completed = append(completed, CompletedDownload{
|
|
ID: t.Hash,
|
|
Name: t.Name,
|
|
OutputPath: t.ContentPath,
|
|
Size: t.Size,
|
|
Status: qbStateToStatus(t.State),
|
|
})
|
|
}
|
|
|
|
return completed, nil
|
|
}
|
|
|
|
func (q *QBittorrentClient) Remove(ctx context.Context, hash string) error {
|
|
form := url.Values{}
|
|
form.Set("hashes", hash)
|
|
form.Set("deleteFiles", "true")
|
|
|
|
resp, err := q.doAuthenticated(ctx, http.MethodPost, "/api/v2/torrents/delete", form)
|
|
if err != nil {
|
|
return fmt.Errorf("qbittorrent remove: %w", err)
|
|
}
|
|
resp.Body.Close()
|
|
|
|
return nil
|
|
}
|
|
|
|
func (q *QBittorrentClient) Pause(ctx context.Context, hash string) error {
|
|
form := url.Values{}
|
|
form.Set("hashes", hash)
|
|
|
|
resp, err := q.doAuthenticated(ctx, http.MethodPost, "/api/v2/torrents/pause", form)
|
|
if err != nil {
|
|
return fmt.Errorf("qbittorrent pause: %w", err)
|
|
}
|
|
resp.Body.Close()
|
|
|
|
return nil
|
|
}
|
|
|
|
func (q *QBittorrentClient) Resume(ctx context.Context, hash string) error {
|
|
form := url.Values{}
|
|
form.Set("hashes", hash)
|
|
|
|
resp, err := q.doAuthenticated(ctx, http.MethodPost, "/api/v2/torrents/resume", form)
|
|
if err != nil {
|
|
return fmt.Errorf("qbittorrent resume: %w", err)
|
|
}
|
|
resp.Body.Close()
|
|
|
|
return nil
|
|
}
|
|
|
|
func qbStateToStatus(state string) string {
|
|
switch state {
|
|
case "downloading", "stalledDL", "forcedDL", "metaDL", "forcedMetaDL":
|
|
return "downloading"
|
|
case "uploading", "stalledUP", "forcedUP":
|
|
return "completed"
|
|
case "pausedDL", "pausedUP":
|
|
return "paused"
|
|
case "queuedDL", "queuedUP":
|
|
return "queued"
|
|
case "checkingDL", "checkingUP", "moving":
|
|
return "checking"
|
|
case "error", "missingFiles", "unknown":
|
|
return "error"
|
|
default:
|
|
return "unknown"
|
|
}
|
|
}
|
|
|
|
type qbTorrentInfo struct {
|
|
Hash string `json:"hash"`
|
|
Name string `json:"name"`
|
|
State string `json:"state"`
|
|
Progress float64 `json:"progress"`
|
|
DLSpeed int64 `json:"dlspeed"`
|
|
ETA int `json:"eta"`
|
|
Size int64 `json:"size"`
|
|
ContentPath string `json:"content_path"`
|
|
AddedOn int64 `json:"added_on"`
|
|
Tracker string `json:"tracker"`
|
|
MagnetURI string `json:"magnet_uri"`
|
|
}
|
|
|
|
var _ = strconv.Atoi
|
|
|
|
var _ io.Reader = nil
|