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.
128 lines
4.3 KiB
Go
128 lines
4.3 KiB
Go
//go:build libvirt
|
|
|
|
package hypervisor
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"libvirt.org/go/libvirtxml"
|
|
)
|
|
|
|
func TestVPCPortIdentityAllowsNewerHostProjectionOnDetach(t *testing.T) {
|
|
left := validVPCPortMetadata()
|
|
right := left
|
|
right.HostRevision++
|
|
right.HostDigest = "1123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
|
|
if !sameVPCPortIdentity(left, right) {
|
|
t.Fatal("stable VPC port identity changed only because host projection advanced")
|
|
}
|
|
right.PrivateIP = "10.60.0.10"
|
|
if sameVPCPortIdentity(left, right) {
|
|
t.Fatal("changed VPC port address was accepted as the same identity")
|
|
}
|
|
}
|
|
|
|
func TestVPCPortIdentityConflictIsScopedByVPCAndVM(t *testing.T) {
|
|
port := validVPCPortMetadata()
|
|
definition := &libvirtxml.Domain{
|
|
UUID: "223e4567-e89b-42d3-a456-426614174000",
|
|
Devices: &libvirtxml.DomainDeviceList{Interfaces: []libvirtxml.DomainInterface{{
|
|
MAC: &libvirtxml.DomainInterfaceMAC{Address: "02:00:00:00:00:80"},
|
|
}}},
|
|
}
|
|
existing := domainVPCPortFromPublic(port)
|
|
metadata := &domainMetadataXML{VPCPort: &existing}
|
|
if !vpcPortConflictsWithManagedDomain(
|
|
"123e4567-e89b-42d3-a456-426614174000", port, definition, metadata,
|
|
) {
|
|
t.Fatal("duplicate VPC port was not rejected")
|
|
}
|
|
|
|
different := port
|
|
different.PortKey = "2123456789abcdef0123456789abcdef"
|
|
different.PrivateIP = "10.60.0.10"
|
|
if vpcPortConflictsWithManagedDomain(
|
|
"123e4567-e89b-42d3-a456-426614174000", different, definition, metadata,
|
|
) {
|
|
t.Fatal("different port in the same VPC was rejected")
|
|
}
|
|
different.MAC = definition.Devices.Interfaces[0].MAC.Address
|
|
if !vpcPortConflictsWithManagedDomain(
|
|
"123e4567-e89b-42d3-a456-426614174000", different, definition, metadata,
|
|
) {
|
|
t.Fatal("duplicate MAC was not rejected")
|
|
}
|
|
|
|
differentVPC := different
|
|
differentVPC.MAC = "02:00:00:00:00:81"
|
|
differentVPC.VPCKey = "3123456789abcdef0123456789abcdef"
|
|
differentVPC.PrivateIP = port.PrivateIP
|
|
if vpcPortConflictsWithManagedDomain(
|
|
"123e4567-e89b-42d3-a456-426614174000", differentVPC, definition, metadata,
|
|
) {
|
|
t.Fatal("same RFC1918 address in a different VPC was rejected")
|
|
}
|
|
if vpcPortConflictsWithManagedDomain(definition.UUID, port, definition, metadata) {
|
|
t.Fatal("the target VM conflicted with its own identity")
|
|
}
|
|
}
|
|
|
|
func TestVPCPortRepairUpgradesOnlyAnExactUnfilteredPrivateInterface(t *testing.T) {
|
|
port := validVPCPortMetadata()
|
|
const uuid = "123e4567-e89b-42d3-a456-426614174000"
|
|
public := dualStackPublicNetwork()
|
|
publicFilter, err := newManagedInterfaceFilterRef(
|
|
networkFilterName(uuid), public, vmMACAddress(uuid),
|
|
)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
definition := &libvirtxml.Domain{
|
|
UUID: uuid,
|
|
VCPU: &libvirtxml.DomainVCPU{Value: 2},
|
|
Devices: &libvirtxml.DomainDeviceList{Interfaces: []libvirtxml.DomainInterface{
|
|
{
|
|
MAC: &libvirtxml.DomainInterfaceMAC{Address: vmMACAddress(uuid)},
|
|
Source: &libvirtxml.DomainInterfaceSource{Bridge: &libvirtxml.DomainInterfaceSourceBridge{Bridge: "br0"}},
|
|
Target: &libvirtxml.DomainInterfaceTarget{Dev: publicInterfaceTarget(uuid)},
|
|
FilterRef: publicFilter,
|
|
},
|
|
{
|
|
MAC: &libvirtxml.DomainInterfaceMAC{Address: port.MAC},
|
|
Source: &libvirtxml.DomainInterfaceSource{Bridge: &libvirtxml.DomainInterfaceSourceBridge{Bridge: port.Bridge}},
|
|
},
|
|
}},
|
|
}
|
|
metadata := &domainMetadataXML{PublicNetwork: domainPublicNetworkFromPublic(public)}
|
|
if err := validateRepairableVPCPortDomain(
|
|
definition, metadata, port,
|
|
); err != nil {
|
|
t.Fatalf("exact legacy private interface was not repairable: %v", err)
|
|
}
|
|
if err := repairVPCPortDomain(definition, metadata, port, true); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !managedNetworkLayoutMatches(definition, metadata) ||
|
|
metadata.VPCPort == nil {
|
|
t.Fatalf("repair did not converge the managed VPC layout: %#v", definition.Devices.Interfaces)
|
|
}
|
|
privateIndex, found := managedVPCInterfaceIndex(
|
|
definition, metadata.VPCPort,
|
|
)
|
|
if !found || !managedVPCInterfaceFilterIPMatches(
|
|
&definition.Devices.Interfaces[privateIndex], port.PrivateIP,
|
|
) {
|
|
t.Fatalf("repair did not install the private anti-spoof binding: %#v",
|
|
definition.Devices.Interfaces)
|
|
}
|
|
|
|
metadata.VPCPort = nil
|
|
definition.Devices.Interfaces[privateIndex].FilterRef =
|
|
&libvirtxml.DomainInterfaceFilterRef{Filter: "foreign-filter"}
|
|
if err := validateRepairableVPCPortDomain(
|
|
definition, metadata, port,
|
|
); err == nil {
|
|
t.Fatal("repair adopted a private interface with a foreign filter")
|
|
}
|
|
}
|