Add VM import (based on HC3 API) to hypercore_vm_resource

Author: anazobec

internal/provider/hypercore_vm_resource.go

@@ -39,11 +39,22 @@ type HypercoreVMResourceModel struct {
 	Description      types.String          `tfsdk:"description"`
 	VCPU             types.Int32           `tfsdk:"vcpu"`
 	Memory           types.Int64           `tfsdk:"memory"`
+	Import           ImportModel           `tfsdk:"import"`
+	HTTPImportPath   types.String          `tfsdk:"http_import_path"`
 	Clone            CloneModel            `tfsdk:"clone"`
 	AffinityStrategy AffinityStrategyModel `tfsdk:"affinity_strategy"`
 	Id               types.String          `tfsdk:"id"`
 }
 
+type ImportModel struct {
+	HTTPPath types.String `tfsdk:"http_path"`
+	Server   types.String `tfsdk:"server"`
+	Username types.String `tfsdk:"username"`
+	Password types.String `tfsdk:"password"`
+	Path     types.String `tfsdk:"path"`
+	FileName types.String `tfsdk:"file_name"`
+}
+
 type CloneModel struct {
 	SourceVMUUID types.String `tfsdk:"source_vm_uuid"`
 	UserData     types.String `tfsdk:"user_data"`
@@ -90,6 +101,19 @@ func (r *HypercoreVMResource) Schema(ctx context.Context, req resource.SchemaReq
 					"and it's memory was modified, the cloned VM will be rebooted (either gracefully or forcefully)",
 				Optional: true,
 			},
+			"import": schema.ObjectAttribute{
+				MarkdownDescription: "Options for importing a VM through an SMB server. <br>" +
+					"All parameters except `file_path` are **required**",
+				Optional: true,
+				AttributeTypes: map[string]attr.Type{
+					"http_path": types.StringType,
+					"server":    types.StringType,
+					"username":  types.StringType,
+					"password":  types.StringType,
+					"path":      types.StringType,
+					"file_name": types.StringType,
+				},
+			},
 			"clone": schema.ObjectAttribute{
 				MarkdownDescription: "" +
 					"Clone options if the VM is being created as a clone. The `source_vm_uuid` is the UUID of the VM used for cloning, <br>" +
@@ -198,6 +222,7 @@ func (r *HypercoreVMResource) Create(ctx context.Context, req resource.CreateReq
 
 	tflog.Info(ctx, fmt.Sprintf("TTRT Create: name=%s, source_uuid=%s", data.Name.ValueString(), data.Clone.SourceVMUUID.ValueString()))
 
+	// Import or clone
 	vmClone, _ := utils.NewVM(
 		data.Name.ValueString(),
 		data.Clone.SourceVMUUID.ValueString(),
@@ -212,13 +237,42 @@ func (r *HypercoreVMResource) Create(ctx context.Context, req resource.CreateReq
 		data.AffinityStrategy.PreferredNodeUUID.ValueString(),
 		data.AffinityStrategy.BackupNodeUUID.ValueString(),
 	)
-	changed, msg := vmClone.Create(*r.client, ctx)
-	tflog.Info(ctx, fmt.Sprintf("Changed: %t, Message: %s\n", changed, msg))
 
-	// General parametrization
-	// set: description, group, vcpu, memory, power_state
-	changed, vmWasRebooted, vmDiff := vmClone.SetVMParams(*r.client, ctx)
-	tflog.Info(ctx, fmt.Sprintf("Changed: %t, Was VM Rebooted: %t, Diff: %v", changed, vmWasRebooted, vmDiff))
+	// http import
+	httpPath := data.Import.HTTPPath.ValueString()
+
+	// smb import
+	smbServer := data.Import.Server.ValueString()
+	smbUsername := data.Import.Username.ValueString()
+	smbPassword := data.Import.Password.ValueString()
+	smbPath := data.Import.Path.ValueString()
+	fileName := data.Import.FileName.ValueString()
+
+	isSMBImport := smbServer != "" || smbUsername != "" || smbPassword != "" || smbPath != ""
+	isHTTPImport := httpPath != ""
+
+	importedVM := map[string]any{}
+	if isHTTPImport && !isSMBImport {
+		utils.ValidateHTTP(httpPath)
+		httpSource := utils.BuildHTTPImportSource(httpPath, fileName)
+		importedVM = vmClone.ImportVM(*r.client, httpSource, ctx)
+		tflog.Debug(ctx, fmt.Sprintf("TTRT Create - with HTTP VM import: vm_uuid=%s, vm=%v", vmClone.UUID, importedVM))
+	} else if isSMBImport && !isHTTPImport {
+		utils.ValidateSMB(smbServer, smbUsername, smbPassword, smbPath)
+		smbSource := utils.BuildSMBImportSource(smbUsername, smbPassword, smbServer, smbPath, fileName)
+		importedVM = vmClone.ImportVM(*r.client, smbSource, ctx)
+		tflog.Debug(ctx, fmt.Sprintf("TTRT Create - with SMB VM import: vm_uuid=%s, vm=%v", vmClone.UUID, importedVM))
+	} else {
+		// Cloning
+		changed, msg := vmClone.Create(*r.client, ctx)
+		tflog.Info(ctx, fmt.Sprintf("Changed: %t, Message: %s\n", changed, msg))
+
+		// General parametrization
+		// set: description, group, vcpu, memory, power_state
+		changed, vmWasRebooted, vmDiff := vmClone.SetVMParams(*r.client, ctx)
+		tflog.Info(ctx, fmt.Sprintf("Changed: %t, Was VM Rebooted: %t, Diff: %v", changed, vmWasRebooted, vmDiff))
+
+	}
 
 	// save into the Terraform state.
 	data.Id = types.StringValue(vmClone.UUID)

internal/utils/helper.go

@@ -12,6 +12,9 @@ import (
 	"net/http"
 	"os"
 	"strconv"
+	"strings"
+
+	"github.com/hashicorp/terraform-plugin-framework/diag"
 )
 
 func isSuperset(superset map[string]any, candidate map[string]any) bool {
@@ -303,3 +306,42 @@ func GetFileSize(sourceFilePath string) int64 {
 	}
 	return fileInfo.Size()
 }
+
+func ValidateSMB(server string, username string, password string, path string) diag.Diagnostic {
+	if server == "" {
+		return diag.NewErrorDiagnostic(
+			"Missing 'server' parameter",
+			"For using SMB, you must specify the 'server' parameter",
+		)
+	}
+	if username == "" {
+		return diag.NewErrorDiagnostic(
+			"Missing 'username' parameter",
+			"For using SMB, you must specify the 'username' parameter",
+		)
+	}
+	if password == "" {
+		return diag.NewErrorDiagnostic(
+			"Missing 'password' parameter",
+			"For using SMB, you must specify the 'password' parameter",
+		)
+	}
+	if path == "" {
+		return diag.NewErrorDiagnostic(
+			"Missing 'path' parameter",
+			"For using SMB, you must specify the 'path' parameter",
+		)
+	}
+	return nil
+}
+
+func ValidateHTTP(httpPath string) diag.Diagnostic {
+	if strings.HasPrefix(httpPath, "http://") || strings.HasPrefix(httpPath, "https://") {
+		return diag.NewErrorDiagnostic(
+			"Invalid HTTP path",
+			"Invalid HTTP path. Path must start with 'http://' or 'https://'",
+		)
+	}
+
+	return nil
+}

internal/utils/vm.go

@@ -172,6 +172,33 @@ func (vc *VM) Create(restClient RestClient, ctx context.Context) (bool, string)
 	panic(fmt.Sprintf("There was a problem during cloning of %s %s, cloning failed.", sourceVMName, vc.sourceVMUUID))
 }
 
+func (vc *VM) ImportVM(
+	restClient RestClient,
+	source map[string]any,
+	ctx context.Context,
+) map[string]any {
+	payload := map[string]any{
+		"source": source,
+	}
+
+	importTemplate := vc.BuildImportTemplate()
+	if len(importTemplate) > 0 {
+		payload["template"] = importTemplate
+	}
+
+	taskTag, _, _ := restClient.CreateRecord(
+		"/rest/v1/VirDomain/import",
+		payload,
+		-1,
+	)
+	taskTag.WaitTask(restClient, ctx)
+	vmUUID := taskTag.CreatedUUID
+	vm := GetOneVM(vmUUID, restClient)
+
+	vc.UUID = vmUUID
+	return vm
+}
+
 func (vc *VM) SetVMParams(restClient RestClient, ctx context.Context) (bool, bool, map[string]any) {
 	vm := GetVMByName(vc.VMName, restClient, true)
 	changed, changedParams := vc.GetChangedParams(ctx, *vm)
@@ -430,6 +457,40 @@ func (vc *VM) BuildUpdatePayload(changedParams map[string]bool) map[string]any {
 	return updatePayload
 }
 
+func (vc *VM) BuildImportTemplate() map[string]any {
+	importTemplate := map[string]any{}
+
+	if vc.description != nil {
+		importTemplate["description"] = *vc.description
+	}
+	if vc.tags != nil {
+		importTemplate["tags"] = tagsListToCommaString(*vc.tags)
+	}
+	if vc.memory != nil {
+		vcMemoryBytes := *vc.memory * 1024 * 1024 // MB to B
+		importTemplate["mem"] = vcMemoryBytes
+	}
+	if vc.vcpu != nil {
+		importTemplate["numVCPU"] = *vc.vcpu
+	}
+
+	affinityStrategy := map[string]any{
+		"strictAffinity": vc.strictAffinity,
+	}
+
+	if vc.preferredNodeUUID != "" {
+		affinityStrategy["preferredNodeUUID"] = vc.preferredNodeUUID
+	}
+
+	if vc.backupNodeUUID != "" {
+		affinityStrategy["backupNodeUUID"] = vc.backupNodeUUID
+	}
+
+	importTemplate["affinityStrategy"] = affinityStrategy
+
+	return importTemplate
+}
+
 func (vc *VM) GetChangedParams(ctx context.Context, vmFromClient map[string]any) (bool, map[string]bool) {
 	changedParams := map[string]bool{}
 
@@ -469,6 +530,31 @@ func (vc *VM) GetChangedParams(ctx context.Context, vmFromClient map[string]any)
 	return false, changedParams
 }
 
+func BuildSMBImportSource(username string, password string, server string, path string, fileName string) map[string]any {
+	pathURI := fmt.Sprintf("smb://%s:%s@%s%s", username, password, server, path)
+
+	source := map[string]any{
+		"pathURI": pathURI,
+	}
+	if fileName != "" {
+		source["definitionFileName"] = fileName
+	}
+
+	return source
+}
+
+func BuildHTTPImportSource(httpPath string, fileName string) map[string]any {
+	source := map[string]any{
+		"pathURI": httpPath,
+	}
+
+	if fileName != "" {
+		source["definitionFileName"] = fileName
+	}
+
+	return source
+}
+
 func GetOneVM(uuid string, restClient RestClient) map[string]any {
 	url := "/rest/v1/VirDomain/" + uuid
 	records := restClient.ListRecords(

local/main.tf

@@ -11,16 +11,49 @@ terraform {
 
 provider "hypercore" {}
 
-data "hypercore_remote_cluster_connection" "all_clusters" {}
+locals {
+  vm_meta_data_tmpl = "./assets/meta-data.ubuntu-22.04.yml.tftpl"
+  vm_user_data_tmpl = "./assets/user-data.ubuntu-22.04.yml.tftpl"
+  vm_name           = "my-vm"
+}
+
+data "hypercore_vm" "clone_source_vm" {
+  name = "source_vm"
+}
+
+# This is what the updated resource will look like with import
+resource "hypercore_vm" "import-from-http" {
+  group       = "my-group"
+  name        = local.vm_name
+  description = "some description"
+
+  vcpu   = 4
+  memory = 4096 # MiB
 
-data "hypercore_remote_cluster_connection" "cluster-a" {
-  remote_cluster_name = "cluster-a"
+  import = {
+    http_path = "http://someurl/my-vm"
+  }
 }
 
-output "all_remote_clusters" {
-  value = jsonencode(data.hypercore_remote_cluster_connection.all_clusters)
+resource "hypercore_vm" "import-from-smb" {
+  group       = "my-group"
+  name        = local.vm_name
+  description = "some description"
+
+  vcpu   = 4
+  memory = 4096 # MiB
+
+  import = {
+    server = "server"
+    username = "username"
+    password = "password"
+    path = "path"
+    file_name = "file_name"
+  }
 }
 
-output "filtered_remote_cluster" {
-  value = jsonencode(data.hypercore_remote_cluster_connection.cluster-a)
+# NOTE: 'clone' parameter can still be defined along with 'import', but in THIS case, 'import' will be the one taking effect, not clone
+
+output "vm_uuid" {
+  value = hypercore_vm.myvm.id
 }