SimpleDB domain resource

builtin/providers/aws/config.go

@@ -51,6 +51,7 @@ import (
 	"github.com/aws/aws-sdk-go/service/route53"
 	"github.com/aws/aws-sdk-go/service/s3"
 	"github.com/aws/aws-sdk-go/service/ses"
+	"github.com/aws/aws-sdk-go/service/simpledb"
 	"github.com/aws/aws-sdk-go/service/sns"
 	"github.com/aws/aws-sdk-go/service/sqs"
 	"github.com/aws/aws-sdk-go/service/sts"
@@ -96,6 +97,7 @@ type AWSClient struct {
 	autoscalingconn       *autoscaling.AutoScaling
 	s3conn                *s3.S3
 	sesConn               *ses.SES
+	simpledbconn          *simpledb.SimpleDB
 	sqsconn               *sqs.SQS
 	snsconn               *sns.SNS
 	stsconn               *sts.STS
@@ -219,6 +221,9 @@ func (c *Config) Client() (interface{}, error) {
 		log.Println("[INFO] Initializing SES connection")
 		client.sesConn = ses.New(sess)
 
+		log.Println("[INFO] Initializing SimpleDB connection")
+		client.simpledbconn = simpledb.New(sess)
+
 		log.Println("[INFO] Initializing SQS connection")
 		client.sqsconn = sqs.New(sess)
 

builtin/providers/aws/provider.go

@@ -260,6 +260,7 @@ func Provider() terraform.ResourceProvider {
 			"aws_s3_bucket_notification":                   resourceAwsS3BucketNotification(),
 			"aws_security_group":                           resourceAwsSecurityGroup(),
 			"aws_security_group_rule":                      resourceAwsSecurityGroupRule(),
+			"aws_simpledb_domain":                          resourceAwsSimpleDBDomain(),
 			"aws_spot_instance_request":                    resourceAwsSpotInstanceRequest(),
 			"aws_spot_fleet_request":                       resourceAwsSpotFleetRequest(),
 			"aws_sqs_queue":                                resourceAwsSqsQueue(),

builtin/providers/aws/resource_aws_simpledb_domain.go

@@ -0,0 +1,81 @@
+package aws
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/hashicorp/terraform/helper/schema"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/awserr"
+	"github.com/aws/aws-sdk-go/service/simpledb"
+)
+
+func resourceAwsSimpleDBDomain() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceAwsSimpleDBDomainCreate,
+		Read:   resourceAwsSimpleDBDomainRead,
+		Delete: resourceAwsSimpleDBDomainDelete,
+
+		Schema: map[string]*schema.Schema{
+			"name": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+		},
+	}
+}
+
+func resourceAwsSimpleDBDomainCreate(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).simpledbconn
+
+	name := d.Get("name").(string)
+	input := &simpledb.CreateDomainInput{
+		DomainName: aws.String(name),
+	}
+	_, err := conn.CreateDomain(input)
+	if err != nil {
+		return fmt.Errorf("Create SimpleDB Domain failed: %s", err)
+	}
+
+	d.SetId(name)
+	return nil
+}
+
+func resourceAwsSimpleDBDomainRead(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).simpledbconn
+
+	input := &simpledb.DomainMetadataInput{
+		DomainName: aws.String(d.Id()),
+	}
+	_, err := conn.DomainMetadata(input)
+	if awsErr, ok := err.(awserr.Error); ok {
+		if awsErr.Code() == "NoSuchDomain" {
+			log.Printf("[WARN] Removing SimpleDB domain %q because it's gone.", d.Id())
+			d.SetId("")
+			return nil
+		}
+	}
+	if err != nil {
+		return err
+	}
+
+	d.Set("name", d.Id())
+	return nil
+}
+
+func resourceAwsSimpleDBDomainDelete(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).simpledbconn
+
+	input := &simpledb.DeleteDomainInput{
+		DomainName: aws.String(d.Id()),
+	}
+	_, err := conn.DeleteDomain(input)
+	if err != nil {
+		return fmt.Errorf("Delete SimpleDB Domain failed: %s", err)
+	}
+
+	d.SetId("")
+	return nil
+}

builtin/providers/aws/resource_aws_simpledb_domain_test.go

@@ -0,0 +1,80 @@
+package aws
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/awserr"
+	"github.com/aws/aws-sdk-go/service/simpledb"
+	"github.com/hashicorp/terraform/helper/resource"
+	"github.com/hashicorp/terraform/terraform"
+)
+
+func TestAccAWSSimpleDBDomain_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckAWSSimpleDBDomainDestroy,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccAWSSimpleDBDomainConfig,
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckAWSSimpleDBDomainExists("aws_simpledb_domain.test_domain"),
+				),
+			},
+		},
+	})
+}
+
+func testAccCheckAWSSimpleDBDomainDestroy(s *terraform.State) error {
+	conn := testAccProvider.Meta().(*AWSClient).simpledbconn
+
+	for _, rs := range s.RootModule().Resources {
+		if rs.Type != "aws_simpledb_domain" {
+			continue
+		}
+
+		input := &simpledb.DomainMetadataInput{
+			DomainName: aws.String(rs.Primary.ID),
+		}
+		_, err := conn.DomainMetadata(input)
+		if err == nil {
+			return fmt.Errorf("Domain exists when it should be destroyed!")
+		}
+
+		// Verify the error is an API error, not something else
+		_, ok := err.(awserr.Error)
+		if !ok {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func testAccCheckAWSSimpleDBDomainExists(n string) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		rs, ok := s.RootModule().Resources[n]
+		if !ok {
+			return fmt.Errorf("Not found: %s", n)
+		}
+
+		if rs.Primary.ID == "" {
+			return fmt.Errorf("No SimpleDB domain with that name exists")
+		}
+
+		conn := testAccProvider.Meta().(*AWSClient).simpledbconn
+		input := &simpledb.DomainMetadataInput{
+			DomainName: aws.String(rs.Primary.ID),
+		}
+		_, err := conn.DomainMetadata(input)
+		return err
+	}
+}
+
+var testAccAWSSimpleDBDomainConfig = `
+resource "aws_simpledb_domain" "test_domain" {
+  name = "terraform-test-domain"
+}
+`