You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
virt/agent/hypervisor/traffic_store_test.go

313 lines
9.8 KiB
Go

package hypervisor
import (
"encoding/json"
"os"
"path/filepath"
"sync"
"testing"
"time"
)
func TestTrafficStorePersistsDeltasAndHandlesCounterReset(t *testing.T) {
path := filepath.Join(t.TempDir(), "traffic.json")
store, err := openTrafficStore(path)
if err != nil {
t.Fatal(err)
}
now := time.Date(2026, 10, 15, 12, 0, 0, 0, time.UTC)
rx, tx, err := store.observe("vm-1", now, availableTrafficObservation(1000, 2000))
if err != nil || rx != 0 || tx != 0 {
t.Fatalf("baseline = %d/%d err=%v", rx, tx, err)
}
rx, tx, err = store.observe("vm-1", now.Add(time.Minute), availableTrafficObservation(1300, 2600))
if err != nil || rx != 300 || tx != 600 {
t.Fatalf("delta = %d/%d err=%v", rx, tx, err)
}
rx, tx, err = store.observe("vm-1", now.Add(2*time.Minute), availableTrafficObservation(40, 70))
if err != nil || rx != 340 || tx != 670 {
t.Fatalf("post-reset = %d/%d err=%v", rx, tx, err)
}
reopened, err := openTrafficStore(path)
if err != nil {
t.Fatal(err)
}
rx, tx, err = reopened.observe("vm-1", now.Add(3*time.Minute), availableTrafficObservation(90, 120))
if err != nil || rx != 390 || tx != 720 {
t.Fatalf("post-restart = %d/%d err=%v", rx, tx, err)
}
}
func TestTrafficStoreMigratesV1DailyBucketsWithoutLosingTotals(t *testing.T) {
path := filepath.Join(t.TempDir(), "traffic.json")
now := time.Date(2026, 10, 15, 12, 0, 0, 0, time.UTC)
legacy := map[string]any{
"version": legacyTrafficStateVersion,
"vms": map[string]any{
"vm-legacy": map[string]any{
// Earliest v1 files used only the combined initialization bit.
"initialized": true,
"last_observed_unix_nano": now.UnixNano(),
"last_rx": 1400, "last_tx": 2500,
"total_rx": 7000, "total_tx": 9000,
"days": map[string]any{
"2026-10-15": map[string]any{
"date": "2026-10-15", "rx_bytes": 400,
"tx_bytes": 500,
},
},
},
},
}
encoded, err := json.Marshal(legacy)
if err != nil {
t.Fatal(err)
}
if err := os.WriteFile(path, encoded, 0o600); err != nil {
t.Fatal(err)
}
store, err := openTrafficStore(path)
if err != nil {
t.Fatal(err)
}
contents, err := os.ReadFile(path)
if err != nil {
t.Fatal(err)
}
var persisted struct {
Version int `json:"version"`
VMs map[string]map[string]json.RawMessage `json:"vms"`
}
if err := json.Unmarshal(contents, &persisted); err != nil {
t.Fatal(err)
}
if persisted.Version != trafficStateVersion {
t.Fatalf("traffic state version = %d", persisted.Version)
}
if _, exists := persisted.VMs["vm-legacy"]["days"]; exists {
t.Fatalf("legacy daily buckets survived migration: %s", contents)
}
rx, tx, err := store.observe(
"vm-legacy", now.Add(time.Minute), availableTrafficObservation(1500, 2600),
)
if err != nil || rx != 7100 || tx != 9100 {
t.Fatalf("post-migration sample = %d/%d err=%v", rx, tx, err)
}
reopened, err := openTrafficStore(path)
if err != nil {
t.Fatal(err)
}
rx, tx, err = reopened.observe(
"vm-legacy", now.Add(2*time.Minute), availableTrafficObservation(1600, 2800),
)
if err != nil || rx != 7200 || tx != 9300 {
t.Fatalf("v2 restart sample = %d/%d err=%v", rx, tx, err)
}
}
func TestTrafficStoreCreateBaselineCountsFirstObservation(t *testing.T) {
store, err := openTrafficStore(filepath.Join(t.TempDir(), "traffic.json"))
if err != nil {
t.Fatal(err)
}
now := time.Date(2026, 10, 15, 12, 0, 0, 0, time.UTC)
created, err := store.initialize("vm-new", now)
if err != nil || !created {
t.Fatalf("initialize created=%v err=%v", created, err)
}
rx, tx, err := store.observe("vm-new", now.Add(time.Minute), availableTrafficObservation(1000, 2000))
if err != nil || rx != 1000 || tx != 2000 {
t.Fatalf("first created-VM sample = %d/%d err=%v", rx, tx, err)
}
reopened, err := openTrafficStore(store.path)
if err != nil {
t.Fatal(err)
}
rx, tx, err = reopened.observe("vm-new", now.Add(2*time.Minute), availableTrafficObservation(1100, 2200))
if err != nil || rx != 1100 || tx != 2200 {
t.Fatalf("post-restart sample = %d/%d err=%v", rx, tx, err)
}
}
func TestTrafficStoreFileLockPreventsCrossProcessLostUpdates(t *testing.T) {
path := filepath.Join(t.TempDir(), "traffic.json")
first, err := openTrafficStore(path)
if err != nil {
t.Fatal(err)
}
second, err := openTrafficStore(path)
if err != nil {
t.Fatal(err)
}
now := time.Date(2026, 10, 19, 12, 0, 0, 0, time.UTC)
start := make(chan struct{})
errors := make(chan error, 2)
go func() {
<-start
_, _, observeErr := first.observe("vm-first", now, availableTrafficObservation(100, 200))
errors <- observeErr
}()
go func() {
<-start
_, _, observeErr := second.observe("vm-second", now, availableTrafficObservation(300, 400))
errors <- observeErr
}()
close(start)
for index := 0; index < 2; index++ {
if err := <-errors; err != nil {
t.Fatal(err)
}
}
reopened, err := openTrafficStore(path)
if err != nil {
t.Fatal(err)
}
if !reopened.contains("vm-first") || !reopened.contains("vm-second") {
t.Fatalf("cross-process update lost: %#v", reopened.entries)
}
}
func TestTrafficStoreProcessesCounterDeltasAcrossWallClockRollback(t *testing.T) {
path := filepath.Join(t.TempDir(), "traffic.json")
store, err := openTrafficStore(path)
if err != nil {
t.Fatal(err)
}
now := time.Date(2026, 10, 15, 12, 0, 0, 0, time.UTC)
if _, err := store.initialize("vm-1", now); err != nil {
t.Fatal(err)
}
if rx, tx, err := store.observe("vm-1", now.Add(2*time.Minute), availableTrafficObservation(1300, 2600)); err != nil || rx != 1300 || tx != 2600 {
t.Fatalf("future-clock sample = %d/%d err=%v", rx, tx, err)
}
reopened, err := openTrafficStore(path)
if err != nil {
t.Fatal(err)
}
rx, tx, err := reopened.observe("vm-1", now.Add(time.Minute), availableTrafficObservation(1400, 2800))
if err != nil || rx != 1400 || tx != 2800 {
t.Fatalf("clock-regressed sample = %d/%d err=%v", rx, tx, err)
}
rx, tx, err = reopened.observe("vm-1", now.Add(time.Minute), availableTrafficObservation(1400, 2800))
if err != nil || rx != 1400 || tx != 2800 {
t.Fatalf("duplicate sample = %d/%d err=%v", rx, tx, err)
}
}
func TestTrafficSampleLockSerializesReadThroughObserve(t *testing.T) {
store, err := openTrafficStore(filepath.Join(t.TempDir(), "traffic.json"))
if err != nil {
t.Fatal(err)
}
now := time.Date(2026, 10, 15, 12, 0, 0, 0, time.UTC)
if _, err := store.initialize("vm-1", now); err != nil {
t.Fatal(err)
}
raw := uint64(1200)
firstHasRead := make(chan struct{})
releaseFirst := make(chan struct{})
secondAttempting := make(chan struct{})
errors := make(chan error, 2)
var wait sync.WaitGroup
wait.Add(2)
go func() {
defer wait.Done()
unlock := store.lockSample("vm-1")
defer unlock()
read := raw
close(firstHasRead)
<-releaseFirst
_, _, observeErr := store.observe(
"vm-1", now.Add(time.Minute), availableTrafficObservation(read, read),
)
errors <- observeErr
}()
<-firstHasRead
raw = 1300
go func() {
defer wait.Done()
close(secondAttempting)
unlock := store.lockSample("vm-1")
defer unlock()
read := raw
_, _, observeErr := store.observe(
"vm-1", now.Add(2*time.Minute), availableTrafficObservation(read, read),
)
errors <- observeErr
}()
<-secondAttempting
close(releaseFirst)
wait.Wait()
close(errors)
for observeErr := range errors {
if observeErr != nil {
t.Fatal(observeErr)
}
}
rx, tx, err := store.observe(
"vm-1", now.Add(3*time.Minute), availableTrafficObservation(1400, 1400),
)
if err != nil || rx != 1400 || tx != 1400 {
t.Fatalf("serialized samples = %d/%d err=%v", rx, tx, err)
}
}
func TestTrafficStoreUnavailableDirectionDoesNotResetBaseline(t *testing.T) {
store, err := openTrafficStore(filepath.Join(t.TempDir(), "traffic.json"))
if err != nil {
t.Fatal(err)
}
now := time.Date(2026, 10, 15, 12, 0, 0, 0, time.UTC)
if _, err := store.initialize("vm-1", now); err != nil {
t.Fatal(err)
}
if _, _, err := store.observe("vm-1", now.Add(time.Minute), availableTrafficObservation(100, 200)); err != nil {
t.Fatal(err)
}
rx, tx, err := store.observe("vm-1", now.Add(2*time.Minute), trafficObservation{
TXBytes: 250, TXAvailable: true,
})
if err != nil || rx != 100 || tx != 250 {
t.Fatalf("partial unavailable sample = %d/%d err=%v", rx, tx, err)
}
rx, tx, err = store.observe("vm-1", now.Add(3*time.Minute), availableTrafficObservation(130, 270))
if err != nil || rx != 130 || tx != 270 {
t.Fatalf("recovered sample reset a baseline: %d/%d err=%v", rx, tx, err)
}
}
func TestAggregateInterfaceTrafficRequiresEveryField(t *testing.T) {
complete := aggregateInterfaceTraffic([]interfaceTrafficSample{
{TargetAvailable: true, RXSet: true, RXBytes: 100, TXSet: true, TXBytes: 200},
{TargetAvailable: true, RXSet: true, RXBytes: 30, TXSet: true, TXBytes: 40},
})
if !complete.RXAvailable || !complete.TXAvailable || complete.RXBytes != 130 || complete.TXBytes != 240 {
t.Fatalf("complete aggregate = %#v", complete)
}
partial := aggregateInterfaceTraffic([]interfaceTrafficSample{
{TargetAvailable: true, RXSet: true, RXBytes: -1, TXSet: true, TXBytes: 200},
})
if partial.RXAvailable || !partial.TXAvailable || partial.TXBytes != 200 {
t.Fatalf("negative field aggregate = %#v", partial)
}
missingTarget := aggregateInterfaceTraffic([]interfaceTrafficSample{
{TargetAvailable: true, RXSet: true, RXBytes: 100, TXSet: true, TXBytes: 200},
{},
})
if missingTarget.RXAvailable || missingTarget.TXAvailable {
t.Fatalf("missing target aggregate = %#v", missingTarget)
}
missingFields := aggregateInterfaceTraffic([]interfaceTrafficSample{
{TargetAvailable: true},
})
if missingFields.RXAvailable || missingFields.TXAvailable {
t.Fatalf("missing stat fields aggregate = %#v", missingFields)
}
}
func TestTrafficStoreRejectsRelativePath(t *testing.T) {
if _, err := openTrafficStore("traffic.json"); err == nil {
t.Fatal("relative traffic path was accepted")
}
}