labctl: segments sur des bridges de l'hôte, routeurs et passerelle VRRP #2
All checks were successful
Tests / test (push) Successful in 3m46s
All checks were successful
Tests / test (push) Successful in 3m46s
Signed-off-by: GnomeZworc <nicolas.boufidjeline@g3e.fr>
This commit is contained in:
parent
e0de56a64f
commit
e9a0c19b72
24 changed files with 1766 additions and 578 deletions
|
|
@ -107,7 +107,10 @@ func (l Lab) Up(ctx context.Context, fetcher provision.Fetcher, timeout time.Dur
|
|||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for _, n := range switchesFirst(l.Plan, nodes) {
|
||||
if err := l.NetworkUp(ctx); err != nil {
|
||||
return err
|
||||
}
|
||||
for _, n := range routersFirst(l.Plan, nodes) {
|
||||
if err := os.Remove(l.pidFile(n.Name)); err != nil && !errors.Is(err, os.ErrNotExist) {
|
||||
return err
|
||||
}
|
||||
|
|
@ -134,10 +137,10 @@ func (l Lab) Up(ctx context.Context, fetcher provision.Fetcher, timeout time.Dur
|
|||
return errors.Join(errs...)
|
||||
}
|
||||
|
||||
func switchesFirst(p *topology.Plan, nodes []render.Node) []render.Node {
|
||||
func routersFirst(p *topology.Plan, nodes []render.Node) []render.Node {
|
||||
var first, rest []render.Node
|
||||
for i, n := range nodes {
|
||||
if p.Nodes[i].Role == topology.RoleSwitch {
|
||||
if p.Nodes[i].Role == topology.RoleRouter {
|
||||
first = append(first, n)
|
||||
} else {
|
||||
rest = append(rest, n)
|
||||
|
|
@ -167,16 +170,16 @@ func (l Lab) waitReady(ctx context.Context, n topology.NodePlan) error {
|
|||
}
|
||||
}
|
||||
|
||||
func services(n topology.NodePlan) []string {
|
||||
func services(p *topology.Plan, n topology.NodePlan) []string {
|
||||
units := append([]string(nil), n.Services...)
|
||||
if n.FRR != "" {
|
||||
if render.NeedsFRR(p, n) {
|
||||
units = append(units, "frr.service")
|
||||
}
|
||||
return units
|
||||
}
|
||||
|
||||
func (l Lab) checkServices(ctx context.Context, n topology.NodePlan) error {
|
||||
for _, unit := range services(n) {
|
||||
for _, unit := range services(l.Plan, n) {
|
||||
if err := l.Runner.Run(ctx, "ssh", l.sshArgs(n, true, []string{"systemctl", "is-active", "--quiet", unit})...); err != nil {
|
||||
return fmt.Errorf("%s is not active: %w", unit, err)
|
||||
}
|
||||
|
|
@ -235,7 +238,10 @@ func (l Lab) Status(w io.Writer) error {
|
|||
}
|
||||
fmt.Fprintf(tw, "%s\t%s\t%s\t%s\t127.0.0.1:%d\n", n.Name, n.Role, state, shown, n.SSHPort)
|
||||
}
|
||||
return tw.Flush()
|
||||
if err := tw.Flush(); err != nil {
|
||||
return err
|
||||
}
|
||||
return l.networkStatus(w)
|
||||
}
|
||||
|
||||
func (l Lab) Down(ctx context.Context) error {
|
||||
|
|
@ -259,7 +265,10 @@ func (l Lab) Down(ctx context.Context) error {
|
|||
}
|
||||
fmt.Fprintf(l.Out, "%s: stopped\n", n.Name)
|
||||
}
|
||||
return errors.Join(errs...)
|
||||
if len(errs) > 0 {
|
||||
return errors.Join(errs...)
|
||||
}
|
||||
return l.NetworkDown(ctx)
|
||||
}
|
||||
|
||||
func (l Lab) stop(ctx context.Context, name string, pid int) error {
|
||||
|
|
|
|||
|
|
@ -38,6 +38,7 @@ type fakeRunner struct {
|
|||
ssh map[string][]error
|
||||
always map[string]error
|
||||
inactive string
|
||||
links map[string]bool
|
||||
}
|
||||
|
||||
func (f *fakeRunner) Run(_ context.Context, name string, args ...string) error {
|
||||
|
|
@ -54,6 +55,22 @@ func (f *fakeRunner) Run(_ context.Context, name string, args ...string) error {
|
|||
return err
|
||||
}
|
||||
return os.WriteFile(private+".pub", []byte(labKey+"\n"), 0o644)
|
||||
case "ip":
|
||||
if f.links == nil {
|
||||
f.links = map[string]bool{}
|
||||
}
|
||||
switch {
|
||||
case len(args) == 4 && args[0] == "link" && args[1] == "show":
|
||||
if !f.links[args[3]] {
|
||||
return exitErr(1)
|
||||
}
|
||||
case args[0] == "link" && args[1] == "add" && args[2] == "name":
|
||||
f.links[args[3]] = true
|
||||
case args[0] == "tuntap" && args[1] == "add":
|
||||
f.links[args[3]] = true
|
||||
case args[0] == "link" && args[1] == "delete":
|
||||
delete(f.links, args[3])
|
||||
}
|
||||
case "ssh":
|
||||
port := args[indexOf(args, "-p")+1]
|
||||
if args[len(args)-1] == f.inactive {
|
||||
|
|
@ -81,6 +98,25 @@ func (f *fakeRunner) commands(name string) [][]string {
|
|||
return out
|
||||
}
|
||||
|
||||
func (f *fakeRunner) ipCalls() []string {
|
||||
var out []string
|
||||
for _, c := range f.commands("ip") {
|
||||
out = append(out, strings.Join(c[1:], " "))
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func (f *fakeRunner) present(links ...string) {
|
||||
f.mu.Lock()
|
||||
defer f.mu.Unlock()
|
||||
if f.links == nil {
|
||||
f.links = map[string]bool{}
|
||||
}
|
||||
for _, l := range links {
|
||||
f.links[l] = true
|
||||
}
|
||||
}
|
||||
|
||||
func indexOf(list []string, value string) int {
|
||||
for i, v := range list {
|
||||
if v == value {
|
||||
|
|
@ -105,7 +141,10 @@ func mirror(t *testing.T) (*httptest.Server, string) {
|
|||
return server, server.URL
|
||||
}
|
||||
|
||||
func labPlan(t *testing.T, base, nodes string) *topology.Plan {
|
||||
const underlay = ` underlay: { routers: [sw1], cidr: 10.250.0.0/24, mtu: 9000 }
|
||||
`
|
||||
|
||||
func labPlan(t *testing.T, base, segments, nodes string) *topology.Plan {
|
||||
t.Helper()
|
||||
doc := `name: evpn-2hv
|
||||
images:
|
||||
|
|
@ -113,8 +152,7 @@ images:
|
|||
url: ` + base + `/deb.qcow2
|
||||
sums: ` + base + `/SHA512SUMS
|
||||
segments:
|
||||
underlay: { switch: sw1, cidr: 10.250.0.0/24, mtu: 9000 }
|
||||
nodes:
|
||||
` + segments + `nodes:
|
||||
` + nodes
|
||||
topo, err := topology.Parse([]byte(doc))
|
||||
if err != nil {
|
||||
|
|
@ -127,9 +165,18 @@ nodes:
|
|||
return p
|
||||
}
|
||||
|
||||
const switchLast = ` rr1: { role: rr, image: deb, cpus: 1, memory: 1024, segments: [underlay] }
|
||||
const routerLast = ` rr1: { role: rr, image: deb, cpus: 1, memory: 1024, segments: [underlay] }
|
||||
hv1: { role: host, image: deb, cpus: 4, memory: 16384, segments: [underlay], services: [agent.service] }
|
||||
sw1: { role: switch, image: deb, cpus: 2, memory: 1024 }
|
||||
sw1: { role: router, image: deb, cpus: 2, memory: 1024, segments: [underlay] }
|
||||
`
|
||||
|
||||
const twoSegments = ` red: { routers: [r1, r2], cidr: 10.1.0.0/24 }
|
||||
blue: { cidr: 10.2.0.0/24, mtu: 1500 }
|
||||
`
|
||||
|
||||
const twoRouters = ` r1: { role: router, image: deb, cpus: 1, memory: 512, segments: [red] }
|
||||
r2: { role: router, image: deb, cpus: 1, memory: 512, segments: [red] }
|
||||
hv: { role: host, image: deb, cpus: 1, memory: 512, segments: [red, blue] }
|
||||
`
|
||||
|
||||
type fixture struct {
|
||||
|
|
@ -140,6 +187,11 @@ type fixture struct {
|
|||
}
|
||||
|
||||
func newFixture(t *testing.T, nodes string) *fixture {
|
||||
t.Helper()
|
||||
return newLab(t, underlay, nodes)
|
||||
}
|
||||
|
||||
func newLab(t *testing.T, segments, nodes string) *fixture {
|
||||
t.Helper()
|
||||
server, base := mirror(t)
|
||||
root := t.TempDir()
|
||||
|
|
@ -147,7 +199,7 @@ func newFixture(t *testing.T, nodes string) *fixture {
|
|||
out := &bytes.Buffer{}
|
||||
return &fixture{
|
||||
lab: Lab{
|
||||
Plan: labPlan(t, base, nodes),
|
||||
Plan: labPlan(t, base, segments, nodes),
|
||||
RunDir: filepath.Join(root, "run"),
|
||||
ProcDir: filepath.Join(root, "proc"),
|
||||
Runner: runner,
|
||||
|
|
@ -217,7 +269,7 @@ func waitDead(t *testing.T, pid int) {
|
|||
}
|
||||
|
||||
func TestPID_NoPidFileMeansStopped(t *testing.T) {
|
||||
f := newFixture(t, switchLast)
|
||||
f := newFixture(t, routerLast)
|
||||
if pid, err := f.lab.PID("hv1"); pid != 0 || err != nil {
|
||||
t.Errorf("PID = %d, %v", pid, err)
|
||||
}
|
||||
|
|
@ -225,7 +277,7 @@ func TestPID_NoPidFileMeansStopped(t *testing.T) {
|
|||
|
||||
func TestPID_RefusesACorruptedPidFile(t *testing.T) {
|
||||
for _, content := range []string{"", "abc", "0", "-12"} {
|
||||
f := newFixture(t, switchLast)
|
||||
f := newFixture(t, routerLast)
|
||||
f.pidFile(t, "hv1", content)
|
||||
if _, err := f.lab.PID("hv1"); err == nil || !strings.Contains(err.Error(), "not a pid") {
|
||||
t.Errorf("pid file %q: error = %v", content, err)
|
||||
|
|
@ -234,7 +286,7 @@ func TestPID_RefusesACorruptedPidFile(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestPID_RecognisesTheNodeProcess(t *testing.T) {
|
||||
f := newFixture(t, switchLast)
|
||||
f := newFixture(t, routerLast)
|
||||
want := f.process(t, "hv1", "sleep 30", qemu("hv1")...)
|
||||
if pid, err := f.lab.PID("hv1"); pid != want || err != nil {
|
||||
t.Errorf("PID = %d, %v, want %d", pid, err, want)
|
||||
|
|
@ -249,7 +301,7 @@ func TestPID_IgnoresAPidReusedByAnotherProcess(t *testing.T) {
|
|||
}
|
||||
for name, cmdline := range cases {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
f := newFixture(t, switchLast)
|
||||
f := newFixture(t, routerLast)
|
||||
f.process(t, "hv1", "sleep 30", cmdline...)
|
||||
if pid, err := f.lab.PID("hv1"); pid != 0 || err != nil {
|
||||
t.Errorf("PID = %d, %v, want 0", pid, err)
|
||||
|
|
@ -259,7 +311,7 @@ func TestPID_IgnoresAPidReusedByAnotherProcess(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestPID_IgnoresADeadProcess(t *testing.T) {
|
||||
f := newFixture(t, switchLast)
|
||||
f := newFixture(t, routerLast)
|
||||
pid := f.process(t, "hv1", "exit 0", qemu("hv1")...)
|
||||
waitDead(t, pid)
|
||||
if got, err := f.lab.PID("hv1"); got != 0 || err != nil {
|
||||
|
|
@ -268,7 +320,7 @@ func TestPID_IgnoresADeadProcess(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestStatus(t *testing.T) {
|
||||
f := newFixture(t, switchLast)
|
||||
f := newFixture(t, routerLast)
|
||||
pid := strconv.Itoa(f.process(t, "hv1", "sleep 30", qemu("hv1")...))
|
||||
var out bytes.Buffer
|
||||
if err := f.lab.Status(&out); err != nil {
|
||||
|
|
@ -281,14 +333,16 @@ func TestStatus(t *testing.T) {
|
|||
want := fmt.Sprintf("node role state %-*s ssh\n", w, "pid") +
|
||||
fmt.Sprintf("rr1 rr stopped %-*s 127.0.0.1:2200\n", w, "-") +
|
||||
fmt.Sprintf("hv1 host running %-*s 127.0.0.1:2201\n", w, pid) +
|
||||
fmt.Sprintf("sw1 switch stopped %-*s 127.0.0.1:2202\n", w, "-")
|
||||
fmt.Sprintf("sw1 router stopped %-*s 127.0.0.1:2202\n", w, "-") +
|
||||
"\nsegment bridge state gateway\n" +
|
||||
"underlay lb-underlay absent 10.250.0.1\n"
|
||||
if out.String() != want {
|
||||
t.Errorf("status:\n%s\nwant:\n%s", out.String(), want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDown_StopsWithSIGTERM(t *testing.T) {
|
||||
f := newFixture(t, switchLast)
|
||||
f := newFixture(t, routerLast)
|
||||
pid := f.process(t, "hv1", "sleep 30", qemu("hv1")...)
|
||||
|
||||
if err := f.lab.Down(context.Background()); err != nil {
|
||||
|
|
@ -305,7 +359,7 @@ func TestDown_StopsWithSIGTERM(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestDown_FallsBackToSIGKILL(t *testing.T) {
|
||||
f := newFixture(t, switchLast)
|
||||
f := newFixture(t, routerLast)
|
||||
f.lab.Stop = 100 * time.Millisecond
|
||||
pid := f.process(t, "hv1", `trap "" TERM; while :; do sleep 0.05; done`, qemu("hv1")...)
|
||||
time.Sleep(50 * time.Millisecond)
|
||||
|
|
@ -322,7 +376,7 @@ func TestDown_FallsBackToSIGKILL(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestDown_NeverSignalsAProcessThatIsNotTheNode(t *testing.T) {
|
||||
f := newFixture(t, switchLast)
|
||||
f := newFixture(t, routerLast)
|
||||
pid := f.process(t, "hv1", "sleep 30", "/usr/sbin/sshd", "-D")
|
||||
|
||||
if err := f.lab.Down(context.Background()); err != nil {
|
||||
|
|
@ -339,7 +393,7 @@ func TestDown_NeverSignalsAProcessThatIsNotTheNode(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestDown_ReportsACorruptedPidFileAndStopsTheOthers(t *testing.T) {
|
||||
f := newFixture(t, switchLast)
|
||||
f := newFixture(t, routerLast)
|
||||
f.pidFile(t, "rr1", "garbage")
|
||||
pid := f.process(t, "hv1", "sleep 30", qemu("hv1")...)
|
||||
|
||||
|
|
@ -352,7 +406,7 @@ func TestDown_ReportsACorruptedPidFileAndStopsTheOthers(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestSSH_Arguments(t *testing.T) {
|
||||
f := newFixture(t, switchLast)
|
||||
f := newFixture(t, routerLast)
|
||||
key := filepath.Join(f.lab.RunDir, "lab_ed25519")
|
||||
base := []string{
|
||||
"-i", key,
|
||||
|
|
@ -388,14 +442,14 @@ func TestSSH_Arguments(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestSSH_UnknownNode(t *testing.T) {
|
||||
f := newFixture(t, switchLast)
|
||||
f := newFixture(t, routerLast)
|
||||
if _, err := f.lab.SSH("hv9", true, nil); err == nil || !strings.Contains(err.Error(), `node "hv9" is not in lab evpn-2hv`) {
|
||||
t.Errorf("error = %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestUp_StartsSwitchesFirstAndWaitsForEveryNode(t *testing.T) {
|
||||
f := newFixture(t, switchLast)
|
||||
func TestUp_StartsRoutersFirstAndWaitsForEveryNode(t *testing.T) {
|
||||
f := newFixture(t, routerLast)
|
||||
|
||||
if err := f.lab.Up(context.Background(), f.fetcher, time.Second); err != nil {
|
||||
t.Fatalf("Up: %v", err)
|
||||
|
|
@ -409,7 +463,7 @@ func TestUp_StartsSwitchesFirstAndWaitsForEveryNode(t *testing.T) {
|
|||
started = append(started, c[indexOf(c, "-name")+1])
|
||||
}
|
||||
if !reflect.DeepEqual(started, []string{"sw1", "rr1", "hv1"}) {
|
||||
t.Errorf("start order = %v, want the switch first", started)
|
||||
t.Errorf("start order = %v, want the router first", started)
|
||||
}
|
||||
|
||||
ssh := f.runner.commands("ssh")
|
||||
|
|
@ -438,7 +492,7 @@ func TestUp_StartsSwitchesFirstAndWaitsForEveryNode(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestUp_RetriesWhileSSHIsUnreachable(t *testing.T) {
|
||||
f := newFixture(t, switchLast)
|
||||
f := newFixture(t, routerLast)
|
||||
f.runner.ssh["2201"] = []error{exitErr(255), exitErr(255), nil}
|
||||
|
||||
if err := f.lab.Up(context.Background(), f.fetcher, time.Second); err != nil {
|
||||
|
|
@ -460,7 +514,7 @@ func TestUp_ReadinessFailures(t *testing.T) {
|
|||
}
|
||||
for name, c := range cases {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
f := newFixture(t, switchLast)
|
||||
f := newFixture(t, routerLast)
|
||||
f.lab.Poll = 10 * time.Millisecond
|
||||
f.runner.ssh["2201"] = c.answers
|
||||
f.runner.always["2201"] = exitErr(255)
|
||||
|
|
@ -478,7 +532,7 @@ func TestUp_ReadinessFailures(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestUp_RecoverableCloudInitErrorsAreReportedNotFatal(t *testing.T) {
|
||||
f := newFixture(t, switchLast)
|
||||
f := newFixture(t, routerLast)
|
||||
f.runner.ssh["2201"] = []error{exitErr(2)}
|
||||
|
||||
if err := f.lab.Up(context.Background(), f.fetcher, time.Second); err != nil {
|
||||
|
|
@ -490,7 +544,7 @@ func TestUp_RecoverableCloudInitErrorsAreReportedNotFatal(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestUp_RefusesARunningLab(t *testing.T) {
|
||||
f := newFixture(t, switchLast)
|
||||
f := newFixture(t, routerLast)
|
||||
f.process(t, "hv1", "sleep 30", qemu("hv1")...)
|
||||
|
||||
err := f.lab.Up(context.Background(), f.fetcher, time.Second)
|
||||
|
|
@ -504,7 +558,7 @@ func TestUp_RefusesARunningLab(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestUp_RemovesAStalePidFileBeforeStarting(t *testing.T) {
|
||||
f := newFixture(t, switchLast)
|
||||
f := newFixture(t, routerLast)
|
||||
pid := f.process(t, "hv1", "exit 0", qemu("hv1")...)
|
||||
waitDead(t, pid)
|
||||
|
||||
|
|
@ -517,7 +571,7 @@ func TestUp_RemovesAStalePidFileBeforeStarting(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestUp_StopsAtTheFirstQEMUFailure(t *testing.T) {
|
||||
f := newFixture(t, switchLast)
|
||||
f := newFixture(t, routerLast)
|
||||
f.runner.fail = "qemu-system-x86_64"
|
||||
|
||||
err := f.lab.Up(context.Background(), f.fetcher, time.Second)
|
||||
|
|
@ -534,7 +588,7 @@ func TestUp_StopsAtTheFirstQEMUFailure(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestStop_RefusesPidsThatTargetAGroup(t *testing.T) {
|
||||
f := newFixture(t, switchLast)
|
||||
f := newFixture(t, routerLast)
|
||||
f.lab.signal = func(pid int, sig syscall.Signal) error {
|
||||
t.Fatalf("signal %v sent to pid %d", sig, pid)
|
||||
return nil
|
||||
|
|
@ -547,7 +601,7 @@ func TestStop_RefusesPidsThatTargetAGroup(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestUp_ChecksTheServicesOfEachRole(t *testing.T) {
|
||||
f := newFixture(t, switchLast)
|
||||
f := newFixture(t, routerLast)
|
||||
conf := filepath.Join(t.TempDir(), "sw1.conf")
|
||||
if err := os.WriteFile(conf, []byte("hostname sw1\n"), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
|
|
@ -574,7 +628,7 @@ func TestUp_ChecksTheServicesOfEachRole(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestUp_ReportsAnInactiveServiceAndWaitsForTheOthers(t *testing.T) {
|
||||
f := newFixture(t, switchLast)
|
||||
f := newFixture(t, routerLast)
|
||||
f.runner.inactive = "agent.service"
|
||||
|
||||
err := f.lab.Up(context.Background(), f.fetcher, time.Second)
|
||||
|
|
@ -586,3 +640,293 @@ func TestUp_ReportsAnInactiveServiceAndWaitsForTheOthers(t *testing.T) {
|
|||
t.Errorf("output = %q", f.out.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestStatus_ShowsTheSegments(t *testing.T) {
|
||||
f := newLab(t, twoSegments, twoRouters)
|
||||
f.runner.present("lb-red")
|
||||
var out bytes.Buffer
|
||||
if err := f.lab.Status(&out); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
want := "\nsegment bridge state gateway\n" +
|
||||
"red lb-red present 10.1.0.1\n" +
|
||||
"blue lb-blue absent -\n"
|
||||
if !strings.HasSuffix(out.String(), want) {
|
||||
t.Errorf("status:\n%s\ndoes not end with:\n%s", out.String(), want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNetworkUp_CreatesBridgesAndTaps(t *testing.T) {
|
||||
f := newLab(t, twoSegments, twoRouters)
|
||||
|
||||
if err := f.lab.NetworkUp(context.Background()); err != nil {
|
||||
t.Fatalf("NetworkUp: %v", err)
|
||||
}
|
||||
|
||||
want := []string{
|
||||
"link show dev lb-red",
|
||||
"link show dev lb-blue",
|
||||
"link show dev lt0",
|
||||
"link show dev lt1",
|
||||
"link show dev lt2",
|
||||
"link show dev lt3",
|
||||
"link add name lb-red type bridge stp_state 0 mcast_snooping 0",
|
||||
"link set dev lb-red addrgenmode none",
|
||||
"tuntap add dev lt0 mode tap",
|
||||
"link set dev lt0 addrgenmode none",
|
||||
"link set dev lt0 mtu 9000 master lb-red up",
|
||||
"tuntap add dev lt1 mode tap",
|
||||
"link set dev lt1 addrgenmode none",
|
||||
"link set dev lt1 mtu 9000 master lb-red up",
|
||||
"tuntap add dev lt2 mode tap",
|
||||
"link set dev lt2 addrgenmode none",
|
||||
"link set dev lt2 mtu 9000 master lb-red up",
|
||||
"link set dev lb-red mtu 9000 up",
|
||||
"link add name lb-blue type bridge stp_state 0 mcast_snooping 0",
|
||||
"link set dev lb-blue addrgenmode none",
|
||||
"tuntap add dev lt3 mode tap",
|
||||
"link set dev lt3 addrgenmode none",
|
||||
"link set dev lt3 mtu 1500 master lb-blue up",
|
||||
"link set dev lb-blue mtu 1500 up",
|
||||
}
|
||||
if got := f.runner.ipCalls(); !reflect.DeepEqual(got, want) {
|
||||
t.Errorf("ip calls:\n%s\nwant:\n%s", strings.Join(got, "\n"), strings.Join(want, "\n"))
|
||||
}
|
||||
if len(f.runner.calls) != len(want) {
|
||||
t.Errorf("other commands ran: %q", f.runner.calls)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNetworkUp_RefusesExistingLinks(t *testing.T) {
|
||||
cases := map[string]struct {
|
||||
link, want string
|
||||
}{
|
||||
"bridge": {"lb-blue", "segment blue: bridge lb-blue already exists on this host: 'labctl down' first, or remove it"},
|
||||
"tap": {"lt2", "node hv: tap lt2 already exists on this host: 'labctl down' first, or remove it"},
|
||||
}
|
||||
for name, c := range cases {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
f := newLab(t, twoSegments, twoRouters)
|
||||
f.runner.present(c.link)
|
||||
dir := filepath.Join(f.lab.ProcDir, "sys", "net", "bridge")
|
||||
if err := os.MkdirAll(dir, 0o755); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.WriteFile(filepath.Join(dir, "bridge-nf-call-iptables"), []byte("1\n"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
err := f.lab.NetworkUp(context.Background())
|
||||
|
||||
if err == nil || err.Error() != c.want {
|
||||
t.Errorf("error = %v, want %q", err, c.want)
|
||||
}
|
||||
for _, call := range f.runner.ipCalls() {
|
||||
if !strings.HasPrefix(call, "link show dev ") {
|
||||
t.Errorf("%q ran after the refusal", call)
|
||||
}
|
||||
}
|
||||
if data, _ := os.ReadFile(filepath.Join(dir, "bridge-nf-call-iptables")); string(data) != "1\n" {
|
||||
t.Errorf("bridge filter changed to %q", data)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestNetworkUp_DisablesTheBridgeFilterWhenPresent(t *testing.T) {
|
||||
f := newLab(t, twoSegments, twoRouters)
|
||||
dir := filepath.Join(f.lab.ProcDir, "sys", "net", "bridge")
|
||||
if err := os.MkdirAll(dir, 0o755); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
path := filepath.Join(dir, "bridge-nf-call-iptables")
|
||||
if err := os.WriteFile(path, []byte("1\n"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
if err := f.lab.NetworkUp(context.Background()); err != nil {
|
||||
t.Fatalf("NetworkUp: %v", err)
|
||||
}
|
||||
if data, err := os.ReadFile(path); err != nil || string(data) != "0\n" {
|
||||
t.Errorf("bridge filter = %q, %v, want 0", data, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNetworkUp_LeavesAnAbsentBridgeFilterAlone(t *testing.T) {
|
||||
f := newLab(t, twoSegments, twoRouters)
|
||||
|
||||
if err := f.lab.NetworkUp(context.Background()); err != nil {
|
||||
t.Fatalf("NetworkUp: %v", err)
|
||||
}
|
||||
if _, err := os.Stat(filepath.Join(f.lab.ProcDir, "sys")); !os.IsNotExist(err) {
|
||||
t.Errorf("bridge filter created under the proc dir: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNetworkUp_ReportsTheFailingSegment(t *testing.T) {
|
||||
f := newLab(t, twoSegments, twoRouters)
|
||||
f.runner.fail = "ip"
|
||||
|
||||
err := f.lab.NetworkUp(context.Background())
|
||||
|
||||
if err == nil || err.Error() != "segment red: ip failed" {
|
||||
t.Errorf("error = %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNetworkDown_DeletesTapsThenBridgesThatExist(t *testing.T) {
|
||||
f := newLab(t, twoSegments, twoRouters)
|
||||
f.runner.present("lb-red", "lb-blue", "lt0", "lt2", "lt3")
|
||||
|
||||
if err := f.lab.NetworkDown(context.Background()); err != nil {
|
||||
t.Fatalf("NetworkDown: %v", err)
|
||||
}
|
||||
|
||||
var deleted []string
|
||||
for _, call := range f.runner.ipCalls() {
|
||||
if link, ok := strings.CutPrefix(call, "link delete dev "); ok {
|
||||
deleted = append(deleted, link)
|
||||
}
|
||||
}
|
||||
if want := []string{"lt0", "lt2", "lt3", "lb-red", "lb-blue"}; !reflect.DeepEqual(deleted, want) {
|
||||
t.Errorf("deleted %v, want %v", deleted, want)
|
||||
}
|
||||
if len(f.runner.links) != 0 {
|
||||
t.Errorf("links left: %v", f.runner.links)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDown_RemovesTheNetworkAfterTheNodes(t *testing.T) {
|
||||
f := newFixture(t, routerLast)
|
||||
f.runner.present("lb-underlay", "lt0", "lt1", "lt2")
|
||||
f.process(t, "hv1", "sleep 30", qemu("hv1")...)
|
||||
|
||||
if err := f.lab.Down(context.Background()); err != nil {
|
||||
t.Fatalf("Down: %v", err)
|
||||
}
|
||||
|
||||
var deleted []string
|
||||
for _, call := range f.runner.ipCalls() {
|
||||
if link, ok := strings.CutPrefix(call, "link delete dev "); ok {
|
||||
deleted = append(deleted, link)
|
||||
}
|
||||
}
|
||||
if want := []string{"lt0", "lt1", "lt2", "lb-underlay"}; !reflect.DeepEqual(deleted, want) {
|
||||
t.Errorf("deleted %v, want %v", deleted, want)
|
||||
}
|
||||
if f.out.String() != "hv1: stopped\n" {
|
||||
t.Errorf("output = %q", f.out.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestDown_KeepsTheNetworkWhenANodeCannotBeStopped(t *testing.T) {
|
||||
f := newFixture(t, routerLast)
|
||||
f.runner.present("lb-underlay", "lt0", "lt1", "lt2")
|
||||
f.pidFile(t, "rr1", "garbage")
|
||||
|
||||
if err := f.lab.Down(context.Background()); err == nil {
|
||||
t.Fatal("Down succeeded")
|
||||
}
|
||||
if calls := f.runner.ipCalls(); len(calls) != 0 {
|
||||
t.Errorf("ip calls after a failed stop: %q", calls)
|
||||
}
|
||||
}
|
||||
|
||||
func TestUp_BuildsTheNetworkBeforeStartingQEMU(t *testing.T) {
|
||||
f := newLab(t, twoSegments, twoRouters)
|
||||
|
||||
if err := f.lab.Up(context.Background(), f.fetcher, time.Second); err != nil {
|
||||
t.Fatalf("Up: %v", err)
|
||||
}
|
||||
|
||||
lastIP, firstQEMU := -1, -1
|
||||
var started []string
|
||||
for i, c := range f.runner.calls {
|
||||
switch c[0] {
|
||||
case "ip":
|
||||
lastIP = i
|
||||
case "qemu-system-x86_64":
|
||||
if firstQEMU < 0 {
|
||||
firstQEMU = i
|
||||
}
|
||||
started = append(started, c[indexOf(c, "-name")+1])
|
||||
}
|
||||
}
|
||||
if lastIP < 0 || firstQEMU < 0 || lastIP > firstQEMU {
|
||||
t.Errorf("last ip call at %d, first qemu start at %d", lastIP, firstQEMU)
|
||||
}
|
||||
if !reflect.DeepEqual(started, []string{"r1", "r2", "hv"}) {
|
||||
t.Errorf("start order = %v", started)
|
||||
}
|
||||
for _, link := range []string{"lb-red", "lb-blue", "lt0", "lt1", "lt2", "lt3"} {
|
||||
if !f.runner.links[link] {
|
||||
t.Errorf("%s was not created", link)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestUp_RefusesAnExistingBridgeBeforeStartingQEMU(t *testing.T) {
|
||||
f := newFixture(t, routerLast)
|
||||
f.runner.present("lb-underlay")
|
||||
|
||||
err := f.lab.Up(context.Background(), f.fetcher, time.Second)
|
||||
|
||||
if err == nil || !strings.Contains(err.Error(), "bridge lb-underlay already exists") {
|
||||
t.Errorf("error = %v", err)
|
||||
}
|
||||
if n := len(f.runner.commands("qemu-system-x86_64")); n != 0 {
|
||||
t.Errorf("%d qemu starts", n)
|
||||
}
|
||||
}
|
||||
|
||||
func TestUp_StopsWhenTheNetworkFails(t *testing.T) {
|
||||
f := newFixture(t, routerLast)
|
||||
f.runner.fail = "ip"
|
||||
|
||||
err := f.lab.Up(context.Background(), f.fetcher, time.Second)
|
||||
|
||||
if err == nil || err.Error() != "segment underlay: ip failed" {
|
||||
t.Errorf("error = %v", err)
|
||||
}
|
||||
if n := len(f.runner.commands("qemu-system-x86_64")); n != 0 {
|
||||
t.Errorf("%d qemu starts", n)
|
||||
}
|
||||
}
|
||||
|
||||
func TestUp_ChecksFRROnVRRPRouters(t *testing.T) {
|
||||
f := newLab(t, twoSegments, twoRouters)
|
||||
|
||||
if err := f.lab.Up(context.Background(), f.fetcher, time.Second); err != nil {
|
||||
t.Fatalf("Up: %v", err)
|
||||
}
|
||||
|
||||
var checks []string
|
||||
for _, c := range f.runner.commands("ssh") {
|
||||
if c[len(c)-4] == "systemctl" {
|
||||
checks = append(checks, c[indexOf(c, "-p")+1]+" "+strings.Join(c[len(c)-4:], " "))
|
||||
}
|
||||
}
|
||||
want := []string{
|
||||
"2200 systemctl is-active --quiet frr.service",
|
||||
"2201 systemctl is-active --quiet frr.service",
|
||||
}
|
||||
if !reflect.DeepEqual(checks, want) {
|
||||
t.Errorf("checks = %q, want %q", checks, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestServices(t *testing.T) {
|
||||
f := newLab(t, twoSegments+underlay, twoRouters+` sw1: { role: router, image: deb, cpus: 1, memory: 512, segments: [underlay], services: [x.service] }
|
||||
`)
|
||||
want := map[string][]string{
|
||||
"r1": {"frr.service"},
|
||||
"r2": {"frr.service"},
|
||||
"hv": nil,
|
||||
"sw1": {"x.service"},
|
||||
}
|
||||
for _, n := range f.lab.Plan.Nodes {
|
||||
if got := services(f.lab.Plan, n); !reflect.DeepEqual(got, want[n.Name]) {
|
||||
t.Errorf("%s services = %q, want %q", n.Name, got, want[n.Name])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
122
internal/machine/network.go
Normal file
122
internal/machine/network.go
Normal file
|
|
@ -0,0 +1,122 @@
|
|||
package machine
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strconv"
|
||||
"text/tabwriter"
|
||||
|
||||
"git.g3e.fr/syonad/labctl/internal/topology"
|
||||
)
|
||||
|
||||
const bridgeFilter = "sys/net/bridge/bridge-nf-call-iptables"
|
||||
|
||||
func (l Lab) exists(ctx context.Context, link string) bool {
|
||||
return l.Runner.Run(ctx, "ip", "link", "show", "dev", link) == nil
|
||||
}
|
||||
|
||||
func (l Lab) NetworkUp(ctx context.Context) error {
|
||||
for _, s := range l.Plan.Segments {
|
||||
if l.exists(ctx, s.Bridge) {
|
||||
return fmt.Errorf("segment %s: bridge %s already exists on this host: 'labctl down' first, or remove it", s.Name, s.Bridge)
|
||||
}
|
||||
}
|
||||
for _, port := range l.Plan.Ports {
|
||||
if l.exists(ctx, port.Tap) {
|
||||
return fmt.Errorf("node %s: tap %s already exists on this host: 'labctl down' first, or remove it", port.Node, port.Tap)
|
||||
}
|
||||
}
|
||||
if err := l.disableBridgeFilter(); err != nil {
|
||||
return err
|
||||
}
|
||||
for _, s := range l.Plan.Segments {
|
||||
if err := l.ip(ctx,
|
||||
[]string{"link", "add", "name", s.Bridge, "type", "bridge", "stp_state", "0", "mcast_snooping", "0"},
|
||||
[]string{"link", "set", "dev", s.Bridge, "addrgenmode", "none"},
|
||||
); err != nil {
|
||||
return fmt.Errorf("segment %s: %w", s.Name, err)
|
||||
}
|
||||
for _, port := range l.Plan.Ports {
|
||||
if port.Segment != s.Name {
|
||||
continue
|
||||
}
|
||||
mtu := strconv.Itoa(port.MTU)
|
||||
if err := l.ip(ctx,
|
||||
[]string{"tuntap", "add", "dev", port.Tap, "mode", "tap"},
|
||||
[]string{"link", "set", "dev", port.Tap, "addrgenmode", "none"},
|
||||
[]string{"link", "set", "dev", port.Tap, "mtu", mtu, "master", s.Bridge, "up"},
|
||||
); err != nil {
|
||||
return fmt.Errorf("node %s: %w", port.Node, err)
|
||||
}
|
||||
}
|
||||
if err := l.ip(ctx, []string{"link", "set", "dev", s.Bridge, "mtu", strconv.Itoa(s.MTU), "up"}); err != nil {
|
||||
return fmt.Errorf("segment %s: %w", s.Name, err)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (l Lab) NetworkDown(ctx context.Context) error {
|
||||
var errs []error
|
||||
for _, port := range l.Plan.Ports {
|
||||
if !l.exists(ctx, port.Tap) {
|
||||
continue
|
||||
}
|
||||
if err := l.ip(ctx, []string{"link", "delete", "dev", port.Tap}); err != nil {
|
||||
errs = append(errs, fmt.Errorf("node %s: %w", port.Node, err))
|
||||
}
|
||||
}
|
||||
for _, s := range l.Plan.Segments {
|
||||
if !l.exists(ctx, s.Bridge) {
|
||||
continue
|
||||
}
|
||||
if err := l.ip(ctx, []string{"link", "delete", "dev", s.Bridge}); err != nil {
|
||||
errs = append(errs, fmt.Errorf("segment %s: %w", s.Name, err))
|
||||
}
|
||||
}
|
||||
return errors.Join(errs...)
|
||||
}
|
||||
|
||||
func (l Lab) ip(ctx context.Context, commands ...[]string) error {
|
||||
for _, args := range commands {
|
||||
if err := l.Runner.Run(ctx, "ip", args...); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (l Lab) disableBridgeFilter() error {
|
||||
path := filepath.Join(l.ProcDir, bridgeFilter)
|
||||
if _, err := os.Stat(path); errors.Is(err, os.ErrNotExist) {
|
||||
return nil
|
||||
}
|
||||
if err := os.WriteFile(path, []byte("0\n"), 0o644); err != nil {
|
||||
return fmt.Errorf("%s: %w", path, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (l Lab) networkStatus(w io.Writer) error {
|
||||
tw := tabwriter.NewWriter(w, 0, 0, 2, ' ', 0)
|
||||
fmt.Fprintf(tw, "\nsegment\tbridge\tstate\tgateway\n")
|
||||
for _, s := range l.Plan.Segments {
|
||||
state := "absent"
|
||||
if l.exists(context.Background(), s.Bridge) {
|
||||
state = "present"
|
||||
}
|
||||
fmt.Fprintf(tw, "%s\t%s\t%s\t%s\n", s.Name, s.Bridge, state, gatewayOf(s))
|
||||
}
|
||||
return tw.Flush()
|
||||
}
|
||||
|
||||
func gatewayOf(s topology.SegmentPlan) string {
|
||||
if !s.Gateway.IsValid() {
|
||||
return "-"
|
||||
}
|
||||
return s.Gateway.String()
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue