feat(agent): report VPC transport capabilities
parent
54dcecd516
commit
6c2ab95f27
@ -0,0 +1,20 @@
|
||||
package hypervisor
|
||||
|
||||
const (
|
||||
maxCapabilityNetworkSelectors = 64
|
||||
capabilityMissing = "not_configured"
|
||||
capabilityUnreadable = "not_readable"
|
||||
capabilityInvalid = "invalid_resource"
|
||||
capabilityUnavailable = "unavailable"
|
||||
capabilityInactive = "inactive"
|
||||
capabilityExhausted = "no_available_capacity"
|
||||
capabilityUnsupported = "unsupported"
|
||||
capabilitySelectorMissing = "no_network_selectors"
|
||||
capabilitySelectorUnusable = "network_selector_unavailable"
|
||||
)
|
||||
|
||||
func availableCheck() CapabilityCheck { return CapabilityCheck{Available: true} }
|
||||
|
||||
func unavailableCheck(reason string) CapabilityCheck {
|
||||
return CapabilityCheck{Available: false, Reason: reason}
|
||||
}
|
||||
@ -0,0 +1,123 @@
|
||||
package hypervisor
|
||||
|
||||
import (
|
||||
"net"
|
||||
"net/netip"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"regexp"
|
||||
"sort"
|
||||
"strings"
|
||||
)
|
||||
|
||||
const (
|
||||
vpcL3CapabilityVersion = uint64(1)
|
||||
maxVPCTransportCandidates = 64
|
||||
vpcNoTransportCandidates = "no_private_transport_addresses"
|
||||
vpcIPv4ForwardingDisabled = "ipv4_forwarding_disabled"
|
||||
vpcL3ImplementationDisabled = "vpc_l3_apply_unavailable"
|
||||
)
|
||||
|
||||
var vpcTransportInterfacePattern = regexp.MustCompile(`^[A-Za-z0-9][A-Za-z0-9_.-]{0,14}$`)
|
||||
|
||||
type vpcInterfaceSnapshot struct {
|
||||
Name string
|
||||
Flags net.Flags
|
||||
MTU int
|
||||
Addresses []string
|
||||
Bridge bool
|
||||
}
|
||||
|
||||
func probeVPCL3Capability() (*VPCL3Capability, map[string]CapabilityCheck) {
|
||||
candidates, candidatesCheck := discoverVPCTransportCandidates()
|
||||
forwardingCheck := probeIPv4Forwarding("/proc/sys/net/ipv4/ip_forward")
|
||||
return &VPCL3Capability{
|
||||
Version: vpcL3CapabilityVersion, ApplySupported: false,
|
||||
IPv4Forwarding: forwardingCheck.Available,
|
||||
Candidates: candidates,
|
||||
}, map[string]CapabilityCheck{
|
||||
"vpc_transport_candidates": candidatesCheck,
|
||||
"vpc_ipv4_forwarding": forwardingCheck,
|
||||
"vpc_l3_apply": unavailableCheck(vpcL3ImplementationDisabled),
|
||||
}
|
||||
}
|
||||
|
||||
func discoverVPCTransportCandidates() ([]VPCTransportCandidate, CapabilityCheck) {
|
||||
interfaces, err := net.Interfaces()
|
||||
if err != nil {
|
||||
return []VPCTransportCandidate{}, unavailableCheck(capabilityUnavailable)
|
||||
}
|
||||
snapshots := make([]vpcInterfaceSnapshot, 0, len(interfaces))
|
||||
for _, device := range interfaces {
|
||||
addresses, addressErr := device.Addrs()
|
||||
if addressErr != nil {
|
||||
continue
|
||||
}
|
||||
values := make([]string, 0, len(addresses))
|
||||
for _, address := range addresses {
|
||||
values = append(values, address.String())
|
||||
}
|
||||
info, statErr := os.Stat(filepath.Join("/sys/class/net", device.Name, "bridge"))
|
||||
snapshots = append(snapshots, vpcInterfaceSnapshot{
|
||||
Name: device.Name, Flags: device.Flags, MTU: device.MTU,
|
||||
Addresses: values, Bridge: statErr == nil && info.IsDir(),
|
||||
})
|
||||
}
|
||||
return normalizeVPCTransportCandidates(snapshots)
|
||||
}
|
||||
|
||||
func normalizeVPCTransportCandidates(
|
||||
snapshots []vpcInterfaceSnapshot,
|
||||
) ([]VPCTransportCandidate, CapabilityCheck) {
|
||||
candidates := make([]VPCTransportCandidate, 0)
|
||||
seen := make(map[string]struct{})
|
||||
for _, device := range snapshots {
|
||||
if device.Flags&net.FlagUp == 0 || device.Flags&net.FlagLoopback != 0 ||
|
||||
!vpcTransportInterfacePattern.MatchString(device.Name) ||
|
||||
device.MTU < 576 || device.MTU > 65535 {
|
||||
continue
|
||||
}
|
||||
for _, raw := range device.Addresses {
|
||||
prefix, err := netip.ParsePrefix(strings.TrimSpace(raw))
|
||||
if err != nil || !prefix.Addr().Is4() || !prefix.Addr().IsPrivate() ||
|
||||
prefix.Addr().IsLoopback() || prefix.Addr().IsLinkLocalUnicast() ||
|
||||
prefix.Addr().IsUnspecified() || prefix.Addr().IsMulticast() {
|
||||
continue
|
||||
}
|
||||
key := device.Name + "\x00" + prefix.String()
|
||||
if _, exists := seen[key]; exists {
|
||||
continue
|
||||
}
|
||||
seen[key] = struct{}{}
|
||||
candidates = append(candidates, VPCTransportCandidate{
|
||||
AddressCIDR: prefix.String(), Address: prefix.Addr().String(),
|
||||
Prefix: uint8(prefix.Bits()), Interface: device.Name,
|
||||
MTU: device.MTU, Bridge: device.Bridge,
|
||||
})
|
||||
}
|
||||
}
|
||||
if len(candidates) > maxVPCTransportCandidates {
|
||||
return []VPCTransportCandidate{}, unavailableCheck(capabilityInvalid)
|
||||
}
|
||||
sort.Slice(candidates, func(left, right int) bool {
|
||||
if candidates[left].Interface != candidates[right].Interface {
|
||||
return candidates[left].Interface < candidates[right].Interface
|
||||
}
|
||||
return candidates[left].AddressCIDR < candidates[right].AddressCIDR
|
||||
})
|
||||
if len(candidates) == 0 {
|
||||
return candidates, unavailableCheck(vpcNoTransportCandidates)
|
||||
}
|
||||
return candidates, availableCheck()
|
||||
}
|
||||
|
||||
func probeIPv4Forwarding(path string) CapabilityCheck {
|
||||
raw, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
return unavailableCheck(capabilityUnreadable)
|
||||
}
|
||||
if strings.TrimSpace(string(raw)) != "1" {
|
||||
return unavailableCheck(vpcIPv4ForwardingDisabled)
|
||||
}
|
||||
return availableCheck()
|
||||
}
|
||||
@ -0,0 +1,83 @@
|
||||
package hypervisor
|
||||
|
||||
import (
|
||||
"net"
|
||||
"os"
|
||||
"reflect"
|
||||
"strconv"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestNormalizeVPCTransportCandidates(t *testing.T) {
|
||||
candidates, check := normalizeVPCTransportCandidates([]vpcInterfaceSnapshot{
|
||||
{Name: "lo", Flags: net.FlagUp | net.FlagLoopback, MTU: 65536,
|
||||
Addresses: []string{"127.0.0.1/8"}},
|
||||
{Name: "br-private", Flags: net.FlagUp | net.FlagBroadcast, MTU: 1500,
|
||||
Addresses: []string{
|
||||
"172.16.0.11/24", "172.16.0.11/24", "203.0.113.5/24", "fe80::1/64",
|
||||
}, Bridge: true},
|
||||
{Name: "bond0", Flags: net.FlagUp, MTU: 9000,
|
||||
Addresses: []string{"10.20.30.40/16"}},
|
||||
{Name: "down0", Flags: 0, MTU: 1500,
|
||||
Addresses: []string{"192.168.1.2/24"}},
|
||||
})
|
||||
if !check.Available {
|
||||
t.Fatalf("private candidates rejected: %#v", check)
|
||||
}
|
||||
want := []VPCTransportCandidate{
|
||||
{AddressCIDR: "10.20.30.40/16", Address: "10.20.30.40", Prefix: 16,
|
||||
Interface: "bond0", MTU: 9000, Bridge: false},
|
||||
{AddressCIDR: "172.16.0.11/24", Address: "172.16.0.11", Prefix: 24,
|
||||
Interface: "br-private", MTU: 1500, Bridge: true},
|
||||
}
|
||||
if !reflect.DeepEqual(candidates, want) {
|
||||
t.Fatalf("private candidates = %#v, want %#v", candidates, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestVPCTransportCandidatesFailClosed(t *testing.T) {
|
||||
candidates, check := normalizeVPCTransportCandidates([]vpcInterfaceSnapshot{{
|
||||
Name: "eth0", Flags: net.FlagUp, MTU: 1500,
|
||||
Addresses: []string{"203.0.113.5/24"},
|
||||
}})
|
||||
if check.Available || check.Reason != vpcNoTransportCandidates || len(candidates) != 0 {
|
||||
t.Fatalf("public-only candidate result = %#v, %#v", candidates, check)
|
||||
}
|
||||
|
||||
many := make([]vpcInterfaceSnapshot, 0, maxVPCTransportCandidates+1)
|
||||
for index := 0; index <= maxVPCTransportCandidates; index++ {
|
||||
many = append(many, vpcInterfaceSnapshot{
|
||||
Name: "br0", Flags: net.FlagUp, MTU: 1500,
|
||||
Addresses: []string{privateTestCIDR(index)}, Bridge: true,
|
||||
})
|
||||
}
|
||||
candidates, check = normalizeVPCTransportCandidates(many)
|
||||
if check.Available || check.Reason != capabilityInvalid || len(candidates) != 0 {
|
||||
t.Fatalf("oversized candidate result = %#v, %#v", candidates, check)
|
||||
}
|
||||
}
|
||||
|
||||
func TestProbeIPv4Forwarding(t *testing.T) {
|
||||
path := t.TempDir() + "/ip_forward"
|
||||
if err := os.WriteFile(path, []byte("0\n"), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if check := probeIPv4Forwarding(path); check.Available ||
|
||||
check.Reason != vpcIPv4ForwardingDisabled {
|
||||
t.Fatalf("disabled forwarding check = %#v", check)
|
||||
}
|
||||
if err := os.WriteFile(path, []byte("1\n"), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if check := probeIPv4Forwarding(path); !check.Available || check.Reason != "" {
|
||||
t.Fatalf("enabled forwarding check = %#v", check)
|
||||
}
|
||||
if check := probeIPv4Forwarding(path + "-missing"); check.Available ||
|
||||
check.Reason != capabilityUnreadable {
|
||||
t.Fatalf("missing forwarding check = %#v", check)
|
||||
}
|
||||
}
|
||||
|
||||
func privateTestCIDR(index int) string {
|
||||
return "10.0." + strconv.Itoa(index) + ".1/24"
|
||||
}
|
||||
Loading…
Reference in New Issue