Implement dds_instance_v3 data-source

docs/data-sources/dds_flavors_v3.md

@@ -9,7 +9,7 @@ Use this data source to get info of available OpenTelekomCloud DDS flavors.
 ## Example Usage
 
 ```hcl
-data "opentelekomcloud_dds_flavors" "flavor" {
+data "opentelekomcloud_dds_flavors_v3" "flavor" {
   engine_name = "DDS-Community"
   vcpus       = 8
 }

docs/data-sources/dds_instance_v3.md

@@ -0,0 +1,20 @@
+---
+subcategory: "Document Database Service (DDS)"
+---
+
+# opentelekomcloud_dds_instance_v3
+
+Use this data source to get info of the concrete OpenTelekomCloud DDS instance.
+
+## Example Usage
+
+```hcl
+data "opentelekomcloud_dds_instance_v3" "flavor" {
+  instance_id = "XXXX"
+  name        = "XXXX"
+}
+```
+
+## Argument Reference
+
+## Attributes Reference

opentelekomcloud/data_source_opentelekomcloud_dds_instance_v3.go

@@ -0,0 +1,270 @@
+package opentelekomcloud
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/go-multierror"
+	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
+	"github.com/opentelekomcloud/gophertelekomcloud/openstack/dds/v3/instances"
+)
+
+func dataSourceDdsInstanceV3() *schema.Resource {
+	return &schema.Resource{
+		Read: dataSourceDdsInstanceV3Read,
+
+		Schema: map[string]*schema.Schema{
+			"instance_id": {
+				Type:     schema.TypeString,
+				Optional: true,
+			},
+			"region": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"name": {
+				Type:     schema.TypeString,
+				Optional: true,
+			},
+			"datastore_type": {
+				Type:     schema.TypeString,
+				Optional: true,
+			},
+			"datastore": {
+				Type:     schema.TypeList,
+				Computed: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"type": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"version": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"storage_engine": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+					},
+				},
+			},
+			"availability_zone": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"vpc_id": {
+				Type:     schema.TypeString,
+				Optional: true,
+			},
+			"subnet_id": {
+				Type:     schema.TypeString,
+				Optional: true,
+			},
+			"security_group_id": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			// "password": {
+			// 	Type:      schema.TypeString,
+			// 	Sensitive: true,
+			// 	Computed:  true,
+			// },
+			"disk_encryption_id": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"mode": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"flavor": {
+				Type:     schema.TypeList,
+				Computed: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"type": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"num": {
+							Type:     schema.TypeInt,
+							Computed: true,
+						},
+						"storage": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"size": {
+							Type:     schema.TypeInt,
+							Computed: true,
+						},
+						"spec_code": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+					},
+				},
+			},
+			"backup_strategy": {
+				Type:     schema.TypeList,
+				Computed: true,
+				MaxItems: 1,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"start_time": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"keep_days": {
+							Type:     schema.TypeInt,
+							Computed: true,
+						},
+					},
+				},
+			},
+			"ssl": {
+				Type:     schema.TypeBool,
+				Computed: true,
+			},
+			"db_username": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"status": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"port": {
+				Type:     schema.TypeInt,
+				Computed: true,
+			},
+			"pay_mode": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"nodes": {
+				Type:     schema.TypeList,
+				Computed: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"id": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"name": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"type": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"role": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"private_ip": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"public_ip": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"status": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+					},
+				},
+			},
+		},
+	}
+}
+
+func dataSourceDdsInstanceV3Read(d *schema.ResourceData, meta interface{}) error {
+	config := meta.(*Config)
+	ddsClient, err := config.ddsV3Client(GetRegion(d, config))
+	if err != nil {
+		return fmt.Errorf("error creating OpenTelekomCloud DDS client: %s", err)
+	}
+
+	listOpts := instances.ListInstanceOpts{
+		Id:            d.Get("instance_id").(string),
+		Name:          d.Get("name").(string),
+		DataStoreType: d.Get("datastore_type").(string),
+		VpcId:         d.Get("vpc_id").(string),
+		SubnetId:      d.Get("subnet_id").(string),
+	}
+
+	allPages, err := instances.List(ddsClient, listOpts).AllPages()
+	if err != nil {
+		return fmt.Errorf("error fetching DDS instance: %s", err)
+	}
+	instancesList, err := instances.ExtractInstances(allPages)
+	if err != nil {
+		return fmt.Errorf("error extracting DDS instance: %s", err)
+	}
+	if len(instancesList.Instances) < 0 {
+		return fmt.Errorf("your query returned no results. Please change your search criteria and try again")
+	}
+
+	if len(instancesList.Instances) > 1 {
+		return fmt.Errorf("your query returned more than one result. Please try a more specific search criteria")
+	}
+
+	ddsInstance := instancesList.Instances[0]
+
+	d.SetId(ddsInstance.Id)
+	mErr := multierror.Append(nil,
+		d.Set("instance_id", ddsInstance.Id),
+		d.Set("name", ddsInstance.Name),
+		d.Set("region", GetRegion(d, config)),
+		d.Set("vpc_id", ddsInstance.VpcId),
+		d.Set("subnet_id", ddsInstance.SubnetId),
+		d.Set("security_group_id", ddsInstance.SecurityGroupId),
+		d.Set("disk_encryption_id", ddsInstance.DiskEncryptionId),
+		d.Set("mode", ddsInstance.Mode),
+		d.Set("db_username", ddsInstance.DbUserName),
+		d.Set("status", ddsInstance.Status),
+		d.Set("port", ddsInstance.Port),
+		d.Set("pay_mode", ddsInstance.PayMode),
+		d.Set("datastore_type", ddsInstance.DataStore.Type),
+	)
+	sslEnable := true
+	if ddsInstance.Ssl == 0 {
+		sslEnable = false
+	}
+	mErr = multierror.Append(
+		mErr,
+		d.Set("ssl", sslEnable),
+	)
+	datastoreList := make([]map[string]interface{}, 0, 1)
+	datastore := map[string]interface{}{
+		"type":           ddsInstance.DataStore.Type,
+		"version":        ddsInstance.DataStore.Version,
+		"storage_engine": ddsInstance.Engine,
+	}
+	datastoreList = append(datastoreList, datastore)
+	if err = d.Set("datastore", datastoreList); err != nil {
+		return fmt.Errorf("error setting DDSv3 datastore opts: %s", err)
+	}
+
+	backupStrategyList := make([]map[string]interface{}, 0, 1)
+	backupStrategy := map[string]interface{}{
+		"start_time": ddsInstance.BackupStrategy.StartTime,
+		"keep_days":  ddsInstance.BackupStrategy.KeepDays,
+	}
+	backupStrategyList = append(backupStrategyList, backupStrategy)
+	if err = d.Set("backup_strategy", backupStrategyList); err != nil {
+		return fmt.Errorf("error setting DDSv3 backup_strategy opts: %s", err)
+	}
+
+	err = d.Set("nodes", FlattenDdsInstanceV3Nodes(ddsInstance))
+	if err != nil {
+		return fmt.Errorf("error setting nodes of DDSv3 instance: %s", err)
+	}
+
+	return mErr.ErrorOrNil()
+}

opentelekomcloud/data_source_opentelekomcloud_dds_instance_v3_test.go

@@ -0,0 +1,46 @@
+package opentelekomcloud
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-sdk/helper/resource"
+	"github.com/hashicorp/terraform-plugin-sdk/terraform"
+)
+
+func TestAccDDSInstanceV3DataSource_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck:  func() { testAccPreCheck(t) },
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDDSInstanceV3DataSource_basic,
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckDDSInstanceV3DataSourceID("data.opentelekomcloud_dds_instance_v3.instance"),
+					resource.TestCheckResourceAttr("data.opentelekomcloud_dds_instance_v3.instance", "name", ""),
+					resource.TestCheckResourceAttr("data.opentelekomcloud_dds_instance_v3.instance", "name", ""),
+					resource.TestCheckResourceAttr("data.opentelekomcloud_dds_instance_v3.instance", "name", ""),
+					resource.TestCheckResourceAttr("data.opentelekomcloud_dds_instance_v3.instance", "name", ""),
+				),
+			},
+		},
+	})
+}
+
+func testAccCheckDDSInstanceV3DataSourceID(n string) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		rs, ok := s.RootModule().Resources[n]
+		if !ok {
+			return fmt.Errorf("Can't find instances data source: %s ", n)
+		}
+
+		if rs.Primary.ID == "" {
+			return fmt.Errorf("Node data source ID not set ")
+		}
+
+		return nil
+	}
+}
+
+var testAccDDSInstanceV3DataSource_basic = fmt.Sprint(`
+`)

opentelekomcloud/provider.go

@@ -242,6 +242,7 @@ func Provider() terraform.ResourceProvider {
 			"opentelekomcloud_dcs_maintainwindow_v1":         dataSourceDcsMaintainWindowV1(),
 			"opentelekomcloud_dcs_product_v1":                dataSourceDcsProductV1(),
 			"opentelekomcloud_dds_flavors_v3":                dataSourceDdsFlavorV3(),
+			"opentelekomcloud_dds_instance_v3":               dataSourceDdsInstanceV3(),
 			"opentelekomcloud_dms_az_v1":                     dataSourceDmsAZV1(),
 			"opentelekomcloud_dms_product_v1":                dataSourceDmsProductV1(),
 			"opentelekomcloud_dms_maintainwindow_v1":         dataSourceDmsMaintainWindowV1(),

opentelekomcloud/resource_opentelekomcloud_dds_instance_v3.go

@@ -430,7 +430,7 @@ func resourceDdsInstanceV3Read(d *schema.ResourceData, meta interface{}) error {
 	}
 
 	// save nodes attribute
-	err = d.Set("nodes", flattenDdsInstanceV3Nodes(instance))
+	err = d.Set("nodes", FlattenDdsInstanceV3Nodes(instance))
 	if err != nil {
 		return fmt.Errorf("error setting nodes of DDSv3 instance: %s", err)
 	}
@@ -540,7 +540,7 @@ func resourceDdsInstanceV3Delete(d *schema.ResourceData, meta interface{}) error
 	return nil
 }
 
-func flattenDdsInstanceV3Nodes(dds instances.InstanceResponse) interface{} {
+func FlattenDdsInstanceV3Nodes(dds instances.InstanceResponse) interface{} {
 	nodesList := make([]map[string]interface{}, 0)
 	for _, group := range dds.Groups {
 		groupType := group.Type