FahdShalhoub
111 lines
3.8 KiB
Go
111 lines
3.8 KiB
Go
// Package consumers holds the queue-driven half of the service: work that
|
|
// arrives on a queue rather than as an HTTP request. It is to SQS what
|
|
// internal/handlers is to HTTP — it decodes a message, calls repositories, and
|
|
// decides what the message's fate is — so the same seams apply, and no SQL
|
|
// lives here.
|
|
package consumers
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"log"
|
|
"strings"
|
|
"thamanyah/discovery/internal/db/repositories"
|
|
"thamanyah/discovery/internal/models"
|
|
"thamanyah/discovery/internal/services"
|
|
"time"
|
|
)
|
|
|
|
// receiveBackoff is how long the loop waits after a failed receive, so a queue
|
|
// that is unreachable produces a slow trickle of log lines rather than a spin.
|
|
const receiveBackoff = 5 * time.Second
|
|
|
|
// announcement is what cms publishes to the catalogue topic when a video
|
|
// becomes ready. It is cms's published contract, mirrored here rather than
|
|
// imported: the two services share no code, and this struct is exactly the
|
|
// coupling between them — so a field renamed on one side has to be renamed
|
|
// here too, deliberately.
|
|
//
|
|
// The subscription delivers raw, so this is the whole message body; there is
|
|
// no SNS envelope to unwrap.
|
|
type announcement struct {
|
|
VideoID string `json:"videoId"`
|
|
Title string `json:"title"`
|
|
PlaybackURL string `json:"playbackUrl"`
|
|
Categories []string `json:"categories"`
|
|
}
|
|
|
|
// CatalogueEvents consumes the announcements cms publishes.
|
|
type CatalogueEvents struct{}
|
|
|
|
// Run consumes announcements until ctx is cancelled. It is meant to be run in
|
|
// its own goroutine for the lifetime of the process.
|
|
func (c CatalogueEvents) Run(ctx context.Context) {
|
|
log.Println("catalogue announcements consumer started")
|
|
|
|
for {
|
|
if ctx.Err() != nil {
|
|
log.Println("catalogue announcements consumer stopped")
|
|
return
|
|
}
|
|
|
|
messages, err := services.SQSClient.ReceiveMessages(ctx)
|
|
if err != nil {
|
|
if ctx.Err() != nil {
|
|
log.Println("catalogue announcements consumer stopped")
|
|
return
|
|
}
|
|
log.Printf("Something Went Wrong Receiving Announcements: %s", err)
|
|
time.Sleep(receiveBackoff)
|
|
continue
|
|
}
|
|
|
|
for _, message := range messages {
|
|
if !c.handleAnnouncement(ctx, message.Body) {
|
|
// Left on the queue on purpose: it becomes visible again when
|
|
// the visibility timeout expires, and reaches the dead-letter
|
|
// queue if it keeps failing.
|
|
continue
|
|
}
|
|
|
|
if err := services.SQSClient.DeleteMessage(ctx, message.ReceiptHandle); err != nil {
|
|
log.Printf("Something Went Wrong Acknowledging An Announcement: %s", err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// handleAnnouncement processes one message and reports whether it is finished
|
|
// with — that is, whether it should be deleted from the queue. It returns
|
|
// false only when a retry could plausibly succeed. Anything a retry cannot fix
|
|
// (a body that will never parse, an announcement naming no video) is finished
|
|
// with, however little it accomplished: leaving it on the queue would only
|
|
// stall the announcements behind it.
|
|
func (c CatalogueEvents) handleAnnouncement(ctx context.Context, body string) bool {
|
|
var announced announcement
|
|
if err := json.Unmarshal([]byte(body), &announced); err != nil {
|
|
log.Printf("Discarding An Announcement That Is Not JSON: %s", err)
|
|
return true
|
|
}
|
|
|
|
if strings.TrimSpace(announced.VideoID) == "" {
|
|
log.Printf("Discarding An Announcement That Names No Video")
|
|
return true
|
|
}
|
|
|
|
if err := repositories.VideoRepo.SaveVideo(ctx, models.Video{
|
|
ID: announced.VideoID,
|
|
Title: announced.Title,
|
|
PlaybackURL: announced.PlaybackURL,
|
|
Categories: announced.Categories,
|
|
}); err != nil {
|
|
// Worth another attempt: the save is an upsert, so a redelivery
|
|
// re-runs it harmlessly.
|
|
log.Printf("Something Went Wrong Saving An Announced Video: video=%q: %s", announced.VideoID, err)
|
|
return false
|
|
}
|
|
|
|
log.Printf("Catalogued An Announced Video: video=%q title=%q", announced.VideoID, announced.Title)
|
|
return true
|
|
}
|