data_source_ibm_is_instances.go

// Copyright IBM Corp. 2017, 2021 All Rights Reserved.
// Licensed under the Mozilla Public License v2.0

package vpc

import (
	"fmt"
	"log"
	"time"

	"github.com/IBM-Cloud/terraform-provider-ibm/ibm/flex"
	"github.com/IBM/vpc-go-sdk/vpcv1"
	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
)

const (
	isInstances         = "instances"
	isInstanceGroupName = "instance_group_name"
)

func DataSourceIBMISInstances() *schema.Resource {
	return &schema.Resource{
		Read: dataSourceIBMISInstancesRead,

		Schema: map[string]*schema.Schema{
			isInstanceGroup: {
				Type:          schema.TypeString,
				Optional:      true,
				ConflictsWith: []string{"vpc", "vpc_crn", "vpc_name", isInstanceGroupName},
				Description:   "Instance group ID to filter the instances attached to it",
			},
			isInstanceGroupName: {
				Type:          schema.TypeString,
				Optional:      true,
				ConflictsWith: []string{"vpc", "vpc_crn", "vpc_name", isInstanceGroup},
				Description:   "Instance group name to filter the instances attached to it",
			},
			"vpc_name": {
				Type:          schema.TypeString,
				Optional:      true,
				ConflictsWith: []string{"vpc", "vpc_crn", "instance_group"},
				Description:   "Name of the vpc to filter the instances attached to it",
			},

			"vpc": {
				Type:          schema.TypeString,
				Optional:      true,
				ConflictsWith: []string{"vpc_name", "vpc_crn", "instance_group"},
				Description:   "VPC ID to filter the instances attached to it",
			},

			"vpc_crn": {
				Type:          schema.TypeString,
				Optional:      true,
				ConflictsWith: []string{"vpc_name", "vpc", "instance_group"},
				Description:   "VPC CRN to filter the instances attached to it",
			},

			"resource_group": {
				Type:        schema.TypeString,
				Optional:    true,
				Description: "Instance resource group",
			},

			"dedicated_host_name": {
				Type:          schema.TypeString,
				Optional:      true,
				ConflictsWith: []string{"dedicated_host"},
				Description:   "Name of the dedicated host to filter the instances attached to it",
			},

			"dedicated_host": {
				Type:          schema.TypeString,
				Optional:      true,
				ConflictsWith: []string{"dedicated_host_name"},
				Description:   "ID of the dedicated host to filter the instances attached to it",
			},

			"placement_group_name": {
				Type:          schema.TypeString,
				Optional:      true,
				ConflictsWith: []string{"placement_group"},
				Description:   "Name of the placement group to filter the instances attached to it",
			},

			"placement_group": {
				Type:          schema.TypeString,
				Optional:      true,
				ConflictsWith: []string{"placement_group_name"},
				Description:   "ID of the placement group to filter the instances attached to it",
			},

			isInstances: {
				Type:        schema.TypeList,
				Description: "List of instances",
				Computed:    true,
				Elem: &schema.Resource{
					Schema: map[string]*schema.Schema{
						"id": {
							Type:        schema.TypeString,
							Computed:    true,
							Description: "Instance id",
						},
						"name": {
							Type:        schema.TypeString,
							Computed:    true,
							Description: "Instance name",
						},
						"crn": {
							Type:        schema.TypeString,
							Computed:    true,
							Description: "The crn for this Instance",
						},
						"memory": {
							Type:        schema.TypeInt,
							Computed:    true,
							Description: "Instance memory",
						},
						"numa_count": {
							Type:        schema.TypeInt,
							Computed:    true,
							Description: "The number of NUMA nodes this virtual server instance is provisioned on. This property may be absent if the instance's `status` is not `running`.",
						},
						isInstanceMetadataServiceEnabled: {
							Type:        schema.TypeBool,
							Computed:    true,
							Description: "Indicates whether the metadata service endpoint is available to the virtual server instance",
						},
						isInstanceMetadataService: {
							Type:        schema.TypeList,
							Computed:    true,
							Description: "The metadata service configuration",
							Elem: &schema.Resource{
								Schema: map[string]*schema.Schema{
									isInstanceMetadataServiceEnabled1: {
										Type:        schema.TypeBool,
										Computed:    true,
										Description: "Indicates whether the metadata service endpoint will be available to the virtual server instance",
									},

									isInstanceMetadataServiceProtocol: {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "The communication protocol to use for the metadata service endpoint. Applies only when the metadata service is enabled.",
									},

									isInstanceMetadataServiceRespHopLimit: {
										Type:        schema.TypeInt,
										Computed:    true,
										Description: "The hop limit (IP time to live) for IP response packets from the metadata service",
									},
								},
							},
						},
						"status": {
							Type:        schema.TypeString,
							Computed:    true,
							Description: "Instance status",
						},
						isInstanceAvailablePolicyHostFailure: {
							Type:        schema.TypeString,
							Computed:    true,
							Description: "The availability policy to use for this virtual server instance. The action to perform if the compute host experiences a failure.",
						},

						isInstanceLifecycleState: {
							Type:        schema.TypeString,
							Computed:    true,
							Description: "The lifecycle state of the virtual server instance.",
						},
						isInstanceLifecycleReasons: {
							Type:        schema.TypeList,
							Computed:    true,
							Description: "The reasons for the current lifecycle_state (if any).",
							Elem: &schema.Resource{
								Schema: map[string]*schema.Schema{
									isInstanceLifecycleReasonsCode: {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "A snake case string succinctly identifying the reason for this lifecycle state.",
									},

									isInstanceLifecycleReasonsMessage: {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "An explanation of the reason for this lifecycle state.",
									},

									isInstanceLifecycleReasonsMoreInfo: {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "Link to documentation about the reason for this lifecycle state.",
									},
								},
							},
						},

						isInstanceStatusReasons: {
							Type:        schema.TypeList,
							Computed:    true,
							Description: "The reasons for the current status (if any).",
							Elem: &schema.Resource{
								Schema: map[string]*schema.Schema{
									isInstanceStatusReasonsCode: {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "A snake case string succinctly identifying the status reason",
									},

									isInstanceStatusReasonsMessage: {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "An explanation of the status reason",
									},

									isInstanceStatusReasonsMoreInfo: {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "Link to documentation about this status reason",
									},
								},
							},
						},

						"resource_group": {
							Type:        schema.TypeString,
							Computed:    true,
							Description: "Instance resource group",
						},
						"vpc": {
							Type:        schema.TypeString,
							Computed:    true,
							Description: "vpc attached to the instance",
						},

						isInstanceCatalogOffering: {
							Type:        schema.TypeList,
							Computed:    true,
							Description: "The catalog offering or offering version to use when provisioning this virtual server instance. If an offering is specified, the latest version of that offering will be used. The specified offering or offering version may be in a different account in the same enterprise, subject to IAM policies.",
							Elem: &schema.Resource{
								Schema: map[string]*schema.Schema{
									isInstanceCatalogOfferingOfferingCrn: {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "Identifies a catalog offering by a unique CRN property",
									},
									isInstanceCatalogOfferingVersionCrn: {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "Identifies a version of a catalog offering by a unique CRN property",
									},
								},
							},
						},
						isInstanceTags: {
							Type:        schema.TypeSet,
							Computed:    true,
							Elem:        &schema.Schema{Type: schema.TypeString},
							Set:         flex.ResourceIBMVPCHash,
							Description: "list of tags for the instance",
						},

						isInstanceAccessTags: {
							Type:        schema.TypeSet,
							Computed:    true,
							Elem:        &schema.Schema{Type: schema.TypeString},
							Set:         flex.ResourceIBMVPCHash,
							Description: "list of access tags for the instance",
						},
						"boot_volume": {
							Type:        schema.TypeList,
							Computed:    true,
							Description: "Instance Boot Volume",
							Elem: &schema.Resource{
								Schema: map[string]*schema.Schema{
									"id": {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "Instance Boot volume id",
									},
									"name": {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "Instance Boot volume name",
									},
									"device": {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "Instance Boot volume device",
									},
									"volume_id": {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "Instance Boot volume's volume id",
									},
									"volume_crn": {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "Instance Boot volume's volume CRN",
									},
								},
							},
						},

						"volume_attachments": {
							Type:        schema.TypeList,
							Computed:    true,
							Description: "Instance Volume Attachments",
							Elem: &schema.Resource{
								Schema: map[string]*schema.Schema{
									"id": {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "Instance volume Attachment id",
									},
									"name": {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "Instance volume Attachment name",
									},
									"volume_id": {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "Instance volume Attachment's volume id",
									},
									"volume_name": {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "Instance volume Attachment's volume name",
									},
									"volume_crn": {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "Instance volume Attachment's volume CRN",
									},
								},
							},
						},

						"primary_network_interface": {
							Type:        schema.TypeList,
							Computed:    true,
							Description: "Instance Primary Network Interface",
							Elem: &schema.Resource{
								Schema: map[string]*schema.Schema{
									"id": {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "Instance Primary Network interface id",
									},
									isInstanceNicName: {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "Instance Primary Network interface name",
									},
									isInstanceNicPrimaryIpv4Address: {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "Instance Primary Network interface IPV4 Address",
									},
									isInstanceNicPrimaryIP: {
										Type:        schema.TypeList,
										Computed:    true,
										Description: "The primary IP address to bind to the network interface. This can be specified using an existing reserved IP, or a prototype object for a new reserved IP.",
										Elem: &schema.Resource{
											Schema: map[string]*schema.Schema{
												isInstanceNicReservedIpAddress: {
													Type:        schema.TypeString,
													Computed:    true,
													Description: "The IP address to reserve, which must not already be reserved on the subnet.",
												},
												isInstanceNicReservedIpHref: {
													Type:        schema.TypeString,
													Computed:    true,
													Description: "The URL for this reserved IP",
												},
												isInstanceNicReservedIpName: {
													Type:        schema.TypeString,
													Computed:    true,
													Description: "The user-defined name for this reserved IP. If unspecified, the name will be a hyphenated list of randomly-selected words. Names must be unique within the subnet the reserved IP resides in. ",
												},
												isInstanceNicReservedIpId: {
													Type:        schema.TypeString,
													Computed:    true,
													Description: "Identifies a reserved IP by a unique property.",
												},
												isInstanceNicReservedIpResourceType: {
													Type:        schema.TypeString,
													Computed:    true,
													Description: "The resource type",
												},
											},
										},
									},
									isInstanceNicSecurityGroups: {
										Type:        schema.TypeSet,
										Computed:    true,
										Elem:        &schema.Schema{Type: schema.TypeString},
										Set:         schema.HashString,
										Description: "Instance Primary Network interface security groups",
									},
									isInstanceNicSubnet: {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "Instance Primary Network interface subnet",
									},
								},
							},
						},
						"placement_target": {
							Type:        schema.TypeList,
							Computed:    true,
							Description: "The placement restrictions for the virtual server instance.",
							Elem: &schema.Resource{
								Schema: map[string]*schema.Schema{
									"crn": {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "The CRN for this placement target resource.",
									},
									"deleted": {
										Type:        schema.TypeList,
										Computed:    true,
										Description: "If present, this property indicates the referenced resource has been deleted and providessome supplementary information.",
										Elem: &schema.Resource{
											Schema: map[string]*schema.Schema{
												"more_info": {
													Type:        schema.TypeString,
													Computed:    true,
													Description: "Link to documentation about deleted resources.",
												},
											},
										},
									},
									"href": {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "The URL for this placement target resource.",
									},
									"id": {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "The unique identifier for this placement target resource.",
									},
									"name": {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "The unique user-defined name for this placement target resource. If unspecified, the name will be a hyphenated list of randomly-selected words.",
									},
									"resource_type": {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "The type of resource referenced.",
									},
								},
							},
						},
						"network_interfaces": {
							Type:        schema.TypeList,
							Computed:    true,
							Description: "Instance Network Interfaces",
							Elem: &schema.Resource{
								Schema: map[string]*schema.Schema{
									"id": {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "Instance Network interface id",
									},
									isInstanceNicName: {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "Instance Network interface name",
									},
									isInstanceNicPrimaryIpv4Address: {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "Instance Network interface IPV4 Address",
									},
									isInstanceNicPrimaryIP: {
										Type:        schema.TypeList,
										Computed:    true,
										Description: "The primary IP address to bind to the network interface. This can be specified using an existing reserved IP, or a prototype object for a new reserved IP.",
										Elem: &schema.Resource{
											Schema: map[string]*schema.Schema{
												isInstanceNicReservedIpAddress: {
													Type:        schema.TypeString,
													Computed:    true,
													Description: "The IP address to reserve, which must not already be reserved on the subnet.",
												},
												isInstanceNicReservedIpHref: {
													Type:        schema.TypeString,
													Computed:    true,
													Description: "The URL for this reserved IP",
												},
												isInstanceNicReservedIpName: {
													Type:        schema.TypeString,
													Computed:    true,
													Description: "The user-defined name for this reserved IP. If unspecified, the name will be a hyphenated list of randomly-selected words. Names must be unique within the subnet the reserved IP resides in. ",
												},
												isInstanceNicReservedIpId: {
													Type:        schema.TypeString,
													Computed:    true,
													Description: "Identifies a reserved IP by a unique property.",
												},
												isInstanceNicReservedIpResourceType: {
													Type:        schema.TypeString,
													Computed:    true,
													Description: "The resource type",
												},
											},
										},
									},
									isInstanceNicSecurityGroups: {
										Type:        schema.TypeSet,
										Computed:    true,
										Elem:        &schema.Schema{Type: schema.TypeString},
										Set:         schema.HashString,
										Description: "Instance Network interface security groups",
									},
									isInstanceNicSubnet: {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "Instance Network interface subnet",
									},
								},
							},
						},
						"profile": {
							Type:        schema.TypeString,
							Computed:    true,
							Description: "Instance Profile",
						},
						isInstanceTotalVolumeBandwidth: {
							Type:        schema.TypeInt,
							Computed:    true,
							Description: "The amount of bandwidth (in megabits per second) allocated exclusively to instance storage volumes",
						},

						isInstanceBandwidth: {
							Type:        schema.TypeInt,
							Computed:    true,
							Description: "The total bandwidth (in megabits per second) shared across the instance's network interfaces and storage volumes",
						},

						isInstanceTotalNetworkBandwidth: {
							Type:        schema.TypeInt,
							Computed:    true,
							Description: "The amount of bandwidth (in megabits per second) allocated exclusively to instance network interfaces.",
						},
						"vcpu": {
							Type:        schema.TypeList,
							Computed:    true,
							Description: "Instance vcpu",
							Elem: &schema.Resource{
								Schema: map[string]*schema.Schema{
									"architecture": {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "Instance vcpu architecture",
									},
									"count": {
										Type:        schema.TypeInt,
										Computed:    true,
										Description: "Instance vcpu count",
									},
									"manufacturer": {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "Instance vcpu manufacturer",
									},
								},
							},
						},
						"zone": {
							Type:        schema.TypeString,
							Computed:    true,
							Description: "Instance zone",
						},
						"image": {
							Type:        schema.TypeString,
							Optional:    true,
							Computed:    true,
							Description: "Instance Image",
						},

						isInstanceGpu: {
							Type:        schema.TypeList,
							Computed:    true,
							Description: "Instance GPU",
							Elem: &schema.Resource{
								Schema: map[string]*schema.Schema{
									isInstanceGpuCount: {
										Type:        schema.TypeInt,
										Computed:    true,
										Description: "Instance GPU Count",
									},
									isInstanceGpuMemory: {
										Type:        schema.TypeInt,
										Computed:    true,
										Description: "Instance GPU Memory",
									},
									isInstanceGpuManufacturer: {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "Instance GPU Manufacturer",
									},
									isInstanceGpuModel: {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "Instance GPU Model",
									},
								},
							},
						},

						isInstanceDisks: {
							Type:        schema.TypeList,
							Computed:    true,
							Description: "Collection of the instance's disks.",
							Elem: &schema.Resource{
								Schema: map[string]*schema.Schema{
									"created_at": {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "The date and time that the disk was created.",
									},
									"href": {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "The URL for this instance disk.",
									},
									"id": {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "The unique identifier for this instance disk.",
									},
									"interface_type": {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "The disk interface used for attaching the disk.The enumerated values for this property are expected to expand in the future. When processing this property, check for and log unknown values. Optionally halt processing and surface the error, or bypass the resource on which the unexpected property value was encountered.",
									},
									"name": {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "The user-defined name for this disk.",
									},
									"resource_type": {
										Type:        schema.TypeString,
										Computed:    true,
										Description: "The resource type.",
									},
									"size": {
										Type:        schema.TypeInt,
										Computed:    true,
										Description: "The size of the disk in GB (gigabytes).",
									},
								},
							},
						},
					},
				},
			},
		},
	}
}

func dataSourceIBMISInstancesRead(d *schema.ResourceData, meta interface{}) error {

	err := instancesList(d, meta)
	if err != nil {
		return err
	}
	return nil
}

func instancesList(d *schema.ResourceData, meta interface{}) error {
	sess, err := vpcClient(meta)
	if err != nil {
		return err
	}

	var vpcName, vpcID, vpcCrn, resourceGroup, insGrp, dHostNameStr, dHostIdStr, placementGrpNameStr, placementGrpIdStr string

	if vpc, ok := d.GetOk("vpc_name"); ok {
		vpcName = vpc.(string)
	}

	if vpc, ok := d.GetOk("vpc"); ok {
		vpcID = vpc.(string)
	}

	if vpccrn, ok := d.GetOk("vpc_crn"); ok {
		vpcCrn = vpccrn.(string)
	}

	if rg, ok := d.GetOk("resource_group"); ok {
		resourceGroup = rg.(string)
	}

	if dHostNameIntf, ok := d.GetOk("dedicated_host_name"); ok {
		dHostNameStr = dHostNameIntf.(string)
	}

	if dHostIdIntf, ok := d.GetOk("dedicated_host"); ok {
		dHostIdStr = dHostIdIntf.(string)
	}

	if placementGrpNameIntf, ok := d.GetOk("placement_group_name"); ok {
		placementGrpNameStr = placementGrpNameIntf.(string)
	}

	if placementGrpIdIntf, ok := d.GetOk("placement_group"); ok {
		placementGrpIdStr = placementGrpIdIntf.(string)
	}

	if insGrpInf, ok := d.GetOk(isInstanceGroup); ok {
		insGrp = insGrpInf.(string)
	} else if insGrpNameInf, ok := d.GetOk(isInstanceGroupName); ok {
		insGrpName := insGrpNameInf.(string)
		start := ""
		allrecs := []vpcv1.InstanceGroup{}
		for {
			listInstanceGroupOptions := vpcv1.ListInstanceGroupsOptions{}
			if start != "" {
				listInstanceGroupOptions.Start = &start
			}
			instanceGroupsCollection, response, err := sess.ListInstanceGroups(&listInstanceGroupOptions)
			if err != nil {
				return fmt.Errorf("[ERROR] Error Fetching InstanceGroups %s\n%s", err, response)
			}
			start = flex.GetNext(instanceGroupsCollection.Next)
			allrecs = append(allrecs, instanceGroupsCollection.InstanceGroups...)

			if start == "" {
				break
			}

		}

		for _, instanceGroup := range allrecs {
			if *instanceGroup.Name == insGrpName {
				insGrp = *instanceGroup.ID
				break
			}
		}
	}

	listInstancesOptions := &vpcv1.ListInstancesOptions{}

	if vpcName != "" {
		listInstancesOptions.VPCName = &vpcName
	}
	if vpcID != "" {
		listInstancesOptions.VPCID = &vpcID
	}
	if resourceGroup != "" {
		listInstancesOptions.ResourceGroupID = &resourceGroup
	}
	if vpcCrn != "" {
		listInstancesOptions.VPCCRN = &vpcCrn
	}

	if dHostNameStr != "" {
		listInstancesOptions.DedicatedHostName = &dHostNameStr
	}

	if dHostIdStr != "" {
		listInstancesOptions.DedicatedHostID = &dHostIdStr
	}

	if placementGrpNameStr != "" {
		listInstancesOptions.PlacementGroupName = &placementGrpNameStr
	}

	if placementGrpIdStr != "" {
		listInstancesOptions.PlacementGroupID = &placementGrpIdStr
	}

	start := ""
	allrecs := []vpcv1.Instance{}
	for {

		if start != "" {
			listInstancesOptions.Start = &start
		}

		instances, response, err := sess.ListInstances(listInstancesOptions)
		if err != nil {
			return fmt.Errorf("[ERROR] Error Fetching Instances %s\n%s", err, response)
		}
		start = flex.GetNext(instances.Next)
		allrecs = append(allrecs, instances.Instances...)
		if start == "" {
			break
		}
	}

	if insGrp != "" {
		membershipMap := map[string]bool{}
		start := ""
		for {
			listInstanceGroupMembershipsOptions := vpcv1.ListInstanceGroupMembershipsOptions{
				InstanceGroupID: &insGrp,
			}
			if start != "" {
				listInstanceGroupMembershipsOptions.Start = &start
			}
			instanceGroupMembershipCollection, response, err := sess.ListInstanceGroupMemberships(&listInstanceGroupMembershipsOptions)
			if err != nil {
				return fmt.Errorf("[ERROR] Error Getting InstanceGroup Membership Collection %s\n%s", err, response)
			}

			start = flex.GetNext(instanceGroupMembershipCollection.Next)
			for _, membershipItem := range instanceGroupMembershipCollection.Memberships {
				membershipMap[*membershipItem.Instance.ID] = true
			}

			if start == "" {
				break
			}

		}

		//Filtering instance allrecs to contain instance group members only
		i := 0
		for _, ins := range allrecs {
			if membershipMap[*ins.ID] {
				allrecs[i] = ins
				i++
			}
		}
		allrecs = allrecs[:i]
	}

	instancesInfo := make([]map[string]interface{}, 0)
	for _, instance := range allrecs {
		id := *instance.ID
		l := map[string]interface{}{}
		l["id"] = id
		l["crn"] = *instance.CRN
		l["name"] = *instance.Name
		l["memory"] = *instance.Memory
		if instance.NumaCount != nil {
			l["numa_count"] = *instance.NumaCount
		}
		if instance.MetadataService != nil {
			l[isInstanceMetadataServiceEnabled] = *instance.MetadataService.Enabled
			metadataService := []map[string]interface{}{}
			metadataServiceMap := map[string]interface{}{}

			metadataServiceMap[isInstanceMetadataServiceEnabled1] = instance.MetadataService.Enabled
			if instance.MetadataService.Protocol != nil {
				metadataServiceMap[isInstanceMetadataServiceProtocol] = instance.MetadataService.Protocol
			}
			if instance.MetadataService.ResponseHopLimit != nil {
				metadataServiceMap[isInstanceMetadataServiceRespHopLimit] = instance.MetadataService.ResponseHopLimit
			}
			metadataService = append(metadataService, metadataServiceMap)
			l[isInstanceMetadataService] = metadataService
		}
		l["status"] = *instance.Status
		l["resource_group"] = *instance.ResourceGroup.ID
		l["vpc"] = *instance.VPC.ID

		if instance.AvailabilityPolicy != nil && instance.AvailabilityPolicy.HostFailure != nil {
			l[isInstanceAvailablePolicyHostFailure] = *instance.AvailabilityPolicy.HostFailure
		}

		if instance.PlacementTarget != nil {
			placementTargetMap := resourceIbmIsInstanceInstancePlacementToMap(*instance.PlacementTarget.(*vpcv1.InstancePlacementTarget))
			l["placement_target"] = []map[string]interface{}{placementTargetMap}
		}
		if instance.Bandwidth != nil {
			l[isInstanceBandwidth] = int(*instance.Bandwidth)
		}

		if instance.TotalNetworkBandwidth != nil {
			l[isInstanceTotalNetworkBandwidth] = int(*instance.TotalNetworkBandwidth)
		}

		if instance.TotalVolumeBandwidth != nil {
			l[isInstanceTotalVolumeBandwidth] = int(*instance.TotalVolumeBandwidth)
		}

		// catalog
		if instance.CatalogOffering != nil {
			versionCrn := *instance.CatalogOffering.Version.CRN
			catalogList := make([]map[string]interface{}, 0)
			catalogMap := map[string]interface{}{}
			catalogMap[isInstanceCatalogOfferingVersionCrn] = versionCrn
			catalogList = append(catalogList, catalogMap)
			l[isInstanceCatalogOffering] = catalogList
		}

		if instance.BootVolumeAttachment != nil {
			bootVolList := make([]map[string]interface{}, 0)
			bootVol := map[string]interface{}{}
			bootVol["id"] = *instance.BootVolumeAttachment.ID
			bootVol["name"] = *instance.BootVolumeAttachment.Name
			if instance.BootVolumeAttachment.Device != nil {
				bootVol["device"] = *instance.BootVolumeAttachment.Device.ID
			}
			if instance.BootVolumeAttachment.Volume != nil {
				bootVol["volume_id"] = *instance.BootVolumeAttachment.Volume.ID
				bootVol["volume_crn"] = *instance.BootVolumeAttachment.Volume.CRN
			}
			bootVolList = append(bootVolList, bootVol)
			l["boot_volume"] = bootVolList
		}
		tags, err := flex.GetGlobalTagsUsingCRN(meta, *instance.CRN, "", isInstanceUserTagType)
		if err != nil {
			log.Printf(
				"Error on get of resource vpc Instance (%s) tags: %s", d.Id(), err)
		}
		l[isInstanceTags] = tags

		accesstags, err := flex.GetGlobalTagsUsingCRN(meta, *instance.CRN, "", isInstanceAccessTagType)
		if err != nil {
			log.Printf(
				"Error on get of resource vpc Instance (%s) access tags: %s", d.Id(), err)
		}
		l[isInstanceAccessTags] = accesstags
		//set the status reasons
		statusReasonsList := make([]map[string]interface{}, 0)
		if instance.StatusReasons != nil {
			for _, sr := range instance.StatusReasons {
				currentSR := map[string]interface{}{}
				if sr.Code != nil && sr.Message != nil {
					currentSR[isInstanceStatusReasonsCode] = *sr.Code
					currentSR[isInstanceStatusReasonsMessage] = *sr.Message
					if sr.MoreInfo != nil {
						currentSR[isInstanceStatusReasonsMoreInfo] = *sr.MoreInfo
					}
					statusReasonsList = append(statusReasonsList, currentSR)
				}
			}
		}
		l[isInstanceStatusReasons] = statusReasonsList

		if instance.VolumeAttachments != nil {
			volList := make([]map[string]interface{}, 0)
			for _, volume := range instance.VolumeAttachments {
				vol := map[string]interface{}{}
				if volume.Volume != nil {
					vol["id"] = *volume.ID
					vol["volume_id"] = *volume.Volume.ID
					vol["name"] = *volume.Name
					vol["volume_name"] = *volume.Volume.Name
					vol["volume_crn"] = *volume.Volume.CRN
					volList = append(volList, vol)
				}
			}
			l["volume_attachments"] = volList
		}

		if instance.PrimaryNetworkInterface != nil {
			primaryNicList := make([]map[string]interface{}, 0)
			currentPrimNic := map[string]interface{}{}
			currentPrimNic["id"] = *instance.PrimaryNetworkInterface.ID
			currentPrimNic[isInstanceNicName] = *instance.PrimaryNetworkInterface.Name

			// reserved ip changes
			primaryIpList := make([]map[string]interface{}, 0)
			currentPrimIp := map[string]interface{}{}

			if instance.PrimaryNetworkInterface.PrimaryIP.Address != nil {
				currentPrimNic[isInstanceNicPrimaryIpv4Address] = *instance.PrimaryNetworkInterface.PrimaryIP.Address
				currentPrimIp[isInstanceNicReservedIpAddress] = *instance.PrimaryNetworkInterface.PrimaryIP.Address
			}
			if instance.PrimaryNetworkInterface.PrimaryIP.Href != nil {
				currentPrimIp[isInstanceNicReservedIpHref] = *instance.PrimaryNetworkInterface.PrimaryIP.Href
			}
			if instance.PrimaryNetworkInterface.PrimaryIP.Name != nil {
				currentPrimIp[isInstanceNicReservedIpName] = *instance.PrimaryNetworkInterface.PrimaryIP.Name
			}
			if instance.PrimaryNetworkInterface.PrimaryIP.ID != nil {
				currentPrimIp[isInstanceNicReservedIpId] = *instance.PrimaryNetworkInterface.PrimaryIP.ID
			}
			if instance.PrimaryNetworkInterface.PrimaryIP.ResourceType != nil {
				currentPrimIp[isInstanceNicReservedIpResourceType] = *instance.PrimaryNetworkInterface.PrimaryIP.ResourceType
			}
			primaryIpList = append(primaryIpList, currentPrimIp)
			currentPrimNic[isInstanceNicPrimaryIP] = primaryIpList

			getnicoptions := &vpcv1.GetInstanceNetworkInterfaceOptions{
				InstanceID: &id,
				ID:         instance.PrimaryNetworkInterface.ID,
			}
			insnic, response, err := sess.GetInstanceNetworkInterface(getnicoptions)
			if err != nil {
				return fmt.Errorf("[ERROR] Error getting network interfaces attached to the instance %s\n%s", err, response)
			}
			currentPrimNic[isInstanceNicSubnet] = *insnic.Subnet.ID
			if len(insnic.SecurityGroups) != 0 {
				secgrpList := []string{}
				for i := 0; i < len(insnic.SecurityGroups); i++ {
					secgrpList = append(secgrpList, string(*(insnic.SecurityGroups[i].ID)))
				}
				currentPrimNic[isInstanceNicSecurityGroups] = flex.NewStringSet(schema.HashString, secgrpList)
			}

			primaryNicList = append(primaryNicList, currentPrimNic)
			l["primary_network_interface"] = primaryNicList
		}

		if instance.NetworkInterfaces != nil {
			interfacesList := make([]map[string]interface{}, 0)
			for _, intfc := range instance.NetworkInterfaces {
				if *intfc.ID != *instance.PrimaryNetworkInterface.ID {
					currentNic := map[string]interface{}{}
					currentNic["id"] = *intfc.ID
					currentNic[isInstanceNicName] = *intfc.Name

					// reserved ip changes
					primaryIpList := make([]map[string]interface{}, 0)
					currentPrimIp := map[string]interface{}{}
					if intfc.PrimaryIP.Address != nil {
						currentPrimIp[isInstanceNicReservedIpAddress] = *intfc.PrimaryIP.Address
						currentNic[isInstanceNicPrimaryIpv4Address] = *intfc.PrimaryIP.Address
					}
					if intfc.PrimaryIP.Href != nil {
						currentPrimIp[isInstanceNicReservedIpHref] = *intfc.PrimaryIP.Href
					}
					if intfc.PrimaryIP.Name != nil {
						currentPrimIp[isInstanceNicReservedIpName] = *intfc.PrimaryIP.Name
					}
					if intfc.PrimaryIP.ID != nil {
						currentPrimIp[isInstanceNicReservedIpId] = *intfc.PrimaryIP.ID
					}
					if intfc.PrimaryIP.ResourceType != nil {
						currentPrimIp[isInstanceNicReservedIpResourceType] = *intfc.PrimaryIP.ResourceType
					}
					primaryIpList = append(primaryIpList, currentPrimIp)
					currentNic[isInstanceNicPrimaryIP] = primaryIpList

					getnicoptions := &vpcv1.GetInstanceNetworkInterfaceOptions{
						InstanceID: &id,
						ID:         intfc.ID,
					}
					insnic, response, err := sess.GetInstanceNetworkInterface(getnicoptions)
					if err != nil {
						return fmt.Errorf("[ERROR] Error getting network interfaces attached to the instance %s\n%s", err, response)
					}
					currentNic[isInstanceNicSubnet] = *insnic.Subnet.ID
					if len(insnic.SecurityGroups) != 0 {
						secgrpList := []string{}
						for i := 0; i < len(insnic.SecurityGroups); i++ {
							secgrpList = append(secgrpList, string(*(insnic.SecurityGroups[i].ID)))
						}
						currentNic[isInstanceNicSecurityGroups] = flex.NewStringSet(schema.HashString, secgrpList)
					}
					interfacesList = append(interfacesList, currentNic)
				}
			}
			l["network_interfaces"] = interfacesList
		}

		l["profile"] = *instance.Profile.Name

		cpuList := make([]map[string]interface{}, 0)
		if instance.Vcpu != nil {
			currentCPU := map[string]interface{}{}
			currentCPU["architecture"] = *instance.Vcpu.Architecture
			currentCPU["count"] = *instance.Vcpu.Count
			currentCPU["manufacturer"] = *instance.Vcpu.Manufacturer
			cpuList = append(cpuList, currentCPU)
		}
		l["vcpu"] = cpuList

		gpuList := make([]map[string]interface{}, 0)
		if instance.Gpu != nil {
			currentGpu := map[string]interface{}{}
			currentGpu[isInstanceGpuManufacturer] = instance.Gpu.Manufacturer
			currentGpu[isInstanceGpuModel] = instance.Gpu.Model
			currentGpu[isInstanceGpuCount] = instance.Gpu.Count
			currentGpu[isInstanceGpuMemory] = instance.Gpu.Memory
			gpuList = append(gpuList, currentGpu)
			l[isInstanceGpu] = gpuList
		}

		//set the lifecycle status, reasons
		if instance.LifecycleState != nil {
			l[isInstanceLifecycleState] = *instance.LifecycleState
		}
		if instance.LifecycleReasons != nil {
			l[isInstanceLifecycleReasons] = dataSourceInstanceFlattenLifecycleReasons(instance.LifecycleReasons)
		}

		l["zone"] = *instance.Zone.Name
		if instance.Image != nil {
			l["image"] = *instance.Image.ID
		}

		if instance.Disks != nil {
			l[isInstanceDisks] = dataSourceInstanceFlattenDisks(instance.Disks)
		}

		instancesInfo = append(instancesInfo, l)
	}
	d.SetId(dataSourceIBMISInstancesID(d))
	d.Set(isInstances, instancesInfo)
	return nil
}

// dataSourceIBMISInstancesID returns a reasonable ID for a Instance list.
func dataSourceIBMISInstancesID(d *schema.ResourceData) string {
	return time.Now().UTC().String()
}