r/aws_backup_selection: Adding resource to manage selections for AWS Backup plans

aws/provider.go

@@ -326,6 +326,7 @@ func Provider() terraform.ResourceProvider {
 			"aws_autoscaling_policy":                           resourceAwsAutoscalingPolicy(),
 			"aws_autoscaling_schedule":                         resourceAwsAutoscalingSchedule(),
 			"aws_backup_plan":                                  resourceAwsBackupPlan(),
+			"aws_backup_selection":                             resourceAwsBackupSelection(),
 			"aws_backup_vault":                                 resourceAwsBackupVault(),
 			"aws_budgets_budget":                               resourceAwsBudgetsBudget(),
 			"aws_cloud9_environment_ec2":                       resourceAwsCloud9EnvironmentEc2(),

aws/resource_aws_backup_selection.go

@@ -0,0 +1,182 @@
+package aws
+
+import (
+	"bytes"
+	"fmt"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/backup"
+	"github.com/hashicorp/terraform/helper/hashcode"
+	"github.com/hashicorp/terraform/helper/schema"
+)
+
+func resourceAwsBackupSelection() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceAwsBackupSelectionCreate,
+		Read:   resourceAwsBackupSelectionRead,
+		Delete: resourceAwsBackupSelectionDelete,
+
+		Schema: map[string]*schema.Schema{
+			"name": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+			"plan_id": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+			"iam_role": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+			"tag": {
+				Type:     schema.TypeSet,
+				Optional: true,
+				ForceNew: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"type": {
+							Type:     schema.TypeString,
+							Required: true,
+						},
+						"key": {
+							Type:     schema.TypeString,
+							Required: true,
+						},
+						"value": {
+							Type:     schema.TypeString,
+							Required: true,
+						},
+					},
+				},
+				Set: resourceAwsConditionTagHash,
+			},
+			"resources": {
+				Type:     schema.TypeList,
+				Optional: true,
+				ForceNew: true,
+				Elem:     &schema.Schema{Type: schema.TypeString},
+			},
+		},
+	}
+}
+
+func resourceAwsBackupSelectionCreate(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).backupconn
+
+	selection := &backup.Selection{}
+
+	selection.SelectionName = aws.String(d.Get("name").(string))
+	selection.IamRoleArn = aws.String(d.Get("iam_role").(string))
+	selection.ListOfTags = gatherConditionTags(d)
+	selection.Resources = expandStringList(d.Get("resources").([]interface{}))
+
+	input := &backup.CreateBackupSelectionInput{
+		BackupPlanId:    aws.String(d.Get("plan_id").(string)),
+		BackupSelection: selection,
+	}
+
+	resp, err := conn.CreateBackupSelection(input)
+	if err != nil {
+		return fmt.Errorf("error creating Backup Selection: %s", err)
+	}
+
+	d.SetId(*resp.SelectionId)
+
+	return resourceAwsBackupSelectionRead(d, meta)
+}
+
+func resourceAwsBackupSelectionRead(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).backupconn
+
+	input := &backup.GetBackupSelectionInput{
+		BackupPlanId: aws.String(d.Get("plan_id").(string)),
+		SelectionId:  aws.String(d.Id()),
+	}
+
+	resp, err := conn.GetBackupSelection(input)
+	if err != nil {
+		return fmt.Errorf("error reading Backup Selection: %s", err)
+	}
+
+	d.Set("plan_id", resp.BackupPlanId)
+	d.Set("name", resp.BackupSelection.SelectionName)
+	d.Set("iam_role", resp.BackupSelection.IamRoleArn)
+
+	if resp.BackupSelection.ListOfTags != nil {
+		tag := &schema.Set{F: resourceAwsConditionTagHash}
+
+		for _, r := range resp.BackupSelection.ListOfTags {
+			m := make(map[string]interface{})
+
+			m["type"] = *r.ConditionType
+			m["key"] = *r.ConditionKey
+			m["value"] = *r.ConditionValue
+
+			tag.Add(m)
+		}
+
+		d.Set("tag", tag)
+	}
+	if resp.BackupSelection.Resources != nil {
+		d.Set("resources", resp.BackupSelection.Resources)
+	}
+
+	return nil
+}
+
+func resourceAwsBackupSelectionDelete(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).backupconn
+
+	input := &backup.DeleteBackupSelectionInput{
+		BackupPlanId: aws.String(d.Get("plan_id").(string)),
+		SelectionId:  aws.String(d.Id()),
+	}
+
+	_, err := conn.DeleteBackupSelection(input)
+	if err != nil {
+		return fmt.Errorf("error deleting Backup Selection: %s", err)
+	}
+
+	return nil
+}
+
+func gatherConditionTags(d *schema.ResourceData) []*backup.Condition {
+	conditions := []*backup.Condition{}
+	selectionTags := d.Get("tag").(*schema.Set).List()
+
+	for _, i := range selectionTags {
+		item := i.(map[string]interface{})
+		tag := &backup.Condition{}
+
+		tag.ConditionType = aws.String(item["type"].(string))
+		tag.ConditionKey = aws.String(item["key"].(string))
+		tag.ConditionValue = aws.String(item["value"].(string))
+
+		conditions = append(conditions, tag)
+	}
+
+	return conditions
+}
+
+func resourceAwsConditionTagHash(v interface{}) int {
+	var buf bytes.Buffer
+	m := v.(map[string]interface{})
+
+	if v, ok := m["type"]; ok {
+		buf.WriteString(fmt.Sprintf("%s-", v.(string)))
+	}
+
+	if v, ok := m["key"]; ok {
+		buf.WriteString(fmt.Sprintf("%s-", v.(string)))
+	}
+
+	if v, ok := m["value"]; ok {
+		buf.WriteString(fmt.Sprintf("%s-", v.(string)))
+	}
+
+	return hashcode.String(buf.String())
+}

aws/resource_aws_backup_selection_test.go

@@ -0,0 +1,189 @@
+package aws
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/backup"
+	"github.com/hashicorp/terraform/helper/acctest"
+	"github.com/hashicorp/terraform/helper/resource"
+	"github.com/hashicorp/terraform/terraform"
+)
+
+func TestAccAwsBackupSelection_basic(t *testing.T) {
+	rInt := acctest.RandInt()
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckAwsBackupSelectionDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccBackupSelectionConfigBasic(rInt),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckAwsBackupSelectionExists("aws_backup_selection.test"),
+				),
+			},
+		},
+	})
+}
+
+func TestAccAwsBackupSelection_withTags(t *testing.T) {
+	rInt := acctest.RandInt()
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckAwsBackupSelectionDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccBackupSelectionConfigWithTags(rInt),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckAwsBackupSelectionExists("aws_backup_selection.test"),
+					resource.TestCheckResourceAttr("aws_backup_selection.test", "tag.#", "2"),
+				),
+			},
+		},
+	})
+}
+
+func TestAccAwsBackupSelection_withResources(t *testing.T) {
+	rInt := acctest.RandInt()
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckAwsBackupSelectionDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccBackupSelectionConfigWithResources(rInt),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckAwsBackupSelectionExists("aws_backup_selection.test"),
+					resource.TestCheckResourceAttr("aws_backup_selection.test", "resources.#", "2"),
+				),
+			},
+		},
+	})
+}
+
+func testAccCheckAwsBackupSelectionDestroy(s *terraform.State) error {
+	conn := testAccProvider.Meta().(*AWSClient).backupconn
+	for _, rs := range s.RootModule().Resources {
+		if rs.Type != "aws_backup_selection" {
+			continue
+		}
+
+		input := &backup.GetBackupSelectionInput{
+			BackupPlanId: aws.String(rs.Primary.Attributes["plan_id"]),
+			SelectionId:  aws.String(rs.Primary.ID),
+		}
+
+		resp, err := conn.GetBackupSelection(input)
+
+		if err == nil {
+			if *resp.SelectionId == rs.Primary.ID {
+				return fmt.Errorf("Selection '%s' was not deleted properly", rs.Primary.ID)
+			}
+		}
+	}
+
+	return nil
+}
+
+func testAccCheckAwsBackupSelectionExists(name string) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		_, ok := s.RootModule().Resources[name]
+		if !ok {
+			return fmt.Errorf("not found: %s, %v", name, s.RootModule().Resources)
+		}
+		return nil
+	}
+}
+
+func testAccBackupSelectionConfigBase(rInt int) string {
+	return fmt.Sprintf(`
+data "aws_caller_identity" "current" {}
+
+resource "aws_backup_vault" "test" {
+  name = "tf_acc_test_backup_vault_%d"
+}
+
+resource "aws_backup_plan" "test" {
+  name = "tf_acc_test_backup_plan_%d"
+
+  rule {
+    rule_name         = "tf_acc_test_backup_rule_%d"
+    target_vault_name = "${aws_backup_vault.test.name}"
+    schedule          = "cron(0 12 * * ? *)"
+  }
+}
+`, rInt, rInt, rInt)
+}
+
+func testAccBackupSelectionConfigBasic(rInt int) string {
+	return testAccBackupSelectionConfigBase(rInt) + fmt.Sprintf(`
+resource "aws_backup_selection" "test" {
+  plan_id  = "${aws_backup_plan.test.id}"
+
+  name     = "tf_acc_test_backup_selection_%d"
+  iam_role = "arn:aws:iam::${data.aws_caller_identity.current.account_id}:role/service-role/AWSBackupDefaultServiceRole"
+
+  tag {
+    type = "STRINGEQUALS"
+    key = "foo"
+    value = "bar"
+  }
+
+  resources = [
+    "arn:aws:ec2:us-east-1:${data.aws_caller_identity.current.account_id}:volume/"
+  ]
+}
+`, rInt)
+}
+
+func testAccBackupSelectionConfigWithTags(rInt int) string {
+	return testAccBackupSelectionConfigBase(rInt) + fmt.Sprintf(`
+resource "aws_backup_selection" "test" {
+  plan_id  = "${aws_backup_plan.test.id}"
+
+  name     = "tf_acc_test_backup_selection_%d"
+  iam_role = "arn:aws:iam::${data.aws_caller_identity.current.account_id}:role/service-role/AWSBackupDefaultServiceRole"
+
+  tag {
+    type = "STRINGEQUALS"
+    key = "foo"
+    value = "bar"
+  }
+
+  tag {
+    type = "STRINGEQUALS"
+    key = "boo"
+    value = "far"
+  }
+
+  resources = [
+    "arn:aws:ec2:us-east-1:${data.aws_caller_identity.current.account_id}:volume/"
+  ]
+}
+`, rInt)
+}
+
+func testAccBackupSelectionConfigWithResources(rInt int) string {
+	return testAccBackupSelectionConfigBase(rInt) + fmt.Sprintf(`
+resource "aws_backup_selection" "test" {
+  plan_id  = "${aws_backup_plan.test.id}"
+
+  name     = "tf_acc_test_backup_selection_%d"
+  iam_role = "arn:aws:iam::${data.aws_caller_identity.current.account_id}:role/service-role/AWSBackupDefaultServiceRole"
+
+  tag {
+    type = "STRINGEQUALS"
+    key = "foo"
+    value = "bar"
+  }
+
+  resources = [
+    "arn:aws:ec2:us-east-1:${data.aws_caller_identity.current.account_id}:volume/",
+    "arn:aws:elasticfilesystem:us-east-1:${data.aws_caller_identity.current.account_id}:file-system/"
+  ]
+}
+`, rInt)
+}

website/aws.erb

@@ -576,6 +576,9 @@
                         <li<%= sidebar_current("docs-aws-resource-backup-plan") %>>
                             <a href="/docs/providers/aws/r/backup_plan.html">aws_backup_plan</a>
                         </li>
+                        <li<%= sidebar_current("docs-aws-resource-backup-selection") %>>
+                            <a href="/docs/providers/aws/r/backup_selection.html">aws_backup_selection</a>
+                        </li>
                         <li<%= sidebar_current("docs-aws-resource-backup-vault") %>>
                             <a href="/docs/providers/aws/r/backup_vault.html">aws_backup_vault</a>
                         </li>