updates

internal/vcenter/vcenter.go

@@ -7,6 +7,7 @@ import (
 	"log/slog"
 	"net/url"
 	"os"
+	"path"
 
 	"github.com/vmware/govmomi"
 	"github.com/vmware/govmomi/find"
@@ -24,7 +25,9 @@ type Vcenter struct {
 }
 
 type VmProperties struct {
-	Vm mo.VirtualMachine
+	Vm           mo.VirtualMachine
+	ResourcePool string
+	FolderPath   string
 	//Datacenter string
 }
 
@@ -177,6 +180,8 @@ func (v *Vcenter) FindVMByID(vmID string) (*VmProperties, error) {
 func (v *Vcenter) FindVMByIDWithDatacenter(vmID string, dcID string) (*VmProperties, error) {
 	//var dcName string
 	var err error
+	resourcePool := ""
+	vmFolderPath := ""
 	v.Logger.Debug("searching for vm id", "vm_id", vmID, "datacenter_id", dcID)
 
 	finder := find.NewFinder(v.client.Client, true)
@@ -196,14 +201,6 @@ func (v *Vcenter) FindVMByIDWithDatacenter(vmID string, dcID string) (*VmPropert
 	// Use finder.SetDatacenter to set the datacenter
 	finder.SetDatacenter(datacenter)
 
-	/*
-		dcName, err = datacenter.ObjectName(v.ctx)
-		if err != nil {
-			v.Logger.Error("Couldn't find the name of the datacenter", "error", err)
-			dcName = ""
-		}
-	*/
-
 	// Create a ManagedObjectReference for the VM
 	vmRef := types.ManagedObjectReference{
 		Type:  "VirtualMachine",
@@ -215,18 +212,93 @@ func (v *Vcenter) FindVMByIDWithDatacenter(vmID string, dcID string) (*VmPropert
 	err = v.client.RetrieveOne(v.ctx, vmRef, nil, &vm)
 	if err == nil {
 		v.Logger.Debug("Found VM")
+
+		// Retrieve the resource pool the VM is in
+		if vm.ResourcePool != nil {
+			rp := object.NewResourcePool(v.client.Client, *vm.ResourcePool)
+			rpName, err := rp.ObjectName(v.ctx)
+			if err != nil {
+				v.Logger.Error("failed to get resource pool name", "error", err)
+			} else {
+				v.Logger.Debug("Found resource pool name", "rp_name", rpName)
+				resourcePool = rpName
+			}
+
+		}
+
+		// Retrieve the full folder path of the VM
+		folderPath, err := v.getVMFolderPath(vm)
+		if err != nil {
+			v.Logger.Error("failed to get vm folder path", "error", err)
+		} else {
+			v.Logger.Debug("Found vm folder path", "folder_path", folderPath)
+			vmFolderPath = folderPath
+		}
+
 		return &VmProperties{
 			//Datacenter: dcName,
-			Vm: vm,
+			Vm:           vm,
+			ResourcePool: resourcePool,
+			FolderPath:   vmFolderPath,
 		}, nil
 	} else if _, ok := err.(*find.NotFoundError); !ok {
 		// If the error is not a NotFoundError, return it
 		//return nil, fmt.Errorf("failed to retrieve VM with ID %s in datacenter %s: %w", vmID, dc.Name(), err)
 		v.Logger.Debug("Couldn't find vm in datacenter", "vm_id", vmID, "datacenter_id", dcID)
+		return nil, nil
 	} else {
 		return nil, fmt.Errorf("failed to retrieve VM: %w", err)
 	}
 
-	v.Logger.Info("Unable to find vm in datacenter", "vm_id", vmID, "datacenter_id", dcID)
-	return nil, nil
+	//v.Logger.Info("Unable to find vm in datacenter", "vm_id", vmID, "datacenter_id", dcID)
+	//return nil, nil
+}
+
+// Helper function to retrieve the full folder path for the VM
+func (v *Vcenter) getVMFolderPath(vm mo.VirtualMachine) (string, error) {
+	//finder := find.NewFinder(v.client.Client, true)
+
+	v.Logger.Debug("Commencing vm folder path search")
+
+	// Start from the VM's parent
+	parentRef := vm.Parent
+	if parentRef == nil {
+		return "", fmt.Errorf("no parent found for the VM")
+	}
+
+	// Traverse the folder hierarchy to build the full folder path
+	folderPath := ""
+	v.Logger.Debug("parent is", "parent", parentRef)
+
+	for parentRef.Type != "Datacenter" {
+		// Retrieve the parent object
+		//parentObj, err := finder.ObjectReference(v.ctx, *parentRef)
+		//if err != nil {
+		//	return "", fmt.Errorf("failed to find parent object in inventory: %w", err)
+		//}
+
+		// Retrieve the folder name
+
+		var parentObj mo.Folder
+		err := v.client.RetrieveOne(v.ctx, *parentRef, nil, &parentObj)
+		if err != nil {
+			v.Logger.Error("Failed to get object for parent reference", "ref", parentRef)
+			break
+		}
+
+		// Prepend the folder name to the path
+		folderPath = path.Join("/", parentObj.Name, folderPath)
+
+		// Move up to the next parent
+		//if folder, ok := parentObj.(*object.Folder); ok {
+		if parentObj.Parent != nil {
+			parentRef = parentObj.Parent
+			v.Logger.Debug("Parent uplevel is", "ref", parentRef)
+		} else {
+			return "", fmt.Errorf("unexpected parent type: %s", parentObj.Reference().Type)
+		}
+		//break
+	}
+
+	return folderPath, nil
 }