使用 Golang 自定义管理 qBittorrent 下载种子的规则

qBittorrent-manager --username=admin --password=admin

package main

import (
	"bytes"
	"encoding/json"
	"errors"
	"flag"
	"fmt"
	"net/http"
	"net/http/cookiejar"
	"os"
	"time"
)

// Torrent 结构体定义
type Torrent struct {
	Hash  string  `json:"hash"`
	Name  string  `json:"name"`
	Ratio float64 `json:"ratio"`
	Addon int64   `json:"added_on"`
}

// 登录并获取会话 cookie
func login(client *http.Client, qbURL, username, password string) error {
	loginData := fmt.Sprintf("username=%s&password=%s", username, password)
	req, err := http.NewRequest("POST", qbURL+"/api/v2/auth/login", bytes.NewBufferString(loginData))
	if err != nil {
		return err
	}
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")

	resp, err := client.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return fmt.Errorf("failed to login, status code: %d", resp.StatusCode)
	}

	fmt.Println("Logged in successfully.")
	return nil
}

// 获取当前所有种子的状态
func getTorrents(client *http.Client, qbURL string) ([]Torrent, error) {
	req, err := http.NewRequest("GET", qbURL+"/api/v2/torrents/info", nil)
	if err != nil {
		return nil, err
	}
	req.Header.Set("Content-Type", "application/json")

	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("failed to fetch torrents info, status code: %d", resp.StatusCode)
	}

	var torrents []Torrent
	if err := json.NewDecoder(resp.Body).Decode(&torrents); err != nil {
		return nil, err
	}

	fmt.Println("Torrents information fetched successfully.")
	return torrents, nil
}

// 删除种子
func deleteTorrent(client *http.Client, qbURL, hash string) error {
	data := fmt.Sprintf("hashes=%s&deleteFiles=true", hash)
	req, err := http.NewRequest("POST", qbURL+"/api/v2/torrents/delete", bytes.NewBufferString(data))
	if err != nil {
		return err
	}
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")

	resp, err := client.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return fmt.Errorf("failed to delete torrent, status code: %d", resp.StatusCode)
	}

	return nil
}

func searchTorrentOnLocal(hash, recordFile string) (Torrent, error) {
	var torrent Torrent
	var torrents []Torrent
	if _, err := os.Stat(recordFile); os.IsNotExist(err) {
		fmt.Println("No existing torrents found. Starting fresh.")
		return torrent, err
	}

	data, err := os.ReadFile(recordFile)
	if err != nil {
		return torrent, err
	}

	if err := json.Unmarshal(data, &torrents); err != nil {
		return torrent, err
	}

	for _, torrent := range torrents {
		if torrent.Hash == hash {
			return torrent, nil
		}
	}

	return torrent, errors.New("hash Not Found")
}

// 保存记录
func saveTorrentToLocal(torrents []Torrent, recordFile string) error {
	data, err := json.MarshalIndent(torrents, "", "  ")
	if err != nil {
		return err
	}

	if err := os.WriteFile(recordFile, data, 0644); err != nil {
		return err
	}

	fmt.Printf("Records saved to %s.\n", recordFile)
	return nil
}

func main() {
	// 定义命令行参数
	qbURL := flag.String("url", "http://localhost:8080", "The URL of the qBittorrent Web UI")
	username := flag.String("username", "admin", "The username for qBittorrent Web UI")
	password := flag.String("password", "adminadmin", "The password for qBittorrent Web UI")
	recordFile := flag.String("recordFile", "torrent-records.json", "The file to save torrent records")
	ratioIncrease := flag.Float64("ratioIncrease", 0.5, "The radio increases each time")
	protectionPeriod := flag.Int("protectionPeriod", 7, "The protection period for torrent")
	try := flag.Bool("try", false, "Display the deletion target without actually deleting the torrent")

	// 解析命令行参数
	flag.Parse()

	// 创建一个 cookie jar 来管理会话
	jar, err := cookiejar.New(nil)
	if err != nil {
		fmt.Printf("Error creating cookie jar: %v\n", err)
		return
	}

	// 创建 HTTP 客户端并设置 cookie jar
	client := &http.Client{
		Jar: jar,
	}

	// 执行登录
	if err := login(client, *qbURL, *username, *password); err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	// 获取种子信息
	torrents, err := getTorrents(client, *qbURL)
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	// 检查上传率
	nowTime := time.Now()
	for _, torrent := range torrents {
		fmt.Printf("Processing torrent <%s>\n", torrent.Name)
		if record, err := searchTorrentOnLocal(torrent.Hash, *recordFile); err != nil {
			// 种子在本地没有记录则跳过
			fmt.Printf("Torrent <%s> name not found\n", torrent.Name)
			continue
		} else {
			// 保护期内的种子不会被删除
			addTime := time.Unix(torrent.Addon, 0)
			daysDiffDays := int(nowTime.Sub(addTime).Hours() / 24)
			if daysDiffDays < *protectionPeriod {
				fmt.Printf("Torrent <%s> not more than %d days\n", torrent.Name, *protectionPeriod)
				continue
			}

			// 比对分享率增长
			fmt.Printf("Torrent <%s> local record ratio %.2f and torrent current radio %.2f\n", record.Name, record.Ratio, torrent.Ratio)

			if torrent.Ratio-record.Ratio < *ratioIncrease {
				// 删除分享率上升不足的种子
				fmt.Printf("Deleting torrent <%s> due to insufficient share ratio increase(radio increase %.2f).\n", torrent.Name, torrent.Ratio-record.Ratio)
				if err := deleteTorrent(client, *qbURL, torrent.Hash); err != nil && !*try {
					fmt.Printf("Failed to delete torrent %s error: %v\n", torrent.Name, err)
				}
			}
		}
	}

	// 保存本次查询结果，方便下次查询比对分享率的增长情况
	if err := saveTorrentToLocal(torrents, *recordFile); err != nil {
		fmt.Printf("Error saving torrents to local file: %v\n", err)
		return
	}

	fmt.Println("All records processed and updated.")
}