add cloudstack_cluster data source and documentation (#222)

Author: ianc769

cloudstack/data_source_cloudstack_cluster.go

@@ -0,0 +1,357 @@
+//
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+//
+
+package cloudstack
+
+import (
+	"fmt"
+	"log"
+	"reflect"
+	"regexp"
+	"strings"
+
+	"github.com/apache/cloudstack-go/v2/cloudstack"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+func dataSourceCloudstackCluster() *schema.Resource {
+	return &schema.Resource{
+		Read: datasourceCloudStackClusterRead,
+		Schema: map[string]*schema.Schema{
+			"filter": dataSourceFiltersSchema(),
+
+			//Computed values
+			"id": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"allocation_state": {
+				Description: "Allocation state of this cluster for allocation of new resources",
+				Type:        schema.TypeString,
+				Computed:    true,
+			},
+			"cluster_name": {
+				Description: "the cluster name",
+				Type:        schema.TypeString,
+				Computed:    true,
+			},
+			"name": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"cluster_type": {
+				Description: "Type of the cluster: CloudManaged, ExternalManaged",
+				Type:        schema.TypeString,
+				Computed:    true,
+			},
+			"guest_vswitch_name": {
+				Description: "Name of virtual switch used for guest traffic in the cluster. This would override zone wide traffic label setting.",
+				Type:        schema.TypeString,
+				Computed:    true,
+			},
+			"guest_vswitch_type": {
+				Description: "Type of virtual switch used for guest traffic in the cluster. Allowed values are, vmwaresvs (for VMware standard vSwitch) and vmwaredvs (for VMware distributed vSwitch)",
+				Type:        schema.TypeString,
+				Computed:    true,
+			},
+			"hypervisor": {
+				Description: "hypervisor type of the cluster: XenServer,KVM,VMware,Hyperv,BareMetal,Simulator,Ovm3",
+				Type:        schema.TypeString,
+				Computed:    true,
+			},
+			"ovm3_cluster": {
+				Description: "Ovm3 native OCFS2 clustering enabled for cluster",
+				Type:        schema.TypeString,
+				Computed:    true,
+			},
+			"ovm3_pool": {
+				Description: "Ovm3 native pooling enabled for cluster",
+				Type:        schema.TypeString,
+				Computed:    true,
+			},
+			"ovm3_vip": {
+				Description: "Ovm3 vip to use for pool (and cluster)",
+				Type:        schema.TypeString,
+				Computed:    true,
+			},
+			"ovm3vip": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"password": {
+				Description: "the password for the host",
+				Type:        schema.TypeString,
+				Computed:    true,
+				Sensitive:   true,
+			},
+			"public_vswitch_name": {
+				Description: "Name of virtual switch used for public traffic in the cluster. This would override zone wide traffic label setting.",
+				Type:        schema.TypeString,
+				Computed:    true,
+			},
+			"public_vswitch_type": {
+				Description: "Type of virtual switch used for public traffic in the cluster. Allowed values are, vmwaresvs (for VMware standard vSwitch) and vmwaredvs (for VMware distributed vSwitch)",
+				Type:        schema.TypeString,
+				Computed:    true,
+			},
+			"pod_id": {
+				Description: "The Pod ID for the cluster",
+				Type:        schema.TypeString,
+				Computed:    true,
+			},
+			"pod_name": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"url": {
+				Description: "the URL",
+				Type:        schema.TypeString,
+				Computed:    true,
+			},
+			"username": {
+				Description: "the username for the cluster",
+				Type:        schema.TypeString,
+				Computed:    true,
+			},
+			"vsm_ip_address": {
+				Description: "the ipaddress of the VSM associated with this cluster",
+				Type:        schema.TypeString,
+				Computed:    true,
+			},
+			"vsm_password": {
+				Description: "the password for the VSM associated with this cluster",
+				Type:        schema.TypeString,
+				Computed:    true,
+				Sensitive:   true,
+			},
+			"vsm_username": {
+				Description: "the username for the VSM associated with this cluster",
+				Type:        schema.TypeString,
+				Computed:    true,
+			},
+			"zone_id": {
+				Description: "the Zone ID for the cluster",
+				Type:        schema.TypeString,
+				Computed:    true,
+			},
+			"zone_name": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"managed_state": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"cpu_overcommit_ratio": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"memory_overcommit_ratio": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"arch": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"capacity": {
+				Type:     schema.TypeList,
+				Computed: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"capacity_allocated": {
+							Type:     schema.TypeInt,
+							Computed: true,
+						},
+						"capacity_total": {
+							Type:     schema.TypeInt,
+							Computed: true,
+						},
+						"capacity_used": {
+							Type:     schema.TypeInt,
+							Computed: true,
+						},
+						"cluster_id": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"cluster_name": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"name": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"percent_used": {
+							Type:     schema.TypeInt,
+							Computed: true,
+						},
+						"pod_id": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"pod_name": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"type": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"zone_id": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"zone_name": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+					},
+				},
+			},
+		},
+	}
+}
+
+func dsFlattenClusterCapacity(capacity []cloudstack.ClusterCapacity) []map[string]interface{} {
+	cap := make([]map[string]interface{}, len(capacity))
+	for i, c := range capacity {
+		cap[i] = map[string]interface{}{
+			"capacity_allocated": c.Capacityallocated,
+			"capacity_total":     c.Capacitytotal,
+			"capacity_used":      c.Capacityused,
+			"cluster_id":         c.Clusterid,
+			"cluster_name":       c.Clustername,
+			"name":               c.Name,
+			"percent_used":       c.Percentused,
+			"pod_id":             c.Podid,
+			"pod_name":           c.Podname,
+			"type":               c.Type,
+			"zone_id":            c.Zoneid,
+			"zone_name":          c.Zonename,
+		}
+	}
+	return cap
+}
+
+func datasourceCloudStackClusterRead(d *schema.ResourceData, meta interface{}) error {
+	cs := meta.(*cloudstack.CloudStackClient)
+	p := cs.Cluster.NewListClustersParams()
+
+	csClusters, err := cs.Cluster.ListClusters(p)
+	if err != nil {
+		return fmt.Errorf("failed to list clusters: %s", err)
+	}
+
+	filters := d.Get("filter")
+
+	for _, cluster := range csClusters.Clusters {
+		match, err := applyClusterFilters(cluster, filters.(*schema.Set))
+		if err != nil {
+			return err
+		}
+		if match {
+			return clusterDescriptionAttributes(d, cluster)
+		}
+	}
+
+	return fmt.Errorf("no clusters found")
+}
+
+func clusterDescriptionAttributes(d *schema.ResourceData, cluster *cloudstack.Cluster) error {
+	d.SetId(cluster.Id)
+
+	fields := map[string]interface{}{
+		"id":                      cluster.Id,
+		"allocation_state":        cluster.Allocationstate,
+		"cluster_name":            cluster.Name,
+		"name":                    cluster.Name,
+		"cluster_type":            cluster.Clustertype,
+		"hypervisor":              cluster.Hypervisortype,
+		"ovm3_vip":                cluster.Ovm3vip,
+		"ovm3vip":                 cluster.Ovm3vip,
+		"pod_id":                  cluster.Podid,
+		"pod_name":                cluster.Podname,
+		"zone_id":                 cluster.Zoneid,
+		"zone_name":               cluster.Zonename,
+		"managed_state":           cluster.Managedstate,
+		"cpu_overcommit_ratio":    cluster.Cpuovercommitratio,
+		"memory_overcommit_ratio": cluster.Memoryovercommitratio,
+		"arch":                    cluster.Arch,
+		"capacity":                dsFlattenClusterCapacity(cluster.Capacity),
+	}
+
+	// Set fields that may not be available in all cluster responses to empty strings
+	// These are typically only available during cluster creation/configuration
+	emptyStringFields := []string{
+		"guest_vswitch_name",
+		"guest_vswitch_type",
+		"ovm3_cluster",
+		"ovm3_pool",
+		"password",
+		"public_vswitch_name",
+		"public_vswitch_type",
+		"url",
+		"username",
+		"vsm_ip_address",
+		"vsm_password",
+		"vsm_username",
+	}
+
+	for k, v := range fields {
+		if err := d.Set(k, v); err != nil {
+			log.Printf("[WARN] Error setting %s: %s", k, err)
+		}
+	}
+
+	for _, field := range emptyStringFields {
+		if err := d.Set(field, ""); err != nil {
+			log.Printf("[WARN] Error setting %s: %s", field, err)
+		}
+	}
+
+	return nil
+}
+
+func applyClusterFilters(cluster *cloudstack.Cluster, filters *schema.Set) (bool, error) {
+	val := reflect.ValueOf(cluster).Elem()
+
+	for _, f := range filters.List() {
+		filter := f.(map[string]interface{})
+		r, err := regexp.Compile(filter["value"].(string))
+		if err != nil {
+			return false, fmt.Errorf("invalid regex: %s", err)
+		}
+		updatedName := strings.ReplaceAll(filter["name"].(string), "_", "")
+		clusterField := val.FieldByNameFunc(func(fieldName string) bool {
+			if strings.EqualFold(fieldName, updatedName) {
+				updatedName = fieldName
+				return true
+			}
+			return false
+		}).String()
+
+		if r.MatchString(clusterField) {
+			return true, nil
+		}
+	}
+
+	return false, nil
+}