Add support for userdata and linking to templates

cloudstack/data_source_cloudstack_user_data.go

@@ -0,0 +1,128 @@
+//
+// 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 (
+	"encoding/base64"
+	"fmt"
+	"log"
+
+	"github.com/apache/cloudstack-go/v2/cloudstack"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+func dataSourceCloudstackUserData() *schema.Resource {
+	return &schema.Resource{
+		Read: dataSourceCloudstackUserDataRead,
+		Schema: map[string]*schema.Schema{
+			"filter": dataSourceFiltersSchema(),
+			"account": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"account_id": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"domain": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"domain_id": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"project": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"project_id": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"userdata_id": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"userdata": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"params": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+		},
+	}
+}
+
+func dataSourceCloudstackUserDataRead(d *schema.ResourceData, meta interface{}) error {
+	cs := meta.(*cloudstack.CloudStackClient)
+
+	name := d.Get("name").(string)
+	p := cs.User.NewListUserDataParams()
+	p.SetName(name)
+
+	if v, ok := d.GetOk("account"); ok {
+		p.SetAccount(v.(string))
+	}
+	if v, ok := d.GetOk("domain_id"); ok {
+		p.SetDomainid(v.(string))
+	}
+
+	log.Printf("[DEBUG] Listing user data with name: %s", name)
+	userdataList, err := cs.User.ListUserData(p)
+	if err != nil {
+		return fmt.Errorf("Error listing user data with name %s: %s", name, err)
+	}
+
+	if len(userdataList.UserData) == 0 {
+		return fmt.Errorf("No user data found with name: %s", name)
+	}
+	if len(userdataList.UserData) > 1 {
+		return fmt.Errorf("Multiple user data entries found with name: %s", name)
+	}
+
+	userdata := userdataList.UserData[0]
+
+	d.SetId(userdata.Id)
+	d.Set("name", userdata.Name)
+	d.Set("account", userdata.Account)
+	d.Set("account_id", userdata.Accountid)
+	d.Set("domain", userdata.Domain)
+	d.Set("domain_id", userdata.Domainid)
+	d.Set("userdata_id", userdata.Id)
+	d.Set("params", userdata.Params)
+
+	if userdata.Project != "" {
+		d.Set("project", userdata.Project)
+		d.Set("project_id", userdata.Projectid)
+	}
+
+	if userdata.Userdata != "" {
+		decoded, err := base64.StdEncoding.DecodeString(userdata.Userdata)
+		if err != nil {
+			d.Set("userdata", userdata.Userdata) // Fallback: use raw data
+		} else {
+			d.Set("userdata", string(decoded))
+		}
+	}
+	return nil
+}

cloudstack/provider.go

@@ -104,6 +104,7 @@ func Provider() *schema.Provider {
 			"cloudstack_quota":                dataSourceCloudStackQuota(),
 			"cloudstack_quota_enabled":        dataSourceCloudStackQuotaEnabled(),
 			"cloudstack_quota_tariff":         dataSourceCloudStackQuotaTariff(),
+			"cloudstack_user_data":            dataSourceCloudstackUserData(),
 		},
 
 		ResourcesMap: map[string]*schema.Resource{
@@ -164,6 +165,7 @@ func Provider() *schema.Provider {
 			"cloudstack_limits":                         resourceCloudStackLimits(),
 			"cloudstack_snapshot_policy":                resourceCloudStackSnapshotPolicy(),
 			"cloudstack_quota_tariff":                   resourceCloudStackQuotaTariff(),
+			"cloudstack_user_data":                      resourceCloudStackUserData(),
 		},
 
 		ConfigureFunc: providerConfigure,

cloudstack/resource_cloudstack_instance.go

@@ -212,6 +212,17 @@ func resourceCloudStackInstance() *schema.Resource {
 				},
 			},
 
+			"userdata_id": {
+				Type:     schema.TypeString,
+				Optional: true,
+			},
+
+			"userdata_details": {
+				Type:     schema.TypeMap,
+				Optional: true,
+				Elem:     &schema.Schema{Type: schema.TypeString},
+			},
+
 			"details": {
 				Type:     schema.TypeMap,
 				Optional: true,
@@ -446,6 +457,20 @@ func resourceCloudStackInstanceCreate(d *schema.ResourceData, meta interface{})
 		p.SetUserdata(ud)
 	}
 
+	if userdataID, ok := d.GetOk("userdata_id"); ok {
+		p.SetUserdataid(userdataID.(string))
+	}
+
+	if userdataDetails, ok := d.GetOk("userdata_details"); ok {
+		udDetails := make(map[string]string)
+		index := 0
+		for k, v := range userdataDetails.(map[string]interface{}) {
+			udDetails[fmt.Sprintf("userdatadetails[%d].%s", index, k)] = v.(string)
+			index++
+		}
+		p.SetUserdatadetails(udDetails)
+	}
+
 	// Create the new instance
 	r, err := cs.VirtualMachine.DeployVirtualMachine(p)
 	if err != nil {
@@ -560,6 +585,23 @@ func resourceCloudStackInstanceRead(d *schema.ResourceData, meta interface{}) er
 		d.Set("boot_mode", vm.Bootmode)
 	}
 
+	if vm.Userdataid != "" {
+		d.Set("userdata_id", vm.Userdataid)
+	}
+
+	if vm.Userdata != "" {
+		decoded, err := base64.StdEncoding.DecodeString(vm.Userdata)
+		if err != nil {
+			d.Set("user_data", vm.Userdata)
+		} else {
+			d.Set("user_data", string(decoded))
+		}
+	}
+
+	if vm.Userdatadetails != "" {
+		log.Printf("[DEBUG] Instance %s has userdata details: %s", vm.Name, vm.Userdatadetails)
+	}
+
 	return nil
 }
 
@@ -609,7 +651,8 @@ func resourceCloudStackInstanceUpdate(d *schema.ResourceData, meta interface{})
 
 	// Attributes that require reboot to update
 	if d.HasChange("name") || d.HasChange("service_offering") || d.HasChange("affinity_group_ids") ||
-		d.HasChange("affinity_group_names") || d.HasChange("keypair") || d.HasChange("keypairs") || d.HasChange("user_data") {
+		d.HasChange("affinity_group_names") || d.HasChange("keypair") || d.HasChange("keypairs") ||
+		d.HasChange("user_data") || d.HasChange("userdata_id") || d.HasChange("userdata_details") {
 
 		// Before we can actually make these changes, the virtual machine must be stopped
 		_, err := cs.VirtualMachine.StopVirtualMachine(
@@ -763,6 +806,40 @@ func resourceCloudStackInstanceUpdate(d *schema.ResourceData, meta interface{})
 			}
 		}
 
+		if d.HasChange("userdata_id") {
+			log.Printf("[DEBUG] userdata_id changed for %s, starting update", name)
+
+			p := cs.VirtualMachine.NewUpdateVirtualMachineParams(d.Id())
+			if userdataID, ok := d.GetOk("userdata_id"); ok {
+				p.SetUserdataid(userdataID.(string))
+			}
+			_, err := cs.VirtualMachine.UpdateVirtualMachine(p)
+			if err != nil {
+				return fmt.Errorf(
+					"Error updating userdata_id for instance %s: %s", name, err)
+			}
+		}
+
+		if d.HasChange("userdata_details") {
+			log.Printf("[DEBUG] userdata_details changed for %s, starting update", name)
+
+			p := cs.VirtualMachine.NewUpdateVirtualMachineParams(d.Id())
+			if userdataDetails, ok := d.GetOk("userdata_details"); ok {
+				udDetails := make(map[string]string)
+				index := 0
+				for k, v := range userdataDetails.(map[string]interface{}) {
+					udDetails[fmt.Sprintf("userdatadetails[%d].%s", index, k)] = v.(string)
+					index++
+				}
+				p.SetUserdatadetails(udDetails)
+			}
+			_, err := cs.VirtualMachine.UpdateVirtualMachine(p)
+			if err != nil {
+				return fmt.Errorf(
+					"Error updating userdata_details for instance %s: %s", name, err)
+			}
+		}
+
 		// Start the virtual machine again
 		_, err = cs.VirtualMachine.StartVirtualMachine(
 			cs.VirtualMachine.NewStartVirtualMachineParams(d.Id()))