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.
381 lines
13 KiB
Go
381 lines
13 KiB
Go
//go:build libvirt
|
|
|
|
package hypervisor
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"testing"
|
|
|
|
"git.luoli.live/root/virt/agent/cloudinit"
|
|
"git.luoli.live/root/virt/agent/operation"
|
|
"git.luoli.live/root/virt/agent/publicnetwork"
|
|
"libvirt.org/go/libvirtxml"
|
|
)
|
|
|
|
type createLikeNetworkEvidenceFixture struct {
|
|
record operation.Record
|
|
definition *libvirtxml.Domain
|
|
metadata *domainMetadataXML
|
|
seed []byte
|
|
}
|
|
|
|
func newCreateLikeNetworkEvidenceFixture(t *testing.T,
|
|
withVPC bool) createLikeNetworkEvidenceFixture {
|
|
t.Helper()
|
|
definition := validDomainDefinition()
|
|
definition.Network[0].MAC = vmMACAddress(definition.UUID)
|
|
var port *VPCPortMetadata
|
|
if withVPC {
|
|
value := validVPCPortMetadata()
|
|
port = &value
|
|
definition.VPCPort = port
|
|
definition.Network = append(definition.Network, NetworkAttachment{
|
|
Bridge: port.Bridge, MAC: port.MAC,
|
|
})
|
|
}
|
|
document, err := BuildDomainXML(definition)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
parsed, metadata, err := parseManagedDomain(document)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
seed := buildCreateLikeNetworkSeed(
|
|
t, definition.UUID, definition.PublicNetwork,
|
|
definition.Network[0].MAC, port,
|
|
)
|
|
source, err := ParseNetworkSelector(definition.PublicNetwork.NetworkSelector)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
expected := &operation.ExpectedState{
|
|
Kind: operation.ExpectedCreateLikeNetwork,
|
|
TransitionID: "operation-create-like-network-evidence",
|
|
NetworkSourceType: source.Type, NetworkSourceName: source.Source,
|
|
PublicNetwork: definition.PublicNetwork,
|
|
VPCPresent: port != nil,
|
|
}
|
|
if port != nil {
|
|
expected.VPCKey = port.VPCKey
|
|
expected.VPCRevision = port.HostRevision
|
|
expected.VPCDigest = port.HostDigest
|
|
expected.VPCPortKey = port.PortKey
|
|
expected.VPCCIDR = port.CIDR
|
|
expected.VPCGateway = port.Gateway
|
|
expected.VPCPrivateIP = port.PrivateIP
|
|
expected.VPCMAC = port.MAC
|
|
expected.VPCBridge = port.Bridge
|
|
}
|
|
return createLikeNetworkEvidenceFixture{
|
|
record: operation.Record{
|
|
OperationID: expected.TransitionID,
|
|
ResourceID: definition.UUID,
|
|
Action: "receive-peer-migration:0123456789abcdef0123456789abcdef",
|
|
ExpectedState: expected,
|
|
},
|
|
definition: parsed, metadata: metadata, seed: seed,
|
|
}
|
|
}
|
|
|
|
func buildCreateLikeNetworkSeed(t *testing.T, uuid string,
|
|
public publicnetwork.Intent, mac string, port *VPCPortMetadata) []byte {
|
|
t.Helper()
|
|
var private *cloudinit.PrivateNetwork
|
|
if port != nil {
|
|
private = &cloudinit.PrivateNetwork{
|
|
MAC: port.MAC, PrivateIP: port.PrivateIP,
|
|
CIDR: port.CIDR, Gateway: port.Gateway,
|
|
InterfaceKey: seedVPCInterfaceKey,
|
|
}
|
|
}
|
|
image, err := cloudinit.BuildISO(cloudinit.Request{
|
|
UUID: uuid, Name: "vm-create-like", PreserveGuestCredentials: true,
|
|
Network: cloudinit.Network{
|
|
MAC: mac, Public: public, InterfaceKey: seedPublicInterfaceKey,
|
|
Private: private,
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return image
|
|
}
|
|
|
|
func TestCreateLikeNetworkEvidenceRequiresExactDualStackIdentity(t *testing.T) {
|
|
for _, withVPC := range []bool{false, true} {
|
|
fixture := newCreateLikeNetworkEvidenceFixture(t, withVPC)
|
|
if !createLikeNetworkEvidenceMatches(
|
|
fixture.record, fixture.definition, fixture.metadata, fixture.seed,
|
|
) {
|
|
t.Fatalf("exact create-like network evidence rejected (VPC=%v)", withVPC)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCreateLikeNetworkEvidenceDriftRemainsUnresolved(t *testing.T) {
|
|
tests := map[string]func(*createLikeNetworkEvidenceFixture){
|
|
"transition": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.record.ExpectedState.TransitionID = "operation-other"
|
|
},
|
|
"resource UUID": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.record.ResourceID = "123e4567-e89b-42d3-a456-426614174999"
|
|
},
|
|
"metadata IPv4": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.metadata.PublicNetwork.IPv4.AddressCIDR = "8.8.8.11/24"
|
|
},
|
|
"metadata IPv6": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.metadata.PublicNetwork.IPv6.AddressCIDR = "2404:c140:156:3a::1001/64"
|
|
},
|
|
"metadata DNS": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.metadata.PublicNetwork.DNSServers = []string{"9.9.9.9", "2620:fe::fe"}
|
|
},
|
|
"metadata selector": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.metadata.PublicNetwork.NetworkSelector = "bridge:br1"
|
|
},
|
|
"metadata IPv4 gateway": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.metadata.PublicNetwork.IPv4.Gateway = "8.8.8.2"
|
|
},
|
|
"metadata IPv6 gateway": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.metadata.PublicNetwork.IPv6.Gateway = "2404:c140:156::2"
|
|
},
|
|
"network source": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.definition.Devices.Interfaces[0].Source.Bridge.Bridge = "br1"
|
|
},
|
|
"public MAC": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.definition.Devices.Interfaces[0].MAC.Address = "02:00:00:00:00:44"
|
|
},
|
|
"nwfilter IPv4": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.definition.Devices.Interfaces[0].FilterRef.Parameters[0].Value = "8.8.8.11"
|
|
},
|
|
"nwfilter IPv6": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.definition.Devices.Interfaces[0].FilterRef.Parameters[1].Value = "2404:c140:156:3a::1001"
|
|
},
|
|
"nwfilter link-local": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.definition.Devices.Interfaces[0].FilterRef.Parameters[2].Value = "fe80::1"
|
|
},
|
|
"nwfilter name": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.definition.Devices.Interfaces[0].FilterRef.Filter = "virt-forged"
|
|
},
|
|
"seed IPv4": func(value *createLikeNetworkEvidenceFixture) {
|
|
public := value.record.ExpectedState.PublicNetwork
|
|
public.IPv4.AddressCIDR = "8.8.8.11/24"
|
|
value.seed = buildCreateLikeNetworkSeed(
|
|
t, value.record.ResourceID, public,
|
|
vmMACAddress(value.record.ResourceID), nil,
|
|
)
|
|
},
|
|
"seed IPv6": func(value *createLikeNetworkEvidenceFixture) {
|
|
public := value.record.ExpectedState.PublicNetwork
|
|
public.IPv6.AddressCIDR = "2404:c140:156:3a::1001/64"
|
|
value.seed = buildCreateLikeNetworkSeed(
|
|
t, value.record.ResourceID, public,
|
|
vmMACAddress(value.record.ResourceID), nil,
|
|
)
|
|
},
|
|
"seed IPv4 gateway": func(value *createLikeNetworkEvidenceFixture) {
|
|
public := value.record.ExpectedState.PublicNetwork
|
|
public.IPv4.Gateway = "8.8.8.2"
|
|
value.seed = buildCreateLikeNetworkSeed(
|
|
t, value.record.ResourceID, public,
|
|
vmMACAddress(value.record.ResourceID), nil,
|
|
)
|
|
},
|
|
"seed IPv6 gateway": func(value *createLikeNetworkEvidenceFixture) {
|
|
public := value.record.ExpectedState.PublicNetwork
|
|
public.IPv6.Gateway = "2404:c140:156::2"
|
|
value.seed = buildCreateLikeNetworkSeed(
|
|
t, value.record.ResourceID, public,
|
|
vmMACAddress(value.record.ResourceID), nil,
|
|
)
|
|
},
|
|
"seed DNS": func(value *createLikeNetworkEvidenceFixture) {
|
|
public := value.record.ExpectedState.PublicNetwork
|
|
public.DNSServers = []string{"9.9.9.9", "2620:fe::fe"}
|
|
value.seed = buildCreateLikeNetworkSeed(
|
|
t, value.record.ResourceID, public,
|
|
vmMACAddress(value.record.ResourceID), nil,
|
|
)
|
|
},
|
|
"seed link-local": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.seed = rewriteCreateLikeSeedLinkLocal(t, value.seed, "fe80::1/64")
|
|
},
|
|
}
|
|
for name, mutate := range tests {
|
|
t.Run(name, func(t *testing.T) {
|
|
fixture := newCreateLikeNetworkEvidenceFixture(t, false)
|
|
mutate(&fixture)
|
|
if createLikeNetworkEvidenceMatches(
|
|
fixture.record, fixture.definition, fixture.metadata, fixture.seed,
|
|
) {
|
|
t.Fatal("drifted create-like network evidence was accepted")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCreateLikeNetworkEvidenceRequiresExactOptionalVPCIdentity(t *testing.T) {
|
|
tests := map[string]func(*createLikeNetworkEvidenceFixture){
|
|
"unexpected VPC": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.record.ExpectedState.VPCPresent = false
|
|
clearExpectedCreateLikeVPC(value.record.ExpectedState)
|
|
},
|
|
"missing metadata": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.metadata.VPCPort = nil
|
|
},
|
|
"port key": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.metadata.VPCPort.PortKey = "3123456789abcdef0123456789abcdef"
|
|
},
|
|
"VPC key": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.metadata.VPCPort.VPCKey = "4123456789abcdef0123456789abcdef"
|
|
},
|
|
"host revision": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.metadata.VPCPort.HostRevision++
|
|
},
|
|
"host digest": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.metadata.VPCPort.HostDigest = "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
|
|
},
|
|
"private IP": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.metadata.VPCPort.PrivateIP = "10.60.0.10"
|
|
},
|
|
"CIDR": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.metadata.VPCPort.CIDR = "10.61.0.0/24"
|
|
},
|
|
"gateway": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.metadata.VPCPort.Gateway = "10.60.0.2"
|
|
},
|
|
"MAC": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.metadata.VPCPort.MAC = "02:00:00:00:00:10"
|
|
},
|
|
"bridge": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.metadata.VPCPort.Bridge = "vcffffffffffff"
|
|
},
|
|
"seed private IP": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.seed = rewriteCreateLikeSeedVPC(t, value.seed, func(entry map[string]any) {
|
|
entry["addresses"] = []any{"10.60.0.10/32"}
|
|
})
|
|
},
|
|
"seed VPC MAC": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.seed = rewriteCreateLikeSeedVPC(t, value.seed, func(entry map[string]any) {
|
|
entry["match"] = map[string]any{"macaddress": "02:00:00:00:00:10"}
|
|
})
|
|
},
|
|
"seed VPC CIDR": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.seed = rewriteCreateLikeSeedVPC(t, value.seed, func(entry map[string]any) {
|
|
routes := entry["routes"].([]any)
|
|
routes[0].(map[string]any)["to"] = "10.61.0.0/24"
|
|
})
|
|
},
|
|
"seed VPC gateway": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.seed = rewriteCreateLikeSeedVPC(t, value.seed, func(entry map[string]any) {
|
|
routes := entry["routes"].([]any)
|
|
routes[0].(map[string]any)["via"] = "10.60.0.2"
|
|
})
|
|
},
|
|
"VPC interface source": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.definition.Devices.Interfaces[1].Source.Bridge.Bridge = "vcffffffffffff"
|
|
},
|
|
"VPC anti-spoof parameter": func(value *createLikeNetworkEvidenceFixture) {
|
|
value.definition.Devices.Interfaces[1].FilterRef.Parameters[0].Value = "10.60.0.10"
|
|
},
|
|
}
|
|
for name, mutate := range tests {
|
|
t.Run(name, func(t *testing.T) {
|
|
fixture := newCreateLikeNetworkEvidenceFixture(t, true)
|
|
mutate(&fixture)
|
|
if createLikeNetworkEvidenceMatches(
|
|
fixture.record, fixture.definition, fixture.metadata, fixture.seed,
|
|
) {
|
|
t.Fatal("drifted VPC evidence was accepted")
|
|
}
|
|
})
|
|
}
|
|
|
|
fixture := newCreateLikeNetworkEvidenceFixture(t, false)
|
|
fixture.record.ExpectedState.VPCPresent = true
|
|
port := validVPCPortMetadata()
|
|
fixture.record.ExpectedState.VPCKey = port.VPCKey
|
|
fixture.record.ExpectedState.VPCRevision = port.HostRevision
|
|
fixture.record.ExpectedState.VPCDigest = port.HostDigest
|
|
fixture.record.ExpectedState.VPCPortKey = port.PortKey
|
|
fixture.record.ExpectedState.VPCCIDR = port.CIDR
|
|
fixture.record.ExpectedState.VPCGateway = port.Gateway
|
|
fixture.record.ExpectedState.VPCPrivateIP = port.PrivateIP
|
|
fixture.record.ExpectedState.VPCMAC = port.MAC
|
|
fixture.record.ExpectedState.VPCBridge = port.Bridge
|
|
if createLikeNetworkEvidenceMatches(
|
|
fixture.record, fixture.definition, fixture.metadata, fixture.seed,
|
|
) {
|
|
t.Fatal("missing VPC domain and seed evidence was accepted")
|
|
}
|
|
}
|
|
|
|
func clearExpectedCreateLikeVPC(expected *operation.ExpectedState) {
|
|
expected.VPCKey = ""
|
|
expected.VPCRevision = 0
|
|
expected.VPCDigest = ""
|
|
expected.VPCPortKey = ""
|
|
expected.VPCCIDR = ""
|
|
expected.VPCGateway = ""
|
|
expected.VPCPrivateIP = ""
|
|
expected.VPCMAC = ""
|
|
expected.VPCBridge = ""
|
|
}
|
|
|
|
func rewriteCreateLikeSeedLinkLocal(t *testing.T, seed []byte,
|
|
replacement string) []byte {
|
|
t.Helper()
|
|
return rewriteCreateLikeSeedNetwork(t, seed, func(ethernets map[string]any) {
|
|
entry, ok := ethernets[seedPublicInterfaceKey].(map[string]any)
|
|
if !ok {
|
|
t.Fatal("public seed interface is missing")
|
|
}
|
|
addresses := entry["addresses"].([]any)
|
|
for index, raw := range addresses {
|
|
if value, ok := raw.(string); ok && bytes.HasPrefix([]byte(value), []byte("fe80:")) {
|
|
addresses[index] = replacement
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
func rewriteCreateLikeSeedVPC(t *testing.T, seed []byte,
|
|
mutate func(map[string]any)) []byte {
|
|
t.Helper()
|
|
return rewriteCreateLikeSeedNetwork(t, seed, func(ethernets map[string]any) {
|
|
entry, ok := ethernets[seedVPCInterfaceKey].(map[string]any)
|
|
if !ok {
|
|
t.Fatal("VPC seed interface is missing")
|
|
}
|
|
mutate(entry)
|
|
})
|
|
}
|
|
|
|
func rewriteCreateLikeSeedNetwork(t *testing.T, seed []byte,
|
|
mutate func(map[string]any)) []byte {
|
|
t.Helper()
|
|
files, err := readSeedISO(seed)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var network map[string]any
|
|
if err := json.Unmarshal(bytes.TrimSpace(files.NetworkConfig), &network); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ethernets, err := managedSeedEthernets(network)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
mutate(ethernets)
|
|
files.NetworkConfig, err = marshalJSONLine(network)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
result, err := buildSeedISO(files)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return result
|
|
}
|