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

feat(irc): improve reconnect and add notifications (#315)

Browse source 
* refactor(irc): nickserv and methods

* feat(notifications): add new events and refactor send

* feat(irc): handle disconnect reconnect and connect

* feat(irc): update config for ergo local irc server

* feat(irc): retry initial connect

* feat(irc): show nickserv errors
This commit is contained in:
Ludvig Lundgren 2022-06-29 16:50:38 +02:00 • committed by GitHub
parent 41eef4e8be
commit f63ace662a
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
16 changed files with 1343 additions and 133 deletions
Download patch file Download diff file Expand all files Collapse all files

27
internal/domain/irc.go
View file

@ -35,18 +35,21 @@ type IrcNetwork struct {
}
type IrcNetworkWithHealth struct {
ID int64 `json:"id"`
Name string `json:"name"`
Enabled bool `json:"enabled"`
Server string `json:"server"`
Port int `json:"port"`
TLS bool `json:"tls"`
Pass string `json:"pass"`
InviteCommand string `json:"invite_command"`
NickServ NickServ `json:"nickserv,omitempty"`
Channels []ChannelWithHealth `json:"channels"`
Connected bool `json:"connected"`
ConnectedSince time.Time `json:"connected_since"`
ID int64 `json:"id"`
Name string `json:"name"`
Enabled bool `json:"enabled"`
Server string `json:"server"`
Port int `json:"port"`
TLS bool `json:"tls"`
Pass string `json:"pass"`
InviteCommand string `json:"invite_command"`
NickServ NickServ `json:"nickserv,omitempty"`
CurrentNick string `json:"current_nick"`
PreferredNick string `json:"preferred_nick"`
Channels []ChannelWithHealth `json:"channels"`
Connected bool `json:"connected"`
ConnectedSince time.Time `json:"connected_since"`
ConnectionErrors []string `json:"connection_errors"`
}
type ChannelWithHealth struct {

6
internal/domain/notification.go
View file

@ -78,11 +78,13 @@ const (
type NotificationEvent string
const (
//NotificationEventAppUpdateAvailable NotificationEvent = "APP_UPDATE_AVAILABLE"
NotificationEventPushApproved NotificationEvent = "PUSH_APPROVED"
NotificationEventPushRejected NotificationEvent = "PUSH_REJECTED"
NotificationEventPushError NotificationEvent = "PUSH_ERROR"
NotificationEventUpdateAvailable NotificationEvent = "UPDATE_AVAILABLE"
NotificationEventIRCHealth NotificationEvent = "IRC_HEALTH"
NotificationEventIRCDisconnected NotificationEvent = "IRC_DISCONNECTED"
NotificationEventIRCReconnected NotificationEvent = "IRC_RECONNECTED"
NotificationEventTest NotificationEvent = "TEST"
)

4
internal/events/subscribers.go
View file

@ -57,7 +57,5 @@ func (s Subscriber) releasePushStatus(actionStatus *domain.ReleaseActionStatus)
func (s Subscriber) sendNotification(event *domain.NotificationEvent, payload *domain.NotificationPayload) {
s.log.Trace().Msgf("events: '%v' '%+v'", event, payload)
if err := s.notificationSvc.Send(*event, *payload); err != nil {
s.log.Error().Err(err).Msgf("events: '%v' error sending notification", event)
}
s.notificationSvc.Send(*event, *payload)
}

335
internal/irc/handler.go
View file

@ -11,18 +11,16 @@ import (
"github.com/autobrr/autobrr/internal/announce"
"github.com/autobrr/autobrr/internal/domain"
"github.com/autobrr/autobrr/internal/logger"
"github.com/autobrr/autobrr/internal/notification"
"github.com/autobrr/autobrr/internal/release"
"github.com/avast/retry-go"
"github.com/dcarbone/zadapters/zstdlog"
"github.com/ergochat/irc-go/ircevent"
"github.com/ergochat/irc-go/ircmsg"
"github.com/rs/zerolog"
)
var (
connectTimeout = 15 * time.Second
)
type channelHealth struct {
m sync.RWMutex
@ -52,40 +50,46 @@ func (h *channelHealth) resetMonitoring() {
h.m.Lock()
h.monitoring = false
h.monitoringSince = time.Time{}
h.lastAnnounce = time.Time{}
h.m.Unlock()
}
type Handler struct {
log zerolog.Logger
network *domain.IrcNetwork
releaseSvc release.Service
announceProcessors map[string]announce.Processor
definitions map[string]*domain.IndexerDefinition
log zerolog.Logger
network *domain.IrcNetwork
releaseSvc release.Service
notificationService notification.Service
announceProcessors map[string]announce.Processor
definitions map[string]*domain.IndexerDefinition
client *ircevent.Connection
m sync.RWMutex
lastPing time.Time
connected bool
connectedSince time.Time
// tODO disconnectedTime
connected bool
connectedSince time.Time
haveDisconnected bool
manuallyDisconnected bool
validAnnouncers map[string]struct{}
validChannels map[string]struct{}
channelHealth map[string]*channelHealth
connectionErrors []string
failedNickServAttempts int
}
func NewHandler(log logger.Logger, network domain.IrcNetwork, definitions []*domain.IndexerDefinition, releaseSvc release.Service) *Handler {
func NewHandler(log logger.Logger, network domain.IrcNetwork, definitions []*domain.IndexerDefinition, releaseSvc release.Service, notificationSvc notification.Service) *Handler {
h := &Handler{
log: log.With().Str("network", network.Server).Logger(),
client: nil,
network: &network,
releaseSvc: releaseSvc,
definitions: map[string]*domain.IndexerDefinition{},
announceProcessors: map[string]announce.Processor{},
validAnnouncers: map[string]struct{}{},
validChannels: map[string]struct{}{},
channelHealth: map[string]*channelHealth{},
log: log.With().Str("network", network.Server).Logger(),
client: nil,
network: &network,
releaseSvc: releaseSvc,
notificationService: notificationSvc,
definitions: map[string]*domain.IndexerDefinition{},
announceProcessors: map[string]announce.Processor{},
validAnnouncers: map[string]struct{}{},
validChannels: map[string]struct{}{},
channelHealth: map[string]*channelHealth{},
}
// init indexer, announceProcessor
@ -135,6 +139,10 @@ func (h *Handler) removeIndexer() {
}
func (h *Handler) Run() error {
// TODO validate
// check if network requires nickserv
// chech if network or channels requires invite command
addr := fmt.Sprintf("%v:%d", h.network.Server, h.network.Port)
subLogger := zstdlog.NewStdLoggerWithLevel(h.log.With().Logger(), zerolog.TraceLevel)
@ -160,11 +168,14 @@ func (h *Handler) Run() error {
}
h.client.AddConnectCallback(h.onConnect)
h.client.AddDisconnectCallback(h.onDisconnect)
h.client.AddCallback("MODE", h.handleMode)
h.client.AddCallback("INVITE", h.handleInvite)
h.client.AddCallback("366", h.handleJoined)
h.client.AddCallback("PART", h.handlePart)
h.client.AddCallback("PRIVMSG", h.onMessage)
h.client.AddCallback("NOTICE", h.onNotice)
h.client.AddCallback("NICK", h.onNick)
if err := h.client.Connect(); err != nil {
h.log.Error().Stack().Err(err).Msg("connect error")
@ -172,11 +183,32 @@ func (h *Handler) Run() error {
// reset connection status on handler and channels
h.resetConnectionStatus()
//return err
}
// count connect attempts
connectAttempts := 1
// set connected since now
h.setConnectionStatus()
// retry initial connect if network is down
// using exponential backoff of 15 seconds
err := retry.Do(
func() error {
h.log.Debug().Msgf("connect attempt %d", connectAttempts)
err := h.client.Connect()
if err != nil {
connectAttempts++
return err
}
h.log.Debug().Msgf("connected at attempt %d", connectAttempts)
return nil
},
retry.Delay(time.Second*15),
retry.Attempts(25),
retry.DelayType(func(n uint, err error, config *retry.Config) time.Duration {
return retry.BackOffDelay(n, err, config)
}),
)
h.log.Error().Stack().Err(err).Msgf("connect error: attempt %d", connectAttempts)
}
h.client.Loop()
@ -239,12 +271,20 @@ func (h *Handler) AddChannelHealth(channel string) {
func (h *Handler) Stop() {
h.log.Debug().Msg("Disconnecting...")
h.m.Lock()
h.manuallyDisconnected = true
h.m.Unlock()
h.client.Quit()
}
func (h *Handler) Restart() error {
h.log.Debug().Msg("Restarting network...")
h.m.Lock()
h.manuallyDisconnected = true
h.m.Unlock()
h.client.Quit()
time.Sleep(4 * time.Second)
@ -253,41 +293,182 @@ func (h *Handler) Restart() error {
}
func (h *Handler) onConnect(m ircmsg.Message) {
identified := false
// 1. No nickserv, no invite command - join
// 2. Nickserv - join after auth
// 3. nickserv and invite command - join after nickserv
// 4. invite command - join
time.Sleep(4 * time.Second)
h.resetConnectErrors()
h.setConnectionStatus()
if h.haveDisconnected {
h.notificationService.Send(domain.NotificationEventIRCReconnected, domain.NotificationPayload{
Subject: "IRC Reconnected",
Message: fmt.Sprintf("Network: %v", h.network.Name),
})
// reset haveDisconnected
h.haveDisconnected = false
}
h.log.Debug().Msgf("connected to: %v", h.network.Name)
time.Sleep(2 * time.Second)
if h.network.NickServ.Password != "" {
err := h.HandleNickServIdentify(h.network.NickServ.Password)
if err != nil {
if err := h.NickServIdentify(h.network.NickServ.Password); err != nil {
h.log.Error().Stack().Err(err).Msg("error nickserv")
return
}
identified = true
// return and wait for NOTICE of nickserv auth
return
}
time.Sleep(4 * time.Second)
if h.network.InviteCommand != "" {
err := h.handleConnectCommands(h.network.InviteCommand)
if err != nil {
if h.network.InviteCommand != "" && h.network.NickServ.Password == "" {
if err := h.sendConnectCommands(h.network.InviteCommand); err != nil {
h.log.Error().Stack().Err(err).Msgf("error sending connect command %v", h.network.InviteCommand)
return
}
time.Sleep(1 * time.Second)
return
}
if !identified {
for _, channel := range h.network.Channels {
err := h.HandleJoinChannel(channel.Name, channel.Password)
if err != nil {
h.log.Error().Stack().Err(err).Msgf("error joining channels %v", err)
// join channels if no password or no invite command
h.JoinChannels()
}
func (h *Handler) onDisconnect(m ircmsg.Message) {
h.log.Debug().Msgf("DISCONNECT")
h.haveDisconnected = true
h.resetConnectionStatus()
// check if we are responsible for disconnect
if !h.manuallyDisconnected {
// only send notification if we did not initiate disconnect/restart/stop
h.notificationService.Send(domain.NotificationEventIRCDisconnected, domain.NotificationPayload{
Subject: "IRC Disconnected unexpectedly",
Message: fmt.Sprintf("Network: %v", h.network.Name),
})
// reset
h.manuallyDisconnected = false
}
}
func (h *Handler) onNotice(msg ircmsg.Message) {
if msg.Nick() == "NickServ" {
h.log.Debug().Msgf("NOTICE from nickserv: %v", msg.Params)
if contains(msg.Params[1],
"Invalid account credentials",
"Authentication failed: Invalid account credentials",
"password incorrect",
) {
h.addConnectError("authentication failed: Bad account credentials")
h.log.Warn().Msg("NickServ: authentication failed - bad account credentials")
if h.failedNickServAttempts >= 1 {
h.log.Warn().Msgf("NickServ %d failed login attempts", h.failedNickServAttempts)
// stop network and notify user
h.Stop()
}
h.failedNickServAttempts++
}
if contains(msg.Params[1],
"Account does not exist",
"Authentication failed: Account does not exist", // Nick ANICK isn't registered
) {
h.addConnectError("authentication failed: account does not exist")
if h.failedNickServAttempts >= 2 {
h.log.Warn().Msgf("NickServ %d failed login attempts", h.failedNickServAttempts)
// stop network and notify user
h.Stop()
}
h.failedNickServAttempts++
}
if contains(msg.Params[1],
"This nickname is registered and protected",
"please choose a different nick",
"choose a different nick",
) {
if h.failedNickServAttempts >= 3 {
h.log.Warn().Msgf("NickServ %d failed login attempts", h.failedNickServAttempts)
h.addConnectError("authentication failed: nick in use and not authenticated")
// stop network and notify user
h.Stop()
}
h.failedNickServAttempts++
}
// params: [test-bot You're now logged in as test-bot]
// Password accepted - you are now recognized.
if contains(msg.Params[1], "you're now logged in as", "password accepted", "you are now recognized") {
h.log.Debug().Msgf("NOTICE nickserv logged in: %v", msg.Params)
h.resetConnectErrors()
h.failedNickServAttempts = 0
// if no invite command, join
if h.network.InviteCommand == "" {
h.JoinChannels()
return
}
// else send connect commands
if err := h.sendConnectCommands(h.network.InviteCommand); err != nil {
h.log.Error().Stack().Err(err).Msgf("error sending connect command %v", h.network.InviteCommand)
return
}
}
}
//[test-bot Invalid parameters. For usage, do /msg NickServ HELP IDENTIFY]
// fallback for networks that require both password and nick to NickServ IDENTIFY
if contains(msg.Params[1], "invalid parameters", "help identify") {
h.log.Debug().Msgf("NOTICE nickserv invalid: %v", msg.Params)
if err := h.client.Send("PRIVMSG", "NickServ", fmt.Sprintf("IDENTIFY %v %v", h.network.NickServ.Account, h.network.NickServ.Password)); err != nil {
return
}
}
// Your nickname is not registered
}
}
func contains(s string, substr ...string) bool {
s = strings.ToLower(s)
for _, c := range substr {
c = strings.ToLower(c)
if strings.Contains(s, c) {
return true
} else if c == s {
return true
}
}
return false
}
func (h *Handler) onNick(msg ircmsg.Message) {
h.log.Debug().Msgf("NICK event: %v params: %v", msg.Nick(), msg.Params)
if h.client.CurrentNick() != h.client.PreferredNick() {
h.log.Debug().Msgf("nick miss-match: got %v want %v", h.client.CurrentNick(), h.client.PreferredNick())
}
}
func (h *Handler) onMessage(msg ircmsg.Message) {
@ -349,7 +530,18 @@ func (h *Handler) sendToAnnounceProcessor(channel string, msg string) error {
return nil
}
func (h *Handler) HandleJoinChannel(channel string, password string) error {
func (h *Handler) JoinChannels() {
for _, channel := range h.network.Channels {
if err := h.JoinChannel(channel.Name, channel.Password); err != nil {
h.log.Error().Stack().Err(err).Msgf("error joining channel %v", channel.Name)
continue
}
time.Sleep(1 * time.Second)
}
}
func (h *Handler) JoinChannel(channel string, password string) error {
m := ircmsg.Message{
Command: "JOIN",
Params: []string{channel},
@ -397,12 +589,12 @@ func (h *Handler) handlePart(msg ircmsg.Message) {
// TODO remove announceProcessor
h.log.Info().Msgf("Left channel '%v'", channel)
h.log.Debug().Msgf("Left channel '%v'", channel)
return
}
func (h *Handler) HandlePartChannel(channel string) error {
func (h *Handler) PartChannel(channel string) error {
h.log.Debug().Msgf("PART channel %v", channel)
err := h.client.Part(channel)
@ -452,7 +644,7 @@ func (h *Handler) handleJoined(msg ircmsg.Message) {
}
}
func (h *Handler) handleConnectCommands(msg string) error {
func (h *Handler) sendConnectCommands(msg string) error {
connectCommand := strings.ReplaceAll(msg, "/msg", "")
connectCommands := strings.Split(connectCommand, ",")
@ -495,7 +687,7 @@ func (h *Handler) handleInvite(msg ircmsg.Message) {
return
}
func (h *Handler) HandleNickServIdentify(password string) error {
func (h *Handler) NickServIdentify(password string) error {
m := ircmsg.Message{
Command: "PRIVMSG",
Params: []string{"NickServ", "IDENTIFY", password},
@ -512,7 +704,7 @@ func (h *Handler) HandleNickServIdentify(password string) error {
return nil
}
func (h *Handler) HandleNickChange(nick string) error {
func (h *Handler) NickChange(nick string) error {
h.log.Debug().Msgf("Nick change: %v", nick)
h.client.SetNick(nick)
@ -520,6 +712,14 @@ func (h *Handler) HandleNickChange(nick string) error {
return nil
}
func (h *Handler) CurrentNick() string {
return h.client.CurrentNick()
}
func (h *Handler) PreferredNick() string {
return h.client.PreferredNick()
}
func (h *Handler) handleMode(msg ircmsg.Message) {
h.log.Debug().Msgf("MODE: %+v", msg)
@ -528,22 +728,15 @@ func (h *Handler) handleMode(msg ircmsg.Message) {
return
}
time.Sleep(5 * time.Second)
if h.network.NickServ.Password != "" && !strings.Contains(msg.Params[0], h.client.Nick) || !strings.Contains(msg.Params[1], "+r") {
h.log.Trace().Msgf("MODE: Not correct permission yet: %v", msg.Params)
return
}
for _, ch := range h.network.Channels {
err := h.HandleJoinChannel(ch.Name, ch.Password)
if err != nil {
h.log.Error().Err(err).Msgf("error joining channel: %v", ch.Name)
continue
}
time.Sleep(2 * time.Second)
time.Sleep(1 * time.Second)
}
// join channels
h.JoinChannels()
return
}
@ -568,14 +761,6 @@ func (h *Handler) isValidChannel(channel string) bool {
return true
}
func (h *Handler) setLastPing() {
h.lastPing = time.Now()
}
func (h *Handler) GetLastPing() time.Time {
return h.lastPing
}
// irc line can contain lots of extra stuff like color so lets clean that
func (h *Handler) cleanMessage(message string) string {
var regexMessageClean = `\x0f|\x1f|\x02|\x03(?:[\d]{1,2}(?:,[\d]{1,2})?)?`
@ -588,3 +773,17 @@ func (h *Handler) cleanMessage(message string) string {
return rxp.ReplaceAllString(message, "")
}
func (h *Handler) addConnectError(message string) {
h.m.Lock()
defer h.m.Unlock()
h.connectionErrors = append(h.connectionErrors, message)
}
func (h *Handler) resetConnectErrors() {
h.m.Lock()
defer h.m.Unlock()
h.connectionErrors = []string{}
}

79
internal/irc/service.go
View file

@ -9,6 +9,7 @@ import (
"github.com/autobrr/autobrr/internal/domain"
"github.com/autobrr/autobrr/internal/indexer"
"github.com/autobrr/autobrr/internal/logger"
"github.com/autobrr/autobrr/internal/notification"
"github.com/autobrr/autobrr/internal/release"
"github.com/pkg/errors"
@ -28,24 +29,26 @@ type Service interface {
}
type service struct {
log logger.Logger
repo domain.IrcRepo
releaseService release.Service
indexerService indexer.Service
indexerMap map[string]string
handlers map[handlerKey]*Handler
log logger.Logger
repo domain.IrcRepo
releaseService release.Service
indexerService indexer.Service
notificationService notification.Service
indexerMap map[string]string
handlers map[handlerKey]*Handler
stopWG sync.WaitGroup
lock sync.Mutex
}
func NewService(log logger.Logger, repo domain.IrcRepo, releaseSvc release.Service, indexerSvc indexer.Service) Service {
func NewService(log logger.Logger, repo domain.IrcRepo, releaseSvc release.Service, indexerSvc indexer.Service, notificationSvc notification.Service) Service {
return &service{
log: log,
repo: repo,
releaseService: releaseSvc,
indexerService: indexerSvc,
handlers: make(map[handlerKey]*Handler),
log: log,
repo: repo,
releaseService: releaseSvc,
indexerService: indexerSvc,
notificationService: notificationSvc,
handlers: make(map[handlerKey]*Handler),
}
}
@ -79,7 +82,7 @@ func (s *service) StartHandlers() {
definitions := s.indexerService.GetIndexersByIRCNetwork(network.Server)
// init new irc handler
handler := NewHandler(s.log, network, definitions, s.releaseService)
handler := NewHandler(s.log, network, definitions, s.releaseService, s.notificationService)
// use network.Server + nick to use multiple indexers with different nick per network
// this allows for multiple handlers to one network
@ -135,7 +138,7 @@ func (s *service) startNetwork(network domain.IrcNetwork) error {
definitions := s.indexerService.GetIndexersByIRCNetwork(network.Server)
// init new irc handler
handler := NewHandler(s.log, network, definitions, s.releaseService)
handler := NewHandler(s.log, network, definitions, s.releaseService, s.notificationService)
s.handlers[handlerKey{network.Server, network.NickServ.Account}] = handler
s.lock.Unlock()
@ -198,15 +201,13 @@ func (s *service) checkIfNetworkRestartNeeded(network *domain.IrcNetwork) error
if handler.NickServ.Account != network.NickServ.Account {
s.log.Debug().Msg("changing nick")
err := existingHandler.HandleNickChange(network.NickServ.Account)
if err != nil {
if err := existingHandler.NickChange(network.NickServ.Account); err != nil {
s.log.Error().Stack().Err(err).Msgf("failed to change nick %q", network.NickServ.Account)
}
} else if handler.NickServ.Password != network.NickServ.Password {
s.log.Debug().Msg("nickserv: changing password")
err := existingHandler.HandleNickServIdentify(network.NickServ.Password)
if err != nil {
if err := existingHandler.NickServIdentify(network.NickServ.Password); err != nil {
s.log.Error().Stack().Err(err).Msgf("failed to identify with nickserv %q", network.NickServ.Account)
}
}
@ -252,8 +253,8 @@ func (s *service) checkIfNetworkRestartNeeded(network *domain.IrcNetwork) error
// leave channels
for _, leaveChannel := range channelsToLeave {
s.log.Debug().Msgf("%v: part channel %v", network.Server, leaveChannel)
err := existingHandler.HandlePartChannel(leaveChannel)
if err != nil {
if err := existingHandler.PartChannel(leaveChannel); err != nil {
s.log.Error().Stack().Err(err).Msgf("failed to leave channel: %q", leaveChannel)
}
}
@ -261,8 +262,8 @@ func (s *service) checkIfNetworkRestartNeeded(network *domain.IrcNetwork) error
// join channels
for _, joinChannel := range channelsToJoin {
s.log.Debug().Msgf("%v: join new channel %v", network.Server, joinChannel)
err := existingHandler.HandleJoinChannel(joinChannel.Name, joinChannel.Password)
if err != nil {
if err := existingHandler.JoinChannel(joinChannel.Name, joinChannel.Password); err != nil {
s.log.Error().Stack().Err(err).Msgf("failed to join channel: %q", joinChannel.Name)
}
}
@ -386,17 +387,18 @@ func (s *service) GetNetworksWithHealth(ctx context.Context) ([]domain.IrcNetwor
for _, n := range networks {
netw := domain.IrcNetworkWithHealth{
ID: n.ID,
Name: n.Name,
Enabled: n.Enabled,
Server: n.Server,
Port: n.Port,
TLS: n.TLS,
Pass: n.Pass,
InviteCommand: n.InviteCommand,
NickServ: n.NickServ,
Connected: false,
Channels: []domain.ChannelWithHealth{},
ID: n.ID,
Name: n.Name,
Enabled: n.Enabled,
Server: n.Server,
Port: n.Port,
TLS: n.TLS,
Pass: n.Pass,
InviteCommand: n.InviteCommand,
NickServ: n.NickServ,
Connected: false,
Channels: []domain.ChannelWithHealth{},
ConnectionErrors: []string{},
}
handler, ok := s.handlers[handlerKey{n.Server, n.NickServ.Account}]
@ -404,10 +406,21 @@ func (s *service) GetNetworksWithHealth(ctx context.Context) ([]domain.IrcNetwor
// only set connected and connected since if we have an active handler and connection
if handler.client.Connected() {
handler.m.RLock()
netw.Connected = handler.connected
netw.ConnectedSince = handler.connectedSince
// current and preferred nick is only available if the network is connected
netw.CurrentNick = handler.CurrentNick()
netw.PreferredNick = handler.PreferredNick()
handler.m.RUnlock()
}
// if we have any connection errors like bad nickserv auth add them here
if len(handler.connectionErrors) > 0 {
netw.ConnectionErrors = handler.connectionErrors
}
}
channels, err := s.repo.ListChannels(n.ID)

4
internal/notification/discord.go
View file

@ -140,6 +140,10 @@ func (a *discordSender) buildEmbed(event domain.NotificationEvent, payload domai
color = GRAY
case domain.NotificationEventPushError:
color = RED
case domain.NotificationEventIRCDisconnected:
color = RED
case domain.NotificationEventIRCReconnected:
color = GREEN
case domain.NotificationEventTest:
color = LIGHT_BLUE
}

18
internal/notification/service.go
View file

@ -13,7 +13,7 @@ type Service interface {
Store(ctx context.Context, n domain.Notification) (*domain.Notification, error)
Update(ctx context.Context, n domain.Notification) (*domain.Notification, error)
Delete(ctx context.Context, id int) error
Send(event domain.NotificationEvent, payload domain.NotificationPayload) error
Send(event domain.NotificationEvent, payload domain.NotificationPayload)
Test(ctx context.Context, notification domain.Notification) error
}
@ -109,17 +109,19 @@ func (s *service) registerSenders() {
}
// Send notifications
func (s *service) Send(event domain.NotificationEvent, payload domain.NotificationPayload) error {
func (s *service) Send(event domain.NotificationEvent, payload domain.NotificationPayload) {
s.log.Debug().Msgf("sending notification for %v", string(event))
for _, sender := range s.senders {
// check if sender is active and have notification types
if sender.CanSend(event) {
sender.Send(event, payload)
go func() {
for _, sender := range s.senders {
// check if sender is active and have notification types
if sender.CanSend(event) {
sender.Send(event, payload)
}
}
}
}()
return nil
return
}
func (s *service) Test(ctx context.Context, notification domain.Notification) error {