Split sending into chained goroutines

main.go

@@ -97,7 +97,8 @@ func main() {
 	logger.Print("Created Telegram Bot API client")
 
 	tgSender := TgSender{bot}
-	go tgSenderWorker(tgEvents, tgSender, &wg, sleeper, log.New(os.Stderr, "TgSender", log.Lmicroseconds))
+	Consume(SendToTg(tgSenderWorker(tgEvents, &wg, sleeper, log.New(os.Stderr, "TgSender", log.Lmicroseconds)),
+		tgSender, &wg, log.New(os.Stderr, "SendToTg", log.Lmicroseconds)))
 	for e := range FilterByLastSeen(s.Events, "hs_wro_last_seen.bin", log.New(os.Stderr, "FilterByLastSeen", log.Lmicroseconds)) {
 		logger.Print("Received change from SATEL: ", e)
 		sendTgMessage(tgEvents, fmt.Sprint("Change from SATEL: type:", e.Type, ", index:", e.Index, ", value:", e.Value), chatIds)

sender_worker.go

@@ -19,15 +19,45 @@ type Sleeper interface {
 	Sleep(ch chan<- interface{})
 }
 
-func tgSenderWorker(tgEvents <-chan GenericMessage, s Sender, wg *sync.WaitGroup, sleeper Sleeper, logger *log.Logger) {
-	logger.Print("Starting")
+func Consume(events <-chan GenericMessage) {
+	go func() {
+		for range events {
+		}
+	}()
+}
+
+func SendToTg(events <-chan GenericMessage, s Sender, wg *sync.WaitGroup, logger *log.Logger) <-chan GenericMessage {
+	returnEvents := make(chan GenericMessage)
+
+	go func() {
 		wg.Add(1)
 		defer wg.Done()
+		for e := range events {
+			returnEvents <- e
+			err := s.Send(e)
+			if err != nil {
+				// TODO: handle it better
+				panic(err)
+			}
+		}
+		close(returnEvents)
+	}()
+
+	return returnEvents
+}
+
+func tgSenderWorker(tgEvents <-chan GenericMessage, wg *sync.WaitGroup, sleeper Sleeper, logger *log.Logger) <-chan GenericMessage {
+	logger.Print("Starting")
 	messagesToSend := make(map[int64]*strings.Builder)
 	waitingStarted := false
 	timeoutEvents := make(chan interface{})
+	returnEvents := make(chan GenericMessage)
 
-loop:
+	go func() {
+		wg.Add(1)
+		defer wg.Done()
+		defer close(returnEvents)
+	loop:
 		for {
 			select {
 			case ev, ok := <-tgEvents:
@@ -50,11 +80,7 @@ loop:
 				logger.Print("Time's up, sending all messages we've got for now.")
 				waitingStarted = false
 				for chatId, msgBuilder := range messagesToSend {
-				err := s.Send(GenericMessage{chatId, msgBuilder.String()})
-				if err != nil {
-					// TODO: handle it better
-					panic(err)
-				}
+					returnEvents <- GenericMessage{chatId, msgBuilder.String()}
 					delete(messagesToSend, chatId)
 				}
 			}
@@ -63,10 +89,9 @@ loop:
 		logger.Print("Exiting")
 		// If anything is left to be sent, send it now
 		for chatId, msgBuilder := range messagesToSend {
-		err := s.Send(GenericMessage{chatId, msgBuilder.String()})
-		if err != nil {
-			// TODO: handle it better
-			panic(err)
-		}
+			returnEvents <- GenericMessage{chatId, msgBuilder.String()}
 		}
+	}()
+
+	return returnEvents
 }

sender_worker_test.go

@@ -35,7 +35,8 @@ func TestMessageThrottling(t *testing.T) {
 	wg := sync.WaitGroup{}
 	mockSender := MockSender{make([]GenericMessage, 0)}
 	mockSleeper := MockSleeper{nil, 0}
-	go tgSenderWorker(testEvents, &mockSender, &wg, &mockSleeper, log.New(io.Discard, "", log.Ltime))
+	Consume(SendToTg(tgSenderWorker(testEvents, &wg, &mockSleeper, log.New(io.Discard, "", log.Ltime)),
+		&mockSender, &wg, log.New(io.Discard, "", log.Ltime)))
 	testEvents <- GenericMessage{123, "test1"}
 	testEvents <- GenericMessage{124, "test3"}
 	testEvents <- GenericMessage{123, "test2"}