New resource - Glue crawlers

CHANGELOG.md

@@ -3,15 +3,21 @@
 FEATURES:
 
 * **New Data Source:** `aws_cloudformation_export` [GH-2180]
+* **New Data Source:** `aws_vpc_dhcp_options` [GH-4878]
+* **New Resource:** `aws_neptune_cluster_parameter_group` [GH-4860]
 * **New Resource:** `aws_neptune_subnet_group` [GH-4782]
 
 ENHANCEMENTS:
 
 * resource/aws_codedeploy_app: Add `compute_platform` argument [GH-4811]
+* resource/aws_kinesis_firehose_delivery_stream: Support extended S3 destination `data_format_conversion_configuration` [GH-4842]
+* resource/aws_neptune_parameter_group: Add `tags` argument and `arn` attribute [GH-4873]
+* resource/aws_rds_cluster: Add `enabled_cloudwatch_logs_exports` argument [GH-4875]
 
 BUG FIXES:
 
 * resource/aws_batch_job_definition: Force resource recreation on retry_strategy attempts updates [GH-4854]
+* resource/aws_cognito_user_pool_client: Prevent panic with updating `refresh_token_validity` [GH-4868]
 
 ## 1.23.0 (June 14, 2018)
 

aws/data_source_aws_vpc_dhcp_options.go

@@ -0,0 +1,126 @@
+package aws
+
+import (
+	"errors"
+	"fmt"
+	"log"
+	"strings"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/hashicorp/terraform/helper/schema"
+)
+
+func dataSourceAwsVpcDhcpOptions() *schema.Resource {
+	return &schema.Resource{
+		Read: dataSourceAwsVpcDhcpOptionsRead,
+
+		Schema: map[string]*schema.Schema{
+			"dhcp_options_id": {
+				Type:     schema.TypeString,
+				Optional: true,
+				Computed: true,
+			},
+			"domain_name": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"domain_name_servers": {
+				Type:     schema.TypeList,
+				Computed: true,
+				Elem:     &schema.Schema{Type: schema.TypeString},
+			},
+			"filter": ec2CustomFiltersSchema(),
+			"netbios_name_servers": {
+				Type:     schema.TypeList,
+				Computed: true,
+				Elem:     &schema.Schema{Type: schema.TypeString},
+			},
+			"netbios_node_type": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"ntp_servers": {
+				Type:     schema.TypeList,
+				Computed: true,
+				Elem:     &schema.Schema{Type: schema.TypeString},
+			},
+			"tags": tagsSchemaComputed(),
+		},
+	}
+}
+
+func dataSourceAwsVpcDhcpOptionsRead(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).ec2conn
+
+	input := &ec2.DescribeDhcpOptionsInput{}
+
+	if v, ok := d.GetOk("dhcp_options_id"); ok && v.(string) != "" {
+		input.DhcpOptionsIds = []*string{aws.String(v.(string))}
+	}
+
+	input.Filters = append(input.Filters, buildEC2CustomFilterList(
+		d.Get("filter").(*schema.Set),
+	)...)
+	if len(input.Filters) == 0 {
+		// Don't send an empty filters list; the EC2 API won't accept it.
+		input.Filters = nil
+	}
+
+	log.Printf("[DEBUG] Reading EC2 DHCP Options: %s", input)
+	output, err := conn.DescribeDhcpOptions(input)
+	if err != nil {
+		if isNoSuchDhcpOptionIDErr(err) {
+			return errors.New("No matching EC2 DHCP Options found")
+		}
+		return fmt.Errorf("error reading EC2 DHCP Options: %s", err)
+	}
+
+	if len(output.DhcpOptions) == 0 {
+		return errors.New("No matching EC2 DHCP Options found")
+	}
+
+	if len(output.DhcpOptions) > 1 {
+		return errors.New("Multiple matching EC2 DHCP Options found")
+	}
+
+	dhcpOptionID := aws.StringValue(output.DhcpOptions[0].DhcpOptionsId)
+	d.SetId(dhcpOptionID)
+	d.Set("dhcp_options_id", dhcpOptionID)
+
+	dhcpConfigurations := output.DhcpOptions[0].DhcpConfigurations
+
+	for _, dhcpConfiguration := range dhcpConfigurations {
+		key := aws.StringValue(dhcpConfiguration.Key)
+		tfKey := strings.Replace(key, "-", "_", -1)
+
+		if len(dhcpConfiguration.Values) == 0 {
+			continue
+		}
+
+		switch key {
+		case "domain-name":
+			d.Set(tfKey, aws.StringValue(dhcpConfiguration.Values[0].Value))
+		case "domain-name-servers":
+			if err := d.Set(tfKey, flattenEc2AttributeValues(dhcpConfiguration.Values)); err != nil {
+				return fmt.Errorf("error setting %s: %s", tfKey, err)
+			}
+		case "netbios-name-servers":
+			if err := d.Set(tfKey, flattenEc2AttributeValues(dhcpConfiguration.Values)); err != nil {
+				return fmt.Errorf("error setting %s: %s", tfKey, err)
+			}
+		case "netbios-node-type":
+			d.Set(tfKey, aws.StringValue(dhcpConfiguration.Values[0].Value))
+		case "ntp-servers":
+			if err := d.Set(tfKey, flattenEc2AttributeValues(dhcpConfiguration.Values)); err != nil {
+				return fmt.Errorf("error setting %s: %s", tfKey, err)
+			}
+		}
+	}
+
+	if err := d.Set("tags", d.Set("tags", tagsToMap(output.DhcpOptions[0].Tags))); err != nil {
+		return fmt.Errorf("error setting tags: %s", err)
+	}
+
+	return nil
+}

aws/data_source_aws_vpc_dhcp_options_test.go

@@ -0,0 +1,139 @@
+package aws
+
+import (
+	"fmt"
+	"regexp"
+	"testing"
+
+	"github.com/hashicorp/terraform/helper/acctest"
+	"github.com/hashicorp/terraform/helper/resource"
+)
+
+func TestAccDataSourceAwsVpcDhcpOptions_basic(t *testing.T) {
+	resourceName := "aws_vpc_dhcp_options.test"
+	datasourceName := "data.aws_vpc_dhcp_options.test"
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:  func() { testAccPreCheck(t) },
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config:      testAccDataSourceAwsVpcDhcpOptionsConfig_Missing,
+				ExpectError: regexp.MustCompile(`No matching EC2 DHCP Options found`),
+			},
+			{
+				Config: testAccDataSourceAwsVpcDhcpOptionsConfig_DhcpOptionsID,
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttrPair(datasourceName, "dhcp_options_id", resourceName, "id"),
+					resource.TestCheckResourceAttrPair(datasourceName, "domain_name", resourceName, "domain_name"),
+					resource.TestCheckResourceAttrPair(datasourceName, "domain_name_servers.#", resourceName, "domain_name_servers.#"),
+					resource.TestCheckResourceAttrPair(datasourceName, "domain_name_servers.0", resourceName, "domain_name_servers.0"),
+					resource.TestCheckResourceAttrPair(datasourceName, "domain_name_servers.1", resourceName, "domain_name_servers.1"),
+					resource.TestCheckResourceAttrPair(datasourceName, "netbios_name_servers.#", resourceName, "netbios_name_servers.#"),
+					resource.TestCheckResourceAttrPair(datasourceName, "netbios_name_servers.0", resourceName, "netbios_name_servers.0"),
+					resource.TestCheckResourceAttrPair(datasourceName, "netbios_node_type", resourceName, "netbios_node_type"),
+					resource.TestCheckResourceAttrPair(datasourceName, "ntp_servers.#", resourceName, "ntp_servers.#"),
+					resource.TestCheckResourceAttrPair(datasourceName, "ntp_servers.0", resourceName, "ntp_servers.0"),
+					resource.TestCheckResourceAttrPair(datasourceName, "tags.%", resourceName, "tags.%"),
+					resource.TestCheckResourceAttrPair(datasourceName, "tags.Name", resourceName, "tags.Name"),
+				),
+			},
+		},
+	})
+}
+
+func TestAccDataSourceAwsVpcDhcpOptions_Filter(t *testing.T) {
+	rInt := acctest.RandInt()
+	resourceName := "aws_vpc_dhcp_options.test"
+	datasourceName := "data.aws_vpc_dhcp_options.test"
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:  func() { testAccPreCheck(t) },
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceAwsVpcDhcpOptionsConfig_Filter(rInt, 1),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttrPair(datasourceName, "dhcp_options_id", resourceName, "id"),
+					resource.TestCheckResourceAttrPair(datasourceName, "domain_name", resourceName, "domain_name"),
+					resource.TestCheckResourceAttrPair(datasourceName, "domain_name_servers.#", resourceName, "domain_name_servers.#"),
+					resource.TestCheckResourceAttrPair(datasourceName, "domain_name_servers.0", resourceName, "domain_name_servers.0"),
+					resource.TestCheckResourceAttrPair(datasourceName, "domain_name_servers.1", resourceName, "domain_name_servers.1"),
+					resource.TestCheckResourceAttrPair(datasourceName, "netbios_name_servers.#", resourceName, "netbios_name_servers.#"),
+					resource.TestCheckResourceAttrPair(datasourceName, "netbios_name_servers.0", resourceName, "netbios_name_servers.0"),
+					resource.TestCheckResourceAttrPair(datasourceName, "netbios_node_type", resourceName, "netbios_node_type"),
+					resource.TestCheckResourceAttrPair(datasourceName, "ntp_servers.#", resourceName, "ntp_servers.#"),
+					resource.TestCheckResourceAttrPair(datasourceName, "ntp_servers.0", resourceName, "ntp_servers.0"),
+					resource.TestCheckResourceAttrPair(datasourceName, "tags.%", resourceName, "tags.%"),
+					resource.TestCheckResourceAttrPair(datasourceName, "tags.Name", resourceName, "tags.Name"),
+				),
+			},
+			{
+				Config:      testAccDataSourceAwsVpcDhcpOptionsConfig_Filter(rInt, 2),
+				ExpectError: regexp.MustCompile(`Multiple matching EC2 DHCP Options found`),
+			},
+		},
+	})
+}
+
+const testAccDataSourceAwsVpcDhcpOptionsConfig_Missing = `
+data "aws_vpc_dhcp_options" "test" {
+  dhcp_options_id = "does-not-exist"
+}
+`
+
+const testAccDataSourceAwsVpcDhcpOptionsConfig_DhcpOptionsID = `
+resource "aws_vpc_dhcp_options" "incorrect" {
+  domain_name = "tf-acc-test-incorrect.example.com"
+}
+
+resource "aws_vpc_dhcp_options" "test" {
+  domain_name          = "service.consul"
+  domain_name_servers  = ["127.0.0.1", "10.0.0.2"]
+  netbios_name_servers = ["127.0.0.1"]
+  netbios_node_type    = 2
+  ntp_servers          = ["127.0.0.1"]
+
+  tags {
+    Name = "tf-acc-test"
+  }
+}
+
+data "aws_vpc_dhcp_options" "test" {
+  dhcp_options_id = "${aws_vpc_dhcp_options.test.id}"
+}
+`
+
+func testAccDataSourceAwsVpcDhcpOptionsConfig_Filter(rInt, count int) string {
+	return fmt.Sprintf(`
+resource "aws_vpc_dhcp_options" "incorrect" {
+  domain_name = "tf-acc-test-incorrect.example.com"
+}
+
+resource "aws_vpc_dhcp_options" "test" {
+  count = %d
+
+  domain_name          = "tf-acc-test-%d.example.com"
+  domain_name_servers  = ["127.0.0.1", "10.0.0.2"]
+  netbios_name_servers = ["127.0.0.1"]
+  netbios_node_type    = 2
+  ntp_servers          = ["127.0.0.1"]
+
+  tags {
+    Name = "tf-acc-test-%d"
+  }
+}
+
+data "aws_vpc_dhcp_options" "test" {
+  filter {
+    name   = "key"
+    values = ["domain-name"]
+  }
+
+  filter {
+    name   = "value"
+    values = ["${aws_vpc_dhcp_options.test.0.domain_name}"]
+  }
+}
+`, count, rInt, rInt)
+}

aws/provider.go

@@ -247,6 +247,7 @@ func Provider() terraform.ResourceProvider {
 			"aws_vpcs":                             dataSourceAwsVpcs(),
 			"aws_security_group":                   dataSourceAwsSecurityGroup(),
 			"aws_vpc":                              dataSourceAwsVpc(),
+			"aws_vpc_dhcp_options":                 dataSourceAwsVpcDhcpOptions(),
 			"aws_vpc_endpoint":                     dataSourceAwsVpcEndpoint(),
 			"aws_vpc_endpoint_service":             dataSourceAwsVpcEndpointService(),
 			"aws_vpc_peering_connection":           dataSourceAwsVpcPeeringConnection(),
@@ -412,6 +413,7 @@ func Provider() terraform.ResourceProvider {
 			"aws_glue_catalog_table":                       resourceAwsGlueCatalogTable(),
 			"aws_glue_classifier":                          resourceAwsGlueClassifier(),
 			"aws_glue_connection":                          resourceAwsGlueConnection(),
+			"aws_glue_crawler":                             resourceAwsGlueCrawler(),
 			"aws_glue_job":                                 resourceAwsGlueJob(),
 			"aws_glue_trigger":                             resourceAwsGlueTrigger(),
 			"aws_guardduty_detector":                       resourceAwsGuardDutyDetector(),
@@ -625,6 +627,7 @@ func Provider() terraform.ResourceProvider {
 			"aws_batch_job_definition":                     resourceAwsBatchJobDefinition(),
 			"aws_batch_job_queue":                          resourceAwsBatchJobQueue(),
 			"aws_neptune_subnet_group":                     resourceAwsNeptuneSubnetGroup(),
+			"aws_neptune_cluster_parameter_group":          resourceAwsNeptuneClusterParameterGroup(),
 
 			// ALBs are actually LBs because they can be type `network` or `application`
 			// To avoid regressions, we will add a new resource for each and they both point

aws/resource_aws_cognito_user_pool_client.go

@@ -283,7 +283,7 @@ func resourceAwsCognitoUserPoolClientUpdate(d *schema.ResourceData, meta interfa
 	}
 
 	if d.HasChange("refresh_token_validity") {
-		params.RefreshTokenValidity = aws.Int64(d.Get("refresh_token_validity").(int64))
+		params.RefreshTokenValidity = aws.Int64(int64(d.Get("refresh_token_validity").(int)))
 	}
 
 	if d.HasChange("allowed_oauth_flows") {

aws/resource_aws_cognito_user_pool_client_test.go

@@ -88,6 +88,32 @@ func TestAccAWSCognitoUserPoolClient_importBasic(t *testing.T) {
 	})
 }
 
+func TestAccAWSCognitoUserPoolClient_RefreshTokenValidity(t *testing.T) {
+	rName := acctest.RandomWithPrefix("tf-acc-test")
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckAWSCognitoUserPoolClientDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccAWSCognitoUserPoolClientConfig_RefreshTokenValidity(rName, 60),
+				Check: resource.ComposeAggregateTestCheckFunc(
+					testAccCheckAWSCognitoUserPoolClientExists("aws_cognito_user_pool_client.client"),
+					resource.TestCheckResourceAttr("aws_cognito_user_pool_client.client", "refresh_token_validity", "60"),
+				),
+			},
+			{
+				Config: testAccAWSCognitoUserPoolClientConfig_RefreshTokenValidity(rName, 120),
+				Check: resource.ComposeAggregateTestCheckFunc(
+					testAccCheckAWSCognitoUserPoolClientExists("aws_cognito_user_pool_client.client"),
+					resource.TestCheckResourceAttr("aws_cognito_user_pool_client.client", "refresh_token_validity", "120"),
+				),
+			},
+		},
+	})
+}
+
 func TestAccAWSCognitoUserPoolClient_allFields(t *testing.T) {
 	userPoolName := fmt.Sprintf("tf-acc-cognito-user-pool-%s", acctest.RandString(7))
 	clientName := acctest.RandStringFromCharSet(10, acctest.CharSetAlphaNum)
@@ -202,6 +228,20 @@ resource "aws_cognito_user_pool_client" "client" {
 `, userPoolName, clientName)
 }
 
+func testAccAWSCognitoUserPoolClientConfig_RefreshTokenValidity(rName string, refreshTokenValidity int) string {
+	return fmt.Sprintf(`
+resource "aws_cognito_user_pool" "pool" {
+  name = "%s"
+}
+
+resource "aws_cognito_user_pool_client" "client" {
+  name                   = "%s"
+  refresh_token_validity = %d
+  user_pool_id           = "${aws_cognito_user_pool.pool.id}"
+}
+`, rName, rName, refreshTokenValidity)
+}
+
 func testAccAWSCognitoUserPoolClientConfig_allFields(userPoolName, clientName string) string {
 	return fmt.Sprintf(`
 resource "aws_cognito_user_pool" "pool" {