sqs-browse: new tool

Started working on a new tool to poll and browse an SQS queue.  This is built using a TUI framework

internal/sqs-browse/providers/memstore/memstore.go

@@ -0,0 +1,31 @@
+package memstore
+
+import (
+	"context"
+	"github.com/lmika/awstools/internal/sqs-browse/models"
+	"sync"
+)
+
+type Store struct {
+	messages []models.Message
+
+	mtx *sync.Mutex
+	currSeqNo uint64
+}
+
+func (s *Store) Save(ctx context.Context, msg *models.Message) error {
+	s.mtx.Lock()
+	defer s.mtx.Unlock()
+
+	s.currSeqNo++
+	msg.ID = s.currSeqNo
+	s.messages = append(s.messages, *msg)
+	return nil
+}
+
+func NewStore() *Store {
+	return &Store{
+		messages: make([]models.Message, 0),
+		mtx: new(sync.Mutex),
+	}
+}

internal/sqs-browse/providers/sqs/provider.go

@@ -0,0 +1,63 @@
+package sqs
+
+import (
+	"context"
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/sqs"
+	"github.com/aws/aws-sdk-go-v2/service/sqs/types"
+	"github.com/lmika/awstools/internal/sqs-browse/models"
+	"github.com/pkg/errors"
+	"log"
+	"time"
+)
+
+type Provider struct {
+	client *sqs.Client
+}
+
+func NewProvider(client *sqs.Client) *Provider {
+	return &Provider{client: client}
+}
+
+func (p *Provider) PollForNewMessages(ctx context.Context, queue string) ([]*models.Message, error) {
+	out, err := p.client.ReceiveMessage(ctx, &sqs.ReceiveMessageInput{
+		QueueUrl:            aws.String(queue),
+		MaxNumberOfMessages: 10,
+		WaitTimeSeconds:     20,
+	})
+	if err != nil {
+		return nil, errors.Wrapf(err, "unable to receive messages from queue %v", queue)
+	}
+
+	if len(out.Messages) == 0 {
+		return nil, nil
+	}
+
+	messagesToReturn := make([]*models.Message, 0, len(out.Messages))
+	messagesToDelete := make([]types.DeleteMessageBatchRequestEntry, 0, len(out.Messages))
+	for _, msg := range out.Messages {
+		newLocalMessage := &models.Message{
+			Queue:    queue,
+			ExtID:    aws.ToString(msg.MessageId),
+			Received: time.Now(),
+			Data:     aws.ToString(msg.Body),
+		}
+		messagesToReturn = append(messagesToReturn, newLocalMessage)
+
+		// Pull the message from the queue
+		// TODO: should this be determined by the caller?
+		messagesToDelete = append(messagesToDelete, types.DeleteMessageBatchRequestEntry{
+			Id:            msg.MessageId,
+			ReceiptHandle: msg.ReceiptHandle,
+		})
+	}
+
+	if _, err := p.client.DeleteMessageBatch(ctx, &sqs.DeleteMessageBatchInput{
+		QueueUrl: aws.String(queue),
+		Entries:  messagesToDelete,
+	}); err != nil {
+		log.Printf("error deleting messages from queue: %v", err)
+	}
+
+	return messagesToReturn, nil
+}