func findExistingTopicARN(config *aws.Config, topic string) (string, error) {
svc := sns.New(nil)
params := &sns.ListTopicsInput{
NextToken: nil,
}
for {
resp, err := svc.ListTopics(params)
if awserr, ok := err.(awserr.Error); ok {
return "", fmt.Errorf("aws error while listing SNS topics: %v %v", awserr.Code(), awserr.Message())
} else if err != nil {
return "", fmt.Errorf("error while listing SNS topics: %v", err)
} else if resp == nil || resp.Topics == nil {
break
}
for _, topicPtr := range resp.Topics {
if topicPtr != nil && topicPtr.TopicArn != nil && strings.HasSuffix(*topicPtr.TopicArn, topic) {
return *topicPtr.TopicArn, nil
}
}
if resp.NextToken != nil {
params.NextToken = resp.NextToken
} else {
break
}
}
return "", nil
}
func createTopic(config *aws.Config, topic string) (string, error) {
svc := sns.New(config)
params := &sns.CreateTopicInput{
Name: aws.String(topic),
}
resp, err := svc.CreateTopic(params)
if awserr, ok := err.(awserr.Error); ok {
return "", fmt.Errorf("aws error while creating SNS topic: %v %v", awserr.Code(), awserr.Message())
} else if err != nil {
return "", fmt.Errorf("error while creating SNS topic: %v", err)
} else if resp == nil || resp.TopicArn == nil {
return "", nil
}
return *resp.TopicArn, nil
}
func createQueue(config *aws.Config, queue string) (string, error) {
svc := sqs.New(config)
params := &sqs.CreateQueueInput{
QueueName: aws.String(queue),
Attributes: map[string]*string{
"ReceiveMessageWaitTimeSeconds": aws.String("5"),
},
}
resp, err := svc.CreateQueue(params)
if awserr, ok := err.(awserr.Error); ok {
return "", fmt.Errorf("aws error while creating SQS queue: %v %v", awserr.Code(), awserr.Message())
} else if err != nil {
return "", fmt.Errorf("error while creating SQS queue: %v", err)
} else if resp == nil || resp.QueueUrl == nil {
return "", nil
}
return *resp.QueueUrl, nil
}
func findSubscription(config *aws.Config, topicARN, queueARN string) (string, error) {
svc := sns.New(config)
params := &sns.ListSubscriptionsByTopicInput{
TopicArn: aws.String(topicARN),
}
for {
resp, err := svc.ListSubscriptionsByTopic(params)
if awserr, ok := err.(awserr.Error); ok {
return "", fmt.Errorf("aws error while listing subscriptions to SNS topic: %v %v", awserr.Code(), awserr.Message())
} else if err != nil {
return "", fmt.Errorf("error while listing subscriptions to SNS topic: %v", err)
} else if resp == nil || resp.Subscriptions == nil {
break
}
for _, sub := range resp.Subscriptions {
if sub.Endpoint != nil && *sub.Endpoint == queueARN && sub.Protocol != nil && *sub.Protocol == "sqs" && sub.SubscriptionArn != nil {
return *sub.SubscriptionArn, nil
}
}
if resp.NextToken != nil {
params.NextToken = resp.NextToken
} else {
break
}
}
return "", nil
}
func createSubscription(config *aws.Config, topicARN, queueARN string) (string, error) {
svc := sns.New(config)
params := &sns.SubscribeInput{
Protocol: aws.String("sqs"),
TopicArn: aws.String(topicARN),
Endpoint: aws.String(queueARN),
}
resp, err := svc.Subscribe(params)
if awserr, ok := err.(awserr.Error); ok {
return "", fmt.Errorf("aws error while creating subscription to SNS topic: %v %v", awserr.Code(), awserr.Message())
} else if err != nil {
return "", fmt.Errorf("error while creating subscription to SNS topic: %v", err)
} else if resp == nil || resp.SubscriptionArn == nil {
return "", fmt.Errorf("error while creating subscription to SNS topic")
}
return *resp.SubscriptionArn, nil
}
func resourceAwsS3BucketNotificationPut(d *schema.ResourceData, meta interface{}) error {
s3conn := meta.(*AWSClient).s3conn
bucket := d.Get("bucket").(string)
// TopicNotifications
topicNotifications := d.Get("topic").([]interface{})
topicConfigs := make([]*s3.TopicConfiguration, 0, len(topicNotifications))
for i, c := range topicNotifications {
tc := &s3.TopicConfiguration{}
c := c.(map[string]interface{})
// Id
if val, ok := c["id"].(string); ok && val != "" {
tc.Id = aws.String(val)
} else {
tc.Id = aws.String(resource.PrefixedUniqueId("tf-s3-topic-"))
}
// TopicArn
if val, ok := c["topic_arn"].(string); ok {
tc.TopicArn = aws.String(val)
}
// Events
events := d.Get(fmt.Sprintf("topic.%d.events", i)).(*schema.Set).List()
tc.Events = make([]*string, 0, len(events))
for _, e := range events {
tc.Events = append(tc.Events, aws.String(e.(string)))
}
// Filter
filterRules := make([]*s3.FilterRule, 0, 2)
if val, ok := c["filter_prefix"].(string); ok && val != "" {
filterRule := &s3.FilterRule{
Name: aws.String("prefix"),
Value: aws.String(val),
}
filterRules = append(filterRules, filterRule)
}
if val, ok := c["filter_suffix"].(string); ok && val != "" {
filterRule := &s3.FilterRule{
Name: aws.String("suffix"),
Value: aws.String(val),
}
filterRules = append(filterRules, filterRule)
}
if len(filterRules) > 0 {
tc.Filter = &s3.NotificationConfigurationFilter{
Key: &s3.KeyFilter{
FilterRules: filterRules,
},
}
}
topicConfigs = append(topicConfigs, tc)
}
// SQS
queueNotifications := d.Get("queue").([]interface{})
queueConfigs := make([]*s3.QueueConfiguration, 0, len(queueNotifications))
for i, c := range queueNotifications {
qc := &s3.QueueConfiguration{}
c := c.(map[string]interface{})
// Id
if val, ok := c["id"].(string); ok && val != "" {
qc.Id = aws.String(val)
} else {
qc.Id = aws.String(resource.PrefixedUniqueId("tf-s3-queue-"))
}
// QueueArn
if val, ok := c["queue_arn"].(string); ok {
qc.QueueArn = aws.String(val)
}
// Events
events := d.Get(fmt.Sprintf("queue.%d.events", i)).(*schema.Set).List()
qc.Events = make([]*string, 0, len(events))
for _, e := range events {
qc.Events = append(qc.Events, aws.String(e.(string)))
}
// Filter
filterRules := make([]*s3.FilterRule, 0, 2)
if val, ok := c["filter_prefix"].(string); ok && val != "" {
filterRule := &s3.FilterRule{
Name: aws.String("prefix"),
Value: aws.String(val),
}
filterRules = append(filterRules, filterRule)
}
if val, ok := c["filter_suffix"].(string); ok && val != "" {
filterRule := &s3.FilterRule{
Name: aws.String("suffix"),
Value: aws.String(val),
}
filterRules = append(filterRules, filterRule)
}
if len(filterRules) > 0 {
qc.Filter = &s3.NotificationConfigurationFilter{
Key: &s3.KeyFilter{
FilterRules: filterRules,
},
}
}
queueConfigs = append(queueConfigs, qc)
}
// Lambda
lambdaFunctionNotifications := d.Get("lambda_function").([]interface{})
lambdaConfigs := make([]*s3.LambdaFunctionConfiguration, 0, len(lambdaFunctionNotifications))
for i, c := range lambdaFunctionNotifications {
lc := &s3.LambdaFunctionConfiguration{}
c := c.(map[string]interface{})
// Id
if val, ok := c["id"].(string); ok && val != "" {
lc.Id = aws.String(val)
} else {
lc.Id = aws.String(resource.PrefixedUniqueId("tf-s3-lambda-"))
}
// LambdaFunctionArn
if val, ok := c["lambda_function_arn"].(string); ok {
lc.LambdaFunctionArn = aws.String(val)
}
// Events
events := d.Get(fmt.Sprintf("lambda_function.%d.events", i)).(*schema.Set).List()
lc.Events = make([]*string, 0, len(events))
for _, e := range events {
lc.Events = append(lc.Events, aws.String(e.(string)))
}
// Filter
filterRules := make([]*s3.FilterRule, 0, 2)
if val, ok := c["filter_prefix"].(string); ok && val != "" {
filterRule := &s3.FilterRule{
Name: aws.String("prefix"),
Value: aws.String(val),
}
filterRules = append(filterRules, filterRule)
}
if val, ok := c["filter_suffix"].(string); ok && val != "" {
filterRule := &s3.FilterRule{
Name: aws.String("suffix"),
Value: aws.String(val),
}
filterRules = append(filterRules, filterRule)
}
if len(filterRules) > 0 {
lc.Filter = &s3.NotificationConfigurationFilter{
Key: &s3.KeyFilter{
FilterRules: filterRules,
},
}
}
lambdaConfigs = append(lambdaConfigs, lc)
}
notificationConfiguration := &s3.NotificationConfiguration{}
if len(lambdaConfigs) > 0 {
notificationConfiguration.LambdaFunctionConfigurations = lambdaConfigs
}
if len(queueConfigs) > 0 {
notificationConfiguration.QueueConfigurations = queueConfigs
}
if len(topicConfigs) > 0 {
notificationConfiguration.TopicConfigurations = topicConfigs
}
i := &s3.PutBucketNotificationConfigurationInput{
Bucket: aws.String(bucket),
NotificationConfiguration: notificationConfiguration,
}
log.Printf("[DEBUG] S3 bucket: %s, Putting notification: %v", bucket, i)
err := resource.Retry(1*time.Minute, func() *resource.RetryError {
if _, err := s3conn.PutBucketNotificationConfiguration(i); err != nil {
if awserr, ok := err.(awserr.Error); ok {
switch awserr.Message() {
case "Unable to validate the following destination configurations":
return resource.RetryableError(awserr)
}
}
// Didn't recognize the error, so shouldn't retry.
return resource.NonRetryableError(err)
}
// Successful put configuration
return nil
})
if err != nil {
return fmt.Errorf("Error putting S3 notification configuration: %s", err)
}
d.SetId(bucket)
return resourceAwsS3BucketNotificationRead(d, meta)
}
func setPolicy(key, secret, region, queueARN, queueURL string, topicARNs []string) error {
svc := sqs.New(getConfig(key, secret, region))
bs, err := json.Marshal(topicARNs)
if err != nil {
return fmt.Errorf("error while creating policy for SQS queue: %v", err)
}
policy := fmt.Sprintf(policyFormat, queueARN, string(bs))
params := &sqs.SetQueueAttributesInput{
Attributes: map[string]*string{
"Policy": aws.String(policy),
},
QueueUrl: aws.String(queueURL),
}
_, err = svc.SetQueueAttributes(params)
if awserr, ok := err.(awserr.Error); ok {
return fmt.Errorf("aws error while setting policy for SQS queue: %v %v", awserr.Code(), awserr.Message())
} else if err != nil {
return fmt.Errorf("error while setting policy for SQS queue: %v", err)
}
return nil
}
func deleteMessage(config *aws.Config, queueURL string, receiptHandle string) error {
svc := sqs.New(config)
params := &sqs.DeleteMessageInput{
QueueUrl: aws.String(queueURL),
ReceiptHandle: aws.String(receiptHandle),
}
_, err := svc.DeleteMessage(params)
if awserr, ok := err.(awserr.Error); ok {
return fmt.Errorf("aws error while deleting message from SQS: %v %v", awserr.Code(), awserr.Message())
} else if err != nil {
return fmt.Errorf("error while deleting message from SQS: %v", err)
}
return nil
}
func getMessage(config *aws.Config, queueURL string) (*sqs.Message, error) {
svc := sqs.New(config)
params := &sqs.ReceiveMessageInput{
QueueUrl: aws.String(queueURL),
MaxNumberOfMessages: aws.Int64(1),
}
resp, err := svc.ReceiveMessage(params)
if awserr, ok := err.(awserr.Error); ok {
return nil, fmt.Errorf("aws error while receiving message from SQS: %v %v", awserr.Code(), awserr.Message())
} else if err != nil {
return nil, fmt.Errorf("error while receiving message from SQS: %v", err)
} else if resp == nil || len(resp.Messages) == 0 {
return nil, nil
}
return resp.Messages[0], nil
}
func getARNForQueueURL(config *aws.Config, queueURL string) (string, error) {
svc := sqs.New(config)
arnKey := "QueueArn"
params := &sqs.GetQueueAttributesInput{
QueueUrl: aws.String(string(queueURL)),
AttributeNames: []*string{
aws.String(arnKey),
},
}
resp, err := svc.GetQueueAttributes(params)
if awserr, ok := err.(awserr.Error); ok {
return "", fmt.Errorf("aws error while getting ARN for SQS queue: %v %v", awserr.Code(), awserr.Message())
} else if err != nil {
return "", fmt.Errorf("error while getting ARN for SQS queue: %v", err)
} else if resp == nil || resp.Attributes == nil {
return "", nil
}
atts := resp.Attributes
arnPtr, ok := atts[arnKey]
if !ok || arnPtr == nil {
return "", nil
}
return *arnPtr, nil
}
func getQueueURLByName(config *aws.Config, queue string) (string, error) {
svc := sqs.New(config)
params := &sqs.GetQueueUrlInput{
QueueName: aws.String(queue),
}
resp, err := svc.GetQueueUrl(params)
if awserr, ok := err.(awserr.Error); ok {
return "", fmt.Errorf("aws error while getting URL for SQS queue: %v %v", awserr.Code(), awserr.Message())
} else if err != nil {
return "", fmt.Errorf("error while getting URL for SQS queue: %v", err)
} else if resp == nil || resp.QueueUrl == nil {
return "", nil
}
return *resp.QueueUrl, nil
}