Add support for updating RDS tags (#5)

* change license

* update buffalo version

* add support for updating RDS tags

* fixup

* add tests for DetermineArn

* fixup

* fixup

* fixup

Author: tenyo

README.md

@@ -124,6 +124,22 @@ PUT http://127.0.0.1:3000/v1/rds/{account}/myaurora
 }
 ```
 
+### Updating tags for a database
+
+You can pass a list of tags (Key/Value pairs) to add or updated on the given database. If there is an RDS cluster and instance with the same name, the tags for both will be updated.
+
+```
+PUT http://127.0.0.1:3000/v1/rds/{account}/myaurora
+{
+   "Tags": [
+      {
+         "Key": "NewTag",
+         "Value": "new"
+      }
+   ]
+}
+```
+
 ### Deleting a database
 
 By default, a final snapshot is _not_ created when deleting a database instance. You can override that by adding `snapshot=true` query parameter.

actions/databases.go

@@ -27,6 +27,7 @@ type DatabaseModifyInput struct {
 	Cluster *rds.ModifyDBClusterInput
 	// https://docs.aws.amazon.com/sdk-for-go/api/service/rds/#ModifyDBInstanceInput
 	Instance *rds.ModifyDBInstanceInput
+	Tags     []*rds.Tag
 }
 
 // DatabasesList gets a list of databases for a given account
@@ -251,16 +252,21 @@ func DatabasesPost(c buffalo.Context) error {
 
 // DatabasesPut modifies a database in a given account
 // Either Cluster or Instance input parameters can be specified for a request
+// Tags list can be given with any key/value tags to add/update
 func DatabasesPut(c buffalo.Context) error {
 	input := DatabaseModifyInput{}
 	if err := c.Bind(&input); err != nil {
 		log.Println(err)
 		return c.Error(400, err)
 	}
-	if (input.Cluster == nil && input.Instance == nil) || (input.Cluster != nil && input.Instance != nil) {
+	if input.Cluster == nil && input.Instance == nil && input.Tags == nil {
 		return c.Error(400, errors.New("Bad request"))
 	}
 
+	if input.Cluster != nil && input.Instance != nil {
+		return c.Error(400, errors.New("Bad request: cannot specify both Cluster and Instance"))
+	}
+
 	rdsClient, ok := RDS[c.Param("account")]
 	if !ok {
 		return c.Error(400, errors.New("Bad request: unknown account "+c.Param("account")))
@@ -294,6 +300,32 @@ func DatabasesPut(c buffalo.Context) error {
 		log.Println("Modified RDS instance", instanceOutput)
 	}
 
+	if input.Tags != nil {
+		log.Println("Updating tags for "+c.Param("db"), input.Tags)
+		tags := &rds.AddTagsToResourceInput{}
+		tags.Tags = input.Tags
+
+		// determine ARN(s) for this RDS resource
+		arns, err := rdsClient.DetermineArn(c.Param("db"))
+		if err != nil {
+			log.Println(err)
+			return c.Error(400, err)
+		}
+
+		// update tags for all RDS resources with matching ARNs
+		for _, arn := range arns {
+			tags.ResourceName = aws.String(arn)
+			if _, err = rdsClient.Service.AddTagsToResourceWithContext(c, tags); err != nil {
+				log.Println(err.Error())
+				if aerr, ok := err.(awserr.Error); ok {
+					return c.Error(400, aerr)
+				}
+				return err
+			}
+			log.Println("Updated tags for RDS resource", arn)
+		}
+	}
+
 	output := struct {
 		*rds.ModifyDBClusterOutput
 		*rds.ModifyDBInstanceOutput

pkg/rds/tags.go

@@ -0,0 +1,46 @@
+package rds
+
+import (
+	"errors"
+	"log"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/rds"
+)
+
+// DetermineArn returns the ARN for an RDS instance or cluster given the database name
+// It could return 2 ARNs if a cluster and instance with the same name exist
+func (cl Client) DetermineArn(dbName string) ([]string, error) {
+	arns := []string{}
+
+	log.Println("Trying to determine ARN for", dbName)
+	db := aws.String(dbName)
+
+	// search clusters for the given db name
+	clustersOutput, _ := cl.Service.DescribeDBClusters(&rds.DescribeDBClustersInput{
+		DBClusterIdentifier: db,
+	})
+
+	// search instances for the given db name
+	instancesOutput, _ := cl.Service.DescribeDBInstances(&rds.DescribeDBInstancesInput{
+		DBInstanceIdentifier: db,
+	})
+
+	if clustersOutput == nil && instancesOutput == nil {
+		return nil, errors.New("Unable to determine ARN for database " + dbName)
+	}
+
+	for _, cluster := range clustersOutput.DBClusters {
+		arns = append(arns, aws.StringValue(cluster.DBClusterArn))
+	}
+
+	for _, instance := range instancesOutput.DBInstances {
+		arns = append(arns, aws.StringValue(instance.DBInstanceArn))
+	}
+
+	if len(arns) == 0 {
+		return nil, errors.New("Unable to determine ARN for database " + dbName)
+	}
+
+	return arns, nil
+}

pkg/rds/tags_test.go

@@ -0,0 +1,84 @@
+package rds
+
+import (
+	"testing"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/rds"
+	"github.com/aws/aws-sdk-go/service/rds/rdsiface"
+)
+
+type mockRdsService struct {
+	rdsiface.RDSAPI
+}
+
+func (m *mockRdsService) DescribeDBClusters(input *rds.DescribeDBClustersInput) (*rds.DescribeDBClustersOutput, error) {
+	dbName := *input.DBClusterIdentifier
+
+	if dbName == "unknown" || dbName == "instance" {
+		return &rds.DescribeDBClustersOutput{}, nil
+	}
+
+	return &rds.DescribeDBClustersOutput{
+		DBClusters: []*rds.DBCluster{
+			&rds.DBCluster{
+				DBClusterArn: aws.String("arn:aws:rds:us-east-1:123456789012:db:" + dbName),
+			},
+		},
+	}, nil
+}
+
+func (m *mockRdsService) DescribeDBInstances(input *rds.DescribeDBInstancesInput) (*rds.DescribeDBInstancesOutput, error) {
+	dbName := *input.DBInstanceIdentifier
+
+	if dbName == "unknown" || dbName == "cluster" {
+		return &rds.DescribeDBInstancesOutput{}, nil
+	}
+
+	return &rds.DescribeDBInstancesOutput{
+		DBInstances: []*rds.DBInstance{
+			&rds.DBInstance{
+				DBInstanceArn: aws.String("arn:aws:rds:us-east-1:123456789012:db:" + dbName),
+			},
+		},
+	}, nil
+}
+
+func TestDetermineArn(t *testing.T) {
+	mc := Client{
+		Service: &mockRdsService{},
+	}
+
+	got, err := mc.DetermineArn("cluster")
+	t.Log(got)
+	if err != nil {
+		t.Fatalf("Expected error nil, got: %v", err)
+	}
+	if len(got) != 1 {
+		t.Fatalf("Expected single ARN, got: %v", len(got))
+	}
+
+	got, err = mc.DetermineArn("instance")
+	t.Log(got)
+	if err != nil {
+		t.Fatalf("Expected error nil, got: %v", err)
+	}
+	if len(got) != 1 {
+		t.Fatalf("Expected single ARN, got: %v", len(got))
+	}
+
+	got, err = mc.DetermineArn("both")
+	t.Log(got)
+	if err != nil {
+		t.Fatalf("Expected error nil, got: %v", err)
+	}
+	if len(got) != 2 {
+		t.Fatalf("Expected two ARNs, got: %v", len(got))
+	}
+
+	got, err = mc.DetermineArn("unknown")
+	t.Log(got)
+	if err == nil {
+		t.Fatalf("Expected error, got: nil")
+	}
+}