vcfa_edge_cluster + vcfa_edge_cluster_qos

.changes/v1.0.0/11-features.md

@@ -0,0 +1,3 @@
+* **New Data Source:** `vcfa_edge_cluster` to read and sync Edge Clusters [GH-11]
+* **New Resource:** `vcfa_edge_cluster_qos` to manage QoS settings for Edge Clusters [GH-11]
+* **New Data Source:** `vcfa_edge_cluster_qos` to read QoS settings for Edge Clusters [GH-11]

.changes/v1.0.0/5-features.md

@@ -1,4 +1,4 @@
-- **New Resource:** `vcfa_region` to manage Regions [GH-5]
+- **New Resource:** `vcfa_region` to manage Regions [GH-5, GH-11]
 - **New Data Source:** `vcfa_region` to read Regions [GH-5]
 - **New Data Source:** `vcfa_supervisor` to read Supervisors [GH-5]
 - **New Data Source:** `vcfa_supervisor_zone` to read Supervisor Zones [GH-5]

vcfa/datasource_not_found_test.go

@@ -148,6 +148,8 @@ func addMandatoryParams(dataSourceName string, mandatoryFields []string, t *test
 			templateFields = templateFields + `region_id = "urn:vcloud:region:12345678-1234-1234-1234-123456789012"` + "\n"
 		case "org_id":
 			templateFields = templateFields + `org_id = "urn:vcloud:org:12345678-1234-1234-1234-123456789012"` + "\n"
+		case "edge_cluster_id":
+			templateFields = templateFields + `edge_cluster_id = "urn:vcloud:edgeCluster:12345678-1234-1234-1234-123456789012"` + "\n"
 		}
 	}
 

vcfa/datasource_vcfa_edge_cluster.go

@@ -0,0 +1,129 @@
+package vcfa
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"github.com/vmware/go-vcloud-director/v3/govcd"
+	"github.com/vmware/go-vcloud-director/v3/types/v56"
+)
+
+const labelVcfaEdgeCluster = "Edge Cluster"
+const labelVcfaEdgeClusterSync = "Edge Cluster Sync"
+
+func datasourceVcfaEdgeCluster() *schema.Resource {
+	return &schema.Resource{
+		ReadContext: datasourceVcfaEdgeClusterRead,
+
+		Schema: map[string]*schema.Schema{
+			"name": {
+				Type:        schema.TypeString,
+				Required:    true,
+				Description: fmt.Sprintf("Name %s", labelVcfaEdgeCluster),
+			},
+			"region_id": {
+				Type:        schema.TypeString,
+				Required:    true,
+				Description: fmt.Sprintf("Region ID of  %s", labelVcfaEdgeCluster),
+			},
+			"sync_before_read": {
+				Type:        schema.TypeBool,
+				Optional:    true,
+				Default:     false,
+				Description: fmt.Sprintf("Will trigger SYNC operation before looking for a given %s", labelVcfaEdgeCluster),
+			},
+			"node_count": {
+				Type:        schema.TypeInt,
+				Computed:    true,
+				Description: fmt.Sprintf("Node count in %s", labelVcfaEdgeCluster),
+			},
+			"org_count": {
+				Type:        schema.TypeInt,
+				Computed:    true,
+				Description: fmt.Sprintf("Org count %s", labelVcfaEdgeCluster),
+			},
+			"vpc_count": {
+				Type:        schema.TypeInt,
+				Computed:    true,
+				Description: fmt.Sprintf("VPC count %s", labelVcfaEdgeCluster),
+			},
+			"average_cpu_usage_percentage": {
+				Type:        schema.TypeFloat,
+				Computed:    true,
+				Description: fmt.Sprintf("Average CPU Usage percentage of %s ", labelVcfaEdgeCluster),
+			},
+			"average_memory_usage_percentage": {
+				Type:        schema.TypeFloat,
+				Computed:    true,
+				Description: fmt.Sprintf("Average Memory Usage percentage of %s ", labelVcfaEdgeCluster),
+			},
+			"health_status": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: fmt.Sprintf("Health status of %s", labelVcfaEdgeCluster),
+			},
+			"status": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: fmt.Sprintf("Status of %s", labelVcfaEdgeCluster),
+			},
+			"deployment_type": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: fmt.Sprintf("Deployment type of %s", labelVcfaEdgeCluster),
+			},
+		},
+	}
+}
+
+func datasourceVcfaEdgeClusterRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	vcdClient := meta.(*VCDClient)
+
+	regionId := d.Get("region_id").(string)
+	getByName := func(name string) (*govcd.TmEdgeCluster, error) {
+		return vcdClient.GetTmEdgeClusterByNameAndRegionId(name, regionId)
+	}
+
+	c := dsReadConfig[*govcd.TmEdgeCluster, types.TmEdgeCluster]{
+		entityLabel:    labelVcfaEdgeCluster,
+		getEntityFunc:  getByName,
+		stateStoreFunc: setTmEdgeClusterData,
+		preReadHooks:   []schemaHook{syncTmEdgeClustersBeforeReadHook},
+	}
+	return readDatasource(ctx, d, meta, c)
+}
+
+func setTmEdgeClusterData(_ *VCDClient, d *schema.ResourceData, t *govcd.TmEdgeCluster) error {
+	if t == nil || t.TmEdgeCluster == nil {
+		return fmt.Errorf("empty %s received", labelVcfaEdgeCluster)
+	}
+
+	d.SetId(t.TmEdgeCluster.ID)
+	dSet(d, "status", t.TmEdgeCluster.Status)
+	dSet(d, "health_status", t.TmEdgeCluster.HealthStatus)
+
+	dSet(d, "region_id", "")
+	if t.TmEdgeCluster.RegionRef != nil {
+		dSet(d, "region_id", t.TmEdgeCluster.RegionRef.ID)
+	}
+	dSet(d, "deployment_type", t.TmEdgeCluster.DeploymentType)
+	dSet(d, "node_count", t.TmEdgeCluster.NodeCount)
+	dSet(d, "org_count", t.TmEdgeCluster.OrgCount)
+	dSet(d, "vpc_count", t.TmEdgeCluster.VpcCount)
+	dSet(d, "average_cpu_usage_percentage", t.TmEdgeCluster.AvgCPUUsagePercentage)
+	dSet(d, "average_memory_usage_percentage", t.TmEdgeCluster.AvgMemoryUsagePercentage)
+
+	return nil
+}
+
+func syncTmEdgeClustersBeforeReadHook(vcdClient *VCDClient, d *schema.ResourceData) error {
+	if d.Get("sync_before_read").(bool) {
+		err := vcdClient.TmSyncEdgeClusters()
+		if err != nil {
+			return fmt.Errorf("error syncing %s before lookup: %s", labelVcfaEdgeClusterSync, err)
+		}
+	}
+	return nil
+}

vcfa/datasource_vcfa_edge_cluster_qos.go

@@ -0,0 +1,62 @@
+package vcfa
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"github.com/vmware/go-vcloud-director/v3/govcd"
+	"github.com/vmware/go-vcloud-director/v3/types/v56"
+)
+
+func datasourceVcfaEdgeClusterQos() *schema.Resource {
+	return &schema.Resource{
+		ReadContext: datasourceVcfaEdgeClusterQosRead,
+
+		Schema: map[string]*schema.Schema{
+			"edge_cluster_id": {
+				Type:        schema.TypeString,
+				Required:    true,
+				ForceNew:    true,
+				Description: fmt.Sprintf("ID of %s", labelVcfaEdgeCluster),
+			},
+			"region_id": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: fmt.Sprintf("Region ID of  %s", labelVcfaEdgeCluster),
+			},
+			"ingress_committed_bandwidth_mbps": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: fmt.Sprintf("Ingress committed bandwidth in Mbps for %s", labelVcfaEdgeCluster),
+			},
+			"ingress_burst_size_bytes": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: fmt.Sprintf("Ingress burst size bytes for %s", labelVcfaEdgeCluster),
+			},
+			"egress_committed_bandwidth_mbps": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: fmt.Sprintf("Egress committed bandwidth in Mbps for %s", labelVcfaEdgeCluster),
+			},
+			"egress_burst_size_bytes": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: fmt.Sprintf("Egress burst size bytes for %s", labelVcfaEdgeCluster),
+			},
+		},
+	}
+}
+
+func datasourceVcfaEdgeClusterQosRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	vcdClient := meta.(*VCDClient)
+	c := dsReadConfig[*govcd.TmEdgeCluster, types.TmEdgeCluster]{
+		entityLabel:              labelVcfaEdgeClusterQos,
+		stateStoreFunc:           setTmEdgeClusterQosData,
+		overrideDefaultNameField: "edge_cluster_id", // pass the value of this field to getEntityFunc
+		getEntityFunc:            vcdClient.GetTmEdgeClusterById,
+	}
+	return readDatasource(ctx, d, meta, c)
+}

vcfa/provider.go

@@ -47,6 +47,8 @@ var globalDataSourceMap = map[string]*schema.Resource{
 	"vcfa_content_library":       datasourceVcfaContentLibrary(),      // 1.0
 	"vcfa_tier0_gateway":         datasourceVcfaTier0Gateway(),        // 1.0
 	"vcfa_provider_gateway":      datasourceVcfaProviderGateway(),     // 1.0
+	"vcfa_edge_cluster":          datasourceVcfaEdgeCluster(),         // 1.0
+	"vcfa_edge_cluster_qos":      datasourceVcfaEdgeClusterQos(),      // 1.0
 }
 
 var globalResourceMap = map[string]*schema.Resource{
@@ -58,6 +60,7 @@ var globalResourceMap = map[string]*schema.Resource{
 	"vcfa_org_vdc":          resourceVcfaOrgVdc(),          // 1.0
 	"vcfa_content_library":  resourceVcfaContentLibrary(),  // 1.0
 	"vcfa_provider_gateway": resourceVcfaProviderGateway(), // 1.0
+	"vcfa_edge_cluster_qos": resourceVcfaEdgeClusterQos(),  // 1.0
 }
 
 // Provider returns a terraform.ResourceProvider.

vcfa/remove_leftovers_test.go

@@ -50,6 +50,26 @@ func removeLeftovers(govcdClient *govcd.VCDClient, verbose bool) error {
 		fmt.Printf("Start leftovers removal\n")
 	}
 
+	// --------------------------------------------------------------
+	// Edge Cluster QoS (Edge Clusters themselves are read-only)
+	// --------------------------------------------------------------
+	if govcdClient.Client.IsSysAdmin {
+		allEcs, err := govcdClient.GetAllTmEdgeClusters(nil)
+		if err != nil {
+			return fmt.Errorf("error retrieving Edge Clusters: %s", err)
+		}
+		for _, ec := range allEcs {
+			toBeDeleted := shouldDeleteEntity(alsoDelete, doNotDelete, ec.TmEdgeCluster.Name, "vcfa_edge_cluster_qos", 2, verbose)
+			if toBeDeleted {
+				fmt.Printf("\t REMOVING Edge Cluster QoS Settings %s\n", ec.TmEdgeCluster.Name)
+				err := ec.Delete()
+				if err != nil {
+					return fmt.Errorf("error deleting %s '%s': %s", labelVcfaEdgeClusterQos, ec.TmEdgeCluster.Name, err)
+				}
+			}
+		}
+	}
+
 	// --------------------------------------------------------------
 	// Content Libraries
 	// --------------------------------------------------------------
@@ -198,6 +218,10 @@ func removeLeftovers(govcdClient *govcd.VCDClient, verbose bool) error {
 		}
 	}
 
+	if verbose {
+		fmt.Printf("End leftovers removal\n")
+	}
+
 	return nil
 }