Add support for tagging aws_dx_lag and aws_dx_connection resources

aws/resource_aws_dx_connection.go

@@ -2,9 +2,11 @@ package aws
 
 import (
  "fmt"
+ "log"
  "time"
 
  "github.com/aws/aws-sdk-go/aws"
+ "github.com/aws/aws-sdk-go/aws/arn"
  "github.com/aws/aws-sdk-go/service/directconnect"
  "github.com/hashicorp/terraform/helper/resource"
  "github.com/hashicorp/terraform/helper/schema"
@@ -14,79 +16,137 @@ func resourceAwsDxConnection() *schema.Resource {
  return &schema.Resource{
  Create: resourceAwsDxConnectionCreate,
  Read: resourceAwsDxConnectionRead,
+ Update: resourceAwsDxConnectionUpdate,
  Delete: resourceAwsDxConnectionDelete,
 
  Schema: map[string]*schema.Schema{
- "name": &schema.Schema{
+ "arn": {
+ Type: schema.TypeString,
+ Computed: true,
+ },
+ "name": {
  Type: schema.TypeString,
  Required: true,
  ForceNew: true,
  },
- "bandwidth": &schema.Schema{
+ "bandwidth": {
  Type: schema.TypeString,
  Required: true,
  ForceNew: true,
  ValidateFunc: validateDxConnectionBandWidth,
  },
- "location": &schema.Schema{
+ "location": {
  Type: schema.TypeString,
  Required: true,
  ForceNew: true,
  },
+ "tags": tagsSchema(),
  },
  }
 }
 
 func resourceAwsDxConnectionCreate(d *schema.ResourceData, meta interface{}) error {
  conn := meta.(*AWSClient).dxconn
 
- input := &directconnect.CreateConnectionInput{
+ req := &directconnect.CreateConnectionInput{
  Bandwidth: aws.String(d.Get("bandwidth").(string)),
  ConnectionName: aws.String(d.Get("name").(string)),
  Location: aws.String(d.Get("location").(string)),
  }
- resp, err := conn.CreateConnection(input)
+
+ log.Printf("[DEBUG] Creating Direct Connect connection: %#v", req)
+ resp, err := conn.CreateConnection(req)
  if err != nil {
  return err
  }
- d.SetId(*resp.ConnectionId)
- return resourceAwsDxConnectionRead(d, meta)
+
+ d.SetId(aws.StringValue(resp.ConnectionId))
+ return resourceAwsDxConnectionUpdate(d, meta)
 }
 
 func resourceAwsDxConnectionRead(d *schema.ResourceData, meta interface{}) error {
  conn := meta.(*AWSClient).dxconn
 
- connectionId := d.Id()
- input := &directconnect.DescribeConnectionsInput{
- ConnectionId: aws.String(connectionId),
- }
- resp, err := conn.DescribeConnections(input)
+ resp, err := conn.DescribeConnections(&directconnect.DescribeConnectionsInput{
+ ConnectionId: aws.String(d.Id()),
+ })
  if err != nil {
+ if isNoSuchDxConnectionErr(err) {
+ log.Printf("[WARN] Direct Connect connection (%s) not found, removing from state", d.Id())
+ d.SetId("")
+ return nil
+ }
  return err
  }
+
  if len(resp.Connections) < 1 {
+ log.Printf("[WARN] Direct Connect connection (%s) not found, removing from state", d.Id())
  d.SetId("")
  return nil
  }
  if len(resp.Connections) != 1 {
- return fmt.Errorf("[ERROR] Number of DX Connection (%s) isn't one, got %d", connectionId, len(resp.Connections))
+ return fmt.Errorf("[ERROR] Number of Direct Connect connections (%s) isn't one, got %d", d.Id(), len(resp.Connections))
+ }
+ connection := resp.Connections[0]
+ if d.Id() != aws.StringValue(connection.ConnectionId) {
+ return fmt.Errorf("[ERROR] Direct Connect connection (%s) not found", d.Id())
+ }
+ if aws.StringValue(connection.ConnectionState) == directconnect.ConnectionStateDeleted {
+ log.Printf("[WARN] Direct Connect connection (%s) not found, removing from state", d.Id())
+ d.SetId("")
+ return nil
  }
- if d.Id() != *resp.Connections[0].ConnectionId {
- return fmt.Errorf("[ERROR] DX Connection (%s) not found", connectionId)
+
+ arn := arn.ARN{
+ Partition: meta.(*AWSClient).partition,
+ Region: meta.(*AWSClient).region,
+ Service: "directconnect",
+ AccountID: meta.(*AWSClient).accountid,
+ Resource: fmt.Sprintf("dxcon/%s", d.Id()),
+ }.String()
+ d.Set("arn", arn)
+ d.Set("name", connection.ConnectionName)
+ d.Set("bandwidth", connection.Bandwidth)
+ d.Set("location", connection.Location)
+
+ if err := getTagsDX(conn, d, arn); err != nil {
+ return err
  }
+
  return nil
 }
 
+func resourceAwsDxConnectionUpdate(d *schema.ResourceData, meta interface{}) error {
+ conn := meta.(*AWSClient).dxconn
+
+ arn := arn.ARN{
+ Partition: meta.(*AWSClient).partition,
+ Region: meta.(*AWSClient).region,
+ Service: "directconnect",
+ AccountID: meta.(*AWSClient).accountid,
+ Resource: fmt.Sprintf("dxcon/%s", d.Id()),
+ }.String()
+ if err := setTagsDX(conn, d, arn); err != nil {
+ return err
+ }
+
+ return resourceAwsDxConnectionRead(d, meta)
+}
+
 func resourceAwsDxConnectionDelete(d *schema.ResourceData, meta interface{}) error {
  conn := meta.(*AWSClient).dxconn
 
- input := &directconnect.DeleteConnectionInput{
+ log.Printf("[DEBUG] Deleting Direct Connect connection: %s", d.Id())
+ _, err := conn.DeleteConnection(&directconnect.DeleteConnectionInput{
  ConnectionId: aws.String(d.Id()),
- }
- _, err := conn.DeleteConnection(input)
+ })
  if err != nil {
+ if isNoSuchDxConnectionErr(err) {
+ return nil
+ }
  return err
  }
+
  deleteStateConf := &resource.StateChangeConf{
  Pending: []string{directconnect.ConnectionStatePending, directconnect.ConnectionStateOrdering, directconnect.ConnectionStateAvailable, directconnect.ConnectionStateRequested, directconnect.ConnectionStateDeleting},
  Target: []string{directconnect.ConnectionStateDeleted},
@@ -97,9 +157,9 @@ func resourceAwsDxConnectionDelete(d *schema.ResourceData, meta interface{}) err
  }
  _, err = deleteStateConf.WaitForState()
  if err != nil {
- return fmt.Errorf("Error waiting for Dx Connection (%s) to be deleted: %s", d.Id(), err)
+ return fmt.Errorf("Error waiting for Direct Connect connection (%s) to be deleted: %s", d.Id(), err)
  }
- d.SetId("")
+
  return nil
 }
 
@@ -112,6 +172,13 @@ func dxConnectionRefreshStateFunc(conn *directconnect.DirectConnect, connId stri
  if err != nil {
  return nil, "failed", err
  }
+ if len(resp.Connections) < 1 {
+ return resp, directconnect.ConnectionStateDeleted, nil
+ }
  return resp, *resp.Connections[0].ConnectionState, nil
  }
 }
+
+func isNoSuchDxConnectionErr(err error) bool {
+ return isAWSErr(err, "DirectConnectClientException", "Could not find Connection with ID")
+}

aws/resource_aws_dx_connection_test.go

@@ -12,15 +12,51 @@ import (
 )
 
 func TestAccAwsDxConnection_basic(t *testing.T) {
+ connectionName := fmt.Sprintf("tf-dx-%s", acctest.RandString(5))
+
+ resource.Test(t, resource.TestCase{
+ PreCheck: func() { testAccPreCheck(t) },
+ Providers: testAccProviders,
+ CheckDestroy: testAccCheckAwsDxConnectionDestroy,
+ Steps: []resource.TestStep{
+ {
+ Config: testAccDxConnectionConfig(connectionName),
+ Check: resource.ComposeTestCheckFunc(
+ testAccCheckAwsDxConnectionExists("aws_dx_connection.hoge"),
+ resource.TestCheckResourceAttr("aws_dx_connection.hoge", "name", connectionName),
+ resource.TestCheckResourceAttr("aws_dx_connection.hoge", "bandwidth", "1Gbps"),
+ resource.TestCheckResourceAttr("aws_dx_connection.hoge", "location", "EqSe2"),
+ resource.TestCheckResourceAttr("aws_dx_connection.hoge", "tags.%", "0"),
+ ),
+ },
+ },
+ })
+}
+
+func TestAccAwsDxConnection_tags(t *testing.T) {
+ connectionName := fmt.Sprintf("tf-dx-%s", acctest.RandString(5))
+
  resource.Test(t, resource.TestCase{
  PreCheck: func() { testAccPreCheck(t) },
  Providers: testAccProviders,
  CheckDestroy: testAccCheckAwsDxConnectionDestroy,
  Steps: []resource.TestStep{
  {
- Config: testAccDxConnectionConfig(acctest.RandString(5)),
+ Config: testAccDxConnectionConfig_tags(connectionName),
  Check: resource.ComposeTestCheckFunc(
  testAccCheckAwsDxConnectionExists("aws_dx_connection.hoge"),
+ resource.TestCheckResourceAttr("aws_dx_connection.hoge", "name", connectionName),
+ resource.TestCheckResourceAttr("aws_dx_connection.hoge", "tags.%", "2"),
+ resource.TestCheckResourceAttr("aws_dx_connection.hoge", "tags.Usage", "original"),
+ ),
+ },
+ {
+ Config: testAccDxConnectionConfig_tagsChanged(connectionName),
+ Check: resource.ComposeTestCheckFunc(
+ testAccCheckAwsDxConnectionExists("aws_dx_connection.hoge"),
+ resource.TestCheckResourceAttr("aws_dx_connection.hoge", "name", connectionName),
+ resource.TestCheckResourceAttr("aws_dx_connection.hoge", "tags.%", "1"),
+ resource.TestCheckResourceAttr("aws_dx_connection.hoge", "tags.Usage", "changed"),
  ),
  },
  },
@@ -63,12 +99,41 @@ func testAccCheckAwsDxConnectionExists(name string) resource.TestCheckFunc {
  }
 }
 
-func testAccDxConnectionConfig(rName string) string {
+func testAccDxConnectionConfig(n string) string {
+ return fmt.Sprintf(`
+resource "aws_dx_connection" "hoge" {
+ name = "%s"
+ bandwidth = "1Gbps"
+ location = "EqSe2"
+}
+`, n)
+}
+
+func testAccDxConnectionConfig_tags(n string) string {
+ return fmt.Sprintf(`
+resource "aws_dx_connection" "hoge" {
+ name = "%s"
+ bandwidth = "1Gbps"
+ location = "EqSe2"
+
+ tags {
+ Environment = "production"
+ Usage = "original"
+ }
+}
+`, n)
+}
+
+func testAccDxConnectionConfig_tagsChanged(n string) string {
  return fmt.Sprintf(`
- resource "aws_dx_connection" "hoge" {
- name = "tf-dx-%s"
- bandwidth = "1Gbps"
- location = "EqSe2"
- }
- `, rName)
+resource "aws_dx_connection" "hoge" {
+ name = "%s"
+ bandwidth = "1Gbps"
+ location = "EqSe2"
+
+ tags {
+ Usage = "changed"
+ }
+}
+`, n)
 }