data-source/neptune_orderable_db_instance: New data source

aws/data_source_aws_neptune_orderable_db_instance.go

@@ -0,0 +1,242 @@
+package aws
+
+import (
+ "fmt"
+ "log"
+
+ "github.com/aws/aws-sdk-go/aws"
+ "github.com/aws/aws-sdk-go/service/neptune"
+ "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+func dataSourceAwsNeptuneOrderableDbInstance() *schema.Resource {
+ return &schema.Resource{
+ Read: dataSourceAwsNeptuneOrderableDbInstanceRead,
+ Schema: map[string]*schema.Schema{
+ "availability_zones": {
+ Type: schema.TypeList,
+ Computed: true,
+ Elem: &schema.Schema{Type: schema.TypeString},
+ },
+
+ "db_instance_class": {
+ Type: schema.TypeString,
+ Optional: true,
+ Computed: true,
+ },
+
+ "engine": {
+ Type: schema.TypeString,
+ Required: true,
+ },
+
+ "engine_version": {
+ Type: schema.TypeString,
+ Optional: true,
+ Computed: true,
+ },
+
+ "license_model": {
+ Type: schema.TypeString,
+ Optional: true,
+ Computed: true,
+ },
+
+ "max_iops_per_db_instance": {
+ Type: schema.TypeInt,
+ Computed: true,
+ },
+
+ "max_iops_per_gib": {
+ Type: schema.TypeFloat,
+ Computed: true,
+ },
+
+ "max_storage_size": {
+ Type: schema.TypeInt,
+ Computed: true,
+ },
+
+ "min_iops_per_db_instance": {
+ Type: schema.TypeInt,
+ Computed: true,
+ },
+
+ "min_iops_per_gib": {
+ Type: schema.TypeFloat,
+ Computed: true,
+ },
+
+ "min_storage_size": {
+ Type: schema.TypeInt,
+ Computed: true,
+ },
+
+ "multi_az_capable": {
+ Type: schema.TypeBool,
+ Computed: true,
+ },
+
+ "preferred_db_instance_classes": {
+ Type: schema.TypeList,
+ Optional: true,
+ Elem: &schema.Schema{Type: schema.TypeString},
+ },
+
+ "read_replica_capable": {
+ Type: schema.TypeBool,
+ Computed: true,
+ },
+
+ "storage_type": {
+ Type: schema.TypeString,
+ Computed: true,
+ },
+
+ "supports_enhanced_monitoring": {
+ Type: schema.TypeBool,
+ Computed: true,
+ },
+
+ "supports_iam_database_authentication": {
+ Type: schema.TypeBool,
+ Computed: true,
+ },
+
+ "supports_iops": {
+ Type: schema.TypeBool,
+ Computed: true,
+ },
+
+ "supports_performance_insights": {
+ Type: schema.TypeBool,
+ Computed: true,
+ },
+
+ "supports_storage_encryption": {
+ Type: schema.TypeBool,
+ Computed: true,
+ },
+
+ "vpc": {
+ Type: schema.TypeBool,
+ Optional: true,
+ Computed: true,
+ },
+ },
+ }
+}
+
+func dataSourceAwsNeptuneOrderableDbInstanceRead(d *schema.ResourceData, meta interface{}) error {
+ conn := meta.(*AWSClient).neptuneconn
+
+ input := &neptune.DescribeOrderableDBInstanceOptionsInput{}
+
+ if v, ok := d.GetOk("db_instance_class"); ok {
+ input.DBInstanceClass = aws.String(v.(string))
+ }
+
+ if v, ok := d.GetOk("engine"); ok {
+ input.Engine = aws.String(v.(string))
+ }
+
+ if v, ok := d.GetOk("engine_version"); ok {
+ input.EngineVersion = aws.String(v.(string))
+ }
+
+ if v, ok := d.GetOk("license_model"); ok {
+ input.LicenseModel = aws.String(v.(string))
+ }
+
+ if v, ok := d.GetOk("vpc"); ok {
+ input.Vpc = aws.Bool(v.(bool))
+ }
+
+ log.Printf("[DEBUG] Reading Neptune Orderable DB Instance Options: %v", input)
+
+ var instanceClassResults []*neptune.OrderableDBInstanceOption
+ err := conn.DescribeOrderableDBInstanceOptionsPages(input, func(resp *neptune.DescribeOrderableDBInstanceOptionsOutput, lastPage bool) bool {
+ for _, instanceOption := range resp.OrderableDBInstanceOptions {
+ if instanceOption == nil {
+ continue
+ }
+
+ instanceClassResults = append(instanceClassResults, instanceOption)
+ }
+ return !lastPage
+ })
+
+ if err != nil {
+ return fmt.Errorf("error reading Neptune orderable DB instance options: %w", err)
+ }
+
+ if len(instanceClassResults) == 0 {
+ return fmt.Errorf("no Neptune Orderable DB Instance options found matching criteria; try different search")
+ }
+
+ // preferred classes
+ var found *neptune.OrderableDBInstanceOption
+ if l := d.Get("preferred_db_instance_classes").([]interface{}); len(l) > 0 {
+ for _, elem := range l {
+ preferredInstanceClass, ok := elem.(string)
+
+ if !ok {
+ continue
+ }
+
+ for _, instanceClassResult := range instanceClassResults {
+ if preferredInstanceClass == aws.StringValue(instanceClassResult.DBInstanceClass) {
+ found = instanceClassResult
+ break
+ }
+ }
+
+ if found != nil {
+ break
+ }
+ }
+ }
+
+ if found == nil && len(instanceClassResults) > 1 {
+ return fmt.Errorf("multiple Neptune DB Instance Classes (%v) match the criteria; try a different search", instanceClassResults)
+ }
+
+ if found == nil && len(instanceClassResults) == 1 {
+ found = instanceClassResults[0]
+ }
+
+ if found == nil {
+ return fmt.Errorf("no Neptune DB Instance Classes match the criteria; try a different search")
+ }
+
+ d.SetId(aws.StringValue(found.DBInstanceClass))
+
+ d.Set("db_instance_class", found.DBInstanceClass)
+
+ var availabilityZones []string
+ for _, az := range found.AvailabilityZones {
+ availabilityZones = append(availabilityZones, aws.StringValue(az.Name))
+ }
+ d.Set("availability_zones", availabilityZones)
+
+ d.Set("engine", found.Engine)
+ d.Set("engine_version", found.EngineVersion)
+ d.Set("license_model", found.LicenseModel)
+ d.Set("max_iops_per_db_instance", found.MaxIopsPerDbInstance)
+ d.Set("max_iops_per_gib", found.MaxIopsPerGib)
+ d.Set("max_storage_size", found.MaxStorageSize)
+ d.Set("min_iops_per_db_instance", found.MinIopsPerDbInstance)
+ d.Set("min_iops_per_gib", found.MinIopsPerGib)
+ d.Set("min_storage_size", found.MinStorageSize)
+ d.Set("multi_az_capable", found.MultiAZCapable)
+ d.Set("read_replica_capable", found.ReadReplicaCapable)
+ d.Set("storage_type", found.StorageType)
+ d.Set("supports_enhanced_monitoring", found.SupportsEnhancedMonitoring)
+ d.Set("supports_iam_database_authentication", found.SupportsIAMDatabaseAuthentication)
+ d.Set("supports_iops", found.SupportsIops)
+ d.Set("supports_performance_insights", found.SupportsPerformanceInsights)
+ d.Set("supports_storage_encryption", found.SupportsStorageEncryption)
+ d.Set("vpc", found.Vpc)
+
+ return nil
+}

aws/data_source_aws_neptune_orderable_db_instance_test.go

@@ -0,0 +1,101 @@
+package aws
+
+import (
+ "fmt"
+ "testing"
+
+ "github.com/aws/aws-sdk-go/aws"
+ "github.com/aws/aws-sdk-go/service/neptune"
+ "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+)
+
+func TestAccAWSNeptuneOrderableDbInstanceDataSource_basic(t *testing.T) {
+ dataSourceName := "data.aws_neptune_orderable_db_instance.test"
+ engine := "neptune"
+ engineVersion := "1.0.2.2"
+ licenseModel := "amazon-license"
+ class := "db.t3.medium"
+
+ resource.ParallelTest(t, resource.TestCase{
+ PreCheck: func() { testAccPreCheck(t); testAccPreCheckAWSNeptuneOrderableDbInstance(t) },
+ Providers: testAccProviders,
+ CheckDestroy: nil,
+ Steps: []resource.TestStep{
+ {
+ Config: testAccAWSNeptuneOrderableDbInstanceDataSourceConfigBasic(class, engine, engineVersion, licenseModel),
+ Check: resource.ComposeTestCheckFunc(
+ resource.TestCheckResourceAttr(dataSourceName, "engine", engine),
+ resource.TestCheckResourceAttr(dataSourceName, "engine_version", engineVersion),
+ resource.TestCheckResourceAttr(dataSourceName, "license_model", licenseModel),
+ resource.TestCheckResourceAttr(dataSourceName, "db_instance_class", class),
+ ),
+ },
+ },
+ })
+}
+
+func TestAccAWSNeptuneOrderableDbInstanceDataSource_preferred(t *testing.T) {
+ dataSourceName := "data.aws_neptune_orderable_db_instance.test"
+ engine := "neptune"
+ engineVersion := "1.0.3.0"
+ licenseModel := "amazon-license"
+ preferredOption := "db.r4.2xlarge"
+
+ resource.ParallelTest(t, resource.TestCase{
+ PreCheck: func() { testAccPreCheck(t); testAccPreCheckAWSNeptuneOrderableDbInstance(t) },
+ Providers: testAccProviders,
+ CheckDestroy: nil,
+ Steps: []resource.TestStep{
+ {
+ Config: testAccAWSNeptuneOrderableDbInstanceDataSourceConfigPreferred(engine, engineVersion, licenseModel, preferredOption),
+ Check: resource.ComposeTestCheckFunc(
+ resource.TestCheckResourceAttr(dataSourceName, "engine", engine),
+ resource.TestCheckResourceAttr(dataSourceName, "engine_version", engineVersion),
+ resource.TestCheckResourceAttr(dataSourceName, "license_model", licenseModel),
+ resource.TestCheckResourceAttr(dataSourceName, "db_instance_class", preferredOption),
+ ),
+ },
+ },
+ })
+}
+
+func testAccPreCheckAWSNeptuneOrderableDbInstance(t *testing.T) {
+ conn := testAccProvider.Meta().(*AWSClient).neptuneconn
+
+ input := &neptune.DescribeOrderableDBInstanceOptionsInput{
+ Engine: aws.String("mysql"),
+ }
+
+ _, err := conn.DescribeOrderableDBInstanceOptions(input)
+
+ if testAccPreCheckSkipError(err) {
+ t.Skipf("skipping acceptance testing: %s", err)
+ }
+
+ if err != nil {
+ t.Fatalf("unexpected PreCheck error: %s", err)
+ }
+}
+
+func testAccAWSNeptuneOrderableDbInstanceDataSourceConfigBasic(class, engine, version, license string) string {
+ return fmt.Sprintf(`
+data "aws_neptune_orderable_db_instance" "test" {
+ db_instance_class = %q
+ engine = %q
+ engine_version = %q
+ license_model = %q
+}
+`, class, engine, version, license)
+}
+
+func testAccAWSNeptuneOrderableDbInstanceDataSourceConfigPreferred(engine, version, license, preferredOption string) string {
+ return fmt.Sprintf(`
+data "aws_neptune_orderable_db_instance" "test" {
+ engine = %q
+ engine_version = %q
+ license_model = %q
+
+ preferred_db_instance_classes = ["db.xyz.xlarge", %q, "db.t3.small"]
+}
+`, engine, version, license, preferredOption)
+}

aws/provider.go

@@ -286,6 +286,7 @@ func Provider() *schema.Provider {
  "aws_msk_cluster": dataSourceAwsMskCluster(),
  "aws_msk_configuration": dataSourceAwsMskConfiguration(),
  "aws_nat_gateway": dataSourceAwsNatGateway(),
+ "aws_neptune_orderable_db_instance": dataSourceAwsNeptuneOrderableDbInstance(),
  "aws_network_acls": dataSourceAwsNetworkAcls(),
  "aws_network_interface": dataSourceAwsNetworkInterface(),
  "aws_network_interfaces": dataSourceAwsNetworkInterfaces(),