From a808ddc28e6afc25e4d65c6a351fcfb8e4ede970 Mon Sep 17 00:00:00 2001 From: Radek Simko Date: Mon, 18 Dec 2017 20:32:04 +0000 Subject: [PATCH] New Resource: aws_gamelift_alias --- aws/provider.go | 1 + aws/resource_aws_gamelift_alias.go | 181 +++++++++++++ aws/resource_aws_gamelift_alias_test.go | 279 ++++++++++++++++++++ website/aws.erb | 3 + website/docs/r/gamelift_alias.html.markdown | 55 ++++ 5 files changed, 519 insertions(+) create mode 100644 aws/resource_aws_gamelift_alias.go create mode 100644 aws/resource_aws_gamelift_alias_test.go create mode 100644 website/docs/r/gamelift_alias.html.markdown diff --git a/aws/provider.go b/aws/provider.go index a70404b80008..20c4543b9599 100644 --- a/aws/provider.go +++ b/aws/provider.go @@ -368,6 +368,7 @@ func Provider() terraform.ResourceProvider { "aws_emr_instance_group": resourceAwsEMRInstanceGroup(), "aws_emr_security_configuration": resourceAwsEMRSecurityConfiguration(), "aws_flow_log": resourceAwsFlowLog(), + "aws_gamelift_alias": resourceAwsGameliftAlias(), "aws_gamelift_build": resourceAwsGameliftBuild(), "aws_gamelift_fleet": resourceAwsGameliftFleet(), "aws_glacier_vault": resourceAwsGlacierVault(), diff --git a/aws/resource_aws_gamelift_alias.go b/aws/resource_aws_gamelift_alias.go new file mode 100644 index 000000000000..f2ef67f2080f --- /dev/null +++ b/aws/resource_aws_gamelift_alias.go @@ -0,0 +1,181 @@ +package aws + +import ( + "log" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/gamelift" + "github.com/hashicorp/terraform/helper/schema" + "github.com/hashicorp/terraform/helper/validation" +) + +func resourceAwsGameliftAlias() *schema.Resource { + return &schema.Resource{ + Create: resourceAwsGameliftAliasCreate, + Read: resourceAwsGameliftAliasRead, + Update: resourceAwsGameliftAliasUpdate, + Delete: resourceAwsGameliftAliasDelete, + + Importer: &schema.ResourceImporter{ + State: schema.ImportStatePassthrough, + }, + + Schema: map[string]*schema.Schema{ + "name": { + Type: schema.TypeString, + Required: true, + ValidateFunc: validation.StringLenBetween(1, 1024), + }, + "description": { + Type: schema.TypeString, + Optional: true, + ValidateFunc: validation.StringLenBetween(1, 1024), + }, + "routing_strategy": { + Type: schema.TypeList, + Required: true, + MaxItems: 1, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "fleet_id": { + Type: schema.TypeString, + Optional: true, + }, + "message": { + Type: schema.TypeString, + Optional: true, + }, + "type": { + Type: schema.TypeString, + Required: true, + ValidateFunc: validation.StringInSlice([]string{ + gamelift.RoutingStrategyTypeSimple, + gamelift.RoutingStrategyTypeTerminal, + }, false), + }, + }, + }, + }, + "arn": { + Type: schema.TypeString, + Computed: true, + }, + }, + } +} + +func resourceAwsGameliftAliasCreate(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).gameliftconn + + rs := expandGameliftRoutingStrategy(d.Get("routing_strategy").([]interface{})) + input := gamelift.CreateAliasInput{ + Name: aws.String(d.Get("name").(string)), + RoutingStrategy: rs, + } + if v, ok := d.GetOk("description"); ok { + input.Description = aws.String(v.(string)) + } + log.Printf("[INFO] Creating Gamelift Alias: %s", input) + out, err := conn.CreateAlias(&input) + if err != nil { + return err + } + + d.SetId(*out.Alias.AliasId) + + return resourceAwsGameliftAliasRead(d, meta) +} + +func resourceAwsGameliftAliasRead(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).gameliftconn + + log.Printf("[INFO] Describing Gamelift Alias: %s", d.Id()) + out, err := conn.DescribeAlias(&gamelift.DescribeAliasInput{ + AliasId: aws.String(d.Id()), + }) + if err != nil { + if isAWSErr(err, gamelift.ErrCodeNotFoundException, "") { + d.SetId("") + log.Printf("[WARN] Gamelift Alias (%s) not found, removing from state", d.Id()) + return nil + } + return err + } + a := out.Alias + + d.Set("arn", a.AliasArn) + d.Set("description", a.Description) + d.Set("name", a.Name) + d.Set("routing_strategy", flattenGameliftRoutingStrategy(a.RoutingStrategy)) + + return nil +} + +func resourceAwsGameliftAliasUpdate(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).gameliftconn + + log.Printf("[INFO] Updating Gamelift Alias: %s", d.Id()) + _, err := conn.UpdateAlias(&gamelift.UpdateAliasInput{ + AliasId: aws.String(d.Id()), + Name: aws.String(d.Get("name").(string)), + Description: aws.String(d.Get("description").(string)), + RoutingStrategy: expandGameliftRoutingStrategy(d.Get("routing_strategy").([]interface{})), + }) + if err != nil { + return err + } + + return resourceAwsGameliftAliasRead(d, meta) +} + +func resourceAwsGameliftAliasDelete(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).gameliftconn + + log.Printf("[INFO] Deleting Gamelift Alias: %s", d.Id()) + _, err := conn.DeleteAlias(&gamelift.DeleteAliasInput{ + AliasId: aws.String(d.Id()), + }) + if err != nil { + return err + } + + return nil +} + +func expandGameliftRoutingStrategy(cfg []interface{}) *gamelift.RoutingStrategy { + if len(cfg) < 1 { + return nil + } + + strategy := cfg[0].(map[string]interface{}) + + out := gamelift.RoutingStrategy{ + Type: aws.String(strategy["type"].(string)), + } + + if v, ok := strategy["fleet_id"].(string); ok && len(v) > 0 { + out.FleetId = aws.String(v) + } + if v, ok := strategy["message"].(string); ok && len(v) > 0 { + out.Message = aws.String(v) + } + + return &out +} + +func flattenGameliftRoutingStrategy(rs *gamelift.RoutingStrategy) []interface{} { + if rs == nil { + return []interface{}{} + } + + m := make(map[string]interface{}, 0) + if rs.FleetId != nil { + m["fleet_id"] = *rs.FleetId + } + if rs.Message != nil { + m["message"] = *rs.Message + } + m["type"] = *rs.Type + + return []interface{}{m} +} diff --git a/aws/resource_aws_gamelift_alias_test.go b/aws/resource_aws_gamelift_alias_test.go new file mode 100644 index 000000000000..d20b0f037248 --- /dev/null +++ b/aws/resource_aws_gamelift_alias_test.go @@ -0,0 +1,279 @@ +package aws + +import ( + "fmt" + "log" + "strings" + "testing" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/gamelift" + "github.com/hashicorp/terraform/helper/acctest" + "github.com/hashicorp/terraform/helper/resource" + "github.com/hashicorp/terraform/terraform" +) + +func init() { + resource.AddTestSweepers("aws_gamelift_alias", &resource.Sweeper{ + Name: "aws_gamelift_alias", + Dependencies: []string{ + "aws_gamelift_fleet", + }, + F: testSweepGameliftAliases, + }) +} + +func testSweepGameliftAliases(region string) error { + client, err := sharedClientForRegion(region) + if err != nil { + return fmt.Errorf("error getting client: %s", err) + } + conn := client.(*AWSClient).gameliftconn + + err = listGameliftAliases(&gamelift.ListAliasesInput{}, conn, func(resp *gamelift.ListAliasesOutput) error { + if len(resp.Aliases) == 0 { + log.Print("[DEBUG] No Gamelift Aliases to sweep") + return nil + } + + log.Printf("[INFO] Found %d Gamelift Aliases", len(resp.Aliases)) + + for _, alias := range resp.Aliases { + if !strings.HasPrefix(*alias.Name, "tf_acc_alias_") { + continue + } + + log.Printf("[INFO] Deleting Gamelift Alias %q", *alias.AliasId) + _, err := conn.DeleteAlias(&gamelift.DeleteAliasInput{ + AliasId: alias.AliasId, + }) + if err != nil { + return fmt.Errorf("Error deleting Gamelift Alias (%s): %s", + *alias.AliasId, err) + } + } + return nil + }) + if err != nil { + return fmt.Errorf("Error listing Gamelift Aliases: %s", err) + } + + return nil +} + +func listGameliftAliases(input *gamelift.ListAliasesInput, conn *gamelift.GameLift, f func(*gamelift.ListAliasesOutput) error) error { + resp, err := conn.ListAliases(input) + if err != nil { + return err + } + err = f(resp) + if err != nil { + return err + } + + if resp.NextToken != nil { + return listGameliftAliases(input, conn, f) + } + return nil +} + +func TestAccAWSGameliftAlias_basic(t *testing.T) { + var conf gamelift.Alias + + rString := acctest.RandString(8) + + aliasName := fmt.Sprintf("tf_acc_alias_%s", rString) + description := fmt.Sprintf("tf test description %s", rString) + message := fmt.Sprintf("tf test message %s", rString) + + uAliasName := fmt.Sprintf("tf_acc_alias_upd_%s", rString) + uDescription := fmt.Sprintf("tf test updated description %s", rString) + uMessage := fmt.Sprintf("tf test updated message %s", rString) + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckAWSGameliftAliasDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAWSGameliftAliasBasicConfig(aliasName, description, message), + Check: resource.ComposeTestCheckFunc( + testAccCheckAWSGameliftAliasExists("aws_gamelift_alias.test", &conf), + resource.TestCheckResourceAttrSet("aws_gamelift_alias.test", "arn"), + resource.TestCheckResourceAttr("aws_gamelift_alias.test", "routing_strategy.#", "1"), + resource.TestCheckResourceAttr("aws_gamelift_alias.test", "routing_strategy.0.message", message), + resource.TestCheckResourceAttr("aws_gamelift_alias.test", "routing_strategy.0.type", "TERMINAL"), + resource.TestCheckResourceAttr("aws_gamelift_alias.test", "name", aliasName), + resource.TestCheckResourceAttr("aws_gamelift_alias.test", "description", description), + ), + }, + { + Config: testAccAWSGameliftAliasBasicConfig(uAliasName, uDescription, uMessage), + Check: resource.ComposeTestCheckFunc( + testAccCheckAWSGameliftAliasExists("aws_gamelift_alias.test", &conf), + resource.TestCheckResourceAttrSet("aws_gamelift_alias.test", "arn"), + resource.TestCheckResourceAttr("aws_gamelift_alias.test", "routing_strategy.#", "1"), + resource.TestCheckResourceAttr("aws_gamelift_alias.test", "routing_strategy.0.message", uMessage), + resource.TestCheckResourceAttr("aws_gamelift_alias.test", "routing_strategy.0.type", "TERMINAL"), + resource.TestCheckResourceAttr("aws_gamelift_alias.test", "name", uAliasName), + resource.TestCheckResourceAttr("aws_gamelift_alias.test", "description", uDescription), + ), + }, + }, + }) +} + +func TestAccAWSGameliftAlias_importBasic(t *testing.T) { + rString := acctest.RandString(8) + + aliasName := fmt.Sprintf("tf_acc_alias_%s", rString) + description := fmt.Sprintf("tf test description %s", rString) + message := fmt.Sprintf("tf test message %s", rString) + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckAWSGameliftAliasDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAWSGameliftAliasBasicConfig(aliasName, description, message), + }, + { + ResourceName: "aws_gamelift_alias.test", + ImportState: true, + ImportStateVerify: true, + }, + }, + }) +} + +func TestAccAWSGameliftAlias_fleetRouting(t *testing.T) { + var conf gamelift.Alias + + rString := acctest.RandString(8) + + aliasName := fmt.Sprintf("tf_acc_alias_%s", rString) + description := fmt.Sprintf("tf test description %s", rString) + fleetName := fmt.Sprintf("tf_acc_fleet_%s", rString) + buildName := fmt.Sprintf("tf_acc_build_%s", rString) + + region := testAccGetRegion() + g, err := testAccAWSGameliftSampleGame(region) + if err != nil { + t.Fatal(err) + } + + loc := g.Location + bucketName := *loc.Bucket + roleArn := *loc.RoleArn + key := *loc.Key + + launchPath := g.LaunchPath + params := g.Parameters(33435) + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckAWSGameliftAliasDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAWSGameliftAliasAllFieldsConfig(aliasName, description, + fleetName, launchPath, params, buildName, bucketName, key, roleArn), + Check: resource.ComposeTestCheckFunc( + testAccCheckAWSGameliftAliasExists("aws_gamelift_alias.test", &conf), + resource.TestCheckResourceAttrSet("aws_gamelift_alias.test", "arn"), + resource.TestCheckResourceAttr("aws_gamelift_alias.test", "routing_strategy.#", "1"), + resource.TestCheckResourceAttrSet("aws_gamelift_alias.test", "routing_strategy.0.fleet_id"), + resource.TestCheckResourceAttr("aws_gamelift_alias.test", "routing_strategy.0.type", "SIMPLE"), + resource.TestCheckResourceAttr("aws_gamelift_alias.test", "name", aliasName), + resource.TestCheckResourceAttr("aws_gamelift_alias.test", "description", description), + ), + }, + }, + }) +} + +func testAccCheckAWSGameliftAliasExists(n string, res *gamelift.Alias) 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 Gamelift Alias ID is set") + } + + conn := testAccProvider.Meta().(*AWSClient).gameliftconn + + out, err := conn.DescribeAlias(&gamelift.DescribeAliasInput{ + AliasId: aws.String(rs.Primary.ID), + }) + if err != nil { + return err + } + a := out.Alias + + if *a.AliasId != rs.Primary.ID { + return fmt.Errorf("Gamelift Alias not found") + } + + *res = *a + + return nil + } +} + +func testAccCheckAWSGameliftAliasDestroy(s *terraform.State) error { + conn := testAccProvider.Meta().(*AWSClient).gameliftconn + + for _, rs := range s.RootModule().Resources { + if rs.Type != "aws_gamelift_alias" { + continue + } + + _, err := conn.DescribeAlias(&gamelift.DescribeAliasInput{ + AliasId: aws.String(rs.Primary.ID), + }) + if err == nil { + return fmt.Errorf("Gamelift Alias still exists") + } + + if isAWSErr(err, gamelift.ErrCodeNotFoundException, "") { + return nil + } + + return err + } + + return nil +} + +func testAccAWSGameliftAliasBasicConfig(aliasName, description, message string) string { + return fmt.Sprintf(` +resource "aws_gamelift_alias" "test" { + name = "%s" + description = "%s" + routing_strategy { + message = "%s" + type = "TERMINAL" + } +} +`, aliasName, description, message) +} + +func testAccAWSGameliftAliasAllFieldsConfig(aliasName, description, + fleetName, launchPath, params, buildName, bucketName, key, roleArn string) string { + return fmt.Sprintf(` +resource "aws_gamelift_alias" "test" { + name = "%s" + description = "%s" + routing_strategy { + fleet_id = "${aws_gamelift_fleet.test.id}" + type = "SIMPLE" + } +} +%s +`, aliasName, description, + testAccAWSGameliftFleetBasicConfig(fleetName, launchPath, params, buildName, bucketName, key, roleArn)) +} diff --git a/website/aws.erb b/website/aws.erb index f9a44a8bfb30..85c7089ca5c6 100644 --- a/website/aws.erb +++ b/website/aws.erb @@ -976,6 +976,9 @@ > Gamelift Resources