Add support for userdata and linking to templates

Author: Pearl1594

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_userdata":                       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,31 @@ func resourceCloudStackInstanceRead(d *schema.ResourceData, meta interface{}) er
 		d.Set("boot_mode", vm.Bootmode)
 	}
 
+	// Set userdata information if available
+	if vm.Userdataid != "" {
+		d.Set("userdata_id", vm.Userdataid)
+	}
+
+	// Handle userdata with graceful Base64 decoding
+	if vm.Userdata != "" {
+		decoded, err := base64.StdEncoding.DecodeString(vm.Userdata)
+		if err != nil {
+			// If decoding fails, store the raw data
+			d.Set("user_data", vm.Userdata)
+		} else {
+			// Successfully decoded, store as string
+			d.Set("user_data", string(decoded))
+		}
+	}
+
+	// Set userdata_details if available (CloudStack might return them in a specific format)
+	if vm.Userdatadetails != "" {
+		// Note: CloudStack typically returns userdata details as a JSON string or key-value pairs
+		// We may need to parse this based on the actual CloudStack response format
+		// For now, we'll leave this as a placeholder since the exact format needs to be verified
+		log.Printf("[DEBUG] Instance %s has userdata details: %s", vm.Name, vm.Userdatadetails)
+	}
+
 	return nil
 }
 
@@ -609,7 +659,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 +814,42 @@ func resourceCloudStackInstanceUpdate(d *schema.ResourceData, meta interface{})
 			}
 		}
 
+		// Check if the userdata_id has changed and if so, update it
+		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)
+			}
+		}
+
+		// Check if the userdata_details has changed and if so, update it
+		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()))

cloudstack/resource_cloudstack_template.go

@@ -133,6 +133,37 @@ func resourceCloudStackTemplate() *schema.Resource {
 				ForceNew: true,
 			},
 
+			"userdata_link": {
+				Type:     schema.TypeList,
+				Optional: true,
+				MaxItems: 1,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"userdata_id": {
+							Type:        schema.TypeString,
+							Required:    true,
+							Description: "The ID of the user data to link to the template.",
+						},
+						"userdata_policy": {
+							Type:        schema.TypeString,
+							Optional:    true,
+							Default:     "ALLOWOVERRIDE",
+							Description: "Override policy of the userdata. Possible values: ALLOWOVERRIDE, APPEND, DENYOVERRIDE. Default: ALLOWOVERRIDE",
+						},
+						"userdata_name": {
+							Type:        schema.TypeString,
+							Computed:    true,
+							Description: "The name of the linked user data.",
+						},
+						"userdata_params": {
+							Type:        schema.TypeString,
+							Computed:    true,
+							Description: "The parameters of the linked user data.",
+						},
+					},
+				},
+			},
+
 			"tags": tagsSchema(),
 		},
 	}
@@ -224,6 +255,11 @@ func resourceCloudStackTemplateCreate(d *schema.ResourceData, meta interface{})
 		return fmt.Errorf("Error setting tags on the template %s: %s", name, err)
 	}
 
+	// Link userdata if specified
+	if err = linkUserdataToTemplate(cs, d, r.RegisterTemplate[0].Id); err != nil {
+		return fmt.Errorf("Error linking userdata to template %s: %s", name, err)
+	}
+
 	// Wait until the template is ready to use, or timeout with an error...
 	currentTime := time.Now().Unix()
 	timeout := int64(d.Get("is_ready_timeout").(int))
@@ -300,6 +336,11 @@ func resourceCloudStackTemplateRead(d *schema.ResourceData, meta interface{}) er
 	setValueOrID(d, "project", t.Project, t.Projectid)
 	setValueOrID(d, "zone", t.Zonename, t.Zoneid)
 
+	// Read userdata link information
+	if err := readUserdataFromTemplate(d, t); err != nil {
+		return fmt.Errorf("Error reading userdata link from template: %s", err)
+	}
+
 	return nil
 }
 
@@ -349,6 +390,12 @@ func resourceCloudStackTemplateUpdate(d *schema.ResourceData, meta interface{})
 		}
 	}
 
+	if d.HasChange("userdata_link") {
+		if err := updateUserdataLink(cs, d); err != nil {
+			return fmt.Errorf("Error updating userdata link for template %s: %s", name, err)
+		}
+	}
+
 	return resourceCloudStackTemplateRead(d, meta)
 }
 
@@ -383,3 +430,105 @@ func verifyTemplateParams(d *schema.ResourceData) error {
 
 	return nil
 }
+
+func linkUserdataToTemplate(cs *cloudstack.CloudStackClient, d *schema.ResourceData, templateID string) error {
+	userdataLinks := d.Get("userdata_link").([]interface{})
+	if len(userdataLinks) == 0 {
+		return nil
+	}
+
+	userdataLink := userdataLinks[0].(map[string]interface{})
+
+	p := cs.Template.NewLinkUserDataToTemplateParams()
+	p.SetTemplateid(templateID)
+	p.SetUserdataid(userdataLink["userdata_id"].(string))
+
+	if policy, ok := userdataLink["userdata_policy"].(string); ok && policy != "" {
+		p.SetUserdatapolicy(policy)
+	}
+
+	_, err := cs.Template.LinkUserDataToTemplate(p)
+	return err
+}
+
+func readUserdataFromTemplate(d *schema.ResourceData, template *cloudstack.Template) error {
+	if template.Userdataid == "" {
+		d.Set("userdata_link", []interface{}{})
+		return nil
+	}
+
+	userdataLink := map[string]interface{}{
+		"userdata_id":     template.Userdataid,
+		"userdata_name":   template.Userdataname,
+		"userdata_params": template.Userdataparams,
+	}
+
+	if existingLinks := d.Get("userdata_link").([]interface{}); len(existingLinks) > 0 {
+		if existingLink, ok := existingLinks[0].(map[string]interface{}); ok {
+			if policy, exists := existingLink["userdata_policy"]; exists {
+				userdataLink["userdata_policy"] = policy
+			}
+		}
+	}
+
+	d.Set("userdata_link", []interface{}{userdataLink})
+	return nil
+}
+
+func updateUserdataLink(cs *cloudstack.CloudStackClient, d *schema.ResourceData) error {
+	templateID := d.Id()
+
+	oldLinks, newLinks := d.GetChange("userdata_link")
+	oldLinksSlice := oldLinks.([]interface{})
+	newLinksSlice := newLinks.([]interface{})
+
+	// Check if we're removing userdata link (had one before, now empty)
+	if len(oldLinksSlice) > 0 && len(newLinksSlice) == 0 {
+		unlinkP := cs.Template.NewLinkUserDataToTemplateParams()
+		unlinkP.SetTemplateid(templateID)
+
+		_, err := cs.Template.LinkUserDataToTemplate(unlinkP)
+		if err != nil {
+			return fmt.Errorf("Error unlinking userdata from template: %s", err)
+		}
+		log.Printf("[DEBUG] Unlinked userdata from template: %s", templateID)
+		return nil
+	}
+
+	if len(newLinksSlice) > 0 {
+		newLink := newLinksSlice[0].(map[string]interface{})
+
+		if len(oldLinksSlice) > 0 {
+			oldLink := oldLinksSlice[0].(map[string]interface{})
+
+			if oldLink["userdata_id"].(string) == newLink["userdata_id"].(string) {
+				oldPolicy := ""
+				newPolicy := ""
+
+				if p, ok := oldLink["userdata_policy"].(string); ok {
+					oldPolicy = p
+				}
+				if p, ok := newLink["userdata_policy"].(string); ok {
+					newPolicy = p
+				}
+
+				if oldPolicy == newPolicy {
+					log.Printf("[DEBUG] Userdata link unchanged, skipping API call")
+					return nil
+				}
+			}
+
+			unlinkP := cs.Template.NewLinkUserDataToTemplateParams()
+			unlinkP.SetTemplateid(templateID)
+
+			_, err := cs.Template.LinkUserDataToTemplate(unlinkP)
+			if err != nil {
+				log.Printf("[DEBUG] Error unlinking existing userdata (this may be normal): %s", err)
+			}
+		}
+
+		return linkUserdataToTemplate(cs, d, templateID)
+	}
+
+	return nil
+}