// Get Message Function
// Takes SQS Object, Queue_url, and Message Attributes
// Returns a ReceiveMessageOutput Struct and Errors
func getMessage(queue *sqs.SQS, queue_url *string, message_attributes []*string) (sqs.Message, error) {
// Params object of ReceiveMessageInput Struct
params := &sqs.ReceiveMessageInput{
QueueURL: queue_url,
MessageAttributeNames: message_attributes,
MaxNumberOfMessages: aws.Long(1),
VisibilityTimeout: aws.Long(1),
WaitTimeSeconds: aws.Long(1),
}
resp, err := queue.ReceiveMessage(params)
message := *resp.Messages[0]
return message, err
}
func receive_from_queue(svc *sqs.SQS, queue_url *string) (*string, *string, *string, error) {
// get sqs message
params := &sqs.ReceiveMessageInput{
QueueUrl: queue_url,
MaxNumberOfMessages: aws.Int64(1),
VisibilityTimeout: aws.Int64(1),
}
resp, err := svc.ReceiveMessage(params)
if err != nil { return nil, nil, nil, err }
// error on empty queue
if len(resp.Messages) == 0 { return nil, nil, nil, errors.New("queue is empty") }
receipt_handle := resp.Messages[0].ReceiptHandle
body := resp.Messages[0].Body
// unmarshal sqs message body
data := &SqsBody{}
err = json.Unmarshal([]byte(*body), &data)
if err != nil { return nil, nil, nil, err }
bucket := &data.Records[0].S3.Bucket.Name
key := &data.Records[0].S3.Object.Key
return receipt_handle, bucket, key, nil
}
func receive(qUrl string, svc *sqs.SQS, rx chan msg.Raw) {
for {
param := &sqs.ReceiveMessageInput{
QueueUrl: aws.String(qUrl),
MaxNumberOfMessages: aws.Int64(int64(MaxNumberOfMessages)),
VisibilityTimeout: aws.Int64(int64(VisibilityTimeout)),
WaitTimeSeconds: aws.Int64(int64(WaitTimeSeconds)),
}
r, err := svc.ReceiveMessage(param)
if err != nil {
log.Println("WARN - problem receiving messages from SQS, sleeping, continuing.")
time.Sleep(retry)
continue
}
if (len(r.Messages)) > 0 {
for _, raw := range r.Messages {
m := msg.Raw{
Body: *raw.Body,
ReceiptHandle: *raw.ReceiptHandle,
}
rx <- m
}
}
}
}
func run(svc *sqs.SQS, params *sqs.ReceiveMessageInput) {
for {
resp, err := svc.ReceiveMessage(params)
if err != nil {
fmt.Println("There was an issue receiving a message: ", err)
}
renderIntoTemplate()
if len(resp.Messages) > 0 {
fmt.Printf("\nDisplay received message:\n\n%+v", resp)
}
time.Sleep(5 * time.Second) // message needs to be explicitly deleted still
}
}
func receiveMessage(svc *sqs.SQS, queueURL string) (*sqs.Message, error) {
params := &sqs.ReceiveMessageInput{
QueueUrl: aws.String(queueURL), // Required
MaxNumberOfMessages: aws.Int64(1),
VisibilityTimeout: aws.Int64(1),
WaitTimeSeconds: aws.Int64(1),
}
resp, err := svc.ReceiveMessage(params)
if err != nil {
return nil, err
}
for _, item := range resp.Messages {
return item, nil
}
return nil, nil
}
// receiveMessage receives messages up to count.
func receiveMessage(svc *sqs.SQS, count int64) ([]*sqs.Message, error) {
// create message receiption params
rcvParams := sqs.ReceiveMessageInput{
QueueUrl: queueURL,
MaxNumberOfMessages: aws.Int64(count),
}
// receive message
res, err := svc.ReceiveMessage(&rcvParams)
if err != nil {
return nil, err
}
for i, msg := range res.Messages {
fmt.Printf("message received %v: %v\n", i, *msg.Body)
}
return res.Messages, nil
}
func getMessages(x int, sqssvc *sqs.SQS, wg *sync.WaitGroup) {
defer wg.Done()
params := &sqs.ReceiveMessageInput{
QueueUrl: aws.String("https://sqs.us-west-2.amazonaws.com/123456789098/sqs-queue-name"),
MaxNumberOfMessages: aws.Int64(10),
VisibilityTimeout: aws.Int64(30),
WaitTimeSeconds: aws.Int64(0),
}
resp, err := sqssvc.ReceiveMessage(params)
if err != nil {
log.Printf("error reading from sqs: %v\n", err)
os.Exit(1)
}
log.Printf("routine: %d count: %v\n", x, len(resp.Messages))
for _, message := range resp.Messages {
log.Printf("routine: %d body %s\n", x, *message.Body)
}
}