VolumeAttachment: Handle unsupported attachment types.

If an unsupported attachment type is returned by the service, we should
use the SDK's base interface to populate common fields.

This is better than panicking if we don't know the type.

This fixes github issue #477

Author: alexng-canuck

provider/core_volume_attachments_data_source.go

@@ -4,6 +4,7 @@ package provider
 
 import (
 	"context"
+	"log"
 
 	"github.com/hashicorp/terraform/helper/schema"
 	oci_core "github.com/oracle/oci-go-sdk/core"
@@ -132,71 +133,79 @@ func (s *VolumeAttachmentsDataSourceCrud) SetData() {
 	resources := []map[string]interface{}{}
 
 	for _, r := range s.Res.Items {
-		iscsiVolumeAttachment, castOk := r.(oci_core.IScsiVolumeAttachment)
-		if !castOk {
-			panic("unexpected VolumeAttachment type on item.")
-		}
+		resources = append(resources, volumeAttachmentToMap(r))
+	}
 
-		volumeAttachment := map[string]interface{}{
-			"compartment_id":  *r.GetCompartmentId(),
-			"attachment_type": IScsiVolumeAttachmentDiscriminator,
-		}
+	if f, fOk := s.D.GetOkExists("filter"); fOk {
+		resources = ApplyFilters(f.(*schema.Set), resources)
+	}
 
-		if iscsiVolumeAttachment.AvailabilityDomain != nil {
-			volumeAttachment["availability_domain"] = *iscsiVolumeAttachment.AvailabilityDomain
-		}
+	if err := s.D.Set("volume_attachments", resources); err != nil {
+		panic(err)
+	}
 
-		if iscsiVolumeAttachment.DisplayName != nil {
-			volumeAttachment["display_name"] = *iscsiVolumeAttachment.DisplayName
-		}
+	return
+}
 
-		if iscsiVolumeAttachment.Id != nil {
-			volumeAttachment["id"] = *iscsiVolumeAttachment.Id
-		}
+func volumeAttachmentToMap(r oci_core.VolumeAttachment) map[string]interface{} {
+	volumeAttachment := map[string]interface{}{
+		"compartment_id": *r.GetCompartmentId(),
+	}
 
-		if iscsiVolumeAttachment.InstanceId != nil {
-			volumeAttachment["instance_id"] = *iscsiVolumeAttachment.InstanceId
-		}
+	if availabilityDomain := r.GetAvailabilityDomain(); availabilityDomain != nil {
+		volumeAttachment["availability_domain"] = *availabilityDomain
+	}
 
-		volumeAttachment["state"] = iscsiVolumeAttachment.LifecycleState
+	if displayName := r.GetDisplayName(); displayName != nil {
+		volumeAttachment["display_name"] = *displayName
+	}
 
-		volumeAttachment["time_created"] = iscsiVolumeAttachment.TimeCreated.String()
+	if id := r.GetId(); id != nil {
+		volumeAttachment["id"] = *id
+	}
 
-		if iscsiVolumeAttachment.VolumeId != nil {
-			volumeAttachment["volume_id"] = *iscsiVolumeAttachment.VolumeId
-		}
+	if instanceId := r.GetInstanceId(); instanceId != nil {
+		volumeAttachment["instance_id"] = *instanceId
+	}
+
+	volumeAttachment["state"] = string(r.GetLifecycleState())
+
+	if timeCreated := r.GetTimeCreated(); timeCreated != nil {
+		volumeAttachment["time_created"] = timeCreated.String()
+	}
+
+	if volumeId := r.GetVolumeId(); volumeId != nil {
+		volumeAttachment["volume_id"] = *volumeId
+	}
+
+	switch typedValue := r.(type) {
+	case oci_core.IScsiVolumeAttachment:
+		volumeAttachment["attachment_type"] = IScsiVolumeAttachmentDiscriminator
 
 		// IScsiVolumeAttachment-specific fields:
-		if iscsiVolumeAttachment.ChapSecret != nil {
-			volumeAttachment["chap_secret"] = *iscsiVolumeAttachment.ChapSecret
+		if typedValue.ChapSecret != nil {
+			volumeAttachment["chap_secret"] = *typedValue.ChapSecret
 		}
 
-		if iscsiVolumeAttachment.ChapUsername != nil {
-			volumeAttachment["chap_username"] = *iscsiVolumeAttachment.ChapUsername
+		if typedValue.ChapUsername != nil {
+			volumeAttachment["chap_username"] = *typedValue.ChapUsername
 		}
 
-		if iscsiVolumeAttachment.Ipv4 != nil {
-			volumeAttachment["ipv4"] = *iscsiVolumeAttachment.Ipv4
+		if typedValue.Ipv4 != nil {
+			volumeAttachment["ipv4"] = *typedValue.Ipv4
 		}
 
-		if iscsiVolumeAttachment.Iqn != nil {
-			volumeAttachment["iqn"] = *iscsiVolumeAttachment.Iqn
+		if typedValue.Iqn != nil {
+			volumeAttachment["iqn"] = *typedValue.Iqn
 		}
 
-		if iscsiVolumeAttachment.Port != nil {
-			volumeAttachment["port"] = *iscsiVolumeAttachment.Port
+		if typedValue.Port != nil {
+			volumeAttachment["port"] = *typedValue.Port
 		}
-
-		resources = append(resources, volumeAttachment)
+	default:
+		volumeAttachment["attachment_type"] = "Unknown"
+		log.Printf("[WARNING] Retrieved a volume attachment of unknown type.")
 	}
 
-	if f, fOk := s.D.GetOkExists("filter"); fOk {
-		resources = ApplyFilters(f.(*schema.Set), resources)
-	}
-
-	if err := s.D.Set("volume_attachments", resources); err != nil {
-		panic(err)
-	}
-
-	return
+	return volumeAttachment
 }

provider/core_volume_attachments_data_source_test.go

@@ -4,6 +4,11 @@ package provider
 
 import (
 	"testing"
+	"time"
+
+	common "github.com/oracle/oci-go-sdk/common"
+
+	oci_core "github.com/oracle/oci-go-sdk/core"
 
 	"github.com/hashicorp/terraform/helper/resource"
 	"github.com/hashicorp/terraform/terraform"
@@ -78,6 +83,93 @@ func (s *DatasourceCoreVolumeAttachmentTestSuite) TestAccDatasourceCoreVolumeAtt
 	)
 }
 
+type customVolumeAttachment struct {
+	ad            string
+	compartmentId string
+	id            string
+	instanceId    string
+	volumeId      string
+	displayName   string
+	timeCreated   common.SDKTime
+	state         oci_core.VolumeAttachmentLifecycleStateEnum
+}
+
+//GetAvailabilityDomain returns AvailabilityDomain
+func (m customVolumeAttachment) GetAvailabilityDomain() *string {
+	return &m.ad
+}
+
+//GetCompartmentId returns CompartmentId
+func (m customVolumeAttachment) GetCompartmentId() *string {
+	return &m.compartmentId
+}
+
+//GetId returns Id
+func (m customVolumeAttachment) GetId() *string {
+	return &m.id
+}
+
+//GetInstanceId returns InstanceId
+func (m customVolumeAttachment) GetInstanceId() *string {
+	return &m.instanceId
+}
+
+//GetLifecycleState returns LifecycleState
+func (m customVolumeAttachment) GetLifecycleState() oci_core.VolumeAttachmentLifecycleStateEnum {
+	return m.state
+}
+
+//GetTimeCreated returns TimeCreated
+func (m customVolumeAttachment) GetTimeCreated() *common.SDKTime {
+	return &m.timeCreated
+}
+
+//GetVolumeId returns VolumeId
+func (m customVolumeAttachment) GetVolumeId() *string {
+	return &m.volumeId
+}
+
+//GetDisplayName returns DisplayName
+func (m customVolumeAttachment) GetDisplayName() *string {
+	return &m.displayName
+}
+
+func checkExpectedValue(mapped map[string]interface{}, key string, expected string, t *testing.T) {
+	if value := mapped[key].(string); value != expected {
+		t.Errorf("Expected attachment to have type %s, but got %s", expected, value)
+	}
+}
+
+// This unit tests that any datasource result that implements the SDK's VolumeAttachment interface can
+// be converted to a map to be stored in Terraform.
+func TestUnitVolumeAttachmentToMap_unknownType(t *testing.T) {
+	customAttachment := customVolumeAttachment{
+		ad:            "ad1",
+		compartmentId: "compartment",
+		id:            "myId",
+		instanceId:    "myInstanceId",
+		volumeId:      "myVolumeId",
+		displayName:   "myDisplayName",
+		timeCreated:   common.SDKTime{time.Now()},
+		state:         oci_core.VolumeAttachmentLifecycleStateDetached,
+	}
+
+	result := volumeAttachmentToMap(customAttachment)
+
+	// Check that type is set to Unknown for unsupported VolumeAttachment types
+	checkExpectedValue(result, "attachment_type", "Unknown", t)
+
+	// Check that all VolumeAttachment base class attributes are set
+	checkExpectedValue(result, "availability_domain", customAttachment.ad, t)
+	checkExpectedValue(result, "compartment_id", customAttachment.compartmentId, t)
+	checkExpectedValue(result, "id", customAttachment.id, t)
+	checkExpectedValue(result, "instance_id", customAttachment.instanceId, t)
+	checkExpectedValue(result, "volume_id", customAttachment.volumeId, t)
+	checkExpectedValue(result, "display_name", customAttachment.displayName, t)
+	checkExpectedValue(result, "time_created", customAttachment.timeCreated.String(), t)
+	checkExpectedValue(result, "state", string(customAttachment.state), t)
+}
+
 func TestDatasourceCoreVolumeAttachmentTestSuite(t *testing.T) {
 	suite.Run(t, new(DatasourceCoreVolumeAttachmentTestSuite))
 }