Feature: Deluge download client (#12)

* chore: add go-libdeluge package

* feat: implement deluge v1 and v2 clients

* feat(web): handle add and update deluge clients

* chore: temp remove releaseinfo parser
This commit is contained in:
Ludvig Lundgren 2021-08-20 22:08:32 +02:00 committed by GitHub
parent eb5b040eeb
commit 0c4aaa29b0
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
19 changed files with 493 additions and 122 deletions

195
internal/action/deluge.go Normal file
View file

@ -0,0 +1,195 @@
package action
import (
"encoding/base64"
"errors"
"io/ioutil"
"time"
"github.com/autobrr/autobrr/internal/domain"
delugeClient "github.com/gdm85/go-libdeluge"
"github.com/rs/zerolog/log"
)
func (s *service) deluge(action domain.Action, torrentFile string) error {
log.Trace().Msgf("action DELUGE: %v", torrentFile)
var err error
// get client for action
client, err := s.clientSvc.FindByID(action.ClientID)
if err != nil {
log.Error().Err(err).Msgf("error finding client: %v", action.ClientID)
return err
}
if client == nil {
return errors.New("no client found")
}
settings := delugeClient.Settings{
Hostname: client.Host,
Port: uint(client.Port),
Login: client.Username,
Password: client.Password,
DebugServerResponses: true,
ReadWriteTimeout: time.Second * 20,
}
switch client.Type {
case "DELUGE_V1":
err = delugeV1(settings, action, torrentFile)
case "DELUGE_V2":
err = delugeV2(settings, action, torrentFile)
}
return err
}
func delugeV1(settings delugeClient.Settings, action domain.Action, torrentFile string) error {
deluge := delugeClient.NewV1(settings)
// perform connection to Deluge server
err := deluge.Connect()
if err != nil {
log.Error().Err(err).Msgf("error logging into client: %v", settings.Hostname)
return err
}
defer deluge.Close()
t, err := ioutil.ReadFile(torrentFile)
if err != nil {
log.Error().Err(err).Msgf("could not read torrent file: %v", torrentFile)
return err
}
// encode file to base64 before sending to deluge
encodedFile := base64.StdEncoding.EncodeToString(t)
if encodedFile == "" {
log.Error().Err(err).Msgf("could not encode torrent file: %v", torrentFile)
return err
}
// set options
options := delugeClient.Options{}
if action.Paused {
options.AddPaused = &action.Paused
}
if action.SavePath != "" {
options.DownloadLocation = &action.SavePath
}
if action.LimitDownloadSpeed > 0 {
maxDL := int(action.LimitDownloadSpeed)
options.MaxDownloadSpeed = &maxDL
}
if action.LimitUploadSpeed > 0 {
maxUL := int(action.LimitUploadSpeed)
options.MaxUploadSpeed = &maxUL
}
torrentHash, err := deluge.AddTorrentFile(torrentFile, encodedFile, &options)
if err != nil {
log.Error().Err(err).Msgf("could not add torrent to client: %v", torrentFile)
return err
}
if action.Label != "" {
p, err := deluge.LabelPlugin()
if err != nil {
log.Error().Err(err).Msgf("could not load label plugin: %v", torrentFile)
return err
}
if p != nil {
// TODO first check if label exists, if not, add it, otherwise set
err = p.SetTorrentLabel(torrentHash, action.Label)
if err != nil {
log.Error().Err(err).Msgf("could not set label: %v", torrentFile)
return err
}
}
}
log.Trace().Msgf("deluge: torrent successfully added! hash: %v", torrentHash)
return nil
}
func delugeV2(settings delugeClient.Settings, action domain.Action, torrentFile string) error {
deluge := delugeClient.NewV2(settings)
// perform connection to Deluge server
err := deluge.Connect()
if err != nil {
log.Error().Err(err).Msgf("error logging into client: %v", settings.Hostname)
return err
}
defer deluge.Close()
t, err := ioutil.ReadFile(torrentFile)
if err != nil {
log.Error().Err(err).Msgf("could not read torrent file: %v", torrentFile)
return err
}
// encode file to base64 before sending to deluge
encodedFile := base64.StdEncoding.EncodeToString(t)
if encodedFile == "" {
log.Error().Err(err).Msgf("could not encode torrent file: %v", torrentFile)
return err
}
// set options
options := delugeClient.Options{}
if action.Paused {
options.AddPaused = &action.Paused
}
if action.SavePath != "" {
options.DownloadLocation = &action.SavePath
}
if action.LimitDownloadSpeed > 0 {
maxDL := int(action.LimitDownloadSpeed)
options.MaxDownloadSpeed = &maxDL
}
if action.LimitUploadSpeed > 0 {
maxUL := int(action.LimitUploadSpeed)
options.MaxUploadSpeed = &maxUL
}
torrentHash, err := deluge.AddTorrentFile(torrentFile, encodedFile, &options)
if err != nil {
log.Error().Err(err).Msgf("could not add torrent to client: %v", torrentFile)
return err
}
if action.Label != "" {
p, err := deluge.LabelPlugin()
if err != nil {
log.Error().Err(err).Msgf("could not load label plugin: %v", torrentFile)
return err
}
if p != nil {
// TODO first check if label exists, if not, add it, otherwise set
err = p.SetTorrentLabel(torrentHash, action.Label)
if err != nil {
log.Error().Err(err).Msgf("could not set label: %v", torrentFile)
return err
}
}
}
log.Trace().Msgf("deluge: torrent successfully added! hash: %v", torrentHash)
return nil
}

View file

@ -57,10 +57,17 @@ func (s *service) RunActions(torrentFile string, hash string, filter domain.Filt
case domain.ActionTypeExec:
go s.execCmd(announce, action, torrentFile)
// deluge
case domain.ActionTypeDelugeV1, domain.ActionTypeDelugeV2:
go func() {
err := s.deluge(action, torrentFile)
if err != nil {
log.Error().Err(err).Msg("error sending torrent to client")
}
}()
// pvr *arr
default:
log.Debug().Msgf("unsupported action: %v type: %v", action.Name, action.Type)
log.Warn().Msgf("unsupported action: %v type: %v", action.Name, action.Type)
}
}

View file

@ -11,8 +11,6 @@ import (
"text/template"
"github.com/autobrr/autobrr/internal/domain"
"github.com/autobrr/autobrr/pkg/releaseinfo"
"github.com/pkg/errors"
"github.com/rs/zerolog/log"
)
@ -262,12 +260,12 @@ func (s *service) extractReleaseInfo(varMap map[string]string, releaseName strin
canonReleaseName := cleanReleaseName(releaseName)
log.Trace().Msgf("canonicalize release name: %v", canonReleaseName)
release, err := releaseinfo.Parse(releaseName)
if err != nil {
return err
}
log.Trace().Msgf("release: %+v", release)
//release, err := releaseinfo.Parse(releaseName)
//if err != nil {
// return err
//}
//
//log.Trace().Msgf("release: %+v", release)
// https://github.com/autodl-community/autodl-irssi/pull/194/files
// year

View file

@ -34,6 +34,7 @@ const (
ActionTypeTest ActionType = "TEST"
ActionTypeExec ActionType = "EXEC"
ActionTypeQbittorrent ActionType = "QBITTORRENT"
ActionTypeDeluge ActionType = "DELUGE"
ActionTypeDelugeV1 ActionType = "DELUGE_V1"
ActionTypeDelugeV2 ActionType = "DELUGE_V2"
ActionTypeWatchFolder ActionType = "WATCH_FOLDER"
)

View file

@ -24,5 +24,6 @@ type DownloadClientType string
const (
DownloadClientTypeQbittorrent DownloadClientType = "QBITTORRENT"
DownloadClientTypeDeluge DownloadClientType = "DELUGE"
DownloadClientTypeDelugeV1 DownloadClientType = "DELUGE_V1"
DownloadClientTypeDelugeV2 DownloadClientType = "DELUGE_V2"
)

View file

@ -1,10 +1,13 @@
package download_client
import (
"github.com/rs/zerolog/log"
"errors"
"time"
"github.com/autobrr/autobrr/internal/domain"
"github.com/autobrr/autobrr/pkg/qbittorrent"
delugeClient "github.com/gdm85/go-libdeluge"
"github.com/rs/zerolog/log"
)
type Service interface {
@ -43,6 +46,13 @@ func (s *service) FindByID(id int32) (*domain.DownloadClient, error) {
func (s *service) Store(client domain.DownloadClient) (*domain.DownloadClient, error) {
// validate data
if client.Host == "" {
return nil, errors.New("validation error: no host")
} else if client.Port == 0 {
return nil, errors.New("validation error: no port")
} else if client.Type == "" {
return nil, errors.New("validation error: no type")
}
// store
c, err := s.repo.Store(client)
@ -64,6 +74,15 @@ func (s *service) Delete(clientID int) error {
}
func (s *service) Test(client domain.DownloadClient) error {
// basic validation of client
if client.Host == "" {
return errors.New("validation error: no host")
} else if client.Port == 0 {
return errors.New("validation error: no port")
} else if client.Type == "" {
return errors.New("validation error: no type")
}
// test
err := s.testConnection(client)
if err != nil {
@ -74,22 +93,75 @@ func (s *service) Test(client domain.DownloadClient) error {
}
func (s *service) testConnection(client domain.DownloadClient) error {
if client.Type == "QBITTORRENT" {
qbtSettings := qbittorrent.Settings{
Hostname: client.Host,
Port: uint(client.Port),
Username: client.Username,
Password: client.Password,
SSL: client.SSL,
}
qbt := qbittorrent.NewClient(qbtSettings)
err := qbt.Login()
if err != nil {
log.Error().Err(err).Msgf("error logging into client: %v", client.Host)
return err
}
switch client.Type {
case domain.DownloadClientTypeQbittorrent:
return s.testQbittorrentConnection(client)
case domain.DownloadClientTypeDelugeV1, domain.DownloadClientTypeDelugeV2:
return s.testDelugeConnection(client)
}
return nil
}
func (s *service) testQbittorrentConnection(client domain.DownloadClient) error {
qbtSettings := qbittorrent.Settings{
Hostname: client.Host,
Port: uint(client.Port),
Username: client.Username,
Password: client.Password,
SSL: client.SSL,
}
qbt := qbittorrent.NewClient(qbtSettings)
err := qbt.Login()
if err != nil {
log.Error().Err(err).Msgf("error logging into client: %v", client.Host)
return err
}
return nil
}
func (s *service) testDelugeConnection(client domain.DownloadClient) error {
var deluge delugeClient.DelugeClient
settings := delugeClient.Settings{
Hostname: client.Host,
Port: uint(client.Port),
Login: client.Username,
Password: client.Password,
DebugServerResponses: true,
ReadWriteTimeout: time.Second * 10,
}
switch client.Type {
case "DELUGE_V1":
deluge = delugeClient.NewV1(settings)
case "DELUGE_V2":
deluge = delugeClient.NewV2(settings)
default:
deluge = delugeClient.NewV2(settings)
}
// perform connection to Deluge server
err := deluge.Connect()
if err != nil {
log.Error().Err(err).Msgf("error logging into client: %v", client.Host)
return err
}
defer deluge.Close()
// print daemon version
ver, err := deluge.DaemonVersion()
if err != nil {
log.Error().Err(err).Msgf("could not get daemon version: %v", client.Host)
return err
}
log.Debug().Msgf("daemon version: %v", ver)
return nil
}