topology-map/internal/cache/datacache.go

package cache

import (
	"sync"

	"git.faercol.me/faercol/topology-map/internal/models"
)

func NewDataCache() *DataCache {
	return &DataCache{
		lock:         sync.Mutex{},
		devices:      make(map[int]*models.Device),
		interfaces:   make(map[int]*models.Interface),
		cables:       make(map[int]*models.Cable),
		vms:          make(map[int]*models.VM),
		vmInterfaces: make(map[int]*models.VMInterface),
	}
}

type DataCache struct {
	lock         sync.Mutex
	devices      map[int]*models.Device
	interfaces   map[int]*models.Interface
	cables       map[int]*models.Cable
	vms          map[int]*models.VM
	arpRecords   []*models.ARPRecord
	vmInterfaces map[int]*models.VMInterface
}

func (d *DataCache) AddDevice(device models.Device) {
	d.lock.Lock()
	defer d.lock.Unlock()
	d.devices[device.ID] = &device
}

func (d *DataCache) GetDevices() []*models.Device {
	d.lock.Lock()
	defer d.lock.Unlock()

	var res []*models.Device
	for _, dev := range d.devices {
		res = append(res, dev)
	}
	return res
}

func (d *DataCache) AddInterface(iface models.Interface) {
	d.lock.Lock()
	defer d.lock.Unlock()
	d.interfaces[iface.ID] = &iface
}

func (d *DataCache) GetInterfaces() []*models.Interface {
	d.lock.Lock()
	defer d.lock.Unlock()

	var res []*models.Interface
	for _, iface := range d.interfaces {
		res = append(res, iface)
	}
	return res
}

func (d *DataCache) AddCable(cable models.Cable) {
	d.lock.Lock()
	defer d.lock.Unlock()
	d.cables[cable.ID] = &cable
}

func (d *DataCache) GetCables() []*models.Cable {
	d.lock.Lock()
	defer d.lock.Unlock()

	var res []*models.Cable
	for _, cable := range d.cables {
		res = append(res, cable)
	}
	return res
}

func (d *DataCache) AddVM(vm models.VM) {
	d.lock.Lock()
	defer d.lock.Unlock()
	d.vms[vm.ID] = &vm
}

func (d *DataCache) GetVMs() []*models.VM {
	d.lock.Lock()
	defer d.lock.Unlock()

	var res []*models.VM
	for _, vm := range d.vms {
		res = append(res, vm)
	}
	return res
}

func (d *DataCache) AddARPRecords(records []*models.ARPRecord) {
	d.lock.Lock()
	defer d.lock.Unlock()

	d.arpRecords = records
}

func (d *DataCache) ReconcileData() {
	d.lock.Lock()
	defer d.lock.Unlock()

	for id, cable := range d.cables {
		ifaceA, ok := d.interfaces[cable.ATerminations[0].ObjectID]
		if !ok {
			continue
		}
		cable.ATerminations[0].Object.Interface = *ifaceA

		ifaceB, ok := d.interfaces[cable.BTerminations[0].ObjectID]
		if !ok {
			continue
		}
		cable.BTerminations[0].Object.Interface = *ifaceB

		d.cables[id] = cable
	}

	for _, r := range d.arpRecords {
		for _, iif := range d.interfaces {
			if r.MacAddress == iif.MacAddress {
				r.Device = &iif.Device
				break
			}
		}
		for _, iif := range d.vmInterfaces {
			if r.MacAddress == iif.MacAddress {
				r.VM = &iif.VM
				break
			}
		}
	}
}

func (d *DataCache) GetUnmonitoredMachines() []models.UnmonitoredDevice {
	d.lock.Lock()
	defer d.lock.Unlock()

	var res []models.UnmonitoredDevice

	for _, r := range d.arpRecords {
		if r.Device == nil && r.VM == nil {
			res = append(res, models.UnmonitoredDevice{Address: r.Address, MacAddress: r.MacAddress})
		}
	}

	return res
}

func (d *DataCache) AddVMInterface(iface models.VMInterface) {
	d.lock.Lock()
	defer d.lock.Unlock()

	d.vmInterfaces[iface.ID] = &iface
}

func (d *DataCache) GetVMInterfaces() []*models.VMInterface {
	d.lock.Lock()
	defer d.lock.Unlock()

	res := []*models.VMInterface{}
	for _, iif := range d.vmInterfaces {
		res = append(res, iif)
	}
	return res
}