How to add items from HTTP request to channel without waiting - go

Question

I'm struggling a bit with understanding concurrency and could use a sanity check. I'm building a notification service and my goal is to have a endpoint in Gin Framework that receives textmessages that my service should send to different protocols (like SMS, email etc.)
My attached simplified code example works but after reading up on pitfalls and caveats with concurrency I'm very unconfident if it's even close to idiomatic.
In the code example Gin has one endpoint, notify, that receives POST request with a json payload. The payload is a json array containing notification objects (just a property with a message string).
Gin binds this array to a slice of pointers for type Notification in Go. Then a Goroutine adds these Notifications to a unbuffered channel Notifier.que. I do this in a Goroutine so that Gin can return status 200 to the HTTP request sender.
The Go application has a simple notification engine with a worker pool that receives Notifications on channel Notifier.que and then calls receiver function Notification.Send().
I have two questions:
1: Is it reasonable to add Notification to the channel Notifier.que using a Goroutine in this way? Can you see any danger with it?
2: Is it ok to have the worker pool inactive while the Notifier.que is empty. Would it be better to close the channel, kill the workers and create a new pool next time notifications is posted?
package main
import (
"fmt"
"net/http"
"time"
"github.com/gin-gonic/gin"
)
// A simple notification sender engine
type Notifier struct {
que chan *Notification // Que of notification to send
workers chan struct{} // Workerpool
}
// Start the notifier engine by generating workers for the pool
func (n *Notifier) Start() {
for i := 0; i < cap(n.workers); i++ {
go n.worker(i + 1)
}
}
// Defining a worker process
func (n *Notifier) worker(id int) {
for {
notification := <-n.que // Listens on channel que
notification.Send(id) // Processes a notification
}
}
// A simplified notification
type Notification struct {
Message string `json:"message"`
}
// Process a notification by calling it's send function
func (n *Notification) Send(workerId int) {
time.Sleep(500 * time.Millisecond)
fmt.Printf("Send '%v' from worker id %v\n", n.Message, workerId)
}
func main() {
// Initiare a notifier engine with four workers in pool
notifier := Notifier{
que: make(chan *Notification),
workers: make(chan struct{}, 4),
}
notifier.Start()
// Start gin engine
r := gin.Default()
r.POST("/notify", func(c *gin.Context) { // Route for POST to /notify
// Get notifications from json body in HTTP POST
var addToQue []*Notification
if err := c.ShouldBindJSON(&addToQue); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
// Generate new notification in the que, without waiting before sending HTTP response
go func() {
for _, notification := range addToQue {
notifier.que <- notification
}
}()
c.JSON(200, gin.H{"message": "OK"})
})
r.Run()
}
A curl request to send 25 notifications
curl --location --request POST '127.0.0.1:8080/notify' \
--header 'Content-Type: application/json' \
--data-raw '[
{"message":"Notice 1"},{"message":"Notice 2"},{"message":"Notice 3"},{"message":"Notice 4"},{"message":"Notice 5"},
{"message":"Notice 6"},{"message":"Notice 7"},{"message":"Notice 8"},{"message":"Notice 9"},{"message":"Notice 10"},
{"message":"Notice 11"},{"message":"Notice 12"},{"message":"Notice 13"},{"message":"Notice 14"},{"message":"Notice 15"},
{"message":"Notice 16"},{"message":"Notice 17"},{"message":"Notice 18"},{"message":"Notice 19"},{"message":"Notice 20"},
{"message":"Notice 21"},{"message":"Notice 22"},{"message":"Notice 23"},{"message":"Notice 24"},{"message":"Notice 25"}
]'