From 6430fca7f639418c385bf2482d90fb1accb81a14 Mon Sep 17 00:00:00 2001 From: Raphael Randschau Date: Sat, 5 Mar 2016 23:19:25 +0100 Subject: [PATCH] Add aws_api_gateway_deployment resource --- builtin/providers/aws/provider.go | 1 + .../resource_aws_api_gateway_deployment.go | 169 ++++++++++++++++++ ...esource_aws_api_gateway_deployment_test.go | 157 ++++++++++++++++ builtin/providers/aws/structure.go | 67 +++++++ .../r/api_gateway_deployment.html.markdown | 55 ++++++ website/source/layouts/aws.erb | 3 + 6 files changed, 452 insertions(+) create mode 100644 builtin/providers/aws/resource_aws_api_gateway_deployment.go create mode 100644 builtin/providers/aws/resource_aws_api_gateway_deployment_test.go create mode 100644 website/source/docs/providers/aws/r/api_gateway_deployment.html.markdown diff --git a/builtin/providers/aws/provider.go b/builtin/providers/aws/provider.go index 8e500572b..d561ad9ae 100644 --- a/builtin/providers/aws/provider.go +++ b/builtin/providers/aws/provider.go @@ -122,6 +122,7 @@ func Provider() terraform.ResourceProvider { "aws_api_gateway_method_response": resourceAwsApiGatewayMethodResponse(), "aws_api_gateway_integration": resourceAwsApiGatewayIntegration(), "aws_api_gateway_integration_response": resourceAwsApiGatewayIntegrationResponse(), + "aws_api_gateway_deployment": resourceAwsApiGatewayDeployment(), "aws_app_cookie_stickiness_policy": resourceAwsAppCookieStickinessPolicy(), "aws_autoscaling_group": resourceAwsAutoscalingGroup(), "aws_autoscaling_notification": resourceAwsAutoscalingNotification(), diff --git a/builtin/providers/aws/resource_aws_api_gateway_deployment.go b/builtin/providers/aws/resource_aws_api_gateway_deployment.go new file mode 100644 index 000000000..4d7517bfb --- /dev/null +++ b/builtin/providers/aws/resource_aws_api_gateway_deployment.go @@ -0,0 +1,169 @@ +package aws + +import ( + "fmt" + "log" + "time" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/aws-sdk-go/service/apigateway" + "github.com/hashicorp/terraform/helper/resource" + "github.com/hashicorp/terraform/helper/schema" +) + +func resourceAwsApiGatewayDeployment() *schema.Resource { + return &schema.Resource{ + Create: resourceAwsApiGatewayDeploymentCreate, + Read: resourceAwsApiGatewayDeploymentRead, + Update: resourceAwsApiGatewayDeploymentUpdate, + Delete: resourceAwsApiGatewayDeploymentDelete, + + Schema: map[string]*schema.Schema{ + "rest_api_id": &schema.Schema{ + Type: schema.TypeString, + Required: true, + ForceNew: true, + }, + + "stage_name": &schema.Schema{ + Type: schema.TypeString, + Optional: true, + ForceNew: true, + }, + + "description": &schema.Schema{ + Type: schema.TypeString, + Optional: true, + }, + + "stage_description": &schema.Schema{ + Type: schema.TypeString, + Optional: true, + ForceNew: true, + }, + + "variables": &schema.Schema{ + Type: schema.TypeMap, + Optional: true, + ForceNew: true, + Elem: schema.TypeString, + }, + }, + } +} + +func resourceAwsApiGatewayDeploymentCreate(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).apigateway + // Create the gateway + log.Printf("[DEBUG] Creating API Gateway Deployment") + + variables := make(map[string]string) + for k, v := range d.Get("variables").(map[string]interface{}) { + variables[k] = v.(string) + } + + var err error + deployment, err := conn.CreateDeployment(&apigateway.CreateDeploymentInput{ + RestApiId: aws.String(d.Get("rest_api_id").(string)), + StageName: aws.String(d.Get("stage_name").(string)), + Description: aws.String(d.Get("description").(string)), + StageDescription: aws.String(d.Get("stage_description").(string)), + Variables: aws.StringMap(variables), + }) + if err != nil { + return fmt.Errorf("Error creating API Gateway Deployment: %s", err) + } + + d.SetId(*deployment.Id) + log.Printf("[DEBUG] API Gateway Deployment ID: %s", d.Id()) + + return nil +} + +func resourceAwsApiGatewayDeploymentRead(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).apigateway + + log.Printf("[DEBUG] Reading API Gateway Deployment %s", d.Id()) + out, err := conn.GetDeployment(&apigateway.GetDeploymentInput{ + RestApiId: aws.String(d.Get("rest_api_id").(string)), + DeploymentId: aws.String(d.Id()), + }) + if err != nil { + if awsErr, ok := err.(awserr.Error); ok && awsErr.Code() == "NotFoundException" { + d.SetId("") + return nil + } + return err + } + log.Printf("[DEBUG] Received API Gateway Deployment: %s", out) + d.SetId(*out.Id) + d.Set("description", out.Description) + + return nil +} + +func resourceAwsApiGatewayDeploymentUpdateOperations(d *schema.ResourceData) []*apigateway.PatchOperation { + operations := make([]*apigateway.PatchOperation, 0) + + if d.HasChange("description") { + operations = append(operations, &apigateway.PatchOperation{ + Op: aws.String("replace"), + Path: aws.String("/description"), + Value: aws.String(d.Get("description").(string)), + }) + } + + return operations +} + +func resourceAwsApiGatewayDeploymentUpdate(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).apigateway + + log.Printf("[DEBUG] Updating API Gateway API Key: %s", d.Id()) + + _, err := conn.UpdateDeployment(&apigateway.UpdateDeploymentInput{ + DeploymentId: aws.String(d.Id()), + RestApiId: aws.String(d.Get("rest_api_id").(string)), + PatchOperations: resourceAwsApiGatewayDeploymentUpdateOperations(d), + }) + if err != nil { + return err + } + + return resourceAwsApiGatewayDeploymentRead(d, meta) +} + +func resourceAwsApiGatewayDeploymentDelete(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).apigateway + log.Printf("[DEBUG] Deleting API Gateway Deployment: %s", d.Id()) + + return resource.Retry(5*time.Minute, func() error { + log.Printf("[DEBUG] schema is %#v", d) + if _, err := conn.DeleteStage(&apigateway.DeleteStageInput{ + StageName: aws.String(d.Get("stage_name").(string)), + RestApiId: aws.String(d.Get("rest_api_id").(string)), + }); err == nil { + return nil + } + + _, err := conn.DeleteDeployment(&apigateway.DeleteDeploymentInput{ + DeploymentId: aws.String(d.Id()), + RestApiId: aws.String(d.Get("rest_api_id").(string)), + }) + if err == nil { + return nil + } + + apigatewayErr, ok := err.(awserr.Error) + if apigatewayErr.Code() == "NotFoundException" { + return nil + } + + if !ok { + return resource.RetryError{Err: err} + } + + return resource.RetryError{Err: err} + }) +} diff --git a/builtin/providers/aws/resource_aws_api_gateway_deployment_test.go b/builtin/providers/aws/resource_aws_api_gateway_deployment_test.go new file mode 100644 index 000000000..9da846e51 --- /dev/null +++ b/builtin/providers/aws/resource_aws_api_gateway_deployment_test.go @@ -0,0 +1,157 @@ +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/apigateway" + "github.com/hashicorp/terraform/helper/resource" + "github.com/hashicorp/terraform/terraform" +) + +func TestAccAWSAPIGatewayDeployment_basic(t *testing.T) { + var conf apigateway.Deployment + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckAWSAPIGatewayDeploymentDestroy, + Steps: []resource.TestStep{ + resource.TestStep{ + Config: testAccAWSAPIGatewayDeploymentConfig, + Check: resource.ComposeTestCheckFunc( + testAccCheckAWSAPIGatewayDeploymentExists("aws_api_gateway_deployment.test", &conf), + resource.TestCheckResourceAttr( + "aws_api_gateway_deployment.test", "stage_name", "test"), + resource.TestCheckResourceAttr( + "aws_api_gateway_deployment.test", "description", "This is a test"), + resource.TestCheckResourceAttr( + "aws_api_gateway_deployment.test", "variables.a", "2"), + ), + }, + }, + }) +} + +func testAccCheckAWSAPIGatewayDeploymentExists(n string, res *apigateway.Deployment) 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 API Gateway Deployment ID is set") + } + + conn := testAccProvider.Meta().(*AWSClient).apigateway + + req := &apigateway.GetDeploymentInput{ + DeploymentId: aws.String(rs.Primary.ID), + RestApiId: aws.String(s.RootModule().Resources["aws_api_gateway_rest_api.test"].Primary.ID), + } + describe, err := conn.GetDeployment(req) + if err != nil { + return err + } + + if *describe.Id != rs.Primary.ID { + return fmt.Errorf("APIGateway Deployment not found") + } + + *res = *describe + + return nil + } +} + +func testAccCheckAWSAPIGatewayDeploymentDestroy(s *terraform.State) error { + conn := testAccProvider.Meta().(*AWSClient).apigateway + + for _, rs := range s.RootModule().Resources { + if rs.Type != "aws_api_gateway_resource" { + continue + } + + req := &apigateway.GetDeploymentsInput{ + RestApiId: aws.String(s.RootModule().Resources["aws_api_gateway_rest_api.test"].Primary.ID), + } + describe, err := conn.GetDeployments(req) + + if err == nil { + if len(describe.Items) != 0 && + *describe.Items[0].Id == rs.Primary.ID { + return fmt.Errorf("API Gateway Deployment still exists") + } + } + + aws2err, ok := err.(awserr.Error) + if !ok { + return err + } + if aws2err.Code() != "NotFoundException" { + return err + } + + return nil + } + + return nil +} + +const testAccAWSAPIGatewayDeploymentConfig = ` +resource "aws_api_gateway_rest_api" "test" { + name = "test" +} + +resource "aws_api_gateway_resource" "test" { + rest_api_id = "${aws_api_gateway_rest_api.test.id}" + parent_id = "${aws_api_gateway_rest_api.test.root_resource_id}" + path_part = "test" +} + +resource "aws_api_gateway_method" "test" { + rest_api_id = "${aws_api_gateway_rest_api.test.id}" + resource_id = "${aws_api_gateway_resource.test.id}" + http_method = "GET" + authorization = "NONE" +} + +resource "aws_api_gateway_method_response" "error" { + rest_api_id = "${aws_api_gateway_rest_api.test.id}" + resource_id = "${aws_api_gateway_resource.test.id}" + http_method = "${aws_api_gateway_method.test.http_method}" + status_code = "400" +} + +resource "aws_api_gateway_integration" "test" { + rest_api_id = "${aws_api_gateway_rest_api.test.id}" + resource_id = "${aws_api_gateway_resource.test.id}" + http_method = "${aws_api_gateway_method.test.http_method}" + + type = "HTTP" + uri = "https://www.google.de" + integration_http_method = "GET" +} + +resource "aws_api_gateway_integration_response" "test" { + rest_api_id = "${aws_api_gateway_rest_api.test.id}" + resource_id = "${aws_api_gateway_resource.test.id}" + http_method = "${aws_api_gateway_integration.test.http_method}" + status_code = "${aws_api_gateway_method_response.error.status_code}" +} + +resource "aws_api_gateway_deployment" "test" { + depends_on = ["aws_api_gateway_integration.test"] + + rest_api_id = "${aws_api_gateway_rest_api.test.id}" + stage_name = "test" + description = "This is a test" + + variables = { + "a" = "2" + } +} +` diff --git a/builtin/providers/aws/structure.go b/builtin/providers/aws/structure.go index 04d8f0bdd..b63fa9a66 100644 --- a/builtin/providers/aws/structure.go +++ b/builtin/providers/aws/structure.go @@ -784,6 +784,24 @@ func flattenAsgEnabledMetrics(list []*autoscaling.EnabledMetric) []string { } return strs } + +func expandApiGatewayStageKeys(d *schema.ResourceData) []*apigateway.StageKey { + var stageKeys []*apigateway.StageKey + + if stageKeyData, ok := d.GetOk("stage_key"); ok { + params := stageKeyData.(*schema.Set).List() + for k := range params { + data := params[k].(map[string]interface{}) + stageKeys = append(stageKeys, &apigateway.StageKey{ + RestApiId: aws.String(data["rest_api_id"].(string)), + StageName: aws.String(data["stage_name"].(string)), + }) + } + } + + return stageKeys +} + func expandApiGatewayRequestResponseModelOperations(d *schema.ResourceData, key string, prefix string) []*apigateway.PatchOperation { operations := make([]*apigateway.PatchOperation, 0) @@ -827,3 +845,52 @@ func expandApiGatewayRequestResponseModelOperations(d *schema.ResourceData, key return operations } +func expandApiGatewayStageKeyOperations(d *schema.ResourceData) []*apigateway.PatchOperation { + operations := make([]*apigateway.PatchOperation, 0) + + prev, curr := d.GetChange("stage_key") + prevList := prev.(*schema.Set).List() + currList := curr.(*schema.Set).List() + + for i := range prevList { + p := prevList[i].(map[string]interface{}) + exists := false + + for j := range currList { + c := currList[j].(map[string]interface{}) + if c["rest_api_id"].(string) == p["rest_api_id"].(string) && c["stage_name"].(string) == p["stage_name"].(string) { + exists = true + } + } + + if !exists { + operations = append(operations, &apigateway.PatchOperation{ + Op: aws.String("remove"), + Path: aws.String("/stages"), + Value: aws.String(fmt.Sprintf("%s/%s", p["rest_api_id"].(string), p["stage_name"].(string))), + }) + } + } + + for i := range currList { + c := currList[i].(map[string]interface{}) + exists := false + + for j := range prevList { + p := prevList[j].(map[string]interface{}) + if c["rest_api_id"].(string) == p["rest_api_id"].(string) && c["stage_name"].(string) == p["stage_name"].(string) { + exists = true + } + } + + if !exists { + operations = append(operations, &apigateway.PatchOperation{ + Op: aws.String("add"), + Path: aws.String("/stages"), + Value: aws.String(fmt.Sprintf("%s/%s", c["rest_api_id"].(string), c["stage_name"].(string))), + }) + } + } + + return operations +} diff --git a/website/source/docs/providers/aws/r/api_gateway_deployment.html.markdown b/website/source/docs/providers/aws/r/api_gateway_deployment.html.markdown new file mode 100644 index 000000000..399e69e10 --- /dev/null +++ b/website/source/docs/providers/aws/r/api_gateway_deployment.html.markdown @@ -0,0 +1,55 @@ +--- +layout: "aws" +page_title: "AWS: aws_api_gateway_deployment" +sidebar_current: "docs-aws-resource-api-gateway-deployment" +description: |- + Provides an API Gateway Deployment. +--- + +# aws\_api\_gateway\_deployment + +Provides an API Gateway Deployment. + +-> **Note:** Depends on having `aws_api_gateway_method` inside your rest api. To ensure this +you might need to add an explicit `depends_on` for clean runs. + +## Example Usage + +``` +resource "aws_api_gateway_rest_api" "MyDemoAPI" { + name = "MyDemoAPI" + description = "This is my API for demonstration purposes" +} + +resource "aws_api_gateway_resource" "test" { + rest_api_id = "${aws_api_gateway_rest_api.MyDemoAPI.id}" + parent_id = "${aws_api_gateway_rest_api.MyDemoAPI.root_resource_id}" + path_part = "test" +} + +resource "aws_api_gateway_method" "test" { + rest_api_id = "${aws_api_gateway_rest_api.MyDemoAPI.id}" + resource_id = "${aws_api_gateway_resource.test.id}" + http_method = "GET" + authorization = "NONE" +} + +resource "aws_api_gateway_deployment" "MyDemoDeployment" { + depends_on = ["aws_api_gateway_integration.test"] + + rest_api_id = "${aws_api_gateway_rest_api.MyDemoAPI.id}" + + variables = { + "answer" = "42" + } +} +``` + +## Argument Reference + +The following arguments are supported: + +* `rest_api_id` - (Required) ID of the API Gateway +* `stage_name` - (Required) name of the stage +* `description` - (Optional) name of the stage +* `variables` - (Optional) Stage Variables diff --git a/website/source/layouts/aws.erb b/website/source/layouts/aws.erb index 04850e4d1..7b7bae621 100644 --- a/website/source/layouts/aws.erb +++ b/website/source/layouts/aws.erb @@ -16,6 +16,9 @@ > aws_api_gateway_rest_api + > + aws_api_gateway_deployment + > aws_api_gateway_api_key