FahdShalhoub
84 lines
2.7 KiB
Go
84 lines
2.7 KiB
Go
// Package services holds this service's AWS clients. Discovery reaches exactly
|
|
// one AWS API — the SQS queue subscribed to the catalogue topic — so unlike
|
|
// cms there is no S3 or MediaConvert here, and nothing database-related.
|
|
package services
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
"github.com/aws/aws-sdk-go-v2/service/sqs"
|
|
)
|
|
|
|
var SQSClient SQS
|
|
|
|
// QueueMessage is one message taken off the queue. ReceiptHandle is what
|
|
// identifies it for deletion — it belongs to this delivery, not to the
|
|
// message, so it cannot be held across receives.
|
|
type QueueMessage struct {
|
|
Body string
|
|
ReceiptHandle string
|
|
}
|
|
|
|
type SQS interface {
|
|
ReceiveMessages(ctx context.Context) ([]QueueMessage, error)
|
|
DeleteMessage(ctx context.Context, receiptHandle string) error
|
|
}
|
|
|
|
type SQSConcrete struct {
|
|
SQSClient *sqs.Client
|
|
QueueURL string
|
|
}
|
|
|
|
// receiveWaitSeconds turns every receive into a long poll: the call parks on
|
|
// the server until a message arrives or this elapses, so an event is picked up
|
|
// within milliseconds of being published while an idle consumer costs one
|
|
// request every twenty seconds rather than spinning. 20 is the AWS maximum.
|
|
const receiveWaitSeconds = 20
|
|
|
|
func (svc SQSConcrete) ReceiveMessages(ctx context.Context) ([]QueueMessage, error) {
|
|
output, err := svc.SQSClient.ReceiveMessage(ctx, &sqs.ReceiveMessageInput{
|
|
QueueUrl: &svc.QueueURL,
|
|
MaxNumberOfMessages: 10,
|
|
WaitTimeSeconds: receiveWaitSeconds,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
messages := make([]QueueMessage, 0, len(output.Messages))
|
|
for _, message := range output.Messages {
|
|
if message.Body == nil || message.ReceiptHandle == nil {
|
|
continue
|
|
}
|
|
messages = append(messages, QueueMessage{
|
|
Body: *message.Body,
|
|
ReceiptHandle: *message.ReceiptHandle,
|
|
})
|
|
}
|
|
|
|
return messages, nil
|
|
}
|
|
|
|
// DeleteMessage acknowledges a message. Until this is called the message is
|
|
// merely invisible, and it returns to the queue when its visibility timeout
|
|
// expires — which is how a handler that failed gets another attempt.
|
|
func (svc SQSConcrete) DeleteMessage(ctx context.Context, receiptHandle string) error {
|
|
_, err := svc.SQSClient.DeleteMessage(ctx, &sqs.DeleteMessageInput{
|
|
QueueUrl: &svc.QueueURL,
|
|
ReceiptHandle: &receiptHandle,
|
|
})
|
|
return err
|
|
}
|
|
|
|
// AssertSuccessfulConnection verifies the queue is reachable and readable with
|
|
// the configured credentials. It panics on failure, since a service whose
|
|
// consumer cannot start would serve a catalogue that silently stops growing.
|
|
func (svc SQSConcrete) AssertSuccessfulConnection(ctx context.Context) {
|
|
if _, err := svc.SQSClient.GetQueueAttributes(ctx, &sqs.GetQueueAttributesInput{
|
|
QueueUrl: &svc.QueueURL,
|
|
}); err != nil {
|
|
panic(fmt.Errorf("sqs: cannot connect to queue %q: %w", svc.QueueURL, err))
|
|
}
|
|
}
|