added support for identifier in volume datasource

ibm/service/vpc/data_source_ibm_is_volume.go

@@ -4,25 +4,35 @@
 package vpc
 
 import (
+	"context"
 	"fmt"
 	"log"
 
 	"github.com/IBM-Cloud/terraform-provider-ibm/ibm/flex"
 	"github.com/IBM-Cloud/terraform-provider-ibm/ibm/validate"
 	"github.com/IBM/vpc-go-sdk/vpcv1"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 )
 
 func DataSourceIBMISVolume() *schema.Resource {
 	return &schema.Resource{
-		Read: dataSourceIBMISVolumeRead,
+		ReadContext: dataSourceIBMISVolumeRead,
 
 		Schema: map[string]*schema.Schema{
 
 			isVolumeName: {
 				Type:         schema.TypeString,
-				Required:     true,
-				ValidateFunc: validate.InvokeDataSourceValidator("ibm_is_subnet", isVolumeName),
+				Optional:     true,
+				ExactlyOneOf: []string{isVolumeName, "identifier"},
+				ValidateFunc: validate.InvokeDataSourceValidator("ibm_is_volume", isVolumeName),
+				Description:  "Volume name",
+			},
+			"identifier": {
+				Type:         schema.TypeString,
+				Optional:     true,
+				ExactlyOneOf: []string{isVolumeName, "identifier"},
+				ValidateFunc: validate.InvokeDataSourceValidator("ibm_is_volume", "identifier"),
 				Description:  "Volume name",
 			},
 
@@ -317,6 +327,11 @@ func DataSourceIBMISVolume() *schema.Resource {
 
 func DataSourceIBMISVolumeValidator() *validate.ResourceValidator {
 	validateSchema := make([]validate.ValidateSchema, 0)
+	validateSchema = append(validateSchema,
+		validate.ValidateSchema{
+			Identifier:                 "identifier",
+			ValidateFunctionIdentifier: validate.ValidateNoZeroValues,
+			Type:                       validate.TypeString})
 	validateSchema = append(validateSchema,
 		validate.ValidateSchema{
 			Identifier:                 isVolumeName,
@@ -327,44 +342,58 @@ func DataSourceIBMISVolumeValidator() *validate.ResourceValidator {
 	return &ibmISVoulmeDataSourceValidator
 }
 
-func dataSourceIBMISVolumeRead(d *schema.ResourceData, meta interface{}) error {
-
-	name := d.Get(isVolumeName).(string)
+func dataSourceIBMISVolumeRead(context context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 
-	err := volumeGet(d, meta, name)
+	err := volumeGet(d, meta)
 	if err != nil {
-		return err
+		return diag.FromErr(err)
 	}
 	return nil
 }
 
-func volumeGet(d *schema.ResourceData, meta interface{}, name string) error {
+func volumeGet(d *schema.ResourceData, meta interface{}) error {
 	sess, err := vpcClient(meta)
 	if err != nil {
 		return err
 	}
-	zone := ""
-	if zname, ok := d.GetOk(isVolumeZone); ok {
-		zone = zname.(string)
-	}
-	listVolumesOptions := &vpcv1.ListVolumesOptions{
-		Name: &name,
-	}
 
-	if zone != "" {
-		listVolumesOptions.ZoneName = &zone
-	}
-	listVolumesOptions.Name = &name
-	vols, response, err := sess.ListVolumes(listVolumesOptions)
-	if err != nil {
-		return fmt.Errorf("[ERROR] Error Fetching volumes %s\n%s", err, response)
-	}
-	allrecs := vols.Volumes
+	var vol vpcv1.Volume
+	if volName, ok := d.GetOk(isVolumeName); ok {
+		name := volName.(string)
+		zone := ""
+		if zname, ok := d.GetOk(isVolumeZone); ok {
+			zone = zname.(string)
+		}
+		listVolumesOptions := &vpcv1.ListVolumesOptions{
+			Name: &name,
+		}
 
-	if len(allrecs) == 0 {
-		return fmt.Errorf("[ERROR] No Volume found with name %s", name)
+		if zone != "" {
+			listVolumesOptions.ZoneName = &zone
+		}
+		listVolumesOptions.Name = &name
+		vols, response, err := sess.ListVolumes(listVolumesOptions)
+		if err != nil {
+			return fmt.Errorf("[ERROR] Error Fetching volumes %s\n%s", err, response)
+		}
+		allrecs := vols.Volumes
+
+		if len(allrecs) == 0 {
+			return fmt.Errorf("[ERROR] No Volume found with name %s", name)
+		}
+		vol = allrecs[0]
+	} else {
+		identifier := d.Get("identifier").(string)
+		getVolumeOptions := &vpcv1.GetVolumeOptions{
+			ID: &identifier,
+		}
+
+		volPtr, response, err := sess.GetVolume(getVolumeOptions)
+		if err != nil {
+			return fmt.Errorf("[ERROR] Error on get volume %s\n%s", err, response)
+		}
+		vol = *volPtr
 	}
-	vol := allrecs[0]
 	d.SetId(*vol.ID)
 	if vol.Active != nil {
 		d.Set(isVolumesActive, vol.Active)
@@ -383,6 +412,7 @@ func volumeGet(d *schema.ResourceData, meta interface{}, name string) error {
 		d.Set(isVolumesCreatedAt, flex.DateTimeToString(vol.CreatedAt))
 	}
 	d.Set(isVolumeName, *vol.Name)
+	d.Set("identifier", *vol.ID)
 	if vol.OperatingSystem != nil {
 		operatingSystemList := []map[string]interface{}{}
 		operatingSystemMap := dataSourceVolumeCollectionVolumesOperatingSystemToMap(*vol.OperatingSystem)

ibm/service/vpc/data_source_ibm_is_volume_test.go

@@ -49,6 +49,60 @@ func TestAccIBMISVolumeDatasource_basic(t *testing.T) {
 		},
 	})
 }
+func TestAccIBMISVolumeDatasourceIdnetifier_basic(t *testing.T) {
+	name := fmt.Sprintf("tf-vol-%d", acctest.RandIntRange(10, 100))
+	zone := acc.ISZoneName
+	resName := "data.ibm_is_volume.testacc_dsvol"
+	resNameId := "data.ibm_is_volume.testacc_dsvolidentifier"
+
+	resource.Test(t, resource.TestCase{
+		PreCheck:  func() { acc.TestAccPreCheck(t) },
+		Providers: acc.TestAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccCheckIBMISVolumeDataSourceWithIdentifierConfig(name, zone),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr(
+						resName, "name", name),
+					resource.TestCheckResourceAttr(
+						resName, "zone", zone),
+					resource.TestCheckResourceAttrSet(
+						resName, "active"),
+					resource.TestCheckResourceAttrSet(
+						resName, "attachment_state"),
+					resource.TestCheckResourceAttrSet(
+						resName, "bandwidth"),
+					resource.TestCheckResourceAttrSet(
+						resName, "busy"),
+					resource.TestCheckResourceAttrSet(
+						resName, "created_at"),
+					resource.TestCheckResourceAttrSet(
+						resName, "resource_group"),
+					resource.TestCheckResourceAttrSet(
+						resName, "profile"),
+					resource.TestCheckResourceAttr(
+						resNameId, "name", name),
+					resource.TestCheckResourceAttr(
+						resNameId, "zone", zone),
+					resource.TestCheckResourceAttrSet(
+						resNameId, "active"),
+					resource.TestCheckResourceAttrSet(
+						resNameId, "attachment_state"),
+					resource.TestCheckResourceAttrSet(
+						resNameId, "bandwidth"),
+					resource.TestCheckResourceAttrSet(
+						resNameId, "busy"),
+					resource.TestCheckResourceAttrSet(
+						resNameId, "created_at"),
+					resource.TestCheckResourceAttrSet(
+						resNameId, "resource_group"),
+					resource.TestCheckResourceAttrSet(
+						resNameId, "profile"),
+				),
+			},
+		},
+	})
+}
 func TestAccIBMISVolumeDatasource_Sdp(t *testing.T) {
 	name := fmt.Sprintf("tf-vol-%d", acctest.RandIntRange(10, 100))
 	zone := "eu-gb-1"
@@ -193,6 +247,22 @@ func testAccCheckIBMISVolumeDataSourceConfig(name, zone string) string {
 		name = ibm_is_volume.testacc_volume.name
 	}`, name, zone)
 }
+func testAccCheckIBMISVolumeDataSourceWithIdentifierConfig(name, zone string) string {
+	return fmt.Sprintf(`
+	resource "ibm_is_volume" "testacc_volume"{
+		name = "%s"
+		profile = "10iops-tier"
+		zone = "%s"
+	}
+	data "ibm_is_volume" "testacc_dsvol" {
+		name = ibm_is_volume.testacc_volume.name
+	}
+	data "ibm_is_volume" "testacc_dsvolidentifier" {
+		identifier = ibm_is_volume.testacc_volume.id
+	}
+
+	`, name, zone)
+}
 func testAccCheckIBMISVolumeDataSourceSdpConfig(name, zone string) string {
 	return fmt.Sprintf(`
 	resource "ibm_is_volume" "testacc_volume"{

website/docs/d/is_volume.html.markdown

@@ -37,7 +37,8 @@ data "ibm_is_volume" "example" {
 ## Argument reference
 Review the argument references that you can specify for your data source. 
 
-- `name` - (Required, String) The name of the volume.
+- `identifier` - (Optional, String) The id of the volume. (one of `identifier`, `name` is required)
+- `name` - (Optional, String) The name of the volume. (one of `identifier`, `name` is required)
 - `zone` - (Optional, String) The zone name of the volume.
 
 ## Attribute reference