// Check to see if we have a message on the queue func (s *Sqs) recieve() int { if s.svc == nil { s.svc = sqs.New(&aws.Config{Region: s.Region}) } params := &sqs.ReceiveMessageInput{ QueueURL: aws.String(s.Url), MaxNumberOfMessages: aws.Long(10), } resp, err := s.svc.ReceiveMessage(params) if err != nil { // A non-service error occurred. s.Log.Error(err.Error()) return 0 } numMsg := len(resp.Messages) if numMsg == 0 { return 0 } for _, element := range resp.Messages { s.processRaw(*element.Body) s.remove(element) } return numMsg }
func ExampleSQS_ChangeMessageVisibilityBatch() { svc := sqs.New(nil) params := &sqs.ChangeMessageVisibilityBatchInput{ Entries: []*sqs.ChangeMessageVisibilityBatchRequestEntry{ // Required &sqs.ChangeMessageVisibilityBatchRequestEntry{ // Required ID: aws.String("String"), // Required ReceiptHandle: aws.String("String"), // Required VisibilityTimeout: aws.Long(1), }, // More values... }, QueueURL: aws.String("String"), // Required } resp, err := svc.ChangeMessageVisibilityBatch(params) if err != nil { if awsErr, ok := err.(awserr.Error); ok { // Generic AWS Error with Code, Message, and original error (if any) fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr()) if reqErr, ok := err.(awserr.RequestFailure); ok { // A service error occurred fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID()) } } else { // This case should never be hit, The SDK should alwsy return an // error which satisfies the awserr.Error interface. fmt.Println(err.Error()) } } // Pretty-print the response data. fmt.Println(awsutil.StringValue(resp)) }
func ExampleSQS_SetQueueAttributes() { svc := sqs.New(nil) params := &sqs.SetQueueAttributesInput{ Attributes: &map[string]*string{ // Required "Key": aws.String("String"), // Required // More values... }, QueueURL: aws.String("String"), // Required } resp, err := svc.SetQueueAttributes(params) if err != nil { if awsErr, ok := err.(awserr.Error); ok { // Generic AWS Error with Code, Message, and original error (if any) fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr()) if reqErr, ok := err.(awserr.RequestFailure); ok { // A service error occurred fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID()) } } else { // This case should never be hit, The SDK should alwsy return an // error which satisfies the awserr.Error interface. fmt.Println(err.Error()) } } // Pretty-print the response data. fmt.Println(awsutil.StringValue(resp)) }
func ExampleSQS_GetQueueURL() { svc := sqs.New(nil) params := &sqs.GetQueueURLInput{ QueueName: aws.String("String"), // Required QueueOwnerAWSAccountID: aws.String("String"), } resp, err := svc.GetQueueURL(params) if err != nil { if awsErr, ok := err.(awserr.Error); ok { // Generic AWS Error with Code, Message, and original error (if any) fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr()) if reqErr, ok := err.(awserr.RequestFailure); ok { // A service error occurred fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID()) } } else { // This case should never be hit, The SDK should alwsy return an // error which satisfies the awserr.Error interface. fmt.Println(err.Error()) } } // Pretty-print the response data. fmt.Println(awsutil.StringValue(resp)) }
// deleteSQS removes a completed notification from the queue func (c *config) deleteSQS(receiptHandle *string) error { q := sqs.New(&c.awsConfig) req := sqs.DeleteMessageInput{ QueueURL: aws.String(c.queueURL), ReceiptHandle: aws.String(*receiptHandle), } _, err := q.DeleteMessage(&req) if err != nil { return err } return nil }
// deleteSQS removes a completed notification from the queue func (c *config) deleteSQS(m *cloudtrailNotification) error { q := sqs.New(&c.awsConfig) req := sqs.DeleteMessageInput{ QueueURL: aws.String(c.queueURL), ReceiptHandle: aws.String(m.ReceiptHandle), } _, err := q.DeleteMessage(&req) if err != nil { return err } return nil }
func ExampleSQS_SendMessageBatch() { svc := sqs.New(nil) params := &sqs.SendMessageBatchInput{ Entries: []*sqs.SendMessageBatchRequestEntry{ // Required &sqs.SendMessageBatchRequestEntry{ // Required ID: aws.String("String"), // Required MessageBody: aws.String("String"), // Required DelaySeconds: aws.Long(1), MessageAttributes: &map[string]*sqs.MessageAttributeValue{ "Key": &sqs.MessageAttributeValue{ // Required DataType: aws.String("String"), // Required BinaryListValues: [][]byte{ []byte("PAYLOAD"), // Required // More values... }, BinaryValue: []byte("PAYLOAD"), StringListValues: []*string{ aws.String("String"), // Required // More values... }, StringValue: aws.String("String"), }, // More values... }, }, // More values... }, QueueURL: aws.String("String"), // Required } resp, err := svc.SendMessageBatch(params) if err != nil { if awsErr, ok := err.(awserr.Error); ok { // Generic AWS Error with Code, Message, and original error (if any) fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr()) if reqErr, ok := err.(awserr.RequestFailure); ok { // A service error occurred fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID()) } } else { // This case should never be hit, The SDK should alwsy return an // error which satisfies the awserr.Error interface. fmt.Println(err.Error()) } } // Pretty-print the response data. fmt.Println(awsutil.StringValue(resp)) }
func TestFlattenedTraits(t *testing.T) { s := sqs.New(nil) _, err := s.DeleteMessageBatch(&sqs.DeleteMessageBatchInput{ QueueURL: aws.String("QUEUE"), Entries: []*sqs.DeleteMessageBatchRequestEntry{ &sqs.DeleteMessageBatchRequestEntry{ ID: aws.String("TEST"), ReceiptHandle: aws.String("RECEIPT"), }, }, }) assert.Error(t, err) assert.Equal(t, "InvalidAddress", err.Code()) assert.Equal(t, "The address QUEUE is not valid for this endpoint.", err.Message()) }
// dequeue fetches an item from SQS func (c *config) dequeue() (*cloudtrailNotificationRecord, error) { numRequested := 1 q := sqs.New(&c.awsConfig) req := sqs.ReceiveMessageInput{ QueueURL: aws.String(c.queueURL), MaxNumberOfMessages: aws.Long(int64(numRequested)), WaitTimeSeconds: aws.Long(20), // max allowed } resp, err := q.ReceiveMessage(&req) if err != nil { return nil, fmt.Errorf("SQS ReceiveMessage error: %s", err.Error()) } //c.debug("Received %d messsage from SQS.", len(resp.Messages)) if len(resp.Messages) > numRequested { return nil, fmt.Errorf("Expected %d but got %d messages.", numRequested, len(resp.Messages)) } else if len(resp.Messages) == 0 { return nil, nil } m := resp.Messages[0] body := *m.Body not := sqsNotification{} if err := json.Unmarshal([]byte(body), ¬); err != nil { return nil, fmt.Errorf("SQS message JSON error [id: %s]: %s", not.MessageID, err.Error()) } n := cloudtrailNotification{} if not.Message == "CloudTrail validation message." { // swallow validation messages if err = c.deleteSQS(m.ReceiptHandle); err != nil { return nil, fmt.Errorf("Error deleting CloudTrail validation message [id: %s]: %s", not.MessageID, err.Error()) } return nil, fmt.Errorf("Deleted CloudTrail validation message id %s", not.MessageID) } else if err := json.Unmarshal([]byte(not.Message), &n); err != nil { kerblowie(fmt.Sprintf("CloudTrail JSON error [id: %s]: %s", not.MessageID, err.Error())) // return nil, fmt.Errorf("CloudTrail JSON error [id: %s]: %s", not.MessageID, err.Error()) } record := n.Records[0] record.MessageID = not.MessageID record.ReceiptHandle = *m.ReceiptHandle b, err := json.Marshal(record) c.debug(string(b)) return &record, nil }
// Satisfies the Listener interface and places the event on an AWS SQS func (this *Sqs) Exec(evt event.Event) { this.Log.Handler(this, &evt) url := magicString(this.Config.GetUrl(), evt) reg := magicString(this.Config.GetRegion(), evt) msg := magicString(this.Config.GetMessage(), evt) svc := sqs.New(&aws.Config{Region: reg}) params := &sqs.SendMessageInput{ MessageBody: aws.String(msg), QueueURL: aws.String(url), } _, err := svc.SendMessage(params) if err != nil { this.Log.Error(err.Error()) return } }
func TestSendMessageChecksumInvalidNoValidation(t *testing.T) { s := sqs.New(&aws.Config{ DisableParamValidation: true, DisableComputeChecksums: true, }) s.Handlers.Send.Clear() req, _ := s.SendMessageRequest(&sqs.SendMessageInput{ MessageBody: aws.String("test"), }) req.Handlers.Send.PushBack(func(r *aws.Request) { body := ioutil.NopCloser(bytes.NewReader([]byte(""))) r.HTTPResponse = &http.Response{StatusCode: 200, Body: body} r.Data = &sqs.SendMessageOutput{ MD5OfMessageBody: aws.String("000"), MessageID: aws.String("12345"), } }) err := req.Send() assert.NoError(t, err) }
func ExampleSQS_ReceiveMessage() { svc := sqs.New(nil) params := &sqs.ReceiveMessageInput{ QueueURL: aws.String("String"), // Required AttributeNames: []*string{ aws.String("QueueAttributeName"), // Required // More values... }, MaxNumberOfMessages: aws.Long(1), MessageAttributeNames: []*string{ aws.String("MessageAttributeName"), // Required // More values... }, VisibilityTimeout: aws.Long(1), WaitTimeSeconds: aws.Long(1), } resp, err := svc.ReceiveMessage(params) if err != nil { if awsErr, ok := err.(awserr.Error); ok { // Generic AWS Error with Code, Message, and original error (if any) fmt.Println(awsErr.Code(), awsErr.Message(), awsErr.OrigErr()) if reqErr, ok := err.(awserr.RequestFailure); ok { // A service error occurred fmt.Println(reqErr.Code(), reqErr.Message(), reqErr.StatusCode(), reqErr.RequestID()) } } else { // This case should never be hit, The SDK should alwsy return an // error which satisfies the awserr.Error interface. fmt.Println(err.Error()) } } // Pretty-print the response data. fmt.Println(awsutil.StringValue(resp)) }
"io/ioutil" "net/http" "testing" "github.com/awslabs/aws-sdk-go/aws" "github.com/awslabs/aws-sdk-go/aws/awserr" "github.com/awslabs/aws-sdk-go/internal/test/unit" "github.com/awslabs/aws-sdk-go/service/sqs" "github.com/stretchr/testify/assert" ) var _ = unit.Imported var svc = func() *sqs.SQS { s := sqs.New(&aws.Config{ DisableParamValidation: true, }) s.Handlers.Send.Clear() return s }() func TestSendMessageChecksum(t *testing.T) { req, _ := svc.SendMessageRequest(&sqs.SendMessageInput{ MessageBody: aws.String("test"), }) req.Handlers.Send.PushBack(func(r *aws.Request) { body := ioutil.NopCloser(bytes.NewReader([]byte(""))) r.HTTPResponse = &http.Response{StatusCode: 200, Body: body} r.Data = &sqs.SendMessageOutput{ MD5OfMessageBody: aws.String("098f6bcd4621d373cade4e832627b4f6"), MessageID: aws.String("12345"),
func init() { Before("@sqs", func() { World["client"] = sqs.New(nil) }) }
func TestInterface(t *testing.T) { assert.Implements(t, (*sqsiface.SQSAPI)(nil), sqs.New(nil)) }