297 lines
8.1 KiB
Go
297 lines
8.1 KiB
Go
package debrid
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"github.com/rs/zerolog"
|
|
"github.com/sirrobot01/debrid-blackhole/common"
|
|
"github.com/sirrobot01/debrid-blackhole/pkg/debrid/structs"
|
|
"net/http"
|
|
gourl "net/url"
|
|
"os"
|
|
"path/filepath"
|
|
"slices"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
type RealDebrid struct {
|
|
BaseDebrid
|
|
}
|
|
|
|
func (r *RealDebrid) GetMountPath() string {
|
|
return r.MountPath
|
|
}
|
|
|
|
func (r *RealDebrid) GetName() string {
|
|
return r.Name
|
|
}
|
|
|
|
func (r *RealDebrid) GetLogger() zerolog.Logger {
|
|
return r.logger
|
|
}
|
|
|
|
func GetTorrentFiles(data structs.RealDebridTorrentInfo) []TorrentFile {
|
|
files := make([]TorrentFile, 0)
|
|
for _, f := range data.Files {
|
|
name := filepath.Base(f.Path)
|
|
if common.RegexMatch(common.SAMPLEMATCH, name) {
|
|
// Skip sample files
|
|
continue
|
|
}
|
|
if !common.RegexMatch(common.VIDEOMATCH, name) && !common.RegexMatch(common.MUSICMATCH, name) {
|
|
continue
|
|
}
|
|
fileId := f.ID
|
|
file := TorrentFile{
|
|
Name: name,
|
|
Path: name,
|
|
Size: f.Bytes,
|
|
Id: strconv.Itoa(fileId),
|
|
}
|
|
files = append(files, file)
|
|
}
|
|
return files
|
|
}
|
|
|
|
func (r *RealDebrid) IsAvailable(infohashes []string) map[string]bool {
|
|
// Check if the infohashes are available in the local cache
|
|
hashes, result := GetLocalCache(infohashes, r.cache)
|
|
|
|
if len(hashes) == 0 {
|
|
// Either all the infohashes are locally cached or none are
|
|
r.cache.AddMultiple(result)
|
|
return result
|
|
}
|
|
|
|
// Divide hashes into groups of 100
|
|
for i := 0; i < len(hashes); i += 200 {
|
|
end := i + 200
|
|
if end > len(hashes) {
|
|
end = len(hashes)
|
|
}
|
|
|
|
// Filter out empty strings
|
|
validHashes := make([]string, 0, end-i)
|
|
for _, hash := range hashes[i:end] {
|
|
if hash != "" {
|
|
validHashes = append(validHashes, hash)
|
|
}
|
|
}
|
|
|
|
// If no valid hashes in this batch, continue to the next batch
|
|
if len(validHashes) == 0 {
|
|
continue
|
|
}
|
|
|
|
hashStr := strings.Join(validHashes, "/")
|
|
url := fmt.Sprintf("%s/torrents/instantAvailability/%s", r.Host, hashStr)
|
|
req, _ := http.NewRequest(http.MethodGet, url, nil)
|
|
resp, err := r.client.MakeRequest(req)
|
|
if err != nil {
|
|
r.logger.Info().Msgf("Error checking availability: %v", err)
|
|
return result
|
|
}
|
|
var data structs.RealDebridAvailabilityResponse
|
|
err = json.Unmarshal(resp, &data)
|
|
if err != nil {
|
|
r.logger.Info().Msgf("Error marshalling availability: %v", err)
|
|
return result
|
|
}
|
|
for _, h := range hashes[i:end] {
|
|
hosters, exists := data[strings.ToLower(h)]
|
|
if exists && len(hosters.Rd) > 0 {
|
|
result[h] = true
|
|
}
|
|
}
|
|
}
|
|
r.cache.AddMultiple(result) // Add the results to the cache
|
|
return result
|
|
}
|
|
|
|
func (r *RealDebrid) SubmitMagnet(torrent *Torrent) (*Torrent, error) {
|
|
url := fmt.Sprintf("%s/torrents/addMagnet", r.Host)
|
|
payload := gourl.Values{
|
|
"magnet": {torrent.Magnet.Link},
|
|
}
|
|
var data structs.RealDebridAddMagnetSchema
|
|
req, _ := http.NewRequest(http.MethodPost, url, strings.NewReader(payload.Encode()))
|
|
resp, err := r.client.MakeRequest(req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
err = json.Unmarshal(resp, &data)
|
|
r.logger.Info().Msgf("Torrent: %s added with id: %s", torrent.Name, data.Id)
|
|
torrent.Id = data.Id
|
|
|
|
return torrent, nil
|
|
}
|
|
|
|
func (r *RealDebrid) GetTorrent(id string) (*Torrent, error) {
|
|
torrent := &Torrent{}
|
|
url := fmt.Sprintf("%s/torrents/info/%s", r.Host, id)
|
|
req, _ := http.NewRequest(http.MethodGet, url, nil)
|
|
resp, err := r.client.MakeRequest(req)
|
|
if err != nil {
|
|
return torrent, err
|
|
}
|
|
var data structs.RealDebridTorrentInfo
|
|
err = json.Unmarshal(resp, &data)
|
|
if err != nil {
|
|
return torrent, err
|
|
}
|
|
name := common.RemoveInvalidChars(data.OriginalFilename)
|
|
torrent.Id = id
|
|
torrent.Name = name
|
|
torrent.Bytes = data.Bytes
|
|
torrent.Folder = name
|
|
torrent.Progress = data.Progress
|
|
torrent.Status = data.Status
|
|
torrent.Speed = data.Speed
|
|
torrent.Seeders = data.Seeders
|
|
torrent.Filename = data.Filename
|
|
torrent.OriginalFilename = data.OriginalFilename
|
|
torrent.Links = data.Links
|
|
torrent.Debrid = r
|
|
files := GetTorrentFiles(data)
|
|
torrent.Files = files
|
|
return torrent, nil
|
|
}
|
|
|
|
func (r *RealDebrid) CheckStatus(torrent *Torrent, isSymlink bool) (*Torrent, error) {
|
|
url := fmt.Sprintf("%s/torrents/info/%s", r.Host, torrent.Id)
|
|
req, _ := http.NewRequest(http.MethodGet, url, nil)
|
|
for {
|
|
resp, err := r.client.MakeRequest(req)
|
|
if err != nil {
|
|
r.logger.Info().Msgf("ERROR Checking file: %v", err)
|
|
return torrent, err
|
|
}
|
|
var data structs.RealDebridTorrentInfo
|
|
err = json.Unmarshal(resp, &data)
|
|
status := data.Status
|
|
name := common.RemoveInvalidChars(data.OriginalFilename)
|
|
torrent.Name = name // Important because some magnet changes the name
|
|
torrent.Folder = name
|
|
torrent.Filename = data.Filename
|
|
torrent.OriginalFilename = data.OriginalFilename
|
|
torrent.Bytes = data.Bytes
|
|
torrent.Progress = data.Progress
|
|
torrent.Speed = data.Speed
|
|
torrent.Seeders = data.Seeders
|
|
torrent.Links = data.Links
|
|
torrent.Status = status
|
|
torrent.Debrid = r
|
|
downloadingStatus := []string{"downloading", "magnet_conversion", "queued", "compressing", "uploading"}
|
|
if status == "error" || status == "dead" || status == "magnet_error" {
|
|
return torrent, fmt.Errorf("torrent: %s has error: %s", torrent.Name, status)
|
|
} else if status == "waiting_files_selection" {
|
|
files := GetTorrentFiles(data)
|
|
torrent.Files = files
|
|
if len(files) == 0 {
|
|
return torrent, fmt.Errorf("no video files found")
|
|
}
|
|
filesId := make([]string, 0)
|
|
for _, f := range files {
|
|
filesId = append(filesId, f.Id)
|
|
}
|
|
p := gourl.Values{
|
|
"files": {strings.Join(filesId, ",")},
|
|
}
|
|
payload := strings.NewReader(p.Encode())
|
|
req, _ := http.NewRequest(http.MethodPost, fmt.Sprintf("%s/torrents/selectFiles/%s", r.Host, torrent.Id), payload)
|
|
_, err = r.client.MakeRequest(req)
|
|
if err != nil {
|
|
return torrent, err
|
|
}
|
|
} else if status == "downloaded" {
|
|
files := GetTorrentFiles(data)
|
|
torrent.Files = files
|
|
r.logger.Info().Msgf("Torrent: %s downloaded to RD", torrent.Name)
|
|
if !isSymlink {
|
|
err = r.GetDownloadLinks(torrent)
|
|
if err != nil {
|
|
return torrent, err
|
|
}
|
|
}
|
|
break
|
|
} else if slices.Contains(downloadingStatus, status) {
|
|
if !r.DownloadUncached {
|
|
return torrent, fmt.Errorf("torrent: %s not cached", torrent.Name)
|
|
}
|
|
// Break out of the loop if the torrent is downloading.
|
|
// This is necessary to prevent infinite loop since we moved to sync downloading and async processing
|
|
break
|
|
}
|
|
|
|
}
|
|
return torrent, nil
|
|
}
|
|
|
|
func (r *RealDebrid) DeleteTorrent(torrent *Torrent) {
|
|
url := fmt.Sprintf("%s/torrents/delete/%s", r.Host, torrent.Id)
|
|
req, _ := http.NewRequest(http.MethodDelete, url, nil)
|
|
_, err := r.client.MakeRequest(req)
|
|
if err == nil {
|
|
r.logger.Info().Msgf("Torrent: %s deleted", torrent.Name)
|
|
} else {
|
|
r.logger.Info().Msgf("Error deleting torrent: %s", err)
|
|
}
|
|
}
|
|
|
|
func (r *RealDebrid) GetDownloadLinks(torrent *Torrent) error {
|
|
url := fmt.Sprintf("%s/unrestrict/link/", r.Host)
|
|
downloadLinks := make([]TorrentDownloadLinks, 0)
|
|
for _, link := range torrent.Links {
|
|
if link == "" {
|
|
continue
|
|
}
|
|
payload := gourl.Values{
|
|
"link": {link},
|
|
}
|
|
req, _ := http.NewRequest(http.MethodPost, url, strings.NewReader(payload.Encode()))
|
|
resp, err := r.client.MakeRequest(req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
var data structs.RealDebridUnrestrictResponse
|
|
if err = json.Unmarshal(resp, &data); err != nil {
|
|
return err
|
|
}
|
|
download := TorrentDownloadLinks{
|
|
Link: data.Link,
|
|
Filename: data.Filename,
|
|
DownloadLink: data.Download,
|
|
}
|
|
downloadLinks = append(downloadLinks, download)
|
|
}
|
|
torrent.DownloadLinks = downloadLinks
|
|
return nil
|
|
}
|
|
|
|
func (r *RealDebrid) GetCheckCached() bool {
|
|
return r.CheckCached
|
|
}
|
|
|
|
func NewRealDebrid(dc common.DebridConfig, cache *common.Cache) *RealDebrid {
|
|
rl := common.ParseRateLimit(dc.RateLimit)
|
|
headers := map[string]string{
|
|
"Authorization": fmt.Sprintf("Bearer %s", dc.APIKey),
|
|
}
|
|
client := common.NewRLHTTPClient(rl, headers)
|
|
logger := common.NewLogger(dc.Name, common.CONFIG.LogLevel, os.Stdout)
|
|
return &RealDebrid{
|
|
BaseDebrid: BaseDebrid{
|
|
Name: "realdebrid",
|
|
Host: dc.Host,
|
|
APIKey: dc.APIKey,
|
|
DownloadUncached: dc.DownloadUncached,
|
|
client: client,
|
|
cache: cache,
|
|
MountPath: dc.Folder,
|
|
logger: logger,
|
|
CheckCached: dc.CheckCached,
|
|
},
|
|
}
|
|
}
|