Initial SNS topic / subscription support

builtin/providers/aws/config.go

@@ -18,6 +18,7 @@ import (
 	"github.com/awslabs/aws-sdk-go/service/route53"
 	"github.com/awslabs/aws-sdk-go/service/s3"
 	"github.com/awslabs/aws-sdk-go/service/sqs"
+	"github.com/awslabs/aws-sdk-go/service/sns"
 )
 
 type Config struct {
@@ -37,6 +38,7 @@ type AWSClient struct {
 	autoscalingconn *autoscaling.AutoScaling
 	s3conn          *s3.S3
 	sqsconn         *sqs.SQS
+	snsconn         *sns.SNS
 	r53conn         *route53.Route53
 	region          string
 	rdsconn         *rds.RDS
@@ -89,6 +91,9 @@ func (c *Config) Client() (interface{}, error) {
 		log.Println("[INFO] Initializing SQS connection")
 		client.sqsconn = sqs.New(awsConfig)
 
+		log.Println("[INFO] Initializing SNS connection")
+		client.snsconn = sns.New(awsConfig)
+
 		log.Println("[INFO] Initializing RDS Connection")
 		client.rdsconn = rds.New(awsConfig)
 

builtin/providers/aws/provider.go

@@ -123,6 +123,8 @@ func Provider() terraform.ResourceProvider {
 			"aws_security_group":               resourceAwsSecurityGroup(),
 			"aws_security_group_rule":          resourceAwsSecurityGroupRule(),
 			"aws_sqs_queue":                    resourceAwsSqsQueue(),
+			"aws_sns_topic":                    resourceAwsSnsTopic(),
+			"aws_sns_topic_subscription":       resourceAwsSnsTopicSubscription(),
 			"aws_subnet":                       resourceAwsSubnet(),
 			"aws_vpc_dhcp_options_association": resourceAwsVpcDhcpOptionsAssociation(),
 			"aws_vpc_dhcp_options":             resourceAwsVpcDhcpOptions(),

builtin/providers/aws/resource_aws_sns_topic.go

@@ -0,0 +1,153 @@
+package aws
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/hashicorp/terraform/helper/schema"
+
+	"github.com/awslabs/aws-sdk-go/aws"
+	"github.com/awslabs/aws-sdk-go/service/sns"
+)
+
+// Mutable attributes
+var SNSAttributeMap = map[string]string{
+	"display_name" : "DisplayName",
+	"policy" : "Policy",
+	"delivery_policy": "DeliveryPolicy",
+}
+
+
+func resourceAwsSnsTopic() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceAwsSnsTopicCreate,
+		Read:   resourceAwsSnsTopicRead,
+		Update: resourceAwsSnsTopicUpdate,
+		Delete: resourceAwsSnsTopicDelete,
+
+		Schema: map[string]*schema.Schema{
+			"name": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+			"display_name": &schema.Schema{
+				Type:      schema.TypeString,
+				Optional:  true,
+				ForceNew:  false,
+			},
+			"policy": &schema.Schema{
+				Type:      schema.TypeString,
+				Optional:  true,
+				ForceNew:  false,
+				Computed:  true,
+			},
+			"delivery_policy": &schema.Schema{
+				Type:      schema.TypeString,
+				Optional:  true,
+				ForceNew:  false,
+			},
+			"arn": &schema.Schema{
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+		},
+	}
+}
+
+func resourceAwsSnsTopicCreate(d *schema.ResourceData, meta interface{}) error {
+	snsconn := meta.(*AWSClient).snsconn
+
+	name := d.Get("name").(string)
+
+	log.Printf("[DEBUG] SNS create topic: %s", name)
+
+	req := &sns.CreateTopicInput{
+		Name: aws.String(name),
+	}
+
+	output, err := snsconn.CreateTopic(req)
+	if err != nil {
+		return fmt.Errorf("Error creating SNS topic: %s", err)
+	}
+
+	d.SetId(*output.TopicARN)
+
+	// Write the ARN to the 'arn' field for export
+	d.Set("arn", *output.TopicARN)
+
+	return resourceAwsSnsTopicUpdate(d, meta)
+}
+
+func resourceAwsSnsTopicUpdate(d *schema.ResourceData, meta interface{}) error {
+	snsconn := meta.(*AWSClient).snsconn
+
+	resource := *resourceAwsSnsTopic()
+
+	for k, _ := range resource.Schema {
+		if attrKey, ok := SNSAttributeMap[k]; ok {
+			if d.HasChange(k) {
+				log.Printf("[DEBUG] Updating %s", attrKey)
+				_, n := d.GetChange(k)
+				// Ignore an empty policy
+				if !(k == "policy" && n == "") {
+					// Make API call to update attributes
+					req := &sns.SetTopicAttributesInput{
+						TopicARN: aws.String(d.Id()),
+						AttributeName: aws.String(attrKey),
+						AttributeValue: aws.String(n.(string)),
+					}
+					snsconn.SetTopicAttributes(req)
+				}
+			}
+		}
+	}
+
+	return resourceAwsSnsTopicRead(d, meta)
+}
+
+func resourceAwsSnsTopicRead(d *schema.ResourceData, meta interface{}) error {
+	snsconn := meta.(*AWSClient).snsconn
+
+	attributeOutput, err := snsconn.GetTopicAttributes(&sns.GetTopicAttributesInput{
+		TopicARN: aws.String(d.Id()),
+	})
+
+	if err != nil {
+		return err
+	}
+
+	if attributeOutput.Attributes != nil && len(*attributeOutput.Attributes) > 0 {
+		attrmap := *attributeOutput.Attributes
+		resource := *resourceAwsSnsTopic()
+		// iKey = internal struct key, oKey = AWS Attribute Map key
+		for iKey, oKey := range SNSAttributeMap {
+			log.Printf("[DEBUG] Updating %s => %s", iKey, oKey)
+
+			if attrmap[oKey] != nil {
+				// Some of the fetched attributes are stateful properties such as
+				// the number of subscriptions, the owner, etc. skip those
+				if resource.Schema[iKey] != nil {
+					value := *attrmap[oKey]
+					log.Printf("[DEBUG] Updating %s => %s -> %s", iKey, oKey, value)
+					d.Set(iKey, *attrmap[oKey])
+				}
+			}
+		}
+	}
+
+	return nil
+}
+
+func resourceAwsSnsTopicDelete(d *schema.ResourceData, meta interface{}) error {
+	snsconn := meta.(*AWSClient).snsconn
+
+	log.Printf("[DEBUG] SNS Delete Topic: %s", d.Id())
+	_, err := snsconn.DeleteTopic(&sns.DeleteTopicInput{
+		TopicARN: aws.String(d.Id()),
+	})
+	if err != nil {
+		return err
+	}
+	return nil
+}

builtin/providers/aws/resource_aws_sns_topic_subscription.go

@@ -0,0 +1,181 @@
+package aws
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/hashicorp/terraform/helper/schema"
+
+	"github.com/awslabs/aws-sdk-go/aws"
+	"github.com/awslabs/aws-sdk-go/service/sns"
+)
+
+
+func resourceAwsSnsTopicSubscription() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceAwsSnsTopicSubscriptionCreate,
+		Read:   resourceAwsSnsTopicSubscriptionRead,
+		Update: resourceAwsSnsTopicSubscriptionUpdate,
+		Delete: resourceAwsSnsTopicSubscriptionDelete,
+
+		Schema: map[string]*schema.Schema{
+			"protocol": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: false,
+			},
+			"endpoint": &schema.Schema{
+				Type: 	   schema.TypeString,
+				Required:  true,
+				ForceNew:  false,
+			},
+			"topic_arn": &schema.Schema{
+				Type:      schema.TypeString,
+				Required:  true,
+				ForceNew:  false,
+			},
+			"delivery_policy": &schema.Schema{
+				Type:      schema.TypeString,
+				Optional:  true,
+				ForceNew:  false,
+			},
+			"raw_message_delivery": &schema.Schema{
+				Type:      schema.TypeBool,
+				Optional:  true,
+				ForceNew:  false,
+				Default:   false,
+			},
+			"arn": &schema.Schema{
+				Type:      schema.TypeString,
+				Computed:  true,
+			},
+		},
+	}
+}
+
+func resourceAwsSnsTopicSubscriptionCreate(d *schema.ResourceData, meta interface{}) error {
+	snsconn := meta.(*AWSClient).snsconn
+
+	if(d.Get("protocol") == "email") {
+		return fmt.Errorf("Email endpoints are not supported!")
+	}
+
+	output, err := subscribeToSNSTopic(d, snsconn)
+
+	if err != nil {
+		return err
+	}
+
+	log.Printf("New subscription ARN: %s", *output.SubscriptionARN)
+	d.SetId(*output.SubscriptionARN)
+
+	// Write the ARN to the 'arn' field for export
+	d.Set("arn", *output.SubscriptionARN)
+
+	return resourceAwsSnsTopicSubscriptionUpdate(d, meta)
+}
+
+func resourceAwsSnsTopicSubscriptionUpdate(d *schema.ResourceData, meta interface{}) error {
+	snsconn := meta.(*AWSClient).snsconn
+
+	// If any changes happened, un-subscribe and re-subscribe
+	if d.HasChange("protocol") || d.HasChange("endpoint") || d.HasChange("topic_arn") {
+		log.Printf("[DEBUG] Updating subscription %s", d.Id())
+		// Unsubscribe
+		_, err := snsconn.Unsubscribe(&sns.UnsubscribeInput{
+			SubscriptionARN: aws.String(d.Id()),
+		})
+
+		if err != nil {
+			return fmt.Errorf("Error unsubscribing from SNS topic: %s", err)
+		}
+
+		// Re-subscribe and set id
+		output, err := subscribeToSNSTopic(d, snsconn)
+		d.SetId(*output.SubscriptionARN)
+
+	}
+
+	if d.HasChange("raw_message_delivery") {
+		_, n := d.GetChange("raw_message_delivery")
+
+		attrValue := "false"
+
+		if n.(bool) {
+			attrValue = "true"
+		}
+
+		req := &sns.SetSubscriptionAttributesInput{
+			SubscriptionARN: aws.String(d.Id()),
+			AttributeName: aws.String("RawMessageDelivery"),
+			AttributeValue: aws.String(attrValue),
+		}
+		_, err := snsconn.SetSubscriptionAttributes(req)
+
+		if err != nil {
+			return fmt.Errorf("Unable to set raw message delivery attribute on subscription")
+		}
+	}
+
+	return resourceAwsSnsTopicSubscriptionRead(d, meta)
+}
+
+func resourceAwsSnsTopicSubscriptionRead(d *schema.ResourceData, meta interface{}) error {
+	snsconn := meta.(*AWSClient).snsconn
+
+	log.Printf("[DEBUG] Loading subscription %s", d.Id())
+
+	attributeOutput, err := snsconn.GetSubscriptionAttributes(&sns.GetSubscriptionAttributesInput{
+		SubscriptionARN: aws.String(d.Id()),
+	})
+	if err != nil {
+		return err
+	}
+
+	if attributeOutput.Attributes != nil && len(*attributeOutput.Attributes) > 0 {
+		attrHash := *attributeOutput.Attributes
+		log.Printf("[DEBUG] raw message delivery: %s", *attrHash["RawMessageDelivery"])
+		if *attrHash["RawMessageDelivery"] == "true" {
+			d.Set("raw_message_delivery", true)
+		} else {
+			d.Set("raw_message_delivery", false)
+		}
+	}
+
+	return nil
+}
+
+func resourceAwsSnsTopicSubscriptionDelete(d *schema.ResourceData, meta interface{}) error {
+	snsconn := meta.(*AWSClient).snsconn
+
+	log.Printf("[DEBUG] SNS delete topic subscription: %s", d.Id())
+	_, err := snsconn.Unsubscribe(&sns.UnsubscribeInput{
+		SubscriptionARN: aws.String(d.Id()),
+	})
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func subscribeToSNSTopic(d *schema.ResourceData, snsconn *sns.SNS) (output *sns.SubscribeOutput, err error)  {
+	protocol := d.Get("protocol").(string)
+	endpoint := d.Get("endpoint").(string)
+	topic_arn := d.Get("topic_arn").(string)
+
+	log.Printf("[DEBUG] SNS create topic subscription: %s (%s) @ '%s'", endpoint, protocol, topic_arn)
+
+	req := &sns.SubscribeInput{
+		Protocol: aws.String(protocol),
+		Endpoint: aws.String(endpoint),
+		TopicARN: aws.String(topic_arn),
+	}
+
+	output, err = snsconn.Subscribe(req)
+	if err != nil {
+		return nil, fmt.Errorf("Error creating SNS topic: %s", err)
+	}
+
+	log.Printf("[DEBUG] Created new subscription!")
+	return output, nil
+}