package topology import ( "bytes" "fmt" "net/netip" "reflect" "strings" "testing" ) func compute(t *testing.T, doc string) *Plan { t.Helper() p, err := Compute(parse(t, doc)) if err != nil { t.Fatalf("Compute: %v", err) } return p } func computeError(t *testing.T, doc string) string { t.Helper() _, err := Compute(parse(t, doc)) if err == nil { t.Fatalf("Compute accepted:\n%s", doc) } return err.Error() } func portOf(t *testing.T, p *Plan, node, segment string) Port { t.Helper() for _, port := range p.Ports { if port.Node == node && port.Segment == segment { return port } } t.Fatalf("no port for %s on %s", node, segment) return Port{} } func segmentOf(t *testing.T, p *Plan, name string) SegmentPlan { t.Helper() for _, s := range p.Segments { if s.Name == name { return s } } t.Fatalf("no segment %s", name) return SegmentPlan{} } func nodeOf(t *testing.T, p *Plan, name string) NodePlan { t.Helper() for _, n := range p.Nodes { if n.Name == name { return n } } t.Fatalf("no node %s", name) return NodePlan{} } const twoHypervisors = header + ` segments: underlay: { routers: [sw1], cidr: 10.250.0.0/24, mtu: 9000 } nodes: sw1: { role: router, image: deb, cpus: 2, memory: 1024, segments: [underlay] } rr1: { role: rr, image: deb, cpus: 1, memory: 1024, segments: [underlay] } hv1: { role: host, image: deb, cpus: 4, memory: 16384, segments: [underlay] } hv2: { role: host, image: deb, cpus: 4, memory: 16384, segments: [underlay] } ` func TestCompute_TwoHypervisorsPlan(t *testing.T) { p := compute(t, twoHypervisors) if len(p.Segments) != 1 { t.Fatalf("%d segments, want 1", len(p.Segments)) } s := p.Segments[0] if s.Bridge != "lb-underlay" || s.Gateway != netip.MustParseAddr("10.250.0.1") || s.MTU != 9000 || !reflect.DeepEqual(s.Routers, []string{"sw1"}) || s.VRID != 0 { t.Errorf("segment = %+v", s) } want := []struct { node, address, mac, tap string }{ {"sw1", "10.250.0.2/24", "02:4c:00:00:00:00", "lt0"}, {"rr1", "10.250.0.3/24", "02:4c:00:01:00:00", "lt1"}, {"hv1", "10.250.0.4/24", "02:4c:00:02:00:00", "lt2"}, {"hv2", "10.250.0.5/24", "02:4c:00:03:00:00", "lt3"}, } if len(p.Ports) != len(want) { t.Fatalf("%d ports, want %d", len(p.Ports), len(want)) } for _, w := range want { port := portOf(t, p, w.node, "underlay") if port.Address.String() != w.address { t.Errorf("%s address = %s, want %s", w.node, port.Address, w.address) } if port.MAC.String() != w.mac { t.Errorf("%s mac = %s, want %s", w.node, port.MAC, w.mac) } if port.Tap != w.tap { t.Errorf("%s tap = %s, want %s", w.node, port.Tap, w.tap) } if port.Interface != "underlay" || port.MTU != 9000 { t.Errorf("%s port = %+v", w.node, port) } } for name, port := range map[string]int{"sw1": 2200, "rr1": 2201, "hv1": 2202, "hv2": 2203} { if got := nodeOf(t, p, name).SSHPort; got != port { t.Errorf("%s ssh port = %d, want %d", name, got, port) } } if hv := nodeOf(t, p, "hv1"); hv.Role != "host" || hv.CPUs != 4 || hv.Memory != 16384 || hv.Image != "deb" { t.Errorf("hv1 = %+v", hv) } } func TestCompute_CarriesTheDeclaredImages(t *testing.T) { p := compute(t, twoHypervisors) want := []Image{{Name: "deb", URL: "https://example.invalid/deb.qcow2", Sums: "https://example.invalid/SHA512SUMS"}} if !reflect.DeepEqual(p.Images, want) { t.Errorf("images = %+v, want %+v", p.Images, want) } } func TestCompute_IsStableAcrossRuns(t *testing.T) { first := compute(t, twoHypervisors) for i := 0; i < 20; i++ { if again := compute(t, twoHypervisors); !reflect.DeepEqual(first, again) { t.Fatalf("plan differs on run %d", i) } } } func TestCompute_AddressesFollowDeclarationOrderNotNames(t *testing.T) { p := compute(t, header+` segments: under: { routers: [sw], cidr: 10.0.0.0/24 } nodes: zeta: { role: rr, image: deb, cpus: 1, memory: 512, segments: [under] } sw: { role: router, image: deb, cpus: 1, memory: 512, segments: [under] } alfa: { role: rr, image: deb, cpus: 1, memory: 512, segments: [under] } `) for node, want := range map[string]string{"zeta": "10.0.0.2/24", "sw": "10.0.0.3/24", "alfa": "10.0.0.4/24"} { if got := portOf(t, p, node, "under").Address.String(); got != want { t.Errorf("%s = %s, want %s", node, got, want) } } } func TestCompute_ExplicitAddressIsKeptAndSkippedByAllocation(t *testing.T) { p := compute(t, header+` segments: under: { routers: [sw], cidr: 10.0.0.0/24 } nodes: sw: { role: router, image: deb, cpus: 1, memory: 512, segments: [under], addresses: {under: 10.0.0.254} } a: { role: rr, image: deb, cpus: 1, memory: 512, segments: [under] } b: { role: rr, image: deb, cpus: 1, memory: 512, segments: [under], addresses: {under: 10.0.0.3} } c: { role: rr, image: deb, cpus: 1, memory: 512, segments: [under] } `) for node, want := range map[string]string{"sw": "10.0.0.254/24", "a": "10.0.0.2/24", "b": "10.0.0.3/24", "c": "10.0.0.4/24"} { if got := portOf(t, p, node, "under").Address.String(); got != want { t.Errorf("%s = %s, want %s", node, got, want) } } } func TestCompute_SegmentWithoutRouterHasNoGateway(t *testing.T) { p := compute(t, header+` segments: l2: { cidr: 10.3.0.0/24 } nodes: a: { role: host, image: deb, cpus: 1, memory: 512, segments: [l2] } b: { role: host, image: deb, cpus: 1, memory: 512, segments: [l2] } `) s := segmentOf(t, p, "l2") if s.Gateway.IsValid() || s.VRID != 0 || len(s.Routers) != 0 || s.Bridge != "lb-l2" { t.Errorf("segment = %+v, want no gateway", s) } for node, want := range map[string]string{"a": "10.3.0.1/24", "b": "10.3.0.2/24"} { if got := portOf(t, p, node, "l2").Address.String(); got != want { t.Errorf("%s = %s, want %s", node, got, want) } } } func TestCompute_SegmentWithoutRouterAcceptsTheFirstAddress(t *testing.T) { p := compute(t, header+` segments: l2: { cidr: 10.3.0.0/24 } nodes: a: { role: host, image: deb, cpus: 1, memory: 512, segments: [l2] } b: { role: host, image: deb, cpus: 1, memory: 512, segments: [l2], addresses: {l2: 10.3.0.1} } `) for node, want := range map[string]string{"a": "10.3.0.2/24", "b": "10.3.0.1/24"} { if got := portOf(t, p, node, "l2").Address.String(); got != want { t.Errorf("%s = %s, want %s", node, got, want) } } } func TestCompute_SegmentWithOneRouter(t *testing.T) { p := compute(t, header+` segments: red: { routers: [r1], cidr: 10.1.0.0/24 } nodes: hv: { role: host, image: deb, cpus: 1, memory: 512, segments: [red] } r1: { role: router, image: deb, cpus: 1, memory: 512, segments: [red] } `) s := segmentOf(t, p, "red") if s.Gateway != netip.MustParseAddr("10.1.0.1") || s.VRID != 0 || !reflect.DeepEqual(s.Routers, []string{"r1"}) { t.Errorf("segment = %+v", s) } for node, want := range map[string]string{"hv": "10.1.0.2/24", "r1": "10.1.0.3/24"} { if got := portOf(t, p, node, "red").Address.String(); got != want { t.Errorf("%s = %s, want %s", node, got, want) } } } func TestCompute_SegmentWithTwoRoutersUsesVRRP(t *testing.T) { p := compute(t, header+` segments: red: { routers: [r1], cidr: 10.1.0.0/24 } blue: { routers: [r2, r1], cidr: 10.2.0.0/24 } pure: { cidr: 10.3.0.0/24 } nodes: r1: { role: router, image: deb, cpus: 1, memory: 512, segments: [red, blue] } r2: { role: router, image: deb, cpus: 1, memory: 512, segments: [blue], addresses: {blue: 10.2.0.250} } hv: { role: host, image: deb, cpus: 1, memory: 512, segments: [red, blue, pure] } `) blue := segmentOf(t, p, "blue") if blue.VRID != 2 || blue.Gateway != netip.MustParseAddr("10.2.0.1") || !reflect.DeepEqual(blue.Routers, []string{"r2", "r1"}) { t.Errorf("blue = %+v", blue) } if red := segmentOf(t, p, "red"); red.VRID != 0 { t.Errorf("red vrid = %d, want 0", red.VRID) } if pure := segmentOf(t, p, "pure"); pure.VRID != 0 || pure.Gateway.IsValid() { t.Errorf("pure = %+v", pure) } for node, want := range map[string]string{"r1": "10.2.0.2/24", "r2": "10.2.0.250/24", "hv": "10.2.0.3/24"} { if got := portOf(t, p, node, "blue").Address.String(); got != want { t.Errorf("%s = %s, want %s", node, got, want) } } } func TestCompute_TwoSegmentsPortOrderMacsAndTaps(t *testing.T) { p := compute(t, header+` segments: red: { routers: [sw], cidr: 10.1.0.0/24 } blue: { cidr: 10.2.0.0/24, mtu: 1500 } nodes: sw: { role: router, image: deb, cpus: 1, memory: 512, segments: [red] } hv: { role: host, image: deb, cpus: 1, memory: 512, segments: [blue, red] } rr: { role: rr, image: deb, cpus: 1, memory: 512, segments: [red, blue] } `) got := make([]string, 0, len(p.Ports)) for _, port := range p.Ports { got = append(got, port.Segment+"/"+port.Node+"/"+port.Tap) } if strings.Join(got, ",") != "red/sw/lt0,red/hv/lt1,red/rr/lt2,blue/hv/lt3,blue/rr/lt4" { t.Errorf("port order = %v", got) } blue := portOf(t, p, "hv", "blue") if blue.MAC.String() != "02:4c:00:01:01:00" || blue.Tap != "lt3" || blue.MTU != 1500 || blue.Interface != "blue" || blue.Address.String() != "10.2.0.1/24" { t.Errorf("hv on blue = %+v", blue) } if red := portOf(t, p, "hv", "red"); red.MAC.String() != "02:4c:00:01:00:00" || red.Address.String() != "10.1.0.3/24" { t.Errorf("hv on red = %+v", red) } if rr := portOf(t, p, "rr", "blue"); rr.MAC.String() != "02:4c:00:02:01:00" || rr.Address.String() != "10.2.0.2/24" { t.Errorf("rr on blue = %+v", rr) } } func TestCompute_MacEncodesNodeAndSegmentRanks(t *testing.T) { p := compute(t, generated(3, 300)) if got := portOf(t, p, "n299", "s2").MAC.String(); got != "02:4c:01:2b:02:00" { t.Errorf("n299 on s2 mac = %s, want 02:4c:01:2b:02:00", got) } } func TestCompute_EveryMacTapAndPortIsUnique(t *testing.T) { p := compute(t, header+` segments: a: { routers: [sw], cidr: 10.1.0.0/24 } b: { routers: [sw], cidr: 10.2.0.0/24 } nodes: sw: { role: router, image: deb, cpus: 1, memory: 512, segments: [a, b] } n1: { role: rr, image: deb, cpus: 1, memory: 512, segments: [a, b] } n2: { role: rr, image: deb, cpus: 1, memory: 512, segments: [a, b] } n3: { role: host, image: deb, cpus: 1, memory: 512, segments: [b, a] } `) macs := map[string]bool{} taps := map[string]bool{} ports := map[int]bool{} for _, n := range p.Nodes { if ports[n.SSHPort] { t.Errorf("ssh port %d used twice", n.SSHPort) } ports[n.SSHPort] = true } for _, port := range p.Ports { if macs[port.MAC.String()] { t.Errorf("mac %s used twice", port.MAC) } macs[port.MAC.String()] = true if taps[port.Tap] { t.Errorf("tap %s used twice", port.Tap) } taps[port.Tap] = true } if len(macs) != 8 || len(taps) != 8 { t.Errorf("%d distinct macs and %d distinct taps, want 8", len(macs), len(taps)) } } func TestCompute_MacsAreLocallyAdministeredUnicast(t *testing.T) { for _, port := range compute(t, twoHypervisors).Ports { if m := port.MAC.String(); !strings.HasPrefix(m, "02:") { t.Errorf("mac %s is not locally administered unicast", m) } } } func TestCompute_InterfaceAndTapNamesFitInIFNAMSIZ(t *testing.T) { p := compute(t, generated(23, 1000)) for _, port := range p.Ports { if len(port.Tap) > 15 || len(port.Interface) > 15 { t.Fatalf("port %+v has a name longer than 15", port) } } for _, s := range p.Segments { if len(s.Bridge) > 15 { t.Fatalf("bridge %s is longer than 15", s.Bridge) } } } func TestCompute_AddressRejections(t *testing.T) { base := func(addresses string) string { return header + ` segments: under: { routers: [sw], cidr: 10.0.0.0/29 } nodes: sw: { role: router, image: deb, cpus: 1, memory: 512, segments: [under] } a: { role: rr, image: deb, cpus: 1, memory: 512, segments: [under]` + addresses + ` } b: { role: rr, image: deb, cpus: 1, memory: 512, segments: [under], addresses: {under: 10.0.0.5} } ` } cases := []struct{ name, addresses, want string }{ {"outside", ", addresses: {under: 10.0.1.2}", "node a: address 10.0.1.2 is outside segment under"}, {"network", ", addresses: {under: 10.0.0.0}", "node a: address 10.0.0.0 is the network or broadcast"}, {"broadcast", ", addresses: {under: 10.0.0.7}", "node a: address 10.0.0.7 is the network or broadcast"}, {"gateway", ", addresses: {under: 10.0.0.1}", "node a: address 10.0.0.1 on segment under is already taken by the gateway"}, {"duplicate", ", addresses: {under: 10.0.0.5}", "node b: address 10.0.0.5 on segment under is already taken by a"}, } for _, c := range cases { t.Run(c.name, func(t *testing.T) { requireContains(t, computeError(t, base(c.addresses)), c.want) }) } } func TestCompute_RouterAddressCannotBeTheGateway(t *testing.T) { got := computeError(t, header+` segments: under: { routers: [sw], cidr: 10.0.0.0/24 } nodes: sw: { role: router, image: deb, cpus: 1, memory: 512, segments: [under], addresses: {under: 10.0.0.1} } `) requireContains(t, got, "node sw: address 10.0.0.1 on segment under is already taken by the gateway") } func TestCompute_ReportsExhaustedSegment(t *testing.T) { got := computeError(t, header+` segments: tiny: { routers: [sw], cidr: 10.0.0.0/30 } nodes: sw: { role: router, image: deb, cpus: 1, memory: 512, segments: [tiny] } a: { role: rr, image: deb, cpus: 1, memory: 512, segments: [tiny] } `) requireContains(t, got, "segment tiny: no address left in 10.0.0.0/30 for node a") } func TestCompute_FillsSegmentExactly(t *testing.T) { p := compute(t, header+` segments: tiny: { routers: [sw], cidr: 10.0.0.0/29 } nodes: sw: { role: router, image: deb, cpus: 1, memory: 512, segments: [tiny] } a: { role: rr, image: deb, cpus: 1, memory: 512, segments: [tiny] } b: { role: rr, image: deb, cpus: 1, memory: 512, segments: [tiny] } c: { role: rr, image: deb, cpus: 1, memory: 512, segments: [tiny] } d: { role: rr, image: deb, cpus: 1, memory: 512, segments: [tiny] } `) if got := portOf(t, p, "d", "tiny").Address.String(); got != "10.0.0.6/29" { t.Errorf("last node = %s, want 10.0.0.6/29", got) } } func TestCompute_FillsSegmentWithoutRouterExactly(t *testing.T) { p := compute(t, header+` segments: tiny: { cidr: 10.0.0.0/30 } nodes: a: { role: rr, image: deb, cpus: 1, memory: 512, segments: [tiny] } b: { role: rr, image: deb, cpus: 1, memory: 512, segments: [tiny] } `) if got := portOf(t, p, "b", "tiny").Address.String(); got != "10.0.0.2/30" { t.Errorf("last node = %s, want 10.0.0.2/30", got) } } func TestCompute_RefusesInvalidTopology(t *testing.T) { requireContains(t, computeError(t, strings.Replace(valid, "role: rr", "role: spine", 1)), `role "spine"`) } func TestLastAddr(t *testing.T) { for cidr, want := range map[string]string{ "10.0.0.0/24": "10.0.0.255", "10.0.0.0/30": "10.0.0.3", "10.250.0.0/16": "10.250.255.255", "192.168.4.8/29": "192.168.4.15", } { if got := lastAddr(netip.MustParsePrefix(cidr)).String(); got != want { t.Errorf("lastAddr(%s) = %s, want %s", cidr, got, want) } } } func TestWrite_TwoHypervisorsPlan(t *testing.T) { var buf bytes.Buffer if err := compute(t, twoHypervisors).Write(&buf); err != nil { t.Fatalf("Write: %v", err) } want := `lab lab-test: nodes 4, segments 1, ports 4 nodes name role image cpus memory ssh sw1 router deb 2 1024 MiB 127.0.0.1:2200 rr1 rr deb 1 1024 MiB 127.0.0.1:2201 hv1 host deb 4 16384 MiB 127.0.0.1:2202 hv2 host deb 4 16384 MiB 127.0.0.1:2203 segment underlay: 10.250.0.0/24, mtu 9000, bridge lb-underlay, gateway 10.250.0.1 on sw1 node interface address mac tap sw1 underlay 10.250.0.2/24 02:4c:00:00:00:00 lt0 rr1 underlay 10.250.0.3/24 02:4c:00:01:00:00 lt1 hv1 underlay 10.250.0.4/24 02:4c:00:02:00:00 lt2 hv2 underlay 10.250.0.5/24 02:4c:00:03:00:00 lt3 ` if buf.String() != want { t.Errorf("output:\n%s\nwant:\n%s", buf.String(), want) } } func TestWrite_GatewayLines(t *testing.T) { var buf bytes.Buffer if err := compute(t, header+` segments: red: { routers: [r1], cidr: 10.1.0.0/24 } blue: { routers: [r2, r1], cidr: 10.2.0.0/24, mtu: 1500 } pure: { cidr: 10.3.0.0/24 } nodes: r1: { role: router, image: deb, cpus: 1, memory: 512, segments: [red, blue] } r2: { role: router, image: deb, cpus: 1, memory: 512, segments: [blue] } hv: { role: host, image: deb, cpus: 1, memory: 512, segments: [blue, pure] } `).Write(&buf); err != nil { t.Fatalf("Write: %v", err) } for _, want := range []string{ "lab lab-test: nodes 3, segments 3, ports 5\n", "\nsegment red: 10.1.0.0/24, mtu 9000, bridge lb-red, gateway 10.1.0.1 on r1\n", "\nsegment blue: 10.2.0.0/24, mtu 1500, bridge lb-blue, gateway 10.2.0.1 by vrrp 2 on r2, r1\n", "\nsegment pure: 10.3.0.0/24, mtu 9000, bridge lb-pure, no gateway\n", " hv pure 10.3.0.1/24 02:4c:00:02:02:00 lt4\n", } { if !strings.Contains(buf.String(), want) { t.Errorf("plan:\n%s\ndoes not contain %q", buf.String(), want) } } } func generated(segments, nodes int) string { var b strings.Builder b.WriteString(header + "segments:\n") names := make([]string, segments) for i := range names { names[i] = fmt.Sprintf("s%d", i) fmt.Fprintf(&b, " %s: { routers: [sw], cidr: 10.%d.0.0/16 }\n", names[i], i%250) } fmt.Fprintf(&b, "nodes:\n sw: { role: router, image: deb, cpus: 1, memory: 512, segments: [%s] }\n", strings.Join(names, ", ")) for i := 1; i < nodes; i++ { fmt.Fprintf(&b, " n%d: { role: rr, image: deb, cpus: 1, memory: 512, segments: [%s] }\n", i, strings.Join(names, ", ")) } return b.String() } func withVRRPAt(segments, rank int) string { var b strings.Builder b.WriteString(header + "segments:\n") names := make([]string, segments) for i := range names { names[i] = fmt.Sprintf("s%d", i) routers := "[r1]" if i == rank { routers = "[r1, r2]" } fmt.Fprintf(&b, " %s: { routers: %s, cidr: 10.%d.0.0/16 }\n", names[i], routers, i%250) } fmt.Fprintf(&b, "nodes:\n r1: { role: router, image: deb, cpus: 1, memory: 512, segments: [%s] }\n", strings.Join(names, ", ")) fmt.Fprintf(&b, " r2: { role: router, image: deb, cpus: 1, memory: 512, segments: [%s] }\n", names[rank]) return b.String() } func TestValidate_RejectsTooManyNodes(t *testing.T) { requireContains(t, validationError(t, generated(1, 1001)), "nodes: 1001 declared, at most 1000") } func TestValidate_AcceptsExactlyMaxNodes(t *testing.T) { if err := parse(t, generated(1, 1000)).Validate(); err != nil { t.Fatalf("1000 nodes rejected: %v", err) } } func TestValidate_RejectsTooManySegments(t *testing.T) { requireContains(t, validationError(t, generated(257, 2)), "segments: 257 declared, at most 256") } func TestValidate_RejectsVRRPBeyondTheVRIDRange(t *testing.T) { msg := validationError(t, withVRRPAt(256, 255)) requireContains(t, msg, "segment s255: a segment with several routers must be among the first 255") } func TestCompute_AcceptsVRRPOnTheLastVRID(t *testing.T) { p := compute(t, withVRRPAt(256, 254)) if got := segmentOf(t, p, "s254").VRID; got != 255 { t.Errorf("vrid = %d, want 255", got) } } func TestCompute_ManyPortsNeedNoPortRange(t *testing.T) { p := compute(t, generated(23, 1000)) if len(p.Ports) != 23000 { t.Fatalf("%d ports, want 23000", len(p.Ports)) } if last := p.Ports[len(p.Ports)-1].Tap; last != "lt22999" { t.Errorf("last tap = %s, want lt22999", last) } }