255 lines
8.6 KiB
Go
255 lines
8.6 KiB
Go
// Package qbt — клиент qBittorrent WebUI API (v2): сессия, добавление
|
|
// торрента, опрос задач по категории.
|
|
//
|
|
// Логин ленивый: cookie-сессия устанавливается при первом 403 и повторно
|
|
// при её протухании. Источник (magnet/.torrent) отдаём qBittorrent — он сам
|
|
// качает, jellybit не делает исходящих запросов на пользовательский URL.
|
|
package qbt
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"mime/multipart"
|
|
"net/http"
|
|
"net/http/cookiejar"
|
|
"net/url"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
// Config — параметры подключения к qBittorrent WebUI.
|
|
type Config struct {
|
|
URL string
|
|
Username string
|
|
Password string
|
|
Timeout time.Duration
|
|
}
|
|
|
|
// Client — клиент qBittorrent WebUI API.
|
|
type Client struct {
|
|
base *url.URL
|
|
hc *http.Client
|
|
user string
|
|
pass string
|
|
mu sync.Mutex // сериализует логин
|
|
}
|
|
|
|
// Torrent — подмножество полей /torrents/info, нужное jellybit.
|
|
type Torrent struct {
|
|
Hash string `json:"hash"`
|
|
Name string `json:"name"`
|
|
State string `json:"state"`
|
|
SavePath string `json:"save_path"`
|
|
ContentPath string `json:"content_path"`
|
|
Category string `json:"category"`
|
|
Tags string `json:"tags"` // через запятую
|
|
Progress float64 `json:"progress"`
|
|
AmountLeft int64 `json:"amount_left"`
|
|
AddedOn int64 `json:"added_on"`
|
|
InfohashV1 string `json:"infohash_v1"`
|
|
InfohashV2 string `json:"infohash_v2"`
|
|
}
|
|
|
|
// File — элемент /torrents/files: путь файла относительно save_path
|
|
// (включая корневую папку торрента для многофайловых раздач) и его размер.
|
|
// Абсолютный путь на диске = filepath.Join(save_path, Name) — НЕ content_path:
|
|
// для многофайловой раздачи это удвоило бы корневую папку, для однофайловой
|
|
// дало бы путь под самим файлом.
|
|
type File struct {
|
|
Name string `json:"name"`
|
|
Size int64 `json:"size"`
|
|
}
|
|
|
|
// AddRequest — параметры добавления торрента.
|
|
type AddRequest struct {
|
|
URLs []string // magnet/URL-ссылки
|
|
Torrents [][]byte // .torrent-файлы (Ф1 не использует)
|
|
Category string
|
|
SavePath string
|
|
Paused bool
|
|
}
|
|
|
|
// New создаёт клиент с собственным cookie-jar.
|
|
func New(cfg Config) (*Client, error) {
|
|
base, err := url.Parse(strings.TrimRight(cfg.URL, "/"))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("parse qbittorrent url %q: %w", cfg.URL, err)
|
|
}
|
|
jar, err := cookiejar.New(nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("cookie jar: %w", err)
|
|
}
|
|
timeout := cfg.Timeout
|
|
if timeout == 0 {
|
|
timeout = 30 * time.Second
|
|
}
|
|
return &Client{
|
|
base: base,
|
|
hc: &http.Client{Jar: jar, Timeout: timeout},
|
|
user: cfg.Username,
|
|
pass: cfg.Password,
|
|
}, nil
|
|
}
|
|
|
|
func (c *Client) endpoint(path string) string { return c.base.String() + path }
|
|
|
|
// login устанавливает cookie-сессию. Сериализован, чтобы параллельные
|
|
// вызовы (поллинг + приём) не логинились наперегонки.
|
|
func (c *Client) login(ctx context.Context) error {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
|
|
form := url.Values{"username": {c.user}, "password": {c.pass}}
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodPost,
|
|
c.endpoint("/api/v2/auth/login"), strings.NewReader(form.Encode()))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
|
|
req.Header.Set("Referer", c.base.String()) // qBit проверяет Referer/Host
|
|
resp, err := c.hc.Do(req)
|
|
if err != nil {
|
|
return fmt.Errorf("qbittorrent login: %w", err)
|
|
}
|
|
defer func() { _ = resp.Body.Close() }()
|
|
body, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<10))
|
|
if resp.StatusCode != http.StatusOK || strings.TrimSpace(string(body)) != "Ok." {
|
|
return fmt.Errorf("qbittorrent login failed: status %d body %q",
|
|
resp.StatusCode, strings.TrimSpace(string(body)))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// do выполняет запрос; при 403 один раз перелогинивается и повторяет.
|
|
// build вызывается заново для повтора, т.к. тело запроса одноразовое.
|
|
func (c *Client) do(ctx context.Context, build func() (*http.Request, error)) (*http.Response, error) {
|
|
req, err := build()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
resp, err := c.hc.Do(req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if resp.StatusCode == http.StatusForbidden {
|
|
_ = resp.Body.Close()
|
|
if err := c.login(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
req2, err := build()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return c.hc.Do(req2)
|
|
}
|
|
return resp, nil
|
|
}
|
|
|
|
// Add добавляет торрент(ы) в qBittorrent.
|
|
func (c *Client) Add(ctx context.Context, ar AddRequest) error {
|
|
var buf bytes.Buffer
|
|
mw := multipart.NewWriter(&buf)
|
|
if len(ar.URLs) > 0 {
|
|
_ = mw.WriteField("urls", strings.Join(ar.URLs, "\n"))
|
|
}
|
|
if ar.Category != "" {
|
|
_ = mw.WriteField("category", ar.Category)
|
|
}
|
|
if ar.SavePath != "" {
|
|
_ = mw.WriteField("savepath", ar.SavePath)
|
|
}
|
|
_ = mw.WriteField("paused", strconv.FormatBool(ar.Paused))
|
|
for i, data := range ar.Torrents {
|
|
fw, err := mw.CreateFormFile("torrents", fmt.Sprintf("file%d.torrent", i))
|
|
if err != nil {
|
|
return fmt.Errorf("qbittorrent add: form file: %w", err)
|
|
}
|
|
if _, err := fw.Write(data); err != nil {
|
|
return fmt.Errorf("qbittorrent add: write file: %w", err)
|
|
}
|
|
}
|
|
if err := mw.Close(); err != nil {
|
|
return fmt.Errorf("qbittorrent add: close multipart: %w", err)
|
|
}
|
|
contentType := mw.FormDataContentType()
|
|
payload := buf.Bytes()
|
|
|
|
resp, err := c.do(ctx, func() (*http.Request, error) {
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodPost,
|
|
c.endpoint("/api/v2/torrents/add"), bytes.NewReader(payload))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
req.Header.Set("Content-Type", contentType)
|
|
req.Header.Set("Referer", c.base.String())
|
|
return req, nil
|
|
})
|
|
if err != nil {
|
|
return fmt.Errorf("qbittorrent add: %w", err)
|
|
}
|
|
defer func() { _ = resp.Body.Close() }()
|
|
body, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<10))
|
|
if resp.StatusCode != http.StatusOK {
|
|
return fmt.Errorf("qbittorrent add: status %d body %q",
|
|
resp.StatusCode, strings.TrimSpace(string(body)))
|
|
}
|
|
if strings.TrimSpace(string(body)) == "Fails." {
|
|
return fmt.Errorf("qbittorrent add: rejected (Fails.)")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Torrents возвращает задачи указанной категории (пустая — все).
|
|
func (c *Client) Torrents(ctx context.Context, category string) ([]Torrent, error) {
|
|
resp, err := c.do(ctx, func() (*http.Request, error) {
|
|
u := c.endpoint("/api/v2/torrents/info")
|
|
if category != "" {
|
|
u += "?category=" + url.QueryEscape(category)
|
|
}
|
|
return http.NewRequestWithContext(ctx, http.MethodGet, u, nil)
|
|
})
|
|
if err != nil {
|
|
return nil, fmt.Errorf("qbittorrent info: %w", err)
|
|
}
|
|
defer func() { _ = resp.Body.Close() }()
|
|
if resp.StatusCode != http.StatusOK {
|
|
body, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<10))
|
|
return nil, fmt.Errorf("qbittorrent info: status %d body %q",
|
|
resp.StatusCode, strings.TrimSpace(string(body)))
|
|
}
|
|
var ts []Torrent
|
|
if err := json.NewDecoder(resp.Body).Decode(&ts); err != nil {
|
|
return nil, fmt.Errorf("decode qbittorrent info: %w", err)
|
|
}
|
|
return ts, nil
|
|
}
|
|
|
|
// Files возвращает список файлов торрента (имена относительно save_path,
|
|
// включая корневую папку для многофайловых раздач, и размеры). Нужен
|
|
// распознаванию как один из сигналов; абсолютный путь — join(save_path, Name).
|
|
func (c *Client) Files(ctx context.Context, hash string) ([]File, error) {
|
|
resp, err := c.do(ctx, func() (*http.Request, error) {
|
|
u := c.endpoint("/api/v2/torrents/files?hash=" + url.QueryEscape(hash))
|
|
return http.NewRequestWithContext(ctx, http.MethodGet, u, nil)
|
|
})
|
|
if err != nil {
|
|
return nil, fmt.Errorf("qbittorrent files: %w", err)
|
|
}
|
|
defer func() { _ = resp.Body.Close() }()
|
|
if resp.StatusCode != http.StatusOK {
|
|
body, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<10))
|
|
return nil, fmt.Errorf("qbittorrent files: status %d body %q",
|
|
resp.StatusCode, strings.TrimSpace(string(body)))
|
|
}
|
|
var fs []File
|
|
if err := json.NewDecoder(resp.Body).Decode(&fs); err != nil {
|
|
return nil, fmt.Errorf("decode qbittorrent files: %w", err)
|
|
}
|
|
return fs, nil
|
|
}
|