makes the call to publish message async

server/server.go

···
 		if message == nil {
 			continue
 		}
-		// TODO: this can be done in a go routine because once we've got the message from the publisher, the publisher
-		// doesn't need to wait for us to send the message to all peers
 
-		topic := s.getTopic(message.topic)
-		if topic != nil {
-			topic.sendMessageToSubscribers(message.data)
-		}
+		// sending messages to the subscribers can be done async because the publisher doesn't need to wait for
+		// subscribers to be sent the message
+		go func() {
+			topic := s.getTopic(message.topic)
+			if topic != nil {
+				topic.sendMessageToSubscribers(message.data)
+			}
+		}()
 	}
 }
 

server/server_test.go

···
 	err = binary.Write(publisherConn, binary.BigEndian, Publish)
 	require.NoError(t, err)
 
-	messages := make([][]byte, 0, 10)
+	messages := make([]string, 0, 10)
 	for i := 0; i < 10; i++ {
-		messages = append(messages, []byte(fmt.Sprintf("message %d", i)))
+		messages = append(messages, fmt.Sprintf("message %d", i))
 	}
 
 	subscribeFinCh := make(chan struct{})
···
 	subscriberConn := createConnectionAndSubscribe(t, []string{topicA, topicB})
 	go func() {
 		// check subscriber got all messages
-		for _, msg := range messages {
+		results := make([]string, 0, len(messages))
+		for i := 0; i < len(messages); i++ {
 			var topicLen uint64
 			err = binary.Read(subscriberConn, binary.BigEndian, &topicLen)
 			require.NoError(t, err)
···
 			require.NoError(t, err)
 			require.Equal(t, int(dataLen), n)
 
-			assert.Equal(t, msg, buf)
+			results = append(results, string(buf))
 		}
+
+		assert.ElementsMatch(t, results, messages)
 
 		subscribeFinCh <- struct{}{}
 	}()

server/topic.go

···
 	subscribers := t.subscriptions
 	t.mu.Unlock()
 
-	for addr, subscriber := range subscribers {
-		err := subscriber.peer.RunConnOperation(sendMessageOp(t.name, msgData))
-		if err != nil {
-			slog.Error("failed to send to message", "error", err, "peer", addr)
-			return
-		}
+	var wg sync.WaitGroup
+
+	for _, subscriber := range subscribers {
+		wg.Add(1)
+		sub := subscriber
+		go func() {
+			defer wg.Done()
+			sendMessage(sub, t.name, msgData)
+		}()
+	}
+
+	wg.Wait()
+}
+
+func sendMessage(sub subscriber, topicName string, message []byte) {
+	err := sub.peer.RunConnOperation(sendMessageOp(topicName, message))
+	if err != nil {
+		slog.Error("failed to send to message", "error", err, "peer", sub.peer.Addr())
+		return
 	}
 }