From 5268cedf32e1fd553f84001f445c24689e2763bb Mon Sep 17 00:00:00 2001 From: shibataka000 Date: Tue, 4 Jul 2017 15:32:25 +0900 Subject: [PATCH 01/17] Add support for aws_batch_compute_environment. --- aws/config.go | 3 + aws/provider.go | 1 + aws/resource_aws_batch_compute_environment.go | 428 +++++++++++++ ...urce_aws_batch_compute_environment_test.go | 579 ++++++++++++++++++ website/aws.erb | 9 + .../r/batch_compute_environment.html.markdown | 140 +++++ 6 files changed, 1160 insertions(+) create mode 100644 aws/resource_aws_batch_compute_environment.go create mode 100644 aws/resource_aws_batch_compute_environment_test.go create mode 100644 website/docs/r/batch_compute_environment.html.markdown diff --git a/aws/config.go b/aws/config.go index a6e4af6b4660..78b7783a6ac0 100644 --- a/aws/config.go +++ b/aws/config.go @@ -18,6 +18,7 @@ import ( "github.com/aws/aws-sdk-go/service/apigateway" "github.com/aws/aws-sdk-go/service/applicationautoscaling" "github.com/aws/aws-sdk-go/service/autoscaling" + "github.com/aws/aws-sdk-go/service/batch" "github.com/aws/aws-sdk-go/service/cloudformation" "github.com/aws/aws-sdk-go/service/cloudfront" "github.com/aws/aws-sdk-go/service/cloudtrail" @@ -176,6 +177,7 @@ type AWSClient struct { wafconn *waf.WAF wafregionalconn *wafregional.WAFRegional iotconn *iot.IoT + batchconn *batch.Batch } func (c *AWSClient) S3() *s3.S3 { @@ -384,6 +386,7 @@ func (c *Config) Client() (interface{}, error) { client.ssmconn = ssm.New(sess) client.wafconn = waf.New(sess) client.wafregionalconn = wafregional.New(sess) + client.batchconn = batch.New(sess) // Workaround for https://github.com/aws/aws-sdk-go/issues/1376 client.kinesisconn.Handlers.Retry.PushBack(func(r *request.Request) { diff --git a/aws/provider.go b/aws/provider.go index 84e348534a90..13fc0b5f7f78 100644 --- a/aws/provider.go +++ b/aws/provider.go @@ -484,6 +484,7 @@ func Provider() terraform.ResourceProvider { "aws_waf_sql_injection_match_set": resourceAwsWafSqlInjectionMatchSet(), "aws_wafregional_byte_match_set": resourceAwsWafRegionalByteMatchSet(), "aws_wafregional_ipset": resourceAwsWafRegionalIPSet(), + "aws_batch_compute_environment": resourceAwsBatchComputeEnvironment(), }, ConfigureFunc: providerConfigure, } diff --git a/aws/resource_aws_batch_compute_environment.go b/aws/resource_aws_batch_compute_environment.go new file mode 100644 index 000000000000..79c21451f80c --- /dev/null +++ b/aws/resource_aws_batch_compute_environment.go @@ -0,0 +1,428 @@ +package aws + +import ( + "fmt" + "log" + "time" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/batch" + "github.com/hashicorp/terraform/helper/schema" + "github.com/hashicorp/terraform/helper/validation" +) + +func resourceAwsBatchComputeEnvironment() *schema.Resource { + return &schema.Resource{ + Create: resourceAwsBatchComputeEnvironmentCreate, + Read: resourceAwsBatchComputeEnvironmentRead, + Update: resourceAwsBatchComputeEnvironmentUpdate, + Delete: resourceAwsBatchComputeEnvironmentDelete, + + Schema: map[string]*schema.Schema{ + "compute_environment_name": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + }, + "compute_resources": { + Type: schema.TypeList, + Optional: true, + MinItems: 0, + MaxItems: 1, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "bid_percentage": { + Type: schema.TypeInt, + Optional: true, + ForceNew: true, + }, + "desired_vcpus": { + Type: schema.TypeInt, + Optional: true, + }, + "ec2_key_pair": { + Type: schema.TypeString, + Optional: true, + ForceNew: true, + }, + "image_id": { + Type: schema.TypeString, + Optional: true, + ForceNew: true, + }, + "instance_role": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + }, + "instance_type": { + Type: schema.TypeSet, + Required: true, + ForceNew: true, + Elem: &schema.Schema{Type: schema.TypeString}, + Set: schema.HashString, + }, + "max_vcpus": { + Type: schema.TypeInt, + Required: true, + }, + "min_vcpus": { + Type: schema.TypeInt, + Required: true, + }, + "security_group_ids": { + Type: schema.TypeSet, + Required: true, + ForceNew: true, + Elem: &schema.Schema{Type: schema.TypeString}, + Set: schema.HashString, + }, + "spot_iam_fleet_role": { + Type: schema.TypeString, + Optional: true, + ForceNew: true, + }, + "subnets": { + Type: schema.TypeSet, + Required: true, + ForceNew: true, + Elem: &schema.Schema{Type: schema.TypeString}, + Set: schema.HashString, + }, + "tags": tagsSchema(), + "type": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + ValidateFunc: validation.StringInSlice([]string{"EC2", "SPOT"}, true), + }, + }, + }, + }, + "service_role": { + Type: schema.TypeString, + Required: true, + }, + "state": { + Type: schema.TypeString, + Optional: true, + ValidateFunc: validation.StringInSlice([]string{"ENABLED", "DISABLED"}, true), + Default: "ENABLED", + }, + "type": { + Type: schema.TypeString, + Required: true, + ForceNew: true, + ValidateFunc: validation.StringInSlice([]string{"MANAGED", "UNMANAGED"}, true), + }, + "arn": { + Type: schema.TypeString, + Computed: true, + }, + "ecc_cluster_arn": { + Type: schema.TypeString, + Computed: true, + }, + "status": { + Type: schema.TypeString, + Computed: true, + }, + "status_reason": { + Type: schema.TypeString, + Computed: true, + }, + }, + } +} + +func resourceAwsBatchComputeEnvironmentCreate(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).batchconn + + computeEnvironmentName := d.Get("compute_environment_name").(string) + + log.Printf("[DEBUG] Create compute environment \"%s\".\n", computeEnvironmentName) + + serviceRole := d.Get("service_role").(string) + computeEnvironmentType := d.Get("type").(string) + + input := &batch.CreateComputeEnvironmentInput{ + ComputeEnvironmentName: aws.String(computeEnvironmentName), + ServiceRole: aws.String(serviceRole), + Type: aws.String(computeEnvironmentType), + } + + if v, ok := d.GetOk("state"); ok { + input.State = aws.String(v.(string)) + } + + if computeEnvironmentType == "MANAGED" { + computeResources := d.Get("compute_resources").([]interface{}) + if len(computeResources) == 0 { + return fmt.Errorf("One compute environment is expected, but no compute environments are set") + } + computeResource := computeResources[0].(map[string]interface{}) + + instanceRole := computeResource["instance_role"].(string) + maxvCpus := int64(computeResource["max_vcpus"].(int)) + minvCpus := int64(computeResource["min_vcpus"].(int)) + computeResourceType := computeResource["type"].(string) + + var instanceTypes []*string + for _, v := range computeResource["instance_type"].(*schema.Set).List() { + instanceTypes = append(instanceTypes, aws.String(v.(string))) + } + + var securityGroupIds []*string + for _, v := range computeResource["security_group_ids"].(*schema.Set).List() { + securityGroupIds = append(securityGroupIds, aws.String(v.(string))) + } + + var subnets []*string + for _, v := range computeResource["subnets"].(*schema.Set).List() { + subnets = append(subnets, aws.String(v.(string))) + } + + input.ComputeResources = &batch.ComputeResource{ + InstanceRole: aws.String(instanceRole), + InstanceTypes: instanceTypes, + MaxvCpus: aws.Int64(maxvCpus), + MinvCpus: aws.Int64(minvCpus), + SecurityGroupIds: securityGroupIds, + Subnets: subnets, + Type: aws.String(computeResourceType), + } + + if v, ok := computeResource["bid_percentage"]; ok { + input.ComputeResources.BidPercentage = aws.Int64(int64(v.(int))) + } + if v, ok := computeResource["desired_vcpus"]; ok { + input.ComputeResources.DesiredvCpus = aws.Int64(int64(v.(int))) + } + if v, ok := computeResource["ec2_key_pair"]; ok { + input.ComputeResources.Ec2KeyPair = aws.String(v.(string)) + } + if v, ok := computeResource["image_id"]; ok { + input.ComputeResources.ImageId = aws.String(v.(string)) + } + if v, ok := computeResource["spot_iam_fleet_role"]; ok { + input.ComputeResources.SpotIamFleetRole = aws.String(v.(string)) + } + if v, ok := computeResource["tags"]; ok { + input.ComputeResources.Tags = tagsFromMapGeneric(v.(map[string]interface{})) + } + } + + if _, err := conn.CreateComputeEnvironment(input); err != nil { + return err + } + + d.SetId(computeEnvironmentName) + + if err := waitComputeEnvironmentValid(d, meta); err != nil { + return err + } + + return resourceAwsBatchComputeEnvironmentRead(d, meta) +} + +func resourceAwsBatchComputeEnvironmentRead(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).batchconn + + computeEnvironmentName := d.Get("compute_environment_name").(string) + + input := &batch.DescribeComputeEnvironmentsInput{ + ComputeEnvironments: []*string{ + aws.String(computeEnvironmentName), + }, + } + + result, err := conn.DescribeComputeEnvironments(input) + if err != nil { + return err + } + + if len(result.ComputeEnvironments) == 0 { + return fmt.Errorf("One compute environment is expected, but AWS return no compute environment") + } else if len(result.ComputeEnvironments) >= 2 { + return fmt.Errorf("One compute environment is expected, but AWS return too many compute environment") + } + computeEnvironment := result.ComputeEnvironments[0] + + d.Set("service_role", computeEnvironment.ServiceRole) + d.Set("state", computeEnvironment.State) + d.Set("type", computeEnvironment.Type) + + if *(computeEnvironment.Type) == "MANAGED" { + computeResource := computeEnvironment.ComputeResources + + d.Set("compute_resources", []interface{}{ + map[string]interface{}{ + "bid_percentage": computeResource.BidPercentage, + "desired_vcpus": computeResource.DesiredvCpus, + "ec2_key_pair": computeResource.Ec2KeyPair, + "image_id": computeResource.ImageId, + "instance_role": computeResource.InstanceRole, + "instance_type": schema.NewSet(schema.HashString, flattenStringList(computeResource.InstanceTypes)), + "max_vcpus": computeResource.MaxvCpus, + "min_vcpus": computeResource.MinvCpus, + "security_group_ids": schema.NewSet(schema.HashString, flattenStringList(computeResource.SecurityGroupIds)), + "spot_iam_fleet_role": computeResource.SpotIamFleetRole, + "subnets": schema.NewSet(schema.HashString, flattenStringList(computeResource.Subnets)), + "tags": tagsToMapGeneric(computeResource.Tags), + "type": computeResource.Type, + }, + }) + } + + d.Set("arn", computeEnvironment.ComputeEnvironmentArn) + d.Set("ecc_cluster_arn", computeEnvironment.ComputeEnvironmentArn) + d.Set("status", computeEnvironment.Status) + d.Set("status_reason", computeEnvironment.StatusReason) + + return nil +} + +func resourceAwsBatchComputeEnvironmentDelete(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).batchconn + + computeEnvironmentName := d.Get("compute_environment_name").(string) + + log.Printf("[DEBUG] Delete compute environment \"%s\".\n", computeEnvironmentName) + + updateInput := &batch.UpdateComputeEnvironmentInput{ + ComputeEnvironment: aws.String(computeEnvironmentName), + State: aws.String("DISABLED"), + } + + if _, err := conn.UpdateComputeEnvironment(updateInput); err != nil { + return err + } + + if err := waitComputeEnvironmentValid(d, meta); err != nil { + return err + } + + input := &batch.DeleteComputeEnvironmentInput{ + ComputeEnvironment: aws.String(computeEnvironmentName), + } + + if _, err := conn.DeleteComputeEnvironment(input); err != nil { + return err + } + + if err := waitComputeEnvironmentDeleted(d, meta); err != nil { + return err + } + + d.SetId("") + + return nil +} + +func resourceAwsBatchComputeEnvironmentUpdate(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).batchconn + + computeEnvironmentName := d.Get("compute_environment_name").(string) + + log.Printf("[DEBUG] Update compute environment \"%s\".\n", computeEnvironmentName) + + input := &batch.UpdateComputeEnvironmentInput{ + ComputeEnvironment: aws.String(computeEnvironmentName), + ComputeResources: &batch.ComputeResourceUpdate{}, + } + + if d.HasChange("service_role") { + log.Printf("[DEBUG] Service role of \"%s\" has change.\n", computeEnvironmentName) + input.ServiceRole = aws.String(d.Get("service_role").(string)) + } + if d.HasChange("state") { + log.Printf("[DEBUG] State of \"%s\" has change.\n", computeEnvironmentName) + input.ServiceRole = aws.String(d.Get("state").(string)) + } + + if d.HasChange("compute_resources") { + log.Printf("[DEBUG] Compute resources of \"%s\" has change.\n", computeEnvironmentName) + computeResources := d.Get("compute_resources").([]interface{}) + if len(computeResources) == 0 { + return fmt.Errorf("One compute environment is expected, but no compute environments are set") + } + computeResource := computeResources[0].(map[string]interface{}) + + if d.HasChange("compute_resources.0.desired_vcpus") { + log.Printf("[DEBUG] Desired vCpus of \"%s\" has change.\n", computeEnvironmentName) + input.ComputeResources.DesiredvCpus = aws.Int64(int64(computeResource["desired_vcpus"].(int))) + } + if d.HasChange("compute_resources.0.max_vcpus") { + log.Printf("[DEBUG] Max vCpus of \"%s\" has change.\n", computeEnvironmentName) + input.ComputeResources.MaxvCpus = aws.Int64(int64(computeResource["max_vcpus"].(int))) + } + if d.HasChange("compute_resources.0.min_vcpus") { + log.Printf("[DEBUG] Min vCpus of \"%s\" has change.\n", computeEnvironmentName) + input.ComputeResources.MinvCpus = aws.Int64(int64(computeResource["min_vcpus"].(int))) + } + } + + if _, err := conn.UpdateComputeEnvironment(input); err != nil { + return err + } + + return resourceAwsBatchComputeEnvironmentRead(d, meta) +} + +func waitComputeEnvironmentValid(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).batchconn + + computeEnvironmentName := d.Get("compute_environment_name").(string) + + for { + result, err := conn.DescribeComputeEnvironments(&batch.DescribeComputeEnvironmentsInput{ + ComputeEnvironments: []*string{ + aws.String(computeEnvironmentName), + }, + }) + if err != nil { + return err + } + + if len(result.ComputeEnvironments) == 0 { + return fmt.Errorf("One compute environment is expected, but AWS return no compute environment") + } else if len(result.ComputeEnvironments) >= 2 { + return fmt.Errorf("One compute environment is expected, but AWS return too many compute environment") + } + computeEnvironment := result.ComputeEnvironments[0] + if *(computeEnvironment.Status) == "VALID" { + break + } else { + time.Sleep(1 * time.Second) + } + } + + log.Printf("[DEBUG] Status of compute environment \"%s\" get VALID.\n", computeEnvironmentName) + return nil +} + +func waitComputeEnvironmentDeleted(d *schema.ResourceData, meta interface{}) error { + conn := meta.(*AWSClient).batchconn + + computeEnvironmentName := d.Get("compute_environment_name").(string) + + for { + result, err := conn.DescribeComputeEnvironments(&batch.DescribeComputeEnvironmentsInput{ + ComputeEnvironments: []*string{ + aws.String(computeEnvironmentName), + }, + }) + if err != nil { + return err + } + + if len(result.ComputeEnvironments) == 0 { + break + } else { + time.Sleep(1 * time.Second) + } + } + + log.Printf("[DEBUG] Compute environment \"%s\" deleted.\n", computeEnvironmentName) + return nil +} diff --git a/aws/resource_aws_batch_compute_environment_test.go b/aws/resource_aws_batch_compute_environment_test.go new file mode 100644 index 000000000000..3507ff5b91c6 --- /dev/null +++ b/aws/resource_aws_batch_compute_environment_test.go @@ -0,0 +1,579 @@ +package aws + +import ( + "fmt" + "regexp" + "testing" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/batch" + "github.com/hashicorp/terraform/helper/resource" + "github.com/hashicorp/terraform/terraform" +) + +func TestAccAWSBatchComputeEnvironment_createEc2(t *testing.T) { + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckBatchComputeEnvironmentDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAWSBatchComputeEnvironmentConfigEC2, + Check: resource.ComposeTestCheckFunc( + testAccCheckAwsBatchComputeEnvironmentExists(), + ), + }, + }, + }) +} + +func TestAccAWSBatchComputeEnvironment_createEc2WithTags(t *testing.T) { + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckBatchComputeEnvironmentDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAWSBatchComputeEnvironmentConfigEC2WithTags, + Check: resource.ComposeTestCheckFunc( + testAccCheckAwsBatchComputeEnvironmentExists(), + resource.TestCheckResourceAttr("aws_batch_compute_environment.ec2", "compute_resources.0.tags.%", "1"), + resource.TestCheckResourceAttr("aws_batch_compute_environment.ec2", "compute_resources.0.tags.Key1", "Value1"), + ), + }, + }, + }) +} + +func TestAccAWSBatchComputeEnvironment_createSpot(t *testing.T) { + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckBatchComputeEnvironmentDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAWSBatchComputeEnvironmentConfigSpot, + Check: resource.ComposeTestCheckFunc( + testAccCheckAwsBatchComputeEnvironmentExists(), + ), + }, + }, + }) +} + +func TestAccAWSBatchComputeEnvironment_createUnmanaged(t *testing.T) { + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckBatchComputeEnvironmentDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAWSBatchComputeEnvironmentConfigUnmanaged, + Check: resource.ComposeTestCheckFunc( + testAccCheckAwsBatchComputeEnvironmentExists(), + ), + }, + }, + }) +} + +func TestAccAWSBatchComputeEnvironment_updateMaxvCpus(t *testing.T) { + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckBatchComputeEnvironmentDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAWSBatchComputeEnvironmentConfigEC2, + Check: resource.ComposeTestCheckFunc( + testAccCheckAwsBatchComputeEnvironmentExists(), + resource.TestCheckResourceAttr("aws_batch_compute_environment.ec2", "compute_resources.0.max_vcpus", "16"), + ), + }, + { + Config: testAccAWSBatchComputeEnvironmentConfigEC2UpdateMaxvCpus, + Check: resource.ComposeTestCheckFunc( + testAccCheckAwsBatchComputeEnvironmentExists(), + resource.TestCheckResourceAttr("aws_batch_compute_environment.ec2", "compute_resources.0.max_vcpus", "32"), + ), + }, + }, + }) +} + +func TestAccAWSBatchComputeEnvironment_updateInstanceType(t *testing.T) { + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckBatchComputeEnvironmentDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAWSBatchComputeEnvironmentConfigEC2, + Check: resource.ComposeTestCheckFunc( + testAccCheckAwsBatchComputeEnvironmentExists(), + resource.TestCheckResourceAttr("aws_batch_compute_environment.ec2", "compute_resources.0.instance_type.#", "1"), + ), + }, + { + Config: testAccAWSBatchComputeEnvironmentConfigEC2UpdateInstanceType, + Check: resource.ComposeTestCheckFunc( + testAccCheckAwsBatchComputeEnvironmentExists(), + resource.TestCheckResourceAttr("aws_batch_compute_environment.ec2", "compute_resources.0.instance_type.#", "2"), + ), + }, + }, + }) +} + +func TestAccAWSBatchComputeEnvironment_updateComputeEnvironmentName(t *testing.T) { + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckBatchComputeEnvironmentDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAWSBatchComputeEnvironmentConfigEC2, + Check: resource.ComposeTestCheckFunc( + testAccCheckAwsBatchComputeEnvironmentExists(), + resource.TestCheckResourceAttr("aws_batch_compute_environment.ec2", "compute_environment_name", "sample"), + ), + }, + { + Config: testAccAWSBatchComputeEnvironmentConfigEC2UpdateComputeEnvironmentName, + Check: resource.ComposeTestCheckFunc( + testAccCheckAwsBatchComputeEnvironmentExists(), + resource.TestCheckResourceAttr("aws_batch_compute_environment.ec2", "compute_environment_name", "sample_updated"), + ), + }, + }, + }) +} + +func TestAccAWSBatchComputeEnvironment_createEc2WithoutComputeResources(t *testing.T) { + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckBatchComputeEnvironmentDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAWSBatchComputeEnvironmentConfigEC2WithoutComputeResources, + ExpectError: regexp.MustCompile(`One compute environment is expected, but no compute environments are set`), + }, + }, + }) +} + +func TestAccAWSBatchComputeEnvironment_createUnmanagedWithComputeResources(t *testing.T) { + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckBatchComputeEnvironmentDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAWSBatchComputeEnvironmentConfigUnmanagedWithComputeResources, + Check: resource.ComposeTestCheckFunc( + testAccCheckAwsBatchComputeEnvironmentExists(), + resource.TestCheckResourceAttr("aws_batch_compute_environment.unmanaged", "type", "UNMANAGED"), + ), + }, + }, + }) +} + +func TestAccAWSBatchComputeEnvironment_createSpotWithoutBidPercentage(t *testing.T) { + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckBatchComputeEnvironmentDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAWSBatchComputeEnvironmentConfigSpotWithoutBidPercentage, + ExpectError: regexp.MustCompile(`ComputeResources.spotIamFleetRole cannot not be null or empty`), + }, + }, + }) +} + +func testAccCheckBatchComputeEnvironmentDestroy(s *terraform.State) error { + conn := testAccProvider.Meta().(*AWSClient).batchconn + + for _, rs := range s.RootModule().Resources { + if rs.Type != "aws_batch_compute_environment" { + continue + } + + result, err := conn.DescribeComputeEnvironments(&batch.DescribeComputeEnvironmentsInput{ + ComputeEnvironments: []*string{ + aws.String(rs.Primary.ID), + }, + }) + + if err != nil { + return fmt.Errorf("Error occured when get compute environment information.") + } + if len(result.ComputeEnvironments) == 1 { + return fmt.Errorf("Compute environment still exists.") + } + + } + + return nil +} + +func testAccCheckAwsBatchComputeEnvironmentExists() resource.TestCheckFunc { + return func(s *terraform.State) error { + conn := testAccProvider.Meta().(*AWSClient).batchconn + + for _, rs := range s.RootModule().Resources { + if rs.Type != "aws_batch_compute_environment" { + continue + } + + result, err := conn.DescribeComputeEnvironments(&batch.DescribeComputeEnvironmentsInput{ + ComputeEnvironments: []*string{ + aws.String(rs.Primary.ID), + }, + }) + + if err != nil { + return fmt.Errorf("Error occured when get compute environment information.") + } + if len(result.ComputeEnvironments) == 0 { + return fmt.Errorf("Compute environment doesn't exists.") + } else if len(result.ComputeEnvironments) >= 2 { + return fmt.Errorf("Too many compute environments exist.") + } + } + + return nil + } +} + +const testAccAWSBatchComputeEnvironmentConfigBase = ` + +########## ecs_instance_role ########## + +resource "aws_iam_role" "ecs_instance_role" { + name = "ecs_instance_role" + assume_role_policy = < + > + Batch + + + > CloudFormation Resources
    diff --git a/website/docs/r/batch_compute_environment.html.markdown b/website/docs/r/batch_compute_environment.html.markdown new file mode 100644 index 000000000000..fed43c617e1d --- /dev/null +++ b/website/docs/r/batch_compute_environment.html.markdown @@ -0,0 +1,140 @@ +--- +layout: "aws" +page_title: "AWS: aws_batch_compute_environment" +sidebar_current: "docs-aws-resource-batch-compute-environment" +description: |- + Creates a AWS Batch compute environment. +--- + +# aws\_batch\_compute\_environment + +Creates a AWS Batch compute environment. Compute environments contain the Amazon ECS container instances that are used to run containerized batch jobs. + +For information about AWS Batch, see [What is AWS Batch?][1] . +For information about compute environment, see [Compute Environments][2] . + +## Example Usage + +```hcl +resource "aws_iam_role" "ecs_instance_role" { + name = "ecs_instance_role" + assume_role_policy = < Date: Mon, 28 Aug 2017 23:27:25 +0900 Subject: [PATCH 02/17] Fix document about batch_compute_environment --- .../r/batch_compute_environment.html.markdown | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-) diff --git a/website/docs/r/batch_compute_environment.html.markdown b/website/docs/r/batch_compute_environment.html.markdown index fed43c617e1d..fb25a1345599 100644 --- a/website/docs/r/batch_compute_environment.html.markdown +++ b/website/docs/r/batch_compute_environment.html.markdown @@ -105,27 +105,24 @@ resource "aws_batch_compute_environment" "sample" { ## Argument Reference * `compute_environment_name` - (Required) The name for your compute environment. Up to 128 letters (uppercase and lowercase), numbers, and underscores are allowed. -* `compute_resources` - (Optional) Details of the compute resources managed by the compute environment. This parameter is required for managed compute environments. +* `compute_resources` - (Optional) Details of the compute resources managed by the compute environment. This parameter is required for managed compute environments. See details below. * `service_role` - (Required) The full Amazon Resource Name (ARN) of the IAM role that allows AWS Batch to make calls to other AWS services on your behalf. * `state` - (Optional) The state of the compute environment. If the state is `ENABLED`, then the compute environment accepts jobs from a queue and can scale out automatically based on queues. Valid items are `ENABLED` or `DISABLED`. Defaults to `ENABLED`. * `type` - (Required) The type of the compute environment. Valid items are `MANAGED` or `UNMANAGED`. **compute_resources** is a child block with a single argument: -* `bid_percentage` - (Optional) The minimum percentage that a Spot Instance price must be when compared with the On-Demand price for that instance type before instances are launched. - For example, if your bid percentage is 20%, then the Spot price must be below 20% of the current On-Demand price for that EC2 instance. - This parameter is required for SPOT compute environments. +* `bid_percentage` - (Optional) The minimum percentage that a Spot Instance price must be when compared with the On-Demand price for that instance type before instances are launched. For example, if your bid percentage is 20%, then the Spot price must be below 20% of the current On-Demand price for that EC2 instance. This parameter is required for SPOT compute environments. * `desired_vcpus` - (Optional) The desired number of EC2 vCPUS in the compute environment. * `ec2_key_pair` - (Optional) The EC2 key pair that is used for instances launched in the compute environment. * `image_id` - (Optional) The Amazon Machine Image (AMI) ID used for instances launched in the compute environment. * `instance_role` - (Required) The Amazon ECS instance role applied to Amazon EC2 instances in a compute environment. -* `instance_type` - (Required) The instances types that may launched. +* `instance_type` - (Required) A list of instance types that may be launched. * `max_vcpus` - (Required) The maximum number of EC2 vCPUs that an environment can reach. * `min_vcpus` - (Required) The minimum number of EC2 vCPUs that an environment should maintain. -* `security_group_ids` - (Required) The EC2 security group that is associated with instances launched in the compute environment. -* `spot_iam_fleet_role` - (Optional) The Amazon Resource Name (ARN) of the Amazon EC2 Spot Fleet IAM role applied to a SPOT compute environment. - This parameter is required for SPOT compute environments. -* `subnets` - (Required) The VPC subnets into which the compute resources are launched. +* `security_group_ids` - (Required) A list of EC2 security group that are associated with instances launched in the compute environment. +* `spot_iam_fleet_role` - (Optional) The Amazon Resource Name (ARN) of the Amazon EC2 Spot Fleet IAM role applied to a SPOT compute environment. This parameter is required for SPOT compute environments. +* `subnets` - (Required) A list of VPC subnets into which the compute resources are launched. * `tags` - (Optional) Key-value pair tags to be applied to resources that are launched in the compute environment. * `type` - (Required) The type of compute environment. Valid items are `EC2` or `SPOT`. From 8ce14c502259ec4bd63110c33f33ad748d6669a1 Mon Sep 17 00:00:00 2001 From: shibataka000 Date: Mon, 28 Aug 2017 23:42:39 +0900 Subject: [PATCH 03/17] Use const instead of literal in resource_aws_batch_compute_environment.go --- aws/resource_aws_batch_compute_environment.go | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/aws/resource_aws_batch_compute_environment.go b/aws/resource_aws_batch_compute_environment.go index 79c21451f80c..b6422b637ba8 100644 --- a/aws/resource_aws_batch_compute_environment.go +++ b/aws/resource_aws_batch_compute_environment.go @@ -11,6 +11,15 @@ import ( "github.com/hashicorp/terraform/helper/validation" ) +const ( + MANAGED = "MANAGED" + UNMANAGED = "UNMANAGED" + EC2 = "EC2" + SPOT = "SPOT" + ENABLED = "ENABLED" + DISABLED = "DISABLED" +) + func resourceAwsBatchComputeEnvironment() *schema.Resource { return &schema.Resource{ Create: resourceAwsBatchComputeEnvironmentCreate, @@ -94,7 +103,7 @@ func resourceAwsBatchComputeEnvironment() *schema.Resource { Type: schema.TypeString, Required: true, ForceNew: true, - ValidateFunc: validation.StringInSlice([]string{"EC2", "SPOT"}, true), + ValidateFunc: validation.StringInSlice([]string{EC2, SPOT}, true), }, }, }, @@ -106,14 +115,14 @@ func resourceAwsBatchComputeEnvironment() *schema.Resource { "state": { Type: schema.TypeString, Optional: true, - ValidateFunc: validation.StringInSlice([]string{"ENABLED", "DISABLED"}, true), + ValidateFunc: validation.StringInSlice([]string{ENABLED, DISABLED}, true), Default: "ENABLED", }, "type": { Type: schema.TypeString, Required: true, ForceNew: true, - ValidateFunc: validation.StringInSlice([]string{"MANAGED", "UNMANAGED"}, true), + ValidateFunc: validation.StringInSlice([]string{MANAGED, UNMANAGED}, true), }, "arn": { Type: schema.TypeString, @@ -155,7 +164,7 @@ func resourceAwsBatchComputeEnvironmentCreate(d *schema.ResourceData, meta inter input.State = aws.String(v.(string)) } - if computeEnvironmentType == "MANAGED" { + if computeEnvironmentType == MANAGED { computeResources := d.Get("compute_resources").([]interface{}) if len(computeResources) == 0 { return fmt.Errorf("One compute environment is expected, but no compute environments are set") @@ -291,7 +300,7 @@ func resourceAwsBatchComputeEnvironmentDelete(d *schema.ResourceData, meta inter updateInput := &batch.UpdateComputeEnvironmentInput{ ComputeEnvironment: aws.String(computeEnvironmentName), - State: aws.String("DISABLED"), + State: aws.String(DISABLED), } if _, err := conn.UpdateComputeEnvironment(updateInput); err != nil { From 6b487f01f9b836393cc163076dd410607585a398 Mon Sep 17 00:00:00 2001 From: shibataka000 Date: Mon, 28 Aug 2017 23:51:02 +0900 Subject: [PATCH 04/17] Omit unnecessary parameter in resource_aws_batch_compute_environment.go --- aws/resource_aws_batch_compute_environment.go | 3 --- 1 file changed, 3 deletions(-) diff --git a/aws/resource_aws_batch_compute_environment.go b/aws/resource_aws_batch_compute_environment.go index b6422b637ba8..d6dc5fd1dea5 100644 --- a/aws/resource_aws_batch_compute_environment.go +++ b/aws/resource_aws_batch_compute_environment.go @@ -69,7 +69,6 @@ func resourceAwsBatchComputeEnvironment() *schema.Resource { Required: true, ForceNew: true, Elem: &schema.Schema{Type: schema.TypeString}, - Set: schema.HashString, }, "max_vcpus": { Type: schema.TypeInt, @@ -84,7 +83,6 @@ func resourceAwsBatchComputeEnvironment() *schema.Resource { Required: true, ForceNew: true, Elem: &schema.Schema{Type: schema.TypeString}, - Set: schema.HashString, }, "spot_iam_fleet_role": { Type: schema.TypeString, @@ -96,7 +94,6 @@ func resourceAwsBatchComputeEnvironment() *schema.Resource { Required: true, ForceNew: true, Elem: &schema.Schema{Type: schema.TypeString}, - Set: schema.HashString, }, "tags": tagsSchema(), "type": { From 57e0021788e76d7c586f2fa424b7487c68d02eb6 Mon Sep 17 00:00:00 2001 From: shibataka000 Date: Tue, 29 Aug 2017 21:41:58 +0900 Subject: [PATCH 05/17] Validate compute environment name in resource_aws_batch_compute_environment.go --- aws/resource_aws_batch_compute_environment.go | 25 +++- ...urce_aws_batch_compute_environment_test.go | 113 ++++++++++++++++++ 2 files changed, 135 insertions(+), 3 deletions(-) diff --git a/aws/resource_aws_batch_compute_environment.go b/aws/resource_aws_batch_compute_environment.go index d6dc5fd1dea5..17a79dd81979 100644 --- a/aws/resource_aws_batch_compute_environment.go +++ b/aws/resource_aws_batch_compute_environment.go @@ -3,6 +3,7 @@ package aws import ( "fmt" "log" + "regexp" "time" "github.com/aws/aws-sdk-go/aws" @@ -20,6 +21,8 @@ const ( DISABLED = "DISABLED" ) +var reComputeEnvironmentName = regexp.MustCompile(`^[A-Za-z0-9_]*$`) + func resourceAwsBatchComputeEnvironment() *schema.Resource { return &schema.Resource{ Create: resourceAwsBatchComputeEnvironmentCreate, @@ -29,9 +32,10 @@ func resourceAwsBatchComputeEnvironment() *schema.Resource { Schema: map[string]*schema.Schema{ "compute_environment_name": { - Type: schema.TypeString, - Required: true, - ForceNew: true, + Type: schema.TypeString, + Required: true, + ForceNew: true, + ValidateFunc: isCorrentComputeEnvironmentName, }, "compute_resources": { Type: schema.TypeList, @@ -432,3 +436,18 @@ func waitComputeEnvironmentDeleted(d *schema.ResourceData, meta interface{}) err log.Printf("[DEBUG] Compute environment \"%s\" deleted.\n", computeEnvironmentName) return nil } + +func isCorrentComputeEnvironmentName(i interface{}, k string) (s []string, es []error) { + v, ok := i.(string) + if !ok { + es = append(es, fmt.Errorf("expected type of %s to be string", k)) + return + } + + if !(reComputeEnvironmentName.MatchString(v) && len(v) <= 128) { + es = append(es, fmt.Errorf("computeEnvironmentName must be up to 128 letters (uppercase and lowercase), numbers, and underscores.")) + return + } + + return +} diff --git a/aws/resource_aws_batch_compute_environment_test.go b/aws/resource_aws_batch_compute_environment_test.go index 3507ff5b91c6..b1914048d338 100644 --- a/aws/resource_aws_batch_compute_environment_test.go +++ b/aws/resource_aws_batch_compute_environment_test.go @@ -194,6 +194,50 @@ func TestAccAWSBatchComputeEnvironment_createSpotWithoutBidPercentage(t *testing }) } +func TestAccAWSBatchComputeEnvironment_createEc2WithGoodComputeEnvironmentName(t *testing.T) { + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckBatchComputeEnvironmentDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAWSBatchComputeEnvironmentConfigEC2WithGoodComputeEnvironmentName, + Check: resource.ComposeTestCheckFunc( + testAccCheckAwsBatchComputeEnvironmentExists(), + ), + }, + }, + }) +} + +func TestAccAWSBatchComputeEnvironment_createEc2WithBadComputeEnvironmentName1(t *testing.T) { + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckBatchComputeEnvironmentDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAWSBatchComputeEnvironmentConfigEC2WithBadComputeEnvironmentName1, + ExpectError: regexp.MustCompile(`computeEnvironmentName must be up to 128 letters \(uppercase and lowercase\), numbers, and underscores.`), + }, + }, + }) +} + +func TestAccAWSBatchComputeEnvironment_createEc2WithBadComputeEnvironmentName2(t *testing.T) { + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckBatchComputeEnvironmentDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAWSBatchComputeEnvironmentConfigEC2WithBadComputeEnvironmentName2, + ExpectError: regexp.MustCompile(`computeEnvironmentName must be up to 128 letters \(uppercase and lowercase\), numbers, and underscores.`), + }, + }, + }) +} + func testAccCheckBatchComputeEnvironmentDestroy(s *terraform.State) error { conn := testAccProvider.Meta().(*AWSClient).batchconn @@ -577,3 +621,72 @@ resource "aws_batch_compute_environment" "ec2" { type = "MANAGED" } ` + +const testAccAWSBatchComputeEnvironmentConfigEC2WithGoodComputeEnvironmentName = testAccAWSBatchComputeEnvironmentConfigBase + ` +resource "aws_batch_compute_environment" "ec2" { + compute_environment_name = "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678" + compute_resources { + instance_role = "${aws_iam_instance_profile.ecs_instance_role.arn}" + instance_type = [ + "c4.large", + ] + max_vcpus = 16 + min_vcpus = 0 + security_group_ids = [ + "${aws_security_group.test_acc.id}" + ] + subnets = [ + "${aws_subnet.test_acc.id}" + ] + type = "EC2" + } + service_role = "${aws_iam_role.aws_batch_service_role.arn}" + type = "MANAGED" +} +` + +const testAccAWSBatchComputeEnvironmentConfigEC2WithBadComputeEnvironmentName1 = testAccAWSBatchComputeEnvironmentConfigBase + ` +resource "aws_batch_compute_environment" "ec2" { + compute_environment_name = "sam@ple" + compute_resources { + instance_role = "${aws_iam_instance_profile.ecs_instance_role.arn}" + instance_type = [ + "c4.large", + ] + max_vcpus = 16 + min_vcpus = 0 + security_group_ids = [ + "${aws_security_group.test_acc.id}" + ] + subnets = [ + "${aws_subnet.test_acc.id}" + ] + type = "EC2" + } + service_role = "${aws_iam_role.aws_batch_service_role.arn}" + type = "MANAGED" +} +` + +const testAccAWSBatchComputeEnvironmentConfigEC2WithBadComputeEnvironmentName2 = testAccAWSBatchComputeEnvironmentConfigBase + ` +resource "aws_batch_compute_environment" "ec2" { + compute_environment_name = "123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" + compute_resources { + instance_role = "${aws_iam_instance_profile.ecs_instance_role.arn}" + instance_type = [ + "c4.large", + ] + max_vcpus = 16 + min_vcpus = 0 + security_group_ids = [ + "${aws_security_group.test_acc.id}" + ] + subnets = [ + "${aws_subnet.test_acc.id}" + ] + type = "EC2" + } + service_role = "${aws_iam_role.aws_batch_service_role.arn}" + type = "MANAGED" +} +` From 1646dfe8c5b102733c6ce79eeebbe33cd9fe0bdd Mon Sep 17 00:00:00 2001 From: shibataka000 Date: Tue, 29 Aug 2017 21:43:27 +0900 Subject: [PATCH 06/17] Write ComputeEnvironmentInput struct to log instead of comput environment name --- aws/resource_aws_batch_compute_environment.go | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/aws/resource_aws_batch_compute_environment.go b/aws/resource_aws_batch_compute_environment.go index 17a79dd81979..3d443b6b1773 100644 --- a/aws/resource_aws_batch_compute_environment.go +++ b/aws/resource_aws_batch_compute_environment.go @@ -150,8 +150,6 @@ func resourceAwsBatchComputeEnvironmentCreate(d *schema.ResourceData, meta inter computeEnvironmentName := d.Get("compute_environment_name").(string) - log.Printf("[DEBUG] Create compute environment \"%s\".\n", computeEnvironmentName) - serviceRole := d.Get("service_role").(string) computeEnvironmentType := d.Get("type").(string) @@ -222,6 +220,8 @@ func resourceAwsBatchComputeEnvironmentCreate(d *schema.ResourceData, meta inter } } + log.Printf("[DEBUG] Create compute environment %s.\n", input) + if _, err := conn.CreateComputeEnvironment(input); err != nil { return err } @@ -246,6 +246,8 @@ func resourceAwsBatchComputeEnvironmentRead(d *schema.ResourceData, meta interfa }, } + log.Printf("[DEBUG] Read compute environment %s.\n", input) + result, err := conn.DescribeComputeEnvironments(input) if err != nil { return err @@ -297,13 +299,13 @@ func resourceAwsBatchComputeEnvironmentDelete(d *schema.ResourceData, meta inter computeEnvironmentName := d.Get("compute_environment_name").(string) - log.Printf("[DEBUG] Delete compute environment \"%s\".\n", computeEnvironmentName) - updateInput := &batch.UpdateComputeEnvironmentInput{ ComputeEnvironment: aws.String(computeEnvironmentName), State: aws.String(DISABLED), } + log.Printf("[DEBUG] Delete compute environment %s.\n", updateInput) + if _, err := conn.UpdateComputeEnvironment(updateInput); err != nil { return err } @@ -334,8 +336,6 @@ func resourceAwsBatchComputeEnvironmentUpdate(d *schema.ResourceData, meta inter computeEnvironmentName := d.Get("compute_environment_name").(string) - log.Printf("[DEBUG] Update compute environment \"%s\".\n", computeEnvironmentName) - input := &batch.UpdateComputeEnvironmentInput{ ComputeEnvironment: aws.String(computeEnvironmentName), ComputeResources: &batch.ComputeResourceUpdate{}, @@ -372,6 +372,8 @@ func resourceAwsBatchComputeEnvironmentUpdate(d *schema.ResourceData, meta inter } } + log.Printf("[DEBUG] Update compute environment %s.\n", input) + if _, err := conn.UpdateComputeEnvironment(input); err != nil { return err } From 6a4a03dbcbfa721c51f4c6adebab6d8827a571e8 Mon Sep 17 00:00:00 2001 From: shibataka000 Date: Tue, 29 Aug 2017 21:44:10 +0900 Subject: [PATCH 07/17] Stop writing log about changing of each fields because of unnecessity --- aws/resource_aws_batch_compute_environment.go | 6 ------ 1 file changed, 6 deletions(-) diff --git a/aws/resource_aws_batch_compute_environment.go b/aws/resource_aws_batch_compute_environment.go index 3d443b6b1773..48b6b3c3789b 100644 --- a/aws/resource_aws_batch_compute_environment.go +++ b/aws/resource_aws_batch_compute_environment.go @@ -342,16 +342,13 @@ func resourceAwsBatchComputeEnvironmentUpdate(d *schema.ResourceData, meta inter } if d.HasChange("service_role") { - log.Printf("[DEBUG] Service role of \"%s\" has change.\n", computeEnvironmentName) input.ServiceRole = aws.String(d.Get("service_role").(string)) } if d.HasChange("state") { - log.Printf("[DEBUG] State of \"%s\" has change.\n", computeEnvironmentName) input.ServiceRole = aws.String(d.Get("state").(string)) } if d.HasChange("compute_resources") { - log.Printf("[DEBUG] Compute resources of \"%s\" has change.\n", computeEnvironmentName) computeResources := d.Get("compute_resources").([]interface{}) if len(computeResources) == 0 { return fmt.Errorf("One compute environment is expected, but no compute environments are set") @@ -359,15 +356,12 @@ func resourceAwsBatchComputeEnvironmentUpdate(d *schema.ResourceData, meta inter computeResource := computeResources[0].(map[string]interface{}) if d.HasChange("compute_resources.0.desired_vcpus") { - log.Printf("[DEBUG] Desired vCpus of \"%s\" has change.\n", computeEnvironmentName) input.ComputeResources.DesiredvCpus = aws.Int64(int64(computeResource["desired_vcpus"].(int))) } if d.HasChange("compute_resources.0.max_vcpus") { - log.Printf("[DEBUG] Max vCpus of \"%s\" has change.\n", computeEnvironmentName) input.ComputeResources.MaxvCpus = aws.Int64(int64(computeResource["max_vcpus"].(int))) } if d.HasChange("compute_resources.0.min_vcpus") { - log.Printf("[DEBUG] Min vCpus of \"%s\" has change.\n", computeEnvironmentName) input.ComputeResources.MinvCpus = aws.Int64(int64(computeResource["min_vcpus"].(int))) } } From 216c73339d8654e38ff7f4d7a69e22a83339a09c Mon Sep 17 00:00:00 2001 From: shibataka000 Date: Tue, 29 Aug 2017 21:10:12 +0900 Subject: [PATCH 08/17] Use StateChangeConf to wait status of compute envrionment in AWS Batch change --- aws/resource_aws_batch_compute_environment.go | 78 ++++++++++++------- 1 file changed, 48 insertions(+), 30 deletions(-) diff --git a/aws/resource_aws_batch_compute_environment.go b/aws/resource_aws_batch_compute_environment.go index 48b6b3c3789b..ff8de99d9c99 100644 --- a/aws/resource_aws_batch_compute_environment.go +++ b/aws/resource_aws_batch_compute_environment.go @@ -8,6 +8,7 @@ import ( "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/service/batch" + "github.com/hashicorp/terraform/helper/resource" "github.com/hashicorp/terraform/helper/schema" "github.com/hashicorp/terraform/helper/validation" ) @@ -19,6 +20,12 @@ const ( SPOT = "SPOT" ENABLED = "ENABLED" DISABLED = "DISABLED" + CREATING = "CREATING" + DELETING = "DELETING" + UPDATING = "UPDATING" + DELETED = "DELETED" + VALID = "VALID" + FAILED = "FAILED" ) var reComputeEnvironmentName = regexp.MustCompile(`^[A-Za-z0-9_]*$`) @@ -228,7 +235,14 @@ func resourceAwsBatchComputeEnvironmentCreate(d *schema.ResourceData, meta inter d.SetId(computeEnvironmentName) - if err := waitComputeEnvironmentValid(d, meta); err != nil { + stateConf := &resource.StateChangeConf{ + Pending: []string{CREATING}, + Target: []string{VALID}, + Refresh: resourceAwsBatchComputeEnvironmentStatusRefreshFunc(d, meta), + Timeout: d.Timeout(schema.TimeoutCreate), + MinTimeout: 5 * time.Second, + } + if _, err := stateConf.WaitForState(); err != nil { return err } @@ -310,7 +324,14 @@ func resourceAwsBatchComputeEnvironmentDelete(d *schema.ResourceData, meta inter return err } - if err := waitComputeEnvironmentValid(d, meta); err != nil { + stateConf := &resource.StateChangeConf{ + Pending: []string{UPDATING}, + Target: []string{VALID}, + Refresh: resourceAwsBatchComputeEnvironmentStatusRefreshFunc(d, meta), + Timeout: d.Timeout(schema.TimeoutDelete), + MinTimeout: 5 * time.Second, + } + if _, err := stateConf.WaitForState(); err != nil { return err } @@ -322,7 +343,14 @@ func resourceAwsBatchComputeEnvironmentDelete(d *schema.ResourceData, meta inter return err } - if err := waitComputeEnvironmentDeleted(d, meta); err != nil { + stateConfForDelete := &resource.StateChangeConf{ + Pending: []string{DELETING}, + Target: []string{DELETED}, + Refresh: resourceAwsBatchComputeEnvironmentDeleteRefreshFunc(d, meta), + Timeout: d.Timeout(schema.TimeoutDelete), + MinTimeout: 5 * time.Second, + } + if _, err := stateConfForDelete.WaitForState(); err != nil { return err } @@ -375,62 +403,52 @@ func resourceAwsBatchComputeEnvironmentUpdate(d *schema.ResourceData, meta inter return resourceAwsBatchComputeEnvironmentRead(d, meta) } -func waitComputeEnvironmentValid(d *schema.ResourceData, meta interface{}) error { - conn := meta.(*AWSClient).batchconn +func resourceAwsBatchComputeEnvironmentStatusRefreshFunc(d *schema.ResourceData, meta interface{}) resource.StateRefreshFunc { + return func() (interface{}, string, error) { + conn := meta.(*AWSClient).batchconn - computeEnvironmentName := d.Get("compute_environment_name").(string) + computeEnvironmentName := d.Get("compute_environment_name").(string) - for { result, err := conn.DescribeComputeEnvironments(&batch.DescribeComputeEnvironmentsInput{ ComputeEnvironments: []*string{ aws.String(computeEnvironmentName), }, }) if err != nil { - return err + return nil, FAILED, err } if len(result.ComputeEnvironments) == 0 { - return fmt.Errorf("One compute environment is expected, but AWS return no compute environment") - } else if len(result.ComputeEnvironments) >= 2 { - return fmt.Errorf("One compute environment is expected, but AWS return too many compute environment") + return nil, FAILED, fmt.Errorf("One compute environment is expected, but AWS return no compute environment") } + computeEnvironment := result.ComputeEnvironments[0] - if *(computeEnvironment.Status) == "VALID" { - break - } else { - time.Sleep(1 * time.Second) - } + return result, *(computeEnvironment.Status), nil } - - log.Printf("[DEBUG] Status of compute environment \"%s\" get VALID.\n", computeEnvironmentName) - return nil } -func waitComputeEnvironmentDeleted(d *schema.ResourceData, meta interface{}) error { - conn := meta.(*AWSClient).batchconn +func resourceAwsBatchComputeEnvironmentDeleteRefreshFunc(d *schema.ResourceData, meta interface{}) resource.StateRefreshFunc { + return func() (interface{}, string, error) { + conn := meta.(*AWSClient).batchconn - computeEnvironmentName := d.Get("compute_environment_name").(string) + computeEnvironmentName := d.Get("compute_environment_name").(string) - for { result, err := conn.DescribeComputeEnvironments(&batch.DescribeComputeEnvironmentsInput{ ComputeEnvironments: []*string{ aws.String(computeEnvironmentName), }, }) if err != nil { - return err + return nil, FAILED, err } if len(result.ComputeEnvironments) == 0 { - break - } else { - time.Sleep(1 * time.Second) + return result, DELETED, nil } - } - log.Printf("[DEBUG] Compute environment \"%s\" deleted.\n", computeEnvironmentName) - return nil + computeEnvironment := result.ComputeEnvironments[0] + return result, *(computeEnvironment.Status), nil + } } func isCorrentComputeEnvironmentName(i interface{}, k string) (s []string, es []error) { From b2e8115aa79cb162b53d33fbbef9cf5090209995 Mon Sep 17 00:00:00 2001 From: shibataka000 Date: Tue, 29 Aug 2017 21:53:38 +0900 Subject: [PATCH 09/17] Validate format of ARN in resource_aws_batch_compute_environment.go --- aws/resource_aws_batch_compute_environment.go | 53 +++++++++++-- ...urce_aws_batch_compute_environment_test.go | 74 +++++++++++++++++++ 2 files changed, 119 insertions(+), 8 deletions(-) diff --git a/aws/resource_aws_batch_compute_environment.go b/aws/resource_aws_batch_compute_environment.go index ff8de99d9c99..8a6f49fe0a85 100644 --- a/aws/resource_aws_batch_compute_environment.go +++ b/aws/resource_aws_batch_compute_environment.go @@ -29,6 +29,8 @@ const ( ) var reComputeEnvironmentName = regexp.MustCompile(`^[A-Za-z0-9_]*$`) +var reArnOfIamRole = regexp.MustCompile(`^arn:aws:iam::[0-9]{12}:role/.*$`) +var reArnOfIamInstanceProfile = regexp.MustCompile(`^arn:aws:iam::[0-9]{12}:instance-profile/.*$`) func resourceAwsBatchComputeEnvironment() *schema.Resource { return &schema.Resource{ @@ -71,9 +73,10 @@ func resourceAwsBatchComputeEnvironment() *schema.Resource { ForceNew: true, }, "instance_role": { - Type: schema.TypeString, - Required: true, - ForceNew: true, + Type: schema.TypeString, + Required: true, + ForceNew: true, + ValidateFunc: isArnOfIamInstanceProfile, }, "instance_type": { Type: schema.TypeSet, @@ -96,9 +99,10 @@ func resourceAwsBatchComputeEnvironment() *schema.Resource { Elem: &schema.Schema{Type: schema.TypeString}, }, "spot_iam_fleet_role": { - Type: schema.TypeString, - Optional: true, - ForceNew: true, + Type: schema.TypeString, + Optional: true, + ForceNew: true, + ValidateFunc: isArnOfIamRole, }, "subnets": { Type: schema.TypeSet, @@ -117,8 +121,9 @@ func resourceAwsBatchComputeEnvironment() *schema.Resource { }, }, "service_role": { - Type: schema.TypeString, - Required: true, + Type: schema.TypeString, + Required: true, + ValidateFunc: isArnOfIamRole, }, "state": { Type: schema.TypeString, @@ -465,3 +470,35 @@ func isCorrentComputeEnvironmentName(i interface{}, k string) (s []string, es [] return } + +func isArnOfIamRole(i interface{}, k string) (s []string, es []error) { + v, ok := i.(string) + if !ok { + es = append(es, fmt.Errorf("expected type of %s to be string", k)) + return + } + + if !reArnOfIamRole.MatchString(v) { + es = append(es, fmt.Errorf("expected arn of iam role, got %s", v)) + return + + } + + return +} + +func isArnOfIamInstanceProfile(i interface{}, k string) (s []string, es []error) { + v, ok := i.(string) + if !ok { + es = append(es, fmt.Errorf("expected type of %s to be string", k)) + return + } + + if !reArnOfIamInstanceProfile.MatchString(v) { + es = append(es, fmt.Errorf("expected arn of iam instance profile, got %s", v)) + return + + } + + return +} diff --git a/aws/resource_aws_batch_compute_environment_test.go b/aws/resource_aws_batch_compute_environment_test.go index b1914048d338..4f02bf097e52 100644 --- a/aws/resource_aws_batch_compute_environment_test.go +++ b/aws/resource_aws_batch_compute_environment_test.go @@ -238,6 +238,34 @@ func TestAccAWSBatchComputeEnvironment_createEc2WithBadComputeEnvironmentName2(t }) } +func TestAccAWSBatchComputeEnvironment_createEc2WithBadIamInstanceProfileArn(t *testing.T) { + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckBatchComputeEnvironmentDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAWSBatchComputeEnvironmentConfigEC2WithBadIamInstanceProfileArn, + ExpectError: regexp.MustCompile(`expected arn of iam instance profile, got bad_iam_instance_profile_arn`), + }, + }, + }) +} + +func TestAccAWSBatchComputeEnvironment_createEc2WithBadIamRoleArn(t *testing.T) { + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckBatchComputeEnvironmentDestroy, + Steps: []resource.TestStep{ + { + Config: testAccAWSBatchComputeEnvironmentConfigEC2WithBadIamRoleArn, + ExpectError: regexp.MustCompile(`expected arn of iam role, got bad_iam_role_arn`), + }, + }, + }) +} + func testAccCheckBatchComputeEnvironmentDestroy(s *terraform.State) error { conn := testAccProvider.Meta().(*AWSClient).batchconn @@ -690,3 +718,49 @@ resource "aws_batch_compute_environment" "ec2" { type = "MANAGED" } ` + +const testAccAWSBatchComputeEnvironmentConfigEC2WithBadIamInstanceProfileArn = testAccAWSBatchComputeEnvironmentConfigBase + ` +resource "aws_batch_compute_environment" "ec2" { + compute_environment_name = "sample" + compute_resources { + instance_role = "bad_iam_instance_profile_arn" + instance_type = [ + "c4.large", + ] + max_vcpus = 16 + min_vcpus = 0 + security_group_ids = [ + "${aws_security_group.test_acc.id}" + ] + subnets = [ + "${aws_subnet.test_acc.id}" + ] + type = "EC2" + } + service_role = "${aws_iam_role.aws_batch_service_role.arn}" + type = "MANAGED" +} +` + +const testAccAWSBatchComputeEnvironmentConfigEC2WithBadIamRoleArn = testAccAWSBatchComputeEnvironmentConfigBase + ` +resource "aws_batch_compute_environment" "ec2" { + compute_environment_name = "sample" + compute_resources { + instance_role = "${aws_iam_instance_profile.ecs_instance_role.arn}" + instance_type = [ + "c4.large", + ] + max_vcpus = 16 + min_vcpus = 0 + security_group_ids = [ + "${aws_security_group.test_acc.id}" + ] + subnets = [ + "${aws_subnet.test_acc.id}" + ] + type = "EC2" + } + service_role = "bad_iam_role_arn" + type = "MANAGED" +} +` From bbb09b1bd2803bcfe6dcb21f8932ce4653d71e86 Mon Sep 17 00:00:00 2001 From: shibataka000 Date: Tue, 29 Aug 2017 21:12:41 +0900 Subject: [PATCH 10/17] Stop validate that number of compute environment in AWS Batch are not greater than 2 Because DescribeComputeEnvironments return only one compute environment if DescribeComputeEnvironmentInput contain only one name of compute environment --- aws/resource_aws_batch_compute_environment.go | 2 -- 1 file changed, 2 deletions(-) diff --git a/aws/resource_aws_batch_compute_environment.go b/aws/resource_aws_batch_compute_environment.go index 8a6f49fe0a85..40f0a77ff00f 100644 --- a/aws/resource_aws_batch_compute_environment.go +++ b/aws/resource_aws_batch_compute_environment.go @@ -274,8 +274,6 @@ func resourceAwsBatchComputeEnvironmentRead(d *schema.ResourceData, meta interfa if len(result.ComputeEnvironments) == 0 { return fmt.Errorf("One compute environment is expected, but AWS return no compute environment") - } else if len(result.ComputeEnvironments) >= 2 { - return fmt.Errorf("One compute environment is expected, but AWS return too many compute environment") } computeEnvironment := result.ComputeEnvironments[0] From 15ebd84a468e3534e144c303b93b0e1b92ed6e97 Mon Sep 17 00:00:00 2001 From: shibataka000 Date: Tue, 29 Aug 2017 22:01:15 +0900 Subject: [PATCH 11/17] Delete unused testcase in resource_aws_batch_compute_environment_test.go --- ...urce_aws_batch_compute_environment_test.go | 23 ------------------- 1 file changed, 23 deletions(-) diff --git a/aws/resource_aws_batch_compute_environment_test.go b/aws/resource_aws_batch_compute_environment_test.go index 4f02bf097e52..8040fbc3bc03 100644 --- a/aws/resource_aws_batch_compute_environment_test.go +++ b/aws/resource_aws_batch_compute_environment_test.go @@ -503,29 +503,6 @@ resource "aws_batch_compute_environment" "unmanaged" { } ` -const testAccAWSBatchComputeEnvironmentConfigUpdatevCpus = testAccAWSBatchComputeEnvironmentConfigBase + ` -resource "aws_batch_compute_environment" "ec2" { - compute_environment_name = "sample" - compute_resources { - instance_role = "${aws_iam_instance_profile.ecs_instance_role.arn}" - instance_type = [ - "c4.large", - ] - max_vcpus = 32 - min_vcpus = 0 - security_group_ids = [ - "${aws_security_group.test_acc.id}" - ] - subnets = [ - "${aws_subnet.test_acc.id}" - ] - type = "EC2" - } - service_role = "${aws_iam_role.aws_batch_service_role.arn}" - type = "MANAGED" -} -` - const testAccAWSBatchComputeEnvironmentConfigEC2UpdateMaxvCpus = testAccAWSBatchComputeEnvironmentConfigBase + ` resource "aws_batch_compute_environment" "ec2" { compute_environment_name = "sample" From b7e9f87130034b3991162841c5e85c84b9808f5d Mon Sep 17 00:00:00 2001 From: shibataka000 Date: Tue, 29 Aug 2017 22:20:21 +0900 Subject: [PATCH 12/17] Stop checking that children of compute_resource block has change in resource_aws_batch_compute_environment.go Because I know compute_resource block has change --- aws/resource_aws_batch_compute_environment.go | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-) diff --git a/aws/resource_aws_batch_compute_environment.go b/aws/resource_aws_batch_compute_environment.go index 40f0a77ff00f..b7a753f1f6b9 100644 --- a/aws/resource_aws_batch_compute_environment.go +++ b/aws/resource_aws_batch_compute_environment.go @@ -386,15 +386,9 @@ func resourceAwsBatchComputeEnvironmentUpdate(d *schema.ResourceData, meta inter } computeResource := computeResources[0].(map[string]interface{}) - if d.HasChange("compute_resources.0.desired_vcpus") { - input.ComputeResources.DesiredvCpus = aws.Int64(int64(computeResource["desired_vcpus"].(int))) - } - if d.HasChange("compute_resources.0.max_vcpus") { - input.ComputeResources.MaxvCpus = aws.Int64(int64(computeResource["max_vcpus"].(int))) - } - if d.HasChange("compute_resources.0.min_vcpus") { - input.ComputeResources.MinvCpus = aws.Int64(int64(computeResource["min_vcpus"].(int))) - } + input.ComputeResources.DesiredvCpus = aws.Int64(int64(computeResource["desired_vcpus"].(int))) + input.ComputeResources.MaxvCpus = aws.Int64(int64(computeResource["max_vcpus"].(int))) + input.ComputeResources.MinvCpus = aws.Int64(int64(computeResource["min_vcpus"].(int))) } log.Printf("[DEBUG] Update compute environment %s.\n", input) From e9672f2d885fa92bc34915e38e95423f7d41921e Mon Sep 17 00:00:00 2001 From: shibataka000 Date: Mon, 11 Sep 2017 23:12:37 +0900 Subject: [PATCH 13/17] Fix document --- website/aws.erb | 2 +- website/docs/r/batch_compute_environment.html.markdown | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/website/aws.erb b/website/aws.erb index d22b82c59f6d..90575489d65a 100644 --- a/website/aws.erb +++ b/website/aws.erb @@ -270,7 +270,7 @@
- > + > Batch
    > diff --git a/website/docs/r/batch_compute_environment.html.markdown b/website/docs/r/batch_compute_environment.html.markdown index fb25a1345599..11b1dae2b404 100644 --- a/website/docs/r/batch_compute_environment.html.markdown +++ b/website/docs/r/batch_compute_environment.html.markdown @@ -6,7 +6,7 @@ description: |- Creates a AWS Batch compute environment. --- -# aws\_batch\_compute\_environment +# aws_batch_compute_environment Creates a AWS Batch compute environment. Compute environments contain the Amazon ECS container instances that are used to run containerized batch jobs. From a494850b46290c7baf1e6fca9bea060f1fcd95ea Mon Sep 17 00:00:00 2001 From: shibataka000 Date: Mon, 11 Sep 2017 23:14:33 +0900 Subject: [PATCH 14/17] Use of constants from the SDK --- aws/resource_aws_batch_compute_environment.go | 47 +++++++------------ 1 file changed, 16 insertions(+), 31 deletions(-) diff --git a/aws/resource_aws_batch_compute_environment.go b/aws/resource_aws_batch_compute_environment.go index b7a753f1f6b9..fd0caf440ddf 100644 --- a/aws/resource_aws_batch_compute_environment.go +++ b/aws/resource_aws_batch_compute_environment.go @@ -13,21 +13,6 @@ import ( "github.com/hashicorp/terraform/helper/validation" ) -const ( - MANAGED = "MANAGED" - UNMANAGED = "UNMANAGED" - EC2 = "EC2" - SPOT = "SPOT" - ENABLED = "ENABLED" - DISABLED = "DISABLED" - CREATING = "CREATING" - DELETING = "DELETING" - UPDATING = "UPDATING" - DELETED = "DELETED" - VALID = "VALID" - FAILED = "FAILED" -) - var reComputeEnvironmentName = regexp.MustCompile(`^[A-Za-z0-9_]*$`) var reArnOfIamRole = regexp.MustCompile(`^arn:aws:iam::[0-9]{12}:role/.*$`) var reArnOfIamInstanceProfile = regexp.MustCompile(`^arn:aws:iam::[0-9]{12}:instance-profile/.*$`) @@ -115,7 +100,7 @@ func resourceAwsBatchComputeEnvironment() *schema.Resource { Type: schema.TypeString, Required: true, ForceNew: true, - ValidateFunc: validation.StringInSlice([]string{EC2, SPOT}, true), + ValidateFunc: validation.StringInSlice([]string{batch.CRTypeEc2, batch.CRTypeSpot}, true), }, }, }, @@ -128,14 +113,14 @@ func resourceAwsBatchComputeEnvironment() *schema.Resource { "state": { Type: schema.TypeString, Optional: true, - ValidateFunc: validation.StringInSlice([]string{ENABLED, DISABLED}, true), - Default: "ENABLED", + ValidateFunc: validation.StringInSlice([]string{batch.CEStateEnabled, batch.CEStateDisabled}, true), + Default: batch.CEStateEnabled, }, "type": { Type: schema.TypeString, Required: true, ForceNew: true, - ValidateFunc: validation.StringInSlice([]string{MANAGED, UNMANAGED}, true), + ValidateFunc: validation.StringInSlice([]string{batch.CETypeManaged, batch.CETypeUnmanaged}, true), }, "arn": { Type: schema.TypeString, @@ -175,7 +160,7 @@ func resourceAwsBatchComputeEnvironmentCreate(d *schema.ResourceData, meta inter input.State = aws.String(v.(string)) } - if computeEnvironmentType == MANAGED { + if computeEnvironmentType == batch.CETypeManaged { computeResources := d.Get("compute_resources").([]interface{}) if len(computeResources) == 0 { return fmt.Errorf("One compute environment is expected, but no compute environments are set") @@ -241,8 +226,8 @@ func resourceAwsBatchComputeEnvironmentCreate(d *schema.ResourceData, meta inter d.SetId(computeEnvironmentName) stateConf := &resource.StateChangeConf{ - Pending: []string{CREATING}, - Target: []string{VALID}, + Pending: []string{batch.CEStatusCreating}, + Target: []string{batch.CEStatusValid}, Refresh: resourceAwsBatchComputeEnvironmentStatusRefreshFunc(d, meta), Timeout: d.Timeout(schema.TimeoutCreate), MinTimeout: 5 * time.Second, @@ -318,7 +303,7 @@ func resourceAwsBatchComputeEnvironmentDelete(d *schema.ResourceData, meta inter updateInput := &batch.UpdateComputeEnvironmentInput{ ComputeEnvironment: aws.String(computeEnvironmentName), - State: aws.String(DISABLED), + State: aws.String(batch.CEStateDisabled), } log.Printf("[DEBUG] Delete compute environment %s.\n", updateInput) @@ -328,8 +313,8 @@ func resourceAwsBatchComputeEnvironmentDelete(d *schema.ResourceData, meta inter } stateConf := &resource.StateChangeConf{ - Pending: []string{UPDATING}, - Target: []string{VALID}, + Pending: []string{batch.CEStatusUpdating}, + Target: []string{batch.CEStatusValid}, Refresh: resourceAwsBatchComputeEnvironmentStatusRefreshFunc(d, meta), Timeout: d.Timeout(schema.TimeoutDelete), MinTimeout: 5 * time.Second, @@ -347,8 +332,8 @@ func resourceAwsBatchComputeEnvironmentDelete(d *schema.ResourceData, meta inter } stateConfForDelete := &resource.StateChangeConf{ - Pending: []string{DELETING}, - Target: []string{DELETED}, + Pending: []string{batch.CEStatusDeleting}, + Target: []string{batch.CEStatusDeleted}, Refresh: resourceAwsBatchComputeEnvironmentDeleteRefreshFunc(d, meta), Timeout: d.Timeout(schema.TimeoutDelete), MinTimeout: 5 * time.Second, @@ -412,11 +397,11 @@ func resourceAwsBatchComputeEnvironmentStatusRefreshFunc(d *schema.ResourceData, }, }) if err != nil { - return nil, FAILED, err + return nil, "failed", err } if len(result.ComputeEnvironments) == 0 { - return nil, FAILED, fmt.Errorf("One compute environment is expected, but AWS return no compute environment") + return nil, "failed", fmt.Errorf("One compute environment is expected, but AWS return no compute environment") } computeEnvironment := result.ComputeEnvironments[0] @@ -436,11 +421,11 @@ func resourceAwsBatchComputeEnvironmentDeleteRefreshFunc(d *schema.ResourceData, }, }) if err != nil { - return nil, FAILED, err + return nil, "failed", err } if len(result.ComputeEnvironments) == 0 { - return result, DELETED, nil + return result, batch.CEStatusDeleted, nil } computeEnvironment := result.ComputeEnvironments[0] From ec89dc0a733f3bd0444b0332ef603b07be24c432 Mon Sep 17 00:00:00 2001 From: shibataka000 Date: Mon, 11 Sep 2017 23:18:12 +0900 Subject: [PATCH 15/17] Use the validateArn function --- aws/resource_aws_batch_compute_environment.go | 40 +--------- ...urce_aws_batch_compute_environment_test.go | 75 ------------------- 2 files changed, 3 insertions(+), 112 deletions(-) diff --git a/aws/resource_aws_batch_compute_environment.go b/aws/resource_aws_batch_compute_environment.go index fd0caf440ddf..7659092b6263 100644 --- a/aws/resource_aws_batch_compute_environment.go +++ b/aws/resource_aws_batch_compute_environment.go @@ -14,8 +14,6 @@ import ( ) var reComputeEnvironmentName = regexp.MustCompile(`^[A-Za-z0-9_]*$`) -var reArnOfIamRole = regexp.MustCompile(`^arn:aws:iam::[0-9]{12}:role/.*$`) -var reArnOfIamInstanceProfile = regexp.MustCompile(`^arn:aws:iam::[0-9]{12}:instance-profile/.*$`) func resourceAwsBatchComputeEnvironment() *schema.Resource { return &schema.Resource{ @@ -61,7 +59,7 @@ func resourceAwsBatchComputeEnvironment() *schema.Resource { Type: schema.TypeString, Required: true, ForceNew: true, - ValidateFunc: isArnOfIamInstanceProfile, + ValidateFunc: validateArn, }, "instance_type": { Type: schema.TypeSet, @@ -87,7 +85,7 @@ func resourceAwsBatchComputeEnvironment() *schema.Resource { Type: schema.TypeString, Optional: true, ForceNew: true, - ValidateFunc: isArnOfIamRole, + ValidateFunc: validateArn, }, "subnets": { Type: schema.TypeSet, @@ -108,7 +106,7 @@ func resourceAwsBatchComputeEnvironment() *schema.Resource { "service_role": { Type: schema.TypeString, Required: true, - ValidateFunc: isArnOfIamRole, + ValidateFunc: validateArn, }, "state": { Type: schema.TypeString, @@ -447,35 +445,3 @@ func isCorrentComputeEnvironmentName(i interface{}, k string) (s []string, es [] return } - -func isArnOfIamRole(i interface{}, k string) (s []string, es []error) { - v, ok := i.(string) - if !ok { - es = append(es, fmt.Errorf("expected type of %s to be string", k)) - return - } - - if !reArnOfIamRole.MatchString(v) { - es = append(es, fmt.Errorf("expected arn of iam role, got %s", v)) - return - - } - - return -} - -func isArnOfIamInstanceProfile(i interface{}, k string) (s []string, es []error) { - v, ok := i.(string) - if !ok { - es = append(es, fmt.Errorf("expected type of %s to be string", k)) - return - } - - if !reArnOfIamInstanceProfile.MatchString(v) { - es = append(es, fmt.Errorf("expected arn of iam instance profile, got %s", v)) - return - - } - - return -} diff --git a/aws/resource_aws_batch_compute_environment_test.go b/aws/resource_aws_batch_compute_environment_test.go index 8040fbc3bc03..a731776a175c 100644 --- a/aws/resource_aws_batch_compute_environment_test.go +++ b/aws/resource_aws_batch_compute_environment_test.go @@ -237,35 +237,6 @@ func TestAccAWSBatchComputeEnvironment_createEc2WithBadComputeEnvironmentName2(t }, }) } - -func TestAccAWSBatchComputeEnvironment_createEc2WithBadIamInstanceProfileArn(t *testing.T) { - resource.Test(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, - Providers: testAccProviders, - CheckDestroy: testAccCheckBatchComputeEnvironmentDestroy, - Steps: []resource.TestStep{ - { - Config: testAccAWSBatchComputeEnvironmentConfigEC2WithBadIamInstanceProfileArn, - ExpectError: regexp.MustCompile(`expected arn of iam instance profile, got bad_iam_instance_profile_arn`), - }, - }, - }) -} - -func TestAccAWSBatchComputeEnvironment_createEc2WithBadIamRoleArn(t *testing.T) { - resource.Test(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, - Providers: testAccProviders, - CheckDestroy: testAccCheckBatchComputeEnvironmentDestroy, - Steps: []resource.TestStep{ - { - Config: testAccAWSBatchComputeEnvironmentConfigEC2WithBadIamRoleArn, - ExpectError: regexp.MustCompile(`expected arn of iam role, got bad_iam_role_arn`), - }, - }, - }) -} - func testAccCheckBatchComputeEnvironmentDestroy(s *terraform.State) error { conn := testAccProvider.Meta().(*AWSClient).batchconn @@ -695,49 +666,3 @@ resource "aws_batch_compute_environment" "ec2" { type = "MANAGED" } ` - -const testAccAWSBatchComputeEnvironmentConfigEC2WithBadIamInstanceProfileArn = testAccAWSBatchComputeEnvironmentConfigBase + ` -resource "aws_batch_compute_environment" "ec2" { - compute_environment_name = "sample" - compute_resources { - instance_role = "bad_iam_instance_profile_arn" - instance_type = [ - "c4.large", - ] - max_vcpus = 16 - min_vcpus = 0 - security_group_ids = [ - "${aws_security_group.test_acc.id}" - ] - subnets = [ - "${aws_subnet.test_acc.id}" - ] - type = "EC2" - } - service_role = "${aws_iam_role.aws_batch_service_role.arn}" - type = "MANAGED" -} -` - -const testAccAWSBatchComputeEnvironmentConfigEC2WithBadIamRoleArn = testAccAWSBatchComputeEnvironmentConfigBase + ` -resource "aws_batch_compute_environment" "ec2" { - compute_environment_name = "sample" - compute_resources { - instance_role = "${aws_iam_instance_profile.ecs_instance_role.arn}" - instance_type = [ - "c4.large", - ] - max_vcpus = 16 - min_vcpus = 0 - security_group_ids = [ - "${aws_security_group.test_acc.id}" - ] - subnets = [ - "${aws_subnet.test_acc.id}" - ] - type = "EC2" - } - service_role = "bad_iam_role_arn" - type = "MANAGED" -} -` From a45966526120795ebc5a39f2a700b8617942ed65 Mon Sep 17 00:00:00 2001 From: shibataka000 Date: Mon, 11 Sep 2017 23:19:06 +0900 Subject: [PATCH 16/17] Move validateBatchComputeEnvironmentName function to validators.go --- aws/resource_aws_batch_compute_environment.go | 20 +--- ...urce_aws_batch_compute_environment_test.go | 112 ------------------ aws/validators.go | 8 ++ aws/validators_test.go | 23 ++++ 4 files changed, 32 insertions(+), 131 deletions(-) diff --git a/aws/resource_aws_batch_compute_environment.go b/aws/resource_aws_batch_compute_environment.go index 7659092b6263..ae733803c287 100644 --- a/aws/resource_aws_batch_compute_environment.go +++ b/aws/resource_aws_batch_compute_environment.go @@ -3,7 +3,6 @@ package aws import ( "fmt" "log" - "regexp" "time" "github.com/aws/aws-sdk-go/aws" @@ -13,8 +12,6 @@ import ( "github.com/hashicorp/terraform/helper/validation" ) -var reComputeEnvironmentName = regexp.MustCompile(`^[A-Za-z0-9_]*$`) - func resourceAwsBatchComputeEnvironment() *schema.Resource { return &schema.Resource{ Create: resourceAwsBatchComputeEnvironmentCreate, @@ -27,7 +24,7 @@ func resourceAwsBatchComputeEnvironment() *schema.Resource { Type: schema.TypeString, Required: true, ForceNew: true, - ValidateFunc: isCorrentComputeEnvironmentName, + ValidateFunc: validateBatchComputeEnvironmentName, }, "compute_resources": { Type: schema.TypeList, @@ -430,18 +427,3 @@ func resourceAwsBatchComputeEnvironmentDeleteRefreshFunc(d *schema.ResourceData, return result, *(computeEnvironment.Status), nil } } - -func isCorrentComputeEnvironmentName(i interface{}, k string) (s []string, es []error) { - v, ok := i.(string) - if !ok { - es = append(es, fmt.Errorf("expected type of %s to be string", k)) - return - } - - if !(reComputeEnvironmentName.MatchString(v) && len(v) <= 128) { - es = append(es, fmt.Errorf("computeEnvironmentName must be up to 128 letters (uppercase and lowercase), numbers, and underscores.")) - return - } - - return -} diff --git a/aws/resource_aws_batch_compute_environment_test.go b/aws/resource_aws_batch_compute_environment_test.go index a731776a175c..5adfd9c987d1 100644 --- a/aws/resource_aws_batch_compute_environment_test.go +++ b/aws/resource_aws_batch_compute_environment_test.go @@ -194,49 +194,6 @@ func TestAccAWSBatchComputeEnvironment_createSpotWithoutBidPercentage(t *testing }) } -func TestAccAWSBatchComputeEnvironment_createEc2WithGoodComputeEnvironmentName(t *testing.T) { - resource.Test(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, - Providers: testAccProviders, - CheckDestroy: testAccCheckBatchComputeEnvironmentDestroy, - Steps: []resource.TestStep{ - { - Config: testAccAWSBatchComputeEnvironmentConfigEC2WithGoodComputeEnvironmentName, - Check: resource.ComposeTestCheckFunc( - testAccCheckAwsBatchComputeEnvironmentExists(), - ), - }, - }, - }) -} - -func TestAccAWSBatchComputeEnvironment_createEc2WithBadComputeEnvironmentName1(t *testing.T) { - resource.Test(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, - Providers: testAccProviders, - CheckDestroy: testAccCheckBatchComputeEnvironmentDestroy, - Steps: []resource.TestStep{ - { - Config: testAccAWSBatchComputeEnvironmentConfigEC2WithBadComputeEnvironmentName1, - ExpectError: regexp.MustCompile(`computeEnvironmentName must be up to 128 letters \(uppercase and lowercase\), numbers, and underscores.`), - }, - }, - }) -} - -func TestAccAWSBatchComputeEnvironment_createEc2WithBadComputeEnvironmentName2(t *testing.T) { - resource.Test(t, resource.TestCase{ - PreCheck: func() { testAccPreCheck(t) }, - Providers: testAccProviders, - CheckDestroy: testAccCheckBatchComputeEnvironmentDestroy, - Steps: []resource.TestStep{ - { - Config: testAccAWSBatchComputeEnvironmentConfigEC2WithBadComputeEnvironmentName2, - ExpectError: regexp.MustCompile(`computeEnvironmentName must be up to 128 letters \(uppercase and lowercase\), numbers, and underscores.`), - }, - }, - }) -} func testAccCheckBatchComputeEnvironmentDestroy(s *terraform.State) error { conn := testAccProvider.Meta().(*AWSClient).batchconn @@ -597,72 +554,3 @@ resource "aws_batch_compute_environment" "ec2" { type = "MANAGED" } ` - -const testAccAWSBatchComputeEnvironmentConfigEC2WithGoodComputeEnvironmentName = testAccAWSBatchComputeEnvironmentConfigBase + ` -resource "aws_batch_compute_environment" "ec2" { - compute_environment_name = "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678" - compute_resources { - instance_role = "${aws_iam_instance_profile.ecs_instance_role.arn}" - instance_type = [ - "c4.large", - ] - max_vcpus = 16 - min_vcpus = 0 - security_group_ids = [ - "${aws_security_group.test_acc.id}" - ] - subnets = [ - "${aws_subnet.test_acc.id}" - ] - type = "EC2" - } - service_role = "${aws_iam_role.aws_batch_service_role.arn}" - type = "MANAGED" -} -` - -const testAccAWSBatchComputeEnvironmentConfigEC2WithBadComputeEnvironmentName1 = testAccAWSBatchComputeEnvironmentConfigBase + ` -resource "aws_batch_compute_environment" "ec2" { - compute_environment_name = "sam@ple" - compute_resources { - instance_role = "${aws_iam_instance_profile.ecs_instance_role.arn}" - instance_type = [ - "c4.large", - ] - max_vcpus = 16 - min_vcpus = 0 - security_group_ids = [ - "${aws_security_group.test_acc.id}" - ] - subnets = [ - "${aws_subnet.test_acc.id}" - ] - type = "EC2" - } - service_role = "${aws_iam_role.aws_batch_service_role.arn}" - type = "MANAGED" -} -` - -const testAccAWSBatchComputeEnvironmentConfigEC2WithBadComputeEnvironmentName2 = testAccAWSBatchComputeEnvironmentConfigBase + ` -resource "aws_batch_compute_environment" "ec2" { - compute_environment_name = "123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" - compute_resources { - instance_role = "${aws_iam_instance_profile.ecs_instance_role.arn}" - instance_type = [ - "c4.large", - ] - max_vcpus = 16 - min_vcpus = 0 - security_group_ids = [ - "${aws_security_group.test_acc.id}" - ] - subnets = [ - "${aws_subnet.test_acc.id}" - ] - type = "EC2" - } - service_role = "${aws_iam_role.aws_batch_service_role.arn}" - type = "MANAGED" -} -` diff --git a/aws/validators.go b/aws/validators.go index 7ea9873eedb7..1da496cf60ec 100644 --- a/aws/validators.go +++ b/aws/validators.go @@ -1385,3 +1385,11 @@ func validateSsmParameterType(v interface{}, k string) (ws []string, errors []er } return } + +func validateBatchComputeEnvironmentName(v interface{}, k string) (ws []string, errors []error) { + value := v.(string) + if !(regexp.MustCompile(`^[A-Za-z0-9_]*$`).MatchString(value) && len(value) <= 128) { + errors = append(errors, fmt.Errorf("computeEnvironmentName must be up to 128 letters (uppercase and lowercase), numbers, and underscores.")) + } + return +} diff --git a/aws/validators_test.go b/aws/validators_test.go index 032e3f1805cb..97523e0f8815 100644 --- a/aws/validators_test.go +++ b/aws/validators_test.go @@ -2399,3 +2399,26 @@ func TestValidateSsmParameterType(t *testing.T) { } } } + +func TestValidateBatchComputeEnvironmentName(t *testing.T) { + validNames := []string{ + strings.Repeat("W", 128), // <= 128 + } + for _, v := range validNames { + _, errors := validateBatchComputeEnvironmentName(v, "name") + if len(errors) != 0 { + t.Fatalf("%q should be a valid Batch compute environment name: %q", v, errors) + } + } + + invalidNames := []string{ + "s@mple", + strings.Repeat("W", 129), // >= 129 + } + for _, v := range invalidNames { + _, errors := validateBatchComputeEnvironmentName(v, "name") + if len(errors) == 0 { + t.Fatalf("%q should be a invalid Batch compute environment name: %q", v, errors) + } + } +} From 73180b447ea1119fdaf42083d3b48fc18476e876 Mon Sep 17 00:00:00 2001 From: shibataka000 Date: Tue, 19 Sep 2017 23:55:01 +0900 Subject: [PATCH 17/17] Move codes reading compute_resources to a flatten function --- aws/resource_aws_batch_compute_environment.go | 42 ++++++++++--------- 1 file changed, 23 insertions(+), 19 deletions(-) diff --git a/aws/resource_aws_batch_compute_environment.go b/aws/resource_aws_batch_compute_environment.go index ae733803c287..e0cc33da93d6 100644 --- a/aws/resource_aws_batch_compute_environment.go +++ b/aws/resource_aws_batch_compute_environment.go @@ -262,25 +262,7 @@ func resourceAwsBatchComputeEnvironmentRead(d *schema.ResourceData, meta interfa d.Set("type", computeEnvironment.Type) if *(computeEnvironment.Type) == "MANAGED" { - computeResource := computeEnvironment.ComputeResources - - d.Set("compute_resources", []interface{}{ - map[string]interface{}{ - "bid_percentage": computeResource.BidPercentage, - "desired_vcpus": computeResource.DesiredvCpus, - "ec2_key_pair": computeResource.Ec2KeyPair, - "image_id": computeResource.ImageId, - "instance_role": computeResource.InstanceRole, - "instance_type": schema.NewSet(schema.HashString, flattenStringList(computeResource.InstanceTypes)), - "max_vcpus": computeResource.MaxvCpus, - "min_vcpus": computeResource.MinvCpus, - "security_group_ids": schema.NewSet(schema.HashString, flattenStringList(computeResource.SecurityGroupIds)), - "spot_iam_fleet_role": computeResource.SpotIamFleetRole, - "subnets": schema.NewSet(schema.HashString, flattenStringList(computeResource.Subnets)), - "tags": tagsToMapGeneric(computeResource.Tags), - "type": computeResource.Type, - }, - }) + d.Set("compute_resources", flattenComputeResources(computeEnvironment.ComputeResources)) } d.Set("arn", computeEnvironment.ComputeEnvironmentArn) @@ -291,6 +273,28 @@ func resourceAwsBatchComputeEnvironmentRead(d *schema.ResourceData, meta interfa return nil } +func flattenComputeResources(computeResource *batch.ComputeResource) []map[string]interface{} { + result := make([]map[string]interface{}, 0) + m := make(map[string]interface{}) + + m["bid_percentage"] = computeResource.BidPercentage + m["desired_vcpus"] = computeResource.DesiredvCpus + m["ec2_key_pair"] = computeResource.Ec2KeyPair + m["image_id"] = computeResource.ImageId + m["instance_role"] = computeResource.InstanceRole + m["instance_type"] = schema.NewSet(schema.HashString, flattenStringList(computeResource.InstanceTypes)) + m["max_vcpus"] = computeResource.MaxvCpus + m["min_vcpus"] = computeResource.MinvCpus + m["security_group_ids"] = schema.NewSet(schema.HashString, flattenStringList(computeResource.SecurityGroupIds)) + m["spot_iam_fleet_role"] = computeResource.SpotIamFleetRole + m["subnets"] = schema.NewSet(schema.HashString, flattenStringList(computeResource.Subnets)) + m["tags"] = tagsToMapGeneric(computeResource.Tags) + m["type"] = computeResource.Type + + result = append(result, m) + return result +} + func resourceAwsBatchComputeEnvironmentDelete(d *schema.ResourceData, meta interface{}) error { conn := meta.(*AWSClient).batchconn