Feat: Add google_oracle_database_db_servers datasource

.changelog/11963.txt

@@ -0,0 +1,3 @@
+```release-note:new-datasource
+`google_oracle_database_db_servers`
+```

google-beta/provider/provider_mmv1_resources.go

@@ -292,6 +292,7 @@ var handwrittenDatasources = map[string]*schema.Resource{
 	"google_monitoring_app_engine_service":                 monitoring.DataSourceMonitoringServiceAppEngine(),
 	"google_monitoring_uptime_check_ips":                   monitoring.DataSourceGoogleMonitoringUptimeCheckIps(),
 	"google_netblock_ip_ranges":                            resourcemanager.DataSourceGoogleNetblockIpRanges(),
+	"google_oracle_database_db_servers":                    oracledatabase.DataSourceOracleDatabaseDbServers(),
 	"google_organization":                                  resourcemanager.DataSourceGoogleOrganization(),
 	"google_privateca_certificate_authority":               privateca.DataSourcePrivatecaCertificateAuthority(),
 	"google_privileged_access_manager_entitlement":         privilegedaccessmanager.DataSourceGooglePrivilegedAccessManagerEntitlement(),

google-beta/services/oracledatabase/data_source_oracle_database_db_servers.go

@@ -0,0 +1,249 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+package oracledatabase
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"github.com/hashicorp/terraform-provider-google-beta/google-beta/tpgresource"
+	transport_tpg "github.com/hashicorp/terraform-provider-google-beta/google-beta/transport"
+)
+
+func DataSourceOracleDatabaseDbServers() *schema.Resource {
+	dsSchema := map[string]*schema.Schema{
+		"project": {
+			Type:        schema.TypeString,
+			Optional:    true,
+			Description: "The ID of the project in which the dataset is located. If it is not provided, the provider project is used.",
+		},
+		"location": {
+			Type:        schema.TypeString,
+			Required:    true,
+			Description: "location",
+		},
+		"cloud_exadata_infrastructure": {
+			Type:        schema.TypeString,
+			Required:    true,
+			Description: "exadata",
+		},
+		"db_servers": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"display_name": {
+						Type:        schema.TypeString,
+						Computed:    true,
+						Description: "The Display name",
+					},
+					"properties": {
+						Type:     schema.TypeList,
+						Computed: true,
+						Elem: &schema.Resource{
+							Schema: map[string]*schema.Schema{
+								"ocid": {
+									Type:        schema.TypeString,
+									Computed:    true,
+									Description: "Output only",
+								},
+								"ocpu_count": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Output only",
+								},
+								"max_ocpu_count": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Output only",
+								},
+								"memory_size_gb": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Output only",
+								},
+								"max_memory_size_gb": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Output only",
+								},
+								"db_node_storage_size_gb": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Output only",
+								},
+								"max_db_node_storage_size_gb": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Output only",
+								},
+								"vm_count": {
+									Type:        schema.TypeInt,
+									Computed:    true,
+									Description: "Output only",
+								},
+								"state": {
+									Type:        schema.TypeString,
+									Computed:    true,
+									Description: "Output only",
+								},
+								"db_node_ids": {
+									Type:        schema.TypeList,
+									Computed:    true,
+									Description: "Output only",
+									Elem: &schema.Schema{
+										Type: schema.TypeString,
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+	return &schema.Resource{
+		Read:          DataSourceOracleDatabaseDbServersRead,
+		Schema:        dsSchema,
+		UseJSONNumber: true,
+	}
+}
+
+func DataSourceOracleDatabaseDbServersRead(d *schema.ResourceData, meta interface{}) error {
+	config := meta.(*transport_tpg.Config)
+	userAgent, err := tpgresource.GenerateUserAgentString(d, config.UserAgent)
+	if err != nil {
+		return err
+	}
+
+	billingProject := ""
+	project, err := tpgresource.GetProject(d, config)
+	if err != nil {
+		return fmt.Errorf("Error fetching project for DbServer: %s", err)
+	}
+	billingProject = project
+	// err == nil indicates that the billing_project value was found
+	if bp, err := tpgresource.GetBillingProject(d, config); err == nil {
+		billingProject = bp
+	}
+
+	url, err := tpgresource.ReplaceVars(d, config, "{{OracleDatabaseBasePath}}projects/{{project}}/locations/{{location}}/cloudExadataInfrastructures/{{cloud_exadata_infrastructure}}/dbServers")
+	if err != nil {
+		return err
+	}
+
+	res, err := transport_tpg.SendRequest(transport_tpg.SendRequestOptions{
+		Config:    config,
+		Method:    "GET",
+		Project:   billingProject,
+		RawURL:    url,
+		UserAgent: userAgent,
+	})
+	if err != nil {
+		return fmt.Errorf("Error reading DbServer: %s", err)
+	}
+	if res["dbServers"] == nil {
+		return fmt.Errorf("Error reading DbServer: %s", err)
+	}
+	dbServers, err := flattenOracleDatabaseDbServerList(config, res["dbServers"])
+	if err != nil {
+		return fmt.Errorf("error flattening dbserver list: %s", err)
+	}
+
+	if err := d.Set("db_servers", dbServers); err != nil {
+		return fmt.Errorf("error setting dbserver: %s", err)
+	}
+
+	id, err := tpgresource.ReplaceVars(d, config, "projects/{{project}}/locations/{{location}}/cloudExadataInfrastructures/{{cloud_exadata_infrastructure_id}}/dbServers")
+	if err != nil {
+		return fmt.Errorf("Error constructing id: %s", err)
+	}
+	d.SetId(id)
+	return nil
+}
+
+func flattenOracleDatabaseDbServerList(config *transport_tpg.Config, dbServerList interface{}) (interface{}, error) {
+
+	if dbServerList == nil {
+		return nil, nil
+	}
+
+	l := dbServerList.([]interface{})
+	transformed := make([]interface{}, 0)
+	for _, raw := range l {
+		original := raw.(map[string]interface{})
+		transformed = append(transformed, map[string]interface{}{
+			"display_name": flattenOracleDatabaseDbServerDisplayName(original["displayName"], config),
+			"properties":   flattenOracleDatabaseDbServerProperties(original["properties"], config),
+		})
+	}
+	return transformed, nil
+
+}
+
+func flattenOracleDatabaseDbServerDisplayName(v interface{}, config *transport_tpg.Config) interface{} {
+	return v
+}
+
+func flattenOracleDatabaseDbServerProperties(v interface{}, config *transport_tpg.Config) interface{} {
+	if v == nil {
+		return nil
+	}
+	original := v.(map[string]interface{})
+	if len(original) == 0 {
+		return nil
+	}
+	transformed := make(map[string]interface{})
+	transformed["ocid"] = flattenOracleDatabaseDbServerPropertiesOcid(original["ocid"], config)
+	transformed["ocpu_count"] = flattenOracleDatabaseDbServerPropertiesOcpuCount(original["ocpuCount"], config)
+	transformed["max_ocpu_count"] = flattenOracleDatabaseDbServerPropertiesMaxOcpuCount(original["maxOcpuCount"], config)
+	transformed["memory_size_gb"] = flattenOracleDatabaseDbServerPropertiesMemorySizeGb(original["memorySizeGb"], config)
+	transformed["max_memory_size_gb"] = flattenOracleDatabaseDbServerPropertiesMaxMemorySizeGb(original["maxMemorySizeGb"], config)
+	transformed["db_node_storage_size_gb"] = flattenOracleDatabaseDbServerPropertiesDbNodeStorageSizeGb(original["dbNodeStorageSizeGb"], config)
+	transformed["max_db_node_storage_size_gb"] = flattenOracleDatabaseDbServerPropertiesMaxDbNodeStorageSizeGb(original["maxDbNodeStorageSizeGb"], config)
+	transformed["vm_count"] = flattenOracleDatabaseDbServerPropertiesVmcount(original["vmCount"], config)
+	transformed["state"] = flattenOracleDatabaseDbServerPropertiesState(original["state"], config)
+	transformed["db_node_ids"] = flattenOracleDatabaseDbServerPropertiesDbNodeIds(original["dbNodeIds"], config)
+
+	return []interface{}{transformed}
+}
+
+func flattenOracleDatabaseDbServerPropertiesOcid(v interface{}, config *transport_tpg.Config) interface{} {
+	return v
+}
+
+func flattenOracleDatabaseDbServerPropertiesOcpuCount(v interface{}, config *transport_tpg.Config) interface{} {
+	return v
+}
+
+func flattenOracleDatabaseDbServerPropertiesMaxOcpuCount(v interface{}, config *transport_tpg.Config) interface{} {
+	return v
+}
+
+func flattenOracleDatabaseDbServerPropertiesMemorySizeGb(v interface{}, config *transport_tpg.Config) interface{} {
+	return v
+}
+
+func flattenOracleDatabaseDbServerPropertiesMaxMemorySizeGb(v interface{}, config *transport_tpg.Config) interface{} {
+	return v
+}
+
+func flattenOracleDatabaseDbServerPropertiesDbNodeStorageSizeGb(v interface{}, config *transport_tpg.Config) interface{} {
+	return v
+}
+
+func flattenOracleDatabaseDbServerPropertiesMaxDbNodeStorageSizeGb(v interface{}, config *transport_tpg.Config) interface{} {
+	return v
+}
+
+func flattenOracleDatabaseDbServerPropertiesVmcount(v interface{}, config *transport_tpg.Config) interface{} {
+	return v
+}
+
+func flattenOracleDatabaseDbServerPropertiesState(v interface{}, config *transport_tpg.Config) interface{} {
+	return v
+}
+
+func flattenOracleDatabaseDbServerPropertiesDbNodeIds(v interface{}, config *transport_tpg.Config) interface{} {
+	return v
+}

google-beta/services/oracledatabase/data_source_oracle_database_db_servers_test.go

@@ -0,0 +1,43 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: MPL-2.0
+package oracledatabase_test
+
+import (
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
+	"github.com/hashicorp/terraform-provider-google-beta/google-beta/acctest"
+)
+
+func TestAccOracleDatabaseDbServers_basic(t *testing.T) {
+	t.Parallel()
+	acctest.VcrTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccOracleDatabaseDbServers_basic,
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttrSet("data.google_oracle_database_db_servers.my_db_servers", "db_servers.0.display_name"),
+					resource.TestCheckResourceAttrSet("data.google_oracle_database_db_servers.my_db_servers", "db_servers.0.properties.#"),
+					resource.TestCheckResourceAttrSet("data.google_oracle_database_db_servers.my_db_servers", "db_servers.0.properties.0.max_ocpu_count"),
+					resource.TestCheckResourceAttrSet("data.google_oracle_database_db_servers.my_db_servers", "db_servers.1.display_name"),
+					resource.TestCheckResourceAttrSet("data.google_oracle_database_db_servers.my_db_servers", "db_servers.1.properties.#"),
+					resource.TestCheckResourceAttrSet("data.google_oracle_database_db_servers.my_db_servers", "db_servers.1.properties.0.max_ocpu_count"),
+					resource.TestCheckResourceAttr("data.google_oracle_database_db_servers.my_db_servers", "db_servers.0.display_name", "dbServer-1"),
+					resource.TestCheckResourceAttr("data.google_oracle_database_db_servers.my_db_servers", "db_servers.1.display_name", "dbServer-2"),
+					resource.TestCheckResourceAttr("data.google_oracle_database_db_servers.my_db_servers", "db_servers.0.properties.0.max_ocpu_count", "126"),
+					resource.TestCheckResourceAttr("data.google_oracle_database_db_servers.my_db_servers", "db_servers.1.properties.0.max_ocpu_count", "126"),
+				),
+			},
+		},
+	})
+}
+
+const testAccOracleDatabaseDbServers_basic = `
+data "google_oracle_database_db_servers" "my_db_servers"{
+	location = "us-east4"
+	project = "oci-terraform-testing"
+	cloud_exadata_infrastructure = "ofake-do-not-delete-tf-exadata"
+}
+`

website/docs/d/oracle_database_db_servers.html.markdown

@@ -0,0 +1,67 @@
+---
+subcategory: "Oracle Database"
+description: |-
+  List all DbServers of a Cloud ExdataInfrastructure.
+---
+
+# google_oracle_database_db_servers
+
+List all DbServers of a Cloud Exdata Infrastructure.
+
+## Example Usage
+
+```hcl
+data "google_oracle_database_db_servers" "my_db_servers"{
+	location = "us-east4"
+	cloud_exadata_infrastructure = "exadata-id"
+}
+```
+
+## Argument Reference
+
+The following arguments are supported:
+
+* `cloud_exadata_infrastructure` - (Required) The Exadata Infrastructure id.
+
+* `location` - (Required) The location of resource.
+
+- - -
+* `project` - (Optional) The project to which the resource belongs. If it
+    is not provided, the provider project is used.
+
+* `db_servers` - (Output) List of dbServers
+
+<a name="nested_properties"></a> The `db_servers` block supports:
+
+* `display_name` - User friendly name for the resource.
+
+* `properties` - Various properties of the databse server.
+
+<a name="nested_properties"></a> The `properties` block supports:
+
+* `ocid` - The OCID of database server.
+
+* `ocpu_count` - The OCPU count per database.
+
+* `max_ocpu_count` - The total number of CPU cores available.
+
+* `memory_size_gb` - The allocated memory in gigabytes on the database server.
+
+* `max_memory_size_gb` - The total memory available in gigabytes.
+
+* `db_node_storage_size_gb` - The local storage per VM.
+
+* `max_db_node_storage_size_gb` - The total local node storage available in GBs.
+
+* `vm_count` - The VM count per database.
+
+* `state` - The current state of the database server.
+<a name="nested_states"></a>Allowed values for `state` are:<br>
+`STATE_UNSPECIFIED` - Default unspecified value.<br>
+`CREATING` - Indicates that the resource is being created.<br>
+`AVAILABLE` - Indicates that the resource is available.<br>
+`UNAVAILABLE` - Indicates that the resource is unavailable.<br>
+`DELETING` - Indicates that the resource is being deleted.<br>
+`DELETED` - Indicates that the resource has been deleted.<br>
+
+* `db_node_ids` - The OCID of database nodes associated with the database server.