Added - Support for Host API - Host visibility improvements

Author: AravindOracle

examples/compute/host_visibility/host_info.tf

@@ -0,0 +1,52 @@
+provider "oci" {
+  tenancy_ocid     = var.tenancy_ocid
+  user_ocid        = var.user_ocid
+  fingerprint      = var.fingerprint
+  private_key_path = var.private_key_path
+  region           = var.region
+}
+
+variable "tenancy_ocid" {
+}
+
+variable "user_ocid" {
+}
+
+variable "fingerprint" {
+}
+
+variable "private_key_path" {
+}
+
+variable "region" {
+}
+
+variable "compartment_ocid" {
+}
+
+data "oci_core_compute_hosts" "test_compute_hosts" {
+  compartment_id = "${var.compartment_ocid}"
+}
+
+locals {
+  core_compute_hosts_ids = [
+    for host in data.oci_core_compute_hosts.test_compute_hosts.compute_host_collection :
+    [ for item in host.items : item.id ]
+  ]
+}
+
+data "oci_core_compute_host" "test_compute_host" {
+  for_each = toset(flatten(local.core_compute_hosts_ids))
+
+  compute_host_id = each.key
+}
+
+output "compute_host_values" {
+  value = {
+    for key, value in data.oci_core_compute_host.test_compute_host :
+    key => {
+      name = value.display_name
+      fd = value.fault_domain
+    }
+  }
+}

internal/integrationtest/core_compute_host_test.go

@@ -0,0 +1,90 @@
+// Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved.
+// Licensed under the Mozilla Public License v2.0
+
+package integrationtest
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
+
+	"github.com/oracle/terraform-provider-oci/httpreplay"
+	"github.com/oracle/terraform-provider-oci/internal/acctest"
+
+	"github.com/oracle/terraform-provider-oci/internal/utils"
+)
+
+var (
+	CoreComputeHostSingularDataSourceRepresentation = map[string]interface{}{
+		"compute_host_id": acctest.Representation{RepType: acctest.Required, Create: `${var.baremetalhost_id}`},
+	}
+
+	CoreComputeHostDataSourceRepresentation = map[string]interface{}{
+		"compartment_id":               acctest.Representation{RepType: acctest.Required, Create: `${var.compartment_id}`},
+		"availability_domain":          acctest.Representation{RepType: acctest.Optional, Create: `${data.oci_identity_availability_domains.test_availability_domains.availability_domains.0.name}`},
+		"compute_host_health":          acctest.Representation{RepType: acctest.Optional, Create: `computeHostHealth`},
+		"compute_host_lifecycle_state": acctest.Representation{RepType: acctest.Optional, Create: `computeHostLifecycleState`},
+		"display_name":                 acctest.Representation{RepType: acctest.Optional, Create: `displayName`, Update: `displayName2`},
+		"network_resource_id":          acctest.Representation{RepType: acctest.Optional, Create: `${oci_cloud_guard_resource.test_resource.id}`},
+	}
+
+	CloudGuardResourceDataSourceRepresentation = map[string]interface{}{}
+
+	CoreComputeHostResourceConfig = acctest.GenerateDataSourceFromRepresentationMap("oci_cloud_guard_resources", "test_resources", acctest.Required, acctest.Create, CloudGuardResourceDataSourceRepresentation) +
+		AvailabilityDomainConfig
+)
+
+// issue-routing-tag: core/computeSharedOwnershipVmAndBm
+func TestCoreComputeHostResource_basic(t *testing.T) {
+	httpreplay.SetScenario("TestCoreComputeHostResource_basic")
+	defer httpreplay.SaveScenario()
+
+	config := acctest.ProviderTestConfig()
+
+	compartmentId := utils.GetEnvSettingWithBlankDefault("compartment_ocid")
+	compartmentIdVariableStr := fmt.Sprintf("variable \"compartment_id\" { default = \"%s\" }\n", compartmentId)
+
+	datasourceName := "data.oci_core_compute_hosts.test_compute_hosts"
+	singularDatasourceName := "data.oci_core_compute_host.test_compute_host"
+
+	acctest.SaveConfigContent("", "", "", t)
+
+	acctest.ResourceTest(t, nil, []resource.TestStep{
+		// verify datasource
+		{
+			Config: config +
+				acctest.GenerateDataSourceFromRepresentationMap("oci_core_compute_hosts", "test_compute_hosts", acctest.Required, acctest.Create, CoreComputeHostDataSourceRepresentation) +
+				compartmentIdVariableStr,
+			Check: acctest.ComposeAggregateTestCheckFuncWrapper(
+				resource.TestCheckResourceAttr(datasourceName, "compartment_id", compartmentId),
+				resource.TestCheckResourceAttrSet(datasourceName, "id"),
+				resource.TestCheckResourceAttrSet(datasourceName, "compute_host_collection.#"),
+			),
+		},
+		// verify singular datasource
+		{
+			Config: config +
+				acctest.GenerateDataSourceFromRepresentationMap("oci_core_compute_host", "test_compute_host", acctest.Required, acctest.Create, CoreComputeHostSingularDataSourceRepresentation) +
+				compartmentIdVariableStr,
+			Check: acctest.ComposeAggregateTestCheckFuncWrapper(
+				resource.TestCheckResourceAttrSet(singularDatasourceName, "compute_host_id"),
+				resource.TestCheckResourceAttrSet(singularDatasourceName, "availability_domain"),
+				resource.TestCheckResourceAttr(singularDatasourceName, "compartment_id", compartmentId),
+				resource.TestCheckResourceAttrSet(singularDatasourceName, "display_name"),
+				resource.TestCheckResourceAttrSet(singularDatasourceName, "fault_domain"),
+				resource.TestCheckResourceAttrSet(singularDatasourceName, "health"),
+				resource.TestCheckResourceAttrSet(singularDatasourceName, "hpc_island_id"),
+				resource.TestCheckResourceAttrSet(singularDatasourceName, "id"),
+				resource.TestCheckResourceAttrSet(singularDatasourceName, "instance_id"),
+				resource.TestCheckResourceAttrSet(singularDatasourceName, "local_block_id"),
+				resource.TestCheckResourceAttrSet(singularDatasourceName, "gpu_memory_fabric_id"),
+				resource.TestCheckResourceAttrSet(singularDatasourceName, "network_block_id"),
+				resource.TestCheckResourceAttrSet(singularDatasourceName, "shape"),
+				resource.TestCheckResourceAttrSet(singularDatasourceName, "state"),
+				resource.TestCheckResourceAttrSet(singularDatasourceName, "time_created"),
+				resource.TestCheckResourceAttrSet(singularDatasourceName, "time_updated"),
+			),
+		},
+	})
+}

internal/service/core/core_compute_host_data_source.go

@@ -0,0 +1,235 @@
+// Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved.
+// Licensed under the Mozilla Public License v2.0
+
+package core
+
+import (
+	"context"
+	"encoding/json"
+	"log"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	oci_core "github.com/oracle/oci-go-sdk/v65/core"
+
+	"github.com/oracle/terraform-provider-oci/internal/client"
+	"github.com/oracle/terraform-provider-oci/internal/tfresource"
+)
+
+func CoreComputeHostDataSource() *schema.Resource {
+	return &schema.Resource{
+		Read: readSingularCoreComputeHost,
+		Schema: map[string]*schema.Schema{
+			"compute_host_id": {
+				Type:     schema.TypeString,
+				Required: true,
+			},
+			// Computed
+			"additional_data": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"availability_domain": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"capacity_reservation_id": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"compartment_id": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"defined_tags": {
+				Type:     schema.TypeMap,
+				Computed: true,
+				Elem:     schema.TypeString,
+			},
+			"display_name": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"fault_domain": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"freeform_tags": {
+				Type:     schema.TypeMap,
+				Computed: true,
+				Elem:     schema.TypeString,
+			},
+			"health": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"hpc_island_id": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"impacted_component_details": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"instance_id": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"lifecycle_details": {
+				Type:     schema.TypeMap,
+				Computed: true,
+				Elem:     schema.TypeString,
+			},
+			"local_block_id": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"gpu_memory_fabric_id": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"network_block_id": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"shape": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"state": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"time_created": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"time_updated": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+		},
+	}
+}
+
+func readSingularCoreComputeHost(d *schema.ResourceData, m interface{}) error {
+	sync := &CoreComputeHostDataSourceCrud{}
+	sync.D = d
+	sync.Client = m.(*client.OracleClients).ComputeClient()
+
+	return tfresource.ReadResource(sync)
+}
+
+type CoreComputeHostDataSourceCrud struct {
+	D      *schema.ResourceData
+	Client *oci_core.ComputeClient
+	Res    *oci_core.GetComputeHostResponse
+}
+
+func (s *CoreComputeHostDataSourceCrud) VoidState() {
+	s.D.SetId("")
+}
+
+func (s *CoreComputeHostDataSourceCrud) Get() error {
+	request := oci_core.GetComputeHostRequest{}
+
+	if computeHostId, ok := s.D.GetOkExists("compute_host_id"); ok {
+		tmp := computeHostId.(string)
+		request.ComputeHostId = &tmp
+	}
+
+	request.RequestMetadata.RetryPolicy = tfresource.GetRetryPolicy(false, "core")
+
+	response, err := s.Client.GetComputeHost(context.Background(), request)
+	if err != nil {
+		return err
+	}
+
+	s.Res = &response
+	return nil
+}
+
+func (s *CoreComputeHostDataSourceCrud) SetData() error {
+	if s.Res == nil {
+		return nil
+	}
+
+	s.D.SetId(*s.Res.Id)
+
+	s.D.Set("additional_data", readData(s.Res.AdditionalData))
+
+	if s.Res.AvailabilityDomain != nil {
+		s.D.Set("availability_domain", *s.Res.AvailabilityDomain)
+	}
+
+	if s.Res.CapacityReservationId != nil {
+		s.D.Set("capacity_reservation_id", *s.Res.CapacityReservationId)
+	}
+
+	if s.Res.CompartmentId != nil {
+		s.D.Set("compartment_id", *s.Res.CompartmentId)
+	}
+
+	if s.Res.DefinedTags != nil {
+		s.D.Set("defined_tags", tfresource.DefinedTagsToMap(s.Res.DefinedTags))
+	}
+
+	if s.Res.DisplayName != nil {
+		s.D.Set("display_name", *s.Res.DisplayName)
+	}
+
+	if s.Res.FaultDomain != nil {
+		s.D.Set("fault_domain", *s.Res.FaultDomain)
+	}
+
+	s.D.Set("freeform_tags", s.Res.FreeformTags)
+
+	s.D.Set("health", s.Res.Health)
+
+	if s.Res.HpcIslandId != nil {
+		s.D.Set("hpc_island_id", *s.Res.HpcIslandId)
+	}
+
+	s.D.Set("impacted_component_details", readData(s.Res.ImpactedComponentDetails))
+
+	if s.Res.InstanceId != nil {
+		s.D.Set("instance_id", *s.Res.InstanceId)
+	}
+
+	s.D.Set("lifecycle_details", s.Res.LifecycleDetails)
+
+	if s.Res.LocalBlockId != nil {
+		s.D.Set("local_block_id", *s.Res.LocalBlockId)
+	}
+
+	if s.Res.GpuMemoryFabricId != nil {
+		s.D.Set("gpu_memory_fabric_id", *s.Res.GpuMemoryFabricId)
+	}
+
+	if s.Res.NetworkBlockId != nil {
+		s.D.Set("network_block_id", *s.Res.NetworkBlockId)
+	}
+
+	if s.Res.Shape != nil {
+		s.D.Set("shape", *s.Res.Shape)
+	}
+
+	s.D.Set("state", s.Res.LifecycleState)
+
+	if s.Res.TimeCreated != nil {
+		s.D.Set("time_created", s.Res.TimeCreated.String())
+	}
+
+	if s.Res.TimeUpdated != nil {
+		s.D.Set("time_updated", s.Res.TimeUpdated.String())
+	}
+
+	return nil
+}
+
+func readData(Data interface{}) string {
+	buf, err := json.Marshal(Data)
+	if err != nil {
+		log.Printf("error Marshalling Data: %v", err)
+	}
+	return string(buf)
+}