idanoo/autobrr
1
0
Fork 0
mirror of https://github.com/idanoo/autobrr synced 2025-07-23 08:49:13 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

feat(lists): integrate Omegabrr (#1885)

Browse source 
* feat(lists): integrate Omegabrr

* feat(lists): add missing lists index

* feat(lists): add db repo

* feat(lists): add db migrations

* feat(lists): labels

* feat(lists): url lists and more arrs

* fix(lists): db migrations client_id wrong type

* fix(lists): db fields

* feat(lists): create list form wip

* feat(lists): show in list and create

* feat(lists): update and delete

* feat(lists): trigger via webhook

* feat(lists): add webhook handler

* fix(arr): encode json to pointer

* feat(lists): rename endpoint to lists

* feat(lists): fetch tags from arr

* feat(lists): process plaintext lists

* feat(lists): add background refresh job

* run every 6th hour with a random start delay between 1-35 seconds

* feat(lists): refresh on save and improve logging

* feat(lists): cast arr client to pointer

* feat(lists): improve error handling

* feat(lists): reset shows field with match release

* feat(lists): filter opts all lists

* feat(lists): trigger on update if enabled

* feat(lists): update option for lists

* feat(lists): show connected filters in list

* feat(lists): missing listSvc dep

* feat(lists): cleanup

* feat(lists): typo arr list

* feat(lists): radarr include original

* feat(lists): rename ExcludeAlternateTitle to IncludeAlternateTitle

* fix(lists): arr client type conversion to pointer

* fix(actions): only log panic recover if err not nil

* feat(lists): show spinner on save

* feat(lists): show icon in filters list

* feat(lists): change icon color in filters list

* feat(lists): delete relations on filter delete
This commit is contained in:
ze0s 2024-12-25 13:23:37 +01:00 • committed by GitHub
parent b68ae334ca
commit 221bc35371
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
77 changed files with 5025 additions and 254 deletions
Download patch file Download diff file Expand all files Collapse all files

198
pkg/arr/lidarr/client.go Normal file
View file

@ -0,0 +1,198 @@
// Copyright (c) 2021 - 2024, Ludvig Lundgren and the autobrr contributors.
// SPDX-License-Identifier: GPL-2.0-or-later
package lidarr
import (
"bytes"
"context"
"encoding/json"
"io"
"net/http"
"net/url"
"path"
"github.com/autobrr/autobrr/pkg/errors"
)
func (c *Client) get(ctx context.Context, endpoint string) (int, []byte, error) {
u, err := url.Parse(c.config.Hostname)
if err != nil {
return 0, nil, errors.Wrap(err, "could not parse url: %s", c.config.Hostname)
}
u.Path = path.Join(u.Path, "/api/v1/", endpoint)
reqUrl := u.String()
req, err := http.NewRequestWithContext(ctx, http.MethodGet, reqUrl, http.NoBody)
if err != nil {
return 0, nil, errors.Wrap(err, "lidarr Client request error : %v", reqUrl)
}
if c.config.BasicAuth {
req.SetBasicAuth(c.config.Username, c.config.Password)
}
c.setHeaders(req)
resp, err := c.http.Do(req)
if err != nil {
return 0, nil, errors.Wrap(err, "lidarr.http.Do(req)")
}
defer resp.Body.Close()
if resp.Body == nil {
return resp.StatusCode, nil, errors.New("response body is nil")
}
var buf bytes.Buffer
if _, err = io.Copy(&buf, resp.Body); err != nil {
return resp.StatusCode, nil, errors.Wrap(err, "lidarr.io.Copy error")
}
return resp.StatusCode, buf.Bytes(), nil
}
func (c *Client) getJSON(ctx context.Context, endpoint string, params url.Values, data any) error {
u, err := url.Parse(c.config.Hostname)
if err != nil {
return errors.Wrap(err, "could not parse url: %s", c.config.Hostname)
}
u.Path = path.Join(u.Path, "/api/v1/", endpoint)
reqUrl := u.String()
req, err := http.NewRequestWithContext(ctx, http.MethodGet, reqUrl, http.NoBody)
if err != nil {
return errors.Wrap(err, "could not build request")
}
if c.config.BasicAuth {
req.SetBasicAuth(c.config.Username, c.config.Password)
}
c.setHeaders(req)
req.URL.RawQuery = params.Encode()
resp, err := c.http.Do(req)
if err != nil {
return errors.Wrap(err, "lidarr.http.Do(req): %+v", req)
}
defer resp.Body.Close()
if resp.Body == nil {
return errors.New("response body is nil")
}
if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
return errors.Wrap(err, "could not unmarshal data")
}
return nil
}
func (c *Client) post(ctx context.Context, endpoint string, data interface{}) (*http.Response, error) {
u, err := url.Parse(c.config.Hostname)
if err != nil {
return nil, errors.Wrap(err, "could not parse url: %s", c.config.Hostname)
}
u.Path = path.Join(u.Path, "/api/v1/", endpoint)
reqUrl := u.String()
jsonData, err := json.Marshal(data)
if err != nil {
return nil, errors.Wrap(err, "lidarr Client could not marshal data: %v", reqUrl)
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, reqUrl, bytes.NewBuffer(jsonData))
if err != nil {
return nil, errors.Wrap(err, "lidarr Client request error: %v", reqUrl)
}
if c.config.BasicAuth {
req.SetBasicAuth(c.config.Username, c.config.Password)
}
req.Header.Add("X-Api-Key", c.config.APIKey)
req.Header.Set("Content-Type", "application/json; charset=UTF-8")
req.Header.Set("User-Agent", "autobrr")
res, err := c.http.Do(req)
if err != nil {
return res, errors.Wrap(err, "lidarr Client request error: %v", reqUrl)
}
// validate response
if res.StatusCode == http.StatusUnauthorized {
return res, errors.New("lidarr: unauthorized: bad credentials")
} else if res.StatusCode != http.StatusOK {
return res, errors.New("lidarr: bad request")
}
// return raw response and let the caller handle json unmarshal of body
return res, nil
}
func (c *Client) postBody(ctx context.Context, endpoint string, data interface{}) (int, []byte, error) {
u, err := url.Parse(c.config.Hostname)
if err != nil {
return 0, nil, errors.Wrap(err, "could not parse url: %s", c.config.Hostname)
}
u.Path = path.Join(u.Path, "/api/v1/", endpoint)
reqUrl := u.String()
jsonData, err := json.Marshal(data)
if err != nil {
return 0, nil, errors.Wrap(err, "lidarr Client could not marshal data: %v", reqUrl)
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, reqUrl, bytes.NewBuffer(jsonData))
if err != nil {
return 0, nil, errors.Wrap(err, "lidarr Client request error: %v", reqUrl)
}
if c.config.BasicAuth {
req.SetBasicAuth(c.config.Username, c.config.Password)
}
c.setHeaders(req)
resp, err := c.http.Do(req)
if err != nil {
return 0, nil, errors.Wrap(err, "lidarr.http.Do(req)")
}
defer resp.Body.Close()
if resp.Body == nil {
return resp.StatusCode, nil, errors.New("response body is nil")
}
var buf bytes.Buffer
if _, err = io.Copy(&buf, resp.Body); err != nil {
return resp.StatusCode, nil, errors.Wrap(err, "lidarr.io.Copy")
}
if resp.StatusCode == http.StatusBadRequest {
return resp.StatusCode, buf.Bytes(), nil
} else if resp.StatusCode < 200 || resp.StatusCode > 401 {
return resp.StatusCode, buf.Bytes(), errors.New("lidarr: bad request: %v (status: %s): %s", resp.Request.RequestURI, resp.Status, buf.String())
}
return resp.StatusCode, buf.Bytes(), nil
}
func (c *Client) setHeaders(req *http.Request) {
if req.Body != nil {
req.Header.Set("Content-Type", "application/json")
}
req.Header.Set("User-Agent", "autobrr")
req.Header.Set("X-Api-Key", c.config.APIKey)
}

147
pkg/arr/lidarr/lidarr.go Normal file
View file

@ -0,0 +1,147 @@
// Copyright (c) 2021 - 2024, Ludvig Lundgren and the autobrr contributors.
// SPDX-License-Identifier: GPL-2.0-or-later
package lidarr
import (
"context"
"encoding/json"
"io"
"log"
"net/http"
"net/url"
"strconv"
"strings"
"time"
"github.com/autobrr/autobrr/pkg/errors"
"github.com/autobrr/autobrr/pkg/sharedhttp"
)
type Config struct {
Hostname string
APIKey string
// basic auth username and password
BasicAuth bool
Username string
Password string
Log *log.Logger
}
type ClientInterface interface {
Test(ctx context.Context) (*SystemStatusResponse, error)
Push(ctx context.Context, release Release) ([]string, error)
}
type Client struct {
config Config
http *http.Client
Log *log.Logger
}
// New create new lidarr Client
func New(config Config) *Client {
httpClient := &http.Client{
Timeout: time.Second * 120,
Transport: sharedhttp.Transport,
}
c := &Client{
config: config,
http: httpClient,
Log: log.New(io.Discard, "", log.LstdFlags),
}
if config.Log != nil {
c.Log = config.Log
}
return c
}
func (c *Client) Test(ctx context.Context) (*SystemStatusResponse, error) {
status, res, err := c.get(ctx, "system/status")
if err != nil {
return nil, errors.Wrap(err, "lidarr Client get error")
}
if status == http.StatusUnauthorized {
return nil, errors.New("unauthorized: bad credentials")
}
c.Log.Printf("lidarr system/status response status: %v body: %v", status, string(res))
response := SystemStatusResponse{}
err = json.Unmarshal(res, &response)
if err != nil {
return nil, errors.Wrap(err, "lidarr Client error json unmarshal")
}
return &response, nil
}
func (c *Client) Push(ctx context.Context, release Release) ([]string, error) {
status, res, err := c.postBody(ctx, "release/push", release)
if err != nil {
return nil, errors.Wrap(err, "lidarr Client post error")
}
c.Log.Printf("lidarr release/push response status: %v body: %v", status, string(res))
if status == http.StatusBadRequest {
badRequestResponses := make([]*BadRequestResponse, 0)
if err = json.Unmarshal(res, &badRequestResponses); err != nil {
return nil, errors.Wrap(err, "could not unmarshal data")
}
rejections := []string{}
for _, response := range badRequestResponses {
rejections = append(rejections, response.String())
}
return rejections, nil
}
pushResponse := PushResponse{}
if err = json.Unmarshal(res, &pushResponse); err != nil {
return nil, errors.Wrap(err, "lidarr Client error json unmarshal")
}
// log and return if rejected
if pushResponse.Rejected {
rejections := strings.Join(pushResponse.Rejections, ", ")
c.Log.Printf("lidarr release/push rejected %v reasons: %q\n", release.Title, rejections)
return pushResponse.Rejections, nil
}
return nil, nil
}
func (c *Client) GetAlbums(ctx context.Context, mbID int64) ([]Album, error) {
params := make(url.Values)
if mbID != 0 {
params.Set("ForeignAlbumId", strconv.FormatInt(mbID, 10))
}
data := make([]Album, 0)
err := c.getJSON(ctx, "album", params, &data)
if err != nil {
return nil, errors.Wrap(err, "could not get tags")
}
return data, nil
}
func (c *Client) GetArtistByID(ctx context.Context, artistID int64) (*Artist, error) {
var data Artist
err := c.getJSON(ctx, "artist/"+strconv.FormatInt(artistID, 10), nil, &data)
if err != nil {
return nil, errors.Wrap(err, "could not get tags")
}
return &data, nil
}

187
pkg/arr/lidarr/lidarr_test.go Normal file
View file

@ -0,0 +1,187 @@
// Copyright (c) 2021 - 2024, Ludvig Lundgren and the autobrr contributors.
// SPDX-License-Identifier: GPL-2.0-or-later
//go:build integration
package lidarr
import (
"context"
"net/http"
"net/http/httptest"
"os"
"testing"
"github.com/rs/zerolog"
"github.com/stretchr/testify/assert"
)
func Test_client_Push(t *testing.T) {
// disable logger
zerolog.SetGlobalLevel(zerolog.Disabled)
mux := http.NewServeMux()
ts := httptest.NewServer(mux)
defer ts.Close()
key := "mock-key"
mux.HandleFunc("/api/v1/release/push", func(w http.ResponseWriter, r *http.Request) {
// request validation logic
apiKey := r.Header.Get("X-Api-Key")
if apiKey != "" {
if apiKey != key {
w.WriteHeader(http.StatusUnauthorized)
w.Write(nil)
return
}
}
// read json response
jsonPayload, _ := os.ReadFile("testdata/release_push_response.json")
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
w.Write(jsonPayload)
})
type fields struct {
config Config
}
type args struct {
release Release
}
tests := []struct {
name string
fields fields
args args
err error
rejections []string
wantErr bool
}{
{
name: "push",
fields: fields{
config: Config{
Hostname: ts.URL,
APIKey: "",
BasicAuth: false,
Username: "",
Password: "",
},
},
args: args{release: Release{
Title: "JR Get Money - Nobody But You [2008] [Single] - FLAC / Lossless / Log / 100% / Cue / CD",
DownloadUrl: "https://www.test.org/rss/download/0000001/00000000000000000000/That Show S01 2160p ATVP WEB-DL DDP 5.1 Atmos DV HEVC-NOGROUP.torrent",
Size: 0,
Indexer: "test",
DownloadProtocol: "torrent",
Protocol: "torrent",
PublishDate: "2021-08-21T15:36:00Z",
}},
rejections: []string{"Unknown Artist"},
},
{
name: "push_error",
fields: fields{
config: Config{
Hostname: ts.URL,
APIKey: key,
BasicAuth: false,
Username: "",
Password: "",
},
},
args: args{release: Release{
Title: "JR Get Money - Nobody But You [2008] [Single] - FLAC / Lossless / Log / 100% / Cue / CD",
DownloadUrl: "https://www.test.org/rss/download/0000001/00000000000000000000/That Show S01 2160p ATVP WEB-DL DDP 5.1 Atmos DV HEVC-NOGROUP.torrent",
Size: 0,
Indexer: "test",
DownloadProtocol: "torrent",
Protocol: "torrent",
PublishDate: "2021-08-21T15:36:00Z",
}},
rejections: []string{"Unknown Artist"},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
c := New(tt.fields.config)
rejections, err := c.Push(context.Background(), tt.args.release)
assert.Equal(t, tt.rejections, rejections)
if tt.wantErr && assert.Error(t, err) {
assert.Equal(t, tt.err, err)
}
})
}
}
func Test_client_Test(t *testing.T) {
// disable logger
zerolog.SetGlobalLevel(zerolog.Disabled)
key := "mock-key"
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
apiKey := r.Header.Get("X-Api-Key")
if apiKey != "" {
if apiKey != key {
w.WriteHeader(http.StatusUnauthorized)
w.Write(nil)
return
}
}
jsonPayload, _ := os.ReadFile("testdata/system_status_response.json")
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
w.Write(jsonPayload)
}))
defer srv.Close()
tests := []struct {
name string
cfg Config
want *SystemStatusResponse
expectedErr string
wantErr bool
}{
{
name: "fetch",
cfg: Config{
Hostname: srv.URL,
APIKey: key,
BasicAuth: false,
Username: "",
Password: "",
},
want: &SystemStatusResponse{Version: "0.8.1.2135"},
expectedErr: "",
wantErr: false,
},
{
name: "fetch_unauthorized",
cfg: Config{
Hostname: srv.URL,
APIKey: "bad-mock-key",
BasicAuth: false,
Username: "",
Password: "",
},
want: nil,
wantErr: true,
expectedErr: "unauthorized: bad credentials",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
c := New(tt.cfg)
got, err := c.Test(context.Background())
if tt.wantErr && assert.Error(t, err) {
assert.EqualErrorf(t, err, tt.expectedErr, "Error should be: %v, got: %v", tt.wantErr, err)
}
assert.Equal(t, tt.want, got)
})
}
}

39
pkg/arr/lidarr/testdata/release_push_response.json vendored Normal file
View file

@ -0,0 +1,39 @@
{
"guid": "PUSH-https://localhost/test/download.torrent",
"quality": {
"quality": {
"id": 6,
"name": "FLAC"
},
"revision": {
"version": 1,
"real": 0,
"isRepack": false
}
},
"qualityWeight": 1,
"age": 1301,
"ageHours": 31240.51104018011,
"ageMinutes": 1874430.6624115533,
"size": 0,
"indexerId": 0,
"indexer": "test",
"releaseHash": "",
"title": "JR Get Money - Nobody But You [2008] [Single] - FLAC / Lossless / Log / 100% / Cue / CD",
"discography": false,
"sceneSource": false,
"artistName": "JR Get Money",
"albumTitle": "Nobody But You",
"approved": false,
"temporarilyRejected": false,
"rejected": true,
"rejections": [
"Unknown Artist"
],
"publishDate": "2018-01-28T07:00:00Z",
"downloadUrl": "https://localhost/test/download.torrent",
"downloadAllowed": false,
"releaseWeight": 0,
"preferredWordScore": 0,
"protocol": "torrent"
}

28
pkg/arr/lidarr/testdata/system_status_response.json vendored Normal file
View file

@ -0,0 +1,28 @@
{
"version": "0.8.1.2135",
"buildTime": "2021-04-18T15:43:22Z",
"isDebug": false,
"isProduction": true,
"isAdmin": false,
"isUserInteractive": false,
"startupPath": "/opt/Lidarr",
"appData": "/home/test/.config/Lidarr",
"osName": "debian",
"osVersion": "10",
"isNetCore": true,
"isMono": false,
"isLinux": true,
"isOsx": false,
"isWindows": false,
"isDocker": false,
"mode": "console",
"branch": "master",
"authentication": "none",
"sqliteVersion": "3.27.2",
"migrationVersion": 45,
"urlBase": "/lidarr",
"runtimeVersion": "3.1.13",
"runtimeName": "netCore",
"startTime": "2021-08-21T23:18:16.4948193Z",
"packageUpdateMechanism": "builtIn"
}

150
pkg/arr/lidarr/types.go Normal file
View file

@ -0,0 +1,150 @@
package lidarr
import (
"fmt"
"time"
"github.com/autobrr/autobrr/pkg/arr"
)
type Release struct {
Title string `json:"title"`
InfoUrl string `json:"infoUrl,omitempty"`
DownloadUrl string `json:"downloadUrl,omitempty"`
MagnetUrl string `json:"magnetUrl,omitempty"`
Size uint64 `json:"size"`
Indexer string `json:"indexer"`
DownloadProtocol string `json:"downloadProtocol"`
Protocol string `json:"protocol"`
PublishDate string `json:"publishDate"`
DownloadClientId int `json:"downloadClientId,omitempty"`
DownloadClient string `json:"downloadClient,omitempty"`
}
type PushResponse struct {
Approved bool `json:"approved"`
Rejected bool `json:"rejected"`
TempRejected bool `json:"temporarilyRejected"`
Rejections []string `json:"rejections"`
}
type BadRequestResponse struct {
PropertyName string `json:"propertyName"`
ErrorMessage string `json:"errorMessage"`
ErrorCode string `json:"errorCode"`
AttemptedValue string `json:"attemptedValue"`
Severity string `json:"severity"`
}
func (r BadRequestResponse) String() string {
return fmt.Sprintf("[%s: %s] %s: %s - got value: %s", r.Severity, r.ErrorCode, r.PropertyName, r.ErrorMessage, r.AttemptedValue)
}
type SystemStatusResponse struct {
Version string `json:"version"`
}
type Statistics struct {
AlbumCount int `json:"albumCount,omitempty"`
TrackFileCount int `json:"trackFileCount"`
TrackCount int `json:"trackCount"`
TotalTrackCount int `json:"totalTrackCount"`
SizeOnDisk int `json:"sizeOnDisk"`
PercentOfTracks float64 `json:"percentOfTracks"`
}
type Artist struct {
ID int64 `json:"id"`
Status string `json:"status,omitempty"`
LastInfoSync time.Time `json:"lastInfoSync,omitempty"`
ArtistName string `json:"artistName,omitempty"`
ForeignArtistID string `json:"foreignArtistId,omitempty"`
TadbID int64 `json:"tadbId,omitempty"`
DiscogsID int64 `json:"discogsId,omitempty"`
QualityProfileID int64 `json:"qualityProfileId,omitempty"`
MetadataProfileID int64 `json:"metadataProfileId,omitempty"`
Overview string `json:"overview,omitempty"`
ArtistType string `json:"artistType,omitempty"`
Disambiguation string `json:"disambiguation,omitempty"`
RootFolderPath string `json:"rootFolderPath,omitempty"`
Path string `json:"path,omitempty"`
CleanName string `json:"cleanName,omitempty"`
SortName string `json:"sortName,omitempty"`
Links []*arr.Link `json:"links,omitempty"`
Images []*arr.Image `json:"images,omitempty"`
Genres []string `json:"genres,omitempty"`
Tags []int `json:"tags,omitempty"`
Added time.Time `json:"added,omitempty"`
Ratings *arr.Ratings `json:"ratings,omitempty"`
Statistics *Statistics `json:"statistics,omitempty"`
LastAlbum *Album `json:"lastAlbum,omitempty"`
NextAlbum *Album `json:"nextAlbum,omitempty"`
AddOptions *ArtistAddOptions `json:"addOptions,omitempty"`
AlbumFolder bool `json:"albumFolder,omitempty"`
Monitored bool `json:"monitored"`
Ended bool `json:"ended,omitempty"`
}
type Album struct {
ID int64 `json:"id,omitempty"`
Title string `json:"title"`
Disambiguation string `json:"disambiguation"`
Overview string `json:"overview"`
ArtistID int64 `json:"artistId"`
ForeignAlbumID string `json:"foreignAlbumId"`
ProfileID int64 `json:"profileId"`
Duration int `json:"duration"`
AlbumType string `json:"albumType"`
SecondaryTypes []interface{} `json:"secondaryTypes"`
MediumCount int `json:"mediumCount"`
Ratings *arr.Ratings `json:"ratings"`
ReleaseDate time.Time `json:"releaseDate"`
Releases []*AlbumRelease `json:"releases"`
Genres []interface{} `json:"genres"`
Media []*Media `json:"media"`
Artist *Artist `json:"artist"`
Links []*arr.Link `json:"links"`
Images []*arr.Image `json:"images"`
Statistics *Statistics `json:"statistics"`
RemoteCover string `json:"remoteCover,omitempty"`
AddOptions *AlbumAddOptions `json:"addOptions,omitempty"`
Monitored bool `json:"monitored"`
AnyReleaseOk bool `json:"anyReleaseOk"`
Grabbed bool `json:"grabbed"`
}
// Release is part of an Album.
type AlbumRelease struct {
ID int64 `json:"id"`
AlbumID int64 `json:"albumId"`
ForeignReleaseID string `json:"foreignReleaseId"`
Title string `json:"title"`
Status string `json:"status"`
Duration int `json:"duration"`
TrackCount int `json:"trackCount"`
Media []*Media `json:"media"`
MediumCount int `json:"mediumCount"`
Disambiguation string `json:"disambiguation"`
Country []string `json:"country"`
Label []string `json:"label"`
Format string `json:"format"`
Monitored bool `json:"monitored"`
}
// Media is part of an Album.
type Media struct {
MediumNumber int64 `json:"mediumNumber"`
MediumName string `json:"mediumName"`
MediumFormat string `json:"mediumFormat"`
}
// ArtistAddOptions is part of an artist and an album.
type ArtistAddOptions struct {
Monitor string `json:"monitor,omitempty"`
Monitored bool `json:"monitored,omitempty"`
SearchForMissingAlbums bool `json:"searchForMissingAlbums,omitempty"`
}
type AlbumAddOptions struct {
SearchForNewAlbum bool `json:"searchForNewAlbum,omitempty"`
}

200
pkg/arr/radarr/client.go Normal file
View file

@ -0,0 +1,200 @@
// Copyright (c) 2021 - 2024, Ludvig Lundgren and the autobrr contributors.
// SPDX-License-Identifier: GPL-2.0-or-later
package radarr
import (
"bytes"
"context"
"encoding/json"
"io"
"net/http"
"net/url"
"path"
"github.com/autobrr/autobrr/pkg/errors"
)
func (c *Client) get(ctx context.Context, endpoint string) (int, []byte, error) {
u, err := url.Parse(c.config.Hostname)
if err != nil {
return 0, nil, errors.Wrap(err, "could not parse url: %s", c.config.Hostname)
}
u.Path = path.Join(u.Path, "/api/v3/", endpoint)
reqUrl := u.String()
req, err := http.NewRequestWithContext(ctx, http.MethodGet, reqUrl, http.NoBody)
if err != nil {
return 0, nil, errors.Wrap(err, "could not build request: %v", reqUrl)
}
if c.config.BasicAuth {
req.SetBasicAuth(c.config.Username, c.config.Password)
}
c.setHeaders(req)
resp, err := c.http.Do(req)
if err != nil {
return 0, nil, errors.Wrap(err, "radarr.http.Do(req): %v", reqUrl)
}
defer resp.Body.Close()
if resp.Body == nil {
return resp.StatusCode, nil, errors.New("response body is nil")
}
var buf bytes.Buffer
if _, err = io.Copy(&buf, resp.Body); err != nil {
return resp.StatusCode, nil, errors.Wrap(err, "radarr.io.Copy")
}
return resp.StatusCode, buf.Bytes(), nil
}
func (c *Client) getJSON(ctx context.Context, endpoint string, params url.Values, data any) error {
u, err := url.Parse(c.config.Hostname)
if err != nil {
return errors.Wrap(err, "could not parse url: %s", c.config.Hostname)
}
u.Path = path.Join(u.Path, "/api/v3/", endpoint)
reqUrl := u.String()
req, err := http.NewRequestWithContext(ctx, http.MethodGet, reqUrl, http.NoBody)
if err != nil {
return errors.Wrap(err, "could not build request")
}
if c.config.BasicAuth {
req.SetBasicAuth(c.config.Username, c.config.Password)
}
c.setHeaders(req)
req.URL.RawQuery = params.Encode()
resp, err := c.http.Do(req)
if err != nil {
return errors.Wrap(err, "radarr.http.Do(req): %+v", req)
}
defer resp.Body.Close()
if resp.Body == nil {
return errors.New("response body is nil")
}
if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
return errors.Wrap(err, "could not unmarshal data")
}
return nil
}
func (c *Client) post(ctx context.Context, endpoint string, data interface{}) (*http.Response, error) {
u, err := url.Parse(c.config.Hostname)
if err != nil {
return nil, errors.Wrap(err, "could not parse url: %s", c.config.Hostname)
}
u.Path = path.Join(u.Path, "/api/v3/", endpoint)
reqUrl := u.String()
jsonData, err := json.Marshal(data)
if err != nil {
return nil, errors.Wrap(err, "could not marshal data: %+v", data)
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, reqUrl, bytes.NewBuffer(jsonData))
if err != nil {
return nil, errors.Wrap(err, "could not build request: %v", reqUrl)
}
if c.config.BasicAuth {
req.SetBasicAuth(c.config.Username, c.config.Password)
}
req.Header.Add("X-Api-Key", c.config.APIKey)
req.Header.Set("Content-Type", "application/json; charset=UTF-8")
req.Header.Set("User-Agent", "autobrr")
res, err := c.http.Do(req)
if err != nil {
return res, errors.Wrap(err, "could not make request: %+v", req)
}
// validate response
if res.StatusCode == http.StatusUnauthorized {
return res, errors.New("unauthorized: bad credentials")
} else if res.StatusCode == http.StatusBadRequest {
return res, errors.New("radarr: bad request")
} else if res.StatusCode != http.StatusOK {
return res, errors.New("radarr: bad request")
}
// return raw response and let the caller handle json unmarshal of body
return res, nil
}
func (c *Client) postBody(ctx context.Context, endpoint string, data interface{}) (int, []byte, error) {
u, err := url.Parse(c.config.Hostname)
if err != nil {
return 0, nil, errors.Wrap(err, "could not parse url: %s", c.config.Hostname)
}
u.Path = path.Join(u.Path, "/api/v3/", endpoint)
reqUrl := u.String()
jsonData, err := json.Marshal(data)
if err != nil {
return 0, nil, errors.Wrap(err, "could not marshal data: %+v", data)
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, reqUrl, bytes.NewBuffer(jsonData))
if err != nil {
return 0, nil, errors.Wrap(err, "could not build request: %v", reqUrl)
}
if c.config.BasicAuth {
req.SetBasicAuth(c.config.Username, c.config.Password)
}
c.setHeaders(req)
resp, err := c.http.Do(req)
if err != nil {
return 0, nil, errors.Wrap(err, "radarr.http.Do(req): %+v", req)
}
defer resp.Body.Close()
if resp.Body == nil {
return resp.StatusCode, nil, errors.New("response body is nil")
}
var buf bytes.Buffer
if _, err = io.Copy(&buf, resp.Body); err != nil {
return resp.StatusCode, nil, errors.Wrap(err, "radarr.io.Copy")
}
if resp.StatusCode == http.StatusBadRequest {
return resp.StatusCode, buf.Bytes(), nil
} else if resp.StatusCode < 200 || resp.StatusCode > 401 {
return resp.StatusCode, buf.Bytes(), errors.New("radarr: bad request: %v (status: %s): %s", resp.Request.RequestURI, resp.Status, buf.String())
}
return resp.StatusCode, buf.Bytes(), nil
}
func (c *Client) setHeaders(req *http.Request) {
if req.Body != nil {
req.Header.Set("Content-Type", "application/json")
}
req.Header.Set("User-Agent", "autobrr")
req.Header.Set("X-Api-Key", c.config.APIKey)
}

147
pkg/arr/radarr/radarr.go Normal file
View file

@ -0,0 +1,147 @@
// Copyright (c) 2021 - 2024, Ludvig Lundgren and the autobrr contributors.
// SPDX-License-Identifier: GPL-2.0-or-later
package radarr
import (
"context"
"encoding/json"
"io"
"log"
"net/http"
"net/url"
"strconv"
"strings"
"time"
"github.com/autobrr/autobrr/pkg/arr"
"github.com/autobrr/autobrr/pkg/errors"
"github.com/autobrr/autobrr/pkg/sharedhttp"
)
type Config struct {
Hostname string
APIKey string
// basic auth username and password
BasicAuth bool
Username string
Password string
Log *log.Logger
}
type ClientInterface interface {
Test(ctx context.Context) (*SystemStatusResponse, error)
Push(ctx context.Context, release Release) ([]string, error)
}
type Client struct {
config Config
http *http.Client
Log *log.Logger
}
func New(config Config) *Client {
httpClient := &http.Client{
Timeout: time.Second * 120,
Transport: sharedhttp.Transport,
}
c := &Client{
config: config,
http: httpClient,
Log: log.New(io.Discard, "", log.LstdFlags),
}
if config.Log != nil {
c.Log = config.Log
}
return c
}
func (c *Client) Test(ctx context.Context) (*SystemStatusResponse, error) {
status, res, err := c.get(ctx, "system/status")
if err != nil {
return nil, errors.Wrap(err, "radarr error running test")
}
if status == http.StatusUnauthorized {
return nil, errors.New("unauthorized: bad credentials")
}
response := SystemStatusResponse{}
if err = json.Unmarshal(res, &response); err != nil {
return nil, errors.Wrap(err, "could not unmarshal data")
}
c.Log.Printf("radarr system/status status: (%v) response: %v\n", status, string(res))
return &response, nil
}
func (c *Client) Push(ctx context.Context, release Release) ([]string, error) {
status, res, err := c.postBody(ctx, "release/push", release)
if err != nil {
return nil, errors.Wrap(err, "error push release")
}
c.Log.Printf("radarr release/push status: (%v) response: %v\n", status, string(res))
if status == http.StatusBadRequest {
badRequestResponses := make([]*BadRequestResponse, 0)
if err = json.Unmarshal(res, &badRequestResponses); err != nil {
return nil, errors.Wrap(err, "could not unmarshal data")
}
rejections := []string{}
for _, response := range badRequestResponses {
rejections = append(rejections, response.String())
}
return rejections, nil
}
pushResponse := make([]PushResponse, 0)
if err = json.Unmarshal(res, &pushResponse); err != nil {
return nil, errors.Wrap(err, "could not unmarshal data")
}
// log and return if rejected
if pushResponse[0].Rejected {
rejections := strings.Join(pushResponse[0].Rejections, ", ")
c.Log.Printf("radarr release/push rejected %v reasons: %q\n", release.Title, rejections)
return pushResponse[0].Rejections, nil
}
// success true
return nil, nil
}
func (c *Client) GetMovies(ctx context.Context, tmdbID int64) ([]Movie, error) {
params := make(url.Values)
if tmdbID != 0 {
params.Set("tmdbId", strconv.FormatInt(tmdbID, 10))
}
data := make([]Movie, 0)
err := c.getJSON(ctx, "movie", params, &data)
if err != nil {
return nil, errors.Wrap(err, "could not get tags")
}
return data, nil
}
func (c *Client) GetTags(ctx context.Context) ([]*arr.Tag, error) {
data := make([]*arr.Tag, 0)
err := c.getJSON(ctx, "tag", nil, &data)
if err != nil {
return nil, errors.Wrap(err, "could not get tags")
}
return data, nil
}

239
pkg/arr/radarr/radarr_test.go Normal file
View file

@ -0,0 +1,239 @@
// Copyright (c) 2021 - 2024, Ludvig Lundgren and the autobrr contributors.
// SPDX-License-Identifier: GPL-2.0-or-later
//go:build integration
package radarr
import (
"context"
"io"
"net/http"
"net/http/httptest"
"os"
"strings"
"testing"
"github.com/rs/zerolog"
"github.com/stretchr/testify/assert"
)
func Test_client_Push(t *testing.T) {
// disable logger
zerolog.SetGlobalLevel(zerolog.Disabled)
mux := http.NewServeMux()
ts := httptest.NewServer(mux)
defer ts.Close()
key := "mock-key"
mux.HandleFunc("/api/v3/release/push", func(w http.ResponseWriter, r *http.Request) {
// request validation logic
apiKey := r.Header.Get("X-Api-Key")
if apiKey != "" {
if apiKey != key {
w.WriteHeader(http.StatusUnauthorized)
w.Write(nil)
return
}
}
defer r.Body.Close()
data, err := io.ReadAll(r.Body)
if err != nil {
t.Errorf("expected error to be nil got %v", err)
}
if strings.Contains(string(data), "Minx 1 epi 9 2160p") {
jsonPayload, _ := os.ReadFile("testdata/release_push_parse_error.json")
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusBadRequest)
w.Write(jsonPayload)
return
}
// read json response
jsonPayload, _ := os.ReadFile("testdata/release_push_response.json")
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
w.Write(jsonPayload)
})
type fields struct {
config Config
}
type args struct {
release Release
}
tests := []struct {
name string
fields fields
args args
rejections []string
err error
wantErr bool
}{
{
name: "push",
fields: fields{
config: Config{
Hostname: ts.URL,
APIKey: "",
BasicAuth: false,
Username: "",
Password: "",
},
},
args: args{release: Release{
Title: "Some.Old.Movie.1996.Remastered.1080p.BluRay.REMUX.AVC.MULTI.TrueHD.Atmos.7.1-NOGROUP",
DownloadUrl: "https://www.test.org/rss/download/0000001/00000000000000000000/Some.Old.Movie.1996.Remastered.1080p.BluRay.REMUX.AVC.MULTI.TrueHD.Atmos.7.1-NOGROUP.torrent",
Size: 0,
Indexer: "test",
DownloadProtocol: "torrent",
Protocol: "torrent",
PublishDate: "2021-08-21T15:36:00Z",
}},
rejections: []string{"Could not find Some Old Movie"},
},
{
name: "push_error",
fields: fields{
config: Config{
Hostname: ts.URL,
APIKey: key,
BasicAuth: false,
Username: "",
Password: "",
},
},
args: args{release: Release{
Title: "Some.Old.Movie.1996.Remastered.1080p.BluRay.REMUX.AVC.MULTI.TrueHD.Atmos.7.1-NOGROUP",
DownloadUrl: "https://www.test.org/rss/download/0000001/00000000000000000000/Some.Old.Movie.1996.Remastered.1080p.BluRay.REMUX.AVC.MULTI.TrueHD.Atmos.7.1-NOGROUP.torrent",
Size: 0,
Indexer: "test",
DownloadProtocol: "torrent",
Protocol: "torrent",
PublishDate: "2021-08-21T15:36:00Z",
}},
rejections: []string{"Could not find Some Old Movie"},
},
{
name: "push_parse_error",
fields: fields{
config: Config{
Hostname: ts.URL,
APIKey: key,
BasicAuth: false,
Username: "",
Password: "",
},
},
args: args{release: Release{
Title: "Minx 1 epi 9 2160p",
DownloadUrl: "https://www.test.org/rss/download/0000001/00000000000000000000/Minx.1.epi.9.2160p.torrent",
Size: 0,
Indexer: "test",
DownloadProtocol: "torrent",
Protocol: "torrent",
PublishDate: "2021-08-21T15:36:00Z",
}},
rejections: []string{"[error: ] Title: Unable to parse - got value: Minx 1 epi 9 2160p"},
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
c := New(tt.fields.config)
rejections, err := c.Push(context.Background(), tt.args.release)
assert.Equal(t, tt.rejections, rejections)
if tt.wantErr && assert.Error(t, err) {
assert.Equal(t, tt.err, err)
}
})
}
}
func Test_client_Test(t *testing.T) {
// disable logger
zerolog.SetGlobalLevel(zerolog.Disabled)
key := "mock-key"
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
apiKey := r.Header.Get("X-Api-Key")
if apiKey != "" {
if apiKey != key {
w.WriteHeader(http.StatusUnauthorized)
w.Write(nil)
return
}
}
jsonPayload, _ := os.ReadFile("testdata/system_status_response.json")
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
w.Write(jsonPayload)
}))
defer srv.Close()
tests := []struct {
name string
cfg Config
want *SystemStatusResponse
expectedErr string
wantErr bool
}{
{
name: "fetch",
cfg: Config{
Hostname: srv.URL,
APIKey: key,
BasicAuth: false,
Username: "",
Password: "",
},
want: &SystemStatusResponse{Version: "3.2.2.5080"},
expectedErr: "",
wantErr: false,
},
{
name: "fetch_unauthorized",
cfg: Config{
Hostname: srv.URL,
APIKey: "bad-mock-key",
BasicAuth: false,
Username: "",
Password: "",
},
want: nil,
wantErr: true,
expectedErr: "unauthorized: bad credentials",
},
{
name: "fetch_subfolder",
cfg: Config{
Hostname: srv.URL + "/radarr",
APIKey: key,
BasicAuth: false,
Username: "",
Password: "",
},
want: &SystemStatusResponse{Version: "3.2.2.5080"},
expectedErr: "",
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
c := New(tt.cfg)
got, err := c.Test(context.Background())
if tt.wantErr && assert.Error(t, err) {
assert.EqualErrorf(t, err, tt.expectedErr, "Error should be: %v, got: %v", tt.wantErr, err)
}
assert.Equal(t, tt.want, got)
})
}
}

8
pkg/arr/radarr/testdata/release_push_parse_error.json vendored Normal file
View file

@ -0,0 +1,8 @@
[
{
"propertyName": "Title",
"errorMessage": "Unable to parse",
"attemptedValue": "Minx 1 epi 9 2160p",
"severity": "error"
}
]

54
pkg/arr/radarr/testdata/release_push_response.json vendored Normal file
View file

@ -0,0 +1,54 @@
[
{
"guid": "PUSH-https://www.test.org/rss/download/0000001/00000000000000000000/Some.Old.Movie.1996.Remastered.1080p.BluRay.REMUX.AVC.MULTI.TrueHD.Atmos.7.1-NOGROUP.torrent",
"quality": {
"quality": {
"id": 30,
"name": "Remux-1080p",
"source": "bluray",
"resolution": 1080,
"modifier": "remux"
},
"revision": {
"version": 1,
"real": 0,
"isRepack": false
}
},
"customFormats": [],
"customFormatScore": 0,
"qualityWeight": 1901,
"age": 0,
"ageHours": 0.028290299305555554,
"ageMinutes": 1.69741874,
"size": 0,
"indexerId": 0,
"indexer": "test",
"releaseGroup": "NOGROUP",
"releaseHash": "",
"title": "Some.Old.Movie.1996.Remastered.1080p.BluRay.REMUX.AVC.MULTI.TrueHD.Atmos.7.1-NOGROUP",
"sceneSource": false,
"movieTitle": "Twister",
"languages": [
{
"id": 1,
"name": "English"
}
],
"approved": false,
"temporarilyRejected": false,
"rejected": true,
"tmdbId": 0,
"imdbId": 0,
"rejections": [
"Could not find Some Old Movie"
],
"publishDate": "2021-08-21T15:36:00Z",
"downloadUrl": "https://www.test.org/rss/download/0000001/00000000000000000000/Some.Old.Movie.1996.Remastered.1080p.BluRay.REMUX.AVC.MULTI.TrueHD.Atmos.7.1-NOGROUP.torrent",
"downloadAllowed": false,
"releaseWeight": 0,
"indexerFlags": [],
"edition": "Remastered",
"protocol": "torrent"
}
]

28
pkg/arr/radarr/testdata/system_status_response.json vendored Normal file
View file

@ -0,0 +1,28 @@
{
"version": "3.2.2.5080",
"buildTime": "2021-06-03T11:51:33Z",
"isDebug": false,
"isProduction": true,
"isAdmin": false,
"isUserInteractive": true,
"startupPath": "/opt/Radarr",
"appData": "/home/test/.config/Radarr",
"osName": "debian",
"osVersion": "10",
"isNetCore": true,
"isMono": false,
"isLinux": true,
"isOsx": false,
"isWindows": false,
"isDocker": false,
"mode": "console",
"branch": "master",
"authentication": "none",
"sqliteVersion": "3.27.2",
"migrationVersion": 195,
"urlBase": "/radarr",
"runtimeVersion": "5.0.5",
"runtimeName": "netCore",
"startTime": "2021-08-20T20:49:42Z",
"packageUpdateMechanism": "builtIn"
}

135
pkg/arr/radarr/types.go Normal file
View file

@ -0,0 +1,135 @@
package radarr
import (
"fmt"
"time"
"github.com/autobrr/autobrr/pkg/arr"
)
type Movie struct {
ID int64 `json:"id"`
Title string `json:"title,omitempty"`
Path string `json:"path,omitempty"`
MinimumAvailability string `json:"minimumAvailability,omitempty"`
QualityProfileID int64 `json:"qualityProfileId,omitempty"`
TmdbID int64 `json:"tmdbId,omitempty"`
OriginalTitle string `json:"originalTitle,omitempty"`
AlternateTitles []*AlternativeTitle `json:"alternateTitles,omitempty"`
SecondaryYearSourceID int `json:"secondaryYearSourceId,omitempty"`
SortTitle string `json:"sortTitle,omitempty"`
SizeOnDisk int64 `json:"sizeOnDisk,omitempty"`
Status string `json:"status,omitempty"`
Overview string `json:"overview,omitempty"`
InCinemas time.Time `json:"inCinemas,omitempty"`
PhysicalRelease time.Time `json:"physicalRelease,omitempty"`
DigitalRelease time.Time `json:"digitalRelease,omitempty"`
Images []*arr.Image `json:"images,omitempty"`
Website string `json:"website,omitempty"`
Year int `json:"year,omitempty"`
YouTubeTrailerID string `json:"youTubeTrailerId,omitempty"`
Studio string `json:"studio,omitempty"`
FolderName string `json:"folderName,omitempty"`
Runtime int `json:"runtime,omitempty"`
CleanTitle string `json:"cleanTitle,omitempty"`
ImdbID string `json:"imdbId,omitempty"`
TitleSlug string `json:"titleSlug,omitempty"`
Certification string `json:"certification,omitempty"`
Genres []string `json:"genres,omitempty"`
Tags []int `json:"tags,omitempty"`
Added time.Time `json:"added,omitempty"`
Ratings *arr.Ratings `json:"ratings,omitempty"`
MovieFile *MovieFile `json:"movieFile,omitempty"`
Collection *Collection `json:"collection,omitempty"`
HasFile bool `json:"hasFile,omitempty"`
IsAvailable bool `json:"isAvailable,omitempty"`
Monitored bool `json:"monitored"`
}
type AlternativeTitle struct {
MovieID int `json:"movieId"`
Title string `json:"title"`
SourceType string `json:"sourceType"`
SourceID int `json:"sourceId"`
Votes int `json:"votes"`
VoteCount int `json:"voteCount"`
Language *arr.Value `json:"language"`
ID int `json:"id"`
}
type MovieFile struct {
ID int64 `json:"id"`
MovieID int64 `json:"movieId"`
RelativePath string `json:"relativePath"`
Path string `json:"path"`
Size int64 `json:"size"`
DateAdded time.Time `json:"dateAdded"`
SceneName string `json:"sceneName"`
IndexerFlags int64 `json:"indexerFlags"`
Quality *arr.Quality `json:"quality"`
MediaInfo *MediaInfo `json:"mediaInfo"`
QualityCutoffNotMet bool `json:"qualityCutoffNotMet"`
Languages []*arr.Value `json:"languages"`
ReleaseGroup string `json:"releaseGroup"`
Edition string `json:"edition"`
}
type MediaInfo struct {
AudioAdditionalFeatures string `json:"audioAdditionalFeatures"`
AudioBitrate int `json:"audioBitrate"`
AudioChannels float64 `json:"audioChannels"`
AudioCodec string `json:"audioCodec"`
AudioLanguages string `json:"audioLanguages"`
AudioStreamCount int `json:"audioStreamCount"`
VideoBitDepth int `json:"videoBitDepth"`
VideoBitrate int `json:"videoBitrate"`
VideoCodec string `json:"videoCodec"`
VideoFps float64 `json:"videoFps"`
Resolution string `json:"resolution"`
RunTime string `json:"runTime"`
ScanType string `json:"scanType"`
Subtitles string `json:"subtitles"`
}
type Collection struct {
Name string `json:"name"`
TmdbID int64 `json:"tmdbId"`
Images []*arr.Image `json:"images"`
}
type Release struct {
Title string `json:"title"`
InfoUrl string `json:"infoUrl,omitempty"`
DownloadUrl string `json:"downloadUrl,omitempty"`
MagnetUrl string `json:"magnetUrl,omitempty"`
Size uint64 `json:"size"`
Indexer string `json:"indexer"`
DownloadProtocol string `json:"downloadProtocol"`
Protocol string `json:"protocol"`
PublishDate string `json:"publishDate"`
DownloadClientId int `json:"downloadClientId,omitempty"`
DownloadClient string `json:"downloadClient,omitempty"`
}
type PushResponse struct {
Approved bool `json:"approved"`
Rejected bool `json:"rejected"`
TempRejected bool `json:"temporarilyRejected"`
Rejections []string `json:"rejections"`
}
type SystemStatusResponse struct {
Version string `json:"version"`
}
type BadRequestResponse struct {
Severity string `json:"severity"`
ErrorCode string `json:"errorCode"`
ErrorMessage string `json:"errorMessage"`
PropertyName string `json:"propertyName"`
AttemptedValue string `json:"attemptedValue"`
}
func (r *BadRequestResponse) String() string {
return fmt.Sprintf("[%s: %s] %s: %s - got value: %s", r.Severity, r.ErrorCode, r.PropertyName, r.ErrorMessage, r.AttemptedValue)
}

200
pkg/arr/readarr/client.go Normal file
View file

@ -0,0 +1,200 @@
// Copyright (c) 2021 - 2024, Ludvig Lundgren and the autobrr contributors.
// SPDX-License-Identifier: GPL-2.0-or-later
package readarr
import (
"bytes"
"context"
"encoding/json"
"io"
"net/http"
"net/url"
"path"
"github.com/autobrr/autobrr/pkg/errors"
)
func (c *Client) get(ctx context.Context, endpoint string) (int, []byte, error) {
u, err := url.Parse(c.config.Hostname)
if err != nil {
return 0, nil, errors.Wrap(err, "could not parse url: %s", c.config.Hostname)
}
u.Path = path.Join(u.Path, "/api/v1/", endpoint)
reqUrl := u.String()
req, err := http.NewRequestWithContext(ctx, http.MethodGet, reqUrl, http.NoBody)
if err != nil {
return 0, nil, errors.Wrap(err, "could not build request")
}
if c.config.BasicAuth {
req.SetBasicAuth(c.config.Username, c.config.Password)
}
c.setHeaders(req)
resp, err := c.http.Do(req)
if err != nil {
return 0, nil, errors.Wrap(err, "readarr.http.Do(req): %+v", req)
}
defer resp.Body.Close()
if resp.Body == nil {
return resp.StatusCode, nil, errors.New("response body is nil")
}
var buf bytes.Buffer
if _, err = io.Copy(&buf, resp.Body); err != nil {
return resp.StatusCode, nil, errors.Wrap(err, "readarr.io.Copy")
}
return resp.StatusCode, buf.Bytes(), nil
}
func (c *Client) getJSON(ctx context.Context, endpoint string, params url.Values, data any) error {
u, err := url.Parse(c.config.Hostname)
if err != nil {
return errors.Wrap(err, "could not parse url: %s", c.config.Hostname)
}
u.Path = path.Join(u.Path, "/api/v1/", endpoint)
reqUrl := u.String()
req, err := http.NewRequestWithContext(ctx, http.MethodGet, reqUrl, http.NoBody)
if err != nil {
return errors.Wrap(err, "could not build request")
}
if c.config.BasicAuth {
req.SetBasicAuth(c.config.Username, c.config.Password)
}
c.setHeaders(req)
req.URL.RawQuery = params.Encode()
resp, err := c.http.Do(req)
if err != nil {
return errors.Wrap(err, "readarr.http.Do(req): %+v", req)
}
defer resp.Body.Close()
if resp.Body == nil {
return errors.New("response body is nil")
}
if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
return errors.Wrap(err, "could not unmarshal data")
}
return nil
}
func (c *Client) post(ctx context.Context, endpoint string, data interface{}) (*http.Response, error) {
u, err := url.Parse(c.config.Hostname)
if err != nil {
return nil, errors.Wrap(err, "could not parse url: %s", c.config.Hostname)
}
u.Path = path.Join(u.Path, "/api/v1/", endpoint)
reqUrl := u.String()
jsonData, err := json.Marshal(data)
if err != nil {
return nil, errors.Wrap(err, "could not marshal data: %+v", data)
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, reqUrl, bytes.NewBuffer(jsonData))
if err != nil {
return nil, errors.Wrap(err, "could not build request")
}
if c.config.BasicAuth {
req.SetBasicAuth(c.config.Username, c.config.Password)
}
req.Header.Add("X-Api-Key", c.config.APIKey)
req.Header.Set("Content-Type", "application/json; charset=UTF-8")
req.Header.Set("User-Agent", "autobrr")
res, err := c.http.Do(req)
if err != nil {
return nil, errors.Wrap(err, "could not make request: %+v", req)
}
// validate response
if res.StatusCode == http.StatusUnauthorized {
return res, errors.New("unauthorized: bad credentials")
} else if res.StatusCode != http.StatusOK {
return res, errors.New("readarr: bad request")
}
// return raw response and let the caller handle json unmarshal of body
return res, nil
}
func (c *Client) postBody(ctx context.Context, endpoint string, data interface{}) (int, []byte, error) {
u, err := url.Parse(c.config.Hostname)
if err != nil {
return 0, nil, errors.Wrap(err, "could not parse url: %s", c.config.Hostname)
}
u.Path = path.Join(u.Path, "/api/v1/", endpoint)
reqUrl := u.String()
jsonData, err := json.Marshal(data)
if err != nil {
return 0, nil, errors.Wrap(err, "could not marshal data: %+v", data)
}
c.Log.Printf("readarr push JSON: %s\n", string(jsonData))
req, err := http.NewRequestWithContext(ctx, http.MethodPost, reqUrl, bytes.NewBuffer(jsonData))
if err != nil {
return 0, nil, errors.Wrap(err, "could not build request")
}
if c.config.BasicAuth {
req.SetBasicAuth(c.config.Username, c.config.Password)
}
c.setHeaders(req)
resp, err := c.http.Do(req)
if err != nil {
return 0, nil, errors.Wrap(err, "readarr.http.Do(req): %+v", req)
}
defer resp.Body.Close()
if resp.Body == nil {
return resp.StatusCode, nil, errors.New("response body is nil")
}
var buf bytes.Buffer
if _, err = io.Copy(&buf, resp.Body); err != nil {
return resp.StatusCode, nil, errors.Wrap(err, "readarr.io.Copy")
}
if resp.StatusCode == http.StatusBadRequest {
return resp.StatusCode, buf.Bytes(), nil
} else if resp.StatusCode < 200 || resp.StatusCode > 401 {
return resp.StatusCode, buf.Bytes(), errors.New("readarr: bad request: %v (status: %s): %s", resp.Request.RequestURI, resp.Status, buf.String())
}
return resp.StatusCode, buf.Bytes(), nil
}
func (c *Client) setHeaders(req *http.Request) {
if req.Body != nil {
req.Header.Set("Content-Type", "application/json")
}
req.Header.Set("User-Agent", "autobrr")
req.Header.Set("X-Api-Key", c.config.APIKey)
}

150
pkg/arr/readarr/readarr.go Normal file
View file

@ -0,0 +1,150 @@
// Copyright (c) 2021 - 2024, Ludvig Lundgren and the autobrr contributors.
// SPDX-License-Identifier: GPL-2.0-or-later
package readarr
import (
"context"
"encoding/json"
"io"
"net/http"
"net/url"
"strings"
"time"
"log"
"github.com/autobrr/autobrr/pkg/arr"
"github.com/autobrr/autobrr/pkg/errors"
"github.com/autobrr/autobrr/pkg/sharedhttp"
)
type Config struct {
Hostname string
APIKey string
// basic auth username and password
BasicAuth bool
Username string
Password string
Log *log.Logger
}
type ClientInterface interface {
Test(ctx context.Context) (*SystemStatusResponse, error)
Push(ctx context.Context, release Release) ([]string, error)
}
type Client struct {
config Config
http *http.Client
Log *log.Logger
}
// New create new readarr Client
func New(config Config) *Client {
httpClient := &http.Client{
Timeout: time.Second * 120,
Transport: sharedhttp.Transport,
}
c := &Client{
config: config,
http: httpClient,
Log: log.New(io.Discard, "", log.LstdFlags),
}
if config.Log != nil {
c.Log = config.Log
}
return c
}
func (c *Client) Test(ctx context.Context) (*SystemStatusResponse, error) {
status, res, err := c.get(ctx, "system/status")
if err != nil {
return nil, errors.Wrap(err, "could not make Test")
}
if status == http.StatusUnauthorized {
return nil, errors.New("unauthorized: bad credentials")
}
c.Log.Printf("readarr system/status status: (%v) response: %v\n", status, string(res))
response := SystemStatusResponse{}
if err = json.Unmarshal(res, &response); err != nil {
return nil, errors.Wrap(err, "could not unmarshal data")
}
return &response, nil
}
func (c *Client) Push(ctx context.Context, release Release) ([]string, error) {
status, res, err := c.postBody(ctx, "release/push", release)
if err != nil {
return nil, errors.Wrap(err, "could not push release to readarr")
}
c.Log.Printf("readarr release/push status: (%v) response: %v\n", status, string(res))
if status == http.StatusBadRequest {
badRequestResponses := make([]*BadRequestResponse, 0)
if err = json.Unmarshal(res, &badRequestResponses); err != nil {
return nil, errors.Wrap(err, "could not unmarshal data")
}
rejections := []string{}
for _, response := range badRequestResponses {
rejections = append(rejections, response.String())
}
return rejections, nil
}
// pushResponse := make([]PushResponse, 0)
var pushResponse PushResponse
if err = json.Unmarshal(res, &pushResponse); err != nil {
return nil, errors.Wrap(err, "could not unmarshal data")
}
// log and return if rejected
if pushResponse.Rejected {
rejections := strings.Join(pushResponse.Rejections, ", ")
c.Log.Printf("readarr release/push rejected %v reasons: %q\n", release.Title, rejections)
return pushResponse.Rejections, nil
}
// successful push
return nil, nil
}
func (c *Client) GetBooks(ctx context.Context, gridID string) ([]Book, error) {
params := make(url.Values)
if gridID != "" {
params.Set("titleSlug", gridID)
}
data := make([]Book, 0)
err := c.getJSON(ctx, "book", params, &data)
if err != nil {
return nil, errors.Wrap(err, "could not get tags")
}
return data, nil
}
func (c *Client) GetTags(ctx context.Context) ([]*arr.Tag, error) {
data := make([]*arr.Tag, 0)
err := c.getJSON(ctx, "tag", nil, &data)
if err != nil {
return nil, errors.Wrap(err, "could not get tags")
}
return data, nil
}

164
pkg/arr/readarr/readarr_test.go Normal file
View file

@ -0,0 +1,164 @@
// Copyright (c) 2021 - 2024, Ludvig Lundgren and the autobrr contributors.
// SPDX-License-Identifier: GPL-2.0-or-later
//go:build integration
package readarr
import (
"context"
"net/http"
"net/http/httptest"
"os"
"testing"
"github.com/rs/zerolog"
"github.com/stretchr/testify/assert"
)
func Test_client_Push(t *testing.T) {
// disable logger
zerolog.SetGlobalLevel(zerolog.Disabled)
mux := http.NewServeMux()
ts := httptest.NewServer(mux)
defer ts.Close()
key := "mock-key"
mux.HandleFunc("/api/v1/release/push", func(w http.ResponseWriter, r *http.Request) {
// request validation logic
apiKey := r.Header.Get("X-Api-Key")
if apiKey != "" {
if apiKey != key {
w.WriteHeader(http.StatusUnauthorized)
w.Write(nil)
return
}
}
// read json response
jsonPayload, _ := os.ReadFile("testdata/release_push_ok_response.json")
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
w.Write(jsonPayload)
})
type fields struct {
config Config
}
type args struct {
release Release
}
tests := []struct {
name string
fields fields
args args
err error
rejections []string
wantErr bool
}{
{
name: "push",
fields: fields{
config: Config{
Hostname: ts.URL,
APIKey: "",
BasicAuth: false,
Username: "",
Password: "",
},
},
args: args{release: Release{
Title: "The Best Book by Famous Author [English / epub, mobi]",
DownloadUrl: "https://www.mock-indexer.test/tor/download.php?tid=000000",
Size: 1048576,
Indexer: "mock-indexer",
DownloadProtocol: "torrent",
Protocol: "torrent",
PublishDate: "2022-10-14T17:36:15Z",
}},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
c := New(tt.fields.config)
rejections, err := c.Push(context.Background(), tt.args.release)
assert.Equal(t, tt.rejections, rejections)
if tt.wantErr && assert.Error(t, err) {
assert.Equal(t, tt.err, err)
}
})
}
}
func Test_client_Test(t *testing.T) {
// disable logger
zerolog.SetGlobalLevel(zerolog.Disabled)
key := "mock-key"
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
apiKey := r.Header.Get("X-Api-Key")
if apiKey != "" {
if apiKey != key {
w.WriteHeader(http.StatusUnauthorized)
w.Write(nil)
return
}
}
jsonPayload, _ := os.ReadFile("testdata/system_status_response_ok.json")
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
w.Write(jsonPayload)
}))
defer srv.Close()
tests := []struct {
name string
cfg Config
want *SystemStatusResponse
expectedErr string
wantErr bool
}{
{
name: "fetch",
cfg: Config{
Hostname: srv.URL,
APIKey: key,
BasicAuth: false,
Username: "",
Password: "",
},
want: &SystemStatusResponse{AppName: "Readarr", Version: "0.1.1.1320"},
expectedErr: "",
wantErr: false,
},
{
name: "fetch_unauthorized",
cfg: Config{
Hostname: srv.URL,
APIKey: "bad-mock-key",
BasicAuth: false,
Username: "",
Password: "",
},
want: nil,
wantErr: true,
expectedErr: "unauthorized: bad credentials",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
c := New(tt.cfg)
got, err := c.Test(context.Background())
if tt.wantErr && assert.Error(t, err) {
assert.EqualErrorf(t, err, tt.expectedErr, "Error should be: %v, got: %v", tt.wantErr, err)
}
assert.Equal(t, tt.want, got)
})
}
}

37
pkg/arr/readarr/testdata/release_push_ok_response.json vendored Normal file
View file

@ -0,0 +1,37 @@
{
"guid": "PUSH-https://www.mock-indexer.test/tor/download.php?tid=000000",
"quality": {
"quality": {
"id": 3,
"name": "EPUB"
},
"revision": {
"version": 1,
"real": 0,
"isRepack": false
}
},
"qualityWeight": 301,
"age": 0,
"ageHours": 0.00138141025,
"ageMinutes": 0.08288463833333333,
"size": 1048576,
"indexerId": 0,
"indexer": "mock-indexer",
"releaseHash": "",
"title": "The Best Book by Famous Author [English / epub, mobi]",
"discography": false,
"sceneSource": false,
"authorName": "Famous Author",
"bookTitle": "The best book",
"approved": true,
"temporarilyRejected": false,
"rejected": false,
"rejections": [],
"publishDate": "2022-10-14T17:36:15Z",
"downloadUrl": "https://www.mock-indexer.test/tor/download.php?tid=000000",
"downloadAllowed": true,
"releaseWeight": 0,
"preferredWordScore": 0,
"protocol": "torrent"
}

31
pkg/arr/readarr/testdata/system_status_response_ok.json vendored Normal file
View file

@ -0,0 +1,31 @@
{
"appName": "Readarr",
"version": "0.1.1.1320",
"buildTime": "2022-05-09T22:53:15Z",
"isDebug": false,
"isProduction": true,
"isAdmin": false,
"isUserInteractive": true,
"startupPath": "/app/bin",
"appData": "/config",
"osName": "alpine",
"osVersion": "3.16.2",
"isNetCore": true,
"isMono": false,
"isLinux": true,
"isOsx": false,
"isWindows": false,
"isDocker": false,
"mode": "console",
"branch": "develop",
"authentication": "none",
"sqliteVersion": "3.38.5",
"migrationVersion": 21,
"urlBase": "",
"runtimeVersion": "6.0.3",
"runtimeName": "netCore",
"startTime": "2022-10-14T17:26:21Z",
"packageVersion": "testing-e06fe51",
"packageAuthor": "[hotio](https://github.com/hotio)",
"packageUpdateMechanism": "docker"
}

122
pkg/arr/readarr/types.go Normal file
View file

@ -0,0 +1,122 @@
package readarr
import (
"fmt"
"github.com/autobrr/autobrr/pkg/arr"
"time"
)
type Release struct {
Title string `json:"title"`
InfoUrl string `json:"infoUrl,omitempty"`
DownloadUrl string `json:"downloadUrl,omitempty"`
MagnetUrl string `json:"magnetUrl,omitempty"`
Size uint64 `json:"size"`
Indexer string `json:"indexer"`
DownloadProtocol string `json:"downloadProtocol"`
Protocol string `json:"protocol"`
PublishDate string `json:"publishDate"`
DownloadClientId int `json:"downloadClientId,omitempty"`
DownloadClient string `json:"downloadClient,omitempty"`
}
type PushResponse struct {
Approved bool `json:"approved"`
Rejected bool `json:"rejected"`
TempRejected bool `json:"temporarilyRejected"`
Rejections []string `json:"rejections"`
}
type BadRequestResponse struct {
PropertyName string `json:"propertyName"`
ErrorMessage string `json:"errorMessage"`
ErrorCode string `json:"errorCode"`
AttemptedValue string `json:"attemptedValue"`
Severity string `json:"severity"`
}
func (r *BadRequestResponse) String() string {
return fmt.Sprintf("[%s: %s] %s: %s - got value: %s", r.Severity, r.ErrorCode, r.PropertyName, r.ErrorMessage, r.AttemptedValue)
}
type SystemStatusResponse struct {
AppName string `json:"appName"`
Version string `json:"version"`
}
type Book struct {
Title string `json:"title"`
SeriesTitle string `json:"seriesTitle"`
Overview string `json:"overview"`
AuthorID int64 `json:"authorId"`
ForeignBookID string `json:"foreignBookId"`
TitleSlug string `json:"titleSlug"`
Monitored bool `json:"monitored"`
AnyEditionOk bool `json:"anyEditionOk"`
Ratings *arr.Ratings `json:"ratings"`
ReleaseDate time.Time `json:"releaseDate"`
PageCount int `json:"pageCount"`
Genres []interface{} `json:"genres"`
Author *BookAuthor `json:"author,omitempty"`
Images []*arr.Image `json:"images"`
Links []*arr.Link `json:"links"`
Statistics *Statistics `json:"statistics,omitempty"`
Editions []*Edition `json:"editions"`
ID int64 `json:"id"`
Disambiguation string `json:"disambiguation,omitempty"`
}
// Statistics for a Book, or maybe an author.
type Statistics struct {
BookCount int `json:"bookCount"`
BookFileCount int `json:"bookFileCount"`
TotalBookCount int `json:"totalBookCount"`
SizeOnDisk int `json:"sizeOnDisk"`
PercentOfBooks float64 `json:"percentOfBooks"`
}
// BookAuthor of a Book.
type BookAuthor struct {
ID int64 `json:"id"`
Status string `json:"status"`
AuthorName string `json:"authorName"`
ForeignAuthorID string `json:"foreignAuthorId"`
TitleSlug string `json:"titleSlug"`
Overview string `json:"overview"`
Links []*arr.Link `json:"links"`
Images []*arr.Image `json:"images"`
Path string `json:"path"`
QualityProfileID int64 `json:"qualityProfileId"`
MetadataProfileID int64 `json:"metadataProfileId"`
Genres []interface{} `json:"genres"`
CleanName string `json:"cleanName"`
SortName string `json:"sortName"`
Tags []int `json:"tags"`
Added time.Time `json:"added"`
Ratings *arr.Ratings `json:"ratings"`
Statistics *Statistics `json:"statistics"`
Monitored bool `json:"monitored"`
Ended bool `json:"ended"`
}
// Edition is more Book meta data.
type Edition struct {
ID int64 `json:"id"`
BookID int64 `json:"bookId"`
ForeignEditionID string `json:"foreignEditionId"`
TitleSlug string `json:"titleSlug"`
Isbn13 string `json:"isbn13"`
Asin string `json:"asin"`
Title string `json:"title"`
Overview string `json:"overview"`
Format string `json:"format"`
Publisher string `json:"publisher"`
PageCount int `json:"pageCount"`
ReleaseDate time.Time `json:"releaseDate"`
Images []*arr.Image `json:"images"`
Links []*arr.Link `json:"links"`
Ratings *arr.Ratings `json:"ratings"`
Monitored bool `json:"monitored"`
ManualAdd bool `json:"manualAdd"`
IsEbook bool `json:"isEbook"`
}

57
pkg/arr/shared.go Normal file
View file

@ -0,0 +1,57 @@
package arr
type Tag struct {
ID int
Label string
}
type Link struct {
URL string `json:"url"`
Name string `json:"name"`
}
type Image struct {
CoverType string `json:"coverType"`
URL string `json:"url"`
RemoteURL string `json:"remoteUrl,omitempty"`
Extension string `json:"extension,omitempty"`
}
type Ratings struct {
Votes int64 `json:"votes"`
Value float64 `json:"value"`
Popularity float64 `json:"popularity,omitempty"`
}
type Value struct {
ID int64 `json:"id"`
Name string `json:"name"`
}
// BaseQuality is a base quality profile.
type BaseQuality struct {
ID int64 `json:"id"`
Name string `json:"name"`
Source string `json:"source,omitempty"`
Resolution int `json:"resolution,omitempty"`
Modifier string `json:"modifier,omitempty"`
}
// Quality is a download quality profile attached to a movie, book, track or series.
// It may contain 1 or more profiles.
// Sonarr nor Readarr use Name or ID in this struct.
type Quality struct {
Name string `json:"name,omitempty"`
ID int `json:"id,omitempty"`
Quality *BaseQuality `json:"quality,omitempty"`
Items []*Quality `json:"items,omitempty"`
Allowed bool `json:"allowed"`
Revision *QualityRevision `json:"revision,omitempty"` // Not sure which app had this....
}
// QualityRevision is probably used in Sonarr.
type QualityRevision struct {
Version int64 `json:"version"`
Real int64 `json:"real"`
IsRepack bool `json:"isRepack,omitempty"`
}

198
pkg/arr/sonarr/client.go Normal file
View file

@ -0,0 +1,198 @@
// Copyright (c) 2021 - 2024, Ludvig Lundgren and the autobrr contributors.
// SPDX-License-Identifier: GPL-2.0-or-later
package sonarr
import (
"bytes"
"context"
"encoding/json"
"io"
"net/http"
"net/url"
"path"
"github.com/autobrr/autobrr/pkg/errors"
)
func (c *Client) get(ctx context.Context, endpoint string) (int, []byte, error) {
u, err := url.Parse(c.config.Hostname)
if err != nil {
return 0, nil, errors.Wrap(err, "could not parse url: %s", c.config.Hostname)
}
u.Path = path.Join(u.Path, "/api/v3/", endpoint)
reqUrl := u.String()
req, err := http.NewRequestWithContext(ctx, http.MethodGet, reqUrl, http.NoBody)
if err != nil {
return 0, nil, errors.Wrap(err, "could not build request")
}
if c.config.BasicAuth {
req.SetBasicAuth(c.config.Username, c.config.Password)
}
c.setHeaders(req)
resp, err := c.http.Do(req)
if err != nil {
return 0, nil, errors.Wrap(err, "sonarr.http.Do(req): %+v", req)
}
defer resp.Body.Close()
if resp.Body == nil {
return resp.StatusCode, nil, errors.New("response body is nil")
}
var buf bytes.Buffer
if _, err = io.Copy(&buf, resp.Body); err != nil {
return resp.StatusCode, nil, errors.Wrap(err, "sonarr.io.Copy")
}
return resp.StatusCode, buf.Bytes(), nil
}
func (c *Client) getJSON(ctx context.Context, endpoint string, params url.Values, data any) error {
u, err := url.Parse(c.config.Hostname)
if err != nil {
return errors.Wrap(err, "could not parse url: %s", c.config.Hostname)
}
u.Path = path.Join(u.Path, "/api/v3/", endpoint)
reqUrl := u.String()
req, err := http.NewRequestWithContext(ctx, http.MethodGet, reqUrl, http.NoBody)
if err != nil {
return errors.Wrap(err, "could not build request")
}
if c.config.BasicAuth {
req.SetBasicAuth(c.config.Username, c.config.Password)
}
c.setHeaders(req)
req.URL.RawQuery = params.Encode()
resp, err := c.http.Do(req)
if err != nil {
return errors.Wrap(err, "sonarr.http.Do(req): %+v", req)
}
defer resp.Body.Close()
if resp.Body == nil {
return errors.New("response body is nil")
}
if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
return errors.Wrap(err, "could not unmarshal data")
}
return nil
}
func (c *Client) post(ctx context.Context, endpoint string, data interface{}) (*http.Response, error) {
u, err := url.Parse(c.config.Hostname)
if err != nil {
return nil, errors.Wrap(err, "could not parse url: %s", c.config.Hostname)
}
u.Path = path.Join(u.Path, "/api/v3/", endpoint)
reqUrl := u.String()
jsonData, err := json.Marshal(data)
if err != nil {
return nil, errors.Wrap(err, "could not marshal data: %+v", data)
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, reqUrl, bytes.NewBuffer(jsonData))
if err != nil {
return nil, errors.Wrap(err, "could not build request")
}
if c.config.BasicAuth {
req.SetBasicAuth(c.config.Username, c.config.Password)
}
req.Header.Add("X-Api-Key", c.config.APIKey)
req.Header.Set("Content-Type", "application/json; charset=UTF-8")
req.Header.Set("User-Agent", "autobrr")
res, err := c.http.Do(req)
if err != nil {
return res, errors.Wrap(err, "could not make request: %+v", req)
}
// validate response
if res.StatusCode == http.StatusUnauthorized {
return res, errors.New("unauthorized: bad credentials")
} else if res.StatusCode != http.StatusOK {
return res, errors.New("sonarr: bad request")
}
// return raw response and let the caller handle json unmarshal of body
return res, nil
}
func (c *Client) postBody(ctx context.Context, endpoint string, data interface{}) (int, []byte, error) {
u, err := url.Parse(c.config.Hostname)
if err != nil {
return 0, nil, errors.Wrap(err, "could not parse url: %s", c.config.Hostname)
}
u.Path = path.Join(u.Path, "/api/v3/", endpoint)
reqUrl := u.String()
jsonData, err := json.Marshal(data)
if err != nil {
return 0, nil, errors.Wrap(err, "could not marshal data: %+v", data)
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, reqUrl, bytes.NewBuffer(jsonData))
if err != nil {
return 0, nil, errors.Wrap(err, "could not build request")
}
if c.config.BasicAuth {
req.SetBasicAuth(c.config.Username, c.config.Password)
}
c.setHeaders(req)
resp, err := c.http.Do(req)
if err != nil {
return 0, nil, errors.Wrap(err, "sonarr.http.Do(req): %+v", req)
}
defer resp.Body.Close()
if resp.Body == nil {
return resp.StatusCode, nil, errors.New("response body is nil")
}
var buf bytes.Buffer
if _, err = io.Copy(&buf, resp.Body); err != nil {
return resp.StatusCode, nil, errors.Wrap(err, "sonarr.io.Copy")
}
if resp.StatusCode == http.StatusBadRequest {
return resp.StatusCode, buf.Bytes(), nil
} else if resp.StatusCode < 200 || resp.StatusCode > 401 {
return resp.StatusCode, buf.Bytes(), errors.New("sonarr: bad request: %v (status: %s): %s", resp.Request.RequestURI, resp.Status, buf.String())
}
return resp.StatusCode, buf.Bytes(), nil
}
func (c *Client) setHeaders(req *http.Request) {
if req.Body != nil {
req.Header.Set("Content-Type", "application/json")
}
req.Header.Set("User-Agent", "autobrr")
req.Header.Set("X-Api-Key", c.config.APIKey)
}

154
pkg/arr/sonarr/sonarr.go Normal file
View file

@ -0,0 +1,154 @@
// Copyright (c) 2021 - 2024, Ludvig Lundgren and the autobrr contributors.
// SPDX-License-Identifier: GPL-2.0-or-later
package sonarr
import (
"context"
"encoding/json"
"io"
"net/http"
"net/url"
"strconv"
"strings"
"time"
"log"
"github.com/autobrr/autobrr/pkg/arr"
"github.com/autobrr/autobrr/pkg/errors"
"github.com/autobrr/autobrr/pkg/sharedhttp"
)
type Config struct {
Hostname string
APIKey string
// basic auth username and password
BasicAuth bool
Username string
Password string
Log *log.Logger
}
type ClientInterface interface {
Test(ctx context.Context) (*SystemStatusResponse, error)
Push(ctx context.Context, release Release) ([]string, error)
}
type Client struct {
config Config
http *http.Client
Log *log.Logger
}
// New create new sonarr Client
func New(config Config) *Client {
httpClient := &http.Client{
Timeout: time.Second * 120,
Transport: sharedhttp.Transport,
}
c := &Client{
config: config,
http: httpClient,
Log: log.New(io.Discard, "", log.LstdFlags),
}
if config.Log != nil {
c.Log = config.Log
}
return c
}
func (c *Client) Test(ctx context.Context) (*SystemStatusResponse, error) {
status, res, err := c.get(ctx, "system/status")
if err != nil {
return nil, errors.Wrap(err, "could not make Test")
}
if status == http.StatusUnauthorized {
return nil, errors.New("unauthorized: bad credentials")
}
c.Log.Printf("sonarr system/status status: (%v) response: %v\n", status, string(res))
response := SystemStatusResponse{}
if err = json.Unmarshal(res, &response); err != nil {
return nil, errors.Wrap(err, "could not unmarshal data")
}
return &response, nil
}
func (c *Client) Push(ctx context.Context, release Release) ([]string, error) {
status, res, err := c.postBody(ctx, "release/push", release)
if err != nil {
return nil, errors.Wrap(err, "could not push release to sonarr")
}
c.Log.Printf("sonarr release/push status: (%v) response: %v\n", status, string(res))
if status == http.StatusBadRequest {
badRequestResponses := make([]*BadRequestResponse, 0)
if err = json.Unmarshal(res, &badRequestResponses); err != nil {
return nil, errors.Wrap(err, "could not unmarshal data")
}
rejections := []string{}
for _, response := range badRequestResponses {
rejections = append(rejections, response.String())
}
return rejections, nil
}
pushResponse := make([]PushResponse, 0)
if err = json.Unmarshal(res, &pushResponse); err != nil {
return nil, errors.Wrap(err, "could not unmarshal data")
}
// log and return if rejected
if pushResponse[0].Rejected {
rejections := strings.Join(pushResponse[0].Rejections, ", ")
c.Log.Printf("sonarr release/push rejected %v reasons: %q\n", release.Title, rejections)
return pushResponse[0].Rejections, nil
}
// successful push
return nil, nil
}
func (c *Client) GetAllSeries(ctx context.Context) ([]Series, error) {
return c.GetSeries(ctx, 0)
}
func (c *Client) GetSeries(ctx context.Context, tvdbID int64) ([]Series, error) {
params := make(url.Values)
if tvdbID != 0 {
params.Set("tvdbId", strconv.FormatInt(tvdbID, 10))
}
data := make([]Series, 0)
err := c.getJSON(ctx, "series", params, &data)
if err != nil {
return nil, errors.Wrap(err, "could not get tags")
}
return data, nil
}
func (c *Client) GetTags(ctx context.Context) ([]*arr.Tag, error) {
data := make([]*arr.Tag, 0)
err := c.getJSON(ctx, "tag", nil, &data)
if err != nil {
return nil, errors.Wrap(err, "could not get tags")
}
return data, nil
}

195
pkg/arr/sonarr/sonarr_test.go Normal file
View file

@ -0,0 +1,195 @@
// Copyright (c) 2021 - 2024, Ludvig Lundgren and the autobrr contributors.
// SPDX-License-Identifier: GPL-2.0-or-later
//go:build integration
package sonarr
import (
"context"
"io"
"log"
"net/http"
"net/http/httptest"
"os"
"testing"
"github.com/rs/zerolog"
"github.com/stretchr/testify/assert"
)
func Test_client_Push(t *testing.T) {
// disable logger
zerolog.SetGlobalLevel(zerolog.Disabled)
log.SetOutput(io.Discard)
mux := http.NewServeMux()
ts := httptest.NewServer(mux)
defer ts.Close()
key := "mock-key"
mux.HandleFunc("/api/v3/release/push", func(w http.ResponseWriter, r *http.Request) {
// request validation logic
apiKey := r.Header.Get("X-Api-Key")
if apiKey != "" {
if apiKey != key {
w.WriteHeader(http.StatusUnauthorized)
w.Write(nil)
return
}
}
// read json response
jsonPayload, _ := os.ReadFile("testdata/release_push_response.json")
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
w.Write(jsonPayload)
})
type fields struct {
config Config
}
type args struct {
release Release
}
tests := []struct {
name string
fields fields
args args
rejections []string
err error
wantErr bool
}{
{
name: "push",
fields: fields{
config: Config{
Hostname: ts.URL,
APIKey: "",
BasicAuth: false,
Username: "",
Password: "",
},
},
args: args{release: Release{
Title: "That Show S01 2160p ATVP WEB-DL DDP 5.1 Atmos DV HEVC-NOGROUP",
DownloadUrl: "https://www.test.org/rss/download/0000001/00000000000000000000/That Show S01 2160p ATVP WEB-DL DDP 5.1 Atmos DV HEVC-NOGROUP.torrent",
Size: 0,
Indexer: "test",
DownloadProtocol: "torrent",
Protocol: "torrent",
PublishDate: "2021-08-21T15:36:00Z",
}},
rejections: []string{"Unknown Series"},
//err: errors.New("sonarr push rejected Unknown Series"),
//wantErr: true,
},
{
name: "push_error",
fields: fields{
config: Config{
Hostname: ts.URL,
APIKey: key,
BasicAuth: false,
Username: "",
Password: "",
},
},
args: args{release: Release{
Title: "That Show S01 2160p ATVP WEB-DL DDP 5.1 Atmos DV HEVC-NOGROUP",
DownloadUrl: "https://www.test.org/rss/download/0000001/00000000000000000000/That Show S01 2160p ATVP WEB-DL DDP 5.1 Atmos DV HEVC-NOGROUP.torrent",
Size: 0,
Indexer: "test",
DownloadProtocol: "torrent",
Protocol: "torrent",
PublishDate: "2021-08-21T15:36:00Z",
}},
rejections: []string{"Unknown Series"},
//err: errors.New("sonarr push rejected Unknown Series"),
//wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
c := New(tt.fields.config)
rejections, err := c.Push(context.Background(), tt.args.release)
assert.Equal(t, tt.rejections, rejections)
if tt.wantErr && assert.Error(t, err) {
assert.Equal(t, tt.err, err)
}
})
}
}
func Test_client_Test(t *testing.T) {
// disable logger
zerolog.SetGlobalLevel(zerolog.Disabled)
log.SetOutput(io.Discard)
key := "mock-key"
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
apiKey := r.Header.Get("X-Api-Key")
if apiKey != "" {
if apiKey != key {
w.WriteHeader(http.StatusUnauthorized)
w.Write(nil)
return
}
}
jsonPayload, _ := os.ReadFile("testdata/system_status_response.json")
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
w.Write(jsonPayload)
}))
defer srv.Close()
tests := []struct {
name string
cfg Config
want *SystemStatusResponse
expectedErr string
wantErr bool
}{
{
name: "fetch",
cfg: Config{
Hostname: srv.URL,
APIKey: key,
BasicAuth: false,
Username: "",
Password: "",
},
want: &SystemStatusResponse{Version: "3.0.6.1196"},
expectedErr: "",
wantErr: false,
},
{
name: "fetch_unauthorized",
cfg: Config{
Hostname: srv.URL,
APIKey: "bad-mock-key",
BasicAuth: false,
Username: "",
Password: "",
},
want: nil,
wantErr: true,
expectedErr: "unauthorized: bad credentials",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
c := New(tt.cfg)
got, err := c.Test(context.Background())
if tt.wantErr && assert.Error(t, err) {
assert.EqualErrorf(t, err, tt.expectedErr, "Error should be: %v, got: %v", tt.wantErr, err)
}
assert.Equal(t, tt.want, got)
})
}
}

60
pkg/arr/sonarr/testdata/release_push_response.json vendored Normal file
View file

@ -0,0 +1,60 @@
[
{
"guid": "PUSH-https://www.test.org/rss/download/0000001/00000000000000000000/That Show S01 2160p ATVP WEB-DL DDP 5.1 Atmos DV HEVC-NOGROUP.torrent",
"quality": {
"quality": {
"id": 18,
"name": "WEBDL-2160p",
"source": "web",
"resolution": 2160
},
"revision": {
"version": 1,
"real": 0,
"isRepack": false
}
},
"qualityWeight": 1401,
"age": 1301,
"ageHours": 31239.6100518075,
"ageMinutes": 1874376.60310845,
"size": 0,
"indexerId": 0,
"indexer": "test",
"releaseGroup": "NOGROUP",
"releaseHash": "",
"title": "That Show S01 2160p ATVP WEB-DL DDP 5.1 Atmos DV HEVC-NOGROUP",
"fullSeason": true,
"sceneSource": false,
"seasonNumber": 1,
"language": {
"id": 1,
"name": "English"
},
"languageWeight": 2200,
"seriesTitle": "That Show",
"episodeNumbers": [],
"absoluteEpisodeNumbers": [],
"mappedEpisodeNumbers": [],
"mappedAbsoluteEpisodeNumbers": [],
"approved": false,
"temporarilyRejected": false,
"rejected": true,
"tvdbId": 0,
"tvRageId": 0,
"rejections": [
"Unknown Series"
],
"publishDate": "2018-01-28T07:00:00Z",
"downloadUrl": "https://www.test.org/rss/download/0000001/00000000000000000000/That Show S01 2160p ATVP WEB-DL DDP 5.1 Atmos DV HEVC-NOGROUP.torrent",
"episodeRequested": false,
"downloadAllowed": false,
"releaseWeight": 0,
"preferredWordScore": 0,
"protocol": "torrent",
"isDaily": false,
"isAbsoluteNumbering": false,
"isPossibleSpecialEpisode": false,
"special": false
}
]

28
pkg/arr/sonarr/testdata/system_status_response.json vendored Normal file
View file

@ -0,0 +1,28 @@
{
"version": "3.0.6.1196",
"buildTime": "2018-01-28T07:00:00Z",
"isDebug": false,
"isProduction": true,
"isAdmin": false,
"isUserInteractive": false,
"startupPath": "/usr/lib/sonarr/bin",
"appData": "/home/test/.config/sonarr",
"osName": "debian",
"osVersion": "10",
"isMonoRuntime": true,
"isMono": true,
"isLinux": true,
"isOsx": false,
"isWindows": false,
"mode": "console",
"branch": "main",
"authentication": "basic",
"sqliteVersion": "3.27.2",
"urlBase": "/sonarr",
"runtimeVersion": "6.8.0.123",
"runtimeName": "mono",
"startTime": "2021-08-20T21:04:34.409467Z",
"packageVersion": "3.0.6",
"packageAuthor": "[Team Sonarr](https://sonarr.tv)",
"packageUpdateMechanism": "builtIn"
}

105
pkg/arr/sonarr/types.go Normal file
View file

@ -0,0 +1,105 @@
package sonarr
import (
"fmt"
"time"
"github.com/autobrr/autobrr/pkg/arr"
)
type Release struct {
Title string `json:"title"`
InfoUrl string `json:"infoUrl,omitempty"`
DownloadUrl string `json:"downloadUrl,omitempty"`
MagnetUrl string `json:"magnetUrl,omitempty"`
Size uint64 `json:"size"`
Indexer string `json:"indexer"`
DownloadProtocol string `json:"downloadProtocol"`
Protocol string `json:"protocol"`
PublishDate string `json:"publishDate"`
DownloadClientId int `json:"downloadClientId,omitempty"`
DownloadClient string `json:"downloadClient,omitempty"`
}
type PushResponse struct {
Approved bool `json:"approved"`
Rejected bool `json:"rejected"`
TempRejected bool `json:"temporarilyRejected"`
Rejections []string `json:"rejections"`
}
type BadRequestResponse struct {
PropertyName string `json:"propertyName"`
ErrorMessage string `json:"errorMessage"`
ErrorCode string `json:"errorCode"`
AttemptedValue string `json:"attemptedValue"`
Severity string `json:"severity"`
}
func (r *BadRequestResponse) String() string {
return fmt.Sprintf("[%s: %s] %s: %s - got value: %s", r.Severity, r.ErrorCode, r.PropertyName, r.ErrorMessage, r.AttemptedValue)
}
type SystemStatusResponse struct {
Version string `json:"version"`
}
type AlternateTitle struct {
Title string `json:"title"`
SeasonNumber int `json:"seasonNumber"`
}
type Season struct {
SeasonNumber int `json:"seasonNumber"`
Monitored bool `json:"monitored"`
Statistics *Statistics `json:"statistics,omitempty"`
}
type Statistics struct {
SeasonCount int `json:"seasonCount"`
PreviousAiring time.Time `json:"previousAiring"`
EpisodeFileCount int `json:"episodeFileCount"`
EpisodeCount int `json:"episodeCount"`
TotalEpisodeCount int `json:"totalEpisodeCount"`
SizeOnDisk int64 `json:"sizeOnDisk"`
PercentOfEpisodes float64 `json:"percentOfEpisodes"`
}
type Series struct {
ID int64 `json:"id"`
Title string `json:"title,omitempty"`
AlternateTitles []*AlternateTitle `json:"alternateTitles,omitempty"`
SortTitle string `json:"sortTitle,omitempty"`
Status string `json:"status,omitempty"`
Overview string `json:"overview,omitempty"`
PreviousAiring time.Time `json:"previousAiring,omitempty"`
Network string `json:"network,omitempty"`
Images []*arr.Image `json:"images,omitempty"`
Seasons []*Season `json:"seasons,omitempty"`
Year int `json:"year,omitempty"`
Path string `json:"path,omitempty"`
QualityProfileID int64 `json:"qualityProfileId,omitempty"`
LanguageProfileID int64 `json:"languageProfileId,omitempty"`
Runtime int `json:"runtime,omitempty"`
TvdbID int64 `json:"tvdbId,omitempty"`
TvRageID int64 `json:"tvRageId,omitempty"`
TvMazeID int64 `json:"tvMazeId,omitempty"`
FirstAired time.Time `json:"firstAired,omitempty"`
SeriesType string `json:"seriesType,omitempty"`
CleanTitle string `json:"cleanTitle,omitempty"`
ImdbID string `json:"imdbId,omitempty"`
TitleSlug string `json:"titleSlug,omitempty"`
RootFolderPath string `json:"rootFolderPath,omitempty"`
Certification string `json:"certification,omitempty"`
Genres []string `json:"genres,omitempty"`
Tags []int `json:"tags,omitempty"`
Added time.Time `json:"added,omitempty"`
Ratings *arr.Ratings `json:"ratings,omitempty"`
Statistics *Statistics `json:"statistics,omitempty"`
NextAiring time.Time `json:"nextAiring,omitempty"`
AirTime string `json:"airTime,omitempty"`
Ended bool `json:"ended,omitempty"`
SeasonFolder bool `json:"seasonFolder,omitempty"`
Monitored bool `json:"monitored"`
UseSceneNumbering bool `json:"useSceneNumbering,omitempty"`
}