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.
313 lines
9.8 KiB
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")
|
|
}
|
|
}
|