Refactor Senders initialization

integration_tests/notifier/notifier_test.go

@@ -14,9 +14,10 @@ import (
 	logging "github.com/moira-alert/moira/logging/zerolog_adapter"
 	"github.com/moira-alert/moira/metrics"
 	mock_moira_alert "github.com/moira-alert/moira/mock/moira-alert"
-	"github.com/moira-alert/moira/notifier"
+	. "github.com/moira-alert/moira/notifier"
 	"github.com/moira-alert/moira/notifier/events"
 	"github.com/moira-alert/moira/notifier/notifications"
+	. "github.com/smartystreets/goconvey/convey"
 )
 
 var senderSettings = map[string]string{
@@ -26,12 +27,12 @@ var senderSettings = map[string]string{
 var location, _ = time.LoadLocation("UTC")
 var dateTimeFormat = "15:04 02.01.2006"
 
-var notifierConfig = notifier.Config{
+var notifierConfig = Config{
 	SendingTimeout:   time.Millisecond * 10,
 	ResendingTimeout: time.Hour * 24,
 	Location:         location,
 	DateTimeFormat:   dateTimeFormat,
-	ReadBatchSize:    notifier.NotificationsLimitUnlimited,
+	ReadBatchSize:    NotificationsLimitUnlimited,
 }
 
 var shutdown = make(chan struct{})
@@ -78,41 +79,51 @@ var event = moira.NotificationEvent{
 func TestNotifier(t *testing.T) {
 	mockCtrl = gomock.NewController(t)
 	defer mockCtrl.Finish()
-	database := redis.NewTestDatabase(logger)
-	metricsSourceProvider := metricSource.CreateMetricSourceProvider(local.Create(database), nil)
-	database.SaveContact(&contact)               //nolint
-	database.SaveSubscription(&subscription)     //nolint
-	database.SaveTrigger(trigger.ID, &trigger)   //nolint
-	database.PushNotificationEvent(&event, true) //nolint
-	notifier2 := notifier.NewNotifier(database, logger, notifierConfig, notifierMetrics, metricsSourceProvider, map[string]moira.ImageStore{})
-	sender := mock_moira_alert.NewMockSender(mockCtrl)
-	sender.EXPECT().Init(senderSettings, logger, location, dateTimeFormat).Return(nil)
-	notifier2.RegisterSender(senderSettings, sender) //nolint
-	sender.EXPECT().SendEvents(gomock.Any(), contact, triggerData, gomock.Any(), false).Return(nil).Do(func(arg0, arg1, arg2, arg3, arg4 interface{}) {
-		fmt.Print("SendEvents called. End test")
-		close(shutdown)
-	})
 
-	fetchEventsWorker := events.FetchEventsWorker{
-		Database:  database,
-		Logger:    logger,
-		Metrics:   notifierMetrics,
-		Scheduler: notifier.NewScheduler(database, logger, notifierMetrics),
-	}
-
-	fetchNotificationsWorker := notifications.FetchNotificationsWorker{
-		Database: database,
-		Logger:   logger,
-		Notifier: notifier2,
-	}
-
-	fetchEventsWorker.Start()
-	fetchNotificationsWorker.Start()
-
-	waitTestEnd()
-
-	fetchEventsWorker.Stop()        //nolint
-	fetchNotificationsWorker.Stop() //nolint
+	Convey("TestNotifier", t, func() {
+		database := redis.NewTestDatabase(logger)
+		metricsSourceProvider := metricSource.CreateMetricSourceProvider(local.Create(database), nil)
+		err := database.SaveContact(&contact)
+		So(err, ShouldBeNil)
+		err = database.SaveSubscription(&subscription)
+		So(err, ShouldBeNil)
+		err = database.SaveTrigger(trigger.ID, &trigger)
+		So(err, ShouldBeNil)
+		err = database.PushNotificationEvent(&event, true)
+		So(err, ShouldBeNil)
+
+		notifier := NewNotifier(database, logger, notifierConfig, notifierMetrics, metricsSourceProvider, map[string]moira.ImageStore{})
+		sender := mock_moira_alert.NewMockSender(mockCtrl)
+		err = notifier.RegisterSender(senderSettings, sender)
+		So(err, ShouldBeNil)
+		sender.EXPECT().SendEvents(gomock.Any(), contact, triggerData, gomock.Any(), false).Return(nil).Do(func(arg0, arg1, arg2, arg3, arg4 interface{}) {
+			fmt.Print("SendEvents called. End test")
+			close(shutdown)
+		})
+
+		fetchEventsWorker := events.FetchEventsWorker{
+			Database:  database,
+			Logger:    logger,
+			Metrics:   notifierMetrics,
+			Scheduler: NewScheduler(database, logger, notifierMetrics),
+		}
+
+		fetchNotificationsWorker := notifications.FetchNotificationsWorker{
+			Database: database,
+			Logger:   logger,
+			Notifier: notifier,
+		}
+
+		fetchEventsWorker.Start()
+		fetchNotificationsWorker.Start()
+
+		waitTestEnd()
+
+		err = fetchEventsWorker.Stop()
+		So(err, ShouldBeNil)
+		err = fetchNotificationsWorker.Stop()
+		So(err, ShouldBeNil)
+	})
 }
 
 func waitTestEnd() {

interfaces.go

@@ -194,7 +194,6 @@ type Logger interface {
 type Sender interface {
 	// TODO refactor: https://github.com/moira-alert/moira/issues/794
 	SendEvents(events NotificationEvents, contact ContactData, trigger TriggerData, plot [][]byte, throttled bool) error
-	Init(senderSettings map[string]string, logger Logger, location *time.Location, dateTimeFormat string) error
 }
 
 // ImageStore is the interface for image storage providers

notifier/notifier_test.go

@@ -219,11 +219,10 @@ func configureNotifier(t *testing.T) {
 		"type": "test",
 	}
 
-	sender.EXPECT().Init(senderSettings, logger, location, "15:04 02.01.2006").Return(nil)
-
-	notif.RegisterSender(senderSettings, sender) //nolint
-
 	Convey("Should return one sender", t, func() {
+		err := notif.RegisterSender(senderSettings, sender)
+		So(err, ShouldBeNil)
+
 		So(notif.GetSenders(), ShouldResemble, map[string]bool{"test": true})
 	})
 }

notifier/registrator.go

@@ -5,21 +5,21 @@ import (
 	"strings"
 
 	"github.com/moira-alert/moira"
-	"github.com/moira-alert/moira/senders/discord"
-	"github.com/moira-alert/moira/senders/mail"
-	"github.com/moira-alert/moira/senders/mattermost"
-	"github.com/moira-alert/moira/senders/msteams"
-	"github.com/moira-alert/moira/senders/opsgenie"
-	"github.com/moira-alert/moira/senders/pagerduty"
-	"github.com/moira-alert/moira/senders/pushover"
-	"github.com/moira-alert/moira/senders/script"
-	"github.com/moira-alert/moira/senders/selfstate"
-	"github.com/moira-alert/moira/senders/slack"
-	"github.com/moira-alert/moira/senders/telegram"
-	"github.com/moira-alert/moira/senders/twilio"
-	"github.com/moira-alert/moira/senders/victorops"
-	"github.com/moira-alert/moira/senders/webhook"
-	// "github.com/moira-alert/moira/senders/kontur"
+	"github.com/moira-alert/moira/notifier/senders/discord"
+	"github.com/moira-alert/moira/notifier/senders/mail"
+	"github.com/moira-alert/moira/notifier/senders/mattermost"
+	"github.com/moira-alert/moira/notifier/senders/msteams"
+	"github.com/moira-alert/moira/notifier/senders/opsgenie"
+	"github.com/moira-alert/moira/notifier/senders/pagerduty"
+	"github.com/moira-alert/moira/notifier/senders/pushover"
+	"github.com/moira-alert/moira/notifier/senders/script"
+	"github.com/moira-alert/moira/notifier/senders/selfstate"
+	"github.com/moira-alert/moira/notifier/senders/slack"
+	"github.com/moira-alert/moira/notifier/senders/telegram"
+	"github.com/moira-alert/moira/notifier/senders/twilio"
+	"github.com/moira-alert/moira/notifier/senders/victorops"
+	"github.com/moira-alert/moira/notifier/senders/webhook"
+	// "github.com/moira-alert/moira/notifier/senders/kontur"
 )
 
 const (
@@ -40,52 +40,62 @@ const (
 	mattermostSender  = "mattermost"
 )
 
-// RegisterSenders watch on senders config and register all configured senders
+// RegisterSenders creates all senders and registers them.
 func (notifier *StandardNotifier) RegisterSenders(connector moira.Database) error { //nolint
-	var err error
+	var (
+		sender moira.Sender
+		err    error
+	)
+
 	for _, senderSettings := range notifier.config.Senders {
 		senderSettings["front_uri"] = notifier.config.FrontURL
+
 		switch senderSettings["type"] {
 		case mailSender:
-			err = notifier.RegisterSender(senderSettings, &mail.Sender{})
+			sender, err = mail.NewSender(senderSettings, notifier.logger, notifier.config.Location, notifier.config.DateTimeFormat)
 		case pushoverSender:
-			err = notifier.RegisterSender(senderSettings, &pushover.Sender{})
+			sender, err = pushover.NewSender(senderSettings, notifier.logger, notifier.config.Location)
 		case scriptSender:
-			err = notifier.RegisterSender(senderSettings, &script.Sender{})
+			sender, err = script.NewSender(senderSettings, notifier.logger)
 		case discordSender:
-			err = notifier.RegisterSender(senderSettings, &discord.Sender{DataBase: connector})
+			sender, err = discord.NewSender(senderSettings, notifier.logger, notifier.config.Location, connector)
 		case slackSender:
-			err = notifier.RegisterSender(senderSettings, &slack.Sender{})
+			sender, err = slack.NewSender(senderSettings, notifier.logger, notifier.config.Location)
 		case telegramSender:
-			err = notifier.RegisterSender(senderSettings, &telegram.Sender{DataBase: connector})
+			sender, err = telegram.NewSender(senderSettings, notifier.logger, notifier.config.Location, connector)
 		case msTeamsSender:
-			err = notifier.RegisterSender(senderSettings, &msteams.Sender{})
+			sender, err = msteams.NewSender(senderSettings, notifier.logger, notifier.config.Location)
 		case pagerdutySender:
-			err = notifier.RegisterSender(senderSettings, &pagerduty.Sender{ImageStores: notifier.imageStores})
+			sender = pagerduty.NewSender(senderSettings, notifier.logger, notifier.config.Location, notifier.imageStores)
 		case twilioSmsSender, twilioVoiceSender:
-			err = notifier.RegisterSender(senderSettings, &twilio.Sender{})
+			sender, err = twilio.NewSender(senderSettings, notifier.logger, notifier.config.Location)
 		case webhookSender:
-			err = notifier.RegisterSender(senderSettings, &webhook.Sender{})
+			sender, err = webhook.NewSender(senderSettings, notifier.logger)
 		case opsgenieSender:
-			err = notifier.RegisterSender(senderSettings, &opsgenie.Sender{ImageStores: notifier.imageStores})
+			sender, err = opsgenie.NewSender(senderSettings, notifier.logger, notifier.config.Location, notifier.imageStores)
 		case victoropsSender:
-			err = notifier.RegisterSender(senderSettings, &victorops.Sender{ImageStores: notifier.imageStores})
+			sender, err = victorops.NewSender(senderSettings, notifier.logger, notifier.config.Location, notifier.imageStores)
 		case mattermostSender:
-			err = notifier.RegisterSender(senderSettings, &mattermost.Sender{})
+			sender, err = mattermost.NewSender(senderSettings, notifier.config.Location)
 		// case "email":
-		// 	err = notifier.RegisterSender(senderSettings, &kontur.MailSender{})
+		// sender = kontur.NewMailSender(senderSettings, notifier.logger, notifier.config.Location, notifier.config.DateTimeFormat)
 		// case "phone":
-		// 	err = notifier.RegisterSender(senderSettings, &kontur.SmsSender{})
+		// sender = kontur.NewSmsSender(senderSettings, notifier.logger, notifier.config.Location)
 		default:
 			return fmt.Errorf("unknown sender type [%s]", senderSettings["type"])
 		}
 		if err != nil {
-			return err
+			return fmt.Errorf("failed to initialize sender [%s], err [%s]", senderSettings["type"], err.Error())
+		}
+		err = notifier.RegisterSender(senderSettings, sender)
+		if err != nil {
+			return fmt.Errorf("failed to register sender [%s], err [%s]", senderSettings["type"], err.Error())
 		}
 	}
 	if notifier.config.SelfStateEnabled {
 		selfStateSettings := map[string]string{"type": selfStateSender}
-		if err = notifier.RegisterSender(selfStateSettings, &selfstate.Sender{Database: connector}); err != nil {
+		sender := selfstate.NewSender(notifier.logger, connector)
+		if err = notifier.RegisterSender(selfStateSettings, sender); err != nil {
 			notifier.logger.Warningf("failed to register selfstate sender: %s", err.Error())
 		}
 	}
@@ -101,10 +111,7 @@ func (notifier *StandardNotifier) RegisterSender(senderSettings map[string]strin
 	default:
 		senderIdent = senderSettings["type"]
 	}
-	err := sender.Init(senderSettings, notifier.logger, notifier.config.Location, notifier.config.DateTimeFormat)
-	if err != nil {
-		return fmt.Errorf("failed to initialize sender [%s], err [%s]", senderIdent, err.Error())
-	}
+
 	eventsChannel := make(chan NotificationPackage)
 	notifier.senders[senderIdent] = eventsChannel
 	notifier.metrics.SendersOkMetrics.RegisterMeter(senderIdent, getGraphiteSenderIdent(senderIdent), "sends_ok")

senders/discord/send.go → notifier/senders/discord/send.go

@@ -9,7 +9,7 @@ import (
 
 	"github.com/bwmarrin/discordgo"
 	"github.com/moira-alert/moira"
-	"github.com/moira-alert/moira/senders"
+	"github.com/moira-alert/moira/notifier/senders"
 )
 
 const (

senders/discord/init.go → notifier/senders/discord/sender.go

@@ -16,7 +16,8 @@ const (
 	workerName      = "DiscordBot"
 )
 
-// Sender implements moira sender interface for discord
+// Sender implements moira sender interface for Discord.
+// Use NewSender to create instance.
 type Sender struct {
 	DataBase  moira.Database
 	logger    moira.Logger
@@ -26,25 +27,28 @@ type Sender struct {
 	botUserID string
 }
 
-// Init reads the yaml config
-func (sender *Sender) Init(senderSettings map[string]string, logger moira.Logger, location *time.Location, dateTimeFormat string) error {
-	var err error
+// NewSender creates Sender instance.
+func NewSender(senderSettings map[string]string, logger moira.Logger, location *time.Location, db moira.Database) (*Sender, error) {
 	token := senderSettings["token"]
 	if token == "" {
-		return fmt.Errorf("cannot read the discord token from the config")
+		return nil, fmt.Errorf("cannot read the discord token from the config")
 	}
-	sender.session, err = discordgo.New("Bot " + token)
+	session, err := discordgo.New("Bot " + token)
 	if err != nil {
-		return fmt.Errorf("error creating discord session: %s", err)
+		return nil, fmt.Errorf("error creating discord session: %s", err)
 	}
-	sender.logger = logger
-	sender.frontURI = senderSettings["front_uri"]
-	sender.location = location
 
+	sender := &Sender{
+		DataBase: db,
+		session:  session,
+		logger:   logger,
+		frontURI: senderSettings["front_uri"],
+		location: location,
+	}
 	handleMsg := func(s *discordgo.Session, m *discordgo.MessageCreate) {
 		channel, err := s.Channel(m.ChannelID)
 		if err != nil {
-			sender.logger.Errorf("error while getting the channel details: %s", err)
+			logger.Errorf("error while getting the channel details: %s", err)
 		}
 
 		msg, err := sender.getResponse(m, channel)
@@ -56,7 +60,8 @@ func (sender *Sender) Init(senderSettings map[string]string, logger moira.Logger
 	sender.session.AddHandler(handleMsg)
 
 	go sender.runBot()
-	return nil
+
+	return sender, nil
 }
 
 func (sender *Sender) runBot() {