feat(#36): post to multiple slack channels (#38)

* feat(#36): post to multiple slack channels

* fix: restore deleted log message

* fix: adjusting log message

* fix: address review comment

* refactor: join err on channel directly

* refactor: undo channel business

* refactor: move summary and thread msgs out of goroutine

Author: scastlara

internal/patrol/patrol.go

@@ -74,12 +74,10 @@ func (s *sheriffService) Patrol(args config.PatrolConfig) (warn error, err error
 
 	if s.slackService != nil {
 		if len(args.ReportToSlackChannels) > 0 {
-			// TODO #36 support sending to multiple slack channels (for now only the first is sent)
-			log.Info().Str("slackChannel", args.ReportToSlackChannels[0]).Msg("Posting report to slack channel")
-
+			log.Info().Strs("slackChannels", args.ReportToSlackChannels).Msg("Posting report to slack channels")
 			paths := pie.Map(args.Locations, func(v config.ProjectLocation) string { return v.Path })
-			if err := publish.PublishAsGeneralSlackMessage(args.ReportToSlackChannels[0], scanReports, paths, s.slackService); err != nil {
-				log.Error().Err(err).Msg("Failed to post slack report")
+			if err := publish.PublishAsGeneralSlackMessage(args.ReportToSlackChannels, scanReports, paths, s.slackService); err != nil {
+				log.Error().Err(err).Msg("Failed to post slack report to some channels")
 				err = errors.Join(errors.New("failed to post slack report"), err)
 				warn = errors.Join(err, warn)
 			}

internal/publish/to_slack.go

@@ -15,30 +15,34 @@ import (
 	goslack "github.com/slack-go/slack"
 )
 
-// PublishAsGeneralSlackMessage publishes a report of the vulnerabilities scanned to a slack channel
-func PublishAsGeneralSlackMessage(channelName string, reports []scanner.Report, paths []string, s slack.IService) (err error) {
+// PublishAsGeneralSlackMessage publishes a report of the vulnerabilities scanned to a list of slack channels
+func PublishAsGeneralSlackMessage(channelNames []string, reports []scanner.Report, paths []string, s slack.IService) error {
+	var wg sync.WaitGroup
+	errChan := make(chan error, len(channelNames))
 	vulnerableReportsBySeverityKind := groupVulnReportsByMaxSeverityKind(reports)
 
 	summary := formatSummary(vulnerableReportsBySeverityKind, len(reports), paths)
-
-	ts, err := s.PostMessage(channelName, summary...)
-	if err != nil {
-		return errors.Join(errors.New("failed to post slack summary"), err)
+	threadMsgs := formatReportMessage(vulnerableReportsBySeverityKind)
+	for _, slackChannel := range channelNames {
+		log.Info().Str("slackChannel", slackChannel).Msg("Posting report to slack channel")
+		wg.Add(1)
+		go func(errChan chan<- error) {
+			defer wg.Done()
+			if err := publishAsGeneralSlackMessageSingleChannel(slackChannel, summary, threadMsgs, s); err != nil {
+				log.Error().Err(err).Str("slackChannel", slackChannel).Msg("Failed to post slack report")
+				errChan <- err
+			}
+		}(errChan)
 	}
+	wg.Wait()
+	close(errChan)
 
-	msgOptions := formatReportMessage(vulnerableReportsBySeverityKind)
-	for _, option := range msgOptions {
-		_, err = s.PostMessage(
-			channelName,
-			option,
-			goslack.MsgOptionTS(ts), // Replies to the summary message in thread
-		)
-		if err != nil {
-			return errors.Join(errors.New("failed to message in slack summary thread"), err)
-		}
+	var outErr error
+	for err := range errChan {
+		outErr = errors.Join(err, outErr)
 	}
 
-	return
+	return outErr
 }
 
 func PublishAsSpecificChannelSlackMessage(reports []scanner.Report, s slack.IService) (warn error) {
@@ -209,6 +213,26 @@ func formatReportMessage(reportsBySeverityKind map[scanner.SeverityScoreKind][]s
 	return
 }
 
+func publishAsGeneralSlackMessageSingleChannel(channelName string, summary []goslack.MsgOption, threadMsgs []goslack.MsgOption, s slack.IService) (err error) {
+	ts, err := s.PostMessage(channelName, summary...)
+	if err != nil {
+		return errors.Join(errors.New("failed to post slack summary"), err)
+	}
+
+	for _, option := range threadMsgs {
+		_, err = s.PostMessage(
+			channelName,
+			option,
+			goslack.MsgOptionTS(ts), // Replies to the summary message in thread
+		)
+		if err != nil {
+			return errors.Join(errors.New("failed to message in slack summary thread"), err)
+		}
+	}
+
+	return
+}
+
 // splitMessage splits a string into chunks of at most maxLen characters.
 // Each chunk is determined by the closest newline character
 func splitMessage(s string, maxLen int) []string {

internal/publish/to_slack_test.go

@@ -25,7 +25,28 @@ func TestPublishAsGeneralSlackMessage(t *testing.T) {
 		},
 	}
 
-	err := PublishAsGeneralSlackMessage("channel", report, []string{"path/to/group", "path/to/project"}, mockSlackService)
+	err := PublishAsGeneralSlackMessage([]string{"channel"}, report, []string{"path/to/group", "path/to/project"}, mockSlackService)
+
+	assert.Nil(t, err)
+	mockSlackService.AssertExpectations(t)
+}
+
+func TestPublishAsGeneralSlackMessageToMultipleChannel(t *testing.T) {
+	mockSlackService := &mockSlackService{}
+	mockSlackService.On("PostMessage", "channel1", mock.Anything).Return("", nil)
+	mockSlackService.On("PostMessage", "channel2", mock.Anything).Return("", nil)
+	report := []scanner.Report{
+		{
+			IsVulnerable: true,
+			Vulnerabilities: []scanner.Vulnerability{
+				{
+					Id: "CVE-2021-1234",
+				},
+			},
+		},
+	}
+
+	err := PublishAsGeneralSlackMessage([]string{"channel1", "channel2"}, report, []string{"path/to/group", "path/to/project"}, mockSlackService)
 
 	assert.Nil(t, err)
 	mockSlackService.AssertExpectations(t)