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

refactor(http): implement bufio (#1604)

Browse source 
* fix: misc http fixes

* feat(io): implement bufio around syscalls

* peek-a-boo

* this can't be right.

* you better be wearing a helmet

* jesus christ.

* refactor(notifications): check err on non-ok status

* fix(notifications): add missing name method

* refactor(indexer): api clients

* fix(indexer): ptp test

---------

Co-authored-by: ze0s <ze0s@riseup.net>
This commit is contained in:
Kyle Sanderson 2024-08-28 23:51:20 -07:00 • committed by GitHub
parent d13b421c42
commit cc0cca9f0d
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
22 changed files with 465 additions and 304 deletions
Download patch file Download diff file Expand all files Collapse all files

32
internal/notification/discord.go
View file

@ -4,6 +4,7 @@
package notification
import (
"bufio"
"bytes"
"encoding/json"
"fmt"
@ -54,6 +55,10 @@ type discordSender struct {
httpClient *http.Client
}
func (a *discordSender) Name() string {
return "discord"
}
func NewDiscordSender(log zerolog.Logger, settings domain.Notification) domain.NotificationSender {
return &discordSender{
log: log.With().Str("sender", "discord").Logger(),
@ -73,14 +78,12 @@ func (a *discordSender) Send(event domain.NotificationEvent, payload domain.Noti
jsonData, err := json.Marshal(m)
if err != nil {
a.log.Error().Err(err).Msgf("discord client could not marshal data: %v", m)
return errors.Wrap(err, "could not marshal data: %+v", m)
return errors.Wrap(err, "could not marshal json request for event: %v payload: %v", event, payload)
}
req, err := http.NewRequest(http.MethodPost, a.Settings.Webhook, bytes.NewBuffer(jsonData))
if err != nil {
a.log.Error().Err(err).Msgf("discord client request error: %v", event)
return errors.Wrap(err, "could not create request")
return errors.Wrap(err, "could not create request for event: %v payload: %v", event, payload)
}
req.Header.Set("Content-Type", "application/json")
@ -88,24 +91,21 @@ func (a *discordSender) Send(event domain.NotificationEvent, payload domain.Noti
res, err := a.httpClient.Do(req)
if err != nil {
a.log.Error().Err(err).Msgf("discord client request error: %v", event)
return errors.Wrap(err, "could not make request: %+v", req)
return errors.Wrap(err, "client request error for event: %v payload: %v", event, payload)
}
defer res.Body.Close()
body, err := io.ReadAll(res.Body)
if err != nil {
a.log.Error().Err(err).Msgf("discord client request error: %v", event)
return errors.Wrap(err, "could not read data")
}
a.log.Trace().Msgf("discord status: %v response: %v", res.StatusCode, string(body))
a.log.Trace().Msgf("discord response status: %d", res.StatusCode)
// discord responds with 204, Notifiarr with 204 so lets take all 200 as ok
if res.StatusCode >= 300 {
a.log.Error().Err(err).Msgf("discord client request error: %v", string(body))
return errors.New("bad status: %v body: %v", res.StatusCode, string(body))
if res.StatusCode != http.StatusOK && res.StatusCode != http.StatusNoContent {
body, err := io.ReadAll(bufio.NewReader(res.Body))
if err != nil {
return errors.Wrap(err, "could not read body for event: %v payload: %v", event, payload)
}
return errors.New("unexpected status: %v body: %v", res.StatusCode, string(body))
}
a.log.Debug().Msg("notification successfully sent to discord")

30
internal/notification/gotify.go
View file

@ -4,6 +4,7 @@
package notification
import (
"bufio"
"fmt"
"io"
"net/http"
@ -31,6 +32,10 @@ type gotifySender struct {
httpClient *http.Client
}
func (s *gotifySender) Name() string {
return "gotify"
}
func NewGotifySender(log zerolog.Logger, settings domain.Notification) domain.NotificationSender {
return &gotifySender{
log: log.With().Str("sender", "gotify").Logger(),
@ -53,11 +58,9 @@ func (s *gotifySender) Send(event domain.NotificationEvent, payload domain.Notif
data.Set("message", m.Message)
data.Set("title", m.Title)
url := fmt.Sprintf("%v/message?token=%v", s.Settings.Host, s.Settings.Token)
req, err := http.NewRequest(http.MethodPost, url, strings.NewReader(data.Encode()))
req, err := http.NewRequest(http.MethodPost, fmt.Sprintf("%v/message?token=%v", s.Settings.Host, s.Settings.Token), strings.NewReader(data.Encode()))
if err != nil {
s.log.Error().Err(err).Msgf("gotify client request error: %v", event)
return errors.Wrap(err, "could not create request")
return errors.Wrap(err, "could not create request for event: %v payload: %v", event, payload)
}
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
@ -65,23 +68,20 @@ func (s *gotifySender) Send(event domain.NotificationEvent, payload domain.Notif
res, err := s.httpClient.Do(req)
if err != nil {
s.log.Error().Err(err).Msgf("gotify client request error: %v", event)
return errors.Wrap(err, "could not make request: %+v", req)
return errors.Wrap(err, "client request error for event: %v payload: %v", event, payload)
}
defer res.Body.Close()
body, err := io.ReadAll(res.Body)
if err != nil {
s.log.Error().Err(err).Msgf("gotify client request error: %v", event)
return errors.Wrap(err, "could not read data")
}
s.log.Trace().Msgf("gotify status: %v response: %v", res.StatusCode, string(body))
s.log.Trace().Msgf("gotify status: %d", res.StatusCode)
if res.StatusCode != http.StatusOK {
s.log.Error().Err(err).Msgf("gotify client request error: %v", string(body))
return errors.New("bad status: %v body: %v", res.StatusCode, string(body))
body, err := io.ReadAll(bufio.NewReader(res.Body))
if err != nil {
return errors.Wrap(err, "could not read body for event: %v payload: %v", event, payload)
}
return errors.New("unexpected status: %v body: %v", res.StatusCode, string(body))
}
s.log.Debug().Msg("notification successfully sent to gotify")

25
internal/notification/lunasea.go
View file

@ -1,8 +1,10 @@
package notification
import (
"bufio"
"bytes"
"encoding/json"
"io"
"net/http"
"regexp"
"time"
@ -31,6 +33,10 @@ type lunaSeaSender struct {
httpClient *http.Client
}
func (s *lunaSeaSender) Name() string {
return "lunasea"
}
func (s *lunaSeaSender) rewriteWebhookURL(url string) string {
re := regexp.MustCompile(`/(radarr|sonarr|lidarr|tautulli|overseerr)/`)
return re.ReplaceAllString(url, "/custom/")
@ -57,31 +63,32 @@ func (s *lunaSeaSender) Send(event domain.NotificationEvent, payload domain.Noti
jsonData, err := json.Marshal(m)
if err != nil {
s.log.Error().Err(err).Msg("lunasea client could not marshal data")
return errors.Wrap(err, "could not marshal data")
return errors.Wrap(err, "could not marshal json request for event: %v payload: %v", event, payload)
}
rewrittenURL := s.rewriteWebhookURL(s.Settings.Webhook)
req, err := http.NewRequest(http.MethodPost, rewrittenURL, bytes.NewBuffer(jsonData))
if err != nil {
s.log.Error().Err(err).Msg("lunasea client request error")
return errors.Wrap(err, "could not create request")
return errors.Wrap(err, "could not create request for event: %v payload: %v", event, payload)
}
req.Header.Set("Content-Type", "application/json")
res, err := s.httpClient.Do(req)
if err != nil {
s.log.Error().Err(err).Msg("lunasea client request error")
return errors.Wrap(err, "could not make request")
return errors.Wrap(err, "client request error for event: %v payload: %v", event, payload)
}
defer res.Body.Close()
if res.StatusCode >= 300 {
s.log.Error().Msgf("bad status from lunasea: %v", res.StatusCode)
return errors.New("bad status: %v", res.StatusCode)
if res.StatusCode != http.StatusOK {
body, err := io.ReadAll(bufio.NewReader(res.Body))
if err != nil {
return errors.Wrap(err, "could not read body for event: %v payload: %v", event, payload)
}
return errors.New("unexpected status: %v body: %v", res.StatusCode, string(body))
}
s.log.Debug().Msg("notification successfully sent to lunasea")

30
internal/notification/notifiarr.go
View file

@ -4,6 +4,7 @@
package notification
import (
"bufio"
"bytes"
"encoding/json"
"io"
@ -49,6 +50,10 @@ type notifiarrSender struct {
httpClient *http.Client
}
func (s *notifiarrSender) Name() string {
return "notifiarr"
}
func NewNotifiarrSender(log zerolog.Logger, settings domain.Notification) domain.NotificationSender {
return &notifiarrSender{
log: log.With().Str("sender", "notifiarr").Logger(),
@ -69,14 +74,12 @@ func (s *notifiarrSender) Send(event domain.NotificationEvent, payload domain.No
jsonData, err := json.Marshal(m)
if err != nil {
s.log.Error().Err(err).Msgf("notifiarr client could not marshal data: %v", m)
return errors.Wrap(err, "could not marshal data: %+v", m)
return errors.Wrap(err, "could not marshal json request for event: %v payload: %v", event, payload)
}
req, err := http.NewRequest(http.MethodPost, s.baseUrl, bytes.NewBuffer(jsonData))
if err != nil {
s.log.Error().Err(err).Msgf("notifiarr client request error: %v", event)
return errors.Wrap(err, "could not create request")
return errors.Wrap(err, "could not create request for event: %v payload: %v", event, payload)
}
req.Header.Set("Content-Type", "application/json")
@ -85,23 +88,20 @@ func (s *notifiarrSender) Send(event domain.NotificationEvent, payload domain.No
res, err := s.httpClient.Do(req)
if err != nil {
s.log.Error().Err(err).Msgf("notifiarr client request error: %v", event)
return errors.Wrap(err, "could not make request: %+v", req)
return errors.Wrap(err, "client request error for event: %v payload: %v", event, payload)
}
defer res.Body.Close()
body, err := io.ReadAll(res.Body)
if err != nil {
s.log.Error().Err(err).Msgf("notifiarr client request error: %v", event)
return errors.Wrap(err, "could not read data")
}
s.log.Trace().Msgf("notifiarr status: %v response: %v", res.StatusCode, string(body))
s.log.Trace().Msgf("response status: %d", res.StatusCode)
if res.StatusCode != http.StatusOK {
s.log.Error().Err(err).Msgf("notifiarr client request error: %v", string(body))
return errors.New("bad status: %v body: %v", res.StatusCode, string(body))
body, err := io.ReadAll(bufio.NewReader(res.Body))
if err != nil {
return errors.Wrap(err, "could not read body for event: %v payload: %v", event, payload)
}
return errors.New("unexpected status: %v body: %v", res.StatusCode, string(body))
}
s.log.Debug().Msg("notification successfully sent to notifiarr")

27
internal/notification/ntfy.go
View file

@ -4,6 +4,7 @@
package notification
import (
"bufio"
"io"
"net/http"
"strconv"
@ -30,6 +31,10 @@ type ntfySender struct {
httpClient *http.Client
}
func (s *ntfySender) Name() string {
return "ntfy"
}
func NewNtfySender(log zerolog.Logger, settings domain.Notification) domain.NotificationSender {
return &ntfySender{
log: log.With().Str("sender", "ntfy").Logger(),
@ -50,8 +55,7 @@ func (s *ntfySender) Send(event domain.NotificationEvent, payload domain.Notific
req, err := http.NewRequest(http.MethodPost, s.Settings.Host, strings.NewReader(m.Message))
if err != nil {
s.log.Error().Err(err).Msgf("ntfy client request error: %v", event)
return errors.Wrap(err, "could not create request")
return errors.Wrap(err, "could not create request for event: %v payload: %v", event, payload)
}
req.Header.Set("Content-Type", "text/plain")
@ -71,23 +75,20 @@ func (s *ntfySender) Send(event domain.NotificationEvent, payload domain.Notific
res, err := s.httpClient.Do(req)
if err != nil {
s.log.Error().Err(err).Msgf("ntfy client request error: %v", event)
return errors.Wrap(err, "could not make request: %+v", req)
return errors.Wrap(err, "client request error for event: %v payload: %v", event, payload)
}
defer res.Body.Close()
body, err := io.ReadAll(res.Body)
if err != nil {
s.log.Error().Err(err).Msgf("ntfy client request error: %v", event)
return errors.Wrap(err, "could not read data")
}
s.log.Trace().Msgf("ntfy status: %v response: %v", res.StatusCode, string(body))
s.log.Trace().Msgf("ntfy response status: %d", res.StatusCode)
if res.StatusCode != http.StatusOK {
s.log.Error().Err(err).Msgf("ntfy client request error: %v", string(body))
return errors.New("bad status: %v body: %v", res.StatusCode, string(body))
body, err := io.ReadAll(bufio.NewReader(res.Body))
if err != nil {
return errors.Wrap(err, "could not read body for event: %v payload: %v", event, payload)
}
return errors.New("unexpected status: %v body: %v", res.StatusCode, string(body))
}
s.log.Debug().Msg("notification successfully sent to ntfy")

27
internal/notification/pushover.go
View file

@ -4,6 +4,7 @@
package notification
import (
"bufio"
"fmt"
"io"
"net/http"
@ -38,6 +39,10 @@ type pushoverSender struct {
httpClient *http.Client
}
func (s *pushoverSender) Name() string {
return "pushover"
}
func NewPushoverSender(log zerolog.Logger, settings domain.Notification) domain.NotificationSender {
return &pushoverSender{
log: log.With().Str("sender", "pushover").Logger(),
@ -81,8 +86,7 @@ func (s *pushoverSender) Send(event domain.NotificationEvent, payload domain.Not
req, err := http.NewRequest(http.MethodPost, s.baseUrl, strings.NewReader(data.Encode()))
if err != nil {
s.log.Error().Err(err).Msgf("pushover client request error: %v", event)
return errors.Wrap(err, "could not create request")
return errors.Wrap(err, "could not create request for event: %v payload: %v", event, payload)
}
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
@ -90,23 +94,20 @@ func (s *pushoverSender) Send(event domain.NotificationEvent, payload domain.Not
res, err := s.httpClient.Do(req)
if err != nil {
s.log.Error().Err(err).Msgf("pushover client request error: %v", event)
return errors.Wrap(err, "could not make request: %+v", req)
return errors.Wrap(err, "client request error for event: %v payload: %v", event, payload)
}
defer res.Body.Close()
body, err := io.ReadAll(res.Body)
if err != nil {
s.log.Error().Err(err).Msgf("pushover client request error: %v", event)
return errors.Wrap(err, "could not read data")
}
s.log.Trace().Msgf("pushover status: %v response: %v", res.StatusCode, string(body))
s.log.Trace().Msgf("pushover response status: %d", res.StatusCode)
if res.StatusCode != http.StatusOK {
s.log.Error().Err(err).Msgf("pushover client request error: %v", string(body))
return errors.New("bad status: %v body: %v", res.StatusCode, string(body))
body, err := io.ReadAll(bufio.NewReader(res.Body))
if err != nil {
return errors.Wrap(err, "could not read body for event: %v payload: %v", event, payload)
}
return errors.New("unexpected status: %v body: %v", res.StatusCode, string(body))
}
s.log.Debug().Msg("notification successfully sent to pushover")

4
internal/notification/service.go
View file

@ -155,7 +155,9 @@ func (s *service) Send(event domain.NotificationEvent, payload domain.Notificati
for _, sender := range s.senders {
// check if sender is active and have notification types
if sender.CanSend(event) {
sender.Send(event, payload)
if err := sender.Send(event, payload); err != nil {
s.log.Error().Err(err).Msgf("could not send %s notification for %v", sender.Name(), string(event))
}
}
}
}()

4
internal/notification/shoutrrr.go
View file

@ -13,6 +13,10 @@ type shoutrrrSender struct {
builder MessageBuilderPlainText
}
func (s *shoutrrrSender) Name() string {
return "shoutrrr"
}
func NewShoutrrrSender(log zerolog.Logger, settings domain.Notification) domain.NotificationSender {
return &shoutrrrSender{
log: log.With().Str("sender", "shoutrrr").Logger(),

31
internal/notification/telegram.go
View file

@ -4,6 +4,7 @@
package notification
import (
"bufio"
"bytes"
"encoding/json"
"fmt"
@ -36,6 +37,10 @@ type telegramSender struct {
httpClient *http.Client
}
func (s *telegramSender) Name() string {
return "telegram"
}
func NewTelegramSender(log zerolog.Logger, settings domain.Notification) domain.NotificationSender {
threadID := 0
if t := settings.Topic; t != "" {
@ -69,8 +74,7 @@ func (s *telegramSender) Send(event domain.NotificationEvent, payload domain.Not
jsonData, err := json.Marshal(m)
if err != nil {
s.log.Error().Err(err).Msgf("telegram client could not marshal data: %v", m)
return errors.Wrap(err, "could not marshal data: %+v", m)
return errors.Wrap(err, "could not marshal json request for event: %v payload: %v", event, payload)
}
var host string
@ -85,8 +89,7 @@ func (s *telegramSender) Send(event domain.NotificationEvent, payload domain.Not
req, err := http.NewRequest(http.MethodPost, url, bytes.NewBuffer(jsonData))
if err != nil {
s.log.Error().Err(err).Msgf("telegram client request error: %v", event)
return errors.Wrap(err, "could not create request")
return errors.Wrap(err, "could not create request for event: %v payload: %v", event, payload)
}
req.Header.Set("Content-Type", "application/json")
@ -94,26 +97,24 @@ func (s *telegramSender) Send(event domain.NotificationEvent, payload domain.Not
res, err := s.httpClient.Do(req)
if err != nil {
s.log.Error().Err(err).Msgf("telegram client request error: %v", event)
return errors.Wrap(err, "could not make request: %+v", req)
return errors.Wrap(err, "client request error for event: %v payload: %v", event, payload)
}
defer res.Body.Close()
body, err := io.ReadAll(res.Body)
if err != nil {
s.log.Error().Err(err).Msgf("telegram client request error: %v", event)
return errors.Wrap(err, "could not read data")
}
s.log.Trace().Msgf("telegram status: %v response: %v", res.StatusCode, string(body))
s.log.Trace().Msgf("telegram status: %d", res.StatusCode)
if res.StatusCode != http.StatusOK {
s.log.Error().Err(err).Msgf("telegram client request error: %v", string(body))
return errors.New("bad status: %v body: %v", res.StatusCode, string(body))
body, err := io.ReadAll(bufio.NewReader(res.Body))
if err != nil {
return errors.Wrap(err, "could not read body for event: %v payload: %v", event, payload)
}
return errors.New("unexpected status: %v body: %v", res.StatusCode, string(body))
}
s.log.Debug().Msg("notification successfully sent to telegram")
return nil
}