better filename

Signed-off-by: Jeff Carr <[email protected]>

1 files changed, 803 insertions, 0 deletions

diff --git a/libvirtxml.go b/libvirtxml.go
new file mode 100644
index 0000000..2584a54
--- /dev/null
+++ b/libvirtxml.go
@@ -0,0 +1,803 @@
+// Copyright 2024 WIT.COM Inc Licensed GPL 3.0
+
+package main
+
+import (
+	"encoding/xml"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+
+	"go.wit.com/log"
+	"libvirt.org/go/libvirtxml"
+)
+
+func makeStandardXml(d *DropletT) *libvirtxml.Domain {
+	log.Info("create new xml file for:", d.pb.Hostname)
+	domcfg := &libvirtxml.Domain{}
+
+	addDefaults(domcfg, "standard.x86")
+	addDefaults(domcfg, "memory")
+	addDefaults(domcfg, "network")
+	addDefaults(domcfg, "spice")
+	addDefaults(domcfg, "qcow")
+	addDefaults(domcfg, d.pb.Hostname)
+
+	return domcfg
+}
+
+func writeoutXml(domcfg *libvirtxml.Domain, filename string) bool {
+	xmldoc, err := domcfg.Marshal()
+
+	if err != nil {
+		fmt.Println("can't make xml file error:\n", err)
+		return false
+	}
+
+	outfile := "/tmp/" + filename + ".xml"
+	regfile, _ := os.OpenFile(outfile, os.O_RDWR|os.O_CREATE, 0666)
+	fmt.Fprintln(regfile, xmldoc)
+
+	log.Info("File is in", outfile)
+	regfile.Close()
+	return true
+}
+
+func setDiskFilename(domcfg *libvirtxml.Domain, filename string) {
+	for i, x := range domcfg.Devices.Disks {
+		// Create a new DomainDiskSourceFile struct
+		newSource := &libvirtxml.DomainDiskSourceFile{
+			File: filename, // Set the file name here
+		}
+
+		// Assign it to the disk's source
+		domcfg.Devices.Disks[i].Source.File = newSource
+
+		// fmt.Printf("Disk Source %s\n", name)
+		fmt.Printf("Disk Device %s\n", x.Source.File)
+	}
+}
+
+func addDefaults(d *libvirtxml.Domain, filename string) {
+	fullname := "resources/xml/" + filename + ".xml"
+	pfile, err := resources.ReadFile(fullname)
+	if err != nil {
+		log.Println("ERROR:", err)
+		return
+	}
+
+	err = d.Unmarshal(string(pfile))
+	if err != nil {
+		log.Info("Marshal failed on file", filename)
+		return
+	}
+}
+
+func readXml(filename string) (*libvirtxml.Domain, error) {
+	log.Verbose("parse xml file:", filename)
+
+	hostname := filepath.Base(filename)
+	hostname = strings.TrimSuffix(hostname, ".xml")
+
+	pfile, err := os.ReadFile(filename)
+	if err != nil {
+		log.Println("ERROR:", err)
+		return nil, err
+	}
+
+	domcfg := &libvirtxml.Domain{}
+
+	err = domcfg.Unmarshal(string(pfile))
+	if err != nil {
+		log.Info("Marshal failed on file", filename, err)
+		return nil, ErrorParseXML
+	}
+
+	if domcfg.Name != hostname {
+		log.Info("ERROR: filename:", filename)
+		log.Info("ERROR: domcfg.Name != name", domcfg.Name, hostname)
+		log.Info("ERROR: xml filenames must match the xml name")
+		os.Exit(-1)
+	}
+
+	return domcfg, nil
+}
+
+func (d *DropletT) mergeXml(filename string) error {
+	log.Info("merge xml file:", filename)
+
+	pfile, err := os.ReadFile(filename)
+	if err != nil {
+		log.Println("ERROR:", err)
+		return ErrorNoFile
+	}
+
+	err = d.xml.Unmarshal(string(pfile))
+	if err != nil {
+		log.Info("Marshal failed on file", filename)
+		return ErrorParseXML
+	}
+	return nil
+}
+
+func setSimpleDisk(domcfg *libvirtxml.Domain, filename string) {
+	// Clear out the existing disks (if any)
+	domcfg.Devices.Disks = nil
+
+	// Define a new disk with "mynew.qcow2"
+	newDisk := libvirtxml.DomainDisk{
+		Device: "disk",
+		Driver: &libvirtxml.DomainDiskDriver{
+			Name: "qemu",
+			Type: "qcow2",
+		},
+		Source: &libvirtxml.DomainDiskSource{
+			File: &libvirtxml.DomainDiskSourceFile{
+				File: filename,
+			},
+		},
+		Target: &libvirtxml.DomainDiskTarget{
+			Dev: "vda",
+			Bus: "virtio",
+		},
+	}
+
+	// Add the new disk to the domain configuration
+	domcfg.Devices.Disks = append(domcfg.Devices.Disks, newDisk)
+}
+
+func getMacs(domcfg *libvirtxml.Domain) []string {
+	var macs []string
+	// Iterate over the network interfaces and print the MAC addresses
+	for _, iface := range domcfg.Devices.Interfaces {
+		if iface.MAC != nil {
+			// iface.MAC.Address = "aa:bb:aa:bb:aa:ff"
+			fmt.Printf("MAC Address: %+v\n", iface.MAC)
+			// fmt.Printf("Interface: %s, MAC Address: %s\n", iface.Target.Dev, iface.MAC.Address)
+			macs = append(macs, iface.MAC.Address)
+		} else {
+			fmt.Printf("Interface: %s, MAC Address: not available\n", iface.Target.Dev)
+		}
+	}
+	return macs
+}
+
+// removes all the ethernet interfaces
+func clearEthernet(domcfg *libvirtxml.Domain) {
+	// Clear out the existing disks (if any)
+	domcfg.Devices.Interfaces = nil
+}
+
+// add a new ethernet interface with mac assigned to bridge name
+func addEthernet(domcfg *libvirtxml.Domain, mac string, brname string) {
+	// Define a new disk with "mynew.qcow2"
+	type DomainInterfaceType string
+
+	newNet := libvirtxml.DomainInterface{
+		MAC: &libvirtxml.DomainInterfaceMAC{
+			Address: mac,
+		},
+		Target: &libvirtxml.DomainInterfaceTarget{
+			Dev: brname,
+		},
+	}
+
+	// Add the new disk to the domain configuration
+	domcfg.Devices.Interfaces = append(domcfg.Devices.Interfaces, newNet)
+}
+
+func setRandomMacs(domcfg *libvirtxml.Domain) {
+	for i, x := range domcfg.Devices.Interfaces {
+		// Create a new DomainDiskInterfaces struct
+		newMac := &libvirtxml.DomainInterfaceMAC{
+			Address: "aa:bb:cc:dd:ee:ff", // make sure this is unique
+		}
+
+		// Assign it to the disk's source
+		domcfg.Devices.Interfaces[i].MAC = newMac
+
+		// fmt.Printf("Disk Source %s\n", name)
+		// fmt.Printf("mac addr %+v\n", x.MAC)
+		fmt.Printf("mac addr %s\n", x.MAC.Address)
+	}
+}
+
+// go through the libvirt xml object and dump out everything
+// that is "standard". This is just a way to double check that
+// there might be something interesting in a VM
+// 'standard' here means what I think is standard
+func dumpNonStandardXML(domcfg *libvirtxml.Domain) {
+	// dump type
+	if domcfg.Type == "kvm" {
+		domcfg.Type = ""
+	} else {
+		fmt.Printf("type: %+v\n", domcfg.Type)
+	}
+
+	// dump normal OS settings
+	var standardOS bool = false
+	if domcfg.OS != nil {
+		if domcfg.OS.Type != nil {
+			// OS Type: &{Arch:x86_64 Machine:pc-i440fx-5.2 Type:hvm}
+			t := domcfg.OS.Type
+			if t.Arch == "x86_64" || t.Machine == "pc-i440fx-5.2" {
+				standardOS = true
+			}
+		}
+	}
+	if standardOS {
+		domcfg.OS = nil
+	} else {
+		fmt.Printf("OS: %+v\n", domcfg.OS)
+		fmt.Printf("OS Type: %+v\n", domcfg.OS.Type)
+	}
+
+	// ignore XMLName and IOThreads probably
+	// skip is hard coded in isDomainEmpty() function
+	// fmt.Printf("XMLName: %+v\n", domcfg.XMLName)
+	// fmt.Printf("IOThreads: %+v\n", domcfg.IOThreads)
+
+	// dump all the clock stuff if it's standard
+	var normalclock bool = true
+	if domcfg.Clock.Offset != "utc" {
+		normalclock = false
+	}
+	for i, t := range domcfg.Clock.Timer {
+		// fmt.Printf("Test Clock Timer: %d , %s , %+v\n", i, t.Name, t)
+		switch t.Name {
+		case "rtc":
+			if t.TickPolicy != "catchup" {
+				fmt.Printf("Clock Name: %+v , %+v\n", i, t)
+				normalclock = false
+			}
+		case "pit":
+			if t.TickPolicy != "delay" {
+				fmt.Printf("Clock Name: %+v , %+v\n", i, t)
+				normalclock = false
+			}
+		case "hpet":
+			if t.Present != "no" {
+				fmt.Printf("Clock Name: %+v , %+v\n", i, t)
+				normalclock = false
+			}
+		default:
+			fmt.Printf("Clock Name: %+v , %+v\n", i, t)
+			normalclock = false
+		}
+	}
+	if normalclock {
+		domcfg.Clock = nil
+	} else {
+		fmt.Printf("Clock was 'nonstandard' %+v\n", domcfg.Clock.Timer)
+	}
+
+	// probably just dump Features for now
+	// fmt.Printf("Features: %+v\n", domcfg.Features)
+	// fmt.Printf("Feature VMPort: %+v\n", domcfg.Features.VMPort)
+	// ignore if ACPI is set or not
+	var featurematch bool = true
+	if domcfg.Features.ACPI != nil {
+		domcfg.Features.ACPI = nil
+	} else {
+		featurematch = false
+	}
+	// ignore if APIC is set or not
+	if domcfg.Features.APIC != nil {
+		domcfg.Features.APIC = nil
+	} else {
+		featurematch = false
+	}
+	// what is VMPort anyway?
+	if domcfg.Features.VMPort != nil {
+		if domcfg.Features.VMPort.State == "off" {
+			domcfg.Features.VMPort = nil
+		}
+	} else {
+		featurematch = false
+	}
+	// screwit, if all three of those match just erase
+	// this. not sure what uses it anyway but it's probably obscure
+	// and I'm not using it on any of my machines right now
+	// also, this is dumb that I'm doing this but I want to
+	// fine tooth comb through this right now
+	// also, I don't have a boss so nobody can tell me what to do
+	if featurematch {
+		domcfg.Features = nil
+	}
+
+	// fmt.Printf("Features: %+v\n", domcfg.Features)
+
+	// for i, f := range domcfg.Features {
+	// 	fmt.Printf("Feature: %+v , %+v\n", i, f)
+	// }
+
+	// these should always just be strings?
+	domcfg.Name = ""
+	domcfg.UUID = ""
+
+	// todo: actually check these for anything different
+	domcfg.Memory = nil
+	domcfg.CurrentMemory = nil
+	domcfg.VCPU = nil
+	// is this always "host-passthrough" and "host-model"?
+	// only Fabrice knows :)
+	if domcfg.CPU != nil {
+		switch domcfg.CPU.Mode {
+		case "host-passthrough":
+			domcfg.CPU = nil
+		case "host-model":
+			domcfg.CPU = nil
+		case "custom":
+			fmt.Printf("? CPU: %+v\n", domcfg.CPU)
+			fmt.Printf("? CPU Model: %+v\n", domcfg.CPU.Model)
+			domcfg.CPU = nil
+		default:
+			fmt.Printf("? CPU: %+v\n", domcfg.CPU)
+			fmt.Printf("? CPU Model: %+v\n", domcfg.CPU.Model)
+			fmt.Printf("? CPU Mode: %+v\n", domcfg.CPU.Mode)
+		}
+	}
+
+	// this goes away if SecLabel is zero'd out?
+	//if domcfg.Metadata != nil {
+	//	fmt.Printf("? Metadata: %+v\n", domcfg.Metadata)
+	//}
+	var secnormal bool = true
+	if len(domcfg.SecLabel) != 0 {
+		for _, sec := range domcfg.SecLabel {
+			if sec.Model == "apparmor" {
+				// this should be configured in dom0
+			} else {
+				fmt.Printf("? SecLabel: %+v\n", sec)
+				fmt.Printf("? SecLabel.Model: %+v\n", sec.Model)
+				secnormal = false
+			}
+		}
+	}
+	if secnormal {
+		domcfg.SecLabel = nil
+	}
+
+	// this will move elsewhere in the protobuf someday
+	// ignore all these for now
+	if domcfg.OnPoweroff != "" { // normally "destroy"
+		domcfg.OnPoweroff = ""
+	}
+	if domcfg.OnCrash != "" { // normally "restart", often "destroy"
+		domcfg.OnCrash = ""
+	}
+	if domcfg.OnReboot != "" { // normally "restart"
+		domcfg.OnReboot = ""
+	}
+	// same with PM. move to protobuf
+	domcfg.PM = nil
+
+	// only keep non-qemu stuff
+	var qemu bool = true
+	for _, disk := range domcfg.Devices.Disks {
+		if disk.Driver.Name != "qemu" {
+			fmt.Printf("- Disk: %s, Device: %s, Source: %s\n", disk.Device, disk.Driver.Name, disk.Source.File.File)
+			fmt.Printf("FOUND NON QEMU DISK\n")
+			fmt.Printf("FOUND NON QEMU DISKS\n")
+			qemu = false
+		} else {
+		}
+	}
+	if qemu {
+		domcfg.Devices.Disks = nil
+	} else {
+		// fmt.Printf("FOUND NON QEMU DISKS\n")
+	}
+
+	// network interfaces get processed elsewhere
+	domcfg.Devices.Interfaces = nil
+
+	// look for strange stuff here
+	var normalPCI bool = true
+	var keepPCI []libvirtxml.DomainController
+	for _, controller := range domcfg.Devices.Controllers {
+		switch controller.Type {
+		case "usb":
+			switch controller.Model {
+			case "ich9-ehci1":
+			case "piix3-uhci":
+			case "qemu-xhci":
+				// fmt.Printf("OK USB: %s, %d\n", controller.Model, *controller.Index)
+			case "ich9-uhci1":
+				// fmt.Printf("OK USB: %s, %d\n", controller.Model, *controller.Index)
+			case "ich9-uhci2":
+				// fmt.Printf("OK USB: %s, %d\n", controller.Model, *controller.Index)
+			case "ich9-uhci3":
+				// fmt.Printf("OK USB: %s, %d\n", controller.Model, *controller.Index)
+			default:
+				keepPCI = append(keepPCI, controller)
+				normalPCI = false
+				fmt.Printf("USB: %s, %d\n", controller.Model, *controller.Index)
+				// Domain:0xc0002d2760 Bus:0xc0002d2768 Slot:0xc0002d2770 Function:0xc0002d2778 MultiFunction:
+				pci := controller.Address.PCI
+				fmt.Printf("USB: Domain: %+v Slot %d Function %d\n", *pci.Domain, *pci.Slot, *pci.Function)
+			}
+		case "ide":
+			// fmt.Printf("IGNORE IDE\n")
+		case "virtio-serial":
+			// fmt.Printf("IGNORE virtio-serial\n")
+		case "sata":
+			// fmt.Printf("SATA: %s, %d\n", controller.Model, *controller.Index)
+			// fmt.Printf("SATA: %+v\n", controller)
+		case "scsi":
+			switch controller.Model {
+			case "lsilogic":
+				// fmt.Printf("IGNORE SCSI: lsilogic\n")
+			default:
+				keepPCI = append(keepPCI, controller)
+				normalPCI = false
+			}
+		case "pci":
+			// these are the strings I've found so far
+			switch controller.Model {
+			case "pci-root":
+			case "pcie-root":
+			case "pcie-root-port":
+			case "pcie-to-pci-bridge":
+			default:
+				fmt.Printf("PCI: %s, %d\n", controller.Model, *controller.Index)
+				// Domain:0xc0002d2760 Bus:0xc0002d2768 Slot:0xc0002d2770 Function:0xc0002d2778 MultiFunction:
+				if controller.Address == nil {
+					fmt.Printf("PCI: controller.Address = nil\n")
+				} else {
+					pci := controller.Address.PCI
+					fmt.Printf("PCI: Domain: %+v Slot %d Function %d\n", *pci.Domain, *pci.Slot, *pci.Function)
+				}
+				normalPCI = false
+				keepPCI = append(keepPCI, controller)
+			}
+		default:
+			fmt.Printf("? controllerType: %s: %+v\n", controller.Type, controller)
+			normalPCI = false
+			keepPCI = append(keepPCI, controller)
+		}
+	}
+	if normalPCI {
+		domcfg.Devices.Controllers = nil
+	} else {
+		domcfg.Devices.Controllers = keepPCI
+	}
+
+	// ignore serial and console
+	domcfg.Devices.Serials = nil
+	domcfg.Devices.Consoles = nil
+
+	// ignore sound
+	domcfg.Devices.Sounds = nil
+
+	// ignore input
+	domcfg.Devices.Inputs = nil
+
+	// ignore MemoryBalloon. This is cool, but no mortal humans
+	// are going to use it at this point. By that I mean me.
+	// someday this will be in protobuf?
+	domcfg.Devices.MemBalloon = nil
+
+	if domcfg.Devices.Emulator == "/usr/bin/qemu-system-x86_64" {
+		domcfg.Devices.Emulator = ""
+	}
+
+	// ignore Graphics == Spice when AutoPort = 'yes'
+	var normalSpice bool = true
+	if domcfg.Devices.Graphics != nil {
+		for i, g := range domcfg.Devices.Graphics {
+			if g.VNC != nil {
+				// ignore vnc settings
+				// fmt.Printf("Ignore Graphics VNC settings: %d %+v\n", i, g)
+				continue
+			}
+			if g.Spice != nil {
+				// this is all moved to updateDroplet()
+				// this is a spice definition, just ignore it
+				// because port mappings and network access will be handled
+				// somewhere else someday
+				// fmt.Printf("Graphics: %d %+v\n", i, g)
+				var s *libvirtxml.DomainGraphicSpice
+				s = g.Spice
+				// fmt.Printf("Spice: %d %+v %s\n", i, s, s.AutoPort)
+				if s.AutoPort == "yes" {
+					// should ignore either way
+				} else {
+					// print out, but ignore the port number
+					// fmt.Printf("Spice Port = %d\n", s.Port)
+				}
+				continue
+			}
+			// figure out what to do with non-spice stuff
+			fmt.Printf("Unknown Graphics: %d %+v\n", i, g)
+			normalSpice = false
+		}
+	}
+	if normalSpice {
+		domcfg.Devices.Graphics = nil
+	}
+
+	// blank out emulator. should be in dom0
+	switch domcfg.Devices.Emulator {
+	case "":
+		domcfg.Devices.Emulator = ""
+	case "/usr/bin/kvm":
+		domcfg.Devices.Emulator = ""
+	case "/usr/bin/kvm-spice":
+		domcfg.Devices.Emulator = ""
+	default:
+		fmt.Printf("Unknown Emulator: %s\n", domcfg.Devices.Emulator)
+	}
+
+	// ignore Channels == SpiceVMC
+	normalSpice = true
+	if domcfg.Devices.Channels != nil {
+		for _, c := range domcfg.Devices.Channels {
+			if c.Source != nil {
+				s := c.Source
+				if s != nil {
+					// fmt.Printf("Channels: %+v\n", s.SpiceVMC)
+				} else {
+					fmt.Printf("? Channels: %+v\n", c)
+					normalSpice = false
+				}
+			} else {
+				fmt.Printf("? Channels: %+v\n", c)
+				normalSpice = false
+			}
+		}
+	}
+	if normalSpice {
+		domcfg.Devices.Channels = nil
+	}
+
+	// this is probably for spice to have keyboard and mouse input
+	normalSpice = true
+	if domcfg.Devices.RedirDevs != nil {
+		for _, c := range domcfg.Devices.RedirDevs {
+			s := c.Source
+			if s != nil {
+				if s.SpiceVMC != nil {
+					// this is the normal USB redirection (I guess)
+				} else {
+					normalSpice = false
+				}
+			} else {
+				normalSpice = false
+			}
+			// fmt.Printf("? RedirDevs: %+v\n", c)
+			// fmt.Printf("? RedirDevs Source: %+v\n", s)
+			// fmt.Printf("? RedirDevs SpiceVMC: %d\n", *s.SpiceVMC)
+			// fmt.Printf("? RedirDevs Address: %+v\n", c.Address)
+			// fmt.Printf("? RedirDevs USB: %+v\n", c.Address.USB)
+		}
+	}
+	if normalSpice {
+		domcfg.Devices.RedirDevs = nil
+	}
+
+	var normalRNGs bool = true
+	if domcfg.Devices.RNGs != nil {
+		for _, rng := range domcfg.Devices.RNGs {
+			if rng.Model == "virtio" {
+				// nothing to do for this
+			} else {
+				fmt.Printf("? RNGs: %+v\n", rng)
+				normalRNGs = false
+			}
+		}
+	}
+	if normalRNGs {
+		domcfg.Devices.RNGs = nil
+	}
+
+	// don't copy this over here yet.
+	// probably most domU's don't really use/need it set to what is in the XML
+	var normalVideo bool = true
+	if domcfg.Devices.Videos != nil {
+		for _, v := range domcfg.Devices.Videos {
+			switch v.Model.Type {
+			case "qxl":
+				if v.Model.VRam == 65536 {
+					// standard qxl video
+				} else {
+					fmt.Printf("? Video: %+v\n", v)
+					fmt.Printf("? Video Model: %+v\n", v.Model)
+					normalVideo = false
+				}
+			case "cirrus":
+			case "virtio":
+				// this should always be standard
+				//fmt.Printf("? Video: %+v\n", v)
+				//fmt.Printf("? Video Model: %+v\n", v.Model)
+				//fmt.Printf("? Video Address: %+v\n", v.Address)
+				//fmt.Printf("? Video PCI: %+v\n", v.Address.PCI)
+			default:
+				fmt.Printf("? Video: %+v\n", v)
+				fmt.Printf("? Video Model: %+v\n", v.Model)
+				normalVideo = false
+			}
+		}
+	}
+	if normalVideo {
+		domcfg.Devices.Videos = nil
+	}
+
+	// dumpLibvirtxmlDomainNames()
+	if libvirtxmlDomainDevicesEmpty(*domcfg.Devices) {
+		// fmt.Println("Domain Devices are empty")
+		domcfg.Devices = nil
+	} else {
+		fmt.Println("Domain Devices are not empty")
+	}
+
+	if libvirtxmlDomainEmpty(*domcfg) {
+		// fmt.Println("Domain Devices are empty")
+		domcfg = nil
+	} else {
+		fmt.Println("Domain is not yet empty")
+	}
+
+	updatedXML, err := xml.MarshalIndent(domcfg, "", "  ")
+	if err != nil {
+		fmt.Printf("Failed to marshal updated XML: %v\n", err)
+		os.Exit(-1)
+	}
+
+	// Print the updated XML to verify
+	fmt.Println(string(updatedXML))
+	// os.Exit(-1)
+}
+
+// dump out all the fields in libvirtxml.DomainDeviceList
+func dumpLibvirtxmlDomainNames() {
+	var domain libvirtxml.Domain
+	t := reflect.TypeOf(domain)
+
+	fmt.Println("Fields in libvirtxml.Domain:")
+	for i := 0; i < t.NumField(); i++ {
+		field := t.Field(i)
+		fmt.Println("Domain:", field.Name)
+	}
+
+	var device libvirtxml.DomainDeviceList
+	t = reflect.TypeOf(device)
+
+	fmt.Println("Fields in libvirtxml.DomainDeviceList:")
+	for i := 0; i < t.NumField(); i++ {
+		field := t.Field(i)
+		fmt.Println("DomainDeviceList:", field.Name)
+	}
+
+	var iface libvirtxml.DomainInterface
+	t = reflect.TypeOf(iface)
+
+	fmt.Println("Fields in libvirtxml.DomainInterface:")
+	for i := 0; i < t.NumField(); i++ {
+		field := t.Field(i)
+		fmt.Println("DomainInterface:", field.Name)
+	}
+}
+
+// dump out all the fields in libvirtxml.DomainDeviceList
+func libvirtxmlDomainDevicesEmpty(mydom libvirtxml.DomainDeviceList) bool {
+	var empty bool = true
+	// Get the reflection object of the variable
+	v := reflect.ValueOf(mydom)
+
+	// Ensure that we are working with a struct
+	if v.Kind() == reflect.Struct {
+		// fmt.Println("Fields and values in libvirtxml.DomainDeviceList:")
+
+		// Loop through each field in the struct
+		for i := 0; i < v.NumField(); i++ {
+			// Get field name
+			field := v.Type().Field(i).Name
+
+			// Get field value
+			value := v.Field(i)
+
+			if !value.IsValid() {
+				fmt.Printf("Field: %s is nil or invalid\n", field)
+				continue
+			}
+
+			// Check if the field is a string, array, or slice
+			switch value.Kind() {
+			case reflect.String:
+				if value.String() != "" {
+					fmt.Printf("Field: %s is a String with value: %s\n", field, value.String())
+					empty = false
+				}
+			case reflect.Slice:
+				if value.Len() != 0 {
+					fmt.Printf("Field: %s is a Slice with length: %d\n", field, value.Len())
+					empty = false
+				}
+			case reflect.Array:
+				if value.Len() != 0 {
+					fmt.Printf("Field: %s is an Array with length: %d\n", field, value.Len())
+					empty = false
+				}
+			case reflect.Ptr:
+				if !value.IsValid() {
+					fmt.Println("Field ptr: value:", value)
+					fmt.Printf("Field ptr: %s is of type: %s\n", field, value.Kind())
+					empty = false
+				}
+			default:
+				fmt.Printf("Field: %s is of type: %s\n", field, value.Kind())
+				empty = false
+			}
+			// Print the field name and value
+			// fmt.Printf("Field: %s, Value: %v\n", field, value)
+		}
+	} else {
+		fmt.Println("Provided variable is not a struct.")
+	}
+	return empty
+}
+
+// dump out all the fields in libvirtxml.DomainDeviceList
+func libvirtxmlDomainEmpty(mydom libvirtxml.Domain) bool {
+	var empty bool = true
+	// Get the reflection object of the variable
+	v := reflect.ValueOf(mydom)
+
+	// Ensure that we are working with a struct
+	if v.Kind() == reflect.Struct {
+		// fmt.Println("Fields and values in libvirtxml.DomainDeviceList:")
+
+		// Loop through each field in the struct
+		for i := 0; i < v.NumField(); i++ {
+			// Get field name
+			field := v.Type().Field(i).Name
+
+			// Get field value
+			value := v.Field(i)
+
+			if !value.IsValid() {
+				fmt.Printf("Field: %s is nil or invalid\n", field)
+				continue
+			}
+			if (field == "IOThreads") || (field == "XMLName") {
+				continue
+			}
+
+			// Check if the field is a string, array, or slice
+			switch value.Kind() {
+			case reflect.String:
+				if value.String() != "" {
+					fmt.Printf("Field: %s is a String with value: %s\n", field, value.String())
+					empty = false
+				}
+			case reflect.Slice:
+				if value.Len() != 0 {
+					fmt.Printf("Field: %s is a Slice with length: %d\n", field, value.Len())
+					empty = false
+				}
+			case reflect.Array:
+				if value.Len() != 0 {
+					fmt.Printf("Field: %s is an Array with length: %d\n", field, value.Len())
+					empty = false
+				}
+			case reflect.Ptr:
+				if !value.IsValid() {
+					fmt.Println("Field ptr: value:", value)
+					fmt.Printf("Field ptr: %s is of type: %s\n", field, value.Kind())
+					empty = false
+				}
+			default:
+				fmt.Printf("Field: %s is of type: %s\n", field, value.Kind())
+				empty = false
+			}
+			// Print the field name and value
+			// fmt.Printf("Field: %s, Value: %v\n", field, value)
+		}
+	} else {
+		fmt.Println("Provided variable is not a struct.")
+	}
+	return empty
+}