312 lines
11 KiB
Go
312 lines
11 KiB
Go
package render
|
|
|
|
import (
|
|
"crypto/sha256"
|
|
"encoding/base64"
|
|
"encoding/hex"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
const withRoles = `name: evpn-2hv
|
|
images:
|
|
deb:
|
|
url: https://example.invalid/deb.qcow2
|
|
sums: https://example.invalid/SHA512SUMS
|
|
segments:
|
|
underlay: { switch: sw1, cidr: 192.168.14.0/24 }
|
|
nodes:
|
|
sw1: { role: switch, image: deb, cpus: 2, memory: 1024, secondary: { underlay: [169.254.0.1/28] }, frr: sw1.conf }
|
|
rr1: { role: rr, image: deb, cpus: 1, memory: 1024, segments: [underlay], secondary: { underlay: [169.254.0.3/28] }, loopback: 10.255.255.1/32, frr: rr1.conf }
|
|
hv1: { role: host, image: deb, cpus: 4, memory: 16384, segments: [underlay], frr: hv1.conf, provision: hv.sh, post_provision: hv-post.sh, files: { agent.yml: two.yml }, services: [agent.service] }
|
|
hv2: { role: host, image: deb, cpus: 4, memory: 16384, segments: [underlay] }
|
|
`
|
|
|
|
var frrConfigs = map[string]string{
|
|
"sw1": "hostname sw1\nrouter bgp 65100\n",
|
|
"rr1": "hostname rr1\nrouter bgp 65000\n",
|
|
"hv1": "hostname hv1\nrouter bgp 64600\n",
|
|
}
|
|
|
|
func roleOptions() Options {
|
|
return Options{
|
|
RunDir: "/srv/lab",
|
|
AuthorizedKeys: []string{labKey},
|
|
FRR: frrConfigs,
|
|
Provision: map[string]string{"hv1": "#!/bin/sh\necho provision\n"},
|
|
PostProvision: map[string]string{"hv1": "#!/bin/sh\necho post\n"},
|
|
}
|
|
}
|
|
|
|
func renderRoles(t *testing.T) map[string]Node {
|
|
t.Helper()
|
|
nodes, err := Render(plan(t, withRoles), roleOptions())
|
|
if err != nil {
|
|
t.Fatalf("Render: %v", err)
|
|
}
|
|
out := map[string]Node{}
|
|
for _, n := range nodes {
|
|
out[n.Name] = n
|
|
}
|
|
return out
|
|
}
|
|
|
|
func runcmd(t *testing.T, n Node) []string {
|
|
t.Helper()
|
|
var out []string
|
|
for _, c := range user(t, n).Runcmd {
|
|
out = append(out, strings.Join(c, " "))
|
|
}
|
|
return out
|
|
}
|
|
|
|
const frrScriptHead = `#!/bin/sh
|
|
set -eu
|
|
export DEBIAN_FRONTEND=noninteractive
|
|
. /etc/os-release
|
|
echo "deb [signed-by=/usr/share/keyrings/frrouting.gpg] https://deb.frrouting.org/frr ${VERSION_CODENAME} frr-stable" > /etc/apt/sources.list.d/frr.list
|
|
n=0
|
|
until apt-get update -qq --error-on=any; do
|
|
n=$((n + 1))
|
|
[ "$n" -lt 30 ] || exit 1
|
|
sleep 10
|
|
done
|
|
apt-get install -y -qq --no-install-recommends frr frr-pythontools
|
|
sed -i 's/^bgpd=no/bgpd=yes/' /etc/frr/daemons
|
|
`
|
|
|
|
func TestRoles_SecondaryAddressFollowsThePrimaryOnTheNode(t *testing.T) {
|
|
doc := network(t, nodeNamed(t, renderRoles(t), "rr1"))
|
|
got := iface(t, doc, "underlay").Addresses
|
|
if !reflect.DeepEqual(got, []string{"192.168.14.2/24", "169.254.0.3/28"}) {
|
|
t.Errorf("rr1 underlay addresses = %v", got)
|
|
}
|
|
}
|
|
|
|
func TestRoles_SwitchCarriesItsSecondaryOnTheBridge(t *testing.T) {
|
|
script := fileAt(t, user(t, nodeNamed(t, renderRoles(t), "sw1")), "/usr/local/sbin/lab-switch").Content
|
|
want := "ip addr replace 192.168.14.1/24 dev br-underlay\nip addr replace 169.254.0.1/28 dev br-underlay\nip link set dev br-underlay up\n"
|
|
if !strings.Contains(script, want) {
|
|
t.Errorf("lab-switch:\n%s\ndoes not contain:\n%s", script, want)
|
|
}
|
|
}
|
|
|
|
func TestRoles_LoopbackOnADummyInterfaceReplayedAtBoot(t *testing.T) {
|
|
rr1 := nodeNamed(t, renderRoles(t), "rr1")
|
|
cfg := user(t, rr1)
|
|
|
|
script := fileAt(t, cfg, "/usr/local/sbin/lab-node")
|
|
want := "#!/bin/sh\nset -eu\nip link add lo1 type dummy 2>/dev/null || true\nip addr replace 10.255.255.1/32 dev lo1\nip link set dev lo1 up\n"
|
|
if script.Content != want || script.Permissions != "0755" {
|
|
t.Errorf("lab-node (%s):\n%s", script.Permissions, script.Content)
|
|
}
|
|
unit := fileAt(t, cfg, "/etc/systemd/system/lab-node.service").Content
|
|
if !strings.Contains(unit, "ExecStart=/usr/local/sbin/lab-node\n") || !strings.Contains(unit, "WantedBy=multi-user.target\n") {
|
|
t.Errorf("lab-node.service:\n%s", unit)
|
|
}
|
|
want = "#!/bin/sh\nset -eu\nsystemctl daemon-reload\nsystemctl enable --now lab-node.service\n/usr/local/sbin/lab-frr\n"
|
|
if got := fileAt(t, cfg, "/usr/local/sbin/lab-provision").Content; got != want {
|
|
t.Errorf("lab-provision:\n%s\nwant:\n%s", got, want)
|
|
}
|
|
}
|
|
|
|
func TestRoles_FRRConfigIsWrittenVerbatimAndPrivately(t *testing.T) {
|
|
for _, name := range []string{"sw1", "rr1", "hv1"} {
|
|
f := fileAt(t, user(t, nodeNamed(t, renderRoles(t), name)), "/etc/lab/frr.conf")
|
|
if f.Content != frrConfigs[name] || f.Permissions != "0640" {
|
|
t.Errorf("%s frr.conf (%s) = %q", name, f.Permissions, f.Content)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRoles_FRRDaemonsDependOnTheRole(t *testing.T) {
|
|
tail := "install -o frr -g frr -m 0640 /etc/lab/frr.conf /etc/frr/frr.conf\nsystemctl restart frr\n"
|
|
bfd := "sed -i 's/^bfdd=no/bfdd=yes/' /etc/frr/daemons\n"
|
|
nodes := renderRoles(t)
|
|
for name, want := range map[string]string{
|
|
"sw1": frrScriptHead + bfd + tail,
|
|
"rr1": frrScriptHead + bfd + tail,
|
|
"hv1": frrScriptHead + tail,
|
|
} {
|
|
f := fileAt(t, user(t, nodeNamed(t, nodes, name)), "/usr/local/sbin/lab-frr")
|
|
if f.Content != want || f.Permissions != "0755" {
|
|
t.Errorf("%s lab-frr (%s):\n%s\nwant:\n%s", name, f.Permissions, f.Content, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRoles_FRRKeyIsThePinnedRepositoryKey(t *testing.T) {
|
|
f := fileAt(t, user(t, nodeNamed(t, renderRoles(t), "hv1")), "/usr/share/keyrings/frrouting.gpg")
|
|
if f.Encoding != "b64" || f.Permissions != "0644" {
|
|
t.Errorf("key file: encoding %q, permissions %q", f.Encoding, f.Permissions)
|
|
}
|
|
key, err := base64.StdEncoding.DecodeString(f.Content)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
sum := sha256.Sum256(key)
|
|
if got := hex.EncodeToString(sum[:]); got != "bf10935b9296e2ce7c5d9855fa29ef30c35810b0fc4b1f53005494a04a33554d" {
|
|
t.Errorf("key sha256 = %s", got)
|
|
}
|
|
}
|
|
|
|
func TestRoles_ProvisioningIsOneScriptThatStopsAtTheFirstFailure(t *testing.T) {
|
|
nodes := renderRoles(t)
|
|
env := "LAB_NODE=hv1 LAB_UPLINK=underlay LAB_FILES=/etc/lab/files "
|
|
files := "mkdir -p /etc/lab/files /run/lab-files\nmount -o ro LABEL=LABFILES /run/lab-files\ncp -R /run/lab-files/. /etc/lab/files/\numount /run/lab-files\n"
|
|
for name, steps := range map[string]string{
|
|
"sw1": "systemctl daemon-reload\nsystemctl enable --now lab-switch.service\n/usr/local/sbin/lab-frr\n",
|
|
"hv1": files + env + "/usr/local/sbin/lab-node-provision\n/usr/local/sbin/lab-frr\n" + env + "/usr/local/sbin/lab-node-post-provision\n",
|
|
} {
|
|
cfg := user(t, nodeNamed(t, nodes, name))
|
|
if !reflect.DeepEqual(cfg.Runcmd, [][]string{{"/usr/local/sbin/lab-provision"}}) {
|
|
t.Errorf("%s runcmd = %q", name, cfg.Runcmd)
|
|
}
|
|
f := fileAt(t, cfg, "/usr/local/sbin/lab-provision")
|
|
if f.Content != "#!/bin/sh\nset -eu\n"+steps || f.Permissions != "0755" {
|
|
t.Errorf("%s lab-provision (%s):\n%s", name, f.Permissions, f.Content)
|
|
}
|
|
}
|
|
if cfg := user(t, nodeNamed(t, nodes, "hv2")); cfg.Runcmd != nil {
|
|
t.Errorf("hv2 has nothing to provision, runcmd = %q", cfg.Runcmd)
|
|
}
|
|
}
|
|
|
|
func TestRoles_FilesTravelOnASecondCDROM(t *testing.T) {
|
|
nodes := renderRoles(t)
|
|
hv1 := nodeNamed(t, nodes, "hv1")
|
|
if !reflect.DeepEqual(hv1.Files, map[string]string{"agent.yml": "two.yml"}) {
|
|
t.Errorf("hv1 files = %v", hv1.Files)
|
|
}
|
|
drive := "file=/srv/lab/hv1/files.iso,media=cdrom,readonly=on"
|
|
if !strings.Contains(strings.Join(hv1.QEMU, " "), "-drive "+drive) {
|
|
t.Errorf("hv1 qemu lacks %s:\n%s", drive, strings.Join(hv1.QEMU, "\n"))
|
|
}
|
|
for _, f := range user(t, hv1).WriteFiles {
|
|
if strings.HasPrefix(f.Path, "/etc/lab/files/") {
|
|
t.Errorf("hv1 user-data carries %s, files belong to the ISO", f.Path)
|
|
}
|
|
}
|
|
for _, name := range []string{"sw1", "rr1", "hv2"} {
|
|
if n := nodeNamed(t, nodes, name); strings.Contains(strings.Join(n.QEMU, " "), "files.iso") || n.Files != nil {
|
|
t.Errorf("%s gets a files ISO", name)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRoles_HostReceivesItsScripts(t *testing.T) {
|
|
cfg := user(t, nodeNamed(t, renderRoles(t), "hv1"))
|
|
for path, want := range map[string]struct {
|
|
content string
|
|
permissions string
|
|
}{
|
|
"/usr/local/sbin/lab-node-provision": {"#!/bin/sh\necho provision\n", "0755"},
|
|
"/usr/local/sbin/lab-node-post-provision": {"#!/bin/sh\necho post\n", "0755"},
|
|
} {
|
|
f := fileAt(t, cfg, path)
|
|
got, err := base64.StdEncoding.DecodeString(f.Content)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if f.Encoding != "b64" || f.Permissions != want.permissions || string(got) != want.content {
|
|
t.Errorf("%s: encoding %q, permissions %q, content %q", path, f.Encoding, f.Permissions, got)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRoles_UplinkIsTheInterfaceCarryingTheDefaultRoute(t *testing.T) {
|
|
p := plan(t, twoSegments)
|
|
hv := nodeNamed(t, renderAll(t, twoSegments), "hv")
|
|
var withDefault []string
|
|
for name, e := range network(t, hv).Ethernets {
|
|
for _, r := range e.Routes {
|
|
if r.To == "0.0.0.0/0" {
|
|
withDefault = append(withDefault, name)
|
|
}
|
|
}
|
|
}
|
|
if !reflect.DeepEqual(withDefault, []string{"red"}) {
|
|
t.Fatalf("default route on %v, want [red]", withDefault)
|
|
}
|
|
for _, n := range p.Nodes {
|
|
if n.Name == "hv" {
|
|
if got := provisionEnv(p, n); got != "LAB_NODE=hv LAB_UPLINK=red LAB_FILES=/etc/lab/files " {
|
|
t.Errorf("provision environment = %q", got)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRoles_NodesWithoutProvisionReceiveNoProvisionFiles(t *testing.T) {
|
|
nodes := renderRoles(t)
|
|
for _, name := range []string{"sw1", "rr1", "hv2"} {
|
|
for _, f := range user(t, nodeNamed(t, nodes, name)).WriteFiles {
|
|
if strings.HasPrefix(f.Path, "/etc/lab/files/") || strings.HasPrefix(f.Path, "/usr/local/sbin/lab-node-") {
|
|
t.Errorf("%s receives %s", name, f.Path)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRoles_FRRDaemons(t *testing.T) {
|
|
p := plan(t, withRoles)
|
|
want := map[string][]string{"sw1": {"bgpd", "bfdd"}, "rr1": {"bgpd", "bfdd"}, "hv1": {"bgpd"}}
|
|
for _, n := range p.Nodes {
|
|
if w, ok := want[n.Name]; ok && !reflect.DeepEqual(frrDaemons(n), w) {
|
|
t.Errorf("%s daemons = %v, want %v", n.Name, frrDaemons(n), w)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRoles_NodeWithoutRoleFieldsGetsNoFRR(t *testing.T) {
|
|
for _, f := range user(t, nodeNamed(t, renderRoles(t), "hv2")).WriteFiles {
|
|
if strings.Contains(f.Path, "frr") {
|
|
t.Errorf("hv2 receives %s", f.Path)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRoles_RefusesAnUnreadFRRConfig(t *testing.T) {
|
|
configs := map[string]string{"sw1": "x", "rr1": "y"}
|
|
_, err := Render(plan(t, withRoles), Options{RunDir: "/srv/lab", AuthorizedKeys: []string{labKey}, FRR: configs})
|
|
if err == nil || err.Error() != "node hv1: frr configuration hv1.conf was not read" {
|
|
t.Errorf("error = %v", err)
|
|
}
|
|
}
|
|
|
|
func TestRoles_SwitchLoopbackIsCreatedByTheSwitchScript(t *testing.T) {
|
|
doc := strings.Replace(withRoles, "secondary: { underlay: [169.254.0.1/28] }, frr: sw1.conf", "secondary: { underlay: [169.254.0.1/28] }, loopback: 10.255.254.1/32, frr: sw1.conf", 1)
|
|
nodes, err := Render(plan(t, doc), roleOptions())
|
|
if err != nil {
|
|
t.Fatalf("Render: %v", err)
|
|
}
|
|
var sw1 Node
|
|
for _, n := range nodes {
|
|
if n.Name == "sw1" {
|
|
sw1 = n
|
|
}
|
|
}
|
|
script := fileAt(t, user(t, sw1), "/usr/local/sbin/lab-switch").Content
|
|
want := "ip link set dev br-underlay up\nip link add lo1 type dummy 2>/dev/null || true\nip addr replace 10.255.254.1/32 dev lo1\nip link set dev lo1 up\nnft -f /etc/lab-switch.nft\n"
|
|
if !strings.HasSuffix(script, want) {
|
|
t.Errorf("lab-switch:\n%s\ndoes not end with:\n%s", script, want)
|
|
}
|
|
}
|
|
|
|
func TestRoles_RefusesUnreadProvisionInputs(t *testing.T) {
|
|
cases := map[string]struct {
|
|
mutate func(*Options)
|
|
want string
|
|
}{
|
|
"provision": {func(o *Options) { o.Provision = nil }, "node hv1: provision script hv.sh was not read"},
|
|
"post": {func(o *Options) { o.PostProvision = nil }, "node hv1: post_provision script hv-post.sh was not read"},
|
|
}
|
|
for name, c := range cases {
|
|
o := roleOptions()
|
|
c.mutate(&o)
|
|
if _, err := Render(plan(t, withRoles), o); err == nil || err.Error() != c.want {
|
|
t.Errorf("%s: error = %v, want %q", name, err, c.want)
|
|
}
|
|
}
|
|
}
|