path: root/addDroplet.go

// Copyright 2024 WIT.COM Inc Licensed GPL 3.0

package main

import (
	"encoding/xml"
	"errors"
	"fmt"
	"os"

	pb "go.wit.com/lib/protobuf/virtbuf"
	"go.wit.com/log"
	"libvirt.org/go/libvirtxml"
)

// import a libvirt xml file
func addDomainDroplet(domcfg *libvirtxml.Domain) (*DropletT, error) {
	if domcfg == nil {
		return nil, errors.New("domcfg == nil")
	}

	d, _ := findDomain(domcfg)
	if d != nil {
		return d, errors.New(d.pb.Hostname + " droplet exists. need to update instead")
	}
	// this is a new unknown droplet (not in the config file)
	d = new(DropletT)

	d.pb = me.cluster.AddDroplet(domcfg.UUID, domcfg.Name, 2, 2*1024*1024)
	d.pb.StartState = "off"

	me.droplets = append(me.droplets, d)
	me.changed = true

	if updateDroplet(d, domcfg) {
		if me.changed {
			log.Info("updateDroplet() worked. droplet changed")
		} else {
			log.Verbose("updateDroplet() worked. nothing changed")
		}
	} else {
		log.Info("updateDroplet() failed for", d.pb.Hostname)
		return d, errors.New("update failed for " + domcfg.Name)
	}
	log.Info("added new droplet", domcfg.Name, domcfg.UUID)

	// Add more parts you are interested in
	fmt.Printf("CPU Model: %+v\n", domcfg.CPU)

	// 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)
	}

	// 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.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

	// clear out this crap
	if domcfg.OnPoweroff == "destroy" {
		domcfg.OnPoweroff = ""
	}
	if domcfg.OnCrash == "destroy" {
		domcfg.OnCrash = ""
	}
	if domcfg.OnReboot == "restart" {
		domcfg.OnReboot = ""
	}

	// 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")
	}

	domcfg.Devices.Interfaces = nil
	for _, iface := range domcfg.Devices.Interfaces {
		fmt.Printf("- Network Interface: %+v\n", iface)
	}
	for _, controller := range domcfg.Devices.Controllers {
		fmt.Printf("- Controller: Type: %s, Index: %d\n", controller.Type, controller.Index)
	}

	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)
	return d, nil
}

func findDomain(domcfg *libvirtxml.Domain) (*DropletT, error) {
	var found *DropletT
	if domcfg == nil {
		return nil, errors.New("domcfg == nil")
	}

	for _, d := range me.droplets {
		if d.pb.Hostname == domcfg.Name {
			if d.pb.Uuid != domcfg.UUID {
				fmt.Println("CHANGED UUID", d.pb.Uuid, domcfg.UUID)
				d.pb.Uuid = domcfg.UUID
				me.changed = true
			}
			if found == nil {
				found = d
			} else {
				fmt.Println("FOUND TWICE", d.pb.Uuid, domcfg.Name, domcfg.UUID)
				return d, errors.New("Found Twice")
			}

		}
		if d.pb.Uuid == domcfg.UUID {
			if d.pb.Hostname != domcfg.Name {
				fmt.Println("FOUND UUID WITH MIS-MATCHED NAME", domcfg.Name, domcfg.UUID)
				return d, errors.New("UUID with mis-matched names")
			}
		}
	}

	return found, nil
}

func updateDroplet(d *DropletT, domcfg *libvirtxml.Domain) bool {
	var ok bool = true

	if d == nil {
		return false
	}
	if domcfg == nil {
		return false
	}

	if !updateMemory(d, domcfg) {
		log.Info("updateMemory() failed")
		ok = false
	}

	// check cpus
	if d.pb.Cpus != int64(domcfg.VCPU.Value) {
		// fmt.Printf("cpus changed. VCPU = %+v\n", domcfg.VCPU)
		fmt.Printf("cpus changed. from %d to %d\n", d.pb.Cpus, domcfg.VCPU.Value)
		d.pb.Cpus = int64(domcfg.VCPU.Value)
		me.changed = true
	}

	// check type
	if domcfg.Type != "kvm" {
		fmt.Printf("not kvm. Virt type == %s\n", domcfg.Type)
		ok = false
	}

	if !updateNetwork(d, domcfg) {
		log.Info("updateNetwork() failed")
		ok = false
	}

	if !updateDisk(d, domcfg) {
		log.Info("updateDisk() failed")
		ok = false
	}
	return ok
}

// returns false if something went wrong
func updateMemory(d *DropletT, domcfg *libvirtxml.Domain) bool {
	if (d == nil) || (domcfg == nil) {
		return false
	}

	// check memory
	if domcfg.Memory.Unit == "KiB" {
		var m int64
		m = int64(domcfg.Memory.Value * 1024)
		if d.pb.Memory != m {
			d.pb.Memory = m
			me.changed = true
			fmt.Printf("Memory changed %s to %d %s\n", pb.HumanFormatBytes(d.pb.Memory), domcfg.Memory.Value, domcfg.Memory.Unit)
		}
		return true
	}

	if domcfg.Memory.Unit == "MiB" {
		var m int64
		m = int64(domcfg.Memory.Value * 1024 * 1024)
		if d.pb.Memory != m {
			d.pb.Memory = m
			me.changed = true
			fmt.Printf("Memory changed %s to %d %s\n", pb.HumanFormatBytes(d.pb.Memory), domcfg.Memory.Value, domcfg.Memory.Unit)
		}
		return true
	}

	if domcfg.Memory.Unit == "GiB" {
		var m int64
		m = int64(domcfg.Memory.Value * 1024 * 1024 * 1024)
		if d.pb.Memory != m {
			d.pb.Memory = m
			me.changed = true
			fmt.Printf("Memory changed %d, %d %s\n", pb.HumanFormatBytes(d.pb.Memory), domcfg.Memory.Value, domcfg.Memory.Unit)
		}
		return true
	}
	fmt.Println("Unknown Memory Unit", domcfg.Memory.Unit)
	return false
}

// returns false if something went wrong
func updateNetwork(d *DropletT, domcfg *libvirtxml.Domain) bool {
	if (d == nil) || (domcfg == nil) {
		return false
	}

	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)
			// log.Info("Interface:", iface.Target, "MAC Address:", iface.MAC.Address)
			// fmt.Printf("source: %+v\n", iface.Source)
			macs = append(macs, iface.MAC.Address)
		} else {
			fmt.Printf("Interface: %s, MAC Address: not available\n", iface.Target.Dev)
		}
	}

	for _, mac := range macs {
		var found bool = false
		for i, eth := range d.pb.Networks {
			if eth.Mac == mac {
				log.Verbose("OKAY. FOUND ETH:", i, eth.Mac, eth.Name)
				found = true
			}
		}
		if !found {
			var eth *pb.Network
			eth = new(pb.Network)
			eth.Mac = mac
			eth.Name = "worldbr"
			d.pb.Networks = append(d.pb.Networks, eth)
			me.changed = true
		}
	}

	log.Verbose("mac addrs:", macs)
	return true
}

// returns false if something went wrong
func updateDisk(d *DropletT, domcfg *libvirtxml.Domain) bool {
	if (d == nil) || (domcfg == nil) {
		return false
	}
	for _, disk := range domcfg.Devices.Disks {
		var t *libvirtxml.DomainDiskSourceFile
		t = disk.Source.File
		filename := t.File
		if filename == "" {
			fmt.Println("No disk source file found.")
			continue
		}

		var found bool = false
		for _, disk := range d.pb.Disks {
			if disk.Filename == filename {
				log.Verbose("OKAY. FOUND filename", filename)
				found = true
			}
		}
		if !found {
			var disk *pb.Disk
			disk = new(pb.Disk)
			disk.Filename = filename
			d.pb.Disks = append(d.pb.Disks, disk)
			log.Info("New filename", filename)
			me.changed = true
		}
	}
	return true
}